! -Auto_test_GC  @Cassiope34 07/2016

gr.open 255,90,140,80,0,0  % green
gr.screen w,h
scx = 1280  : scy = 800
sx  = w/scx : sy  = h/scy
gr.scale sx,sy
wakelock 3
 
gr.bitmap.load autos, path$+"car-sprites.png"

ARRAY.LOAD diX[] ,0 ,1 ,1 ,1 ,0 ,-1,-1,-1    % 1 Nord  3 Est  5 Sud  7 Ouest
ARRAY.LOAD diY[] ,-1,-1,0 ,1 ,1 ,1 ,0 ,-1    % reste =diagonales
DIM cr[6]

gr.bitmap.crop cr[1], autos, 14, 4,67,147    % rouge
gr.bitmap.crop cr[2], autos, 120,5,69,146    % police
gr.bitmap.crop cr[3], autos, 241,8,69,145    % rayée orange
gr.bitmap.crop cr[4], autos, 364,5,80,153    % jaune
gr.bitmap.crop cr[5], autos, 4,206,87,177    % ambulance
gr.bitmap.crop cr[6], autos, 123,214,95,174  % pickup bleu
gr.bitmap.delete autos

nv =6       % nbre de véhicules
lv =98      % longueur véhicule
la =int(lv/1.875)  % conserve la proportion du véhicule.

gr.rect curs, 0,0,1,1   % curseur pour selectionner un véhicule en le touchant.

gr.color 100,200,200,200,1   % grille du terrain
mx =int(scx/lv)
for x=1 to mx+1
  gr.line nul, (x-1)*lv, 0, (x-1)*lv, scy
next
my =int(scy/lv)
for y=1 to my+1
  gr.line nul, 0, (y-1)*lv, scx, (y-1)*lv
next

DIM car[nv,8], t[mx+1,my+1]    % autos & terrain.

gr.color 255,0,255,255,1

for c=1 to nv         % frabrique de bitmaps...
  gr.bitmap.scale scbmp, cr[c], la, lv
  gr.bitmap.delete cr[c]
  gr.bitmap.create tmp, lv, lv   % bitmap carré : le véhicule pivotera dedans.
  gr.bitmap.drawinto.start tmp
  gr.bitmap.draw nul, scbmp, (lv-la)/2, 0
  gr.bitmap.drawinto.end
  car[c,4] =5   % pas (vitesse)
  car[c,3] =30  % cap (angle) actuel
  car[c,6] =30  % cap à obtenir en cas de virage...
  gr.rotate.start car[c,3], 130*c+lv/2, scy-lv-20+lv/2, car[c,2]  % pointeur de rotation
    gr.bitmap.draw car[c,1], tmp, 130*c, scy-lv-20  % pointeur de bitmap
  gr.rotate.end
next
! car[n,5] = l'action en cours :
!   0 = arrêtée
!   1 = avance tout droit suivant le cap actuel car[c,3].
!   2 = tourne à droite
!   3 = tourne à gauche

gr.text.size 32
gr.text.draw mess,10,50,""

gr.line drt, 0,0,0,0   % pour montrer le nouveau cap !?

dl =int(lv/2)

DO           % --------- new -----------
  new =0
  cv  =0   % véhicule en cours.
  for v=1 to nv       % init vehicles positions
    car[v,3] =30  :  car[v,6] =30  :  car[v,5] =0
    gr.modify car[v,1], "x",130*v, "y",scy-lv-20
    gr.modify car[v,2], "angle",car[v,3], "x",130*v+dl, "y",scy-lv-20+dl
    gr.get.position car[v,1], vx, vy   % position sur la grille
    tx =vx/lv+1  :  ty =vy/lv+1  :  t[tx,ty] =v  :  car[v,7] =tx  :  car[v,8] =ty
  next
  
  do        % --------- boucle principale -----------
    
    gr.touch touched,x,y
    if !background() then gr.render
    if quit | new then D_U.break
    
    if touched
      x/=sx  : y/=sy
      ! to select the car :
      gr.modify curs,"left",x,"top",y,"right",x+1,"bottom",y+1  :gr.render
      for n=1 to nv
        if gr_collision(curs,car[n,1]) then f_n.break
      next
      
      if n<nv+1     % une auto touchée : avance ou stoppe.
        if car[n,5] =0 then car[n,5] =1 else car[n,5] =0
        cv =n
      else
        if cv    % calculer le nouveau cap pour cv (l'auto en cours):  / x,y
          gr.get.position car[cv,1], vx, vy
          vx+=dl  :  vy+=dl
          d   =HYPOT((x-vx),(y-vy))       % distance between finger & car
          cap =int(todegrees(acos((x-vx)/d)))  % angle
          if y>vy then cap =360-cap
          car[cv,6] =-cap+90
          
          gr.modify drt, "x1", x, "y1", y, "x2", vx, "y2", vy   :gr.show drt
          
          car[cv,3] =car[cv,6]
          
          gr.modify car[cv,2], "angle", car[cv,3]
          
          ! et définir la nouvelle valeur de car[n,5] : gauche, droite, tout droit.
          car[cv,5] =1   % pour le moment...!
          
          
       !   gr.modify mess, "text", "Cap "+int$(cap)+"°    car[cv,6] ="+int$(abs(car[cv,6]-90))
                    
        endif
      endif
    endif
    
    gr.touch touched,x,y          % just for test
    if !touched then gr.hide drt
    
    for n=1 to nv       % pour chaque véhicule en mouvement.
      if car[n,5]
        if car[n,5]=2 & car[n,6]       % tourne à droite progressivement (ex: 10°)
        ! car[cv,3]+=10 :if car[cv,3]>360 then car[cv,3]=0  % jusqu'à atteindre la valeur car[cv,6]
        ! gr.modify car[cv,2], "angle", car[cv,3]           % car[n,5] passe alors à 1.
       
        elseif car[n,5]=3 & car[n,6]   % tourne à gauche progressivement
        ! car[cv,3]-=10 :if car[cv,3]<0 then car[cv,3]=360  % jusqu'à atteindre la valeur car[cv,6]
        ! gr.modify car[cv,2], "angle", car[cv,3]           % car[n,5] passe alors à 1.
        
        endif
        
          % ou bien tout droit suivant le cap car[n,3]
          
        gr.get.position car[n,1], vx, vy   % pour contrôle
        tx =vx/lv+1  :  ty =vy/lv+1
        if car[n,7]<>tx | car[n,8]<>ty     % maj terrain
          t[tx,ty] =n  :  t[car[n,7],car[n,8]] =0
          car[n,7] =tx :  car[n,8] =ty
        endif
        
        dx =cos(toradians(car[n,3]-90))*car[n,4]
        dy =sin(toradians(car[n,3]-90))*car[n,4]
        
        if vx+(dx*5)<scx-lv & vx+(dx*5)>0 & vy+(dy*5)<scy-lv & vy+(dy*5)>0  % ne sort pas
        
          cap =abs(car[n,3]-90)-112.5 : cap =cap+360*(cap<0)
          di =8-abs(int(cap/45)) %:?cap,di
          
          vix =tx+diX[di] : viy =ty+diY[di]
          
          if vix & viy & vix<mx+1 & viy<my+1
            if !t[vix,viy]
              gr.move car[n,1], dx, dy
              gr.move car[n,2], dx, dy
            else
              car[n,5] =0  % pour le moment : arrêt.
            endif
          endif
        else
          car[n,5] =0  % pour le moment : arrêt.
          
        endif
      endif
    next
    
    gr.modify mess, "text", "Cap "+int$(cap)+"°    car[cv,6] ="+int$(di)

  until new
UNTIL quit         % --------- exit -----------
wakelock 5

END

OnBackKey:
  Dialog.message win$,"       What do you want ?", ok, " Exit ", " New Game ", " Cancel "
  new  =(ok=1 | ok=2) : quit =(ok=1)
back.resume