Discussion :

[nouby]

Salut !

je cherche comment donner à un missile la bonne direction pour toucher une cible.
je ne veux pas d'un missile qui suit la cible mais d'un tir direct selon un angle calculé automatiquement selon la position du tireur et de la cible.

La cible ici c'est mon vaisseau qui peut bouger dans tout l'écran.
Les tireurs c'est trois rectangles qui peuvent bouger.

J'ai utilisé une formule qui se sert de atan2() , du cos() et du sin() mais cela n'a rien donné de précis comme résultat.

[Bousk]

Quand le missile est créé, tu prends la cible, sa position, crées une direction et il avance dans cette direction.

[nouby]

Effectivement c'est ce que je veux, mais comment avoir cet angle et le donner au missile ?

Si la cible bouge je voudrais que le missile continu son chemin.

est-ce que par direction tu entends : diff_x = cible_x - tireur_x et diff_y = cible_y - tireur_y ?

alors on donnerait au missile : missile_x += diff_x et missile_y += diff_y

???

Heu, non en y refléchissant, car la différence entre cible_x et tireur_x peut être très grande et on peut donc pas faire missile_x += diff_x car ça serait un grand saut pour le missile, voire une téléportation, alors comment gérer ça ?

je sais qu'on doit ajouter +vitesse à missile_x et missile_y mais je vois pas comment lier ça à diff_x et diff_y.

[f-leb]

Bonsoir,

Il faut voir (ou revoir) le cours sur la cinématique du point

[nouby]

merci pour le lien, je vais voir ça !

EDIT :
heu.... je viens de regarder le cours, c'est pour les matheux, c'est pas mon cas....

je vois pas comment parametrer mon missile avec ça :/

[f-leb]

C'est plutôt de la physique... Je n'ai pas d'habitudes dans le codage des jeux, mais il te faudra bien programmer la position du missile en suivant les équations du mouvement.

Si on suppose une vitesse uniforme du missile : .
O est le départ du missile, M(t) la position du missile au cours du temps.

Tu peux calculer la position du missile au frame suivant, en fonction de sa position courante avec l'équation suivante :

[Obsidian]

C'est plutôt de la physique... Je n'ai pas d'habitudes dans le codage des jeux, mais il te faudra bien programmer la position du missile en suivant les équations du mouvement.

C'est pertinent mais Nouby nous as déjà confié ici ne pas être un grand matheux. Heureusement, les maths de niveau collège suffisent largement ici pour calculer une trajectoire rectiligne…

merci pour le lien, je vais voir ça !

EDIT :
heu.... je viens de regarder le cours, c'est pour les matheux, c'est pas mon cas....

je vois pas comment parametrer mon missile avec ça :/

Ce n'est pas très difficile : ce sont juste des principes assez naturels qui ont l'avantage d'être rédigés avec le formalisme mathématique de rigueur, ce qui est une bonne chose en soi parce qu'une fois que l'on a compris de quoi il s'agit, cela rend justement la chose plus facile à assimiler.

Dans le cas présent, ce qui t'est conseillé ici est de ne pas t'appuyer sur l'angle de tir, mais sur les distances horizontales et verticales qui séparent ton missile de sa cible, étant entendu que l'on s'appuie sur leurs coordonnées respectives (et que celles-ci s'inscrivent dans un repère orthonormé). Exemple :

Code Texte :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 
           (5,13) * Cible
                  |\
                  | \
                  |  \
                  |   \
                  |    \
|                 +-----! Missile (8,9)
|
+--

• En abscisse, ta cible est en 5 et ton missile en 8, il y a donc trois unités d'écart (8-5) horizontalement entre la cible et le missile. Cette différence est généralement notée dx ou Δx (« d » ou delta pour « différence »).
• En ordonnée, ta cible est en 13 et ton missile en 9, il y a donc quatre unités d'écart (13-9) verticalement entre la cible et le missile. Cette différence est généralement notée dy ou Δy.

Tu peux déjà faire le rapport de l'une de ses différences sur l'autre (c'est-à-dire diviser l'une par l'autre) pour savoir de combien d'unités il faut se déplacer dans un sens quand on avance d'une unité dans l'autre. Mais il y a mieux :

Tu peux calculer le nombre d'unités à parcourir horizontalement et verticalement lorsque l'on parcourt une unité suivant la trajectoire du missile (le trait en diagonale sur le diagramme). Pour cela, il te suffit de connaître la longueur de cette trajectoire et pour la déterminer, on utilise le bon vieux théorème de Pythagore.

On considère ici que tu es au clair avec le théorème de Pythagore. Si ce n'est pas le cas, dis-le nous maintenant parce qu'il est aussi utile que facile à apprendre et il te servira réellement toute ta vie. En plus, tu te donnes toi-même ici un cas d'application concret, donc c'est le bon moment pour l'assimiler sans douleur et une fois pour toutes.

Donc ici, trois unités en largeur et quatre unités en hauteur donnent : 3² + 4² = 9 + 16 = 25 et √25 = 5. La trajectoire de ton missile mesure donc exactement 5 unités.

• Cela signifie qu'il faudra donc parcourir 3 unités en largeur quand ton missile en parcourra 5. Il faudra donc se déplacer de 3÷5 soit 0,6 unité en largeur chaque fois que ton missile parcourra une unité ;
• De la même façon, il faudra parcourir 4 unités en hauteur quand ton missile en parcourra 5. Il faudra donc se déplacer de 4÷5 soit 0,8 unité en hauteur chaque fois que ton missile parcourra une unité.

Il y a deux avantages majeurs à procéder comme suit :

• Ton missile se déplacera toujours à la même vitesse quelle que soit sa direction ;
• Ces deux valeurs dx et dy suffisent à elles-seules à déterminer à la fois la vitesse et la direction de déplacement de ton missile.

SPOIL : ces rapports sont en fait exactement ceux qui te sont donnés par sin(x) et cos(x) lorsque tu pars d'un angle. Tout ceci, toutefois, forme la trigonométrie et si tu es censé l'avoir vue au collège, il nous faudra quand même un commentaire (voire un fil) dédié si tu souhaites que l'on revienne dessus.

Quoi qu'il en soit, le mieux pour l'heure est de définir ces grandeurs comme attributs d'une classe Missile :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
class Missile:
    x   # Position en abscisse
    y   # Position en ordonnée
    dx  # Déplacement en abscisse
    dy  # Déplacement en ordonnée

Par la suite, tu t'apercevras que ces grandeurs combinées sont en fait des vecteurs. Tu peux alors définir une même classe « Vecteur » pour définir à la fois la position d'un côté et la vitesse+direction de l'autre :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class Vecteur:
    x   # Abscisse
    y   # Ordonnée
 
class Missile:
    position    # objet de type Vecteur
    direction   # objet de type Vecteur aussi

Par la suite, tu pourras même passer directement en 3D en rajoutant une composante « z » et encapsuler les calculs à faire directement au sein de ta classe Vecteur pour pouvoir les résumer à « vposition += vdirection » dans ta classe Missile mais ça, ce sera pour une autre fois. ;-)

[nouby]

ouaaaah F-leb, tu m'as tué là, lol

Merci pour votre aide, je vais voir ça devant mon code, super les gars !

et si tu es censé l'avoir vue au collège

Bha non, j'étais dans une classe spéciale qui pouvait se nommer "incapables, à sortir au plus vite de l'école"
lol, le nom officiel c'était "cppn" (classe préparatoire à professionnel ou je sais plus quoi...) on y apprenait les premières notions d'un métier manuel et le reste du temps on nous occupait...

est-ce qu'on peut tirer une formule de ces valeurs pour positionner le missile ?
parce que là je comprend ce que tu as écris mais je vois pas comment l'appliquer au mouvement du missile.

Cela signifie qu'il faudra donc parcourir 3 unités en largeur quand ton missile en parcourra 5. Il faudra donc se déplacer de 3÷5 soit 0,6 unité en largeur chaque fois que ton missile parcourra une unité ;
De la même façon, il faudra parcourir 4 unités en hauteur quand ton missile en parcourra 5. Il faudra donc se déplacer de 4÷5 soit 0,8 unité en hauteur chaque fois que ton missile parcourra une unité.

est-ce valable si je fais : missile_x += vitese * 0.6 et missile_y += vitesse * 0.8

???

L'hypothénuse me sert à quoi ? je m'interesse seulement à la distance de la cible en hauteur et largeur, donc ça m'évite le cours de trigo
j'ai regardé vite fait là un livre de math, sur la trigo, et j'ai vu comment calculer l'hypothenuse.

EDIT : après réflection.

rapport_x = ennemi_x / cible_x
rapport_y = ennemi_y / cible_y
missile_x = vitesse * rapport_x
missile_y = vitesse * rapport_y

???

[Obsidian]

lol, le nom officiel c'était "cppn" (classe préparatoire à professionnel ou je sais plus quoi...) on y apprenait les premières notions d'un métier manuel et le reste du temps on nous occupait...

Ah ! Les CPPN ! Ça faisait un certain temps que je n'avais pas entendu le nom, en effet…

Wikipédia indique qu'elles ont existé jusqu'en 1991, année où j'ai personnellement passé le BEPC en fin de 3ème. Donc tu es au moins de ma génération, potentiellement plus vieux. En tout état de cause, pour une personne soit-disant en décrochage scolaire, tu maîtrises le français et tu raisonnes de façon tout-à-fait rationnelle. Je connais certains ingénieurs chez qui ce n'est plus garanti.

est-ce valable si je fais : missile_x += vitesse * 0.6 et missile_y += vitesse * 0.8

Oui. ;-)

L'hypothénuse me sert à quoi ? je m'interesse seulement à la distance de la cible en hauteur et largeur, donc ça m'évite le cours de trigo
j'ai regardé vite fait là un livre de math, sur la trigo, et j'ai vu comment calculer l'hypothenuse.

Ça a sa place au sein du programme de trigonométrie mais encore une fois, il ne faut pas utiliser les fonctions trigonométriques pour calculer une hypoténuse. Il faut le faire avec le théorème de Pythagore. C'est non seulement beaucoup plus simple pour l'homme mais c'est également beaucoup plus efficace pour la machine.

Si tu regardes bien le diagramme, l'hypoténuse correspond exactement à la trajectoire de ton missile.

Ce que l'on fait ici, c'est que l'on prend cette trajectoire en référence, en commençant d'abord par en calculer la longueur, et c'est ensuite à partir d'elle que l'on déduit les coefficients à appliquer en x et en y.

Donc, si cette trajectoire mesure 5 unités de long, il va falloir parcourir cinq fois « une unité par quantum de temps » et à chacune d'elle, mettre à jour x et y en leur ajoutant les coefficients en question.

En l'occurrence, si « vitesse = 5 » (si la vitesse correspond exactement à la longueur de la trajectoire), le missile va atteindre immédiatement sa cible dans le sens où il va le faire en une seule unité de temps : à un instant donné il sera au point de départ, l'instant d'après il sera pile sur sa cible. Tu l'auras déplacé comme il le faut, mais ce n'est pas forcément ce que tu attends : tu as probablement envie de le voir voyager d'abord, voire même manquer sa cible et continuer sur sa lancée si cette cible se déplace avant d'être atteinte.

EDIT : après réflection.

rapport_x = ennemi_x / cible_x
rapport_y = ennemi_y / cible_y
missile_x = vitesse * rapport_x
missile_y = vitesse * rapport_y

???

Pas tout-à-fait mais il y a de l'idée.

Déjà, il faut définir ce que tu appelles « ennemi » ici. J'imagine que c'est en fait le point de départ du missile.

[nouby]

Je trouve que tes explications sont très précises et pédagogiques, j'aime bien les lire !

j'ai quitté la cppn en fin 78, pour aller apprendre un métier.
c'était le temps de l'insouciance et des culottes courtes, enfin des "shorts" quoi.

merci de votre aide, c'est très sympa et en attendant j'avance mon jeu sur d'autres points.

je dois encore analyser ta réponse pour voir comment déplacer mon missile.

Oui, ennemi c'est le tireur et moi je suis la cible, lol

j'ai fait un tracé sur un cahier et j'ai compris que l'angle de déplacement du missile, c'est le rapport entre le deltaY et le deltaX, comme tu avais dis en fait.

et ce rapport (y_tireur - y_cible) / (x_tireur - x_cible) doit multiplier la vitesse du missile et le résultat etre ajouté à la position du missile.

j'ai testé mais j'ai eu une division par zéro, ce qui a bloqué le programme.

[Obsidian]

Je trouve que tes explications sont très précises et pédagogiques, j'aime bien les lire !

j'ai quitté la cppn en fin 78, pour aller apprendre un métier.
c'était le temps de l'insouciance et des culottes courtes, enfin des "shorts" quoi.

1978 à 1984 a été une époque bénie pour moi aussi, avec d'autres raisons s'ajoutant à cela. Par contre, c'était malheureusement un peu tôt de ton côté pour profiter du plan « Informatique Pour Tous ». Ça, ce fut vraiment une chouette époque pour tous les geeks en devenir.

j'ai fait un tracé sur un cahier et j'ai compris que l'angle de déplacement du missile, c'est le rapport entre le deltaY et le deltaX, comme tu avais dis en fait.

Pas tout-à-fait, justement ! Là encore, comme on le disait dans une autre discussion, il est important d'être précis sur les termes car si on comprend bien le concept général, les détails finissent par se confondre. C'est un peu comme voir très légèrement flou : ça permet de profiter quand même de la majorité du monde, mais c'est suffisant pour nous empêcher de lire, et donc de prendre connaissance d'une information.

Le rapport entre Δy et Δx te donne le coefficient directeur d'une droite, c'est-à-dire sa « pente » en un point donné. Si tu généralises ce principe à tous les points d'une courbe, tu obtiens sa dérivée. C'est extrêmement utile et extrêmement utilisé : c'est la base de ce que l'on appelle le calcul différentiel et c'est ce que l'on commence à faire au lycée autour de la 1ère. Tu n'es pas obligé d'aller si loin pour le moment mais si le sujet t'intéresse, cela reste très abordable pour une personne motivée.

Par contre, ce n'est pas un angle : on voit que ce rapport vaut 0 lorsque la droite est horizontale et qu'il est infini quand elle est verticale. Et de proche en proche, en observant le triangle rectangle formé à chaque fois, on réalise qu'il s'agit en fait de la tangente de cet angle.

On comprend également qu'il n'y a pas de manière simple de passer de l'un à l'autre : il n'y a pas de relation directe entre les deux approches, sinon on l'appliquerait dès le départ et on pourrait même effectuer des simplifications en amont dans nos calculs. C'est pour cela que l'on a formalisés ces relations via les fameuses fonctions sin(x), cos(x) et tan(x). Quand on est au collège et que l'on aboutit à ces fonctions, l'exercice se conclut souvent en « utilisez la calculatrice pour en déterminer la valeur ». Bien. Mais on n'a pas attendu les ordinateurs pour s'en servir, Wikipédia situant d'ailleurs l'apparition du terme autour du XIIème siècle. Donc comment faisait-on ?

En fait, bien souvent en mathématiques, on établit une « théorie » qui définit des objets qui encapsulent des principes compliqués ou difficiles à démontrer, et on leur attribue des propriétés. Donc, en gros, si on peut prouver qu'une valeur donnée est officiellement « le sinus d'un angle », par exemple, alors on peut directement profiter des propriétés du sinus sans avoir à en calculer la valeur.

À l'inverse, quand on aboutit à la fin du calcul et qu'il devient nécessaire d'en déterminer la valeur exacte, comment la calculatrice procède-t-elle ? En fait, avant de rentrer dans les calculs difficiles, on peut déjà montrer qu'il est possible de la déterminer pour certains angles spéciaux. sin(30°) par exemple vaut forcément 1÷2. Mais au delà, il s'agit d'un développement limité et d'une série de Taylor. Pas TRÈS difficile quand on a compris le principe, suffisant pour ces fonctions en particulier, et surtout : rapides à calculer. Par contre, cela reste une valeur approchée ! Il n'est pas possible de connaître sa valeur exacte pour n'importe quel angle en un temps fini. Mais comme les nombres en virgule flottante sur les ordinateurs ont un format fixe, on s'arrête en fait dès que les décimales dépassent ce format.

et ce rapport (y_tireur - y_cible) / (x_tireur - x_cible) doit multiplier la vitesse du missile et le résultat etre ajouté à la position du missile.

j'ai testé mais j'ai eu une division par zéro, ce qui a bloqué le programme.

C'est normal : dès que le missile se trouve à la verticale de sa cible (alignés sur une même colonne, donc), alors la différence en x est nulle, d'où la pente « infinie » et la division par zéro. Mais de toutes façons, ce n'est pas cela qu'il te faut. Le principe est plus simple, et c'est celui que l'on a expliqué dans les commentaires précédents. Il faut en fait « projeter » ta trajectoire sur les axes. Pour faire simple :

• Si le missile est décalé de trois unités horizontalement avec sa cible et de quatre unités verticalement, alors la distance en ligne qui les sépare mesure exactement cinq unités (théorème de Pythagore) ;
• En conséquence (et réciproquement), si tu veux te déplacer de cinq unités le long de cette trajectoire, il te déplacer de trois unités horizontalement et quatre verticalement ;
• Et par extension, si tu souhaites ne te déplacer que d'une unité à la fois, alors il faut tout diviser par cinq. Donc 5÷5 = 1 unité le long de la trajectoire, 3÷5 unités horizontalement (donc 0,6) et 4÷5 unités verticalement (donc 0,8).

À partir du moment où tu as tout ramené à « n unités pour 1 », tu peux re-multiplier le tout par un coefficient « vitesse » comme tu l'as toi-même déduit plus haut.

Évidemment, tout cela est beaucoup plus clair, en principe, avec un petit schéma sur papier. Ça devient même trivial.

[nouby]

salut !

je comprend clairement ce que tu écris et c'est détaillé, mais je n'arrive pas à voir comment je peux faire concrètement, le mettre en application quoi.

mon cerveau franchement ne sait pas imaginer ce genre de calculs.
je suis coincé dans mon code pour le moment.

c'est comme aux echecs, je sais jouer mais je sais pas imaginer des solutions.
Par contre je suis très bon dans d'autres domaines.

Comment fait-on pour éviter la division par zéro ?

Il faut en fait « projeter » ta trajectoire sur les axes. Pour faire simple :

Si le missile est décalé de trois unités horizontalement avec sa cible et de quatre unités verticalement, alors la distance en ligne qui les sépare mesure exactement cinq unités (théorème de Pythagore) ;
En conséquence (et réciproquement), si tu veux te déplacer de cinq unités le long de cette trajectoire, il te déplacer de trois unités horizontalement et quatre verticalement ;
Et par extension, si tu souhaites ne te déplacer que d'une unité à la fois, alors il faut tout diviser par cinq. Donc 5÷5 = 1 unité le long de la trajectoire, 3÷5 unités horizontalement (donc 0,6) et 4÷5 unités verticalement (donc 0,8).

C'est vrai que dans ma tête, le rapport entre les deltas, c'était un angle, mais en fait c'est ce que tu appelles le coefficient directeur d'une droite, sa pente.
mais ce coefficient, je sais pas comment l'utiliser car il devient division par zéro à un moment donné.
ah je viens de comprendre un truc, c'est que si je veux rester le long de la diagonale, je dois avancer de 0.6 dans le sens des X donc la largeur et 0.8 dans le sens des Y donc la hauteur, et ça fait un pas, donc si je veux faire trois pas le long de la pente alors ça fera trois fois 0.6 en largeur et trois fois 0.8 en hauteur, et en fait ces pas, c'est la vitesse donc la formule serait : vitesse x 0.6 en horizontal, et vitesse x 0.8 en hauteur.
Et comme tu as dis que le 0.6 on l'obtient en faisant : largeur / hypothénuse, et le 0.8 on l'obtient en faisant hauteur / hypothénuse, et cette largeur c'est Dtx et cette hauteur c'est Dty.

donc la formule au final c'est :
x du missile = (Dtx/hypothenuse) x vitesse.
y du missile = (Dty/hypothenuse) x vitesse.

Bon il faut d'abord avoir l'hypoténuse quoi. J'ai vu sur le livre de math que c'était a² + b² donc ici 3² + 4² = 9 + 16 = 25 et je fais ensuite racine carrée de 25 pour avoir la longueur de la pente, l'hypoténuse : résultat = 5.

Et si je résume le tout, ça fait :
missile_x = ( (tireur_x - cible_x) / hypoténuse ) x vitesse
missile_y = ( (tireur_y - cible_y) / hypoténuse ) x vitesse


appliqué à mon code je peux faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    def Calcul_coef(self,tireur_pos,cible_pos) :
        dty = (tireur_pos[1] - cible_pos[1])
        dtx = (tireur_pos[0] - cible_pos[0])
        a_carre = dty ** 2
        b_carre = dtx ** 2
        pente_carre = a_carre + b_carre
        pente = sqrt(pente_carre)
        coefy = dty/pente
        coefx = dtx/pente       
        return coefy,coefx

Le double astérique ** c'est l'élevation en puissance et là j'ai élevé à 2, donc au carré quoi.
et sqrt() c'est une fonction du module math qui donne la racine carrée d'un nombre.


ensuite je peux avoir x du missile et y du missile en faisant :

x = coefx * missile_vitesse
y = coefy * missile_vitesse

puis :

missile_x += x
missile_y += y

ou directement :

missile_x += coefx * missile_vitesse
missile_y += coefy * missile_vitesse

Dites-moi si c'est bon !!!

EDIT :
J'ai fait un essai, mais les tireurs tiraient dans le sens opposé, donc vers le haut, et leurs tirs s'loignaient du centre, ça partait en éventail, en dispersion.
Donc j'ai mis un moins (-) devant chaque coef, pour l'inverser, et ça marche, mais les tireurs ne visent pas bien, j'en reviens en fait à mon problème de départ qui était que les tireurs visaient juste seulement si la vitesse des missiles était au moins de 10, donc grande vitesse, alors que moi j'aurais voulu une vitesse moins grande (comme 4) pour mes missiles.

Au final j'obtiens le même résultat que lorsque j'utilisais le cos et sinus, et mon problème n'est pas résolu.
Une chose de bien c'est que j'ai mis en application la trigo et j'ai mieux compris le déplacement des missiles et pourquoi on appelait "pente" l'hypoténuse.
Et ça c'est grace à tous ceux qui m'ont expliqué le rapport entre les delta x et y et la pente.
Je vous remercierais jamais assez pour vos super explications approfondies !!!

[User]

Bonjour,

Concernant ton code Python :

En faisant tireur - cible, tu calcules le vecteur qui va de la cible vers le tireur, il faut inverser :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
dty = cible_pos[1] - tireur_pos[1]
dtx = cible_pos[0] - tireur_pos[0]
 
# Calcul de l'angle de tire 
angle = math.atan2(dty, dtx)
 
# Calcul du vecteur de déplacement
vx = math.cos(angle) * vitesse_missile 
vy = math.sin(angle) * vitesse_missile 
 
...

math.cos(angle) : correspond à ton coefx = dtx/distance (distance calculée avec Pythagore)
math.sin(angle) : correspond à ton coefy = dty/distance

Cdlt,

[nouby]

Merci User !

[User]

Merci User !

De rien

...La cible ici c'est mon vaisseau qui peut bouger dans tout l'écran.

...les tireurs visaient juste seulement si la vitesse des missiles était au moins de 10, donc grande vitesse, alors que moi j'aurais voulu une vitesse moins grande (comme 4) pour mes missiles.

Si la cible bouge pendant le déplacement du missile en ligne droite, un missile plus rapide a plus de chances de la toucher, car la cible a moins de temps pour s'éloigner de sa position au moment du tir.

Cdlt

[nouby]

Si la cible bouge pendant le déplacement du missile en ligne droite, un missile plus rapide a plus de chances de la toucher, car la cible a moins de temps pour s'éloigner de sa position au moment du tir.

Oui, effectivement, mais mon vaisseau ne bougeait pas pour le test, seuls les ennemis bougeaient.
l'angle de tir est calculé au moment du tir, c'est pour ça que je me demande comment ils peuvent rater leur tir pour certains.

[Obsidian]

Juste trois petits points (pour éviter de partir à nouveau dans une longue digression)

l'angle de tir est calculé au moment du tir, c'est pour ça que je me demande comment ils peuvent rater leur tir pour certains.

— Tu n'as pas besoin d'utiliser un angle (et de recourir ensuite à sinus et cosinus) si tu cherches juste à établir une trajectoire entre deux points du plan (dans un repère orthonormé). Un vecteur suffit ;
— Les missiles peuvent bien sûr rater leur cible si celles-ci se déplacent entre le moment où le missile est lancé et celui où il arrive à destination ;
— Les missiles peuvent rater leur cible si le missile parcourt des positions discrètes (ponctuelles) et que la cible se trouve entre deux d'entre elles ;

Sur ce dernier point, si ton missile part de zéro et que tu lui fais parcourir une unité à la fois, et que par ailleurs la cible se trouve en « 5,5 », alors le missile va parcourir les positions 1, 2, 3, 4 et 5 puis 6, 7, 8, etc. Il va donc passer directement de 5 à 6 sans passer par 5,5 et la position du missile ne sera donc jamais « égale » à celle de la cible : seulement inférieure puis supérieure.

C'est un cas de figure très classique quand on débute et que l'on code ce genre de projet. La détection de collision est un problème habituel, pas forcément difficile, mais qui demande quand même un peu de réflexion quand on y est confronté, surtout quand on cherche à la rendre efficace. Il était essentiel, surtout sur les vieilles machines, qu'elle retourne un résultat très rapidement et sans consommer trop de ressources.

[nouby]

— Tu n'as pas besoin d'utiliser un angle (et de recourir ensuite à sinus et cosinus) si tu cherches juste à établir une trajectoire entre deux points du plan (dans un repère orthonormé). Un vecteur suffit ;

Salut !

oui, j'utilise seulement la trigo comme vous me l'avez montré.
je parlais du coefficient qui ensuite dans le mouv() sera multiplié par la vitesse du missile et ajouté à la position du missile.

quand au fait de rater une cible par dépassement ou non-atteinte, du point vaisseau par rapport au nouveau point du missile, cela n'arrive pas dans mon cas, car le missile fait sa rencontre non pas avec un point mais avec le rect du vaisseau cible. et de plus, le tir manqué sur mon écran ne se fait pas par dépassement mais par direction, c'est à dire que le tir ennemi arrive soit à gauche soit à droite de la cible, selon qui est le tireur, et parfois directement sur la cible.
c'est un ratage "horizontal" si je puis dire ainsi.
et la cible est fixe.

[fred1599]

Hello,

Pour compléter les excellents retours de Bousk, f-leb, Obsidian et User, et répondre à ton problème de missiles qui ratent une cible fixe (surtout à faible vitesse), voici la pièce manquante du puzzle.

Le problème de décalage ou de trajectoire "approximative" que tu rencontres provient très probablement de la perte de précision due aux coordonnées entières dans Pygame.

1. Le piège des entiers (pygame.Rect)
Dans Pygame, les positions stockées dans les objets Rect (comme rect.x, rect.y, rect.center) sont obligatoirement des nombres entiers. Si ton calcul mathématique donne un déplacement de 2.4 pixels à cette frame, Pygame va le tronquer à 2. La partie décimale (0.4) est perdue. Cette erreur d'arrondi s'accumule à chaque image et dévie complètement le missile de sa cible originelle. Plus ton missile est lent, plus cette erreur est visible.

2. La solution moderne : Les flottants et pygame.Vector2
Pour régler cela sans avoir à recoder le théorème de Pythagore à la main (comme l'a très bien expliqué Obsidian), Pygame dispose d'un outil natif parfait : la classe pygame.Vector2. Elle gère les mathématiques flottantes et la "normalisation" de vecteurs de manière transparente.

Voici l'approche structurelle à adopter pour ton missile (sans les formules trigonométriques complexes) :

Le ciblage initial (au tir) : Comme dit Bousk, tu captures la position (x, y) du joueur et du tireur une seule fois au moment de l'instanciation du tir. Attention : utilise bien les centres des objets, sinon le tir partira d'un coin pour viser un autre coin.

Le calcul du vecteur : Tu crées le vecteur direction avec une simple soustraction : direction = pygame.Vector2(centre_cible) - pygame.Vector2(centre_tireur) (ce qui respecte le sens d'arrivée donné par User).

La normalisation : Tu appelles direction.normalize(). Cela réduit automatiquement le vecteur à une longueur de 1, tout en conservant l'angle de tir pur. Il suffit ensuite de multiplier ce vecteur pur par ta vitesse (ex: vitesse = 200).

Mouvement et Delta Time : Comme l'a judicieusement suggéré f-leb, tu multiplies cette vélocité par le temps écoulé (dt ou delta_time) pour que le déplacement soit indépendant des FPS.

L'astuce finale (Le secret) : Ne modifie jamais self.rect pour les calculs physiques. Ton missile doit posséder un attribut self.position de type Vector2 (flottants). À chaque frame, tu mets à jour ce vecteur flottant précis : self.position += velocite * dt. Et seulement à la fin, tu viens forcer le centre du rect à s'aligner sur cette position (Pygame arrondira pour l'affichage, mais la donnée physique interne gardera sa précision).
Avec cette architecture, tes missiles fileront droit sur leur cible, quelle que soit leur vitesse, et tu n'auras plus besoin de jongler avec math.atan2 ou math.cos.