Algorithme de déplacement : calculer un angle

Bonjour,

J'ai besoin de faire en sorte qu'un objet fixe soit toujours tourné vers un point mobile, sur un plan orthonormé (2D).

J'utilise donc la fonction tan ex :

Code:

---

1 2	angle = (Math.tan((World.x - Objet.x) / (World.y-Objet.y))*(180/Math.PI));

---

Cela fonctionne cependant je suis obligé de mettre des conditions lorsque une valeur ou l'autre est inférieur...Du coup je bricole un peu la chose par exemple :

Code:

---

1 2 3 4 5 6 7 8

if ( Math.abs(Game.x - x) < Math.abs(Game.y - y) ){ if ( Game.y - y > 0 ){ d = (Math.tan((Game.x - x) / (Game.y-y))*(180f/(float)Math.PI))-90f; }else{ d = (Math.tan((Game.x - x) / (Game.y-y))*(180f/(float)Math.PI))+90f; } }

---

Déjà j'aime pas ce genre de bricolage est il vraiment nécessaire ou connaissez vous une façon plus simple pour obtenir le résultat sans mettre 36000 conditions ?

En plus, lorsque j'arrive sur les bords l'angle qui en résulte devient légèrement plus grand ce qui fait une saccade quand on passe de l'un à l'autre.

Merci si vous pouvez m'aider.

:salut:

A priori, la fonction atan2 (à deux arguments, pour éviter la division et la perte d'informations corre) sert à résoudre ce genre de problèmes.
https://nl.mathworks.com/help/matlab/ref/atan2.html
http://www.cplusplus.com/reference/cmath/atan2/

dourouc05 Génial, merci il semblerait que ça marche!

Heu une dernière chose.

En fait maintenant que j'ai trouvé l'angle j'aimerais le transformer en longueur et largeur pour faire avancer mon objet :

Code:

---

1 2 3 4 5 6

cap = Math.atan2((Game.x - x),(Game.y-y)); setPosition(x - Game.x, Game.y - y, (float) (cap* (180 / Math.PI))-90); //je dessine l'angle   x += Math.cos(cap)* ((Game.gameTime()-time)/5000000000f) y += Math.sin(cap)* ((Game.gameTime()-time)/5000000000f)

---

Le problème est que mon objet se déplace bien dans l'axe...mais à l'envers. J'ai beau essayé de soustraire au lieu d'ajouter, de mettre un Radian avec PI en plus pour faire 180) il inverse toujours la trajectoire.
-ou un coup il se rapproche puis après il inverse et s'éloigne...

sans contexte (ni définition de tes variables) c'est pas facile de comprendre ce que tu fais... ni pourquoi ca marche pas.

en revanche, si tu calcules un angle pour...ensuite le repasser en vecteur ptet que ya un pb.

quand A et B sont deux points... pour que A regardes B il suffit que A regarde dans le sens du vecteur AB...
si A=(x, y) et B=(Game.x, Game.y)
trivialement, le vecteur pour regarder vers B est... v=B-A=(Game.x-x, Game.y-y)
si tu veux te déplacer vers B depuis A... tu normes ton vecteur
v_u = v/norme(v) et
dv=v_u*((Game.gameTime()-time)/5000000000f)
trivialement
x += dv[0]
y += dv[1]

et tu finiras par te rapprocher de B

Oui, en effet, ça marche.

Cependant j'aimerais calculer l'avancée x et y en fonction d'un angle et non du vecteur...car cela me permettra de gérer une trajectoire moins brutale : ex l'objet avance et suit un angle qui va toujours chercher à être le plus proche de l'angle qui le mène vers sa cible.
EX :

Code:

---

1 2 3 4 5 6

if ( angleDeDirrection < angleDeLaCible ){ angleDeDirrection = Math.min(angleDeLaCible, angleDeDirrection + vitesseDeChangementDAngle); }else{ angleDeDirrection = Math.max(angleDeLaCible, angleDeDirrection - vitesseDeChangementDAngle); }

---

du coup si la cible bouge par exemple, l'objet qui va vers lui risque de passer à côté ce qui est voulu...selon le déplacement d'ailleurs, si l'angle reste à peut près le même entre les 2 objets il finiront par se heurter.

De manière générale, les tests si angle1 < angle2 , ça ne marche jamais.
En effet, 0° ou 360°, c'est la même direction. Donc 120° est-il plus grand que 0°, ou plus petit que 360°, on ne sait pas.

Par ailleurs, il te manque plein de choses. Tu parles de angleDirection et AngleCible. Ok. Admettons que la Cible va vers le haut de l'écran, et le joueur aussi va vers le haut de l'écran. Dans ta formule, tu utilises uniquement ces 2 inputs. Mais la position d'origine de la cible et du joueur doivent être prises en compte. Si le joueur est sur la partie droite de l'écran, ou s'il est à gauche, ou s'il est en bas, on veut que la fonction donne 3 réponses différentes. Or, ta fonction ne prend pas en compte la position du joueur !

Bonjour, :D

Si c'est un problème de poursuite, le chasseur (A) se déplace constamment vers la position actuelle de la la cible (B), indépendamment du déplacement simultané de cette dernière.

En notant (r) la distance séparant les positions courantes des deux points
r = ((x_B - x_A)² + (y_B - y_A)²)^1/2
le déplacement de (A) dans l'intervalle de temps (DeltaT) considéré est représenté par le vecteur
DeltaA = (V_A*DeltaT/r).((x_B - x_A).U_x + (y_B - y_A).U_y) .

(B) sera rattrapé dès lors qu'il se déplace à une vitesse plus faible: V_B < V_A .

Si l'on s'intéresse au changement de l'orientation du tir, il suffit de considérer les valeurs successives du vecteur (AB) à deux instants consécutifs:
P = AB_(t)
P₁ = AB_{(t + DeltaT)} = P + DeltaT.(V_B - V_A)
puis de calculer le déterminant correspondant:
Det(P, P₁) = (P, P₁, U_z) = (P*P₁)*Sin(u)
qui s'exprime en fonction de l'écart angulaire entre les deux vecteurs:
u = (P, P₁) = Arcsin(Det(P, P₁)/(P*P₁)) .

Code:

---

1 2	l'objet qui va vers lui risque de passer à côté ce qui est voulu...

---

ok

Code:

---

1 2 3 4 5 6

cap = Math.atan2((Game.x - x),(Game.y-y)); setPosition(x - Game.x, Game.y - y, (float) (cap* (180 / Math.PI))-90); //je dessine l'angle   x += Math.cos(cap)* ((Game.gameTime()-time)/5000000000f) y += Math.sin(cap)* ((Game.gameTime()-time)/5000000000f)

---

note par rapport à ton code
ca a l'air detre en js.
si tu regardes le proto de atan2
https://developer.mozilla.org/en-US/...cts/Math/atan2

atan2 s'attend à avoir Math.atan2(y,x) et non Math.atan2(x,y)

Par ailleurs ton setPosition est mauvais:
setPosition(x-Game.x, Game-y) ----> setPosition(Game.x-x, Game-y)

(cap* (180 / Math.PI))-90
ca ressemble __très fortement__ à une symétrie par rapport à l'axe x=y que tu as du bidouiller (en plus de ton x-Game.x lol)?? parce que atan2(x,y) correspond à un angle dont les coordonnées ont été interverties (==symétrie par rapport à axe y=x)

et ca ne devrait pas être necessaire, simplement cap en paramètre devrait suffire

Attention encore une fois
angleDeDirrection + vitesseDeChangementDAngle
un angle c'est un angle, une vitesse c'est pas un angle.
Donc si c'est vraiment une vitesse, c'est vitesseDeChangementDAngle*deltaT
sinon tu l'appel deltaAngle...