Pourquoi utilisons-nous le théorème de Pythagore en physique des jeux?

J'ai récemment appris que nous utilisons beaucoup le théorème de Pythagore dans nos calculs de physique et j'ai bien peur de ne pas vraiment comprendre.

Voici un exemple tiré d' un livre pour s'assurer qu'un objet ne se déplace pas plus rapidement qu'une MAXIMUM_VELOCITYconstante dans le plan horizontal:

MAXIMUM_VELOCITY = <any number>;
SQUARED_MAXIMUM_VELOCITY = MAXIMUM_VELOCITY * MAXIMUM_VELOCITY; 

function animate(){
    var squared_horizontal_velocity = (x_velocity * x_velocity) + (z_velocity * z_velocity);

    if( squared_horizontal_velocity <= SQUARED_MAXIMUM_VELOCITY ){

        scalar = squared_horizontal_velocity / SQUARED_MAXIMUM_VELOCITY;

        x_velocity = x_velocity / scalar;
        z_velocity = x_velocity / scalar;
    }
}

Essayons cela avec quelques chiffres:

Un objet tente de déplacer 5 unités sur x et 5 unités sur z. Il ne devrait être possible de déplacer que 5 unités horizontalement au total!

MAXIMUM_VELOCITY = 5;
SQUARED_MAXIMUM_VELOCITY = 5 * 5;
SQUARED_MAXIMUM_VELOCITY = 25;

function animate(){
    var x_velocity = 5;
    var z_velocity = 5;

    var squared_horizontal_velocity = (x_velocity * x_velocity) + (z_velocity * z_velocity);
    var squared_horizontal_velocity = 5 * 5 + 5 * 5;
    var squared_horizontal_velocity = 25 + 25;
    var squared_horizontal_velocity = 50;

//  if( squared_horizontal_velocity <= SQUARED_MAXIMUM_VELOCITY ){
    if( 50 <= 25 ){
        scalar = squared_horizontal_velocity / SQUARED_MAXIMUM_VELOCITY;
        scalar = 50 / 25;
        scalar = 2.0;

        x_velocity = x_velocity / scalar;
        x_velocity = 5 / 2.0;
        x_velocity = 2.5;

        z_velocity = z_velocity / scalar;
        z_velocity = 5 / 2.0;
        z_velocity = 2.5;

        // new_horizontal_velocity = x_velocity + z_velocity
        // new_horizontal_velocity = 2.5 + 2.5
        // new_horizontal_velocity = 5
    }
}

Maintenant, cela fonctionne bien, mais nous pouvons faire la même chose sans Pythagore:

MAXIMUM_VELOCITY = 5;

function animate(){
    var x_velocity = 5;
    var z_velocity = 5;

    var horizontal_velocity = x_velocity + z_velocity;
    var horizontal_velocity = 5 + 5;
    var horizontal_velocity = 10;

//  if( horizontal_velocity >= MAXIMUM_VELOCITY ){
    if( 10 >= 5 ){
        scalar = horizontal_velocity / MAXIMUM_VELOCITY;
        scalar = 10 / 5;
        scalar = 2.0;

        x_velocity = x_velocity / scalar;
        x_velocity = 5 / 2.0;
        x_velocity = 2.5;

        z_velocity = z_velocity / scalar;
        z_velocity = 5 / 2.0;
        z_velocity = 2.5;

        // new_horizontal_velocity = x_velocity + z_velocity
        // new_horizontal_velocity = 2.5 + 2.5
        // new_horizontal_velocity = 5
    }
}

Avantages de le faire sans Pythagore:

1. Moins de lignes
2. Dans ces lignes, il est plus facile de lire ce qui se passe
3. ... et cela prend moins de temps à calculer, car il y a moins de multiplications

Il me semble que les ordinateurs et les humains obtiennent une meilleure offre sans le théorème de Pythagore! Cependant, je suis sûr de me tromper car j'ai vu le théorème de Pythagore dans un certain nombre d'endroits réputés. J'aimerais donc que quelqu'un m'explique les avantages de l'utilisation du théorème de Pythagore à un débutant en mathématiques .

Cela at-il quelque chose à voir avec les vecteurs unitaires? Pour moi, un vecteur unitaire consiste à normaliser un vecteur et à le transformer en une fraction. Nous faisons cela en divisant le vecteur par une constante plus grande. Je ne suis pas sûr de ce que c'est constant. La taille totale du graphique? Quoi qu'il en soit, comme il s'agit d'une fraction, je suppose, un vecteur unitaire est fondamentalement un graphique pouvant s'intégrer dans une grille 3D avec l'axe des abscisses allant de -1 à 1, l'axe des z allant de -1 à 1, et le y -axis allant de -1 à 1. C'est littéralement tout ce que je sais sur les vecteurs unitaires ... pas grand chose: P Et je ne vois pas leur utilité.

En outre, nous ne créons pas vraiment de vecteur unitaire dans les exemples ci-dessus. Devrais-je déterminer le scalaire comme ceci:

// a mathematical work-around of my own invention. There may be a cleverer way to do this! I've also made up my own terms such as 'divisive_scalar' so don't bother googling
var divisive_scalar = (squared_horizontal_velocity / SQUARED_MAXIMUM_VELOCITY);
var divisive_scalar = ( 50 / 25 );
var divisive_scalar = 2;

var multiplicative_scalar = (divisive_scalar / (2*divisive_scalar));
var multiplicative_scalar = (2 / (2*2));
var multiplicative_scalar = (2 / 4);
var multiplicative_scalar = 0.5;

x_velocity = x_velocity * multiplicative_scalar
x_velocity = 5 * 0.5
x_velocity = 2.5

Encore une fois, je ne vois pas pourquoi c'est mieux, mais c'est plus "unit-vector-y" parce que multiplicative_scalar est un unit_vector? Comme vous pouvez le constater, j’utilise des mots tels que "unité-vecteur-y", ce qui fait que je ne suis vraiment pas un génie des maths! Sachez également que les vecteurs unitaires n’ont peut-être rien à voir avec le théorème de Pythagore, alors ignorez tout cela si je me trompe d’arbre.

Je suis une personne très visuelle (modeleur 3D et concepteur artistique par métier!) Et je trouve les diagrammes et les graphiques vraiment utiles, afin qu'ils soient aussi nombreux que possible humainement!

Votre code sans Pythagore ne calcule pas une longueur comme nous le pensons normalement.

Normalement, dans les jeux 3D, nous modélisons le monde comme un espace euclidien, et nous utilisons une métrique de distance euclidienne ( également appelé théorème de Pythagore ) pour calculer la longueur totale d'un vecteur v avec les composantes vx et vy, à savoir:

EuclideanLength(v) = sqrt(v.x * v.x + v.y * v.y)

(Notez que cette racine carrée manque dans votre exemple de code ci-dessus, c'est pourquoi les deux approches semblent donner la même réponse. Plus d'informations à ce sujet prochainement ...)

Le code que vous avez décrit utilise la métrique de distance Manhattan :

ManhattanLength(v) = abs(v.x) + abs(v.y)

(Bien que vous n'ayez pas inclus les valeurs absolues, cela peut entraîner un comportement inattendu pour les nombres négatifs)

Il est facile de voir que ces deux fonctions de distance s'accordent lorsque vx ou vy est égal à zéro et que nous ne nous déplaçons que sur un axe. Comment se comparent-ils quand on bouge en diagonale?

Disons que vx = vy = 1. Combien de temps ce vecteur est-il équivalent (à quelle vitesse correspond la vitesse qu'il décrit)?

Euclidean                              Manhattan

sqrt(v.x*v.x + v.y * v.y)              abs(v.x) + abs(v.y)
sqrt(1 * 1 + 1 * 1)                    abs(1) + abs(1)
sqrt(2)                                1 + 1
1.414...                               2

Vous pouvez voir que ces métriques ne correspondent pas vraiment aux lignes diagonales.

Représentons sur un graphique l'ensemble des points que chaque métrique dit être à une distance de 1 de l'origine:

Notre métrique euclidienne bien connue est le cercle rouge. Ceci est l'ensemble de tous les points x, y tels que x ^ 2 + y ^ 2 = 1. Vous pouvez voir que c'est symétrique en rotation, et c'est pourquoi nous l'aimons bien: cela représente bien l'idée que la distance ne change pas avec direction.

La métrique de Manhattan est le diamant bleu. Ce n’est pas un bon choix pour notre idée intuitive de distance - mais cela n’est pas mauvais. Dans de nombreux jeux basés sur des tuiles où vous vous déplacez par étapes discrètes dans les quatre directions principales, la métrique de Manhattan donne la distance correcte entre les points (en termes de "combien de mouvements faudra-t-il pour y arriver?")

Enfin, j’ai jeté la métrique de Chebyshev pour le plaisir - c’est le carré vert:

ChebyshevLength(v) = max(abs(v.x), abs(v.y))

C'est également bon pour les jeux basés sur des tuiles, où vous êtes autorisé à vous déplacer en diagonale. Un roi aux échecs se déplace selon la métrique de Chebyshev.

J'espère que cela clarifiera la différence entre un code typique du style pythagoricien et l'exemple que vous avez fourni ci-dessus.

Sans Pythagore, vous êtes lié à une vitesse fixe sur chaque axe. Vous avez une vitesse x, une vitesse y et (dans un monde en 3D) une vitesse z qui sont toutes indépendantes les unes des autres. Tout mouvement sera aligné sur ces axes perpendiculaires.

Cependant, avec Pythagore, vous avez une vitesse qui peut être constante dans n'importe quel angle. Cela vous permet de faire disparaître la grille et de faire bouger les objets à une vitesse constante dans toutes les directions possibles.

La zone dans laquelle un objet se déplace en une seconde ressemble à ceci sans Pythagore (métrique de Chebyshev):

Et ceci avec Pythagore:

Ce dernier semble généralement beaucoup plus naturel dans de nombreux cas.