Labyrinth

Invité

Je viens de trouver ça sur le web: lien
J'ai pas encore essayé mais ça permet assez facilement de créer son générateur de labyrinthes aléatoire. Dans le bas de la page il y en a un en Flash.

Sujet: Re: Labyrinth Sam 12 Nov 2011 - 3:13

Interessant,

il ne reste plus qu'a faire la même chose en Panoramic avec la 3D en plus.... Very Happy

Sujet: Re: Labyrinth Sam 12 Nov 2011 - 8:09

Cool pour les gens qui veulent s'entrainer à la 3D

Sujet: Re: Labyrinth Sam 12 Nov 2011 - 10:39

super interessant!!!

a noter au passage l'utilisation de structure demandée il y a peu sur ce forum :

On obtient la structure de données :

typedef struct _maze_t {
int m, n;
char *in, *out;
char *array;
} maze_t, *pmaze_t;

jp

Invité

Il y a aussi un téléchargement du code décompilé en C.

Sujet: labyrinthe Dim 13 Nov 2011 - 15:30

BONJOUR à tous les panoramiciens ainsi qu'au créateur de ce langage, que j'ai découvert il y maintenant environ 6 mois!

Je me présente: je suis retraité depuis environ une année, j'ai 54 ans et demi, j'habite à Champigny dans le Val de Marne, et j'ai acquis mon premier ordinateur je crois en mai 1984. Vous savez ces premiers micro comme les zx81, oric, amstrad, thomson mo5, etc...
Le mien c'était un Hector HRX, de marque française, avec le fameux lecteur de cassette sur lequel on enregistrait nos programmes. Je m'en suis servi environ 2ans et demi, et j'en ai toujours eu un bon souvenir. Je me souviens y avoir programmé en forth et en basic.
Les aléas de la vie et de ma profession, m'ont fait me détourner complètement de l'informatique, mais depuis que je suis à la retraite j'y reviens en force, et les choses ont beaucoup évolué en un peu plus d'un quart de siècle dans ce domaine. Bref, tout cela pour dire que ce langage panoramic m'a séduit car simple d'emploi.
Voici un de mes premiers programmes en panoramic que j'ai du faire au mois d'avril il me semble que vous pourrez adapter à vos besoins.
Sortie du programme par la touche ESC ou en arrivant à la porte de sortie du labyrinthe.

Code:: dim d,dtn,h,i,j,k,n,r,s,v,a(33,22),ax(32,21),ay(32,21),c(4),mur(33,22)
label cpos1,cpos2,debut,jeu,lab,termine,trace
label r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11
full_space 0
' VALEURS MAXIMALES de h et v pour voir tout le labyrinthe à l'écran!
' mode écran 800 x 600 --> h=15 ; v=12
' mode écran 1024 x 768 --> h=20 ; v=17
' mode écran 1280 x 800 --> h=15 ; v=12
' mode écran 1600 x 900 --> h=31 ; v=20
debut:
h=31:v=20:n=h*v-1:h=h+1:v=v+1:d=1
for i=1 to h:for j=1 to v:ax(i,j)=(i*50)-85:ay(i,j)=10+(v*40)-(j*40):next j:next i
gosub lab:gosub trace:i=int(h/2):j=2
' TRACÉ DU REPÈRE ET DES PORTES D'ENTRÉE (en bas) ET SORTIE (en haut) EN ROUGE
gosub cpos1:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j),10,ax(i,j)+50,10

jeu:
dtn=scancode
select dtn
case 37: ' gauche
gosub cpos2:if odd(a(i,j))=0 then i=i-1
case 38: ' haut
gosub cpos2:if a(i,j)=1 or a(i,j)=1 or a(i,j)=4 or a(i,j)=5 or a(i,j)=8 or a(i,j)=9 or a(i,j)=12 or a(i,j)=13 then j=j+1
case 39: ' droit
gosub cpos2:if a(i,j)>0 and a(i,j)<4 or a(i,j)>7 and a(i,j)<12 then i=i+1
case 40: ' bas
gosub cpos2:if a(i,j)<8 then j=j-1
case 27:goto termine
end_select
gosub cpos1:wait 100
' test si on arrive à la porte de sortie du labyrinthe fin de programme
if i=int(h/2) and j=v then goto termine
goto jeu
end

cpos1:
2d_pen_color 255,0,0:2d_circle ax(i,j)+25,ay(i,j)+20,5
return
cpos2:
2d_pen_color 240,240,240:2d_circle ax(i,j)+25,ay(i,j)+20,5
return

' TRACÉ DU LABYRINTHE DE COULEUR BLEU
trace:
2d_pen_color 0,0,192:2d_pen_width 3
for j=2 to v:for i=2 to h
select a(i,j)
case 1:2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40
case 2:2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 3:2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 4:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 5:2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 6:2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 7:2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 8:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 9:2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 10:2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 11:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 12:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 13:2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 14:2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
end_select
next i:next j
return

' GÉNÉRATION DU LABYRINTHE
lab:
for j=1 to v+1:a(1,j)=4:a(h+1,j)=1:next j
for i=2 to h:a(i,v+1)=8:a(i,1)=2:for j=2 to v:a(i,j)=15:next j:next i
r=int(h/2+1):s=int(v/2+1):a(r,s)=15
for k=1 to n
r1:
i=0
if a(r-1,s)<15 then goto r2
i=i+1:c(i)=1
r2:
if a(r,s-1)<15 then goto r3
i=i+1:c(i)=2
r3:
if a(r+1,s)<15 then goto r4
i=i+1:c(i)=3
r4:
if a(r,s+1)<15 then goto r5
i=i+1:c(i)=4
r5:
if i=0 then goto r6
if i<>1 then i=int(rnd(i)+1)
select c(i)
case 1
a(r,s)=a(r,s)-(int(a(r,s))-int(int(a(r,s))/2)*2):r=r-1:a(r,s)=a(r,s)-(int(a(r,s)/4)-int(int(a(r,s)/4)/2)*2)*4
goto r11
case 2
a(r,s)=a(r,s)-(int(a(r,s)/8)-int(int(a(r,s)/8)/2)*2)*8:s=s-1:a(r,s)=a(r,s)-(int(a(r,s)/2)-int(int(a(r,s)/2)/2)*2)*2
goto r11
case 3
a(r,s)=a(r,s)-(int(a(r,s)/4)-int(int(a(r,s)/4)/2)*2)*4:r=r+1:a(r,s)=a(r,s)-(int(a(r,s))-int(int(a(r,s))/2)*2)
goto r11
case 4
a(r,s)=a(r,s)-(int(a(r,s)/2)-int(int(a(r,s)/2)/2)*2)*2:s=s+1:a(r,s)=a(r,s)-(int(a(r,s)/8)-int(int(a(r,s)/8)/2)*2)*8
end_select
goto r11
r6:
if d=-1 then goto r7
if r<>h then goto r9
if s<>v then goto r8
r=2:s=2:goto r10
r7:
if r<>2 then goto r9
if s<>v then goto r8
r=h:s=2: goto r10
r8:
s=s+1:d=-1*d:goto r10
r9:
r=r+d
r10:
if a(r,s)=15 then goto r6
goto r1
r11:
mur(r,s)=int(rnd(6)+1)
if mur(r,s)=mur(r-1,s) or mur(r,s)=mur(r+1,s) or mur(r,s)=mur(r,s-1) or mur(r,s)=mur(r,s+1) then goto r11
next k
return

termine:
terminate

J'attend avec impatience vos réactions, vos critiques sur ma manière de programmer, etc... N'hésitez surtout pas, car j'ai besoin d'apprendre. J'ai beaucoup de retard à rattrapper.
A bientôt, cordialement, Bignono

Sujet: Re: Labyrinth Dim 13 Nov 2011 - 16:33

Alors là, moi, je dis bravo. Si c'est l'un de tes premiers programmes, c'est vraiment prometteur Smile

Code super propre et tout ... allez, je fais mon Cosmos, je dirais que le end ne sert à rien, mais bon, comme toi, moi j'aime bien le mettre, car ça montre la fin du programme principal, même si ce n'est que pour se faire plaisir Smile

Le programme marche très bien, mais j'ai rencontré un bug (passage qui aurait dû être autorisé (pas de mur) mais mouvement non autorisé. Ma femme a besoin de l'ordi, mais je regarde ça...

Sujet: Re: Labyrinth Dim 13 Nov 2011 - 18:37

Bonjour et bienvenue Bignono ! Very Happy

C'est pas mal !!!
Une petite remarque sur le codage :

Je trouve que cela manque d'indentation dans ton code.
Dans ta procédure Lab, il y a des goto que tu pourrais éviter, par ex:

Code:: lab:
for j=1 to v+1
a(1,j)=4:a(h+1,j)=1
next j
for i=2 to h
a(i,v+1)=8:a(i,1)=2
for j=2 to v : a(i,j)=15 : next j
next i
r=int(h/2+1):s=int(v/2+1):a(r,s)=15
for k=1 to n
r1:
i=0
if a(r-1,s) >= 15 then i=i+1:c(i)=1
if a(r,s-1) >= 15 then i=i+1:c(i)=2
if a(r+1,s) >= 15 then i=i+1:c(i)=3
if a(r,s+1) >= 15 then i=i+1:c(i)=4

r5:
...

Petite remarque en apparté: Wink

Je trouve dommage qu'au lieu d'écrire :

Code:: r11:
mur(r,s)=int(rnd(6)+1)
if mur(r,s)=mur(r-1,s) or mur(r,s)=mur(r+1,s) or mur(r,s)=mur(r,s-1) or mur(r,s)=mur(r,s+1) then goto r11

on ne puisse pas écrire ça :

Code:: repeat
mur(r,s)=int(rnd(6)+1)
until mur(r,s)<>mur(r-1) and mur(r,s)<>mur(r+1,s) and mur(r,s)<>mur(r,s-1) and mur(r,s)<>mur(r,s+1)

Vive la programmation structurée !!! Laughing

Sujet: labyrinthe Dim 13 Nov 2011 - 19:02

Tout d'abord, merci de vos remarques.
Nardo, je tiens compte de ce que tu me dis, mais sache que j'ai commencé à programmer sur une vieille machine de 1984 un HECTOR HRX qui n'avait que 17ko de mémoire vive en Basic III, 30ko en forth et 32ko quand elle est passé au basic 3X. Cela faisait plus de 25 ans que je n'avais pas fait de programme!
Pour Jicehel, j'ai trouvé le bug que tu me décris! Il peut arriver que le programme génère des salles a(i,j)=0.
dans ce cas il suffit de changer les 4 lignes suivantes:

Code:: case 38: ' haut
gosub cpos2:if a(i,j)=0 or a(i,j)=1 or a(i,j)=4 or a(i,j)=5 or a(i,j)=8 or a(i,j)=9 or a(i,j)=12 or a(i,j)=13 then j=j+1
case 39: ' droit
gosub cpos2:if a(i,j)<4 or a(i,j)>7 and a(i,j)<12 then i=i+1

et normalement, il n'y a plus de bug!
A bientôt

Sujet: Re: Labyrinth Dim 13 Nov 2011 - 19:09

Je test ça de suite Smile

Merci.
PS: j'ai commencé aussi par un Hector (je l'ai eu pour ma première communion) et je me faisait les listing d'un journal informatique qui s'appelait Hebdogiciel (je ne sais pas si tu as connu ...) et on n'habite pas loin l'un de chez l'autre (j'habite Chelles Smile

) ... Bon, aller, j’arrête de sortir du sujet, mais je rajoute une petite phrase que j'avais hommis dans mon premier post: BIENVENU Smile

Sujet: Re: Labyrinth Dim 13 Nov 2011 - 19:24

Bienvenue bignono
Ton programme et très bien et fonctionne aussi très bien.

Sujet: Labyrinthe Dim 13 Nov 2011 - 19:30

Nardo,
[repeat
mur(r,s)=int(rnd(6)+1)
until mur(r,s)<>mur(r-1) and mur(r,s)<>mur(r+1,s) and mur(r,s)<>mur(r,s-1) and mur(r,s)<>mur(r,s+1) ]

J'obtiens l'erreur suivante: (33) Not correct logical expression: Index Overflow Line: 124

Sujet: Re: Labyrinth Dim 13 Nov 2011 - 20:35

Normal, c'est ce que Nardo voulait dire, dommage que Panoramic ne permette pas d'écrire comme ça.

Et bienvenue à toi !

Et je suis d'accord avec lui, vive l'indentation qui facilite grandement la lecture des codes des autres (et des siens propres aussi).

Sujet: Re: Labyrinth Dim 13 Nov 2011 - 20:59

Bignono, j'ai mis le correctif que tu m'a donné dans ton source et j'ai fais ce que Nardo nous avais conseillé (enfin je pense), je mets le code ici des fois que ça intéresse quelqu'un mais bon, ce n'est ni plus ni moins que ton programme

Code:: dim d,dtn,h,i,j,k,n,r,s,v,a(33,22),ax(32,21),ay(32,21),c(4),mur(33,22)
label cpos2,debut,jeu,lab,termine,trace
label r1,r6,r7,r8,r9,r10,r11

full_space 0

debut:
' VALEURS MAXIMALES de h et v pour voir tout le labyrinthe à l'écran!
' mode écran 800 x 600 --> h=15 ; v=12
' mode écran 1024 x 768 --> h=20 ; v=17
' mode écran 1280 x 800 --> h=15 ; v=12
' mode écran 1600 x 900 --> h=31 ; v=20
h=20:v=17:n=h*v-1:h=h+1:v=v+1:d=1

for i=1 to h
for j=1 to v:ax(i,j)=(i*50)-85:ay(i,j)=10+(v*40)-(j*40):next j
next i
gosub lab
gosub trace
i=int(h/2):j=2

' TRACÉ DU REPÈRE ET DES PORTES D'ENTRÉE (en bas) ET SORTIE (en haut) EN ROUGE
2d_pen_color 255,0,0
2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
2d_line ax(i,j),10,ax(i,j)+50,10

' Boucle principale
jeu:
dtn=scancode
select dtn
case 37: ' gauche
gosub cpos2:if odd(a(i,j))=0 then i=i-1
case 38: ' haut
gosub cpos2:if a(i,j)=0 or a(i,j)=1 or a(i,j)=4 or a(i,j)=5 or a(i,j)=8 or a(i,j)=9 or a(i,j)=12 or a(i,j)=13 then j=j+1
case 39: ' droit
gosub cpos2:if a(i,j)<4 or a(i,j)>7 and a(i,j)<12 then i=i+1
case 40: ' bas
gosub cpos2:if a(i,j)<8 then j=j-1
case 27:goto termine
end_select
2d_pen_color 255,0,0:2d_circle ax(i,j)+25,ay(i,j)+20,5
wait 100
if i=int(h/2) and j=v then goto termine : ' Si on arrive à sortie du labyrinthe fin de programme
goto jeu
end

cpos2:
2d_pen_color 240,240,240:2d_circle ax(i,j)+25,ay(i,j)+20,5
return

' TRACÉ DU LABYRINTHE DE COULEUR BLEU
trace:
2d_pen_color 0,0,192:2d_pen_width 3
for j=2 to v
for i=2 to h
select a(i,j)
case 1 :2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40
case 2 :2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 3 :2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 4 :2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 5 :2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 6 :2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 7 :2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 8 :2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 9 :2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 10:2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 11:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 12:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 13:2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 14:2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
end_select
next i
next j
return

' GÉNÉRATION DU LABYRINTHE
lab:
for j=1 to v+1:a(1,j)=4:a(h+1,j)=1:next j
for i=2 to h:a(i,v+1)=8:a(i,1)=2:for j=2 to v:a(i,j)=15:next j:next i
r=int(h/2+1):s=int(v/2+1):a(r,s)=15
for k=1 to n

r1:
i=0
if a(r-1, s )=15 then i=i+1 : c(i)=1
if a(r, s-1)=15 then i=i+1 : c(i)=2
if a(r+1, s )=15 then i=i+1 : c(i)=3
if a(r, s+1)=15 then i=i+1 : c(i)=4
if i=0 then goto r6
if i<>1 then i=int(rnd(i)+1)
select c(i)
case 1 : a(r,s)=a(r,s)-(int(a(r,s))-int(int(a(r,s))/2)*2):r=r-1:a(r,s)=a(r,s)-(int(a(r,s)/4)-int(int(a(r,s)/4)/2)*2)*4
case 2 : a(r,s)=a(r,s)-(int(a(r,s)/8)-int(int(a(r,s)/8)/2)*2)*8:s=s-1:a(r,s)=a(r,s)-(int(a(r,s)/2)-int(int(a(r,s)/2)/2)*2)*2
case 3 : a(r,s)=a(r,s)-(int(a(r,s)/4)-int(int(a(r,s)/4)/2)*2)*4:r=r+1:a(r,s)=a(r,s)-(int(a(r,s))-int(int(a(r,s))/2)*2)
case 4 : a(r,s)=a(r,s)-(int(a(r,s)/2)-int(int(a(r,s)/2)/2)*2)*2:s=s+1:a(r,s)=a(r,s)-(int(a(r,s)/8)-int(int(a(r,s)/8)/2)*2)*8
end_select
goto r11
r6:
if d=-1 then goto r7
if r<>h then goto r9
if s<>v then goto r8
r=2:s=2:goto r10
r7:
if r<>2 then goto r9
if s<>v then goto r8
r=h:s=2: goto r10
r8:
s=s+1:d=-1*d:goto r10
r9:
r=r+d
r10:
if a(r,s)=15 then goto r6
goto r1
r11:
mur(r,s)=int(rnd(6)+1)
if mur(r,s)=mur(r-1,s) or mur(r,s)=mur(r+1,s) or mur(r,s)=mur(r,s-1) or mur(r,s)=mur(r,s+1) then goto r11
next k
return

termine:
terminate

Sujet: Re: Labyrinth Dim 13 Nov 2011 - 22:12

Ce n'est pas un reproche bignono, c'est juste des conseils ! Wink

Je me doute que ça doit être pas évident de se remettre à la programmation... Wink

J'ai commencé sur ZX81 puis Oric1 (trafiqué en Atmos par la suite), j'ai tapé des pages et des pages des listing d'hebdogiciel et passé des heures et des heures par la suite à essayer de les faire fonctionner... Laughing

Pour en revenir à ton programme, il est très bien !
Tu peux t'amuser a le rendre beaucoup plus structuré : ça t'apprend l'utilisation d'autres boucles que les FOR-NEXT mais ce n'est pas une obligation: l'essentiel c'est qu'il marche ! Very Happy

Sujet: Re: Labyrinth Dim 13 Nov 2011 - 22:14

Et en plus, c'est fun comme jeu et en peu de lignes ^^

Sujet: Re: Labyrinth Lun 14 Nov 2011 - 13:49

bienvenue Bignono

(et en plus on est voisins!!! )

jp

Sujet: re Mar 15 Nov 2011 - 4:05

Bravo ! et bienvenue au club ! cheers

Sujet: Un monstre dans le labyrinthe! Mar 15 Nov 2011 - 19:58

Bonsoir à tous,

Je reviens donc avec le même programme du labyrinthe dans lequel on dirige avec les flèches du clavier un petit repère rouge pour chercher la sortie.
Dans le programme, j'ai ajouté un repère noir représentant un monstre qui cherche lui à vous manger! Vous y échapperez difficilement!
Le problème était de gérer les déplacements du monstre, et de lui faire parcourir tout le labyrinthe.
On aurait pu essayer de gèrer les déplacements du monstre avec la fonction rnd en choisissant parmi 4 nombres la direction qu'il devait prendre (par ex: 1 à gauche, 2 en haut, 3 à droite et 4 en bas). Mais il se serait cantonné principalement dans le haut du labyrinthe et en aurait exploré difficilement le bas.

La solution que j'ai adopté, est de le doter d'une variable sens de déplacement appelé "sd" qui sera affectée par la valeur dans la case où il se trouve "a(f,g)".
Ainsi si dans la case où il se trouve, il voit une porte à gauche, il la prend, ensuite, s'il n'y en a pas, il regarde s'il y en a une à droite pour la prendre, et s'il arrive dans un cul de sac, il fait demi tour. Donc le monstre explore tout le labyrinthe.

Avec ce programme qui contient un "petit moteur de déplacement du monstre", imaginez tout ce que vous pouvez créer...
Un labyrinthe peuplé de monstres à votre poursuite ou bien mettre des pastilles dans chaque case et transformer votre repère rouge en "Pac-Man", tantôt fuyant les monstres, tantôt les poursuivant après avoir mangé une pastille énergétique.
Et avec la 3d, pourquoi pas un PACMAN EN 3d!!! Moi j'imagine bien un chateau construit comme un labyrinthe, où une princesse est emprisonnée dans une salle quelconque, et vous incarnez le chevalier explorant chaque salle, et quand vous tombez sur un monstre (un dragon par exemple) vous devez le combattre... etc...
De nombreux scénarios sont possibles, si votre imagination est sans limite!

Code:: dim d,f,g,dtn,h,i,j,k,n,r,s,sd,v,a(33,22),ax(32,21),ay(32,21),c(4),mur(33,22)
label cpos1,cpos2,debut,jeu,lab,termine,trace,r1,r2,r3,r4,r5,r6,r7
full_space 0

debut:
' VALEURS MAXIMALES de h et v pour voir tout le labyrinthe à l'écran!
' mode écran 800 x 600 --> h=15 ; v=12
' mode écran 1024 x 768 --> h=20 ; v=17
' mode écran 1280 x 800 --> h=15 ; v=12
' mode écran 1366 x 768 --> h=26 ; v=17
' mode écran 1600 x 900 --> h=31 ; v=20
h=26:v=17:n=h*v-1:h=h+1:v=v+1:d=1
for i=1 to h
for j=1 to v:ax(i,j)=(i*50)-85:ay(i,j)=10+(v*40)-(j*40):next j
next i
gosub lab:gosub trace

i=int(h/2):j=2:' i et j position de la case de votre repère rouge
f=i:g=v:' f et g position de la case du monstre repère noir
sd=1

' TRACÉ DES PORTES D'ENTRÉE (en bas) ET SORTIE (en haut) EN ROUGE
2d_pen_color 255,0,0
2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
2d_line ax(i,j),10,ax(i,j)+50,10

' Création d'un timer pour gérer déplacements du repère et du monstre
timer 9:timer_interval 9,200:on_timer 9,jeu
end

jeu:
' diriger votre repère rouge avec les flèches du clavier
dtn=scancode
select dtn
case 37: ' gauche
gosub cpos1:if odd(a(i,j))=0 then i=i-1
case 38: ' haut
gosub cpos1:if a(i,j)=0 or a(i,j)=1 or a(i,j)=4 or a(i,j)=5 or a(i,j)=8 or a(i,j)=9 or a(i,j)=12 or a(i,j)=13 then j=j+1
case 39: ' droit
gosub cpos1:if a(i,j)<4 or a(i,j)>7 and a(i,j)<12 then i=i+1
case 40: ' bas
gosub cpos1:if a(i,j)<8 then j=j-1
case 27:goto termine
end_select
2d_pen_color 255,0,0:2d_circle ax(i,j)+25,ay(i,j)+20,5:' afficher votre repère rouge
if i=int(h/2) and j=v then goto termine : ' Si on arrive à sortie du labyrinthe fin de programme

' Gestion déplacement du repère noir (le monstre) qui explore le labyrinthe à votre recherche
select sd
case 1
gosub cpos2:f=f-1
if a(f,g)= 1 or a(f,g)=2 or a(f,g)=3 then sd=4
if a(f,g)= 9 then sd=3
if a(f,g)=11 then sd=2
case 2
gosub cpos2:f=f+1
if a(f,g)= 4 or a(f,g)=8 or a(f,g)=12 then sd=3
if a(f,g)= 6 then sd=4
if a(f,g)=14 then sd=1
case 3
gosub cpos2:g=g+1
if a(f,g)= 2 or a(f,g)=4 or a(f,g)=6 then sd=1
if a(f,g)= 3 then sd=2
if a(f,g)= 7 then sd=4
case 4
gosub cpos2:g=g-1
if a(f,g)= 1 or a(f,g)=8 or a(f,g)=9 then sd=2
if a(f,g)=12 then sd=1
if a(f,g)=13 then sd=3
end_select
2d_pen_color 0,0,0:2d_circle ax(f,g)+25,ay(f,g)+20,5:' affiche le repère noir (le monstre)
if i=f and j=g then goto termine:' le monstre repère noir vous a eu -> fin programme
return

cpos1:
2d_pen_color 240,240,240:2d_circle ax(i,j)+25,ay(i,j)+20,5: ' efface le repère rouge
return
cpos2:
2d_pen_color 240,240,240:2d_circle ax(f,g)+25,ay(f,g)+20,5: ' efface le repère noir (le monstre)
return

' TRACÉ DU LABYRINTHE DE COULEUR BLEU
trace:
2d_pen_color 0,0,192:2d_pen_width 3
for j=2 to v
for i=2 to h
select a(i,j)
case 1 :2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40
case 2 :2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 3 :2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 4 :2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 5 :2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 6 :2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 7 :2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 8 :2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 9 :2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 10:2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
case 11:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j),ay(i,j):2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j)
case 12:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 13:2d_line ax(i,j),ay(i,j),ax(i,j),ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40
case 14:2d_line ax(i,j),ay(i,j),ax(i,j)+50,ay(i,j):2d_line ax(i,j)+50,ay(i,j),ax(i,j)+50,ay(i,j)+40:2d_line ax(i,j),ay(i,j)+40,ax(i,j)+50,ay(i,j)+40
end_select
' ENLEVER LE REM POUR AFFICHER LA VALEUR DE CHAQUE CASE DU LABYRINTHE
rem ' print_locate ax(i,j)+25,ay(i,j)+25:print a(i,j):if a(i,j)=0 then beep_error
next i
next j
return

' GÉNÉRATION DU LABYRINTHE
lab:
for j=1 to v+1:a(1,j)=4:a(h+1,j)=1:next j
for i=2 to h:a(i,v+1)=8:a(i,1)=2:for j=2 to v:a(i,j)=15:next j:next i
r=int(h/2+1):s=int(v/2+1):a(r,s)=15
for k=1 to n
r1:
i=0
if a(r-1,s)=15 then i=i+1 :c(i)=1
if a(r,s-1)=15 then i=i+1 :c(i)=2
if a(r+1,s)=15 then i=i+1 :c(i)=3
if a(r,s+1)=15 then i=i+1 :c(i)=4
if i=0 then goto r2
if i<>1 then i=int(rnd(i)+1)
select c(i)
case 1 :a(r,s)=a(r,s)-(int(a(r,s))-int(int(a(r,s))/2)*2):r=r-1:a(r,s)=a(r,s)-(int(a(r,s)/4)-int(int(a(r,s)/4)/2)*2)*4
case 2 :a(r,s)=a(r,s)-(int(a(r,s)/8)-int(int(a(r,s)/8)/2)*2)*8:s=s-1:a(r,s)=a(r,s)-(int(a(r,s)/2)-int(int(a(r,s)/2)/2)*2)*2
case 3 :a(r,s)=a(r,s)-(int(a(r,s)/4)-int(int(a(r,s)/4)/2)*2)*4:r=r+1:a(r,s)=a(r,s)-(int(a(r,s))-int(int(a(r,s))/2)*2)
case 4 :a(r,s)=a(r,s)-(int(a(r,s)/2)-int(int(a(r,s)/2)/2)*2)*2:s=s+1:a(r,s)=a(r,s)-(int(a(r,s)/8)-int(int(a(r,s)/8)/2)*2)*8
end_select
goto r7
r2:
if d=-1 then goto r3
if r<>h then goto r5
if s<>v then goto r4
r=2:s=2:goto r6
r3:
if r<>2 then goto r5
if s<>v then goto r4
r=h:s=2: goto r6
r4:
s=s+1:d=-1*d:goto r6
r5:
r=r+d
r6:
if a(r,s)=15 then goto r2
goto r1
r7:
mur(r,s)=int(rnd(6)+1)
if mur(r,s)=mur(r-1,s) or mur(r,s)=mur(r+1,s) or mur(r,s)=mur(r,s-1) or mur(r,s)=mur(r,s+1) then goto r7
next k
return

termine:
timer_off 9:terminate

A bientôt

Sujet: Re: Labyrinth Mar 15 Nov 2011 - 20:50

Et dire que tu commences Smile

Ca promet !! Nickel, perso, j'ai ajouté un message pour "Gagné, vous êtes sorti indemne" et "Dommage, le monstre vous dévore ...".

Sujet: Labyrinthe en 3D Jeu 17 Nov 2011 - 23:19

Bonsoir à tous les amis Panoramiciens

Je reviens cette fois-ci avec un labyrinthe en 3d! Car je constate que peu de programme touchant à la 3d sont présent sur ce forum.
Un petit moteur de déplacement est intégré au programme ce qui permet de se déplacer à l'intérieur.

Je continue à travailler dessus, car comme vous le remarquerez, on peut passer à travers les murs. J'avoue que je sèche Mad

, et je n'arrive pas encore à trouver de solution pour gèrer les collisions avec les murs.

J'ai bien utilisé l'instruction 3d_collision_as_faces ou cube pour chaque mur du labyrinthe mais cela me faisait gèrer entre 359 et 362 tests (pour h=15 et v=12) avec if o3d_collision(n,p)=1, ce qui ralentissait considérablement le prog.

Ensuite j'ai essayé de chainer chaque mur entre eux avec l'instruction 3d_chain de manière à n'avoir qu'un seul test de collision à gèrer avec le dernier objet, mais je me suis vite apperçu que panoramic ne pouvait chainer au maximum que 29 objets à la suite les uns des autres, car arrivé au 30ème, le message d'erreur de dépassement de pile s'affiche joyeusement et ironise parfois avec un access violiation!

Alors je vous appelle à l'aide affraid

, si quelqu'un trouve la solution, je suis preneur!!

Youpi, le code:

Code:: dim d,dtn,h,i,j,k,n,r,s,v,a(37,37),c(4),mur(37,37),rot,vrot,vd
label moteur,lab,termine,r1,r2,r3,r4,r5,r6,r7,entr,pan1,pan2,pan4,pan8
scene3d 1:full_space 0:full_space 1:light_position 0,1500,0
3d_plane 1:3d_scale 1,500,500,1:3d_x_rotate 1,90:3d_y_position 1,0:3d_color 1,0,0,32
3d_cube 2,1:3d_mesh 3

h=15:v=12:n=h*v-1:h=h+1:v=v+1:d=1:gosub lab

' CONSTRUCTION DU LABYRINTHE
3d_text 4,"ENTRÉE":3d_color 4,0,0,255:3d_y_rotate 4,180
3d_position 4,((h/2)*8)-(2*odd(h)-2*even(h)),4,12
3d_text 5,"SORTIE":3d_color 5,0,0,255:3d_y_rotate 5,180
3d_position 5,((h/2)*8)-(2*odd(h)-2*even(h)),4,(v*8)+4

for j=2 to v
for i=2 to h
if j=2 and i=int(h/2) or j=v and i=int(h/2) then goto entr
select a(i,j)
case 1: gosub pan1
case 2: gosub pan2
case 3: gosub pan1:gosub pan2
case 4: gosub pan4
case 5: gosub pan1:gosub pan4
case 6: gosub pan2:gosub pan4
case 7: gosub pan1:gosub pan2:gosub pan4
case 8: gosub pan8
case 9: gosub pan1:gosub pan8
case 10: gosub pan2:gosub pan8
case 11: gosub pan1:gosub pan2:gosub pan8
case 12: gosub pan4:gosub pan8
case 13: gosub pan1:gosub pan4:gosub pan8
case 14: gosub pan2:gosub pan4:gosub pan8
end_select
entr:

next i
next j

' Initialisation et création d'un timer pour gérer les déplacements
i=int(h/2):j=2
rot=0:vd=.5:vrot=2:3d_position 2,((h/2)*8)-(3*odd(h)),0,8
timer 3:timer_interval 3,10:on_timer 3,moteur
end

moteur:
select scancode
case 27:goto termine
case 37:rot=rot+vrot:3d_y_rotate 2,rot
case 39:rot=rot-vrot:3d_y_rotate 2,rot
case 38:3d_move 2,vd
case 40:3d_move 2,vd-(2*vd)
end_select
3d_position 3,o3d_x_position(2),o3d_y_position(2)-4,o3d_z_position(2):3d_rotate 3,o3d_x_rotate(2),o3d_y_rotate(2),o3d_z_rotate(2)
3d_move 3,1:cam_position o3d_x_position(2),4,o3d_z_position(2):point_position o3d_x_position(3),4,o3d_z_position(3)
return

pan1:
3d_box number_3d_objects+1,8,8,1:3d_position number_3d_objects,(i*8)-4,4,(j*8)
3d_y_rotate number_3d_objects,90:3d_color number_3d_objects,96,0,0
return
pan2:
3d_box number_3d_objects+1,8,8,1:3d_position number_3d_objects,(i*8),4,(j*8)+4
return
pan4:
3d_box number_3d_objects+1,8,8,1:3d_position number_3d_objects,(i*8)+4,4,(j*8)
3d_y_rotate number_3d_objects,90:3d_color number_3d_objects,96,0,0
return
pan8:
3d_box number_3d_objects+1,8,8,1:3d_position number_3d_objects,(i*8),4,(j*8)-4
return

' GÉNÉRATION DU LABYRINTHE
lab:
for j=1 to v+1:a(1,j)=4:a(h+1,j)=1:next j
for i=2 to h:a(i,v+1)=8:a(i,1)=2:for j=2 to v:a(i,j)=15:next j:next i
r=int(h/2+1):s=int(v/2+1):a(r,s)=15
for k=1 to n
r1:
i=0
if a(r-1,s)=15 then i=i+1 :c(i)=1
if a(r,s-1)=15 then i=i+1 :c(i)=2
if a(r+1,s)=15 then i=i+1 :c(i)=3
if a(r,s+1)=15 then i=i+1 :c(i)=4
if i=0 then goto r2
if i<>1 then i=int(rnd(i)+1)
select c(i)
case 1 :a(r,s)=a(r,s)-(int(a(r,s))-int(int(a(r,s))/2)*2):r=r-1:a(r,s)=a(r,s)-(int(a(r,s)/4)-int(int(a(r,s)/4)/2)*2)*4
case 2 :a(r,s)=a(r,s)-(int(a(r,s)/8)-int(int(a(r,s)/8)/2)*2)*8:s=s-1:a(r,s)=a(r,s)-(int(a(r,s)/2)-int(int(a(r,s)/2)/2)*2)*2
case 3 :a(r,s)=a(r,s)-(int(a(r,s)/4)-int(int(a(r,s)/4)/2)*2)*4:r=r+1:a(r,s)=a(r,s)-(int(a(r,s))-int(int(a(r,s))/2)*2)
case 4 :a(r,s)=a(r,s)-(int(a(r,s)/2)-int(int(a(r,s)/2)/2)*2)*2:s=s+1:a(r,s)=a(r,s)-(int(a(r,s)/8)-int(int(a(r,s)/8)/2)*2)*8
end_select
goto r7
r2:
if d=-1 then goto r3
if r<>h then goto r5
if s<>v then goto r4
r=2:s=2:goto r6
r3:
if r<>2 then goto r5
if s<>v then goto r4
r=h:s=2: goto r6
r4:
s=s+1:d=-1*d:goto r6
r5:
r=r+d
r6:
if a(r,s)=15 then goto r2
goto r1
r7:
mur(r,s)=int(rnd(6)+1)
if mur(r,s)=mur(r-1,s) or mur(r,s)=mur(r+1,s) or mur(r,s)=mur(r,s-1) or mur(r,s)=mur(r,s+1) then goto r7
next k
return

termine:
timer_off 3:terminate

PS: J'ai testé les dimensions jusqu'à h=35 et v=35 en redimensionnant les tableaux en (37,37) et mon ordi a mis environ 10 secondes avant d'afficher le labyrinthe. Vous pouvez aussi tester des dimensions + grande et voir le temps qu'il faut pour avoir le labyrinthe à l'écran! Si vous trouvez les déplacements trop rapides, diminuez la valeur de vd.

A BIENTÔT

Sujet: Re: Labyrinth Jeu 17 Nov 2011 - 23:38

Genial, merci pour ce code Smile

Tu fais avancer le schmilblick Smile

Je ne m'y connais pas encore en 3D mais j'adore ton labyrinthe
Toutefois, quelques remarques:
Il y a une impression de "déformation" quand on bouge dans le labyrinthe (ouverture qui s'élargissent ou qui se rétrécissent et murs qui semblent s'allonger ou se rétrécir"
Pour autoriser ou non le déplacement, pourquoi n'utilises tu pas le même système que ton système 2D en parallèle ? Ca pourrait être une solution paliative ?
Il y a sans doute une solution propre, mais la gestion de la 3D, perso, je ne m'y suis pas encore mis, mais d'autres auront sans doute une solution Smile

En tout cas c'est encore un beau programme Smile

Sujet: Re: Labyrinth Ven 18 Nov 2011 - 0:20

Bonsoir Jicehel

Si tu as des images de mur en jpg ou bmp, tu peux remplacer dans les routines pan1, pan2, pan4 et pan8 les 3d_color number_3d_objects par 3d_load_texture number_3d_objects, "c:\...fichier image\mur.bmp" et tu devrais avoir moins l'impression de déformation. fais de même avec le 3d_color du 3d-plane du début: met lui un fichier image du genre herbe ou pavé ou carrelage, toujours avec 3d_load_texture.
Le système de déplacement en 2d est transposable en 3d, mais je risque d'avoir des déplacements très rapide. de plus en 2d, quand tu veux aller à gauche ou à droite, tu appuies sur la touche et tu changes de direction. En 3d tu regardes ce qu'il y a devant toi, et quand tu appuies sur la flèche gauche ou droite, d'abord tu pivotes et ensuite tu appuies sur la flèche haut pour aller tout droit. Tu saisis ?

Enfin merci pour tes encouragements

A bientôt Very Happy

Sujet: Re: Labyrinth Ven 18 Nov 2011 - 8:23

Merci Bignono l'idée pourrait être pour "calquer" le déplacement 2D de faire comme dans beaucoup de jeu devant tu avance, derriere tu recule, flèche droite tu pivotes de 90° à droite, flèche gauche tu pivote de 90° à gauche (mais bon, on peut aussi laisser le "pivot" libre comme actuellement, ça peut correspondre aussi selon ce que l'on veut faire (si le monstre est animé en temps réel, ça permet de l'esquiver à droite ou à gauche de sa case par exemple), c'est un choix. La première solution à l'avantage d'être plus simple à gérer (on avance par exemple par case, d'où une gestion simplifiée des murs)

Sujet: Re: Labyrinth Ven 18 Nov 2011 - 10:12

Encore une petit remarque bignono, ton programme est vachement bien, mais il manque quelques commentaires sur les pan1...pan8 et sur les valeurs du select qui faciliteraient la compréhesion du programme pour les gens qui ne l'on pas pensé et même si tu as réussi à en faire une version très simple, au début, on rame un peu pour comprendre (enfin moi en tout cas ...)
Si j'ai le temps ce week end, je sortirais la parti génération de labyrinthe dans un programme un part qui fera un level.dat et le programme commencera par avoir un chargement du level.dat
2 avantages => Vu que tu commences à gérer les textures, ça permettra de faire un éditeur de niveau à terme, 2 ça permet de simplifier le labyrinthe obtenu, d'avoir des textures à des emplacements précis et de transmettre le tout au Panoramiciens Smile

Quelqu'un saurait-il ajouter à ce programme la gestion des portes en 3D ?

» FORT LABYRINTH