Realistic Model of the Solar System

This code has been declared by its author to be Public Domain code.

Realistic Model of the Solar System by Krischan

2010

This little demo simulates our solar system with realistic mass effect calculations considering the N-body-problem. Here you can play god and change some parameters:

Arrows up/down = Zoom in/out
Arrows left/right = speed increase/decrease
Space = Tracers
F1 = inner system
F2 = complete system
F3 = double sun mass
F4 = half sun mass
F5 = earth = 0.2 sun masses :-)

Please notice that due low precision here you will "lose" planets if the speed increase is too high. In 1989, Jacques Laskar of the Bureau des Longitudes in Paris published the results of his numerical integration of the Solar System over 200 million years. Laskar's work showed that the Earth's orbit (as well as the orbits of all the inner planets) is chaotic and that an error as small as 15 metres in measuring the position of the Earth today would make it impossible to predict where the Earth would be in its orbit in just over 100 million years' time. -> Stability of the solar system

; Realistic 2D-Model of the solar system 1.0
; considering the N-body problem
; with real object data from 01/01/2000

AppTitle "Realistic 2D-Model of the solar system 1.0"

; parameters
scrX	= 800		; screen width
scrY	= 600		; screen height
scrD	= 32		; color depth
scrT	= 2			; windows / fullscreen

pn		= 10		; number of planets
ps		= 3			; size of planets
zoom	= 200		; zoom factor (1=far, 250=near, 200=inner system, 5=complete)
tracers	= 1			; planet tracers on/off
sunmove = 1			; correct sun movement on/off
sunmass#= 1.0		; sun mass (1=standard)
TIM#	= 0			; reset time factor
TIMINT#	= 0.5		; increase x sun day per cycle, higher values means precision loss!
					; ex. >10 mercury gets lost

; gauss gravitional constant
K1# = .01720209895
K2# = K1# * K1#

; fields
Dim X#(pn), Y#(pn), Z#(pn), VX#(pn), VY#(pn), VZ#(pn), MASS#(pn), ro(pn), gr(pn), bl(pn)
Dim name$(pn), oldx#(pn), oldy#(pn), DEG#(pn), MU#(pn), SEMI#(pn), ECCEN#(pn)

; read planet data
Dim pla$(pn,11)
Restore planetdata
For p=0 To pn-1
	For q=0 To 11
		Read pla$(p,q)
		name$(p)=pla$(p,0)							; Name
		X#(p)=pla$(p,1)								; X-Position
		Y#(p)=pla$(p,2)								; Y-Position
		Z#(p)=pla$(p,3)								; Z-Position
		VX#(p)=pla$(p,4)							; Speed X
		VY#(p)=pla$(p,5)							; Speed Y
		VZ#(p)=pla$(p,6)							; Speed Z
		MASS#(p)=Float(pla$(p,7))*10^Int(pla$(p,8))	; Mass
		ro(p)=pla$(p,9)								; Red
		gr(p)=pla$(p,10)							; Green
		bl(p)=pla$(p,11)							; Blue
	Next
Next

; Object Data from 01/01/2000
.planetdata
;    Name              POS X         POS Y         POS Z             Vx             Vy             Vz   Mass*10^X      R     G     B
Data "Sonne"   ,   0.0000000 ,   0.0000000 ,   0.0000000 ,  0.000000000 ,  0.000000000 ,  0.000000000 , 1.991 , 30 , 255 , 255 ,   0
Data "Merkur"  ,  -0.1778023 ,  -0.3863251 ,  -0.1879025 ,  0.020335410 , -0.007559570 , -0.006147710 , 3.191 , 23 , 255 ,  64 ,   0
Data "Venus"   ,   0.1787301 ,  -0.6390267 ,  -0.2987722 ,  0.019469170 ,  0.004915870 ,  0.000978980 , 4.886 , 24 , 255 , 192 , 128
Data "Erde"    ,  -0.3305873 ,   0.8497269 ,   0.3684325 , -0.016483420 , -0.005365460 , -0.002326460 , 5.979 , 24 ,   0 ,   0 , 255
Data "Mars"    ,  -1.5848092 ,  -0.3648638 ,  -0.1244522 ,  0.003821510 , -0.011241840 , -0.005259630 , 6.418 , 23 , 255 ,   0 ,   0
Data "Jupiter" ,   4.1801700 ,  -2.5386080 ,  -1.1900210 ,  0.004106423 ,  0.006125327 ,  0.002525539 , 1.901 , 27 , 128 , 255 ,   0
Data "Saturn"  ,  -4.6197080 ,  -8.2374610 ,  -3.2033610 ,  0.004647751 , -0.002328957 , -0.001161564 , 5.684 , 26 , 255 , 255 , 128
Data "Uranus"  ,  -3.7245900 , -17.1975200 ,  -7.4791700 ,  0.003833665 , -0.000845721 , -0.000424809 , 8.682 , 25 ,   0 , 255 , 255
Data "Neptun"  ,   1.9138100 , -27.9215500 , -11.4762000 ,  0.003118271 ,  0.000233303 ,  0.000017967 , 1.027 , 26 ,   0 , 128 , 255
Data "Pluto"   , -23.2285900 , -18.5272000 ,   1.2167500 ,  0.002066577 , -0.002488884 , -0.001397200 , 1.080 , 24 , 128 , 128 , 128

; Normalize Mass to sun
For I = 1 To pn-1
	MASS#(I) = MASS#(I) / MASS(0)
Next
MASS#(0) = sunmass#

; create reduced mass in gauss units
For I = 1 To pn-1
	MU#(I) = K2# * (1 + MASS#(I))
Next

; init screen
Graphics scrX,scrY,scrD,scrT
SetBuffer BackBuffer()

; main loop
While Not KeyHit(1)
	
	; increase time by factor
	TIM# = TIM# + TIMINT#
	
	; draw tracers
	For i=0 To pn-1
		If tracers Then Color 32,32,32 Else Color 0,0,0
		Oval(scrX/2+oldx#(i),scrY/2+oldy#(i),ps,ps,1)
	Next
	
	; calculations and output
	Gosub NewV
	Gosub NewP
	
	Rect 0,0,150,42,1
	Color 255,255,255
	
	Text 0, 0,"Days:  "+Int(TIM#)
	Text 0,10,"Years: "+TIM#/365.25
	Text 0,20,"Time:  "+TIMINT#
	Text 0,30,"Zoom:  "+zoom
	
	; Keyboard shortcuts
	; ------------------
	; Arrows up/down		Zoom in/out
	; Arrows left/right		speed increase/decrease
	; Space					Tracers
	; F1					inner system
	; F2					complete system
	; F3					double sun mass
	; F4					half sun mass
	; F5					earth = 0.2 sun masses :-)
	
	kp=0
	If KeyDown(200) Then zoom=zoom+1:If zoom>250 Then zoom=250
	If KeyDown(208) Then zoom=zoom-1:If zoom<1 Then zoom=1
	If KeyDown(203) Then TIMINT#=TIMINT#-.5:If TIMINT#<.5 Then TIMINT#=.5
	If KeyDown(205) Then TIMINT#=TIMINT#+.5:If TIMINT#>25 Then TIMINT#=25
	If KeyHit(57) Then tracers=1-tracers:Cls
	If KeyDown(59) Then zoom=200:Cls
	If KeyDown(60) Then zoom=5:Cls
	If KeyDown(61) Then MASS#(0)=2
	If KeyDown(62) Then MASS#(0)=0.5
	If KeyDown(63) Then MASS#(3)=.2
	
	Flip 1
	
Wend

End


;  calc new speed
.NewV
For I = 0 To pn-1
	
	AX# = 0
	AY# = 0
	AZ# = 0
	
	For J = 0 To pn-1
		If (J = I) Then Goto skip
		XJI# = X#(J) - X#(I)
		YJI# = Y#(J) - Y#(I)
		ZJI# = Z#(J) - Z#(I)
		R# = Sqr(ZJI# * ZJI# + YJI# * YJI# + XJI# * XJI#)
		R3# = R# * R# * R#
		COEFF# = K2# * MASS#(J) / R3#
		AX# = COEFF# * XJI# + AX#
		AY# = COEFF# * YJI# + AY#
		AZ# = COEFF# * ZJI# + AZ#
		.skip
	Next
	
	VX#(I) = VX#(I) + AX# * TIMINT#
	VY#(I) = VY#(I) + AY# * TIMINT#
	VZ#(I) = VZ#(I) + AZ# * TIMINT#
	
Next

Return

; calc new positions and draw planets
.NewP
For i=0 To pn-1
	
	; calc new position
	X#(i) = X(i) + VX#(i) * TIMINT#
	Y#(i) = Y(i) + VY#(i) * TIMINT#
	Z#(i) = Z(i) + VZ#(i) * TIMINT#
	
	; include zoom factor
	sx#=X#(i)*zoom
	sy#=Y#(i)*zoom
	
	; correct sun movement
	If i=0 And sunmove=1 Then
		sunx#=sx#
		suny#=sy#
	EndIf
	
	; new position with zoom and sun movement
	sx#=sx#-sunx#
	sy#=sy#-suny#
	
	; save old position for tracers
	oldx#(i)=sx#
	oldy#(i)=sy#
	
	; draw planets
	Color ro(i),gr(i),bl(i)
	Oval(scrX/2+sx#,scrY/2+sy#,ps,ps,1)
Next

Return

Comments

slenkar

2010

you could use this for astrology, to know where the planets are at a persons time of birth

epiblitikos

2010

SWEET! I'm gonna play with this when I'm bored.

Filax

2012

another gravity code :) blitzmax

Const Grav# = 10.0			' Or whatever
Const dt# = 1.0/60.0	' Fixed 60Hz

Const MAX_PLANETS = 300

Print "Available graphics modes:"
OpenBigScreen()

Function OpenBigScreen()
	
	Local mode:TGraphicsMode
	Local curX:Int,curY:Int
	
	For mode=EachIn GraphicsModes()
		
		If mode.width>curX Then 
			curX=mode.width
			curY=mode.height
		EndIf
		
		Print mode.width+","+mode.height+","+mode.depth+","+mode.hertz
	Next
 
	Print ">"+ curX+","+ curY
	Graphics(curX, curY, 32)
	
End Function

Global sprite:TImage=LoadImage("white_dot02.png")
SetBlend LIGHTBLEND


Type Body
	Field x#, y#, vx#, vy#, M#
	Field red%,green%,blue%
	
	Field size#
	
	Method Draw()
		'DrawOval(x-size, y-size, size, size)
		
		SetColor red%,green%,blue%
		DrawImageRect sprite,x-(size/2), y-(size/2), size, size

	EndMethod
EndType


Local Sun:Body = New Body
Sun.x = GraphicsWidth()/2.0
Sun.y = GraphicsHeight()/2.0
Sun.vx = 0.0
Sun.vy = 0.0
Sun.M = 900000.0
Sun.size = 466.0

Sun.red%=255
Sun.green%=255
Sun.blue%=255


Local Planet:Body[MAX_PLANETS]
For Local i=0 Until MAX_PLANETS
	Planet[i] = New Body
	Planet[i].x = RndFloat()*GraphicsWidth()
	Planet[i].y = RndFloat()*GraphicsHeight()
	
	Planet[i].red%=150
	Planet[i].green%=200
	Planet[i].blue%=200+Rnd(55)

	Planet[i].M = Rnd(10.0,100.0)
	Planet[i].size = Planet[i].M
	
	'Planet[i].vx = (RndFloat()-1.5)*Planet[i].M 
	'Planet[i].vy = (RndFloat()-1.5)*Planet[i].M 
	
	'Planet[i].vx = (RndFloat()-0.5)*Planet[i].M 
	'Planet[i].vy = (RndFloat()-0.5)*Planet[i].M 

	Planet[i].vx = (RndFloat()-1.1)*(Planet[i].M /2)
	Planet[i].vy = (RndFloat()-1.1)*(Planet[i].M /2)
			
Next


While Not KeyHit(KEY_ESCAPE)
	Cls()
	
	Sun.Draw()
	
	' Apply the sun's gravity to each of our planets
	' We ignore the effect the other planets have on the sun and on each other
	For Local p:Body = EachIn Planet

		' Euler physics
		p.x :+ p.vx*dt
		p.y :+ p.vy*dt


		' g = -GM/(r*r)
		Local rx# = p.x-Sun.x
		Local ry# = p.y-Sun.y
		Local r# = Sqr(rx*rx + ry*ry)

		If r>Sun.size	' Don't do it if it's too close
			Local g# = -grav#*Sun.M/(rx*rx + ry*ry)
			Local gx# = rx/r * g
			Local gy# = ry/r * g
		
			p.vx :+ gx*dt
			p.vy :+ gy*dt
		EndIf

		
		p.Draw()
	Next
	
	Flip()
Wend

Rick Nasher

2014

Hi,
Does anybody, or perhaps Krischan himself if snooping around here(btw: great fan of all your code), know how the distances can be scaled up to reflect 'realistic' sizes of the planets?

I'm redoing my own little planetary, but the orbits and calculations are apparently sort of realistic in this one, so looking to see how to encorporate the math into my own stuff. Unfortunately I have to admit the math is beyond me, and don't see how to adjust the code for 3d 'real' distances without messing up the accuracy.

Below a 3D-ified version of the code, in which I had to mess with the sizes as the size of the sun alone would be so big it would cover the entire inner planet system.

; ID: 2746
; Author: Krischan
; Date: 2010-07-31 05:09:57
; Title: Realistic Model of the Solar System
; Description: Realistic 2D-Model of the Solar System considering the N-body problem
;
; Realistic 2D-Model of the solar system 1.0
; considering the N-body problem
; with real object data from 01/01/2000
;
; 
; 'Adapted'(or messed up if you like ;-) for 3d by Rick Nasher.
; to do: real distance/dimensions mode / overview mode.
; to add: moons, rings, nebula's, lighting effects, spaceship cam, etc.


AppTitle "(semi)Realistic 3D-Model of the solar system 1.1"


; parameters
Global scrX	= 1280 ;800		; screen width
Global scrY	= 800 ;600		; screen height
Global scrD	= 32		    ; color depth
Global scrT	= 2		     	; windows / fullscreen

Global pn		= 10		; number of planets
Global ps		= 3			; size of planets.. changes later in code.
Global zoom	    = 200		; zoom factor (1=far, 250=near, 200=inner system, 5=complete)
Global tracers	= 1			; planet tracers on/off
Global sunmove  = 1			; correct sun movement on/off
Global sunmass# = 1.0		; sun mass (1=standard)
Global TIM#  	= 0			; reset time factor
Global TIMINT#	= 0.5    ; 0.5		; increase x sun day per cycle, higher values means precision loss!
					        ; ex. >10 mercury gets lost

Global freeze=False
Global labels=True
Global SizeScale#=0.0005    ; Global Planet Scale
Global DistScale#=1.0       ; Global Distance Scale
Global viewmode$="TopView" : topvwmode=True
Global Target=0

; init screen
Graphics3D scrX,scrY,scrD,scrT
SetBuffer BackBuffer()

; gauss gravitional constant
K1# = .01720209895
K2# = K1# * K1#

; fields / arrays
Dim X#(pn), Y#(pn), Z#(pn), VX#(pn), VY#(pn), VZ#(pn), MASS#(pn), ro(pn), gr(pn), bl(pn),dm#(pn),dst#(pn),rtp#(pn),lod#(pn),plt$(pn)
Dim name$(pn), oldx#(pn), oldy#(pn), DEG#(pn), MU#(pn), SEMI#(pn), ECCEN#(pn)
Dim PlanetSphere(pn) , plantexture(pn), TraceSphere(pn)

Dim Line(pn-1)


; read planet data
Dim pla$(pn,17)      ; planetstring 

Restore planetdata
For p=0 To pn-1  ; 10 planets from 0-9 so 10-1
	For q=0 To 16
		Read pla$(p,q)
		name$(p)  = pla$(p,0)							   ; Name                0
		X#(p)     = pla$(p,1)	: X#(p)= X#(p)*DistScale#  ; X-Position          1
		Y#(p)     = pla$(p,2)	: Y#(p)= Y#(p)*DistScale#  ; Y-Position          2
		Z#(p)     = pla$(p,3)	: Z#(p)= Z#(p)*DistScale#  ; Z-Position          3
		VX#(p)    = pla$(p,4)							   ; Speed X             4
		VY#(p)    = pla$(p,5)							   ; Speed Y             5
		VZ#(p)    = pla$(p,6)							   ; Speed Z             6
   		MASS#(p)  = Float(pla$(p,7))*10^Int(pla$(p,8))	   ; Mass                7
		ro(p)     = pla$(p,9)							   ; Red                 8
		gr(p)     = pla$(p,10)							   ; Green               9
		bl(p)     = pla$(p,11)							   ; Blue               10

		dm#(p)    = pla$(p,12)	   						   ; Diameter           11
        dst#(p)   = pla$(p,13)                             ; Distance           12

		rtp#(p)   = pla$(p,14)                             ; Rotation Period    13
		lod#(p)   = pla$(p,15)                             ; Lenght of Day      14
		plt$(p)   = pla$(p,16)                             ; Texture            15
		
	Next
	
	;ps=1+dm#(p)*SizeScale#
	ps=dm#(p)*SizeScale# ; changed to accomodate added planet dimension data
	PlanetSphere(p)=CreateSphere(32)
	ScaleEntity PlanetSphere(p),ps,ps,ps ;
	plantexture(p)=LoadTexture(plt$(p))
	EntityTexture PlanetSphere(p),plantexture(p)
	
	NameEntity PlanetSphere(p),name$(p) ; added names.
Next

;saturn rings, planning to use torus for this at a later stage.
wiref_piv = CreatePivot()
For n=1 To 10
	ring = create_ring(100,ring,1.2+(n*Rnd(.3,.4))*35, 0,255,0)
Next
EntityParent ring,wiref_piv;
	



; Object Data from 01/01/2000
.planetdata
;     0                         1              2             3            4              5              6          7       8    9    10    11       12          13        14       15    16
;                                                                                                                                               Real        Real       Rotation  Length 
;                                                                    Speed          Speed          Speed                      Color             Diameter    Distance   Period    of Day              
;     Name                     POS X         POS Y         POS Z      Vx             Vy             Vz            Mass*10^X    R     G     B    Million KM  Mill.KM    Hrs       Hrs      Texture                                 
 Data "Sun"              ,   0.0000000 ,   0.0000000 ,   0.0000000 ,  0.000000000 ,  0.000000000 ,  0.000000000 , 1.991 , 30 , 255 , 255 ,   0 , 1392000/50 ,     0.0   ,   648.0 ,    0   , "GFX\Sun\suncyl1.jpg"               ;  0        
 Data "Mercury"          ,  -0.1778023 ,  -0.3863251 ,  -0.1879025 ,  0.020335410 , -0.007559570 , -0.006147710 , 3.191 , 23 , 255 ,  64 ,   0 , 4880     , 57910.0   ,  1407.6 , 4222.6 , "GFX\Mercury\mercurycyl2.jpg"       ;  1
 Data "Venus"            ,   0.1787301 ,  -0.6390267 ,  -0.2987722 ,  0.019469170 ,  0.004915870 ,  0.000978980 , 4.886 , 24 , 255 , 192 , 128 , 12104    ,   108.16  , -5832.5 , 2802.0 , "GFX\Venus\venuscyl2.jpg"           ;  2   
 Data "Earth"            ,  -0.3305873 ,   0.8497269 ,   0.3684325 , -0.016483420 , -0.005365460 , -0.002326460 , 5.979 , 24 ,   0 ,   0 , 255 , 12742    ,   149.6   ,    23.9 ,   24.0 , "GFX\Earth\earthcyl3.jpg"           ;  3  
 Data "Mars"             ,  -1.5848092 ,  -0.3648638 ,  -0.1244522 ,  0.003821510 , -0.011241840 , -0.005259630 , 6.418 , 23 , 255 ,   0 ,   0 , 6780     ,   228.0   ,    24.6 ,   24.7 , "GFX\Mars\marscyl1.jpg"             ;  4  
;Data "Asteroidbelt"     ,             ,             ,             ,              ,              ,              ,       ,    ,     ,     ,     ,          ,           ,         ,        , "GFX\Asteroid\Asteroid.jpg"         ;   
 Data "Jupiter"          ,   4.1801700 ,  -2.5386080 ,  -1.1900210 ,  0.004106423 ,  0.006125327 ,  0.002525539 , 1.901 , 27 , 128 , 255 ,   0 , 139822   ,   778.4   ,     9.9 ,    9.9 , "GFX\Jupiter\jupitercyl2.jpg"       ;  5  
 Data "Saturn"           ,  -4.6197080 ,  -8.2374610 ,  -3.2033610 ,  0.004647751 , -0.002328957 , -0.001161564 , 5.684 , 26 , 255 , 255 , 128 , 116464   ,  1427.0   ,    10.7 ,   10.7 , "GFX\Saturn\saturncyl1.jpg"         ;  6  
 Data "Uranus"           ,  -3.7245900 , -17.1975200 ,  -7.4791700 ,  0.003833665 , -0.000845721 , -0.000424809 , 8.682 , 25 ,   0 , 255 , 255 , 50724    ,  2869.6   ,   -17.2 ,   17.2 , "GFX\Uranus\uranuscyl1.jpg"         ;  7  
 Data "Neptune"          ,   1.9138100 , -27.9215500 , -11.4762000 ,  0.003118271 ,  0.000233303 ,  0.000017967 , 1.027 , 26 ,   0 , 128 , 255 , 49248    ,  4496.6   ,    16.1 ,   16.1 , "GFX\Neptune\neptunecyl1.jpg"       ;  8  
 Data "Pluto"            , -23.2285900 , -18.5272000 ,   1.2167500 ,  0.002066577 , -0.002488884 , -0.001397200 , 1.080 , 24 , 128 , 128 , 128 , 2274     ,  5913.5   ,  -153.3 ,  153.3 , "GFX\Pluto\plutocyl1.jpg"           ;  9
;Data "Van OortCloud"    ,             ,             ,             ,              ,              ,              ,       ,    ,     ,     ,     ,          ,           ,         ,        , "GFX\VanOortCloud\VanOortCloud.jpg" ;
;Data "Proxima Centauri" ,             ,             ,             ,              ,              ,              ,       ,    ,     ,     ,     ,          ,           ,         ,        , "GFX\.jpg"                          ;                                               
;Data to add: moons, rings, nebula's


; Normalize Mass to sun
For I = 1 To pn-1
	MASS#(I) = MASS#(I) / MASS(0)
	i=I
Next
MASS#(0) = sunmass#

; create reduced mass in gauss units
For I = 1 To pn-1
	MU#(I) = K2# * (1 + MASS#(I))
Next




Global Camera=CreateCamera()
Global zzm#=-1000, camz#=-1.5
Global xcam#,ycam#,zcam#=-10000

CameraRange Camera,1,46000
PositionEntity Camera, xcam#,ycam#,zcam#

.mainloop
While Not KeyHit(1)
	
	; increase time by factor
	TIM# = TIM# + TIMINT#
	ScreenshotTaker()
    If freeze=False 
		; calculations and output
		Gosub NewV
		Gosub NewP
		
		;New Tracers
		For cnt=1 To 9 
		    TPX=Int(EntityX(PlanetSphere(cnt)))
			TPY=Int(EntityY(PlanetSphere(cnt)))
			TPZ=Int(EntityZ(PlanetSphere(cnt)))
			Line(cnt) = createLine(TPX,TPY,TPZ,  TPX,TPY,TPZ, Line(cnt))
			EntityColor(Line(cnt), 155,155,155)
		Next
	EndIf
	
	CamControl()
	
	
	PositionEntity Camera, EntityX(PlanetSphere(Target))+xcam#, EntityY(PlanetSphere(Target))+ycam#, EntityZ(PlanetSphere(Target))+zcam# ;

	
	
	; --- rendering
	CameraClsMode(camera, 1, 1)
	Wireframe(0)
    For cnt=0 To 9
		ShowEntity(PlanetSphere(cnt))
		PositionEntity wiref_piv,Int(EntityX(PlanetSphere(6))),Int(EntityY(PlanetSphere(6))),Int(EntityZ(PlanetSphere(6))),1	
	Next 
	RenderWorld()
	
	CameraClsMode(camera, 0, 0)
	Wireframe(1)
	For cnt=0 To 9
		HideEntity(PlanetSphere(cnt))
	Next 
	RenderWorld()


    ; HUD / info
	Rect 0,0,360,130,0
	Rect 750,0,530,160,0
	Color 200,200,200
	
	XTXT=8
	Text XTXT, 0,"Days: "+Int(TIM#) + "  Hours: "+Int(TIM#*24)+"  Mins: "+Int(TIM#*24*60)
	Text XTXT,20,"Years: "+TIM#/365.25 + "  Time: "+TIMINT#
	Text XTXT,50,"Zoom: "+zoom + "  CamZm: "+camz#
	Text XTXT,70,"CamX: "+EntityX(Camera)+"  CamY: "+EntityY(Camera)+"  CamZ: "+EntityZ(Camera)
	Text XTXT,90,"Tracers: "+tracers+ "   Labels: "+labels+"  ViewMode: "+viewmode$
	
	
	XTXT=750
	Text XTXT,  0," Arrows up/down    = Move horiz    |  F1    = inner system         "
	Text XTXT, 20," Arrows Left/Right = Move vert     |  F2    = complete system      "
	Text XTXT, 40," PgUp/Down         = Move in/out   |  F3    = double sun mass      "
	Text XTXT, 60," [ /  ]            = Zoom in/out   |  F4    = half sun mass        "
	Text XTXT, 80," 1 - 0             = Goto Planet   |  F5    = earth = 0.2 sun mass " 
	Text XTXT,100," T                 = Tracers       |  -/+   = speed in/decrease    "
	Text XTXT,120," L                 = Labels        |  Space = freeze               "
	Text XTXT,140," (Left)Alt         = Top/Side View |  Esc   = End program            "

	
		
	kp=0 ;?

	
	For cnt=0 To pn-1 ; for all planets..
	
		TurnEntity PlanetSphere(cnt),0,rtp#(cnt)/2400,0 ; turn planets
	
		If labels Then  ; put labels on planets
			info$=EntityName(PlanetSphere(cnt));+"x:"+Int(EntityX(PlanetSphere(cnt)))+", y:"+Int(EntityY(PlanetSphere(cnt)))+", z:"+ Int(EntityZ(PlanetSphere(cnt)));
			LabelEntity (Camera, PlanetSphere(cnt), info$)
			If tracers Then Color 132,132,132
        EndIf
		
	Next 

	Flip 1 ; 

Wend

End


;  calc new speed
.NewV
For I = 0 To pn-1
	
	AX# = 0;+DistScale#
	AY# = 0;+DistScale#
	AZ# = 0;+DistScale#
	
	For J = 0 To pn-1
		If (J = I) Then Goto skip
		XJI# = X#(J) - X#(I)
		YJI# = Y#(J) - Y#(I)
		ZJI# = Z#(J) - Z#(I)
		R# = Sqr(ZJI# * ZJI# + YJI# * YJI# + XJI# * XJI#)
		R3# = R# * R# * R#
		COEFF# = K2# * MASS#(J) / R3#
		AX# = COEFF# * XJI# + AX#
		AY# = COEFF# * YJI# + AY#
		AZ# = COEFF# * ZJI# + AZ#
		.skip
	Next
	
	VX#(I) = VX#(I) + AX# * TIMINT#
	VY#(I) = VY#(I) + AY# * TIMINT#
	VZ#(I) = VZ#(I) + AZ# * TIMINT#
	
Next

Return

; calc new positions and draw planets
.NewP
For i=0 To pn-1
	
	; calc new position
	X#(i) = X(i) + VX#(i) * TIMINT#

	Y#(i) = Y(i) + VY#(i) * TIMINT# 

	Z#(i) = Z(i) + VZ#(i) * TIMINT# 

	
	; include zoom factor
	sx#=X#(i)*zoom
	sy#=Y#(i)*zoom

	
	; correct sun movement
	If i=0 And sunmove=1 Then
		sunx#=sx#
		suny#=sy#
	EndIf
	
	; new position with zoom and sun movement
	sx#=sx#-sunx#
	sy#=sy#-suny#
	
	; save old position for tracers
	oldx#(i)=sx#
	oldy#(i)=sy#
	
	PositionEntity PlanetSphere(i), (sx#),(-sy#),0
Next

Return


Function CamControl()

	If KeyDown(56) ;And viewmode="SideView" Then ; LeftAlt=TopView 
		viewmode="TopView"
	    RotateEntity Camera, 0,0,0,0
	   ;MoveEntity Camera, 0,-150,0
	   ;PointEntity Camera,  PlanetSphere(Target)
	EndIf
	
	If KeyDown(184) ;And viewmode="TopView" Then ; RightAlt=SideView (nogo yet, needs fix)
		viewmode="SideView"
		RotateEntity Camera, 270,0,0,0
		;PositionEntity Camera, EntityX(PlanetSphere(Target)), EntityY(PlanetSphere(Target))-100, EntityZ(PlanetSphere(Target)) ;
 	    ;PointEntity Camera,  PlanetSphere(Target)
	EndIf

	If KeyDown(27) Then zoom=zoom+1:If zoom>250 Then zoom=250                    ; ]     = Zoom in
	If KeyDown(26) Then zoom=zoom-1:If zoom<1 Then zoom=1                        ; [     = Zoom out
	
	If KeyDown(13) Then TIMINT#=TIMINT#-.001:If TIMINT#<.001 Then TIMINT#=.001   ; +     = speed increase 0.5
	If KeyDown(12) Then TIMINT#=TIMINT#+.001:If TIMINT#>10 Then TIMINT#=10       ; -     = speed decrease 25
		 
	If KeyHit(20)   Then tracers =1-tracers:Cls :Delay 100				         ; T     = Trace  on/off
	If KeyHit(38)   Then labels  =1-labels:Cls :Delay 100                        ; L     = Labels on/off
	If KeyHit(57)   Then freeze=1-freeze:Cls :Delay 100				             ; Space = Freeze on/off


	If KeyDown(59)  Then zoom=200:Cls                                            ; F1    = inner system
	If KeyDown(60)  Then zoom=5:Cls                                              ; F2    = complete system
	If KeyDown(61)  Then MASS#(0)=2                                              ; F3    = double sun mass 
	If KeyDown(62)  Then MASS#(0)=0.5                                            ; F4    = 1/2   sun mass
	If KeyDown(63)  Then MASS#(3)=.2                                             ; F5    = earth = 0.2 sun masses :-)

	
	If KeyDown(201)                                                              ; PgUp  = Move cam out
		zcam#=zcam#+1.5*4
	ElseIf KeyDown(209)                                                          ; PgDown= Move cam in
		zcam#=zcam#-1.5*4
	EndIf

	
	If KeyDown(200) Then ;  Up    = move cam up
    	ycam#=ycam#+.5*4
	EndIf
	If KeyDown(208) Then ;  Down  = move cam down
		ycam#=ycam#-.5*4
	EndIf
	If KeyDown(205) Then ;  Left  = move cam left
		xcam#=xcam#+.5*4
	EndIf
	If KeyDown(203) Then ;  Right = move cam right
		xcam#=xcam#-.5*4
	EndIf
;--
	If KeyDown(2) Then ; key 1
		Target=1 ; 
		PointEntity Camera, PlanetSphere(Target) ;		
	    zcam#=100
	EndIf

	If KeyDown(3) Then ; key  2
		Target=2 ;
		PointEntity Camera, PlanetSphere(Target) ;
		zcam#=100	
	EndIf

	If KeyDown(4) Then ; key  3
		Target=3 ; Earth 
		PointEntity Camera, PlanetSphere(Target) ;
		;PositionEntity Camera , EntityX(PlanetSphere(Target)), EntityY(PlanetSphere(Target)), EntityZ(PlanetSphere(Target))-5
		zcam#=100
	EndIf

	If KeyDown(5) Then ; key  4
		Target=4 ; Mars
		PointEntity Camera, PlanetSphere(Target) ;
		zcam#=100	
	EndIf
	
	If KeyDown(6) Then ; key  5
		Target=5 ; Jupiter
		PointEntity Camera, PlanetSphere(Target) ;	
		zcam#=500
	EndIf

	If KeyDown(7) Then ; key  6
		Target=6 ;
		PointEntity Camera, PlanetSphere(Target) ;	
		zcam#=500		
	EndIf
	
	If KeyDown(8) Then ; key  7
		Target=7 ; 
		PointEntity Camera, PlanetSphere(Target) ;			
		zcam#=500
	EndIf

	If KeyDown(9) Then ; key  8
		Target=8 ;
		PointEntity Camera, PlanetSphere(Target) ;			
		zcam#=500
	EndIf
	
	If KeyDown(10) Then ; key  9
		Target=9 ; 
		PointEntity Camera, PlanetSphere(Target) ;			
		zcam#=50
	EndIf

	If KeyDown(11) Then ; key  0
		Target=0 ;
		PointEntity Camera, PlanetSphere(Target) ;	
		zcam#=500		
	EndIf


End Function

Function LabelEntity (camera, entity, label$) ;entity label (txt at entity position)
	If EntityInView (entity, camera)
		CameraProject camera, EntityX (entity), EntityY (entity)+1, EntityZ (entity)
		w = StringWidth (label$)
		h = StringHeight (label$)
		xp = ProjectedX () - (w / 2) - 1
		yp = ProjectedY () - (h / 2) - 4
		Color 0, 0, 0
		;Rect xp, yp, w + 2, h + 2, 0
		Color 255, 255, 255
		Text xp, yp, label$
	EndIf
End Function

Function createline(x1#,y1#,z1#, x2#,y2#,z2#, mesh=0) ; create line in 3d space 
	
	If mesh = 0 Then 
		mesh=CreateMesh()
		EntityFX(mesh,16)
		surf=CreateSurface(mesh)	
		verts = 0	
	
		AddVertex surf,x1#,y1#,z1#,0,0
	Else
		surf = GetSurface(mesh,1)
		verts = CountVertices(surf)-1
	End If
	
	AddVertex surf,(x1#+x2#)/2,(y1#+y2#)/2,(z1#+z2#)/2,0,0 
	; you could skip creating the above vertex and change the line below to
	; AddTriangle surf,verts,verts+1,verts+0
	; so your line mesh would use less vertices, the drawback is that some videocards (like the matrox g400)
	; aren't able to create a triangle with 2 vertices. so, it's your call :)
	AddVertex surf,x2#,y2#,z2#,1,0
	
	AddTriangle surf,verts,verts+2,verts+1
	
	Return mesh
End Function

Function create_3D_line(mesh,x0#,y0#,z0#,x1#,y1#,z1#,r%=255,g%=255,b%=255) ; create line in 3d space v2

	If mesh = 0 
		mesh = CreateMesh() 
		surf = CreateSurface(mesh) 
		EntityFX mesh,1+2+16
	Else 
		last_surf = CountSurfaces(mesh)
		surf = GetSurface(mesh,last_surf)
		If CountVertices(surf) > 30000 Then surf = CreateSurface(mesh)
	End If 

	v0 = AddVertex(surf,x0,y0,z0) 
	v1 = AddVertex(surf,x1,y1,z1)  
	v2 = AddVertex(surf,x0,y0,z0)  
	AddTriangle surf,v0,v1,v2
	
	VertexColor surf,v0,r,g,b
	VertexColor surf,v1,r,g,b
	VertexColor surf,v2,r,g,b

	Return mesh 

End Function

Function create_ring(segs%,mesh=0,rad#=1,r%=255,g%=255,b%=255) ; create line rings
	
	rstep# = 360.0/segs
	last_ang# = 0
	
	For i = 1 To segs
		new_ang# = last_ang + rstep
		mesh = create_3D_line(mesh, Cos(last_ang)*rad,0,Sin(last_ang)*rad, Cos(new_ang)*rad,0,Sin(new_ang)*rad, r,g,b)
		last_ang = new_ang
	Next
	
	Return mesh

End Function

Function ScreenshotTaker()
	If KeyHit(14) = 1;Backspace
		For w = 1 To 100
			nme$ = "screenshot" + w + ".bmp"
			If FileType(nme$) = 0
				If done = 0
					SaveBuffer(FrontBuffer(), nme$)
					done = 1
				EndIf
			EndIf
		Next
	EndIf
	done = 0	
End Function

Function ooooooFoliagMapStuffoooooo()
End Function

Code + Gfx here:
http://www.mediafire.com/download/k7xwdq232kdxwvs/Simplenatary.rar

Rick Nasher

2014

Anybody, no math/astronomer wizards around?

Krischan

2014

Realistic? You could use Blitzmax using Doubles. But even these large numbers are too small to represent the distances correct. So you need a visual trick. Take a look at my old project, my last post there. There is a codebox with a ready-2-run demo. Just fly away from the planet and you'll see how the planets shrink and you're getting the feeling of being very, very far away from them (the fake Range is from 1km to 10 Billion kilometers)

There is a simple line of code for the sun scale adjustment, it could be better but it works:

; adjust sunscale
sunscale=((1-(1.0/Exp(EntityDistance(Player,Sun0)*0.0000001)))*500000)
ScaleEntity Sun0,sunscale,sunscale,sunscale

And you should take a look at the "Homekeeping" function used there, too to avoid the jitter effect in large distances.

I've experimented with other formulas like above but I don't know exactly where I stored it on my NAS archive right now. But 1.0/Exp(x) has been always an important part of it :-) Or 1.0/Entitydistance(x,y) if you want linear scaling.

Rick Nasher

2014

Hey Krischan, thanks very much for your response.

My goal is to do this in Blitz3d, as way back I did a 3D planetary demo myself of the 9 planets + moons, but I want to do it bit more realistic in the sense of calculations of orbits, distances, speeds and planet sizes. (well, as far as can be of course, scaling is ok, but not too far off, ideally a full realistic mode and a game/demo mode)

Then I saw your calculation stuff and quickly realized it was far more superior. I'm not a great mathematician but thought was to use your calculation code and make this into a 3d version.

Problem I have is, besides that obviously distances need to be scaled, is that I don't know how to size up the movement of your calculations and adjust the speed too so it be sort of every day speed (or scaled to gametime speed where 1 day is being run in 2 hours for instance). I do have some planetary data including sizes and orbit speeds and could just implement that, but I know it wouldn't be as good as the math you're using.

I admire both your pieces of code. Would be great to implement the planetary orbit stuff into your other project(the Spacegame tech demo), cos only thing that one is lacking I feel is movement/orbits of the planets. I added some rough media to see what it would look like and I must say it's rather pretty! :-)

Would really by great if your 2 pieces of code could be combined, however dunno if possible at all.

Krischan

2014

Hmm, perhaps my Interplanetary Travel Code could give you some help about the movements and scaling - and it's in Blitz3D. And you should study my code archive postings here and perhaps all my other space related postings, too. I'm sure you'll find answers for problems you'll encounter later.

By the way, here is a small outlook of my new Planet Creation Code but it's all in Blitzmax now and currently I'm working on my RPG project again. See yourself (click for fullscreen), it is always the same code generating completely different planets.

Rick Nasher

2014

Wow, the detail is absolutely stunning. Can't wait to see your RPG. Always thought was a shame you didn't put all this to use in a game(or did you already and I'm not aware? ). That Interplanetary Travel Code indeed should proof to be very useful. Many thanks. You are a true GFX/Math wizz.

Krischan

2014

Umm it's not a space RPG game, just a planet creation algorithm. Perhaps I'll post a demo of it if I find time to clean up the code, its very messy due many changes. No, I mean the oldschool RPG game I'm working right now, see Graphics Showcase category from today:

http://www.blitzbasic.com/Community/posts.php?topic=103075

I'm working parallel on two games. When I'm tired of one, I'm working on the other one. It is challenging but I hope I'll finish them both in a few years ;-)

Rick Nasher

2014

Ah, same here hehehe. But I should focus more on the one.

Krischan

2014

see last post here:

http://www.blitzbasic.com/Community/posts.php?topic=97336

Rick Nasher

2014

Absolutely stunning stuff. You just HAVE to put all that genius into a game. You owe it to the world. I'm thinking Daft Punk meats Star Trek / merchants and mercenaries..

Rick Nasher

2014

Eventhough Interplanetary travel is a fully moving solar system(impressive sun avoiding code), I've noticed that it suffers from the same issue I've had with my own version: the movements are at times jurky, cos the whole thing operates somewhat like a clockwork.

This causes planets to jump to their new positions when being updated. This is especially noticeable at lower time speeds. I've never found a good solution for this.

Krischan

2014

Then you should give a try to Blitzmax+Doubles for better precision. You can translate the B3D project to Blitzmax+MiniB3D in most cases without any serious problems. And here is a whole external thread about the precision problem:

http://www.gamedev.net/topic/466331-floating-point-precision-problem-for-3d-universe/

"inside a solar system, coordinates are represented as 3x doubles, giving an accuracy of 1 millimeter at 100 AU."

Perhaps 1x double is already sufficient for your problem (according to the BlitzMax docs the 64bit floating point Double ranges are (+/-)10^-308)

Further reading:
http://en.wikipedia.org/wiki/Double-precision_floating-point_format

http://www.gamasutra.com/view/feature/131393/a_realtime_procedural_universe_.php?print=1

Code Archives Forum