Por que meu objeto se move mais rápido a 45 graus do que a 90 graus?

Eu tenho objetos no meu jogo que se movem mais rápido a 45 graus do que a 90 graus.

Cada objeto tem

• Posição do ponto (x, y)
• Direção Vector2D (x, y)
• Int velocidade

E o que faço durante uma atualização é que a nova posição é calculada como:

position.x += direction.x * speed
position.y += direction.y * speed

Como faço para corrigir isso? Quero que ele se mova com a mesma velocidade em qualquer ângulo.

Isso pode ser explicado pelo teorema de Pitágoras , que é a seguinte fórmula:

a² + b² = c²

No seu caso, ao mover para a direita, você está usando (x: 1, y: 0), o que nos fornece

c² = 1 + 0 = 1
c = sqrt(1) = 1.00

Ao mover para cima e para a direita, você está usando (x: 1, y: 1), o que nos fornece

c² = 1 + 1 = 2
c = sqrt(2) = 1.41

Como você pode ver, o comprimento na diagonal é maior que o comprimento nos eixos cardinais.

Como outros já mencionaram, você deve simplesmente normalizar seu vetor de direção. Se você usa o XNA, é feito assim:

var normalizedDirection = direction;
normalizedDirection.Normalize();
position += normalizedDirection * speed

Normalize seu vetor de direção antes de usar.

Conforme explicado pelo MindWorX, isso pode ser entendido simplesmente, se você está preocupado com os vetores de direção que possivelmente causam sofrimento, verifique se eles são vetores unitários (magnitude / comprimento de 1).

Length(Vector2(1, 1)) == 1.4142135623730951 // first hint of grief
Length(Vector2(1, 0)) == 1

Vector2(1, 1) * 2 == Vector2(2, 2)
Vector2(1, 0) * 2 == Vector2(2, 0)

Length(Vector2(2, 2)) = 2.8284271247461903 // second hint
Length(Vector2(2, 0)) = 2

Se normalizado:

normal(Vector2(1, 1)) == Vector2(0.707107, 0.707107)
Length(Vector2(0.707107, 0.707107)) == 1 // perfect

Como você está calculando sua direção? Se 45 graus é (1,1), certamente será mais rápido que 90 graus (1,0).

Eu sugiro que você use algo como isto:

direction.x = Math.Cos(angleInRadians);
direction.y = Math.Sin(angleInRadians);

Para obter o ângulo em radianos, você precisará multiplicar seus graus com PI / 180ou, melhor ainda, com o uso MathHelper. Por exemplo.

angleInRadians = 45.0 * Math.PI / 180.0; // first method
angleInRadians = MathHelper.ToRadians(45f); //second method

Jason,

Em vez de ter três atributos de objeto,

• Posição do ponto (x, y)
• Direção Vector2D (x, y)
• Int velocidade

geralmente é muito mais fácil combinar a direção e a velocidade em um vetor de velocidade. Então você tem apenas dois atributos,

• Posição do ponto (x, y)
• Velocidade do vetor 2D (x, y)

Atualizando posição

Quando você precisa atualizar a posição do objeto, é tão simples quanto:

position.x += velocity.x * Δt;
position.y += velocity.y * Δt;

onde Δtestá seu delta de tempo - ou diferença de tempo - ou intervalo de tempo.

Atualizando posição e velocidade

Também é muito fácil lidar com a aceleração (como na gravidade). Se você tiver um vetor de aceleração, poderá atualizar a velocidade e a posição juntas assim:

position.x += (velocity.x * Δt) + (0.5 * acceleration.x * Δt * Δt);
position.y += (velocity.y * Δt) + (0.5 * acceleration.y * Δt * Δt);

velocity.x += acceleration.x * Δt;
velocity.y += acceleration.y * Δt;

(Esta é basicamente a fórmula s = vt + ½at² da Física 101.)

Aplicando uma velocidade

Se você deseja aplicar uma determinada velocidade em alguma direção normalizada, pode definir a velocidade da seguinte forma:

velocity.x = normalizedDirection.x * speed;
velocity.y = normalizedDirection.y * speed;

Derivando uma velocidade

E se você precisar fazer o inverso - derivando a velocidade e a direção de um determinado vetor de velocidade - você pode simplesmente usar o teorema de Pitágoras ou o .Length()método:

speed = velocity.Length();

E uma vez que a velocidade é conhecida, a direção normalizada pode ser calculada dividindo a velocidade pela velocidade (tomando cuidado para evitar a divisão por zero):

if (speed != 0) {
    normalizedDirection.x = velocity.x / speed;
    normalizedDirection.y = velocity.y / speed;
} else {
    normalizedDirection.x = 0;
    normalizedDirection.y = 0;
}