¿Por qué mi objeto se mueve más rápido a 45 grados que a 90 grados?

Tengo objetos en mi juego que se mueven más rápido a 45 grados que a 90 grados.

Cada objeto tiene

• Posición del punto (x, y)
• Dirección Vector2D (x, y)
• Int velocidad

Y lo que hago durante una actualización es que la nueva posición se calcula como:

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

¿Cómo corrijo esto? Quiero que se mueva con la misma velocidad en cualquier ángulo.

Esto se puede explicar con el Teorema de Pitágoras , que es la siguiente fórmula:

a² + b² = c²

En su caso, cuando se mueve hacia la derecha, está usando (x: 1, y: 0) que nos da

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

Cuando se mueve hacia arriba y hacia la derecha, está usando (x: 1, y: 1) que nos da

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

Como puede ver, la longitud en diagonal es más larga que la longitud en los ejes cardinales.

Como otros han mencionado, simplemente debe normalizar su vector de dirección. Si usa XNA, se hace así:

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

Normalice su vector de dirección antes de usar.

Como lo explicó MindWorX, esto puede entenderse simplemente, si te preocupa que tus vectores de dirección puedan darte pena, asegúrate de que sean vectores unitarios (magnitud / longitud 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

Si está normalizado:

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

¿Cómo estás calculando tu dirección? Si 45 grados es (1,1), entonces ciertamente será más rápido que 90 grados (1,0).

Te sugiero que uses algo como esto:

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

Para obtener el ángulo en radianes, tendrás que multiplicar tus grados con PI / 180o incluso mejor, usar MathHelper. P.ej.

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

Jason

En lugar de tener tres atributos de objeto,

• Posición del punto (x, y)
• Dirección Vector2D (x, y)
• Int velocidad

A menudo es mucho más fácil combinar la dirección y la velocidad en un vector de velocidad. Entonces solo tienes dos atributos,

• Posición del punto (x, y)
• Vector2D (x, y) velocidad

Puesto de actualización

Cuando necesita actualizar la posición del objeto, es tan simple como:

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

¿Dónde Δtestá su delta de tiempo, o diferencia de tiempo, o paso de tiempo?

Actualización de posición y velocidad

También es muy fácil manejar la aceleración (como la gravedad). Si tiene un vector de aceleración, puede actualizar la velocidad y la posición juntas de la siguiente manera:

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 es básicamente la fórmula s = vt + ½at² de Física 101.)

Aplicando una velocidad

Si desea aplicar una velocidad dada en una dirección normalizada, puede establecer la velocidad de esta manera:

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

Derivando una velocidad

Y si necesita hacer lo contrario, derivando la velocidad y la dirección de un vector de velocidad dado, simplemente puede usar el teorema de Pitágoras o el .Length()método:

speed = velocity.Length();

Y una vez que se conoce la velocidad, la dirección normalizada se puede calcular dividiendo la velocidad por la velocidad (teniendo cuidado de evitar dividir por cero):

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