Star Backgound

[johnno56]

There ya go. I'm glad at least one of us remembered my typo... lol (by the way... I just checked... it's still ticked... lol)

J

[bplus]

Vastly improved Sphere Sim:

Code: QB64: [Select]

1. _TITLE "Fake sphere mapping by Paul Dunn, trans from SpecBas to QB64 2018-10-31 B+"
2. '10  Fake sphere mapping
3. '20 GRAPHIC NEW t LOAD "demos:3d/lava_strip.png":gw=gfxw t,gh=gfxh t:
4. '   palette copy t,0,256 to 0:
5. '   paper rgbn(0):
6. '   screen lock
7. '30 r=scrh/2.1,xc=SCRw/2,yc=SCRh/2,xo=0:
8. '   do:
9. '      for y=-r+1 to r-1:
10. '         x1=sqr(r*r-y*y),
11. '         tv=(asn(y/r)+1.5)/3:
12. '         for x=-x1 to x1:
13. '            tu=(asn(x/x1)+1.5)/6:
14. '            plot ink gpoint(t,(xo+tu*gw) mod gw,tv*gh);x+xc,y+yc:
15. '         next x:
16. '      next y:
17. '      xo+=1,xo%=gw:
18. '      wait screen:
19. '      cls:
20. '   loop
21.  
22. SCREEN _NEWIMAGE(800, 600, 32)
23. surface& = _LOADIMAGE("martian.png")
24. 'surface& = _LOADIMAGE("mars.png") 'this image has a color change where ends meet
25. 'surface& = _LOADIMAGE("mars0.jpeg") 'better
26.  
27. gw = _WIDTH(surface&)
28. gh = _HEIGHT(surface&)
29. map& = _NEWIMAGE(gw, gh, 32)
30. _DEST map&
31. _PUTIMAGE , surface&, map&
32. _DEST 0
33.  
34. stars& = _LOADIMAGE("stars.png")
35. _SOURCE stars&
36. _DEST 0
37. _PUTIMAGE
38.  
39. r = _HEIGHT / 3
40. xc = _WIDTH / 2
41. yc = _HEIGHT / 2
42. xo = 0
43. DO
44.     FOR y = -r TO r
45.         x1 = SQR(r * r - y * y)
46.         tv = (_ASIN(y / r) + 1.5) / 3
47.         FOR x = -x1 + 1 TO x1
48.             tu = (_ASIN(x / x1) + 1.5) / 6
49.             _SOURCE map&
50.             pc~& = POINT((xo + tu * gw) MOD gw, tv * gh)
51.             _DEST 0
52.             PSET (x + xc, y + yc), pc~&
53.             'plot ink gpoint(t,(xo+tu*gw) mod gw,tv*gh);x+xc,y+yc
54.         NEXT x
55.     NEXT y
56.     xo = xo + 1
57.     xo = xo MOD gw
58.     _DISPLAY
59.     _LIMIT 60
60.     ' wait screen
61.     'CLS
62. LOOP
63.  
64.  

[SierraKen]

Well, I decided to make my own Solar System. This time with an orbiting Moon. The movement around the Earth wasn't the hard part like I thought. But the relative speed going around the Earth compared to the speed of Earth going around the Sun is where I'm stuck. The main problem is that I don't know this kind of math. It's the same math I used in my Math Graphics program. But I've tried pretty much everything. I know the Earth moves at the same speed as the Moon going around the Sun, but I can't get the speed of the Moon right. Is there any math people out there that could help me with 1 equation? I know the Moon orbits the Earth 13 times a year and I tried that but it keeps staying on around 10 for some reason. Any help is appreciated, thanks. I'm sure a couple of the lines are wrong in the same area, for the Moon. The other planets I think are OK.

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. one:
3. _LIMIT 500
4. mercury = 0.241
5. venus = 0.6152
6. mars = 1.8809
7. moon = 12.368
8. seconds = seconds + .01
9. moonseconds = moonseconds + .0013
10. s = (60 - seconds) * 6 + 180
11. s1 = (60 - seconds) * 6 + 180 / mercury
12. s2 = (60 - seconds) * 6 + 180 / venus
13. s3 = (60 - seconds) * 6 + 180 / mars
14. s4 = (60 - moonseconds) * 6 + 180
15.  
16.  
17. x1 = INT(SIN(s1 / 45 * 3.141592) * 45) + 400
18. y1 = INT(COS(s1 / 45 * 3.141592) * 45) + 300
19.  
20. x2 = INT(SIN(s2 / 90 * 3.141592) * 90) + 400
21. y2 = INT(COS(s2 / 90 * 3.141592) * 90) + 300
22.  
23. x = INT(SIN(s / 180 * 3.141592) * 180) + 400
24. y = INT(COS(s / 180 * 3.141592) * 180) + 300
25.  
26. x3 = INT(SIN(s3 / 270 * 3.141592) * 270) + 400
27. y3 = INT(COS(s3 / 270 * 3.141592) * 270) + 300
28.  
29. 'Moon
30. x4 = INT(SIN(s / 18 * 3.141592) * 18) + x
31. y4 = INT(COS(s / 18 * 3.141592) * 18) + y
32.  
33.  
34.  
35. CIRCLE (x1, y1), 5, _RGB32(120, 98, 102)
36. PAINT (x1, y1), _RGB32(120, 98, 102)
37.  
38. CIRCLE (x2, y2), 5, _RGB32(161, 67, 39)
39. PAINT (x2, y2), _RGB32(161, 67, 39)
40.  
41. CIRCLE (x, y), 5, _RGB32(0, 0, 255)
42. PAINT (x, y), _RGB32(0, 0, 255)
43.  
44.  
45. CIRCLE (x3, y3), 5, _RGB32(240, 72, 22)
46. PAINT (x3, y3), _RGB32(240, 72, 22)
47.  
48. 'Moon
49. CIRCLE (x4, y4), 2.5, _RGB32(179, 179, 181)
50. PAINT (x4, y4), _RGB32(179, 179, 181)
51.  
52.  
53.  
54. CIRCLE (400, 300), 10, _RGB32(249, 240, 22)
55. PAINT (400, 300), _RGB32(249, 240, 22)
56. _DISPLAY
57. IF seconds > 99999 THEN
58.     CLS
59.     seconds = 0
60.     GOTO one:
61. END IF
62. '_DELAY .001
63. CLS
64. GOTO one:
65.  
66.  
67.  

[STxAxTIC]

Welp, I tried solving this from the ground up and ended up reaching for a full-blown n-layers-deep parent-body simulation, and said "this does NOT help this guy", so I scrapped it entirely and went back to your code.

I'm not sure what inspired some of the mathematical decisions here, but if you want the moon to go around 13 times a year, this got me closer:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. one:
3. _LIMIT 500
4. mercury = 0.241
5. venus = 0.6152
6. mars = 1.8809
7. moon = 12.368
8. seconds = seconds + .01
9. moonseconds = moonseconds + .01
10. s = (60 - seconds) * 6 + 180
11. s1 = (60 - seconds) * 6 + 180 / mercury
12. s2 = (60 - seconds) * 6 + 180 / venus
13. s3 = (60 - seconds) * 6 + 180 / mars
14. s4 = (60 - moonseconds) * 6 + 180
15.  
16.  
17. x1 = INT(SIN(s1 / 45 * 3.141592) * 45) + 400
18. y1 = INT(COS(s1 / 45 * 3.141592) * 45) + 300
19.  
20. x2 = INT(SIN(s2 / 90 * 3.141592) * 90) + 400
21. y2 = INT(COS(s2 / 90 * 3.141592) * 90) + 300
22.  
23. x = INT(SIN(s / 180 * 3.141592) * 180) + 400
24. y = INT(COS(s / 180 * 3.141592) * 180) + 300
25.  
26. x3 = INT(SIN(s3 / 270 * 3.141592) * 270) + 400
27. y3 = INT(COS(s3 / 270 * 3.141592) * 270) + 300
28.  
29. 'Moon
30. x4 = INT(SIN(19 * s3 / 270 * 3.141592) * 18) + x
31. y4 = INT(COS(19 * s3 / 270 * 3.141592) * 18) + y
32.  
33. CIRCLE (x1, y1), 5, _RGB32(120, 98, 102)
34. PAINT (x1, y1), _RGB32(120, 98, 102)
35.  
36. CIRCLE (x2, y2), 5, _RGB32(161, 67, 39)
37. PAINT (x2, y2), _RGB32(161, 67, 39)
38.  
39. CIRCLE (x, y), 5, _RGB32(0, 0, 255)
40. PAINT (x, y), _RGB32(0, 0, 255)
41.  
42.  
43. CIRCLE (x3, y3), 5, _RGB32(240, 72, 22)
44. PAINT (x3, y3), _RGB32(240, 72, 22)
45.  
46. 'Moon
47. CIRCLE (x4, y4), 2.5, _RGB32(179, 179, 181)
48. PAINT (x4, y4), _RGB32(179, 179, 181)
49.  
50.  
51.  
52. CIRCLE (400, 300), 10, _RGB32(249, 240, 22)
53. PAINT (400, 300), _RGB32(249, 240, 22)
54. _DISPLAY
55. IF seconds > 99999 THEN
56.     CLS
57.     seconds = 0
58.     GOTO one:
59. END IF
60. '_DELAY .001
61. CLS
62. GOTO one:
63.  

[OldMoses]

The planets in my program are moving "on rails" as well. https://www.qb64.org/forum/index.php?topic=1429.0 That is, the program is not using a gravitational equation. Now the first thing that jumps out at me is that you are assigning almost the exact same numbers to the planets that I did, except the Moon is radically different. The planets are done using the orbital period in years per revolution, while the Moon is using revolutions per year. I'd suggest not treating the moon as a special case, with "moonseconds" as opposed to "seconds", require that it conform to one universal equation. I'll see what I can come up with and post when done. I type rather slowly...

Try this...

By changing p and adding appropriate data, you can easily add more moons and planets.

Code: QB64: [Select]

1. TYPE planet
2.     nam AS STRING * 10
3.     parent AS STRING * 10
4.     x AS INTEGER
5.     y AS INTEGER
6.     s AS SINGLE
7.     orad AS INTEGER
8.     oprd AS SINGLE
9.     rad AS SINGLE
10.     r AS INTEGER
11.     g AS INTEGER
12.     b AS INTEGER
13. END TYPE
14.  
15. DIM SHARED p AS INTEGER
16. p = 6 '                                                         change p to equal number of planets/satellites
17.  
18. REDIM SHARED exo(p) AS planet
19.  
20. FOR a = 1 TO p
21.     READ exo(a).nam
22.     READ exo(a).parent
23.     READ exo(a).x
24.     READ exo(a).y
25.     READ exo(a).orad
26.     READ exo(a).oprd
27.     READ exo(a).rad
28.     READ exo(a).r
29.     READ exo(a).g
30.     READ exo(a).b
31. NEXT a
32.  
33. DATA "Sol","Sol",400,300,0,0,5,249,240,22
34. DATA "Mercury","Sol",0,0,45,0.241,5,120,98,102
35. DATA "Venus","Sol",0,0,90,0.6152,5,161,67,39
36. DATA "Earth","Sol",0,0,180,1,5,0,0,255
37. DATA "Mars","Sol",0,0,270,1.8809,5,240,72,22
38. DATA "Moon","Earth",0,0,18,0.0748,2.5,179,179,181
39.  
40. SCREEN _NEWIMAGE(800, 600, 32)
41. one:
42. _LIMIT 500
43. seconds = seconds + .01
44. b = 1
45. CIRCLE (exo(b).x, exo(b).y), exo(b).rad, _RGB32(exo(b).r, exo(b).g, exo(b).b)
46. PAINT (exo(b).x, exo(b).y), _RGB32(exo(b).r, exo(b).g, exo(b).b)
47.  
48. FOR b = 2 TO p
49.     exo(b).s = (60 - seconds) * 6 + 180 / exo(b).oprd
50.     exo(b).x = INT(SIN(_D2R(exo(b).s / exo(b).oprd)) * exo(b).orad) + exo(FindParent(b)).x
51.     exo(b).y = INT(COS(_D2R(exo(b).s / exo(b).oprd)) * exo(b).orad) + exo(FindParent(b)).y
52.     CIRCLE (exo(b).x, exo(b).y), exo(b).rad, _RGB32(exo(b).r, exo(b).g, exo(b).b)
53.     PAINT (exo(b).x, exo(b).y), _RGB32(exo(b).r, exo(b).g, exo(b).b)
54. NEXT b
55. _DISPLAY
56. IF seconds > 99999 THEN
57.     CLS
58.     seconds = 0
59.     GOTO one:
60. END IF
61. '_DELAY .001
62. CLS
63. GOTO one:
64.  
65. FUNCTION FindParent (var AS INTEGER)
66.  
67.     'Accepts a planetary body index (var) and finds the index of its parent body
68.  
69.     FOR x = 1 TO p
70.         IF exo(var).parent = exo(x).nam THEN o = x
71.     NEXT x
72.     FindParent = o
73.  
74. END FUNCTION 'FindParent
75.  
76.  

[SierraKen]

LOL thanks STxAxTIC! Was easier than I thought. I'm going to stick with your way since it's just about all my code and it will be on my website. Thank you also OldMoses, but the way you program, using TYPE and broken up variables, etc. I just haven't reached that level of expertise yet. STxAxTIC I added your nick to the top of the code. I'll put that on my website probably sometime today, unless I play around with it more. Oh and yes, I used orbital numbers compared to Earth's orbit for other planets. I think I was just thinking too much about this. The Earth and Moon go around the sun in equal time, so just use equal numbers.

[OldMoses]

Thank you also OldMoses, but the way you program, using TYPE and broken up variables, etc. I just haven't reached that level of expertise yet.

If you only knew the power of the Darkside....and we have cookies. ;)

Seriously though, you should try playing around with it some, it's really not as complex as it may seem. You owe it to yourself to push your skills in that direction.

I know you've been doing some fairly sophisticated programming, some of which I can't grasp on a casual reading, so I believe you will not find the concepts difficult. A well designed type array makes adding elements a breeze without a lot of code revision, and is easy to modify if needed. If anything, the variables are less "broken up", and one can keep indexed data ordered easier. You'll be astonished at what you can do with a very small amount of code once the infrastructure is there.

As an illustration, I added the moons of Mars (Phobos & Deimos) to the code. The only thing necessary was to change p from 6 to 8, and to add two data lines for the moons. Since their orbital periods are so fast, I slowed them down by a factor of 100, to make them easier on the eyes.

Code: QB64: [Select]

1. TYPE planet
2.     nam AS STRING * 10
3.     parent AS STRING * 10
4.     x AS INTEGER
5.     y AS INTEGER
6.     s AS SINGLE
7.     orad AS INTEGER
8.     oprd AS SINGLE
9.     rad AS SINGLE
10.     r AS INTEGER
11.     g AS INTEGER
12.     b AS INTEGER
13. END TYPE
14.  
15. DIM SHARED p AS INTEGER
16. p = 8 '                                                         change p to equal number of planets/satellites
17.  
18. REDIM SHARED exo(p) AS planet
19.  
20. FOR a = 1 TO p
21.     READ exo(a).nam
22.     READ exo(a).parent
23.     READ exo(a).x
24.     READ exo(a).y
25.     READ exo(a).orad
26.     READ exo(a).oprd
27.     READ exo(a).rad
28.     READ exo(a).r
29.     READ exo(a).g
30.     READ exo(a).b
31. NEXT a
32.  
33. DATA "Sol","Sol",400,300,0,0,5,249,240,22
34. DATA "Mercury","Sol",0,0,45,0.241,5,120,98,102
35. DATA "Venus","Sol",0,0,90,0.6152,5,161,67,39
36. DATA "Earth","Sol",0,0,180,1,5,0,0,255
37. DATA "Mars","Sol",0,0,270,1.8809,5,240,72,22
38. DATA "Moon","Earth",0,0,18,0.0748,2.5,179,179,181
39. DATA "Phobos","Mars",0,0,10,0.0873,1.5,179,179,181
40. DATA "Deimos","Mars",0,0,30,0.3458,1.5,179,179,181
41.  
42. SCREEN _NEWIMAGE(800, 600, 32)
43. one:
44. _LIMIT 500
45. seconds = seconds + .01
46. b = 1
47. CIRCLE (exo(b).x, exo(b).y), exo(b).rad, _RGB32(exo(b).r, exo(b).g, exo(b).b)
48. PAINT (exo(b).x, exo(b).y), _RGB32(exo(b).r, exo(b).g, exo(b).b)
49.  
50. FOR b = 2 TO p
51.     exo(b).s = (60 - seconds) * 6 + 180 / exo(b).oprd
52.     exo(b).x = INT(SIN(_D2R(exo(b).s / exo(b).oprd)) * exo(b).orad) + exo(FindParent(b)).x
53.     exo(b).y = INT(COS(_D2R(exo(b).s / exo(b).oprd)) * exo(b).orad) + exo(FindParent(b)).y
54.     CIRCLE (exo(b).x, exo(b).y), exo(b).rad, _RGB32(exo(b).r, exo(b).g, exo(b).b)
55.     PAINT (exo(b).x, exo(b).y), _RGB32(exo(b).r, exo(b).g, exo(b).b)
56. NEXT b
57. _DISPLAY
58. IF seconds > 99999 THEN
59.     CLS
60.     seconds = 0
61.     GOTO one:
62. END IF
63. '_DELAY .001
64. CLS
65. GOTO one:
66.  
67. FUNCTION FindParent (var AS INTEGER)
68.  
69.     'Accepts a planetary body index (var) and finds the index of its parent body
70.  
71.     FOR x = 1 TO p
72.         IF exo(var).parent = exo(x).nam THEN o = x
73.     NEXT x
74.     FindParent = o
75.  
76. END FUNCTION 'FindParent
77.  

[SierraKen]

I decided to make my own Solar System Simulator. It has all the planets. It doesn't have Pluto for 2 reasons, one is that Pluto is now a Kupier Belt Object instead of a regular planet, but mostly also because Pluto's orbit is way too hard to calculate. I looked up equations for it online and someone even says it has never been done by anyone and been verified, because it's an elongated orbit going in and out of Neptune's orbit and also it's not the the same vertical plane as the rest of the Solar System. The awesome thing about my little program is that it uses the mouse to zoom in and out to see the rest of the planets (using the mouse wheel) and it also identifies the objects when you put your mouse over them (except The Moon since it's too close to Earth). Check out my funky Saturn. :) By the way, I don't mean to try to be better than anyone else in here with my programming, I just get ideas and go with it. And I think all of us do that. I hope anyway.

(Better version is after this one which has viewing tilt.)

Code: QB64: [Select]

1. 'Ken G. made thie program on August 18, 2019,
2. 'Thank you to STxAxTIC on the QB64.org forum for a little bit of help with the Moon orbit!
3.  
4. _TITLE "Solar System Simulator by Ken G. - Use Mouse To Identify and Mouse Wheel To Zoom In and Out For More Planets"
5. SCREEN _NEWIMAGE(800, 600, 32)
6. mercury = 0.241
7. venus = 0.6152
8. mars = 1.8809
9. jupiter = 11.8618
10. saturn = 29.457
11. uranus = 84.0205
12. neptune = 164.8
13. pluto = 248
14. angle = 180
15. one:
16. _LIMIT 500
17. mouseWheel = 0
18. DO WHILE _MOUSEINPUT
19.     mouseX = _MOUSEX
20.     mouseY = _MOUSEY
21.     mouseLeftButton = _MOUSEBUTTON(1)
22.     mouseRightButton = _MOUSEBUTTON(2)
23.     mouseMiddleButton = _MOUSEBUTTON(3)
24.     mouseWheel = mouseWheel + _MOUSEWHEEL
25. LOOP
26. IF mouseWheel < 0 THEN angle = angle - 10
27. IF mouseWheel > 0 THEN angle = angle + 10
28.  
29. IF mouseX > 385 AND mouseX < 415 AND mouseY > 285 AND mouseY < 315 THEN LOCATE 2, 49: PRINT "Sun    "
30. IF mouseX > x1 - 15 AND mouseX < x1 + 15 AND mouseY > y1 - 15 AND mouseY < y1 + 15 THEN LOCATE 2, 49: PRINT "Mercury"
31. IF mouseX > x2 - 15 AND mouseX < x2 + 15 AND mouseY > y2 - 15 AND mouseY < y2 + 15 THEN LOCATE 2, 49: PRINT "Venus  "
32. IF mouseX > x - 15 AND mouseX < x + 15 AND mouseY > y - 15 AND mouseY < y + 15 THEN LOCATE 2, 49: PRINT "Earth  "
33. IF mouseX > x3 - 15 AND mouseX < x3 + 15 AND mouseY > y3 - 15 AND mouseY < y3 + 15 THEN LOCATE 2, 49: PRINT "Mars   "
34. IF mouseX > x5 - 15 AND mouseX < x5 + 15 AND mouseY > y5 - 15 AND mouseY < y5 + 15 THEN LOCATE 2, 49: PRINT "Jupiter"
35. IF mouseX > x6 - 15 AND mouseX < x6 + 15 AND mouseY > y6 - 15 AND mouseY < y6 + 15 THEN LOCATE 2, 49: PRINT "Saturn "
36. IF mouseX > x7 - 15 AND mouseX < x7 + 15 AND mouseY > y7 - 15 AND mouseY < y7 + 15 THEN LOCATE 2, 49: PRINT "Uranus "
37. IF mouseX > x8 - 15 AND mouseX < x8 + 15 AND mouseY > y8 - 15 AND mouseY < y8 + 15 THEN LOCATE 2, 49: PRINT "Neptune"
38.  
39.  
40. a$ = INKEY$
41. IF a$ = CHR$(27) THEN END
42. IF a$ = CHR$(0) + CHR$(72) THEN angle = angle + 10
43. IF a$ = CHR$(0) + CHR$(80) THEN angle = angle - 10
44. IF angle > 360 THEN angle = 360
45. IF angle < 0 THEN angle = 0
46.  
47. seconds = seconds + .01
48.  
49. s1 = (60 - seconds) * 6 + 180 / mercury
50. s2 = (60 - seconds) * 6 + 180 / venus
51. s3 = (60 - seconds) * 6 + 180 'Earth and Moon
52. s4 = (60 - seconds) * 6 + 180 / mars
53. s5 = (60 - seconds) * 6 + 180 / jupiter
54. s6 = (60 - seconds) * 6 + 180 / saturn
55. s7 = (60 - seconds) * 6 + 180 / uranus
56. s8 = (60 - seconds) * 6 + 180 / neptune
57.  
58. 'Mercury
59. x1 = INT(SIN(s1 / 45 * 3.141592) * angle / 4) + 400
60. y1 = INT(COS(s1 / 45 * 3.141592) * angle / 4) + 300
61.  
62. 'Venus
63. x2 = INT(SIN(s2 / 90 * 3.141592) * angle / 2) + 400
64. y2 = INT(COS(s2 / 90 * 3.141592) * angle / 2) + 300
65.  
66. 'Earth
67. x = INT(SIN(s3 / 180 * 3.141592) * angle) + 400
68. y = INT(COS(s3 / 180 * 3.141592) * angle) + 300
69.  
70. 'Mars
71. x3 = INT(SIN(s4 / 270 * 3.141592) * angle * 1.5) + 400
72. y3 = INT(COS(s4 / 270 * 3.141592) * angle * 1.5) + 300
73.  
74. 'Moon
75. x4 = INT(SIN(19 * s3 / 270 * 3.141592) * angle / 10) + x
76. y4 = INT(COS(19 * s3 / 270 * 3.141592) * angle / 10) + y
77.  
78. 'Outer Planets
79. 'Jupiter
80. x5 = INT(SIN(s5 / 450 * 3.141592) * angle * 3) + 400
81. y5 = INT(COS(s5 / 450 * 3.141592) * angle * 3) + 300
82.  
83. 'Saturn
84. x6 = INT(SIN(s6 / 630 * 3.141592) * angle * 4.5) + 400
85. y6 = INT(COS(s6 / 630 * 3.141592) * angle * 4.5) + 300
86.  
87. 'Uranus
88. x7 = INT(SIN(s7 / 810 * 3.141592) * angle * 6) + 400
89. y7 = INT(COS(s7 / 810 * 3.141592) * angle * 6) + 300
90.  
91. 'Neptune
92. x8 = INT(SIN(s8 / 990 * 3.141592) * angle * 7.5) + 400
93. y8 = INT(COS(s8 / 990 * 3.141592) * angle * 7.5) + 300
94.  
95. 'Mercury
96. CIRCLE (x1, y1), 5, _RGB32(120, 98, 102)
97. PAINT (x1, y1), _RGB32(120, 98, 102)
98.  
99. 'Venus
100. CIRCLE (x2, y2), 5, _RGB32(161, 67, 39)
101. PAINT (x2, y2), _RGB32(161, 67, 39)
102.  
103. 'Earth
104. CIRCLE (x, y), 5, _RGB32(0, 0, 255)
105. PAINT (x, y), _RGB32(0, 0, 255)
106.  
107. 'Mars
108. CIRCLE (x3, y3), 5, _RGB32(240, 72, 22)
109. PAINT (x3, y3), _RGB32(240, 72, 22)
110.  
111. 'Moon
112. CIRCLE (x4, y4), 2.5, _RGB32(179, 179, 181)
113. PAINT (x4, y4), _RGB32(179, 179, 181)
114.  
115. 'Outer Planets
116. 'Jupiter
117. CIRCLE (x5, y5), 5, _RGB32(255, 166, 127)
118. PAINT (x5, y5), _RGB32(255, 166, 127)
119.  
120. 'Saturn
121. CIRCLE (x6, y6), 5, _RGB32(255, 127, 127)
122. PAINT (x6, y6), _RGB32(255, 127, 127)
123. FOR rings = 1 TO 2
124.     CIRCLE (x6, y6), 7 + rings, _RGB32(255, 127, 127)
125. NEXT rings
126.  
127. 'Uranus
128. CIRCLE (x7, y7), 5, _RGB32(127, 166, 255)
129. PAINT (x7, y7), _RGB32(127, 166, 255)
130.  
131. 'Neptune
132. CIRCLE (x8, y8), 5, _RGB32(0, 78, 255)
133. PAINT (x8, y8), _RGB32(0, 78, 255)
134.  
135. 'Sun
136. CIRCLE (400, 300), 5, _RGB32(249, 240, 22)
137. PAINT (400, 300), _RGB32(249, 240, 22)
138. _DISPLAY
139. IF seconds > 99999 THEN
140.     CLS
141.     seconds = 0
142.     GOTO one:
143. END IF
144. CLS
145. GOTO one:
146.  
147.  

[SierraKen]

Use Mouse over the planets to I.D. them. Use Mouse Wheel to zoom in and out to all of the planets, and use Up and Down Arrow Keys to tilt the view.

Code: QB64: [Select]

1. 'Ken G. made thie program on August 18, 2019,
2. 'Thank you to STxAxTIC on the QB64.org forum for a little bit of help with The Moon orbit!
3.  
4. _TITLE "Solar System Simulator by Ken G. Use Mouse Over Planets, Mouse Wheel to Zoom, and Up and Down Arrow Keys To Tilt."
5. SCREEN _NEWIMAGE(800, 600, 32)
6. mercury = 0.241
7. venus = 0.6152
8. mars = 1.8809
9. jupiter = 11.8618
10. saturn = 29.457
11. uranus = 84.0205
12. neptune = 164.8
13. angle = 180
14. tilt = 1
15. one:
16. _LIMIT 500
17. mouseWheel = 0
18. DO WHILE _MOUSEINPUT
19.     mouseX = _MOUSEX
20.     mouseY = _MOUSEY
21.     mouseLeftButton = _MOUSEBUTTON(1)
22.     mouseRightButton = _MOUSEBUTTON(2)
23.     mouseMiddleButton = _MOUSEBUTTON(3)
24.     mouseWheel = mouseWheel + _MOUSEWHEEL
25. LOOP
26. IF mouseWheel < 0 THEN angle = angle - 10
27. IF mouseWheel > 0 THEN angle = angle + 10
28.  
29. IF mouseX > 385 AND mouseX < 415 AND mouseY > 285 AND mouseY < 315 THEN LOCATE 2, 49: PRINT "Sun    "
30. IF mouseX > x1 - 15 AND mouseX < x1 + 15 AND mouseY > y1 - 15 AND mouseY < y1 + 15 THEN LOCATE 2, 49: PRINT "Mercury"
31. IF mouseX > x2 - 15 AND mouseX < x2 + 15 AND mouseY > y2 - 15 AND mouseY < y2 + 15 THEN LOCATE 2, 49: PRINT "Venus  "
32. IF mouseX > x - 15 AND mouseX < x + 15 AND mouseY > y - 15 AND mouseY < y + 15 THEN LOCATE 2, 49: PRINT "Earth  "
33. IF mouseX > x3 - 15 AND mouseX < x3 + 15 AND mouseY > y3 - 15 AND mouseY < y3 + 15 THEN LOCATE 2, 49: PRINT "Mars   "
34. IF mouseX > x5 - 15 AND mouseX < x5 + 15 AND mouseY > y5 - 15 AND mouseY < y5 + 15 THEN LOCATE 2, 49: PRINT "Jupiter"
35. IF mouseX > x6 - 15 AND mouseX < x6 + 15 AND mouseY > y6 - 15 AND mouseY < y6 + 15 THEN LOCATE 2, 49: PRINT "Saturn "
36. IF mouseX > x7 - 15 AND mouseX < x7 + 15 AND mouseY > y7 - 15 AND mouseY < y7 + 15 THEN LOCATE 2, 49: PRINT "Uranus "
37. IF mouseX > x8 - 15 AND mouseX < x8 + 15 AND mouseY > y8 - 15 AND mouseY < y8 + 15 THEN LOCATE 2, 49: PRINT "Neptune"
38.  
39. a$ = INKEY$
40. IF a$ = CHR$(27) THEN END
41. IF a$ = CHR$(0) + CHR$(72) THEN tilt = tilt + 1
42. IF a$ = CHR$(0) + CHR$(80) THEN tilt = tilt - 1
43. IF angle > 360 THEN angle = 360
44. IF angle < 10 THEN angle = 10
45. IF tilt > 90 THEN tilt = 90
46. IF tilt < 1 THEN tilt = 1
47. seconds = seconds + .01
48. s1 = (60 - seconds) * 6 + 180 / mercury
49. s2 = (60 - seconds) * 6 + 180 / venus
50. s3 = (60 - seconds) * 6 + 180 'Earth and Moon
51. s4 = (60 - seconds) * 6 + 180 / mars
52. s5 = (60 - seconds) * 6 + 180 / jupiter
53. s6 = (60 - seconds) * 6 + 180 / saturn
54. s7 = (60 - seconds) * 6 + 180 / uranus
55. s8 = (60 - seconds) * 6 + 180 / neptune
56.  
57. 'Mercury
58. x1 = INT(SIN(s1 / 45 * 3.141592) * angle / 4) + 400
59. y1 = INT(COS(s1 / 45 * 3.141592) * (angle / 4) / tilt) + 300
60.  
61. 'Venus
62. x2 = INT(SIN(s2 / 90 * 3.141592) * angle / 2) + 400
63. y2 = INT(COS(s2 / 90 * 3.141592) * (angle / 2) / tilt) + 300
64.  
65. 'Earth
66. x = INT(SIN(s3 / 180 * 3.141592) * angle) + 400
67. y = INT(COS(s3 / 180 * 3.141592) * angle / tilt) + 300
68.  
69. 'Mars
70. x3 = INT(SIN(s4 / 270 * 3.141592) * angle * 1.5) + 400
71. y3 = INT(COS(s4 / 270 * 3.141592) * (angle * 1.5) / tilt) + 300
72.  
73. 'Moon
74. x4 = INT(SIN(19 * s3 / 270 * 3.141592) * angle / 10) + x
75. y4 = INT(COS(19 * s3 / 270 * 3.141592) * (angle / 10) / tilt) + y
76.  
77. 'Outer Planets
78. 'Jupiter
79. x5 = INT(SIN(s5 / 450 * 3.141592) * angle * 3) + 400
80. y5 = INT(COS(s5 / 450 * 3.141592) * (angle * 3) / tilt) + 300
81.  
82. 'Saturn
83. x6 = INT(SIN(s6 / 630 * 3.141592) * angle * 4.5) + 400
84. y6 = INT(COS(s6 / 630 * 3.141592) * (angle * 4.5) / tilt) + 300
85.  
86. 'Uranus
87. x7 = INT(SIN(s7 / 810 * 3.141592) * angle * 6) + 400
88. y7 = INT(COS(s7 / 810 * 3.141592) * (angle * 6) / tilt) + 300
89.  
90. 'Neptune
91. x8 = INT(SIN(s8 / 990 * 3.141592) * angle * 7.5) + 400
92. y8 = INT(COS(s8 / 990 * 3.141592) * (angle * 7.5) / tilt) + 300
93.  
94. 'Mercury
95. CIRCLE (x1, y1), 5, _RGB32(120, 98, 102)
96. PAINT (x1, y1), _RGB32(120, 98, 102)
97.  
98. 'Venus
99. CIRCLE (x2, y2), 5, _RGB32(161, 67, 39)
100. PAINT (x2, y2), _RGB32(161, 67, 39)
101.  
102. 'Earth
103. CIRCLE (x, y), 5, _RGB32(0, 0, 255)
104. PAINT (x, y), _RGB32(0, 0, 255)
105.  
106. 'Mars
107. CIRCLE (x3, y3), 5, _RGB32(240, 72, 22)
108. PAINT (x3, y3), _RGB32(240, 72, 22)
109.  
110. 'Moon
111. CIRCLE (x4, y4), 2.5, _RGB32(179, 179, 181)
112. PAINT (x4, y4), _RGB32(179, 179, 181)
113.  
114. 'Outer Planets
115. 'Jupiter
116. CIRCLE (x5, y5), 5, _RGB32(255, 166, 127)
117. PAINT (x5, y5), _RGB32(255, 166, 127)
118.  
119. 'Saturn
120. CIRCLE (x6, y6), 5, _RGB32(255, 127, 127)
121. PAINT (x6, y6), _RGB32(255, 127, 127)
122. FOR rings = 1 TO 2
123.     CIRCLE (x6, y6), 7 + rings, _RGB32(255, 127, 127), , , .65
124. NEXT rings
125.  
126. 'Uranus
127. CIRCLE (x7, y7), 5, _RGB32(127, 166, 255)
128. PAINT (x7, y7), _RGB32(127, 166, 255)
129.  
130. 'Neptune
131. CIRCLE (x8, y8), 5, _RGB32(0, 78, 255)
132. PAINT (x8, y8), _RGB32(0, 78, 255)
133.  
134. 'Sun
135. CIRCLE (400, 300), 5, _RGB32(249, 240, 22)
136. PAINT (400, 300), _RGB32(249, 240, 22)
137. _DISPLAY
138. IF seconds > 99999 THEN
139.     CLS
140.     seconds = 0
141.     GOTO one:
142. END IF
143. CLS
144. GOTO one:
145.  

[SMcNeill]

Code: [Select]

DO WHILE _MOUSEINPUT
    mouseX = _MOUSEX
    mouseY = _MOUSEY
    mouseLeftButton = _MOUSEBUTTON(1)
    mouseRightButton = _MOUSEBUTTON(2)
    mouseMiddleButton = _MOUSEBUTTON(3)
    mouseWheel = mouseWheel + _MOUSEWHEEL
LOOP
Warning: The code above is very susceptible to causing lag inside a program, and should generally be avoided at all cost.

Move the mouse quickly back and forth across the screen several times and watch how it lags as it keeps reassigning values over and over to all those variables...  mouse starts in far left, moves to far right, that’s several thousand updates to mousex while the mousebuffer is clearing...

Much better is generally:

Code: [Select]

DO WHILE _MOUSEINPUT
    ‘ mouseX = _MOUSEX
    ‘ mouseY = _MOUSEY
    ‘ mouseLeftButton = _MOUSEBUTTON(1)
    ‘ mouseRightButton = _MOUSEBUTTON(2)
    ‘ mouseMiddleButton = _MOUSEBUTTON(3)
    mouseWheel = mouseWheel + _MOUSEWHEEL
LOOP
mouseX = _MOUSEX
mouseY = _MOUSEY
mouseLeftButton = _MOUSEBUTTON(1)
mouseRightButton = _MOUSEBUTTON(2)
mouseMiddleButton = _MOUSEBUTTON(3)
Who cares how many times the mouse registered an x movement of a fraction of a pixel?  What we need to really know is “where is the mouse once that movement stops”.  After all, we’re not actually doing anything by updating the value a zillion times in the previous loop as it moves across the screen — we just keep overwriting mousex and mousey so we know their value once _MOUSEINPUT = 0.

Get the mouse states after the loop, and not during, and prevent the lag issues before they start.

[bplus]

Hi Ken,

I like the tilting allot! and am curious where the figures:

mercury = 0.241
venus = 0.6152
mars = 1.8809
jupiter = 11.8618
saturn = 29.457
uranus = 84.0205
neptune = 164.8

come from?

[SierraKen]

Thanks! Those figures are comparing those planets with Earth. With Earth as 1 (rotation speed) and the others are all relative to that. Or something like that. lol For example, Mercury flies around the Sun faster than Earth does, so it's less than 1. When you go past Earth, I think I did times instead of division. Speed in the program isn't exact, but I tried. I may have to adjust them.

[SierraKen]

To be exact, those numbers originally came from the Internet, with the real speeds comparing them to Earth.

[johnno56]

Well... If we are talking 'exact'... 'Those' figures are the length of time in years (Earth years) for each planet to complete a single orbit around the Sun.

Simply calculating the length of the orbit, 2 * pi * semi-major axis, dividing it by the number of hours it takes to orbit, will give you the planet's orbiting velocity. This method crude at best. The orbit is assumed to be circular.

Mercury: 87.96878448 days at 107,138.4 mph
Venus: 224.6996656 days at 78,367.7 mph
Earth: 365.24 days at 66,661.22 mph

I think I will stop there... my poor little calculator is complaining of keypad stress... lol

[SierraKen]

Here is a better version, thanks to B+ for the comments in the other thread. This one hides the planets when they go further away.

Code: QB64: [Select]

1. 'Ken G. made thie program on August 18, 2019,
2. 'Thank you to STxAxTIC on the QB64.org forum for a little bit of help with The Moon orbit!
3.  
4. _TITLE "Solar System Simulator by Ken G. Use Mouse Over Planets, Mouse Wheel to Zoom, and Up and Down Arrow Keys To Tilt."
5. SCREEN _NEWIMAGE(800, 600, 32)
6. DIM z(10)
7. mercury = 0.241
8. venus = 0.6152
9. mars = 1.8809
10. jupiter = 11.8618
11. saturn = 29.457
12. uranus = 84.0205
13. neptune = 164.8
14. angle = 180
15. tilt = 1
16. one:
17. _LIMIT 500
18. mouseWheel = 0
19. DO WHILE _MOUSEINPUT
20.     mouseX = _MOUSEX
21.     mouseY = _MOUSEY
22.     mouseLeftButton = _MOUSEBUTTON(1)
23.     mouseRightButton = _MOUSEBUTTON(2)
24.     mouseMiddleButton = _MOUSEBUTTON(3)
25.     mouseWheel = mouseWheel + _MOUSEWHEEL
26. LOOP
27. IF mouseWheel < 0 THEN angle = angle - 10
28. IF mouseWheel > 0 THEN angle = angle + 10
29.  
30. IF mouseX > 385 AND mouseX < 415 AND mouseY > 285 AND mouseY < 315 THEN LOCATE 2, 49: PRINT "Sun    "
31. IF mouseX > x1 - 15 AND mouseX < x1 + 15 AND mouseY > y1 - 15 AND mouseY < y1 + 15 THEN LOCATE 2, 49: PRINT "Mercury"
32. IF mouseX > x2 - 15 AND mouseX < x2 + 15 AND mouseY > y2 - 15 AND mouseY < y2 + 15 THEN LOCATE 2, 49: PRINT "Venus  "
33. IF mouseX > x - 15 AND mouseX < x + 15 AND mouseY > y - 15 AND mouseY < y + 15 THEN LOCATE 2, 49: PRINT "Earth  "
34. IF mouseX > x3 - 15 AND mouseX < x3 + 15 AND mouseY > y3 - 15 AND mouseY < y3 + 15 THEN LOCATE 2, 49: PRINT "Mars   "
35. IF mouseX > x5 - 15 AND mouseX < x5 + 15 AND mouseY > y5 - 15 AND mouseY < y5 + 15 THEN LOCATE 2, 49: PRINT "Jupiter"
36. IF mouseX > x6 - 15 AND mouseX < x6 + 15 AND mouseY > y6 - 15 AND mouseY < y6 + 15 THEN LOCATE 2, 49: PRINT "Saturn "
37. IF mouseX > x7 - 15 AND mouseX < x7 + 15 AND mouseY > y7 - 15 AND mouseY < y7 + 15 THEN LOCATE 2, 49: PRINT "Uranus "
38. IF mouseX > x8 - 15 AND mouseX < x8 + 15 AND mouseY > y8 - 15 AND mouseY < y8 + 15 THEN LOCATE 2, 49: PRINT "Neptune"
39.  
40. a$ = INKEY$
41. IF a$ = CHR$(27) THEN END
42. IF a$ = CHR$(0) + CHR$(72) THEN tilt = tilt + 1
43. IF a$ = CHR$(0) + CHR$(80) THEN tilt = tilt - 1
44. IF angle > 360 THEN angle = 360
45. IF angle < 10 THEN angle = 10
46. IF tilt > 30 THEN tilt = 30
47. IF tilt < 1 THEN tilt = 1
48. seconds = seconds + .01
49. s1 = (60 - seconds) * 6 + 180 / mercury
50. s2 = (60 - seconds) * 6 + 180 / venus
51. s3 = (60 - seconds) * 6 + 180 'Earth and Moon
52. s4 = (60 - seconds) * 6 + 180 / mars
53. s5 = (60 - seconds) * 6 + 180 / jupiter
54. s6 = (60 - seconds) * 6 + 180 / saturn
55. s7 = (60 - seconds) * 6 + 180 / uranus
56. s8 = (60 - seconds) * 6 + 180 / neptune
57.  
58.  
59. 'Mercury
60. oldx1 = x1
61. x1 = INT(SIN(s1 / 45 * 3.141592) * angle / 4) + 400
62. y1 = INT(COS(s1 / 45 * 3.141592) * (angle / 4) / tilt) + 300
63.  
64. 'Venus
65. oldx2 = x2
66. x2 = INT(SIN(s2 / 90 * 3.141592) * angle / 2) + 400
67. y2 = INT(COS(s2 / 90 * 3.141592) * (angle / 2) / tilt) + 300
68.  
69. 'Earth
70. oldx = x
71. x = INT(SIN(s3 / 180 * 3.141592) * angle) + 400
72. y = INT(COS(s3 / 180 * 3.141592) * angle / tilt) + 300
73.  
74. 'Mars
75. oldx3 = x3
76. x3 = INT(SIN(s4 / 270 * 3.141592) * angle * 1.5) + 400
77. y3 = INT(COS(s4 / 270 * 3.141592) * (angle * 1.5) / tilt) + 300
78.  
79. 'Moon
80. x4 = INT(SIN(19 * s3 / 270 * 3.141592) * angle / 10) + x
81. y4 = INT(COS(19 * s3 / 270 * 3.141592) * (angle / 10) / tilt) + y
82.  
83. 'Outer Planets
84. 'Jupiter
85. oldx5 = x5
86. x5 = INT(SIN(s5 / 450 * 3.141592) * angle * 3) + 400
87. y5 = INT(COS(s5 / 450 * 3.141592) * (angle * 3) / tilt) + 300
88.  
89. 'Saturn
90. oldx6 = x6
91. x6 = INT(SIN(s6 / 630 * 3.141592) * angle * 4.5) + 400
92. y6 = INT(COS(s6 / 630 * 3.141592) * (angle * 4.5) / tilt) + 300
93.  
94. 'Uranus
95. oldx7 = x7
96. x7 = INT(SIN(s7 / 810 * 3.141592) * angle * 6) + 400
97. y7 = INT(COS(s7 / 810 * 3.141592) * (angle * 6) / tilt) + 300
98.  
99. 'Neptune
100. oldx8 = x8
101. x8 = INT(SIN(s8 / 990 * 3.141592) * angle * 7.5) + 400
102. y8 = INT(COS(s8 / 990 * 3.141592) * (angle * 7.5) / tilt) + 300
103.  
104.  
105. 'Sun
106. CIRCLE (400, 300), 2, _RGB32(249, 240, 22)
107. PAINT (400, 300), _RGB32(249, 240, 22)
108.  
109. IF tilt > 6 THEN
110.     IF x1 > oldx1 THEN z(1) = 1
111.     IF x2 > oldx2 THEN z(2) = 1
112.     IF x3 > oldx3 THEN z(3) = 1
113.     IF x5 > oldx5 THEN z(4) = 1
114.     IF x6 > oldx6 THEN z(5) = 1
115.     IF x7 > oldx7 THEN z(6) = 1
116.     IF x8 > oldx8 THEN z(7) = 1
117.     IF x > oldx THEN z(8) = 1
118.     IF x1 < oldx1 THEN z(1) = 0
119.     IF x2 < oldx2 THEN z(2) = 0
120.     IF x3 < oldx3 THEN z(3) = 0
121.     IF x5 < oldx5 THEN z(4) = 0
122.     IF x6 < oldx6 THEN z(5) = 0
123.     IF x7 < oldx7 THEN z(6) = 0
124.     IF x8 < oldx8 THEN z(7) = 0
125.     IF x < oldx THEN z(8) = 0
126.  
127.     IF z(1) = 0 THEN
128.         'Mercury
129.         CIRCLE (x1, y1), 5, _RGB32(120, 98, 102)
130.         PAINT (x1, y1), _RGB32(120, 98, 102)
131.     END IF
132.  
133.     IF z(2) = 0 THEN
134.         'Venus
135.         CIRCLE (x2, y2), 5, _RGB32(161, 67, 39)
136.         PAINT (x2, y2), _RGB32(161, 67, 39)
137.     END IF
138.  
139.     IF z(8) = 0 THEN
140.         'Earth
141.         CIRCLE (x, y), 5, _RGB32(0, 0, 255)
142.         PAINT (x, y), _RGB32(0, 0, 255)
143.         'Moon
144.         CIRCLE (x4, y4), 2.5, _RGB32(179, 179, 181)
145.         PAINT (x4, y4), _RGB32(179, 179, 181)
146.     END IF
147.     IF z(3) = 0 THEN
148.         'Mars
149.         CIRCLE (x3, y3), 5, _RGB32(240, 72, 22)
150.         PAINT (x3, y3), _RGB32(240, 72, 22)
151.     END IF
152.     IF z(4) = 0 THEN
153.         'Outer Planets
154.         'Jupiter
155.         CIRCLE (x5, y5), 5, _RGB32(255, 166, 127)
156.         PAINT (x5, y5), _RGB32(255, 166, 127)
157.     END IF
158.     IF z(5) = 0 THEN
159.         'Saturn
160.         CIRCLE (x6, y6), 5, _RGB32(255, 127, 127)
161.         PAINT (x6, y6), _RGB32(255, 127, 127)
162.         FOR rings = 1 TO 2
163.             CIRCLE (x6, y6), 7 + rings, _RGB32(255, 127, 127), , , .65
164.         NEXT rings
165.     END IF
166.     IF z(6) = 0 THEN
167.         'Uranus
168.         CIRCLE (x7, y7), 5, _RGB32(127, 166, 255)
169.         PAINT (x7, y7), _RGB32(127, 166, 255)
170.     END IF
171.     IF z(7) = 0 THEN
172.         'Neptune
173.         CIRCLE (x8, y8), 5, _RGB32(0, 78, 255)
174.         PAINT (x8, y8), _RGB32(0, 78, 255)
175.     END IF
176.  
177. ELSE
178.  
179.     'Mercury
180.     CIRCLE (x1, y1), 5, _RGB32(120, 98, 102)
181.     PAINT (x1, y1), _RGB32(120, 98, 102)
182.  
183.     'Venus
184.     CIRCLE (x2, y2), 5, _RGB32(161, 67, 39)
185.     PAINT (x2, y2), _RGB32(161, 67, 39)
186.  
187.     'Earth
188.     CIRCLE (x, y), 5, _RGB32(0, 0, 255)
189.     PAINT (x, y), _RGB32(0, 0, 255)
190.     'Moon
191.     CIRCLE (x4, y4), 2.5, _RGB32(179, 179, 181)
192.     PAINT (x4, y4), _RGB32(179, 179, 181)
193.  
194.     'Mars
195.     CIRCLE (x3, y3), 5, _RGB32(240, 72, 22)
196.     PAINT (x3, y3), _RGB32(240, 72, 22)
197.  
198.     'Outer Planets
199.     'Jupiter
200.     CIRCLE (x5, y5), 5, _RGB32(255, 166, 127)
201.     PAINT (x5, y5), _RGB32(255, 166, 127)
202.  
203.     'Saturn
204.     CIRCLE (x6, y6), 5, _RGB32(255, 127, 127)
205.     PAINT (x6, y6), _RGB32(255, 127, 127)
206.     FOR rings = 1 TO 2
207.         CIRCLE (x6, y6), 7 + rings, _RGB32(255, 127, 127), , , .65
208.     NEXT rings
209.  
210.     'Uranus
211.     CIRCLE (x7, y7), 5, _RGB32(127, 166, 255)
212.     PAINT (x7, y7), _RGB32(127, 166, 255)
213.  
214.     'Neptune
215.     CIRCLE (x8, y8), 5, _RGB32(0, 78, 255)
216.     PAINT (x8, y8), _RGB32(0, 78, 255)
217.  
218. END IF
219. _DISPLAY
220. IF seconds > 99999 THEN
221.     CLS
222.     seconds = 0
223.     GOTO one:
224. END IF
225. CLS
226. GOTO one:
227.  
228.