World Gen Mods Ramp Up Minecraft Play

dark mode light mode Search Menu
Search

Turtle Solar System

Giuseppe Donatiello on Flickr

Are you ready to write some code that’s out of this world? Using Python with Turtle, we’re going to create our own mini solar-system, with an earth that orbits the sun and a moon that orbits the earth.

SETUP

Navigate to http://repl.it/languages/python_turtle (that’s “python_turtle”).

First, we need to import some stuff from library packages. Type this code into the left-hand editor:

```from turtle import Turtle, Screen
from math import sin, cos, pi, radians
```

Next, we need to set up a “Screen” object, which represents the empty void of space. We’re also going to create three “Turtle” objects, one for each celestial body. We could leave them as little triangles, but to make our solar system more elegant, let’s use the shape function to transform the sun, moon, and earth into circles. Finally, the penup function prevents our orbiting objects from scribbling all over our nice spatial void.

```screen = Screen()

sun = Turtle()
sun.shape('circle')

earth = Turtle()
earth.shape('circle')
earth.penup()

moon = Turtle()
moon.shape('circle')
moon.penup()
```

THE EARTH ORBITS THE SUN

The sun sits at the centre of our solar system, and the planets spin around it in slow, whimsical ellipses. To simplify the math, we’re going to pretend the earth’s orbit is a perfect circle. So no matter what season it is — winter, spring, summer, or autumn — the earth is a fixed distance from the sun. Let’s add some variables to the code:

```earth_distance = 200
earth_angle = 0
```

Our planet starts at angle 0, and every day it inches almost 1° along its orbit, completing the full circle at 365 days / 360°. To make our code work, we need to figure out how to determine the exact position of the earth on any particular day.

A LITTLE TRIGONOMETRY

Let’s put the earth on a cartesian graph. At the beginning, the earth starts 200 units to the right of the sun, otherwise known as the coordinates (200, 0). After circling around for 90°, our spunky little planet is directly above the sun at position (0, 200). Then, at 180° it reaches (-200, 0) and at 270° it hits (0, -200). But what about all the angles in between?

To figure that out, you start by transforming every point on the circle’s circumference into a right-angled triangle:

The radius of the circle becomes each triangle’s hypotenuse. And since we have right-angled triangles, we can use trigonometry!

At its heart, trig is about relationships between lengths. We know that the hypotenuse is always the longest side of a right-angled triangle. If the angle between the base and the hypotenuse is very big, then the opposite side is also very big. If that angle is very small, then the opposite side is very small. With trig, we can figure out exactly how big or small.

The sine function takes in the base angle and compares the opposite side with the hypotenuse. Let’s say our angle is 30°. sin(30) = 0.5, which means our opposite side is exactly 50% the length of the hypotenuse. If your hypotenuse is 8cm, then the opposite side is 4cm.

The cosine function does the same thing, but for the adjacent side. cos(30) = 0.866, so our adjacent side is roughly 87% the length of the hypotenuse (6.9com).

For any point on the circle’s circumference, the x and y coordinates are defined as follows:

x = hypotenuse length * sin(base angle)
y = hypotenuse length * cos(base angle)

Every time the angle increases by one degree, we get a new x and y position.

THE ORBIT CODE

There are many different units we use to measure length. When you measure a piece of paper, you might use centimetres or inches. If you measure the distance from Los Angeles to Tokyo, you probably want kilometres or miles. Similarly, there are different units we use to measure angles. The most common is degrees, but there’s another system called radians, which is more suitable for trig. To keep things simple, we can use the radians function to automatically convert our degrees into the appropriate units.

All together, the code for our solar system goes like this:

```from turtle import Turtle, Screen
from math import sin, cos, pi, radians

screen = Screen()

sun = Turtle()
sun.shape('circle')

earth = Turtle()
earth.shape('circle')
earth.penup()

moon = Turtle()
moon.shape('circle')
moon.penup()

earth_distance = 200
earth_angle = 0

earth_x = earth_distance * cos(earth_angle)
earth_y = earth_distance * sin(earth_angle)
earth.setpos(earth_x, earth_y)

```

The setpos function places the earth at position (x, y), where the x and y coordinates are defined by our sin and cos functions. Every time we run the while loop, earth_angle is increased by one degree, until it completes the orbit. Hit the green “run” button at the top of the screen to try it out!

Adding our second celestial body is a little bit trickier. We know that the moon orbits the earth the same way the earth spins around the sun. But in this scenario, the earth isn’t standing still. Which means we need the moon to orbit the earth while orbiting the sun.

Let’s start by making the moon tag along at a fixed position, like a lovable but clingy puppy:

```while earth_angle <= radians(360):
earth_x = earth_distance * cos(earth_angle)
earth_y = earth_distance * sin(earth_angle)
earth.setpos(earth_x, earth_y)

moon.setpos(earth_x + 40, earth_y + 40)

```

Try it out!

To make the moon spin, we want to trade our fixed 40 unit offset with a variable offset that describes the moon’s orbit. And lucky for us, we already know how to define an orbit! We just need to create a new angle for the moon. Like the earth, the moon’s orbit increases at every iteration of the while loop.

It takes about 1 month for the moon to go through a full cycle. Since this is 12 times faster than the earth’s orbit, we’ll adjust our angles accordingly.

FINAL CODE LISTING

```from turtle import Turtle, Screen
from math import sin, cos, pi, radians

screen = Screen()

sun = Turtle()
sun.shape('circle')

earth = Turtle()
earth.shape('circle')
earth.penup()

moon = Turtle()
moon.shape('circle')
moon.penup()

earth_distance = 200
earth_angle = 0
moon_distance = 40
moon_angle = 0

earth_x = earth_distance * cos(earth_angle)
earth_y = earth_distance * sin(earth_angle)
earth.setpos(earth_x, earth_y)

moon_x = moon_distance * cos(moon_angle)
moon_y = moon_distance * sin(moon_angle)
moon.setpos(earth_x + moon_x, earth_y + moon_y)

```

Psst! If you want to see something cool, delete the lines with the penup function and watch the celestial bodies trace their orbits!

Turtle programming-python

https://www.geeksforgeeks.org/turtle-programming-python/

Solar System

https://gist.github.com/CodeDotJS/64f0d3d86d05b93af3b6https://gist.github.com/CodeDotJS/64f0d3d86d05b93af3b6

Here comes the Whole solar system

http://firsttimeprogrammer.blogspot.com/2014/12/and-here-comes-whole-solar-system.html

Cartesian coordinates

https://www.mathsisfun.com/data/cartesian-coordinates.html

https://www.mathsisfun.com/data/graphs-index.html

Cartesian Plane

http://www.amathsdictionaryforkids.com/qr/c/CartesianPlane.html

Cartesian coordinate system

http://www.projectglobalawakening.com/cartesian-coordinate-system/

Pacman using Python

https://learn.wecode24.com/games-with-turtle-graphics/