J'ai un point à l'écran: 10,10 et jeux veux aller ver le point 400,400 qui se trouve donc à environs 551 pixel de là. Comme je suis dans un jeu, je ne veux pas que ce qui se trouve au premier point se rende au deuxième intantanément. Je me demandais comment faire pour trouver la "direction" qu'il fallait prendre "DirX, DirY" selon une certaine vitesse...
 
Je veux faire qulquechose du genre
 
pos.x = pos.x + dirx;
pos.y = pos.y + diry;
 
j'espère que vous me comprenez

( y2-y1 )
--------- = la pente de ton vecteur non?
( x2-x1 )

Non justement, si je fait cela, je me retrouverais en moin d'un instant sur le point destination...

Ben moi je dirais que tu fais:
 
velocity x = (400 - 10) / k;
velocity y = (400 - 10) / k;
 
Comme ça tu as un vecteur colinéaire entre les deux points, et tu peux choisir la rapidité avec laquelle il faut se rendre au deuxième point en fonction de k.

le problème c'est qu'en fesant ca la vitesse dépend de l'éloignement des 2 points.

Peut-être qu'en utilisant le fait que, pour un triangle rectangle, la racine de l'hypothénuse égale la somme des carrés des autres côtés, cela permet d'imposer une vitesse linéique sur cette hypothénuse en recalculant combien de pixel en X (et donc Y) cela fait.
 
Si les points sont proches, le bout sera atteint rapidement. Sinon, il faudra plus d'une étape (temporelle).

 
ben tu normalises ton vecteur
(division par la norme)
comme ca tu as une direction unitaire.
j'vois pas ou est le probleme.
 
LEGREG

Mais ca depend de quelle norme tu met sur ton espace la
 
Allez, pour rester dans le concret, on va utiliser la norme euclidienne clasique :
 
norm = sqrt( (y2-y1)^2 + (x2-x1)^2 )
 
Une fois que tu a ca, ton vecteur directeur de norme 1 est :
 
dirx = (x2-x1)/norm
diry = (y2-y1)/norm
 
Si tu utilise ce vecteur comme composante de deplacement, tu te deplace "a la vitesse 1". Tu n'a qu'a multiplier ca par une constante positive pour regler finnement la vitesse.

wow, j'ai pas étudier en physiquequatique moi  
 
Si je comprend bien tout ce que j'ai à faire c'est
dirx = (x2-x1)/vitesse?
diry = (y2-y1)/vitesse?

Ventilo a écrit a écrit : wow, j'ai pas étudier en physiquequatique moi

 
mais non pas de mecanique quantique la dedans
en mecanique quantique, il n'y a ni vitesse ni
trajectoire puisqu'un objet occupe simultanement
tout l'espace .
 

 
deja definis ce que tu appelles vitesse :
si ce sont des pixels par frames
alors tu divises ton vecteur direction (x2-x1, y2-y1)
par ta distance en pixels sqrt( (y2-y1)^2 + (x2-x1)^2 )
puis tu le multiplies par ta vitesse en pixels par frame v.
le resultat = (vx, vy)
Et ainsi a chaque frame tu ajoutes
x = x + vx;
y = y + vy;
 
Voila c'est-y plus clair?
 
LEGREG

En fait je veux déplacer mon object en fonction du temps, temps que j'ai en millisecondes depuis le lancement de mon programe.
 
 
En fait ce qu'il me faudrait c'est un bon site avec des explication sur des lois de la physique, tout en restant accessible pour quelqu'un qui na pas fait des études poussé en math (pas encore )

A la cinematique
 
Je ne connais pas de site qui en parle, mais je peu te faire un peu de theorie pour te permetre de faire ton truc. On va se limiter a un probleme d'ordre 1 : Pas de gravitée et autres forces qui interviennent.
 
Un vecteur c'est un deplacement, ca tu l'a deja compris :
 
v définit par : ( x, y )
 
Dans le cas qui nous interresse, on va parler de vecteur unitaires seulement. Un vecteur unitaire c'est un vecteur de norme/taille 1
 
La norme d'un vecteur v c'est : |v| = sqrt ( x^2 + y^2 )
 
Donc si tu a une direction par un vecteur v (x, y), tu obtient le vecteur unitaire correspondant par :  
 
v2 = v/|v| = (x/|v|, y/|v|)
 
Donc, on a la direction de deplacement maintenant. Pour les unitees, on va parler en pixels/s : p/s
 
Un vecteur unitaire, ca a une vitesse de 1 p/s, si tu veux une vitesse a, ton vecteur vitesse devient :
 
v3 = a.v2 = (a.x/|v|, a.y/|v| ) = ( vx, vy)
 
Donc v3 contient à la fois ta vitesse et ta direction en p/s. Supposons qu'un point M se deplace avec pour vecteur vitesse v3, on a :
 
A l'instant 0 :
 
M(t=0) = M0 (x0, y0) : C'est ton point de depart
 
A l'instant t en secondes :
 
M(t) = M0 + t.v3 = (x0 + t.xv, y0 + t.yv )
 
Voila, cette formule doit suffire a resoudre tout ton probleme. Maintenant, attend les cours de physique de Terminale S pour voir ca plus en detail
 
Et fait gaffe aux unitees quand meme. Si ton temps est en milliseconde, ta vitesse doit etre an pixels/ms sinon ca va pas coller.

Il suffit de regarder le sens de la flèche de ton vecteur, celle-ci indique la direction de ce dernier.
 
Vraiment désolé

La je suis tout content parce que j'ai enfin été capable de trouver la bonne direction a prendre grace èa vos indication
 
mais la je suis baisé, quand je trouve DirX,DirY ca me donne un float (c++) bien sur, mais comme je suis en 2D je peut pas aafficher un object à 10,0777,10,0777    
 
Il me faut donc une fonction pour arondire mon chiffre, je crois pas qu'il y est une fonction pour ca de base dans la STD?

Essaye int(xpos) ou (int) xpos suivant ce que tu prefère juste pour voir
 
Si tu veux arrondir de facon plus controlee, dans math.h il y a des trucs comme floor ou ceil mais il ca retourne un float quand meme

OUIIIIII, la fonction ceilf a tout arrengé ca marche

Bon jai un petit problem, quand la direction est en haut a gauche du point et que la vitesse est à 1, la direction tombe à 0,
 
voici mon code: (Ver étant l'arrivé, corps étant le départ)
 
f_vecteur v_dir;
f_vecteur v_temp;
f_vecteur v_vel;
float norm;
 
vm_vectsom(Ver->origine,corps->origine,&v_temp); //additione les deux vecteurs
 
norm = sqrt(vm_exposant(v_temp.x,2) + vm_exposant(v_temp.y,2)); //trouve la norm
 
vm_vectsous(Ver->origine,corps->origine,&v_dir); //soustrait les deux vecteur et donne la direction
 
vm_vectdivi(v_dir,norm,&v_dir); //divise la direction par la norm
 
vm_vectmulti(v_dir,corps->vitesse,&v_dir); //multiplie la direction par la vitesse
 
corps->origine.x = corps->origine.x + ceilf(v_dir.x); //bouge le corps
 
corps->origine.y = corps->origine.y + ceilf(v_dir.y); //bouge le corps
 
fait chier, jaivais quelquechose qui marchait plus ou moin bien, quand le point arrivé étais loin de point départ, la vitesse étais différente de si il étais proche, donc la vitesse dépendait de la distance c'est mon algo qui marche pas??

[edtdd]--Message édité par Ventilo--[/edtdd]

pourquoi fais-tu ca?
 
il faut soustraire les coordonnes des deux points
pour avoir celle de ton vecteur direction
et diviser par la norme de ton vecteur direction  
 
LEGREG

 
je fait ca pour trouver la norm...

Non, legreg a raison, ce que tu voulais faire c'est bien la difference. pour etre precis tu devrait faire Destination - Depart.
 
En fait pour etre precis, Destination + Depart n'a aucun sens utilisable. Ca ne sert a rien, jamais
 
C'est ce vecteur dont tu calcule la norme puis c'est de ce vecteur que tu obtient la direction de deplacement. C'etait peut-etre mal explique je suis desole dans ce cas.
 
Il va peut etre falloir que je fasse un vrai tutorial et que je le mette en ligne un jour

Kristoph a écrit a écrit :   Il va peut etre falloir que je fasse un vrai tutorial et que je le mette en ligne un jour

 
ca serait bien  

 
bon je resume p1 le point de depart
p2 le point d'arrivee.
 
distance = vect_sous(p1, p2);
normedist = sqrt(distance.x * distance.x + distance.y * distance.y); // note: ne jamais faire exposant pour un carre
si normedist != 0 alors
direction = distance/normedist;
 
ca va mieux?
 
LEGREG

 
beacoup mieux!!! MERCI  
 
Enfait ce que je faisais c'est que je trouvais la distance en pixel, pas en vecteur... bah <
 
faut dire que les seul math qui resemble à ca que jai fait cétais de trouver la distance entre deux points sur un plan cartésien, ou de trouver le point milieu d'une droite  

[edtdd]--Message édité par Ventilo--[/edtdd]

Bon je laisse tomber, j'ai finalement été capable de trouver la bonne direction, mais comme je suis en 2D je ne peux pas m'en servire    
 
Les point en 2D ne peuvent être que des entiers, et la direction/vitesse ne peut être représenté adaquatement qu'en double/float    
 
Je suis pas encore assé avancer, je remerci ceux qui mon aider, mais je retourne dans ma programation GUI windows  
 
 

Mais il ne faut pas abandoner pour si peux
 
Comme tu l'a dit, les vecteurs ( surtout les unitaires ) doivent etre representes en float/double. Et bien tu fais TOUT tes calculs en float/double meme pour les coordonnees de tes points et juste avant l'affichage, tu fais
 
int xint = (int) xfloat;
int yint = (int) yfloat;
 
Et voila, tu n'utilise xint et yint que pour afficher sur l'ecran, apres tu les oublies ces valeurs.