Génération d'un labyrinthe parfait !

**Noxalus** · 06/01/2010, 00h32

Bonjour à toutes et à tous !

Je suis en train de créer un jeu dans lequel un labyrinthe parfait et généré. Seulement, je ne stocke pas le labyrinthe de la même façon que ceux que l'on peut trouver sur le net: ceux dont les cases possèdent chacune 4 murs => murs qu'on enlève au fur et à mesure:

Non, mon labyrinthe est en fait représenté sous la forme d'un tableau à 2 dimensions. Chaque case peut être identifiée par ses coordonnées en X et en Y de cette façon là: maze[x, y].
Lors de la génération aléatoire, ces cases prennent donc une valeur, soit 0, ce qui correspond à une case vide, soit 1 => qui représente un mur.
Vous l'aurez compris, c'est un peu le principe du tout ou rien. Pour chaque case on a un mur ou on en a pas.

Or, et c'est là qu'est mon problème, j'ai besoin de générer un labyrinthe parfait, et avec cette représentation, je ne sais pas du tout comment faire

Pour que vous voyez plus précisément ma façon de voir les choses, voici un petit bout de code:

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
 
// Variable aléatoire
Random rand = new Random();
// Taille du labyrinthe
size = new Point(20, 20);
// Création de la structure du labyrinthe
maze = new int[size.X, size.Y];
// On place la sortie
sortie = new Vector2(rand.Next(size.X), rand.Next(size.Y));
// On place les murs
for (int x = 0; x < size.X; x++)
{
    for (int y = 0; y < size.Y; y++)
    {
        maze[x, y] = rand.Next(2);
    }
}

Comme vous pouvez le constater, ce code ne fait que générer un labyrinthe totalement aléatoirement.

Si vous savez comment faire pour générer un labyrinthe parfait à partir de ce code, je suis preneur !

Merci d'avance et bonne soirée !

**bacelar** · 12/01/2010, 02h50

C'est quoi la définition d'un labyrinthe parfait SVP.

Pour moi, une case a de 0 à 4 murs donc ce n'est pas un champs de 1 bits de long (0 ou 1) mais un champs de 4 bits de long.
Comme les murs sont partagés entre des cases adjacentes. Je tirerais au hasard la présence ou non d'un mur à la frontière entre chaque cellule.

**smyley** · 12/01/2010, 08h00

C'est marrant j'ai justement un "mini-jeu" sous la main avec exactement cet algorithme (et un autre) en WPF. Si je te le donne tout de suite tu ne cherchera pas un peux c'est pas aussi drôle

Par contre justement la case elle peux avoir de 0 à 4 murs et je l'avais définie ainsi :

Code c# :

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
    public enum LabiCaseType
    {
        Start, /* point de départ */
        Finish, /* point d'arrivée */
        Wall, /* mur plein */
        Pass /* passage ... il faut vérifier les murs */
    }
 
    [Flags]
    public enum LabiWalls : int
    {
        None = 0,
        Left = 0x1,
        Right = 0x10,
        Top = 0x100,
        Bottom = 0x1000,
        All = Left | Right | Bottom | Top
    }
 
    public class LabiCase
    {
        public LabiCase()
        {
            CaseType = LabiCaseType.Wall;
            Walls = LabiWalls.All;
        }
 
        public virtual LabiCaseType CaseType { get; set; }
        public virtual LabiWalls Walls { get; set; }
 
        public override string ToString()
        {
            return CaseType.ToString() + " : " + Walls.ToString();
        }
    }

ps. Si je me souviens bien, un labyrinthe parfait est un labi avec un unique chemin entre la case de départ et la case d'arrivée (pas 0 chemins, et pas plus d'un chemin).

**Noxalus** · 28/01/2010, 16h51

Woops, j'avais oublié ce sujet...

Merci pour vos réponses ! Par contre, smyley, ton algo ne conviendrait pas pour mon problème, justement parce que les murs ont l'épaisseur d'une case !

Toutefois, j'ai décidé de me creuser la cervelle et en m'inspirant en grande partie du principe qui est montré dans la génération du labyrinthe sur l'image Gif en haut et j'ai réussi à pondre quelque chose qui fonctionne plutôt bien (à part le Stack OverFlow pour des labyrinthes supérieurs à 80x80). Voilà ce que ça donne, si ça peut aider quelqu'un:

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
84
85
 
            /** Génére un layrnithe parfait **/
            public void GenLabyParfait(Point pos_actuelle, Stack<Point> pos_prec)
            {
                // On réinitialise le tableau
                for (int i = 0; i < 4; i++)
                {
                    casespossibles[i] = false;
                }
                // On recherche les cases possibles
                casespossibles = RechercheCasesPossibles(pos_actuelle, casespossibles, pos_prec);
 
                int j = 0;
                for (int i = 0; i < 4; i++)
                {
                    if (casespossibles[i] == false)
                        j++;
                }
                // Si aucune case n'est possible
                if (j == 4)
                {
                    // On regarde qu'on se retrouve pas à la case initiale
                    // (auquel cas la génération du labyrinthe est finie)
                    if (!(pos_actuelle == sortie_position))
                    {
                        // On retourne à la case précédente
                        pos_actuelle = pos_prec.Pop();
                        // Et on rappelle l'algorithme de génération avec la nouvelle position
                        GenLabyParfait(pos_actuelle, pos_prec);
                    }
                }
                // Si au moins un case est possible
                // => on en choisi une au hasard
                else
                {
                    int mur_alea = random.Next(4);
                    while (casespossibles[mur_alea] == false)
                    {
                        mur_alea = random.Next(4);
                    }
 
                    // Haut
                    if (mur_alea == 0)
                    {
                        // On pose un chemin
                        Carte[pos_actuelle.X, pos_actuelle.Y - 1] = 0;
                        // On stocke notre position actuelle
                        pos_prec.Push(pos_actuelle);
                        // On avance sur cette case
                        pos_actuelle = new Point(pos_actuelle.X, pos_actuelle.Y - 1);
                    }
                    // Droite
                    else if (mur_alea == 1)
                    {
                        // On pose un chemin
                        Carte[pos_actuelle.X + 1, pos_actuelle.Y] = 0;
                        // On stocke notre position actuelle
                        pos_prec.Push(pos_actuelle);
                        // On avance sur cette case
                        pos_actuelle = new Point(pos_actuelle.X + 1, pos_actuelle.Y);
                    }
                    // Bas
                    else if (mur_alea == 2)
                    {
                        // On pose un chemin
                        Carte[pos_actuelle.X, pos_actuelle.Y + 1] = 0;
                        // On stocke notre position actuelle
                        pos_prec.Push(pos_actuelle);
                        // On avance sur cette case
                        pos_actuelle = new Point(pos_actuelle.X, pos_actuelle.Y + 1);
                    }
                    // Gauche
                    else if (mur_alea == 3)
                    {
                        // On pose un chemin
                        Carte[pos_actuelle.X - 1, pos_actuelle.Y] = 0;
                        // On stocke notre position actuelle
                        pos_prec.Push(pos_actuelle);
                        // On avance sur cette case
                        pos_actuelle = new Point(pos_actuelle.X - 1, pos_actuelle.Y);
                    }
                    // Et on rapelle l'algorithme
                    GenLabyParfait(pos_actuelle, pos_prec);
                }
            }

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
            /** Recherche les cases qui peuvent être "creusées" autour de la case actuelle **/
            public bool[] RechercheCasesPossibles(Point pos_actuelle, bool[] casespossibles, Stack<Point> pos_prec)
            {
 
                // On vérifie d'abord qu'on est pas sur un bord
                // Bord gauche
                if(pos_actuelle.X == 0)
                {
                    // Coin en haut à gauche
                    if(pos_actuelle.Y == 0)
                    {
                        // Traitement des cases B et D
                        // Droite
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().X != pos_actuelle.X + 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { false, true, true, false }) && Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                        // Bas
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().Y != pos_actuelle.Y + 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { false, true, true, false }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                                casespossibles[2] = true;
                        }
                    }
                    // Coin en bas à gauche
                    else if (pos_actuelle.Y == Size.Y - 1)
                    {
                        // Traitement des cases H et D
                        // Haut
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().Y != pos_actuelle.Y - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { true, true, false, false }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                                casespossibles[0] = true;
                        }
                        // Droite
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().X != pos_actuelle.X + 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, true, false, false }) && Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                    }
                    // Bord milieu gauche
                    else
                    {
                        // Traitement des cases H, B et D
                        // Haut
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().Y != pos_actuelle.Y - 1)
                        {
                            // On vérifie que c'est pas un coin
                            if (pos_actuelle.Y - 1 == 0)
                            {
                                if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { false, true, true, false }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                                    casespossibles[0] = true;
                            }
                            else
                            {
                                if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { true, true, true, false }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                                    casespossibles[0] = true;
                            }
                        }
                        // Droite
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().X != pos_actuelle.X + 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, true, true, false }) && Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                        // Bas
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().Y != pos_actuelle.Y + 1)
                        {
                            // On vérifie que c'est pas un coin
                            if (pos_actuelle.Y + 1 == Size.Y - 1)
                            {
                                if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { true, true, false, false }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                                    casespossibles[2] = true;
                            }
                            else
                            {
                                if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { true, true, true, false }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                                    casespossibles[2] = true;
                            }
                        }
                    }
                }
                // Bord droit
                else if (pos_actuelle.X == Size.X - 1)
                {
                    // Coin en haut à droite
                    if (pos_actuelle.Y == 0)
                    {
                        // Traitement des cases B et G
                        // Bas
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().Y != pos_actuelle.Y + 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { false, false, true, true }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                                casespossibles[2] = true;
                        }
                        // Gauche
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().X != pos_actuelle.X - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { false, false, true, true }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                    }
                    // Coin en bas à droite
                    else if (pos_actuelle.Y == Size.Y - 1)
                    {
                        // Traitement des cases H et G
                        // Haut
                        if (pos_prec.Peek().X != pos_actuelle.Y - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { true, false, false, true }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                                casespossibles[0] = true;
                        }
                        // Gauche
                        if (pos_prec.Peek().X != pos_actuelle.X - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, false, false, true }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                    }
                    // Bord milieu droit
                    else
                    {
                        // Traitement des cases H, B et G
                        // Haut
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().Y != pos_actuelle.Y - 1)
                        {
                            // On vérifie que c'est pas un coin
                            if (pos_actuelle.Y - 1 == 0)
                            {
                                if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { false, false, true, true }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                                    casespossibles[0] = true;
                            }
                            else
                            {
                                if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { true, false, true, true }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                                    casespossibles[0] = true;
                            }
                        }
                        // Bas
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().Y != pos_actuelle.Y + 1)
                        {
                            // On vérifie que c'est pas un coin
                            if (pos_actuelle.Y + 1 == Size.Y - 1)
                            {
                                if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { true, false, false, true }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                                    casespossibles[2] = true;
                            }
                            else
                            {
                                if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { true, false, true, true }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                                    casespossibles[2] = true;
                            }
                        }
                        // Gauche
                        // On regarde uniquement si ce n'était pas notre position précédente
                        if (pos_prec.Peek().X != pos_actuelle.X - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, false, true, true }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                    }               
                }
                // Les coins ont été traités
                // Bord haut
                else if (pos_actuelle.Y == 0)
                {             
                    // Traitement des cases D, G et B
                    // Droite
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().X != pos_actuelle.X + 1)
                    {
                        // On vérifie que c'est pas un coin
                        if (pos_actuelle.X + 1 == Size.X - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { false, false, true, true })&& Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                        else
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { false, true, true, true }) && Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                    }
                    // Bas
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().Y != pos_actuelle.Y + 1)
                    {
                        if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { false, true, true, true }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                            casespossibles[2] = true;
                    }
                    // Gauche
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().X != pos_actuelle.X - 1)
                    {
                        // On vérifie que c'est pas un coin
                        if (pos_actuelle.X - 1 == 0)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { false, true, true, false }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                        else
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { false, true, true, true }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                    }
                }
                // Bord bas
                else if (pos_actuelle.Y == Size.Y - 1)
                {
                    // Traitement des cases D, G et H
                    // Haut
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().Y != pos_actuelle.Y - 1)
                    {
                        if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { true, true, false, true }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                            casespossibles[0] = true;
                    }
                    // Droite
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().X != pos_actuelle.X + 1)
                    {
                        // On vérifie que c'est pas un coin
                        if (pos_actuelle.X + 1 == Size.X - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, false, false, true }) && Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                        else
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, true, false, true }) && Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                    }
                    // Gauche
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().X != pos_actuelle.X - 1)
                    {
                        // On vérifie que c'est pas un coin
                        if (pos_actuelle.X - 1 == 0)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, true, false, false }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                        else
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, true, false, true }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                    }
                }
 
                // Traitement de base sur les 4 cases voisines
                else
                {
                    // Traitement sur les cases H, B, G et D
                    // Haut
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().Y != pos_actuelle.Y - 1)
                    {
                        // On vérifie qu'on ne se trouve pas tout en haut
                        if (pos_actuelle.Y - 1 == 0)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { false, true, true, true }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                                casespossibles[0] = true;
                        }
                        else
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y - 1), pos_actuelle, new bool[] { true, true, true, true }) && Carte[pos_actuelle.X, pos_actuelle.Y - 1] == 1)
                                casespossibles[0] = true;
                        }
                    }
                    // Droite
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().X != pos_actuelle.X + 1)
                    {
                        // On vérifie qu'on ne se trouve pas tout à droite
                        if (pos_actuelle.X + 1 == Size.X - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, false, true, true }) && Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                        else
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X + 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, true, true, true }) && Carte[pos_actuelle.X + 1, pos_actuelle.Y] == 1)
                                casespossibles[1] = true;
                        }
                    }
                    // Bas
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().Y != pos_actuelle.Y + 1)
                    {
                        // On vérifie qu'on ne se trouve pas tout en bas
                        if (pos_actuelle.Y + 1 == Size.Y - 1)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { true, true, false, true }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                                casespossibles[2] = true;
                        }
                        else
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X, pos_actuelle.Y + 1), pos_actuelle, new bool[] { true, true, true, true }) && Carte[pos_actuelle.X, pos_actuelle.Y + 1] == 1)
                                casespossibles[2] = true;
                        }
                    }
                    // Gauche
                    // On regarde uniquement si ce n'était pas notre position précédente
                    if (pos_prec.Peek().X != pos_actuelle.X - 1)
                    {
                        // On vérifie qu'on ne se trouve pas tout à gauche
                        if (pos_actuelle.X - 1 == 0)
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, true, true, false }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                        else
                        {
                            if (EntoureMurs(new Point(pos_actuelle.X - 1, pos_actuelle.Y), pos_actuelle, new bool[] { true, true, true, true }) && Carte[pos_actuelle.X - 1, pos_actuelle.Y] == 1)
                                casespossibles[3] = true;
                        }
                    }
 
                }
 
                return casespossibles;
            }

Code :

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

1
2
3
4
5
6
7
8
9
10
 
            /** Vérifie qu'une case est bien entourée de murs ! **/
            public bool EntoureMurs(Point pos_mur, Point pos_mur_exclu, bool[] murs_possibles)
            {
 
                return ((!murs_possibles[1] || Carte[pos_mur.X + 1, pos_mur.Y] == 1 || pos_mur.X + 1 == pos_mur_exclu.X) &&
                    (!murs_possibles[3] || Carte[pos_mur.X - 1, pos_mur.Y] == 1 || pos_mur.X - 1 == pos_mur_exclu.X) &&
                    (!murs_possibles[2] || Carte[pos_mur.X, pos_mur.Y + 1] == 1 || pos_mur.Y + 1 == pos_mur_exclu.Y) &&
                    (!murs_possibles[0] || Carte[pos_mur.X, pos_mur.Y - 1] == 1 || pos_mur.Y - 1 == pos_mur_exclu.Y));
            }