Bonsoir à toute la communauté,

Je suis une grosse grosse débutante en C# et en programmation (d'ailleurs je n'ai pas utiliser les classes et je me suis rendue compte cette semaine que ce n'était pas bien). Je code un jeu et j'ai un gros souci que je n'arrive pas à résoudre.

Voilà le principe du jeu:
- on joue sur un damier vierge à 2 joueurs (niveau débutant 20*20 cases qui sont des labels dans un panel)
- chaque joueur à un bastion (5*5 cases en haut à gauche pour le gentil et 5*5 cases en bas à droite pour le méchant)
- chaque joueur peut s'approprier une case via un drag&drop lorsque c'est son tour, et ainsi augmenter son territoire

Une des conditions pour gagner c'est d'atteindre le bastion adversaire via un chemin continu (des cases appartenant au gentil par exemple qui sont voisines l'une de l'autre jusqu'au bastion adverse)

Mon raisonnement qui à l'évidence est foireux fut celui-ci:
- A partir du damier je crée une matrice de même dimension (nbCase*nbCase) et je remplie par 2 valeurs : 0 (pour le territoire appartenant au joueur dont c'est le tour et dont je veux vérifier si son dernier drag&drop est gagnant) et 1 (pour le territoire adverse correspondant à des cases interdites ou l'armée du joueur dont c'est le tour ne peut pas passer)
- Je me dit que je doit en quelque sorte scanner toutes ces cases et voir si je peux passer ou pas
--> j'en déduis que c'est un peu le problème de la sortie de labyrinthe et que le bastion du joueur en court est le point de départ et le bastion adverse, celui d'arrivée.

J'ai trouvé un algo de sortie de labyrinthe que j'ai eu du mal a comprendre et puis une fois compris je l'ai recodé version C#.

THE BUG: Dès le premier coup, le joueur gagne. Ma fonction "testTrame" de sortie de labyrinthe me retourne true! Alors que ce n'est pas possible puisque la 1er case on est obligée de la jouer près de son propre bastion.

Voici ou j'appelle les fonctions:
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
 
private void atterissage(object sender, DragEventArgs e)
        {
            //On récupére le numéro de la colonne du joueur actif
            int quelJoueur=joueurActif();
 
            //on va vérifier que la case est mutable
            //si oui, on va remplacer l'image et on va modifier le tag 
 
            Label caseMutee = (Label)sender;
            String temp = (string) caseMutee.Tag;
            //on va vérifier qu'on peut réellemnt atterir 
 
            if (verifMutationCaseGenerique(pn_damier.Controls.IndexOf(caseMutee), tabNonActif2))
            {
                //AVANT LA FINALISATION DU DROP ON FAIT TOUT LES TESTS
                // --- Test de découverte d'un trésor donnant acces au quizz
                if (caseMutee.Tag.Equals("9"))
                {
                    caseTresorDécouverte();
                }
                // --- Test de conversion de la case ennemie
                conversionEnnemi(Convert.ToInt32(temp));
                // --- Test de découverte case joker
                decouverteJoker(temp);
                // --- Test le joueur a t-il atteint l'ennemi et gagné !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! C'EST ICI QUE J'APPELLE LES FONCTIONS TESTTRAME
                int[,] matrice = new int[nbCase,nbCase];
                genererMatrice(matrice);
                Boolean ennemiMort = testTrame(matrice,0,0);
                if (ennemiMort)
                {
                    string gagnant = "RabbitLandia";
                    if (mesJoueurs[quelJoueur, 1] == 16)
                    {
                        gagnant = "Pollutor";
                    }
                    string message = gagnant + " a gagné la partie!";
                    MessageBox.Show(message, "LA PARTIE EST FINIE", MessageBoxButtons.OK, MessageBoxIcon.None);
                }
                //FINALISATION DU DROP
                caseMutee.Image = labelTemp.Image;
                caseMutee.Tag = labelTemp.Tag;
                caseMutee.Text = Convert.ToString(labelTemp.Tag); 
                //une fois que le drop a réussi 
                majNbPizzaDrop(Convert.ToString(caseMutee.Tag));
                //on active les cases 
                activationCase();
                alternerTours2();//alterner tour déclenche la mise à jour du panneau et en cascade le calcul du score
            }
            else
            {
                MessageBox.Show("Interdit", "Recommencez", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            majPanoBastions();
        }
Voici les fonctions en question (testTrame correspondant à la sortie de labyrinthe):
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
 
private void genererMatrice(int [,] matrice)
        {
            //Etape 1 : déclarations et initialisation de la matrice
            int i, j, compteur = 0;
            string temp, OccupSol1 = "1", OccupSol2 = "3", OccupSol3 = "5", depart = "11", arrivee = "13";
 
            //Etape 2 : On test le joueur actif pour déterminer les parcelles où on passe (1) et celles interdites (2)
            int quelJoueur = joueurActif();
            if (mesJoueurs[quelJoueur, 1] == 16) //Pollutor
            {
                OccupSol1 = "2";
                OccupSol2 = "4";
                OccupSol3 = "6";
                depart = "11";
                arrivee = "13";
            }
            //Etape 3 : On parcours le damier pour remplir la matrice
            while (compteur < pn_damier.Controls.Count)
            {
                temp = (string)pn_damier.Controls[compteur].Tag;
                for (i = 0; i < nbCase; i++)
                {
                    for (j = 0; j < nbCase; j++)
                    {
                        if (temp.Equals(OccupSol1) || temp.Equals(OccupSol2) || temp.Equals(OccupSol3) || temp.Equals(arrivee) || temp.Equals(depart))
                        {
                            matrice[i, j] = 0;
                        }
                        else
                        {
                            matrice[i, j] = 1;
                        }
                    }
                }
                compteur++;
            }
        }
        // --- Fonction permettant de tester si le joueur a construit une trame pour détruire le bastion ennemi
        private Boolean testTrame(int [,]tab, int x, int y)
        {
            /*ANALYSE GLOBALE
             *On travaille à partir d'une matrice codée en 0 (je passe) et 1 (je passe pas) pour réduire la complexité
             *On admet que le point de départ est en haut à gauche et le point d'arrivée en bas à droite
             *On a mis à 0 les cases appartenant au territoire du joueur actif
             *1 correspond aux parcelles ennemies ou non découvertes
             *2 aux parcelles qu'on est en train de tester
             *3 aux parcelles qui ne conduisent pas à l'ennemi
            */
            //Etape 1 : on test si on est dans la matrice
            if (x >= nbCase || y >= nbCase || x < 0 || y < 0)
            {
                return false;
            }
            //Etape 2 : On test si le contenu de la matrice n'appartient pas au territoire du joueur (!=0)
            if (tab[x, y] > 0) //Si le contenu de la matrice est différent de 0
            {
                return false;
            }
            //Etape 3 : On test si on est arrivé au bastion ennemie
            if (x == nbCase - 1 && y == nbCase - 1)
            {
                return true;
            }
            //Etape 4 : Si les tests 1,2,3 ne sont pas vérifiés, on est sur le chemin vers l'ennemi
            tab[x, y] = 2;
            //Etape 5 : On va vérifier recursivement les cases autour
            if (testTrame(tab, x + 1, y) || testTrame(tab, x - 1, y) || testTrame(tab, x, y - 1) || testTrame(tab, x, y + 1))
            {
                return true;
            }
            //Sinon, on indique que la parcelle ne conduit pas à l'ennemi
            tab[x, y] = 3;
            return false;
        }
Je suis vraiment bloquée. Et vous remercie d'avance pour les commentaires. Au delà de la note de projet, j'aimerais comprendre ce qui cloche pour progresser.
Merci à tous