Discussion :

[Cornellus1985]

Bonjour,
Je dev un jeu d'othello en Java.

Je cherche a ecrire une fonction, la plus simple possible, permettant de transformer la couleur de pions sur le plan de jeu apres un coup.

Mon plan de jeu est represente par un tableau d'entier a deux dimensions de longueur 10x10, car je definis des bords a -1 sur la gauche, la droite, le haut et le bas du plan de jeu. Cela me permet de savoir plus facilement si on sort du plan de jeu lors d'une recherche de coup jouable par exemple.

Pour parcourir les 8 directions possibles de jeu j'utilise ce tableau :

public final int directions[][] =
{
{0, 1}, {1, 1}, {1, 0}, { 1, -1},
{0, -1}, {-1, -1}, {-1, 0}, {-1, 1}
};

Prealablement j'ai definis une fonction qui permet de savoir si un coup est jouable pour un joueur. Cette fonction se nomme "IsLegalMove" et retourne un boolean.

Le principe que j'utilise pour transformer les pions est le suivant, je recupere l'abscisse et l'ordonnee de la position jouee, j'appelle ma fonction "IsLegalMove" sur ces coordonnees. On recherche grace a notre tableau des directions si un adversaire se trouve dans une case adjacente a notre pion joue.
Si nous en trouvons une, nous continuons dans la direction et si nous trouvons un de nos pions alors, on sauvegarde toutes les coordonnees rencontrees dans un tableau.

Puis on parcours notre tableau de ces positions et on les transforme.

Voila la fonction en Java :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
public int FlipColor(int x, int y, int player)
    {
        int num_flipped = 0;
 
        int positionsToFlip[][] = null;
 
        int next_player = X_CELL;
 
        if (player == X_CELL)
        {
            next_player = O_CELL;
        }
 
        //Si il s'agit d'une position jouable
        if (IsLegalMove(x, y, player))
        {
            int factor = 2;
 
            int tmp_position = -2;
 
            //On commence par chercher le nombre de directions possibles pour faire des transformations
            for (int i = 0 ; i < directions.length ; i++)
            {
                int abs = x + directions[i][0];
 
                int ord = y + directions[i][1];
 
                if (grid[abs][ord] == next_player)
                {
                    Vector xHistory = new Vector();
 
                    Vector yHistory = new Vector();
 
                    while (tmp_position != EMPTY_CELL || tmp_position != SIDE_CELL && tmp_position == next_player)
                    {
                        int tmp_abs = abs * factor;
 
                        int tmp_ord = ord * factor;
 
                        //On memorise la position de l'adversaire
                        xHistory.add(tmp_abs);
 
                        yHistory.add(tmp_ord);
 
                        tmp_position = grid[tmp_abs][tmp_ord];
 
                        //On memorise la position du pion a l'extremite
                        if (tmp_position == player)
                        {
                            xHistory.add(tmp_abs);
 
                            yHistory.add(tmp_ord);
 
                            positionsToFlip = new int[xHistory.size()][2];
 
                            for (int k = 0 ; k < positionsToFlip.length ; k++)
                            {
                                positionsToFlip[k][0] = Integer.valueOf(xHistory.get(k).toString());
 
                                positionsToFlip[k][1] = Integer.valueOf(yHistory.get(k).toString());
                            }
                        }
 
                        factor++;
                    }
                }
            }
 
            for (int i = 0 ; i < positionsToFlip.length ; i++)
            {
                int abs = positionsToFlip[i][0];
 
                int ord = positionsToFlip[i][1];
 
                grid[abs][ord] = player;
 
                num_flipped++;
            }
        }
 
        return num_flipped;
    }

Voila,

Merci de votre aide

[Fifan31]

Je dirai, qu'il te faudrait une méthode qui te retourne la listes des pièces à retournées dans une direction.
Tu appelles cette fonction pour les 8 directions possibles.
Ensuite, tu changes le joueur de toutes les cases retournées par la méthodes

[Cornellus1985]

Tout d'abord, merci pour la reponse.

J'essaye justement de garder en memoire les positions des pions a retourner dans le tableau "positionsToFlip". Ensuite je parcours chaque position et je la transforme.

Mon probleme, se situe dans cette partie de la fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
if (grid[abs][ord] == next_player)
            {
                Vector<Integer> xHistory = new Vector<Integer>();
 
                Vector<Integer> yHistory = new Vector<Integer>();
 
                xHistory.add(abs);
 
                yHistory.add(ord);
 
                for (;;)
                {
                    int tmp_abs = factor * (x + cardinalities[i][0]);
 
                    int tmp_ord = factor * (y + cardinalities[i][1]);
 
                    //On memorise la position de l'adversaire
                    xHistory.add(tmp_abs);
 
                    yHistory.add(tmp_ord);
 
                    tmp_position = grid[tmp_abs][tmp_ord];
 
                    //On memorise la position du pion a l'extremite
                    if (tmp_position == player)
                    {
                        positionsToFlip = new int[xHistory.size()][2];
 
                        for (int k = 0 ; k < positionsToFlip.length ; k++)
                        {
                            positionsToFlip[k][0] = xHistory.get(k);
 
                            positionsToFlip[k][1] = yHistory.get(k);
                        }
                    }
 
                    //if (tmp_position == EMPTY_CELL || tmp_position == SIDE_CELL || tmp_abs < 1 || tmp_abs > 8 || tmp_ord < 1 || tmp_ord > 8)
                    if (tmp_position == EMPTY_CELL || tmp_position == SIDE_CELL)
                    {
                        break;
                    }
 
                    factor++;
                }
            }

Au fait quand on parcours les positions adjacentes et qu'on trouve un pion adversaire la variable "factor" qui est instanciee a 2 retourne une valeur trop grande.

Je m'explique par un exemple :
Je suis les O et l'adversaire joue les X.
Je joue en 3 - 4, en 4 - 4 se trouve un pion adverse, mais pour valider la transformation il faut que le pion adverse en 4 - 4 soit compris entre 3 - 4 et 5 - 4. Or, avec int tmp_abs = factor * (x + cardinalities[i][0]);" la variable tmp_abs prend pour valeur 8, la position indiquee pointe alors vers une case vide, et le programme sort de la boucle for(; sans avoir transfere les positions a transformer dans "positionsToFlip".

Voila, merci d'avance