Il sistema solare può essere rappresentato con precisione nello spazio 3d usando i doppi (o lunghi)?

Vorrei sapere come gestire al meglio le coordinate in un gioco 3D il cui scopo è quello di modellare realisticamente l'intero sistema solare, ma essere in grado di gestire i più piccoli movimenti in una "nave" (cioè: forse possiamo considerare 1 cm come il più piccolo movimento accettabile per una cornice). I doppi a 64-bit (o 64-bit lunghi) supportano questo, o incontriamo problemi di overflow? In caso contrario, dovrebbero essere utilizzati long o double, o in tal caso, quale approccio alternativo pensi sia il più sensato per modellare le posizioni nel sistema solare in un gioco 3D? (cioè: solo tenendo un po 'del sistema alla volta in base alla distanza dalla nave, o avendo il sistema in qualche modo rappresentato in uno spazio di coordinate diverso ecc.)

C'è già una buona risposta sugli interi, ma penso che i punti mobili non debbano essere eliminati. Nella sua risposta, Byte56 ha scelto l'opzione per l'orbita massima di Plutone, probabilmente presa da questo foglio Excel , quindi mi atterrò a quello.

Ciò pone i confini del sistema solare a:

7.376.000.000 km = 7.376x10 ^ 9 km = 7.376x10 ^ 14 cm ≈ 7.4x10 ^ 14 cm

Il formato a virgola mobile a doppia precisione offre una precisione massima di 15 decimali significativi. Quindi sei fortunato: se la tua origine è al centro del Sole e usi una posizione attorno a Plutone, puoi rappresentare tutti i centimetri, ad esempio in C ++:

printf("%.0Lf\n", 7.4e14);
printf("%.0Lf\n", 7.4e14 + 1.0);
printf("%.0Lf\n", 7.4e14 + 2.0);

Output:
-------
740000000000000
740000000000001
740000000000002

Quindi, se riesci a limitare il tuo gioco all'orbita di Plutone, allora congratulazioni! Hai la precisione sufficiente con i doppi per rappresentarla.

Attenzione però, è abbastanza per rappresentarlo in una simulazione , ma non aspettarti di renderlo indolore. Dovrai convertirti in float a 32 bit, forse cambiare la tua origine in modo da avere abbastanza precisione sugli oggetti vicini e probabilmente dovrai fare affidamento su un po 'di buffer Z e inganno della fotocamera per ottenere tutto questo per renderlo correttamente .

Ora, se vuoi che i tuoi astronauti visitino alcune comete lontane nella nuvola di Oort , che è molto più grande, allora è finita. Intorno a 10 ^ 16 cm, inizi a perdere precisione:

printf("%.0Lf\n", 1.0e16);
printf("%.0Lf\n", 1.0e16 + 1.0);
printf("%.0Lf\n", 1.0e16 + 2.0);

Output:
-------
10000000000000000
10000000000000000 <-- oops
10000000000000002

E peggiora ulteriormente, ovviamente.

Quindi, se ti trovi in ​​questo caso, potresti provare alcune soluzioni più avanzate. Ti suggerisco di dare un'occhiata all'articolo di Peter Freeze in Game Programming Gems 4: "2.3 Risoluzione dei problemi di precisione nelle grandi coordinate mondiali". IIRC, suggerisce un sistema che potrebbe soddisfare le tue esigenze, è davvero una sorta di più spazi coordinati diversi.

Questi sono solo alcuni suggerimenti, probabilmente dovrai usare alcune tue ricette per farlo funzionare. Qualcuno che ha già implementato quel tipo di cose potrebbe aiutarti di più. Perché non inviare un'e-mail ai ragazzi dietro Kerbal Space Program per esempio?

Buona fortuna con il tuo gioco!

Supponendo Plutone per il "bordo" del sistema solare (anche se alcuni sostengono che siano trascorsi 3 anni luce). Plutone, alla sua orbita massima, dista circa 7.376.000.000 di chilometri dal sole. Sono 7.37600 × 10 ^ 14 centimetri. Raddoppia quello per ottenere il diametro e otterrai 1.475.200.000.000.000 di centimetri. Questo rientra nella dimensione massima di 64 bit. Poiché l'altezza del sistema solare è trascurabile rispetto al suo diametro, possiamo ignorarlo.

Quindi sì, potresti usare molto per rappresentare la tua posizione nel sistema solare. In effetti, potresti avere posizioni fino a 9,75 anni luce con un lungo firmato (doppio per non firmato).

Si noti che questo non è il caso per trovare le distanze. La distanza massima che puoi trovare è la radice quadrata della distanza massima che puoi percorrere. Questo può essere superato usando un livello di sistema di dettaglio per trovare le distanze. Puoi fare alcuni semplici controlli per indovinare quanto distano le distanze (confronta i loro valori xe y), quindi usa incrementi di 1.000.000 di chilometri per grandi distanze fino a incrementi di centimetro per piccole distanze.

Naturalmente c'è la domanda, vuoi davvero? Il 99,999% del sistema solare è spazio vuoto totalmente poco interessante. Se stai rappresentando accuratamente il sistema solare, spero sicuramente che non rappresenterai accuratamente la fisica. Ci vuole molto tempo per aggirare il sistema solare. Troppo a lungo perché la maggior parte delle persone rimanga interessata.

E perché anche avere una precisione così precisa a meno che non modellerai anche gli oggetti nel sistema solare con quella precisione? Ecco dove ti metterai nei guai. Il volume del sole è 1.40900 × 10 ^ 18 chilometri cubi. Sulla scala cubica di centimetri, l'uso di un singolo bit per indicare che quello spazio è "occupato" occupa 1,4 × 10 ^ 33 bit o 1,6 × 10 ^ 23 gigabyte. Penso che non hai molta RAM.

Puoi usare BigInteger, come lo chiama il tuo linguaggio di programmazione. È un numero intero di dimensioni illimitate; si ridimensiona bene, generalmente usando l' log(n)archiviazione per un numero intero di dimensioni n.

Java e C # ce l'hanno; Sono sicuro che lo fanno anche altre lingue. Altrimenti, puoi decompilarlo e reimplementarlo senza troppe difficoltà.