Se déplacer vers un point sans tremblements

Il y a une question qui reviens souvent sur ce forum qui est "comment utiliser move_towards_point sans que l'instance concernée ne tremble".
On répond systématiquement de jouer sur une distance approximative vers le point, j'ai était confronté à ce problème et la solution qu'on donne souvent ne me convenais pas, voici une solution qui va placer l'instance pile poil au bon endroit sans aucuns tremblement:

moveTowardsPoint

Code:

if( (x == argument0 && y == argument0)
||   point_distance(x, y, argument0, argument1) <= argument2 ){
    speed = 0;
    x = argument0;
    y = argument1;
}else
    move_towards_point(argument0, argument1, argument2);

Pour ce qui est des arguments on utilise le script comme la fonction native de GM :

Citation :

move_towards_point(x, y, sp) Déplace les instances avec la vitesse sp vers la position (x,y).

Ancien script :

Spoiler:

Elle est certes concise, mais elle fait pas mal de calculs superflus ta fonction... Ceci dit, je ne sais pas s'il y a un gain à passer de trop de calcul compilés (fonctions natives) à moins de calculs interprétés.

Tout dépend du nombre de params attendu par la fonction en fait, mais dans mes souvenirs faire un
if(a > b) a = b est 2x plus rapide que a = min(a, b)

Surement car la fonction min attend un nombre de paramètres variable...

Après j'avais fait un bench toutes les fonctions sont a peu près équivalentes niveau perfs, les plus lentes sont juste celles avec le plus de params.


Enfin bon ici on s'en fou un peu, c'est pas comme si ce code allait être utilisé 1000x par step quoi (quoi que avec certains  )

Citation :

Elle est certes concise, mais elle fait pas mal de calculs superflus ta fonction...

Tout les calcules effectués sont obligatoires pour le résultat voulus mais on peut certes rajouter une condition qui évite des calcules lorsque l'instance est déjà au bon endroit.

Code:

if( x == argument0 && y == argument0 ) return noone;

 

Citation :

 Ceci dit, je ne sais pas s'il y a un gain à passer de trop de calcul compilés (fonctions natives) à moins de calculs interprétés.

J'en ai pas la moindre idées mais comme dit Oni dans ce cas précis c'est pas vraiment méchant.

Mais pour le fun j'ai réécrit le script avec le minimum de fonctions natives :

Code:

if( x == argument0 && y == argument0 ) return noone;

var n1, n2, sp;

n1 = x - argument0;
n2 = y - argument1;

n1 *= n1;
n2 *= n2;

sp = n1 + n2;

if( sp < 0 ) sp *= -1;
    
sp = sqrt( sp );

if( sp >= argument2 ) sp = argument2; else sp = floor(sp);

move_towards_point( argument0, argument1, sp );

Par contre je laisse le soin à qui veux de tester la différence de performance des deux scripts (la flemme ).

Je pensais plutôt à :

Code:

if(point_distance(x, y, argument0, argument1) > argument2)
    move_towards_point(argument0, argument1, argument2);
else {
    x = argument0;
    y = argument1;
}

Oui c'est ce que je fait d'habitude mais l'effet dans certaines situations n'est pas le même (légère saccade).

Pas normal... C'est bien un "strictement supérieur" hein. Et surtout pas la fonction distance_to_point() :p

Je viens de tester les deux avec un framerate très faible pour vraiment voir la différence bha il y en as pas
Et avec ta méthode on gagne un "min()" par-contre le "speed" ne se met pas automatiquement en 0 avec ton script il faut le rajouter pour éviter tout problème. 

Je remet tout ça en ordre sur le premier post, merci pour la suggestion, comme d'hab tu optimise pas mal mes trucs

x+=(xto-x)*0.1
y+=(yto-y)*0.1

=)

Oui mais non  
La vitesse ne sera pas constante ; elle va diminuer, et en plus tu peux pas la contrôler facilement.
M'enfin l'effet peut être pas mal, mais c'est différent de move_towards_point()

Yep c'est pour un "fade progress" value. Autant pour moi =)