Estoy creando un juego espacial en 2D y necesito hacer que la nave espacial intercepte un planeta. Tengo un código de trabajo para las intersecciones en línea recta, pero no puedo entender cómo calcular la ubicación de los planetas en una órbita circular.

El juego no es científicamente preciso, así que no me preocupa la inercia, la gravedad, las órbitas elípticas, etc.

Conozco la ubicación y la velocidad de las naves espaciales y también la órbita (radio) y la velocidad de los planetas.

Una solución analítica para esto es difícil, pero podemos usar la búsqueda binaria para encontrar una solución dentro de la precisión requerida.

El barco puede alcanzar el punto más cercano en la órbita en el tiempo t_min :

shipOrbitRadius = (ship.position - planet.orbitCenter).length;
shortestDistance = abs(shipOrbitRadius - planet.orbitRadius);
t_min = shortestDistance/ship.maxSpeed;

La nave puede alcanzar CUALQUIER punto de la órbita en un tiempo menor o igual que t_max :

(Aquí, por simplicidad, supongo que el barco puede conducir a través del sol. Si desea evitar esto, entonces deberá cambiar a caminos que no sean de línea recta por al menos algunos casos. "Los círculos de besos" pueden verse bien y orbitales) mecánica-y, sin cambiar el algoritmo en más de un factor constante)

if(shipOrbitRadius > planet.orbitRadius)
{
   t_max = planet.orbitRadius * 2/ship.maxSpeed + t_min;
}
else
{
   t_max = planet.orbitRadius * 2/ship.maxSpeed - t_min;
}

Si nuestro período orbital es corto, podríamos mejorar en este límite superior eligiendo t_maxser la primera vez después de t_minque el planeta se acerque más a la posición de inicio de la nave. Tome cualquiera de estos dos valores de t_maxes menor. Vea esta respuesta posterior para obtener una derivación de por qué esto funciona.

Ahora podemos usar la búsqueda binaria entre estos extremos, t_min y t_max . Buscaremos un valor t que obtenga el error cercano a cero:

error = (planet.positionAtTime(t) - ship.position).squareMagnitude/(ship.maxSpeed*ship.maxSpeed) - t*t;

(Con esta construcción, error @ t_min> = 0 y error @ t_max <= 0, por lo que debe haber al menos una intersección con error = 0 para un valor t intermedio)

donde, para completar, la función de posición es algo así como ...

Vector2 Planet.positionAtTime(float t)
{
  angle = atan2(startPosition - orbitCenter) + t * orbitalSpeedInRadians;
  return new Vector2(cos(angle), sin(angle)) * orbitRadius + orbitCenter;
}

Tenga en cuenta que si el período orbital del planeta es muy corto en comparación con la velocidad de la nave, esta función de error puede cambiar los signos varias veces durante t_min a t_max. Simplemente haga un seguimiento del primer par + ve & -ve que encuentre y continúe buscando entre ellos hasta que el error esté lo suficientemente cerca de cero ("lo suficientemente cerca" es sensible a sus unidades y contexto de juego. El cuadrado de la mitad de la duración del cuadro puede funciona bien, eso asegura que la intercepción sea precisa dentro de un marco)

Una vez que tengas un buen t para minimizar errores, puedes apuntar la nave hacia planet.positionAtTime (t) y acelerar a fondo, seguro de que el planeta llegará a ese punto al mismo tiempo que tú.

Siempre puede encontrar una solución dentro de las iteraciones Log_2 ((2 * orbitRadius / ship.maxSpeed) / errorThreshold). Entonces, por ejemplo, si mi nave puede atravesar la órbita en 60 cuadros, y quiero una intersección precisa dentro de un cuadro, necesitaré alrededor de 6 iteraciones.

No complicamos demasiado esto. Esta no es una solución "perfecta", pero debería funcionar para la mayoría de los juegos y cualquier imperfección debería ser invisible para el jugador.

if(!OldTargetPoint)
  TargetPoint = PlanetPosition;
else
  TargetPoint = OldTargetPoint;
Distance = CurPosition - TargetPoint;
TimeNeeded = Distance / Speed;
TargetPoint = PlanetPositionInFuture(TimeNeeded);
SteerTowards(TargetPoint);
[...repeat this every AI update, for example every second...]

1. Calcule el tiempo necesario para alcanzar el punto objetivo.
2. Calcule en qué posición estará el planeta en el tiempo calculado.
3. Moverse hacia el punto calculado.
4. Repetir

Esto funciona porque cuanto más se acerca la nave espacial, más bajo se vuelve el error. Entonces el cálculo se vuelve más estable con el tiempo.

El error es la diferencia entre el tiempo necesario calculado para llegar al planeta (TimeNeeded) y el tiempo real necesario para llegar al planeta (después de tener en cuenta el nuevo TargetPoint).

Comencemos por echar un vistazo a las matemáticas detrás del problema.

Paso 1:

Encontrar la intersección entre una línea y una forma es solo una cuestión de insertar la ecuación de la línea en la ecuación de la forma, que en este caso es un círculo.

Toma un círculo con centro c y el radio r . Un punto p está en el círculo si

$$|p - c|^2 = r^2$$

$p = p0 + \mu v$ (donde v es un vector, http://en.wikipedia.org/wiki/Euclidean_vector ), inserta la línea en la fórmula del círculo y obtiene

$$|p0 + \mu v - c|^2 = r^2$$

La distancia al cuadrado se puede reescribir como un producto de punto ( http://en.wikipedia.org/wiki/Dot_product ).

$$(p0 + \mu v - c)•(p0 + \mu v - c) = r^2$$

$a = c - p0$$(\mu v - a)•(\mu v - a) = r^2$

$\mu ^2(v•v) - 2\mu (a•v) + a•a = r^2$

$|v| = 1$

$$\mu ^2 - 2\mu (a•v) + |a|2 - r^2 = 0$$

que es una ecuación cuadrática simple, y llegamos a la solución

$$\mu = a • v +- sqrt((a • v)^2 *a^2 – r^2)$$

$\mu < 0$

$\mu = 0$

$\mu$

Paso 2:

Entonces podemos definir una línea para el barco, y de eso obtenemos 0, 1 o 2 $\mu$ valores . Si obtenemos 1 valor, use ese. Si obtenemos 2, simplemente elija uno de ellos.

¿Qué podemos hacer con esto? Bueno, ahora sabemos la distancia que debe recorrer el barco y en qué punto terminará.

$p = p0 + \mu v$$\mu v$ componente nos da qué tan lejos tendrá que viajar. ¡Simplemente divida este último componente con la velocidad de su nave para obtener cuánto tiempo le llevará llegar allí!

Ahora, todo lo que queda por hacer es calcular dónde debería estar el planeta cuando la nave comience a acercarse a su órbita. Esto se calcula fácilmente con los denominados coodinatos polares ( http://mathworld.wolfram.com/PolarCoordinates.html )

$$x = c + r*cos(θ)$$

$$y = c + r*sin(θ)$$

$t*angularVelocity$

Resumen

Elige una línea para tu nave y ejecuta los cálculos para ver si choca con la órbita del planeta. Si lo hace, calcule el tiempo que llevará llegar a ese punto. Use este tiempo para regresar a la órbita desde este punto con el planeta para calcular dónde debería estar el planeta cuando la nave comience a moverse.

Aquí hay dos soluciones ligeramente "listas para usar".

La pregunta es: dado que la nave se mueve en línea recta a una velocidad dada, y el planeta se mueve en un círculo de radio dado a una velocidad angular dada, y las posiciones iniciales del planeta y la nave, determinan qué vector de dirección de la nave debe haber una línea recta para trazar un curso de intercepción

Solución uno: negar la premisa de la pregunta. La cantidad que es "deslizable" en la pregunta es el ángulo. En cambio, arregla eso. Apunte la nave directamente al centro de la órbita.

• Calcule la posición en la que la nave se encontrará con el planeta; eso es fácil.
• Calcule la distancia desde el barco a la posición de intercepción; También fácil.
• Calcule el tiempo que tomará hasta que el planeta alcance la posición de intercepción. Fácil.
• Divide la distancia desde la nave hasta la intersección por el tiempo hasta que el planeta llegue a la intersección.
• Si eso es menor o igual que la velocidad máxima de la nave, ya está. Pon la nave en movimiento a esa velocidad directamente hacia el sol.
• De lo contrario, agregue el período orbital del planeta al tiempo e intente nuevamente. Sigue haciéndolo hasta que obtengas una velocidad que esté dentro de lo razonable para el barco.

Solución dos: no lo hagas en piloto automático en absoluto. Haz un mini-juego en el que el jugador tenga que usar propulsores para acercarse al planeta, y si lo golpean a una velocidad relativa demasiado alta, explotan, pero también tienen combustible limitado. ¡Haz que el jugador aprenda a resolver el problema de intercepción!

$(x, y, t)$

$$t \cdot v = \sqrt{x^2 + y^2}$$

$v$

La posición del planeta en el espacio y el tiempo se puede parametrizar, p. Ej.

$$\begin{align} x &= x_0 + r \cdot cos(w \cdot u + a) \\ y &= y_0 + r \cdot sin(w \cdot u + a) \\ t &= u \end{align}$$

$u$$0$$w$$a$$u$

$$\begin{align} u \cdot v &= \sqrt{ (x0 + r \cdot cos(w \cdot u + a))^2 + (y_0 + r \cdot sin(w \cdot u + a))^2 } \implies\\ u^2 \cdot v^2 &= (x_0 + r \cdot cos(w \cdot u + a))^2 + (y_0 + r \cdot sin(w \cdot u + a))^2 \implies\\ u^2 \cdot v^2 &= {x_0}^2 + {y_0}^2 + r^2 + 2 \cdot x_0 \cdot r \cdot cos(w \cdot u + a) + 2 \cdot y_0 \cdot r \cdot sin(w \cdot u + a) \end{align}$$

Esta ecuación necesita ser resuelta numéricamente. Puede tener muchas soluciones. Al mirarlo, parece que siempre tiene una solución

Aquí hay parte de una solución. No pude terminarlo a tiempo. Lo intentaré más tarde.

Si entiendo correctamente, tienes la posición y velocidad de un planeta, así como la posición y velocidad de una nave. Desea obtener la dirección de movimiento del barco. Supongo que las velocidades de la nave y del planeta son constantes. También supongo, sin pérdida de generalidad, que el barco está en (0,0); para hacer esto, reste la posición de la nave de la del planeta y agregue la posición de la nave nuevamente al resultado de la operación que se describe a continuación.

Desafortunadamente, sin látex , no puedo formatear esta respuesta muy bien, pero intentaremos hacerlo. Dejar:

• s_s = la velocidad del barco (s_s.x, s_s.y, igualmente)
• s_a= el rumbo del barco (ángulo de movimiento, lo que queremos calcular )
• p_p = posición inicial del planeta, coordenadas globales
• p_r = la distancia del planeta (radio) desde el centro de la órbita, derivable de p_p
• p_a = el ángulo inicial del planeta en radianes, en relación con el centro de la órbita
• p_s = la velocidad angular del planeta (rad / seg)
• t = el tiempo de colisión (esto resulta ser algo que también debemos calcular)

Aquí están las ecuaciones para la posición de los dos cuerpos, desglosadas en componentes:

ship.x = s_s.x * t * cos(s_a)
ship.y = s_s.y * t * sin(s_a)

planet.x = p_r * cos(p_a + p_s * t) + p_p.x
planet.y = p_r * sin(p_a + p_s * t) + p_p.y

Como queremos ship.x = planet.xy ship.y = planet.yen algún momento t, obtenemos esta ecuación (el ycaso es casi simétrico):

   s_s.x * t * cos(s_a) = p_r * cos(p_a + p_s * t) + p_p.x
   s_s.y * t * sin(s_a) = p_r * sin(p_a + p_s * t) + p_p.y

Resolviendo la ecuación superior para s_a:

   s_s.x * t * cos(s_a) = p_r * cos(p_a + p_s * t) + p_p.x
=> s_a = arccos((p_r * cos(p_a + p_s * t) + p_p.x) / (s_s.x * t))

Sustituir esto en la segunda ecuación da como resultado una ecuación bastante aterradora que Wolfram alpha no resolverá por mí . Puede haber una mejor manera de hacer esto sin involucrar coordenadas polares. Si alguien quiere probar este método, puede hacerlo; He hecho esto un wiki. De lo contrario, puede llevar esto a Math StackExchange .

Arreglaría la ubicación en la que interceptar (pastar el círculo, en el lado "saliente" de la órbita).

Ahora solo tienes que ajustar la velocidad de la nave espacial para que el planeta y la nave lleguen a ese punto al mismo tiempo.

Tenga en cuenta que la cita podría ser después de N órbitas más, dependiendo de qué tan lejos esté la nave y qué tan rápido el planeta orbita la estrella.

Elija la N que con el tiempo se acerca más a la duración del viaje del barco a la velocidad actual.

Luego, acelere o reduzca la velocidad de la nave para que coincida exactamente con la marca de tiempo de esas N órbitas.

¡En todo esto, el curso real ya se conoce! Simplemente no la velocidad.