Bonjour à tous, en même temps que je créé mon jeu de courses, j´aurais besoin de faire de la physique pour les objets qui tombent. Ce sera bien sûr fait en BlitzBasic et je pourrais le distribuez si vous le voulez. Bon, pour ce qui est des notions de physique, j´ai eu le cours de physique à l´école (pas de science physique ni de chimie, seulement de la physique (j´ai 17 ans)) pour vous montrer le niveau environ, car au Québec, c´est pas la même chose qu´en Europe. J´ai appris les positions en fonctions du temps, la vitesse en fonction du temps, l´accélération en fonction du temps et pleins d´autres choses, mais je voudrais commencer par ceux-ci. J´ai appris que l´accélération gravitationnelle était de 9,8 m/s², or, cette gravitée, j´ai aucune idée de comment l´écrire dans un langage de programmation. Si vous auriez juste une idée du comment commencer, ca pourrait m´aider beaucoup.

Merci d´avance.

mm... Il faut que tu écrive ceci :

10 sv_gravity = 7;
20 Print ´gravité = 7´
30 goto 10
40 end

maxime64 -> quoi?

Enfait, ce que tu veux faire, c´est simuler la gravité, c´est ça ? L´idée la plus simple, c´est de travailler avec des vecteurs (je suppose que tu as vu ça à l´école?). je vais prendre l´exemple d´un jeux 2D, comme mario. Ou même plus simple, en 1D : imagine un jeu où tu as mario sur une plateforme. En appuyant sur un bouton, mario saute (déplacement uniquement vertical) et redescend. Réfléchissons un peu : la force de gravité l´attire en permanence vers le sol, qu´il saute ou non. Ensuite, pour toute force existe une force de réaction, de sens opposé à la force originale. Dans notre cas, nous aurons donc deux forces en présence :

-la force de gravité (Fp), agissant de haut en bas.
-la force de réaction à la force de pesanteur (Frp), agissant dans le sens opposé, et dont l´intensité est égale à la force de pesanteur.

Dans notre cas, l´intensité de la force de pesanteur est de 9.8 Newton - on pourrait l´arrondir à 10, ce serait plus simple. Nous dirons qu´a chaque frame, mario est déplacé de 10 pixels dans la direction de la force de pesanteur, soit vers le bas. Bien. Maintenant, nous avons la force Frp, qui, elle, agit dans le sens inverse, avec une intensité égale, soit aussi 10 Newton. Mario va donc se déplacer de 10 pixels contre le bas (Fp) et de 10 contre le haut (Frp), il reste donc imobile : c´est le cas de stabilité du système. Si tu veux qu´il saute uand tu appuie sur RETURN, par exemple, tu n´as qu´à faire qu´en cas d´appui sur RETURN, une autre force verticale de direction verticale et de sens de bas en haut soit incrémentée d´un certain nombre de Newton. Tu ajoutera cette valeur à la variable de position verticale (par exemple posY). Voila en gros ce qu´il te faut :

-une variable de position Y du perso.
-une variable Fp
-une variable Frp
-une variable Fverticale

Ensuite, à chaque frame, tu fais :
PosY = PosY - Fp + Frp + Fverticale
et tu affiches ton objet au bon endroit.

J´espère que tu as au moins compris l´essentiel, car j´ai fais ça de tête et j´ai peut-être oublié quelques trucs. Penses aussi au fait qu´il n´y a plus de force de réaction quand le perso ne touche plus le sol.

Allez, courage !

Lapintade, JeanYvesYves... Je vouis laisse éclaircir mes explications douteuses.

je suis presque d´accord. Sauf que tu oublie la vitesse.
10m.s-2 c´est l´acceleration de la force de pesanteur.

Dans l´idée on raisonne par tour de jeu (on discretise les forces physiques), il faut faire un bilan des forces a l´instant t: F_t = \sum F_{ti} ou les F_{ti} sont les forces qui s´appliquent sur le personnage.
ensuite il faut appliquer ces forces sur la vitesse:
V_{t} = V_{t-1} + F

finalement déplacer le personnage:
Pos_{t} = Pos_{t-1} + V_{t}
Ceci est bien sur vrai si il n´y a pas de collisions.
s´il y a une collision (si il y a un objet sur le segment [Pos_{t-1};Pos_{t}]) il faut faire quelquechose pour corriger le problème comme par exemple le coller le plus sur l´objet possible et prévoir pour le prochain tour un "effet de rebond".

Ceci n´est bien sur vrai que pour un point...

Finalement, j´ai réussi à la programmé en utilisant la formule :

acc_gravitationnel# = 9.81

(((-(0.5))*(acc_gravitationnel#)*(lt#)^2)/10000000
000000)

Le /10000000000 est simplement pour ralentir le mouvement, car c´est trop rapide sinon et le lt# est le temps depuis le début.

pour qqch de plus flexible ou les forces en jeu peuvent changer, il va te falloir passer a une version discrete d´integration ; autrement dit, mettre a jour les parametres physiques en fonction du temps ecoule depuis la derniere mise a jour.

les integrations discretes sont qq peu differente des formes classiques. Certaines sont aisees a implementer, d´autres pas du tout ; certaines sont stables, d´autres non, etc.

qq integrations numeriques classiques (tu trouveras plein de details si ca t´interesse, via google ; je note * celles un peu complexes auquelles tu n´as pas formcement envie de t´attaquer..) : Euler explicit, Euler implicit* (aka Backward Euler), Euler semi-implicit (aka NSV = Newton Strom Verlet), Verlet, Runge-Kutta* (ordres 2 et 4)

ces integrations ne sont pas stables pour des choses aussi simples qu´un champs rotationnel (du fait de la discretisation, le point considere sort de son orbite un peu plus a chaque calcul) ; si la stabilite est recherchee, il faut finasser un peu en calculant des facteurs correctifs, tels que : excedent energetique*, conservation du moment, etc.

ca sort p-e un peu du cadre de la question initiale, mais ca pourra p-e te donner des pistes pour la suite..

Merci pour les corrections, c´est vrai que j´y avais pas pensé.

J´en profite pour poster une petite règle sur les rebonds puisque le sujet a été abordé.
Cette règle est super simple : c´est celle de la réflexion de la lumière. Elle ne fonctionnne que dans les cas simples de rebonds, car elle ne tient pas compte, par exemple, de savoir si la balle est en rotation ou non. C´est donc plus une règle théorique que pratique. Mais c´est une bonne base à connaître.

Imaginez que vous lanciez une balle contre un mur. Au moment où elle touche le mur, bloquez le temps. Tirez un trait imaginaire perpendiculaire au mur, et passant par le point de contact. On appelle cette droite "normale". Maintenant, vous n´avez qu´à considéré ce trait comme "un axe de symétrie" : si la trajectoire de la balle était visible, la trajectoire du rebond de la balle en serait l´exacte symétrie dont l´axe serait la normale.

Cette loi ne marche qu´en théorie : il faut penser à gérer d´autres facteurs : les forces en présence, la vitesse de rotation de la balle...

Moi je te conseille :

F = mA; // majuscule = vecteur, miniscules = val
eur

F = ensemble des vecteurs forces
m = masse de ton objet
A = vecteur accéleration

tu veux la chue libre, tu as donc :

F = mG (avec G = vecteur(0,-g) // en 2D, g = 9.81

du coup :

F = mA
<=>
mG = mA
<=>
G = A
A = G

tu dérives :
V = Gt + V0
--> vecteur vitesse V : V0 = ta vitesse au temps t = 0 secondes

tu rederives :

P = Gt²/2 + V0*t + P0

Tu as ta position de la balle en fonction du temps
P0 = position au temps 0 secondes

Allez, un petit exemple pour parler !! !

ton mec est a la position P0 = (3,4)
il ne bouge pas V0 = (0,0)

Tu as envie de savoir ou il sera dans 0.5 secondes si tu lui appliques juste l´apesanteur :
tu appliques :

P = Gt²/2 + V0*t + P0

tu as des vecteurs en 2D, tu decomposes donc :

Px = Gxt²/2 + V0x*t + P0x
Py = Gyt²/2 + V0y*t + P0y

on a :

Px = 0*0.5²/2 + 0*t + P0x = P0x = 3
Py = -9.81*0.5²/2 + 0*t + P0y = -1.22625 + 4 = 2.77375

Ton mec sera donc a la position :
P = (3,2.77375) apres 0.5 secondes !