Discussion :

[haypo]

Salut,

Je développe un jeu (Wormux, clone libre de Worms "toute contribution est bienvue ..."), et je suis en train de me demander comment implémenter le moteur physique.

Pour l'instant, un objet physique a une position, un état (PRET, TOMBE, BOUGE, etc.), l'heure du début du dernier mouvement et l'origine du mouvement.

A chaque itération du jeu (c'est pas du temps réel, alors je calcule la position de l'objet selon le temps), je calcule les nouvelles coordonnées à partir du point de départ.

Avec ça, j'ai la gravité : si l'objet est dans le vide, on le met en état "TOMBE" et sauvegarde de la position et de l'heure de départ du mouvement.

Pb: C'est pas évolutif.
---
J'ai alors pensé d'autres variables :
- position actuelle
- heure du début du mouvement
- position du début du mouvement
- accélération (en X et Y)
- force initiale (en X et Y)

Avec ça je peux ajouter toutes les forces qu je veux ;-)

D'autres proposition ?
---
Mouvements possibles :
- Saut (force initale ayant une valeur et un angle)
- Gravité (accélération valant G)
- Souffle d'une explosion (et donc frottement du sol)
- Un ver pousse un autre (coup de batte de baseball :-P)

@+ Haypo (qui doute d'avoir été très clair, mais c'est dur de pas écrire de code C++ )

[Sub0]

Wouaw! Superbe projet Haypo!

Je n'ai pas encore bien réfléchis à la question, mais je voudrais déjà savoir avec quel(s) compilateur(s) comptes-tu réaliser ce jeu?
En ce qui concerne les actions, je crois qu'il serait judicieux de penser à un algo de programmation évolutif. Ton idée de départ est plutôt intérressante, je crois qu'il faut continuer dans ce sens. Il faudrait, pour bien faire, lister tous les paramètres nécessaires à toutes les actions, et créer des actions à partir de cette liste... Suivant la combinaison des paramètres sélectionnés, et la valeur attribuée à chacun, tu crées une action (modulable). Par exemple, une action possèdera une ou des animations (forcément), une position & timers de départ, et de fin, la direction, les effets (vent, gravité, colision), etc... Vaste projet en perspective! En résumé, ce qui serait vraiment intérressant, c'est de faire un système de création d'action, qui pourrait-être compiler sous forme d'unité ou d'objet... Mais bon, je vois ça compliqué à réaliser.

C'est dommage, je ne suis pas super libre en ce moment, car j'ai moi-même des projets importants à terminer. Mais je suis très curieux de voir comment tu vas réaliser cet algo!

Bon courage!

[haypo]

Wouaw! Superbe projet Haypo!

Je suis pas seul, je bosse avec Lawrence ;-) Et puis le jeu est jouable est fonctionnel (déjà deux armes !!!).

Je n'ai pas encore bien réfléchis à la question, mais je voudrais déjà savoir avec quel(s) compilateur(s) comptes-tu réaliser ce jeu?

C++, en faisant de la belle POO. J'ai une classe mère "ObjetPhysique", puis des fonctions qui prennent en paramètre des objets de ce type.

Vaste projet en perspective! En résumé, ce qui serait vraiment intérressant, c'est de faire un système de création d'action, qui pourrait-être compiler sous forme d'unité ou d'objet...

Moi je pensais simplement à des méthodes du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
obj.AjouteForce (10, 3);
obj.AjouteAcceleration (0, -1.7);

Lorsqu'on ajoute une force, il prend le temps actuel et calcule la vitesse actuelle (une chtite dérivée de rien du tout, (M(t)-M(t+h))/h).

@+ Haypo
PS: Sub0 wins, fatality :-) J'adoooore ce jeu (le premier).

[Sub0]

Arf! Je ne suis jamais arrivé à chopper le reptile... et toi?

[delphi-fan]

Juste une idée toute bête :
1- Tu déclares dans ta classe d'objet des propriétés et des méthodes correspondant aux paramètres que tu veux gérer (position initiale, accélération ...)
2- et tu ajoutes aussi des variables booléennes (Oui/Non) pour indiquer par exemple si l'objet est dans une phase de chute ou pas. on peut imaginer aussi de combiner ces divers flags dans une matrice d'état au sein de ta classe pour chaque objet, ou alors d'utiliser un seul tableau de matrices annexe gérant alors les flags de tous les objets...

A+

[charly]

j'aurais eventuellement une aproche differentes :
Tu definie un vecteur courant de mouvemment ( si immobile v(0,0,0) )
Tu lui apliques les lois de newton , c est asser facile a metre en oeuvre et le resultat sera probant

[haypo]

j'aurais eventuellement une aproche differentes :
Tu definie un vecteur courant de mouvemment ( si immobile v(0,0,0) )
Tu lui apliques les lois de newton , c est asser facile a metre en oeuvre et le resultat sera probant

Un vecteur qui contient quoi ? La vitesse ? Et c'est quoi ta loi de newton ? Moi je connais la force gravitationnelle : accélération en y=-g ... Ce qui donnerait :

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
class ObjetPhysique
{
  typedef struct { double x,y; } Position; // je suis en 2D Charly :D
// [EDIT 14déc. 18h34 (GMT-5 :-P)
  typedef Position Vecteur; // x,y=normes si on veut
  Vecteur vect_force, vect_acceleration;
// [/EDIT]
  Position pos, pos_dernier_mouvement;
  Temps temps_dernier_mouvement;
  Etat etat;
   ...
};  
 
ObjetPhysique::ObjetPhysique()
{
  // Initialise les données
  RAZ_Force();
  etat = PRET;
}
 
void ObjetPhysique::RAZ_Force ()
{
  vect_force.x = vect_force.y = 0;
  vect_acceleration.x = vect_acceleration.y = 0;
}
 
void ObjetPhysique::DebutChute ()
{
  etat = CHUTE;
  temps_dernier_mouvement = <lecture de l'heure>;
  vect_acceleration.y -= GRAVITE;
}
 
void ObjetPhysique::DebutMouvement (double force_init, double angle)
{
  etat = BOUGE;
  double force_x = force_init * cos(angle);
  double force_y = force_init * sin(angle);
  vect_force.x += force_x;
  vect_force.y += force_y;
  temps_dernier_mouvement = <lecture de l'heure>;
  pos_dernier_mouvement.x = pos.x;
  pos_dernier_mouvement.y = pos.y;
}
 
void ObjetPhysique::FinMouvement ()
{
  etat = PRET;
  RAZ_Force();
}
 
void ObjetPhysique::MoteurPhysique()
{
  if (etat == PRET) return;
  double temps = <heure actuelle> - temps_dernier_mouvement); // en secondes
  double x, y;
  x = pos_dernier_mouvement.x;
  y = pos_dernier_mouvement.y;
  x += vect_force.x*temps;
  y += vect_force.y*temps;
  temps *= temps; // t=t^2
  x += vect_acceleration.x*temps;
  y += vect_acceleration.x*temps;
  pos.x = (int)x;
  pos.y = (int)y;
  if (Impact()) FinMouvement();
}

Désolé pour ceux qu'aiment pas le C++, mais c'est plus lisible qu'un algo pour moi.

Là dessus on ajoute facilement le vent ou le souffle d'une explosion, non ?

@+ Haypo

[Sub0]

D'après mes cours de physique, (oula c'est loin tout ça), je crois me souvenir que l'accélération de la gravité est de 9,81m/s², et un peu plus fort à l'équateur qu'aux pôles (ou l'inverse). Bref, tout ça pour dire que l'unité de l'accélération est une distance par un temps au carré. La loi de Newton permet de convertir une Force en poids (masse) en tenant compte de ce coeficient de gravité: F=M.g
-> Pour être sûr, et avoir la définition exacte du Newton, faudra vérifier dans le dico...

D'après mes souvenirs des cours, ya aussi la direction à prendre en compte dans une force, je crois que c'est ce qu'on appel le vecteur (pas persuadé). Un objet qui tombe, chutera de plus en plus vite, à raison de 9,8m/s toutes les secondes, et ceci dans le vide normalement, car on pourrait aussi tenir compte de la pression atmosphérique et le freinage de l'air. La chute libre sature en vitesse vers 170 km/h je crois.

-> Mais bon, ça reste qu'un jeu de worms, à moins que tu comptes les faire sauter d'un avion! ...... à+

[charly]

Bon je vais etre plus explicite , vous vous rappellez peut etre ( ou peut etre pas ) de vos cours de physique de premiére et des trois lois de newton

1er :
Dans un référentiel galiléen , lorsqu'un solide est isolé ou pseudo-isolé ( résultante des forces nulle), son centre d'inertie G est :

soit au repos , G est initialement immobile.
soit animé d'un mouvement rectiligne uniforme

2 eme :
Dans un référentiel galiléen , la somme des forces extérieures appliquéesà un solide est égale au produit de la masse du solide par l'accélération aG de son centre d'inertie G :

3 eme
Lorsqu'un corps A exerce sur un corps B une action mécanique représentée par une force F(A/B) , le corps B exerce sur A une action mécanique représentée par une force F(B/A) . Ces deux forces ont même direction , sens contraire et même norme.

la premiere loi est le principe de l'inertie c'est celle ci qui va nous interresser .
Pour etre plus comprehensible je vais prendre le cas d'un obus dans worms : a cette obus on lui assignera un vecteur cad , une direction , une norme et un sens !

Dans ton programme , tu vas crer un timer qui tous les X ms apliquera a la position de l'obus le vecteur et en plus lui ajoutera diverse reaction de l environement ( reaction de l'air , gravitation , reaction du sol )
pour etre encors plus explicite ( et je sais que je le suis raremment ) voici un exemple ( en pascal ):

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
 
  type
      Tpoint   : array[0..1]of real;   
      Tvector : Tpoint ;
      Tobus   : Tpoint;
 
 procedure Update; // procedure qui rafraichis les position a intervalle regulier 
    begin 
       Tobus[0]:=tobus[0]+Tvector[0];  // aplication du vecteur a l obus
       Tobus[1]:=tobus[1]+Tvector[1];
        // def du nouveu vecteur 
      Tvector[0] := Tvector[0]*AirResist ;// airresist est une constante 
      Tvector[1] := Tvector[1]*AirResist ;// qui definie la resistance de l'air , en bidouillant tu peux la faire proportionnelle a la norme du vecteur 
elle doit toujours etre compris entre 0 et 1 bien sur ; 
      Tvector[1]:=Tvector[1]-Gravity ; // aplication de la gravites , qui elle  est tjs constante , par contre selon la force de la gravites tu augmentes ou tu deminues ,
   end;

je vois les choses comme sa , mais je ne sais pas si sa t avancera beaucoup

[haypo]

Ben justement j'hésite entre deux systèmes :
- "Asynchrome" : formule pour calculer la position d'un point qu'importe le temps passé depuis le dernier calcul
- "Synchrome" : mise à jour toutes les X ms

Pb: Ni Windows, ni Linux ne peut garantir le délai "X ms" ... Mais bon, c'est un jeu. Pas un moteur de régulation de température d'un réacteur nucléaire (qui sont encore tous en analogique selon un ami :-)).

Dans le cas du système asynchrome je bute un peu sur le point "ajout d'un force" alors qu'une autre force est déjà "active". Ex: Un ver tombe, et tout à coup ouvre son parachute. Ou alors, il saute, puis il y a un souffle d'une explosion.

@+ Haypo

[charly]

pour le systeme asynchrome , j ai resolut le probleme en deffinissant une constant : tu definie la norme de ton vecteur , en fonction du temps ecouler entre les deux , c est precis et simple a metre en aplication

[ludovic.fernandez]

C'est trés ancien pour moi, mais je pense me rappeller que des méthodes existent pour représenter des trajectoires dans l'espace (coup dans une balle par exemple). Ces méthodes simples sont :

1> Méthode d'Euler

yn+1 = yn + f(xn,yn) Dx

2> Méthode de Hun

h1 = f(xn,yn) Dx
h2 = f(xn,yn + h1) Dx
yn+1 = yn + 1/2(h1 + h2)

3> Méthode centrée

yn+2 = yn + f(xn+1,yn+1) 2Dx

4> Méthode de Runge-Kutta

Tu peux aussi les approximer mais ça devient beaucoup plus chaud puisque celà fait entrer les courbes de beziers :

1> Représentation de Hermite

x(t) = a + b t + c t2 + d t3
x'(t) = b + 2c t + 3d t2
# p0 correspond à t=0, et p3 à t=1.
p0=a; d0 =b
p3=a + b + c + d; d3 =b + 2c + 3d
x(t) = p0 + d0t + (3p3-3p0 - 2d0-d3)t2 + (2p0-2p3 +d0 + d3)t3

2> Algorithme de Casteljau

Et biensûr comme on utilise des equa.dif, tu peux représenter les lois de la dynamique (frottements..) par ceci.

[haypo]

Salut,

Ben finalement j'ai résolu mon problème moi même. J'ai fait à peu près comme dans le code donné plus faut. Pour ceux qui savoir déchiffrer le C++, on peut consulter le fichier via CVS :
obj_physique.cpp
obj_physique.h

Fonctions intéressantes :
- NouvelleForce (norme, angle) = génère une nouvelle force (RAZ du reste)
- AjouteForce(norme, angle) = ajoute une force aux forces existante. Là ça devient sympa ! J'ai fait des tests dans un tout petit programme spécifique. Et bien j'arrive à simuler le souffle d'une explosion (par exemple).
- CalculeVitesse : calcule la vitesse à l'instant présent. Utilisé par exemple pour donner une force initiale à une dynamite qu'on lache en plein vol. J'ai simplement calculer la dérivée numériquement en prenant un intervalle de temps très petit (ici 10ms), j'évule en deux points. C'est un jeu, pas de la simulation poussée non plus
- CalculeXY : calcule les coordonnées X,Y un l'instant t. Il vaut mieux que t soit supérieur ou égal à la l'heure de l'ajout de la dernière force, sinon on peut avoir de mauvaises surprises ...

Je m'amuse à lancer des dynamites en plein vol, c'est vraiment marrant La dynamite tombe plus doucement que le ver car elle est plus légère. On peut inventer de nouvelles stratégies. En plus, on s'y prenant bien on peut faire de beaux lancés ;-)

Allez @+
Victor

[Jedai]

Je m'amuse à lancer des dynamites en plein vol, c'est vraiment marrant La dynamite tombe plus doucement que le ver car elle est plus légère. On peut inventer de nouvelles stratégies. En plus, on s'y prenant bien on peut faire de beaux lancés

Hum...? Tu sais que normalement ce ne devrait pas être le cas ? Tous les objets tombent à la même vitesse dans le vide et la résistance de l'air doit faire une différence négligeable entre un ver et de la dynamite (en fait j'aurais plutôt imaginé que la dynamite tombe un peu plus vite).

Normalement, l'accélération en chute libre est égale à g (modulo la résistance de l'air bien sûr), quelle que soit la masse.

[haypo]

Normalement, l'accélération en chute libre est égale à g (modulo la résistance de l'air bien sûr), quelle que soit la masse.

Ah mince, je croyais que c'était g*masse :-/ Bon, ben je vais changer ça.

Haypo

[mat.M]

Attention ! Parce qu'un jeu vidéo c'est particulier :

des calculs complexes en virgule flottante risquent de pénaliser la vitesse d'exécution
ne pas perdre de vue la représentation physique des éléments ( personnages animés selon certains attributs physiques comme l'accélération ) , le "visuel" du jeu
Parce que un champs de vision rétreci entre 640*480 à 1024*768 , ça complique la représentation des éléments .
En d'autres termes pour représenter les personnages à l'écran , on peut être amener à complétement modifier les algorithmes de bases reposants sur des lois de physiques.
Est-ce que la simulation de lois de physiques peuvent être facilement être adaptées sur un écran ??
On peut implémenter des lois de physiques pour un calculateur qui sort des données brutes , mais pour un jeu ?