gestion des trajectoires - Page 1

Bon voila, dans un jeux de balles, komment doit on gerer les trajectoires de la balle.
avec une courbe de parabole?
en prenant compte la gravite?
g deja lu le topic sur blobby dans la partie algo mais je comprend po tro les derivees partielles, et surtout ,j e vois po comment l'appliker a un algo
merci de m'aider

regarde dans la partie algo, une question assez proche a été posée y'a pas longtemps.

vi je sais.si t'avais bien lu mon msg tu orais vu ke j'y fesais allusion.

Ben déjà la gravité c que si tu envoies ta balle en l'air; je suppose que c'est le cas.
La courbe est bien du second degré.

Pas la peine d'utiliser des dérivées partielles (qui sont en fait des dérivées ici)

KWT-ArpiK a écrit :
vi je sais.si t'avais bien lu mon msg tu orais vu ke j'y fesais allusion.

Arf en effet

KWT-ArpiK : Je vois ce que tu veux C'est très simple à gérer ! Je te donne les formules de base :

C'est du n'importe quoi cette formule.

Et en plus c'est pas la première fois qu'on la voit

arf en effet

de toute facon y a une erreur dans le produit vectoriel de la 2 eme ligne mdr

nEUrOne a écrit :
Ben déjà la gravité c que si tu envoies ta balle en l'air; je suppose que c'est le cas.
La courbe est bien du second degré.
Pas la peine d'utiliser des dérivées partielles (qui sont en fait des dérivées ici)

en effet c po des derivees partielles
en fait suffit de reutiliser le cour de TS de meca ?!

L'équation de ta courbe est qq ch qui doit ressembler à ça :
y(t) = -5t² + 20t + 1
x(t) = 20t
(en mètres par secondes)
ça te donne leur vitesse :
y'(t) = -10t + 20
x'(t) = 20
leur accélération :
y''(t) = -10 ( ~ 9.81, cad l'attraction terrestre )
x''(t) = 0 (pas d'accélération sur x, sauf si tu veux gérer le vent)

Je te conseille d'avoir une variable pour la vitesse de chaque composante et à chaque cycle, tu incrémentes la composante avec sa vitesse (bien sûr, pour gérer l'accélération, il faut que ajoutes la variable d'accélération avec celle de vitesse) :
vitesse_x+=acceleration_x; // acceleration_x>0 si le vent vient de gauche, <0 si le vent vient de droite
vitesse_y+=acceleration_y; // acceleration_y = -10;
pos_x+=vitesse_x;
pos_y+=vitesse_y;

Je pense que c'est correct.
Bien sûr, il faut qu'au début tu définisses toi même les valeurs initiales des accélérations, vitesses et positions.

emploie des cos et des sins pour l'angle...

Idefix> surtout pas !!!! la trajectoire est une parabole, pkoi utiliser des cos & sin

KWT-ArpiK> quand je dis que ce ne sont pas des dérivées partielles ici c'est que ce sont des dérivées 'droites', donc de fonctions qui ne dépendent que d'une variable.

Les cos et les sin:
Le projectile est lancé dans un plan vertical [0x,0y] avec un vecteur vitesse initiale de norme Vinit et d'angle Alpha par rapport à l'horizontale

La conversion de ce vecteur en Rectangulaire donne
VXinit=Vinit*cos(Alpha), VYinit=Vinit*sin(Alpha)

Après, vx est constante, et vy reçoit à chaque instant t l'accélération ay égale à -_g (_g étant la norme du vecteur accélération gravitationnelle: 9.80665 _m/_s^2 selon la 89, en _m/_s^2 ou en _N/_kg)

donc vx(t)=VXinit
vy(t)=VYinit + _g . t

En intégrant on obtient:
x(t)=Xinit + VXinit . t
y(t)=Yinit + VYinit . t - 1/2 . _g . t²

En remplaçant:
x(t)=Xinit + Vinit*cos(Alpha) . t
y(t)=Yinit + Vinit*sin(Alpha) . t - 1/2 . _g . t²

On peut aussi exprimer y en fonction de x, mais j'ai la flemme...

heu en programmation, c plus rapide de ne pas utiliser sin & cos, c pour cela que je déconseille de les utiliser, car on peut tout à fait utiliser ne pas les utiliser.

Ben tu les utilises au début, vu que l'angle Alpha est une donnée initiale constante, VXinit et VYinit sont constants

Edit:

Ximoon
,ci-dessous: Bien sûr, ça correspond aux formules ci-dessus...

Et oui.

Autre méthode:
Tu définis le déplacement élémentaire horizontal (plutôt que la vitesse, on fait des déplacements discrets ici) et tu déplaces la balle de cette constante à chaque image.
Pour le déplacement vertical, tu ajoutes à chaque affichage la 'vitesse' initiale et tu ajoutes l'accélération (ici -10, par exemple) multipliée par le nombre d'images ou de cycles depuis le début du lancer. Il ne reste plus qu'à ajouter les coordonnées actuelles.
Bien sûr, ça correspond aux formules ci-dessus...

x(n)=x(n-1)+vv0
y(n)=y(n-1)+vh0+a*n

vh=vitesse horizontale
vv=vitesse verticale
a=pseudo-accélération de la pesanteur

Kevin : je ne pense pas qu'on avait besoin de toi pour le remarquer
Moi j'laime bien ma 'tite formule

La 1ere fois c'était drole... Là c'est franchement gavant... Enfin si ça t'amuse après tout

KWT-ArpiK ne la connaissait pas cette formule, Monsieur

comment ca je la connaissait pas??
tu crois ke j'ai apris koi o college?

je crois qu'il faut faire un (char *) tab[]={&ptr1,&ptr2,...}

médor
a écrit : je crois qu'il faut faire un (char *) tab[]={&ptr1,&ptr2,...}

Rapport avec la question???