[DarkBasic] Moteur de collision 2D

` Création d'un Type de variable qui contient la structure des murs qui seront créés.
Type Tmur
ox as float
oy as float
dx as float
dy as float
lx as float
ly as float
l2 as float
l as float
EndType

` On régle la résolution d'écran en 1024x768, la résolution peut bien évidement être modifiée.
set display mode 1024,768,32,0

` On active le mode rafraichissement manuel à l'aide de la commande "sync on"
sync on

` On fixe le nombre d'images par seconde à 60
sync rate 60

` On cache la souris.
hide mouse

` On déclare la variable nWall_max en global et on l'initialise à 8.
` La variable "nWall_max" correspond au nombre de murs.
Global nWall_max as integer : nWall_max=8


` On créé un tableau contenant les informations de tous les murs.
` Ici 8 murs, sachant que le mur 0 existe, d'ou le "nWall_max-1".
Dim wallmap(nWall_max-1) as Tmur

` On créé une map de murs.
` La commande "Gosub" renvoie à l'étiquette "Map_2D"
` Dans cette étiquette, la fonction "add_wall" permet de créé de nouveaux murs.
Gosub Map_2D

` Les 2 premières variables permettent de stocker les coordonnées X,Y de la projection du joueur sur un mur.
Global wallx as float
Global wally as float

` Cette variable correspond à la distance la plus courte entre le joueur et le mur.
Global Dist as float

` Ces 2 variables correspondent au coéficient directeur qui va du mur au joueur.
Global nx as float
Global ny as float

` Ces variables stockent le numéro des 2 murs les plus proches.
Global nWall_A as integer
Global nWall_B as integer

` "testA" et "testB" contiennent les distances des murs "nWall_A" et "nWall_B" au joueur.
` Elle permettent des tests pour des cas particulier.
` Pour éviter les tremblement du joueur dans les angles par exemple.
testA as integer
testB as integer

` La variable "taille" correspond à la taille du joueur.
Global taille as integer : taille=30

` La variable "vitesse" correspond à la vitesse du joueur.
vitesse as integer : vitesse=8

` Ces variables contiennent les informations du joueur.
oldx as float : Joueur_x as float : Joueur_x=125
oldy as float : Joueur_y as float : Joueur_y=0

` Ici, on déclare la variable "Wall" de de type Tmur(la structure de nos murs)
` Cette variable permet d'effectuer tous les calculs de collision avec le mur le plus proche.
Wall as Tmur

do

   cls

   Gosub Deplacements

   mur_le_plus_proche(Joueur_x,Joueur_y)
   wall=wallmap(nWall_A)

   Position_et_Distance_de_Projection(Joueur_x,Joueur_y,wall)

   if abs(dist)<=taille
      hit=1
      CoeficientDirecteurInv(Joueur_x,Joueur_y,wallx,wally)
      Joueur_x=wallx+nx : Joueur_y=wally+ny
      testA=isUnder(Joueur_x,Joueur_y,Wall) : wall=wallmap(nWall_B) : testB=isUnder(Joueur_x,Joueur_y,Wall)
      if ((testA>0 && testB>0) || (testA<0 && testB<0)) || ((testA<0 && testB>0) || (testA>0 && testB<0) 
&& ((wallmap(nWall_A).ox<>wallmap(nWall_B).dx && wallmap(nWall_A).oy<>wallmap(nWall_B).dx)))
         if abs(testB)<=taille
            Joueur_x=oldx
            Joueur_y=oldy
            Position_et_Distance_de_Projection(Joueur_x,Joueur_y,wall)
            CoeficientDirecteurInv(Joueur_x,Joueur_y,wallx,wally)
            Joueur_x=wallx+nx : Joueur_y=wally+ny
         endif
      endif
   else
      hit=0
   endif

   old_f1_key=f1_key : f1_key=keystate(59)
   if f1_key=1 && old_f1_key=0
   if rate=60 : rate=0 : else : rate=60 : endif
   sync rate rate
   endif

   Gosub Affichage

   sync

loop


Deplacements:

   oldx=Joueur_x : oldy=Joueur_y
   if leftkey()=1  : a=a+3 : endif
   if rightkey()=1 : a=a-3 : endif
   if upkey()=1
   Joueur_x=Joueur_x+cos(a)*vitesse
   Joueur_y=Joueur_y-sin(a)*vitesse
   endif
   if downkey()=1
   Joueur_x=Joueur_x+cos(a)*((vitesse*-1)/2)
   Joueur_y=Joueur_y-sin(a)*((vitesse*-1)/2)
   endif

Return

Affichage:

   circle Joueur_x,Joueur_y,taille
   line Joueur_x,Joueur_y,Joueur_x+cos(a)*taille,Joueur_y-sin(a)*taille

   text 0,0,"Appuyez sur F1 pour changer le Fps."
   text 0,14,"FPS : "+str$(screen fps())
   text 0,28,"Hit : "+str$(hit)

Return


Map_2D:

nWall=0
add_wall(nWall,400,300,200,150)

nWall=1
add_wall(nWall,300,150,200,300)

nWall=2
add_wall(nWall,200,300,400,300)

nWall=3
add_wall(nWall,800,200,600,200)

nWall=4
add_wall(nWall,600,200,600,400)

nWall=5
add_wall(nWall,600,400,800,200)

nWall=6
add_wall(nWall,400,400,400,600)

nWall=7
add_wall(nWall,400,600,600,600)

Return

function add_wall(nWall as integer,ox as float,oy as float,dx as float,dy as float)
   wallmap(nWall).ox=ox
   wallmap(nWall).oy=oy
   wallmap(nWall).dx=dx
   wallmap(nWall).dy=dy
   wallmap(nWall).lx=wallmap(nWall).dx-wallmap(nWall).ox
   wallmap(nWall).ly=wallmap(nWall).dy-wallmap(nWall).oy
   wallmap(nWall).l2=wallmap(nWall).lx^2+wallmap(nWall).ly^2
   wallmap(nWall).l=sqrt(wallmap(nWall).l2)
endfunction

function Position_et_Distance_de_Projection(x as float, y as float, Wall as Tmur)
   coef as float : t as float
   coef = (x-Wall.ox)*Wall.lx+(y-Wall.oy)*Wall.ly
   t = coef/(Wall.lx*Wall.lx+ Wall.ly*Wall.ly)
   if t>=0 && t<=1
      wallx = Wall.ox + t*Wall.lx
      wally = Wall.oy + t*Wall.ly
      dist = Distance(x,y,wallx,wally)
   else
      if t<0
      wallx = Wall.ox
      wally = Wall.oy
      dist = Distance(x,y,Wall.ox,Wall.oy)
      endif
      if t>1
      wallx = Wall.dx
      wally = Wall.dy
      dist = Distance(x,y,Wall.dx,Wall.dy)
      endif
   endif
endfunction

function Distance_de_Projection(x as float, y as float, Wall as Tmur)
   coef as float : t as float : vdist as float : wx as float : wy as float
   coef = (x-Wall.ox)*Wall.lx+(y-Wall.oy)*Wall.ly
   t = coef/(Wall.lx*Wall.lx+ Wall.ly*Wall.ly)
   if t>=0 && t<=1
      wx = Wall.ox + t*Wall.lx
      wy = Wall.oy + t*Wall.ly
      vdist = Distance(x,y,wx,wy)
   else
      if t<0
      vdist = Distance(x,y,Wall.ox,Wall.oy)
      endif
      if t>1
      vdist = Distance(x,y,Wall.dx,Wall.dy)
      endif
   endif
endfunction vdist

function mur_le_plus_proche(x as float,y as float)
   Distance as float : wall as Tmur
   rayon_A as float : rayon_B as float
   rayon_A=9999 : rayon_B=9999
   for i=0 to nWall_max-1 : wall=wallmap(i)
      Distance=abs(Distance_de_Projection(x, y, wall))
      if Distance<rayon_A
         nWall_B=nWall_A
         rayon_B=rayon_A
         nWall_A=i
         rayon_A=Distance
      else
         if Distance<rayon_B
            nWall_B=i
            rayon_B=Distance
         endif
      endif
      draw(i)
   next i
endfunction

function Distance(x1 as float, y1 as float, x2 as float, y2 as float)
   result as float : result = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1))
endfunction result

function CoeficientDirecteurInv(x1 as float, y1 as float, x2 as float, y2 as float)
   Normalex as float : Normaley as float : MagnitudeInv as float
   Normalex=x1-x2
   Normaley=y1-y2
   MagnitudeInv = Taille / Sqrt(Normalex*Normalex+Normaley*Normaley)
   nx=Normalex * MagnitudeInv: ny=Normaley * MagnitudeInv
endfunction

function isUnder(x as float, y as float, Wall as Tmur)
   coef as float : t as float : vdist as float
   coef = (x-Wall.ox)*Wall.lx + (y-Wall.oy)*Wall.ly
   t = coef/(Wall.lx*Wall.lx + Wall.ly*Wall.ly)
   if t>=0 && t<=1
      vDist = ((x-Wall.ox)*Wall.ly - (y-Wall.oy)*Wall.lx) / wall.l
   endif
endfunction vDist

function draw(nWall as integer)
   line wallmap(nWall).ox,wallmap(nWall).oy,wallmap(nWall).dx,wallmap(nWall).dy
endfunction

nWall=6
wallmap(nWall).ox=500  <--- avant on avait 400 avant
wallmap(nWall).oy=400
wallmap(nWall).dx=400
wallmap(nWall).dy=600
wallmap(nWall).lx=wallmap(nWall).dx-wallmap(nWall).ox
wallmap(nWall).ly=wallmap(nWall).dy-wallmap(nWall).oy
wallmap(nWall).l2=wallmap(nWall).lx^2+wallmap(nWall).ly^2
wallmap(nWall).l=sqrt(wallmap(nWall).l2)

      ` On refait un test de collision mais cette fois avec le mur_B
      testA=isUnder(x,y,Wall) : wall=wallmap(nWall_B) : testB=isUnder(x,y,Wall)
      ` Ce test permet de savoir si on se trouve dans un coin entre 2 murs ou pas
      ` sans cette condition le personnage se coincerait facilement aux extrémités des murs
      if testA<>0 && testB<>0 && ((testA>0 && testB>0) || (testA<0 && testB<0))
         if abs(testB)<taille
            x=oldx          <--- ici
            y=oldy          <--- et ici
            calcul_vectoriel(x,y,wall)
            normal(wallx,wally,x,y)
            normal(wallx,wally,wallx+nx,wally+ny)
            x=wallx+nx*-1 : y=wally+ny*-1
         endif
      endif

x=oldx 
y=oldy

if abs(testB)<taille

Sinon je pense que la meilleure chose pour l'explication c'est la démonstration des résultats.
Mais ne pas l'expliquer est un bon choix tant qu'on sait a quoi correspond chaque variable^^

Pour le second bug, il faudrait à mon avis tester si la nouvelle position calculée après collision glissante ne rentre pas dans un autre mur, auquel cas réajuster une nouvelle fois les coordonnées.

      ` On refait un test de collision mais cette fois avec le mur_B
      testA=isUnder(x,y,Wall) : wall=wallmap(nWall_B) : testB=isUnder(x,y,Wall)
      ` Ce test permet de savoir si on se trouve dans un coin entre 2 murs ou pas
      ` sans cette condition le personnage se coincerait facilement aux extrémités des murs
      if testA<>0 && testB<>0 && ((testA>0 && testB>0) || (testA<0 && testB<0))
         if abs(testB)<taille
            x=oldx     
            y=oldy         
         endif
      endif

if testA<>0 && testB<>0 && ((testA>0 && testB>0) || (testA<0 && testB<0))

if testA<>0 && testB<>0 && ((testA>0 && testB>0) || (testA<0 && testB<0)) 
or (((wallmap(nWall_A).ox<>wallmap(nWall_B).dx && wallmap(nWall_A).oy<>wallmap(nWall_B).dx)) 
&& (testA<0 && testB>0) || (testA>0 && testB<0))