Sto creando un gioco spaziale 2D e devo fare in modo che l'astronave intercetti un pianeta. Ho un codice funzionante per le intercettazioni in linea retta ma non riesco a capire come calcolare la posizione dei pianeti in un'orbita circolare.

Il gioco non è scientificamente accurato, quindi non sono preoccupato per inerzia, gravità, orbite ellittiche, ecc.

Conosco la posizione e la velocità delle astronavi e anche l'orbita dei pianeti (raggio) e la velocità

Una soluzione analitica è difficile, ma possiamo usare la ricerca binaria per trovare una soluzione con l'accuratezza richiesta.

La nave può raggiungere il punto più vicino sull'orbita nel tempo t_min :

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

La nave può raggiungere QUALSIASI punto sull'orbita in un tempo inferiore o uguale a t_max :

(Qui, per semplicità, suppongo che la nave possa guidare attraverso il sole. Se vuoi evitarlo, dovrai passare a percorsi non rettilinei per almeno alcuni casi. "I circoli del bacio" possono sembrare belli e orbitali meccanica-y, senza modificare l'algoritmo di più di un fattore costante)

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

Se il nostro periodo orbitale è breve, potremmo essere in grado di migliorare su questo limite superiore scegliendo t_maxdi essere la prima volta dopo t_minche il pianeta si avvicina alla posizione di partenza della nave. Prendi qualunque di questi due valori di t_maxè minore. Vedi questa risposta successiva per una derivazione del perché funziona.

Ora possiamo usare la ricerca binaria tra questi estremi, t_min e t_max . Cercheremo un valore t che porti l' errore vicino a zero:

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

(Usando questa costruzione, errore @ t_min> = 0 ed errore @ t_max <= 0, quindi deve esserci almeno un'intercettazione con errore = 0 per un valore t compreso tra)

dove, per completezza, la funzione di posizione è qualcosa come ...

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

Nota che se il periodo orbitale del pianeta è molto breve rispetto alla velocità della nave, questa funzione di errore può cambiare i segni più volte nell'intervallo da t_min a t_max. Tieni traccia della prima coppia + ve & -ve che incontri e continua a cercare tra loro fino a quando l'errore è abbastanza vicino a zero ("abbastanza vicino" è sensibile alle tue unità e al contesto di gioco. Il quadrato della metà della durata del fotogramma può funziona bene - ciò garantisce che l'intercettazione sia accurata all'interno di un frame)

Una volta che hai una bella t che minimizza gli errori, puoi semplicemente puntare la nave verso planet.positionAtTime (t) e andare a tutto gas, fiducioso che il pianeta raggiungerà quel punto nello stesso momento in cui lo fai.

È sempre possibile trovare una soluzione all'interno delle iterazioni Log_2 ((2 * orbitRadius / ship.maxSpeed) / errorThreshold). Quindi, ad esempio, se la mia nave può attraversare l'orbita in 60 fotogrammi e voglio un'intercettazione accurata entro un fotogramma, avrò bisogno di circa 6 iterazioni.

Non compliciamo troppo questo. Questa non è una soluzione "perfetta", ma dovrebbe funzionare per la maggior parte dei giochi e qualsiasi imperfezione dovrebbe essere invisibile al giocatore.

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. Calcola il tempo necessario per raggiungere il punto target.
2. Calcola in quale posizione sarà il pianeta al momento calcolato.
3. Spostarsi verso il punto calcolato.
4. Ripetere

Questo funziona perché più il veicolo spaziale si avvicina e più basso diventa l'errore. Quindi il calcolo diventa più stabile nel tempo.

L'errore è la differenza tra il tempo necessario calcolato per raggiungere il pianeta (TimeNeeded) e il tempo effettivo necessario per raggiungere il pianeta (dopo aver preso in considerazione il nuovo TargetPoint).

Cominciamo dando un'occhiata alla matematica dietro il problema.

Passo 1:

Trovare l'intersezione tra una linea e una forma è solo una questione di inserimento dell'equazione della linea nell'equazione della forma, che in questo caso è un cerchio.

Prendi un cerchio con centro c e raggio r . Un punto p è sul cerchio se

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

$p = p0 + \mu v$

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

La distanza quadrata può essere riscritta come prodotto 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$$

che è una semplice equazione quadratica, e arriviamo alla soluzione

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

$\mu < 0$

$\mu = 0$

$\mu$

Passo 2:

$\mu$

Cosa possiamo fare con questo? Bene, ora sappiamo la distanza che la nave deve percorrere e in che punto finirà!

$p = p0 + \mu v$$\mu v$

Ora, tutto ciò che resta da fare è calcolare dove dovrebbe essere il pianeta quando la nave inizia a dirigersi verso la sua orbita. Questo è facilmente calcolabile con i cosiddetti coodinati polari ( http://mathworld.wolfram.com/PolarCoordinates.html )

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

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

$t*angularVelocity$

Sommario

Scegli una linea per la tua nave ed esegui la matematica per vedere se si scontra con l'orbita dei pianeti. In tal caso, calcola il tempo necessario per arrivare a quel punto. Usa questo tempo per tornare in orbita da questo punto con il pianeta per calcolare dove dovrebbe trovarsi il pianeta quando la nave inizia a muoversi.

Ecco due soluzioni leggermente "out of the box".

La domanda è: dato che la nave si muove in linea retta a una data velocità e il pianeta si muove in un cerchio di un determinato raggio a una data velocità angolare, e le posizioni di partenza del pianeta e della nave, determinano quale direzione vettore della nave la linea retta dovrebbe essere dentro per tracciare una rotta di intercettazione.

Soluzione 1: negare la premessa della domanda. La quantità che è "sfuggibile" nella domanda è l'angolo. Invece, risolvilo. Punta la nave dritta al centro dell'orbita.

• Calcola la posizione in cui la nave incontrerà il pianeta; questo è facile.
• Calcola la distanza dalla nave alla posizione di intercettazione; anche facile.
• Calcola il tempo necessario affinché il pianeta successivo raggiunga la posizione di intercettazione. Facile.
• Dividi la distanza dalla nave all'intercettazione per il tempo fino a quando il pianeta arriva all'intercetta.
• Se è inferiore o uguale alla velocità massima della nave, il gioco è fatto. Imposta la nave che si muove a quella velocità direttamente verso il sole.
• Altrimenti, aggiungi il periodo orbitale del pianeta al tempo e riprova. Continua a farlo fino a quando non ottieni una velocità ragionevole per la nave.

Soluzione 2: non farlo affatto con il pilota automatico. Crea un mini-gioco in cui il giocatore deve usare i propulsori per avvicinarsi al pianeta e se lo colpiscono a una velocità relativa troppo elevata, esplodono, ma hanno anche un carburante limitato. Fai imparare al giocatore come risolvere il problema di intercettazione!

$(x, y, t)$

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

$v$

La posizione del pianeta nello spazio e nel tempo può essere parametrizzata ad es

$$\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}$$

This equation needs to be solved numerically. It may have many solutions. By eyeballing it, it seems it always has a solution

Here's part of a solution. I didn't get to finish it in time. I'll try again later.

If I understand correctly, you have a planet's position & velocity, as well as a ship's position and speed. You want to get the ship's movement direction. I'm assuming the ship's and planet's speeds are constant. I also assume, without loss of generality, that the ship is at (0,0); to do this, subtract the ship's position from the planet's, and add the ship's position back onto the result of the operation described below.

Unfortunately, without latex, I can't format this answer very well, but we'll attempt to make do. Let:

• s_s = the ship's speed (s_s.x, s_s.y, likewise)
• s_a = the ship's bearing (angle of movement, what we want to calculate)
• p_p = the planet's initial position, global coords
• p_r = the planet's distance (radius) from the center of orbit, derivable from p_p
• p_a = the planet's initial angle in radians, relative to the center of orbit
• p_s = the planet's angular velocity (rad/sec)
• t = the time to collision (this turns out to be something we must calculate as well)

Here's the equations for the position of the two bodies, broken down into components:

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

Since we want ship.x = planet.x and ship.y = planet.y at some instant t, we obtain this equation (the y case is nearly symmetrical):

   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

Solving the top equation for 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))

Substituting this into the second equation results in a fairly terrifying equation that Wolfram alpha won't solve for me. There may be a better way to do this not involving polar coordinates. If anyone wants to give this method a shot, you're welcome to it; I've made this a wiki. Otherwise, you may want to take this to the Math StackExchange.

I would fix the location at which to intercept (graze the circle, at the "outgoing" side of the orbit.)

Now you just have to adjust the spaceship's speed so that planet and ship reach that point at the same time.

Note that the rendez-vous could be after N more orbits, depending how far away the ship is, and how fast the planet is orbiting the star.

Pick the N that in time, comes nearest to the ship's journey duration at current speed.

Then speed up or slow down ship to match the timestamp for those N orbits exactly.

In all this, the actual course is already known! Just not the speed.