Bonjour, je fais présentement un shoot´em up 2D en C++ avec HGE et le personnage se controle de la facon suivante: les touches WASD (QWERTY) pour les mouvements et la souris pour faire pivoter le personnage. Le jeu se passe dans notre temps (1980 et +) donc l´utilisation d´armes a feu est de mise.

J´aimerais donc pouvoir "spawn" les balles tirées par mon personnage a l´endroit exacte ou se trouve le canon, j´ai donc écrit une petite fonction qui prend comme arguments 2 pointeurs pour retourner le décalage en x et en y, un rayon de cercle correspondant a la distance séparant le bout du canon ou millieu du sprite, et l´angle a laquelle se trouve le personnage.

Mon problème: le décalage donnée n´est pas exacte, les projectiles ne sont pas affiché exactement là ou je le veux. Que faire ?

voila la fonction en question:

void calc_offset(float *x, float *y, float rayon, float angle)
{
*x = rayon*(cos(angle-M_PI/2));
*y = rayon*(sin(angle-M_PI/2));
}

Je ne comprend pas ce que tu veux faire et ce qu´est sensée calculer ta fonction.

Si tu veux calculer des coordonées x et y et que tu sais que ton mouvement se passe sur un cercle, tu peux utiliser des complexes :

Ton point M est représenté par l´affixe z = x + iy = R.exp(i.théta)

Et ici, R c´est bien evidemment ton rayon, et théta ce que tu appelle ton angle.

Après, pour retrouver ton x et ton y, c´est de la trigo toute bete.

z = R.exp(i.théta) = R[cos(théta) + i.sin(théta)]
Et toi tu voudrais z de la forme z = x+iy.
En identifiant, tu trouves
x = R.cos(théta)
et y = R.sin(théta)

Donc tes formules me sembles bonnes (je sais pas pourquoi je suis partis dans la démo de ca

Par contre, je ne comprend pas pourquoi tu veux enlever PI/2.
Avec mon passage par les complexes, tu vois bien que théta c´est l´angle formé par (Ox) et OM, peut importe s´il est supérieur à PI/2.
D´ailleurs, à la rigueur, j´aurais compris ton erreur si tu voulais retrancher PI ( tu aurais alors voulu prendre l´angle aigu, et laisser l´optus, mais ca ne marcherait pas quand meme acr c´est pas ce qu´il faut).

Le seul truc que tu peux faire c´est :

float temporaire = théta/(2PI);
theta = theta - static_cast<int> (temporaire);
// Tu enleve des tours de cercle complets de 2PI car sin et cos sont periodiques de 2PI.

Mais d´ailleurs faire ceci est superflue : peut importe si ton angle est supérieur à 2PI et que plusieurs tours sont faits : les calculs des sin et des cos seront bon quand meme !

Donc en clair R.cos (théta) et R.sin(théta) devraient marcher.

Reste à voir comment tu va te servir de cette fonction, et comment tu va determiner le théta que tu passeras à chaque appel...
Bonne soirée.

Désolé si je n´ai pas été clair ^^

La raison du fait que je retranche pi/2 est simple, si je ne le fais pas, dans mon jeu les angles on toutes 90 degrées de trop.

Pour ce qui est du reste, c´est déjà ce que je fais (il me semble) alors le problème doit venir de l´angle que je fournit ou bien du rayon que j´ai mal déterminé.

Merci ! ^^

Déja, ta formule :

• x = rayon*(cos(angle-M_PI/2));
• y = rayon*(sin(angle-M_PI/2));

oublie le centre du cercle : cest donc une position relative

• x = centrex + rayon*(cos(angle-M_PI/2));
• y = centrey + rayon*(sin(angle-M_PI/2));

ira peut etre mieux.

Si tu mets angle-Pi/2, ça veut dire que ton canon, a 0, regarde vers le bas c´est ça ?

N´oublie pas que cos et sin prennent des radians et non des degrés mais tu l´as surement vu puisque tu consideres PI.

je ne sais pas comment marche ta lib d´affichage, mais bien souvent le point chaud (l´attache) est en haut a gauche. dans ton cas, il faut la considérer au milieu : donc centrex et centrey doivent etre calculés au milieu.
Pareil pour ton projectile : le point calculé sera le point au bout du canon : affiche donc ton projectile de telle sorte que ce point coincide avec son centre !

Sinon, Salegauss a raison et te propose aussi une solution avec les nombres complexe.