C# / VB.NET - Orbita di un oggetto in C# - XNA

Salve a tutti,
in primo luogo mi scuso se questo non è il posto giusto dove postare. Nel qual caso prego un mod di spostare nella sezione giusta ^^

Vorrei chiedervi aiuto in quanto pur sbattendoci la testa non sono riuscito a trovare una soluzione adeguata.

Ciò che vorrei fare è simulare la rotazione di un oggetto Luna attorno ad un altro oggetto Terra.
Di questi oggetti ho ovviamente un Vector3 che ne rappresenza la posizione.

Qualche idea su come risolvere?
Vi ringrazio anticipatamente

hai considerato una simulazione fisica?

gli oggetti in questione avranno 4 parametri fondamentali:
- massa (mTerra, mLuna)
- posizione (pTerra, pLuna)
- velocità (vTerra, vLuna)
- accelerazione (aTerra, aLuna)

considerando che la gravità influisce sull'accelerazione e che:

G = k * m1 * m2 / d^2 (dove G è una forza, k è una costante)

e ricordando che F = m * a, da cui a = F / m

ricaviamo che aTerra = G / mTerra
e che aLuna = G / mLuna

quindi semplificando otteniamo che:
aTerra = k * mLuna / d^2
aLuna = k * mTerra / d^2

Per trasformare queste equazioni in codice basta considerare le comuni leggi della dinamica e trasformarle in codice... (esempio in pseudocodice)

inizio:
// calcoliamo la distanza quadrata
d2 = (pTerra.x - pLuna.x)^2 + (pTerra.y - pLuna.y)^2 + (pTerra.z - pLuna.z)^2

// calcoliamo le accelerazioni
aTerra = k * mLuna / d2
aLuna = k * mTerra / d2

// i vettori corrispondenti saranno:
accVettTerra = aTerra * ((pLuna - pTerra) / (sqrt(d2))) 
accVettLuna = -accVettTerra // legge della reazione
// ricordiamo che pLuna e pTerra sono vettori

// calcoliamo le velocità
vTerra = vTerra + accVettTerra * deltaTempo
vLuna = vLuna + accVettLuna * deltaTempo

// e le posizioni
pTerra = pTerra + vTerra * deltaTempo
pLuna = pLuna + vLuna * deltaTempo

// aggiorniamo la grafica
disegnaSfera(pTerra)
disegnaSfera(pLuna)

// ricominciamo il ciclo
ripeti da inizio:

Fatta questa premessa, ricorda che le quantità vettoriali (come pTerra, vTerra, ecc...) consistono di 3 elementi (x,y,z) e che nelle equazioni dovrai tener conto di questa cosa (ad esempio ripetendo 3 volte le equazioni, oppure usando funzioni che lavorano direttamente sui vettori).
Inoltre dovrai occuparti anche della visualizzazione grafica (la funzione disegnaSfera), che per entità così semplici non è una cosa difficile e su questo sito potrai trovare diversi programmini e tutorial già pronti per l'uso...

Spero di averti dato una mano... ciao

Ciao, per prima cosa grazie della risposta.
Mi sono dimenticato di dire, sempre che siano informazioni utili, che il progetto è creato come Game XNA 3.1, e che utilizzo per i due astri dei modelli 3D salvati in fbx.

Ho provato ad implementare l'algoritmo che mi hai suggerito.
Però da un problema dopo pochi cicli del gioco : la luna inizialmente sembra fare l'orbita, poi "scappa"

Ti posto un parte del codice, perchè sicuramente avrò sbagliato io qualcosa

protected override void Update(GameTime gameTime)
{
  defineOrbit();//esegue i calcoli per la definizione delle posizioni
...
}

 private void defineOrbit()
        {
            // calcoliamo la distanza quadrata
            // d2 = (pTerra.x - pLuna.x)^2 + (pTerra.y - pLuna.y)^2 + (pTerra.z - pLuna.z)^2
            d2 =(float)( 
                Math.Pow((double)(pTerra.X - pLuna.X),2) +
                Math.Pow((double)(pTerra.Y - pLuna.Y),2) +
                Math.Pow((double)(pTerra.Z - pLuna.Z), 2));
            // calcoliamo le accelerazioni
            // aTerra = k * mLuna / d2
            // aLuna = k * mTerra / d2
            aT = k * mLuna / d2;
            aL = k * mTerra / d2;
            // i vettori corrispondenti saranno:
            // accVettTerra = aTerra * ((pLuna - pTerra) / (sqrt(d2)))
            // accVettLuna = -accVettTerra // legge della reazione
            aTerra.X = aT * ((pLuna.X - pTerra.X) / (float)Math.Sqrt((double)d2));
            aTerra.Y = aT * ((pLuna.Y - pTerra.Y) / (float)Math.Sqrt((double)d2));
            aTerra.Z = aT * ((pLuna.Z - pTerra.Z) / (float)Math.Sqrt((double)d2));
            aLuna.X = -1 * aTerra.X;
            aLuna.Y = -1 * aTerra.Y;
            aLuna.Z = -1 * aTerra.Z;
            // calcoliamo le velocità
            // vTerra = vTerra + accVettTerra * deltaTempo
            // vLuna = vLuna + accVettLuna * deltaTempo
            vTerra = vTerra + aTerra;
            vLuna = vLuna + aLuna;

            // e le posizioni
            // pTerra = pTerra + vTerra * deltaTempo
            // pLuna = pLuna + vLuna * deltaTempo 
            pTerra = pTerra + vTerra;
            pLuna = pLuna + vLuna;
        }
 

Se c'è un errore francamente non riesco a trovarlo :P

Inoltre non ci sarebbe un modo più semplice per calcolare queste posizioni?
Qualcosa che utilizzi, che ne so, seno e coseno o mostruosità simili
L'importante è che la terra rimanga ferma, e che la luna gli orbiti attorno, con questa comunque dipendente dalla posizione della terra (in pratica se sposto durante l'esecuzione la terra anche la luna si dovrà spostare di conseguenza)

che la luna scappi, o che cada sulla terra, è una cosa normale

accade anche nella realtà, ma su scale temporali di miliardi di anni.... basta solo trovare i valori corretti di velocità e posizione iniziali, e massa, per avere una simulazione decente...

Se vuoi fare una cosa meno simulativa, ma più "piacevole alla vista", allora puoi cambiare approccio e usare formule diverse:

ad esempio potresti simulare la cosa come un oggetto attaccato ad una molla. In questo caso le forumule della forza diventano quelle della molla, ma il resto rimane invariato.
Se giochi correttamente sui parametri del coefficiente elastico della molla, riuscirai ad avere un gradevole effetto di orbita, anche se fisicamente non corretto.

PS: per avere la terra sempre ferma, basta semplicemente lasciare la sua accelerazione e velocità a 0 e calcolare solo quelle della luna...
Altro esperimento che potresti fare è quello di calcolare la posizione della luna come moto circolare uniforme (quindi con seno, coseno, e tutte le cose che ti piacciono tanto), ma sarebbe un movimento troppo rigido e regolare. Inoltre spostando la terra, con le formule della molla, vedrai la luna avvicinarsi in modo "elastico", mentre con le formule del moto circolare uniforme, vedrai entrambi i corpi spostasti con un movimento rigido, poco estetico :p

Grazie degli aiuti

Ho risolto in modo poco "realistico" utilizzando come formule quelle del moto curvilineo uniforme

protected override void Update(GameTime gameTime)
{
  GameObject.SetGameObjectRotationAngle(_moon, 0.1f);

  pLuna.Y = Radius * (float)Math.Sin(MathHelper.ToRadians(_moon.getRotation())) + planetPosition.Y;
  pLuna.X = Radius * (float)Math.Cos(MathHelper.ToRadians(_moon.getRotation())) +  planetPosition.X;

  ...
  ...
}

Vedrò comunque di lavorare un po' su la formula che simula la fisica che mi hai suggerito, perchè a dir la verità mi affascina

Ti ringrazio nuovamente

eheh prego, figurati

ciao!