3D : deplacement latéral(type FPS)

Bonjour,

Ce code est en cours de développement, mais il fonctionne très bien comme ça.
La souris n'est pas prise en compte, juste les touches fléchées pour se déplacer, et ZSQD pour la vue camera.

Code:: ' =====================================================================
'
' la vue camera est pilotable avec Z S Q D
' la camera est pilotable avec les touches fléchées
'
' Silverman, mai 2015
'
' =====================================================================

' variables pour tracer le quadrillage
dim maxi,nb_case,taille_case,i

' variables pour positionner la caméra
dim cam_posX,cam_posY,cam_posZ,vitesse_deplacement,ajuste_vitesse

' variables pour la visée camera
dim longitude,latitude
dim inc_longitude,inc_latitude,dec_longitude,dec_latitude
dim cam_vecteurX,cam_vecteurY,cam_vecteurZ

' variables pour précalculer ces valeurs:
dim cosinus_longitude,sinus_longitude,cosinus_latitude,sinus_latitude

' variables pour le clavier
dim k_dwn,k_up,touche,haut,bas,gauche,droite

' label la pour boucle infinie du jeu
label MAIN,deplacement,touche_en_bas,touche_en_haut

' vitesse de déplacement de la camera
vitesse_deplacement=3

' position initiale de la caméra
longitude=0 :' la camera regarde l'infini sur l'axe des +X
latitude=0 :' la vue camera est paralèlle au sol
cam_posX=0
cam_posY=5
cam_posZ=0

' taille maximale du quadrillage
maxi=800

' nombre de cases sur X ou Y
nb_case=100

' taille d'une case
taille_case=int(maxi/nb_case)

' création de l'univers 3D
' full_space 0
left 0,400
scene3D 1:full_space 1:color 1,0,0,0
axes_show

' ===========================================================
' on trace un quadrillage dans le plan XZ pour simuler le sol
' rappel : le plan XZ est un plan horizontal, c'est le "sol"
' les plans XY et YZ sont verticaux
'
' XZ : longitude
' XY , YZ : latitude
' ===========================================================

' tracé des lignes parallèles à l'axe X
for i=0 to nb_case
3d_line i+3, 0, 0, i*taille_case
3d_line i+3, nb_case*taille_case, 0, i*taille_case
3d_line_width i+3,1
3d_color i+3,192,192,0
next i

' tracé des lignes parallèles à l'axe Z
for i=0 to nb_case
3d_line i+nb_case+4, i*taille_case, 0, 0
3d_line i+nb_case+4, i*taille_case, 0, nb_case*taille_case
3d_line_width i+nb_case+4,1
3d_color i+nb_case+4,192,192,0
next i

' point de visée de la camera(sphere blanche)
3d_sphere 501,0.01 : 3d_color 501,255,255,255

' des repères sur la carte
3d_cube 502,taille_case*2 :' cube rouge sur l'axe des +X
3d_color 502,255,0,0
3d_position 502,800,taille_case,0

3d_cube 503,taille_case*2 :' cube vert sur l'axe des +Y
3d_color 503,0,255,0
3d_position 503,0,800,0

3d_cube 504,taille_case*2 :' cube bleu sur l'axe des +Z
3d_color 504,0,0,255
3d_position 504,0,taille_case,800

cam_position cam_posX, cam_posY, cam_posZ

' position de la lumière
light_position 800,4,800

' un form pour le débug
form 99
2d_target_is 99
print_target_is 99

' gère le déplacement
timer 500
timer_interval 500,20
on_timer 500,MAIN

on_key_down 0,touche_en_bas
on_key_up 0,touche_en_haut

set_focus 0

END
MAIN:
timer_off 500

   gosub deplacement

   ' matérialise le point de visée
   3d_position 501,cam_posX + cam_vecteurX, cam_posY + cam_vecteurY, cam_posZ + cam_vecteurZ

   ' debug
   print_locate 0,0
   cls
   print "Vitesse= ";vitesse_deplacement*ajuste_vitesse
   print
   print "Longitude= ";longitude
   print "Latitude= ";latitude
   print
   print "Position_X= ";cam_posX
   print "Position_Y= ";cam_posY
   print "Position_Z= ";cam_posZ
   print
   print "Vecteur_X= ";cam_vecteurX
   print "Vecteur_Y= ";cam_vecteurY
   print "Vecteur_Z= ";cam_vecteurZ

timer_on 500
RETURN

deplacement:

   ' NOTE:
   ' le clavier est géré par les évènements on-key_down/on_key_up

   ' 1 deg=pi/180 rad = 0.01745329252

   ' en Panoramic, l'axe Z est inversé! Donc pour haut: cam_posZ=cam_posZ+(... devient cam_posZ=cam_posZ-(...
   ' et bas: cam_posZ=cam_posZ-(... devient cam_posZ=cam_posZ+(...
   '
   ' une petite optimisation pour le déplacement gauche/droite, normalement on aurait:
   ' if gauche=1 then cam_posZ=cam_posZ-(vitesse_deplacement*sin((90+longitude)*0.01745329252)) : cam_posX=cam_posX+(vitesse_deplacement*cos((90+longitude)*0.01745329252))
   ' if droite=1 then cam_posZ=cam_posZ+(vitesse_deplacement*sin((90+longitude)*0.01745329252)) : cam_posX=cam_posX-(vitesse_deplacement*cos((90+longitude)*0.01745329252))
   ' mais on va simplifier avec: cos(x+90)=-sin(x) et sin(x+90)=cos(x)

   ' visée de la camera
   if inc_latitude=1 then latitude=latitude+2
   if dec_latitude=1 then latitude=latitude-2
   if inc_longitude=1 then longitude=wrap_value(longitude+2)
   if dec_longitude=1 then longitude=wrap_value(longitude-2)

   ' limite le champs visuel entre -90 et +90 degrés
   if latitude<-90
   latitude=-89.9
   else
   if latitude>90 then latitude=89.9
   end_if

   ' précalcule les sinus/cosinus
   cosinus_longitude=cos(longitude*0.01745329252)
   sinus_longitude=sin(longitude*0.01745329252)
   cosinus_latitude=cos(latitude*0.01745329252)
   sinus_latitude=sin(latitude*0.01745329252)

   ' ajuste la vitesse si déplacement en biais
   ajuste_vitesse=1
   if (haut=1 or bas=1) and (gauche=1 or droite=1) then ajuste_vitesse=0.70710678119

   ' déplacement avant/arrière
   if haut=1
   cam_posZ=cam_posZ-(vitesse_deplacement*sinus_longitude*ajuste_vitesse) : cam_posX=cam_posX+(vitesse_deplacement*cosinus_longitude*ajuste_vitesse)
   else
   if bas=1 then cam_posZ=cam_posZ+(vitesse_deplacement*sinus_longitude*ajuste_vitesse) : cam_posX=cam_posX-(vitesse_deplacement*cosinus_longitude*ajuste_vitesse)
   end_if
   ' déplacement gauche/droite
   if gauche=1
   cam_posZ=cam_posZ-(vitesse_deplacement*cosinus_longitude*ajuste_vitesse) : cam_posX=cam_posX-(vitesse_deplacement*sinus_longitude*ajuste_vitesse)
   else
   if droite=1 then cam_posZ=cam_posZ+(vitesse_deplacement*cosinus_longitude*ajuste_vitesse) : cam_posX=cam_posX+(vitesse_deplacement*sinus_longitude*ajuste_vitesse)
   end_if

   ' direction du déplacement: vers le point de visée( = vecteur de la camera)
   cam_vecteurX=cosinus_longitude*cosinus_latitude
   cam_vecteurZ=-1*sinus_longitude*cosinus_latitude :' rappel: l'axe Z est inversé, donc on multiplie par -1
   cam_vecteurY=sinus_latitude

   ' placement de la camera
   cam_position cam_posX, cam_posY, cam_posZ
   point_position cam_posX + cam_vecteurX, cam_posY + cam_vecteurY, cam_posZ + cam_vecteurZ :' la camera se dirige dans cette direction

RETURN

touche_en_bas:
   k_dwn=key_down_code
   ' UP DOWN LEFT RIGHT pour diriger la camera
   touche=38 : if k_dwn=touche then haut=1
   touche=40 : if k_dwn=touche then bas=1
   touche=37 : if k_dwn=touche then gauche=1
   touche=39 : if k_dwn=touche then droite=1

   ' Z S Q D diriger la vue camera
   touche=90 : if k_dwn=touche then inc_latitude=1
   touche=83 : if k_dwn=touche then dec_latitude=1
   touche=81 : if k_dwn=touche then inc_longitude=1
   touche=68 : if k_dwn=touche then dec_longitude=1
RETURN

touche_en_haut:
   k_up=key_up_code
   ' UP DOWN LEFT RIGHT
   touche=38 : if k_up=touche then haut=0
   touche=40 : if k_up=touche then bas=0
   touche=37 : if k_up=touche then gauche=0
   touche=39 : if k_up=touche then droite=0

   ' Z S Q D
   touche=90 : if k_up=touche then inc_latitude=0
   touche=83 : if k_up=touche then dec_latitude=0
   touche=81 : if k_up=touche then inc_longitude=0
   touche=68 : if k_up=touche then dec_longitude=0
RETURN

Je regarde ca attentivement ce soir.

Limite je pense que l'on devrais avoir un topic sur le forum avec comme intituler Développement 3D. Uniquement pour ce retrouver dans tout le contenu de panoramic.

Dans ma logique il y aurai une partie développement application et une partie développement 2D

On proposerai des bout de code en rapport avec la partie?

On laisse la partie "les jeux fait avec panoramic" comprenant les jeux 3D, 2D etc car un jeu reste un jeu, qu'importe la méthode utilisé.

Évidement on garderai le reste du forum, je trouve juste que le contenu est la, mais que cela pourrai etre mieu organiser ?

Vous pouvez aussi synthétiser vos discussion dans un article. Actuellement, par exemple, il y a déjà 3 articles sur la 3D dans le mag

je suis surpris, Tu est vraiment fort !
Tu a penser à "ajuste_vitesse" pour les déplacement en biais, comment fait tu le calcule pour savoir que c'est cette valeur ? ajuste_vitesse=0.70710678119

Ou je peux apprendre ces histoire de vecteur, je suis très intéresser. Je vais déjà essayer par ton code, mais le mieux reste un cours, ou un tuto.

c'est quoi cela ?

Code::    cosinus_longitude=cos(longitude*0.01745329252)
   sinus_longitude=sin(longitude*0.01745329252)
   cosinus_latitude=cos(latitude*0.01745329252)
   sinus_latitude=sin(latitude*0.01745329252)

ça c'est quoi aussi :

Code::    ' visée de la camera
   if inc_latitude=1 then latitude=latitude+2
   if dec_latitude=1 then latitude=latitude-2
   if inc_longitude=1 then longitude=wrap_value(longitude+2)
   if dec_longitude=1 then longitude=wrap_value(longitude-2)

merci

Jimx78 a posé une question à silverman et comme ce dernier est momentanément absent, je propose ma réponse tout en m’excusant auprès de silverman.

0.70710678119 c’est la racine carrée de ½

Code:: cosinus_longitude=cos(longitude*0.01745329252)
   sinus_longitude=sin(longitude*0.01745329252)
   cosinus_latitude=cos(latitude*0.01745329252)
   sinus_latitude=sin(latitude*0.01745329252)

C’est pour calculer une seule fois pour toute des valeurs qui seront utilisées au cours du programme.
Les noms donnés à ces variables sont parfaitement explicites.
La constante 0.01745329252 qui vaut pi/180 sert à convertir les angles (donnés en degrés) en radians.
Il ne faut pas oublier que les lignes trigonométriques (sin, cos, tan, etc.) doivent être exprimés en radians

NB: silverman peut fournir des plus amples informations.

Merci !

Ajuste_vitesse est un facteur multiplicatif initialisé au départ à 1 : donc c’est neutre.
Ce facteur n’est pas modifié pour les mouvements horizontaux et verticaux (flèche gauche/droite et haut/bas)
Mais si on fait un déplacement composé avec deux touches en simultané (par exemple haut ET droite), le déplacement doit se faire en diagonale : c’est la résultante de deux vecteurs en haut et à droite qui vaut la diagonale d’un carré unité ou l’hypoténuse d’un triangle rectangle dont les côtés valent 1. Pythagore nous a enseigné que cette valeur vaut la racine carré de 1² + 1² qui vaut justement 1.41421356…
Silverman en a pris la moitié soit 0.7071…

@ Silverman

Corrige moi si je me trompe. Laughing

je connais Pythagore mais j'ai pas penser à l'utiliser. Dans un triangle rectangle, le carré de l'hypoténuse est égale à la somme des carrés des 2 autres cotés.

La différence est infime (0.7 au lieu de 1) mais je suis sur que tout les jeux ne l'on pas incorporer.
Des fois, en se déplacent en diagonal dans les jeux, on est plus rapide^^

Bref merci encore !

~~Ou je peux trouver des cours de vecteur svp ?~~

http://openclassrooms.com/courses/les-shaders-en-glsl/les-vecteurs-3

En tout cas, ce moteur fonctionne très bien. J'espère que tu as déjà des idées d'applications Wink

@Silverman
je sais que c'est en développement et je te remercie du partage
La touche haut + droite + S bloque la vue, on peux plus descendre, cela doit être une question de priorité dans le code je pense, en tout cas c'est très instructif. Je vais poster bientôt mon code, mais je veux déjà réussir a faire mon pas à gauche et pas à droite

papydall a écrit:: ...je propose ma réponse tout en m’excusant auprès de silverman.

Pas de pb papydall! cheers

Citation :: Silverman en a pris la moitié soit 0.7071

Pas exactement; les déplacements avant/arriere/gauche/droite valent 1 unité, tandis que le déplacement de biais a une longueur de 1.414... unité. Du coup, pour revenir à une valeur de 1, je le multiplie par son inverse qui est 0.7071... . Et donc on se déplace d'une unité dans n'importe quelle direction. sunny

@jimx78
Cosinus_longitude,etc... C'est pour un (petit) gain de temps lors des calculs, plutôt que d'appeler plusieurs fois les fonctions trigonométriques, je les stocke pour les utiliser ensuite.
Pour les variables latitude/longitude, ce sont elles qui oriente la camera;
la longitude c'est par rapport au plan XZ(le sol)
la latitude c'est par rapport aux plans YX et YZ(la hauteur)

Citation :: Des fois, en se déplacent en diagonal dans les jeux, on est plus rapide^^

J'avais remarqué ça aussi, c'est cela qui m'a donné l'idée de la variable ajuste_vitesse

Citation :: je connais Pythagore mais j'ai pas penser à l'utiliser.

Si tu veux créer des déplacements global/local(et pas des position!) il va falloir t'y mettre. Very Happy

Papydall à créé un tuto. de trigonométrie sur les tranformation de coordonnées sphérique--->coordonnées cartésiennes, fait une recherche, ça devrait t'aider.

Jicehel a écrit:: En tout cas, ce moteur fonctionne très bien. J'espère que tu as déjà des idées d'applications Wink

Euh, non, c'est juste pour apporter une pierre à l'édifice. santa

haut + droit + S ?
Je n'ai pas ce pb, Z ne rétabli pas la vue?

EDIT:
ah oui, j'ai bloqué la vue(variable latitude) de +89.9 deg(le ciel) à -89.9 deg(les pieds), au delà, la caméra fait un demi-tour(je n'ai pas encore étudié ce pb)
N'oublie pas que c'est un déplacement de type FPS!

EDIT2:
Je viens d'avoir un éclair de lucidité: les positions locales/globales dont tu parles, c'est pas quand les objets possèdent des membres?
Chaque membre enfant est positionné par rapport au membre parent(donc ils ont un positionnement local), membre parent lui même positionné dans le monde 3D(positionnement global puisque c'est par rapport au monde). C'est ça?

silverman a écrit:: Papydall à créé un tuto. de trigonométrie sur les tranformation de coordonnées sphérique--->coordonnées cartésiennes, fait une recherche, ça devrait t'aider.

Le tuto en question c'est ici
Pour la 2D, c’est là
Pour une rotation d’une figure autour de l’origine, c’est plutôt ici

Une intéressante source d'infos : ici

Merci pour les liens Papydall

Silverman,
Non je ne parler pas des "membres",
Ceux la je les est déjà cerner avec cette exemple :

https://panoramic.1fr1.net/t1540-minipelle

Je ne connaissait pas les vecteurs, ton exemple m'a éclairer.

Il y a bien a bloquage quand tu fait haut enfoncer + droit enfoncer + S (dans cette ordre et les 3 touches enfoncer)
Cela bloc la hauteur de vue : S lâcher ou pas ne change plus rien.

Pour parler des 89,9 que tu a mis, c'est normale, car il met la caméra paralele au sol, est quand il regarde tout en haut, il a plus de repère. Je pense que ca expliquerai pourquoi gta ne pouvais pas faire des looping avec des avions a l'époque ?

Bref merci à vous

@Silverman

Cela fait maintenant quelques petite semaine que je reprogramme en panormaic.

Je te propose un code qui utilise la logique pour me déplacer dans ma scene3D. J'ai pas de vecteur, c'est 3D_move qui fait tout.

Donc c'est moins glorieux que toi, c'est sur, mais cela fonctionne et je viens tout juste de finir ;D

Imagine que la position de l'une des teapot (bleu ou rouge) représente la position de la camera et que la teapot verte sois la position du point de visée.

Je vais publier un dossier ce soir d'un projet plus complet avec une petite surprise.

Code:: label touche_enfoncer , touche_lacher , programme , quitter_programme

dim demi_fenetre_x% , demi_fenetre_y% , souris_sensibiliter , vitesse
dim touche_echap , touche_haut , touche_droit , touche_gauche , touche_bas , dll_souris
dim camera_rotation_x , camera_rotation_y
' Form 0========================================================================

on_key_down 0,touche_enfoncer
on_key_up 0,touche_lacher
' full_space 0
width 0,screen_x
height 0,screen_y
border_hide 0

' ==============================================================================

scene3D 2 : color 2,0,145,255 : full_space 2 : ' cursor_hide 2

3d_teapot 1 : 3d_color 1,255,0,0
3d_teapot 2 : 3d_color 2,0,0,255
' 3d_sphere 3,0.05 : 3d_color 3,0,0,0 : 3d_load_texture 3,"Materiaux\autre\viseur.bmp"
3d_teapot 3 : 3d_color 3,0,255,0

3d_text 5,""

souris_sensibiliter=0.4
vitesse=0.02

dll_on "user32"
demi_fenetre_x%=width(2)/2
demi_fenetre_y%=height(2)/2
timer 1 : timer_interval 1,1 : on_timer 1,programme
END : ' ========================================================================
quitter_programme:
timer_off_all
dll_off
wait 1
terminate
return

touche_enfoncer:
if key_down_code = 27 then touche_echap=1
if key_down_code = 37 then touche_gauche=1
if key_down_code = 38 then touche_haut=1
if key_down_code = 39 then touche_droit=1
if key_down_code = 40 then touche_bas=1
return

touche_lacher:
if key_up_code = 27 then touche_echap=0
if key_up_code = 37 then touche_gauche=0
if key_up_code = 38 then touche_haut=0
if key_up_code = 39 then touche_droit=0
if key_up_code = 40 then touche_bas=0
return

programme:
if touche_echap=1 then goto quitter_programme

camera_rotation_x=o3d_y_rotate(2)+(demi_fenetre_x%-mouse_x_position(2))*souris_sensibiliter
camera_rotation_y=camera_rotation_y+(demi_fenetre_y%-mouse_y_position(2))*souris_sensibiliter

3d_y_rotate 2,camera_rotation_x : ' Le cube 2 (visé) prend la rotation de la variable

if touche_haut=1
3d_y_rotate 1,camera_rotation_x
end_if

if touche_bas=1
3d_y_rotate 1,camera_rotation_x-180
end_if

if touche_gauche=1
3d_y_rotate 1,camera_rotation_x+90
end_if

if touche_droit=1
3d_y_rotate 1,camera_rotation_x-90
end_if

if touche_haut=1 and touche_gauche=1
3d_y_rotate 1,camera_rotation_x+45
end_if

if touche_haut=1 and touche_droit=1
3d_y_rotate 1,camera_rotation_x-45
end_if

if touche_bas=1 and touche_gauche=1
3d_y_rotate 1,camera_rotation_x+135
end_if

if touche_bas=1 and touche_droit=1
3d_y_rotate 1,camera_rotation_x-135
end_if

if touche_haut=1 or touche_bas=1 or touche_gauche=1 or touche_droit=1
3d_move 1,vitesse
end_if

3d_position 2,o3d_x_position(1),o3d_y_position(1),o3d_z_position(1)

if camera_rotation_y > 90 then camera_rotation_y = 89.9
if camera_rotation_y < -90 then camera_rotation_y = -89.9

3d_x_rotate 3,0
3d_y_rotate 3,0

3d_y_rotate 3,camera_rotation_x
3d_x_rotate 3,camera_rotation_y

3d_position 3,o3d_x_position(2),o3d_y_position(2),o3d_z_position(2)
3d_move 3,1

3d_text_change 5,str$(camera_rotation_y)

dll_souris = dll_call2("SetCursorPos",(demi_fenetre_x%),(demi_fenetre_y%))

return

» Déplacement de plusieurs personnages silmultanéments
» Déplacement de deux sprites
» Déterminer le type de clavier
» quelle force selon un déplacement [R]
» Un menu déroulant type "Side Bar"