Tag orbit

Rocket Orbit

This simple commented project allows for the introduction of 3D movements and shapes (the rocket procedure) including a basic introduction to repeat, the creation of turtle models and the use of premodel, an introduction to the orbit primitives and the use of a new worker (thread) for orbiting the camera!

TO rocket
  forward 70
  down 90
  ;these two commands orient the rocket better for use as
  ;a turtle model
  setfillcolor yellow
  ;yellow is a function that returns the value 13
  ;it is a shortcut used for convenience in learning
  ;as is red, green, blue etc.
  cylinder 20 120 10
  ;cylinder takes   
  rollright 180
  ;flip the turtle over to create the nose cone
  cone 20 50 10
  lower 50
  ;lower the turtle to create the 'nose'
  setfillcolor red
  icosphere 3
  setfillcolor orange
  ra 50 + 120
  ;ra is short for raise
  rr 180
  ;rr is shorthand for rollright
  cutcone 20 30 30 10
  ;move the turtle to the bottom of the rocket and
  ;create the tail
  up 90 bk 30.1
  ;bk is short for back
  setfillcolor white
  repeat 2 [cylinderslice 40 5 20 10 rr 90]
  ;create the fins
  setfillcolor red
  dn 90 sl 10 bk 10 cylinder 10 10 10
  ;sl is short for slideleft
  fd 20 cylinder 10 10 10 sr 20
  ;fd is short for forward
  ;sr is short for slideright
  cylinder 10 10 10 bk 20 cylinder 10 10 10
  ;create the jets

TO createmodel
  ;cs is short for clearscreen
  begintag "rocketmodel
  ;tags are used to create turtle models
  ;among other uses. You can also use them to
  ;show or hide parts of the 'turtle track'
  ;run the rocket procedure
  ;close the tag
  newmodel "rocket "rocketmodel
  ;create a new model called 'rocket' based on the
  ;rocketmodel tag
  setmodel "rocket
  ;set the turtle's model to the rocket model
  ;clear away the tagged model, leaving only the

TO starfield :number
  ;suspend rendering of the scene until we're done drawing the stars
  repeat :number [
    randomvectors randomfillcolor
    ;randomvectors orients the turtle randomly
    ;while randomfillcolor sets a random fill color
    forward 1000 + random 1000
    ;move forward a random distance
    up 90
    ;orient the turtle up in preparation of creating a spot
    ;because the spot is created around and below the turtle
    spot 10 + random 10
    ;create a randomly-sized spot
  ;resume rendering

TO main
  ;resets turtleSpaces to a default state
  ;execute the createmodel procedure
  starfield 200
  ;execute the starfield procedure, passing the parameter value 200
  setmodelscale 0.5
  ;decrease the size of the turtle model to half normal
  setpremodel [lt 90]
  ;inserts 'left 90' into the turtle track between the scene
  ;and the turtle model ('pre' the model)
  setfillcolor 14
  ;sets the fillcolor to 14. Type 'showcolors' or 'sc' in the console
  ;to see a list of default colors. You can also definecolor your own!
  ico 50
  ;create an icosphere (the planet)
  ;set the 'anchor point', or the point the turtle 'orbits' around
  ;using the orbit commands, to the current turtle position
  pullout 80
  ;pull away 80 turtle units from the anchor point
  snappy:newworker [forever [orbitleft 0.1]]
  ;tell snappy the camera turtle to create a new routine or thread
  ;that forever orbits around the scene to its left one tenth of
  ;a degree at a time
  make "rotation 0
  ;define a container (variable) called 'rotation'
  ;and set it to 0. We're going to use it to keep track of the
  ;rotation of the rocket
  forever [
    inc "rotation
    ;same as make "rotation :rotation + 1
    ;there is also dec (decrement)
    setpremodel {"lt 90 "rollright :rotation % 360}
    ;curly braces indicate a 'softlist', a list that is evaluated
    ;at runtime. In this case, so that we can have a dynamic
    ;rotation value we pass to setpremodel
    ;% is shorthand for modulus
    orbitleft 1
    ;orbit the rocket one degree to the left
    wait 1
    ;wait one sixtieth of a second



Example: My Gosh, It’s Full of Stars!

Open in turtleSpaces IDE
Run starscape to create a galaxy of randomly-shaped and colored stars.

TO star :radius :points :size :filled
  ;takes number number number boolean (true or false)
  ;eg star 10 9 40 false
  ;or star 20 5 50 true
  pu dropanchor tether
  ;pull up the turtle pen, drop the 'anchor' to set the 'anchor point' to the current position, and do not change it if the turtle's rotation changes (tether)
  ;the anchor point is the point the orbit primitives orbit around
  if :filled [polyspot :radius :points * 2
    if oddp :points [rt 360 / :points / 4]]
  ;if creating a filled star, create a polygon to fill in the center
  ;if the star has an odd number of points, we need to turn a little
  pullout :radius
  ;pull out from the anchor point, which is currently the turtle's position
  repeat :points [
    ;repeat once for each point:
    pu make "position position
    ;set the :position container to the current turtle position
    orbitleft 360 / :points / 2
    ;orbit around the anchor point (in this case the center) to the left
    ;a fraction of 360 degrees divided by the number of points divided by 2
    pullout :size
    ;pull the turtle out from the center of the star (anchor point)
    setvectors direction :position
    ;point the turtle toward the previous position
    if not :filled [pd line distance position :position]
    ;if not making a filled star, create a line in front of the turtle of
    ;the length required for its end to be the previous turtle position.
    if :filled [frag]
    ;if creating a filled star, create a 'fragment' based on the last three
    ;turtle positions
    pu make "position position
    ;set the :position container to the current position
    pullin :size
    ;pull the turtle in toward the center of the star (anchor point)
    orbitleft 360 / :points / 2
    ;orbit to the left again a similar amound to the last orbitleft
    setvectors direction :position
    ;point toward the previous position
    if not :filled [pd line distance position :position]
    ;create a line if not a filled star similarly to the previous line
    if :filled [frag]
    ;create a fragment if a filled star similarly to the previous frag

TO starscape
  reset ht snappy:setposition [0 0 0] snappy:dropanchor repeat 200 [pu home randvec fd 1000 + random 1000 up 90 snappy:setvectors direction myrtle:position randfc randpc randps randfs star 10 + random 100 3 + random 20 10 + random 90 randbool]

Solar System Simulation

This Solar System simulation features the ability to add orbiting moons to the planets, a few of which are already defined. It is not entirely to scale (the planets are larger than they are in reality).

Use the scrollwheel or finger-scroll to zoom in and out, and drag the mouse to rotate around the sun!

TO solarsystem
  cam:pullin 100
  ;pull in the camera turtle
  ;make a starfield in the distance:
  setfillcolor 5
  repeat 200 [
    home randomvectors
    forward 2500 + random 100
    up 90
    spot 1 + random 5
  ;define planetary parameter lists:
  make "distance [0 39 72 100 152 520 953 1918 3006 3953]
  ;the distance of the planets from the sun in 100ths of an AU
  ;The first value is the sun itself, which is at the home position
  make "size [100 3 7.5 7.9 4.2 88.7 74.6 32.6 30.2 1.41]
  ;the planets are in scale relative to each other but not the sun,
  ;which is much larger than the value we have given it here
  make "color [13 8 9 7 1 14 11 7 2 10]
  ;each planet's color (and the sun)
  make "tilt [0 7 3.3 0 1.85 1.31 2.49 0.77 1.77 17.14]
  ;ecliptical tilt
  make "speed [0 4.1 1.62 1 0.53 0.084 0.034 0.011 0.006 0.004]
  ;speed of orbit
  ;define moons:
  make "moon [0 0 0 1 2 0 0 0 0 0]
  ;how many moons?
  make "mooncolor [[][][][5][8 9][][][][][]]
  make "moondistance [[][][][3][2 3][][][][][]]
  make "moonsize [[][][][2.1][1.12 0.62][][][][][]]
  make "moontilt [[][][][0][1 2][][][][][]]
  make "moonspeed [[][][][30][40 30][][][][][]]
  ;moon parameters, similar to planets
  ;only earth and mars are populated here,
  ;add the others as you like!
  ;create the sun and planets:
  repeat 10 [
    make "planet repcount
    ;store the current planet for use inside hatch
    newmodel repcount {"setfc item :planet :color "ico 0.1 * item :planet :size}
    ;create a new turtle model using the data from the :color and :size lists
    ;we use a 'soft list' {} to create 'hard data' for use by newmodel
    ;as the turtle model is rendered each frame
    hatch [
      ;create a new hatchling
      setmodel :planet
      ;set the turtle model
      ;set the orbit (anchor) point to the current position
      pullout 0.5 * item :planet :distance
      ;pull away from the anchor the distance specified in the :distance list
      orbitright random 360
      ;orbit around a random amount
      orbitup item :planet :tilt
      ;orbit up (tilt) the amount specified in the :tilt list
      ;hatchlings are not visible by default
      if 0 < item :planet :moon [ ;are there any moons? foreach "moon item :planet :mooncolor [ ;for each moon, let's create it the same way we did planets: make "moonnumber loopcount make "moonmodel word :planet loopcount newmodel :moonmodel {"setfc :moon "ico 0.1 * item :moonnumber item :planet :moonsize} make "parent turtle ;define the 'parent' turtle for use by the moon hatchling hatch [ ;hatch the moon setmodel :moonmodel dropanchor right random 360 pullout item :moonnumber item :planet :moondistance orbitup item :moonnumber item :planet :moontilt showturtle forever [ fixate query :parent [position] ;keep 'fixated' (look at and set the anchor point to) ;the parent turtle's position. if orbitdistance > item :moonnumber item :planet :moondistance [
                pullin orbitdistance - (item :moonnumber item :planet :moondistance)
              ;if it's getting away from us, try and catch up!
              orbitright 0.1 * item :moonnumber item :planet :moonspeed
              ;orbit the planet based on the :moonspeed
              sleep 6.25
              ;take a little nap
      forever [
        orbitright 0.05 * item :planet :speed
        sleep 25
      ;orbit the sun (we're back to the planet now) based on the value
      ;from the :speed list. Then take a little nap (wait 1)
  ;hide Myrtle, although she would be sitting in the sun