génération d'un labyrinthe

salut à tous !

j'ai tenter de concevoir un générateur de labyrinthe.
en suivant les explication de wikipédia

http://fr.wikipedia.org/wiki/Mod%C3%A9lisation_math%C3%A9matique_d%27un_labyrinthe

ce qui parait simple de prime-abord s'avère un casse tête sans nom pour moi!
(on s'en doute !)

je suis pas tout seul visiblement:
http://ilay.org/yann/articles/maze/

mon résultat à base d'aléatoire, mais qui donne des labyrinthes insolubles quelques fois:

Spoiler:

(j'ai bossé quand même !!)
le gmk correspondant:

(bah personne va télécharger c'te d...)
http://host-a.net/u/marty/tablo.gmk

un test à base de tableaux :
http://host-a.net/u/marty/tablo.gmk

donc si onillink ou caly passe par là!
(à vot'bon coeur messieur !)

requête:
je souhaiterais que vous expliquiez les deux modèles d'algo proposés par wiki, en gml svp!

mais également le fonctionnement de ses fichus tableaux car je n'ai pas réussi à faire un simple tableau en 2 dimensions qui range 1,2,3,4,5,6 comme ceci:
le tout comme si vous parliez à un enfant de 12 ans svp,
(même si j'en suis loin )

[code]for (i=0;i<=3;i+=1){
for (j=0;j<=2;j+=1){
tabv[i,j]=i*j

voiloù!

Pour le labirynthe aléatoire je vais essayer de voir si je peut te sortir un générateur fiable mais je te promet rien . J'avais deja essayer sur une ti82 (he oui il y en a qui s'ennuyent en math ). Mais la c'est diférent et a mon avis je pourrai te soritr quelque chose pour ce week end. Mais pour le tableau j'y est pas encore toucher donc désoler

En utilisant ce générateur, les labyrinthes n'ont pas de solution (généralement), ça génère en gros un "intérieur" de labyrinthe avec des murs tout autour. (normalement on part de la 2è case en haut à droite).
Le but si tu veux rajouter une entrée et une sortie, c'est de rajouter un trou à gauche, et un à droite, et ce en dehors de la génération du labyrinthe... (et tu élimines les cases 0 et n où n est la taille du laby, pour pas te retrouver avec des trous dans les coins=

l’intérêt c'est de pouvoir créer des pièces de labyrinthe "connectables" en ouvrant un mur n'importe où.

tout n'est pas perdu :
le code qui range les chiffres de 1 à 9 et plus dans l'ordre !

Code:

a=0
for (i=1;i<=4;i+=1){
for (j=1;j<=4;j+=1){
a+=1
tabv[j,i]=a}}

astuce: ne pas commencer par i,et j par zéro ,ajouter une variable a qui s'incrémente et inverser le i et le j dans l'écriture de la table! (c'est pas simple quand même!)

Voila la premier algorithme


Soit
explorer[i,j] les cases exploré (boolean);
1<=i<=n
1<=j<=n

Soit
porte_horizontal[i,j] , indique si il y a un mur entre les cases [i,j] et [i+1,j]
1<=i<=n-1
1<=j<=m

Soit
porte_vertical[i,j] , indique si il y a un mur entre les cases [i,j] et [i,j+1]
1<=i<=n
1<=j<=m-1

soit
pile_x une pile ( pose une question si tu ne sait pas comment en faire avec GM)
pile_y une pile

Voila le programme

initialiser explore[i,j] à 0 pour toute i,j
initialiser porte_horizontal[i,j] = 1 pour toute i,j
initialiser porte_vertical[i,j]=1 pour toute i,j

soit
x=1 ( ou toute autre valeur entre 1 et n)
y=1 ( ou toute autre valeur entre 1 et m)

explorer[x,y]=1
empiler x dans pile_x
empiler y dans pile_y

tant que pile_x est non vide
faire

regarder parmis les 4 quatres directions autour de la case (x,y) si il y en a une menant à une case non exploré
si il en existe une
-------- en choisir une aléatoirement
-------- soit (xx,yy) la position de la case non exploré choisit
-------- ouvrir la porte adéquate ( qui sépare les cases (x,y) et (xx,yy)
-------- empiler xx dans pile_x
-------- empiler yy dans pile_y
sinon
-------- x=depiler pile_x
-------- y=depiler pile_y
fin de la boucle

-------------------------------------------

Pour avoir une pile, tu peut utiliser un tableau et un entier (qui te dit ou est la sommet de ta pile)
sinon il y a des piles en GML apparament :

ds_stack_create() Crée une nouvelle pile. La fonction retourne un identifiant id de type entier qui sera à utiliser par toutes les autres fonctions pour manipuler la pile créée. Il vous est possible de créer plusieurs piles.
ds_stack_destroy(id) Détruit la pile d'ID id, libérant la mémoire utilisée par cette dernière. Ne pas oublier d'utiliser cette fonction lorsque vous en avez terminé avec l'utilisation de cette pile.

ds_stack_empty(id) Indique si la pile est actuellement vide. Cela revient à tester si sa taille équivaut à 0.
ds_stack_push(id, val) Stocke (push) la valeur donnée val au sommet de la pile d'ID id.
ds_stack_pop(id) Retourne la valeur du sommet de la pile (pop) puis supprime cette valeur de la pile.

C'est en gros les 5 fonctions que tu va utiliser

--------------------------------------------------------------

Sinon

https://cbna.forumactif.com/t10413-script-generateur-de-labyrinthe-parfait?highlight=labyrinthe