IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Free Pascal Discussion :

Génération aléatoire de labyrinthe [Free Pascal]


Sujet :

Free Pascal

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Homme Profil pro
    Développeur Web
    Inscrit en
    Mars 2010
    Messages
    15
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : Enseignement

    Informations forums :
    Inscription : Mars 2010
    Messages : 15
    Par défaut Génération aléatoire de labyrinthe
    Bonjour à tous. Je viens à vous car je suis completement perdu dans ma fonction.
    Le principe est très simple, j'ai créé il y a plus d'un an une fonction de génération aléatoire de labyrinthe à laquelle je passais un paramètre unique : mes labyrinthes créés sont donc carrés et elle marche à la perfection.

    Mais cette année, le projet a evolué, je suis passé à Lazarus et je voudrais créer des labyrinthes en X * Y. Je change donc le dim_X ci-dessous en lui ajoutant 1 ou 2, mais impossible de résoudre mon problème, la fonction génère un labyrinthe sans les dernières colonnes rajoutées.

    J'ai tout repris sur papier, fait de multiples essais mais je n'y arrive pas. Si l'un d'entre vous veut se poser sur le problème ça serait vraiment très sympa.

    Merci d'avance,
    Tim


    Le 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
    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
    //Genere le fichier .txt à l'oupout rentré, de dimension voulue.
    procedure generer_lab(outpout:string;dim:integer);
    var lab : t_gen;
    	dim_x,dim_y,dim_Finale:integer;
    	continue,rand,x1,x2,y1,y2,i,j:integer;
    	v1,v2,NbMurs:integer;
    	MH : t_gen;
    	MV : t_gen;
    	rendu : t_gen_final;
    	fichier:text;
    begin
    	dim_x := dim;
    	dim_y := dim;
    	dim_Finale := 2*dim+1;
    	randomize;
    	NbMurs := 0;
    	//Initialisation des tableaux de murs
        For i := 0 To dim_x-1 do
    		For j := 0 To dim_y-1 do
    			lab[i,j] := i * dim_y + j;
     
    	For i := 0 To dim_x-1 do
    		For j := 0 To dim_y-2 do
    			MH[i,j] := 1;
     
    	For i := 0 To dim_x-2 do
    		For j := 0 To dim_y-1 do
    			MV[i,j] := 1;
    	//On va maintenant enlever nos murs 1 par 1
    	While NbMurs <> ((dim_x*dim_y)-1) do
    	Begin
    		continue := 0;
    		rand := random(2)+1;
    		Case rand of
    			1:begin//Murs Horizontaux
    				x1 := random(dim_x);
    				y1 := random(dim_y-1);
    				If (MH[x1,y1] = 1) Then
    					begin
    					continue := 1;
    					x2 := x1;
    					y2 := y1 + 1	;
    				end;
    			end;
    			2:begin//Murs Verticaux
    				x1 := random(dim_x-1);
    				y1 := random(dim_y);
    				If MV[x1,y1] = 1 Then
    					begin
    					continue := 1;
    					x2 := x1+1;
    					y2 := y1;
    				end;
    			end;
    		End;
    		If continue = 1 Then // (= Si un mur a été trouvé)
    		Begin
    			v1:=lab[x1,y1];
    			v2:=lab[x2,y2];
    			If v1 <> v2 Then
    			Begin
    				// On enlève le mur
    				Case rand of
    					1:
    						MH[x1][y1] := 0;
    			        2:
    						MV[x1][y1] := 0;
    				End;
    				// On met la même valeur dans les cases de la chaîne
     
    				NettoieCellules(lab, x2, y2, dim_x, dim_y, v1, v2);
     
    				NbMurs := NbMurs+1;
    			End;
     
    		End;
    	End;
     
    	//Maintenant, on a 2 tableaux avec des murs horizontaux et verticaux, tres facile a utiliser.
    	//On doit cependant les traiter pour pouvoir creer notre tableaux de la forme souhaitée dans le TP.
    	//Et ce ne fut pas une partie de plaisir.
     
    	//On met des trous de partout
    	For i := 1 To dim_Finale do
    		For j := 1 To dim_Finale do
    			rendu[i,j]:=' ';
    	//On met des M sur la premiere et derniere ligne
    	For i := 1 to dim_Finale do
    		rendu[1,i]:= 'M';
    	For i := 1 to dim_Finale do
    		rendu[dim_Finale,i]:= 'M';
    	//On met des M sur la premiere colonne et derniere colonne.
    	For i := 1 to dim_Finale do
    		begin
    		rendu[i,1]:= 'M';
    		rendu[i,dim_Finale]:= 'M';
    		end;
    	// On met les murs la ou ils doivent etre en sachant que la dimension finale va etre multipliée par 2 puis additionée à 1.
    	For i := 0 To dim_x-2 do
    		Begin
    		For j := 0 To dim_y-1 do
    			If (MV[i,j] = 1) Then
    				Begin
    				rendu[2*(i+1)+1,j*2+1]:= 'M';
    				rendu[2*(i+1)+1,j*2+2]:= 'M';
    				rendu[2*(i+1)+1,j*2+3]:= 'M';
    				End;
    		End;
    	For i := 0 To dim_x-1 do
    		Begin
    		For j := 0 To dim_y-2 do
    			If (MH[i,j] = 1) Then
    				Begin
    				rendu[i*2+1,(j+1)*2+1]:= 'M';
    				rendu[i*2+2,(j+1)*2+1]:= 'M';
    				rendu[i*2+3,(j+1)*2+1]:= 'M';
    				End;
    		End;
    	//On met l'entrée et la sortie sur les cotés du labyrinthe ou on est sur qu'il n'y a aucun mur devant.
    	rendu[(random(dim_Finale div 2)+1)*2,1]:='E';
    	rendu[(random(dim_Finale div 2)+1)*2,dim_Finale]:='S';
     
    	//On ecrit le fichier
    	assign (fichier,outpout);
    	rewrite(fichier);
     
    	For i := 1 To dim_Finale do
    		Begin
    		For j := 1 To dim_Finale do
    			Write(fichier,rendu[i,j]);
    		Writeln(fichier,'');
    		End;
    	close(fichier);
    End;

  2. #2
    Membre Expert

    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2009
    Messages
    935
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France, Aveyron (Midi Pyrénées)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2009
    Messages : 935
    Par défaut
    Salut

    Comment fonctionne ton algorithme ? Comment est stocké ton labyrinthe ?
    Normalement, le principe de ton algorithme devrait fonctionner quelque soit la dimension du labyrinthe ... Je n'arrive pas bien a comprendre ta technique. Tu aurais peut être du séparer ta procedure en plusieurs sous procedures ...

    Voici quelques techniques de générations de labyrinthe :
    http://ilay.org/yann/articles/maze/

    Bonne chance

  3. #3
    Membre averti
    Homme Profil pro
    Développeur Web
    Inscrit en
    Mars 2010
    Messages
    15
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : Enseignement

    Informations forums :
    Inscription : Mars 2010
    Messages : 15
    Par défaut
    Bonsoir. Merci de votre réponse tout d'abord. J'avais bien entendu suivi le lien que vous m'avez donné il y a un an et j'avais choisi la méthode "Unicité de chemin et aléa" qui semblait donner de meilleurs resultats pour de grandes matrices.

    J'ai donc fait cette implementation qui est toute la premiere 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
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    dim_x := dim;
    	dim_y := dim;
    	dim_Finale := 2*dim+1;
    	randomize;
    	NbMurs := 0;
    	//Initialisation des tableaux de murs
        For i := 0 To dim_x-1 do
    		For j := 0 To dim_y-1 do
    			lab[i,j] := i * dim_y + j;
     
    	For i := 0 To dim_x-1 do
    		For j := 0 To dim_y-2 do
    			MH[i,j] := 1;
     
    	For i := 0 To dim_x-2 do
    		For j := 0 To dim_y-1 do
    			MV[i,j] := 1;
    	//On va maintenant enlever nos murs 1 par 1
    	While NbMurs <> ((dim_x*dim_y)-1) do
    	Begin
    		continue := 0;
    		rand := random(2)+1;
    		Case rand of
    			1:begin//Murs Horizontaux
    				x1 := random(dim_x);
    				y1 := random(dim_y-1);
    				If (MH[x1,y1] = 1) Then
    					begin
    					continue := 1;
    					x2 := x1;
    					y2 := y1 + 1	;
    				end;
    			end;
    			2:begin//Murs Verticaux
    				x1 := random(dim_x-1);
    				y1 := random(dim_y);
    				If MV[x1,y1] = 1 Then
    					begin
    					continue := 1;
    					x2 := x1+1;
    					y2 := y1;
    				end;
    			end;
    		End;
    		If continue = 1 Then // (= Si un mur a été trouvé)
    		Begin
    			v1:=lab[x1,y1];
    			v2:=lab[x2,y2];
    			If v1 <> v2 Then
    			Begin
    				// On enlève le mur
    				Case rand of
    					1:
    						MH[x1][y1] := 0;
    			        2:
    						MV[x1][y1] := 0;
    				End;
    				// On met la même valeur dans les cases de la chaîne
     
    				NettoieCellules(lab, x2, y2, dim_x, dim_y, v1, v2);
     
    				NbMurs := NbMurs+1;
    			End;
     
    		End;
    	End;
     
    	//Maintenant, on a 2 tableaux avec des murs horizontaux et verticaux, tres facile a utiliser.
    	//On doit cependant les traiter pour pouvoir creer notre tableaux de la forme souhaitée dans le TP.
    	//Et ce ne fut pas une partie de plaisir.

    Et comme le precisent les derniers commentaires, je veux en fait des labyrinthes sous la forme suivante:

    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
    MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
    M M   M   M   M M M   M M   M M         M
    M M M M MMM MMM M M MMM MMM M M MMM M M M
    M   M     M M M       M   M M M M   M M S
    MMMMM MMM M M MMMMM MMMMM M M MMMMMMM M M
    M   M   M           M         M   M   M M
    M M MMMMM M MMM MMMMMMMMM MMMMMMM MMM M M
    M M M   M M M M     M   M     M       M M
    M MMMMM MMM M M MMMMMMM M MMM M M M MMMMM
    M       M     M     M     M   M M M     M
    MMM M MMMMMMM MMM MMM M MMMMMMMMM M MMM M
    M   M   M       M   M M         M M   M M
    MMM MMM M MMMMMMM M M M M M MMM M M MMMMM
    M     M M M     M M   M M M M M M M   M M
    MMMMM MMMMM MMMMMMM MMMMMMMMM M MMMMM M M
    M         M       M       M M M M M M   M
    M MMMMMMMMMMM MMMMMMM M MMM M MMM M M MMM
    M   M       M   M     M               M M
    MMM M M MMM MMM MMM M MMM M M M M M MMM M
    M     M M M   M M   M   M M M M M M     M
    MMMMM MMM M MMM M MMM MMM MMMMM MMMMMMMMM
    M   M M   M   M     M   M M           M M
    M MMM MMM MMM M MMM MMM MMM MMMMM MMM M M
    M       M       M     M M       M M   M M
    MMM MMM MMM M M MMM MMMMMMM M MMM MMMMM M
    M     M   M M M   M   M     M M         M
    M MMMMMMMMMMMMM MMM M MMMMM M MMM M MMM M
    E   M       M   M M M M   M M M M M   M M
    MMMMM MMMMMMMMMMM MMM M MMMMMMM M MMM M M
    M M       M   M   M           M   M M M M
    M MMMMMMM MMM M MMMMMMMMM MMMMMMMMM M M M
    M   M M M M     M       M M       M   M M
    M MMM M M MMMMM MMMMM M M M MMMMMMM MMMMM
    M       M   M M   M   M       M         M
    MMM MMM M M M M MMMMMMM M MMMMM MMMMM MMM
    M M   M   M   M       M M     M   M     M
    M MMMMM MMMMM M MMMMMMMMMMM MMMMM M MMM M
    M M       M M   M M M   M       M M   M M
    M MMMMMMM M MMM M M MMM MMMMM MMM MMMMMMM
    M             M                 M       M
    MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
    D'ou la derniere partie du code, et je pense que c'est elle qui pose problème, car les tests semblent montrer que les tableaux MV et MH [pour murs verticaus/horizontaux] sont bien remplis, mais je n'arrive vraiment pas à trouver ou.

  4. #4
    Membre averti
    Homme Profil pro
    Développeur Web
    Inscrit en
    Mars 2010
    Messages
    15
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : Enseignement

    Informations forums :
    Inscription : Mars 2010
    Messages : 15
    Par défaut
    J'ai finalement résolu mon problème en trifouillant bien. Si quelqu'un a besoin de la solution, qu'il n’hésite pas à me MP.


    Merci pour l'aide apportée, bonne continuation,
    Tim

  5. #5
    Responsable Pascal, Lazarus et Assembleur


    Avatar de Alcatîz
    Homme Profil pro
    Ressources humaines
    Inscrit en
    Mars 2003
    Messages
    8 051
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ressources humaines
    Secteur : Service public

    Informations forums :
    Inscription : Mars 2003
    Messages : 8 051
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par timmalos Voir le message
    Si quelqu'un a besoin de la solution, qu'il n'hesite pas à me MP.
    Ce serait encore mieux de la poster directement sur le forum.
    Règles du forum
    Cours et tutoriels Pascal, Delphi, Lazarus et Assembleur
    Avant de poser une question, consultez les FAQ Pascal, Delphi, Lazarus et Assembleur
    Mes tutoriels et sources Pascal

    Le problème en ce bas monde est que les imbéciles sont sûrs d'eux et fiers comme des coqs de basse cour, alors que les gens intelligents sont emplis de doute. [Bertrand Russell]
    La tolérance atteindra un tel niveau que les personnes intelligentes seront interdites de toute réflexion afin de ne pas offenser les imbéciles. [Fiodor Mikhaïlovitch Dostoïevski]

  6. #6
    Expert éminent
    Avatar de Paul TOTH
    Homme Profil pro
    Freelance
    Inscrit en
    Novembre 2002
    Messages
    8 964
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Freelance
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Novembre 2002
    Messages : 8 964
    Par défaut
    Citation Envoyé par Alcatîz Voir le message
    Ce serait encore mieux de la poster directement sur le forum.
    attends, si tout le monde se mettait à donner des solutions sur ce forum il deviendrait une source d'information formidable pour développeur en herbe...c'est pas le but tout de même ?
    Developpez.com: Mes articles, forum FlashPascal
    Entreprise: Execute SARL
    Le Store Excute Store

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Encore génération aléatoire
    Par sebdu94 dans le forum C
    Réponses: 22
    Dernier message: 21/05/2007, 09h58
  2. Problème de génération aléatoire
    Par sebdu94 dans le forum C
    Réponses: 13
    Dernier message: 19/05/2007, 18h04
  3. [VBA-E] memmory génération aléatoire d'images
    Par jhonnybegood dans le forum Macros et VBA Excel
    Réponses: 4
    Dernier message: 04/03/2007, 21h09
  4. génération aléatoire
    Par acewb00 dans le forum MFC
    Réponses: 1
    Dernier message: 02/12/2005, 09h46
  5. génération aléatoire de couleur claire
    Par jiraiya dans le forum Algorithmes et structures de données
    Réponses: 5
    Dernier message: 25/02/2004, 19h52

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo