Salut, voila mon probleme je me test avec directx en faisant un casse brique mais voila que je tombe sur un probleme (qui commence a me faire rager et mal a la tete :'(   )

Ma balle n'avance pas de la meme vitesse sur un pc a 3ghz que sur un pc a 866mhz certes c'est normal si on fais le deplacement avec

balle_x += vitesse * vecteurx
balle_y += vitesse * vecteury

il faut donc rajouter pour le calcul du deplacement de la balle le facteur Temps alors je fais simplement

balle_x += vitesse * vecteurx * delta_temps
balle_y += vitesse * vecteury * delta_temps
delta_temps correspond au temps ecouler entre les affichages de la balle a l'ecran
Ainsi on respecte la formule connu de tous D = v * dt 
ma balle doit parcourir une distance de D pixel a l'ecran selon sa vitesse v * le temps ecoulé dt


ben chez moi ca ne marche pas mes valeurs de delta_temps sont complement folle ! j'ai des resultat pour delta_temps negatif et positif et meme egal a zero ... pourtant j'utilise
temps1 = timeGetTime();
et le delta_temps = timeGetTime() - temps1;

tout ce que je vous demande pour m'aider c'est pas de chercher mon erreur mais plutot de m'expliquer comment vous faites vous. ou bien si vous denichez un code source d'un mouvement en fonction du temps je veux bien le prendre !


merci a vous et desolé pour les fautes que j'aurais pu faire mais j'ai plus de tete et j'en ai ras le bol !
oo

J'aurais bien pris le temps de réediter mon message pour corriger et mieux m'expliquer mais je ne sais pas comment faire

dsl pour vos yeux

oo

je ne mi connais pas du tout en directX mais c'est pas grave.

pour ne pas que ton deplacement soit lié a la vitesse du CPU, faut faire comme sa

avec API WINDOWS :

CreateTimer (hwnd,0,50,NULL) /*Le timer n°0 est apeler tous les 50 ms*/

case WM_TIMER:
/*routine pour réaffichier ton truc, decalage de x pixel*/

comme x = constante et que 50 ms = constante, alors v = d/t = cste voila...

sinon yas aussi la méthode du sleep (temps) mais elle syncrhone et bloquante celle la, bon aïe

non surtout pas de timer. pourquoi ? beaucoup moins souple, surtout en réseau. Une partie de ton calcul et de ton raisonnement est bon, voici la façon dont il faut procéder: tout d'abords, il faut utiliser la fonction "GetTickCount" qui te renvoie une valeur en milliseconde. tu déclares trois variables: int temps1, temps2, difference; dans ta boucle d'affichage, la première chose à faire est de sauver la valeur de GetTickCount dans ta variable "temps1". Ensuite tu calcules la différence entre la variable "temps2" et "temps1" : difference = temps1 - temps2; Si c'est la première itération de ta boucle, la valeur de la variable "difference" sera très grande étant donné que la variable "temps2" = 0 (tu peux toujours palier à ça en lui spécifiant une valeur avant de commencer ta boucle) Ensuite tu effectues tout tes calculs et après avoir affiché ton image à l'écran (avec la fonction style "D3DDevice.Present") tu sauves la valeur de la variable "temps1" dans ta variable "temps2": temps1 = temps2; à la prochaine itération, la différence des deux sera le temps en milliseconde écoulé entre chaque affichage d'une image. c'est cette différence qui va te servir de multiple pour calculer n'importe quel déplacement ou changement. si tu veux voir une source ou cette méthode est utilisée : http://www.cppfrance.com/code.aspx?id=29053 elle est entièrement commentée et utilise opengl (mais ça ne change rien pour toi) ciao

bon, je ne sais vraiment pas ce qui s'est passé (ça doit être opéra, j'essaies avec IE)

non surtout pas de timer.
pourquoi ? beaucoup moins souple, surtout en réseau.

Une partie de ton calcul et de ton raisonnement est bon, voici la façon dont il faut procéder:

tout d'abords, il faut utiliser la fonction "GetTickCount" qui te renvoie une valeur en milliseconde.

tu déclares trois variables:
int temps1, temps2, difference;

dans ta boucle d'affichage, la première chose à faire est de sauver la valeur de GetTickCount dans ta variable "temps1".

Ensuite tu calcules la différence entre la variable "temps2" et "temps1" :
difference = temps1 - temps2;
Si c'est la première itération de ta boucle, la valeur de la variable "difference" sera très grande étant donné que la variable "temps2" = 0 (tu peux toujours palier à ça en lui spécifiant une valeur avant de commencer ta boucle)

Ensuite tu effectues tout tes calculs et après avoir affiché ton image à l'écran (avec la fonction style "D3DDevice.Present") tu sauves la valeur de la variable "temps1" dans ta variable "temps2":
temps1 = temps2;

à la prochaine itération, la différence des deux sera le temps en milliseconde écoulé entre chaque affichage d'une image.

c'est cette différence qui va te servir de multiple pour calculer n'importe quel déplacement ou changement.

si tu veux voir une source ou cette méthode est utilisée : http://www.cppfrance.com/code.aspx?id=29053
elle est entièrement commentée et utilise opengl (mais ça ne change rien pour toi)

ciao

.:. NoRabbit .:.

c'était opéra... pourtant dernière version...
bon je vais switcher à FireFox

.:. NoRabbit .:.

Ok merci tous le monde, j'aurais jamais continuer le casse brique si j'avais pas resolut ce probleme je suis tres prise de tete

Et ben j'espere ne pas devoir revenir ici pour pleurer

Skeleton.

oo

bon bcp de blabla pour pas grand chose g la flemme de lire les poste ,le plus simple c un morceau de code et un bon ptit tuto alors :
[ Lien ]