#### A Starry turtleSpaces Logo Introduction Part Two: Starwarp

In this second part of our introduction to turtleSpaces Logo, we’re going to take the stars we made in the first part, and create a ‘rolling’ starfield we are going to move through using the camera turtle, to create a Star Trek-style warp effect.

To create this effect, the drawing turtle, Myrtle, is going to create stars deep into the space. The camera turtle, Snappy, will move forward (the camera turtle points into the space, towards Myrtle, by default) following Myrtle as she moves deeper, creating stars.

This tutorial is in three parts: First we’ll create the moving starfield, then we’ll cause old stars to vanish (and explain why we need to do that), and finally we’ll set things up so that the starfield ‘pops’ into view, rather than being shown from the beginning.

To begin, we’ll create a new procedure:

```TO starwarp
END
```

```TO starwarp

reset
hideturtle
penup
lower 3000

END
```

We know all of this already from the first part, except for lower, which causes the turtle to descend, from its point of view.

Then we’ll add the main forever loop, which will repeat, well, forever:

```  forever [
]
```

Then we’ll populate it with the commands needed to make the rolling starfield, and explain them:

```  forever [

lower 10
setposition {-1500 + random 3000 -500 + random 1000 zpos}
randomfillcolor
setpencolor fillcolor
spot 0.1 * (1 + random 50)
cam:forward 10

]
```

This is the basic routine, but it can use a lot of work, which we’ll get to in a moment.

lower 10 – lowers the turtle 10 turtle units. The turtle descends from its position and orientation, like an elevator.

setposition {-1500 + random 3000 -500 + random 1000 zpos} – this is a bit complicated. setposition sets the turtle’s position in 3D space. It takes a list of three values, X Y and Z. It does not change the turtle’s orientation.

The center of 3D space is [0 0 0]. From Myrtle’s default position, to her left is negative on the X axis, to her right is positive. To her rear is negative in the Y axis, to her front positive. Below her is negative in the Z axis, while above her is positive.

And so, we’re passing a list to setposition made up of two random calculations (for the X and Y coordinates) and Myrtle’s existing Z co-ordinate, which is expressed by the zpos primitive, which is a function that returns Myrtle’s current Z coordinate.

Why the curly braces? Well, traditional Logo lists such as [pig duck cow] aren’t dynamically generated — if you want to remove, add or change values inside of them, you need to do so using commands that manipulate the list. But this can be a bit tedious and so we created the concept of ‘soft lists’ (as opposed to traditional ‘hard lists’) which are lists whose contents are evaluated (or solidified) at runtime, when the interpreter actually processes and executes the command to which the list is attached.

And so, with soft lists, each item is usually either a function (such as random) or a value (such as 10). If you want to add a string value to a softlist, you need to precede it with a ” eg “duck or surround it with pipes eg |duck|.

So, when the setposition command is evaluated, the parser (the part of Logo that decides what to do next) sees the softlist, and evaluates its contents, turning it into a hard list. So it generates the two random numbers, and gets the zpos, and then creates a hard list of 3 items, passing it back to setposition.

randomfillcolor – sets a random fill color (as in part one)

setpencolor fillcolor – sets the pen color to the fill color (as in part one)

spot 0.1 * (1 + random 50) – creates a spot of a size from 0.1 to 5

cam:forward 10 – moves the camera turtle (cam is a shortcut turtle name for the current view turtle). Prefixing a command with turtle: causes the named turtle to execute that command.

…and that’s it for version one! Run the starwarp procedure and see what happens.

Pretty cool huh? But it has a few shortcomings, which we will address in part three.

```TO starwarp

;this procedure recreates the classic
;'moving starfield' effect

;the turtle starts deep into the workspace
;(by 'lowering' or decreasing its Z-coordinate)
;then creating stars (at least a certain distance
;away from the center using the distance function)
;and continuing to lower. Meanwhile the camera
;moves forward (from its perspective), following
;the turtle.

;Like in reality, the stars are not moving, the
;turtles are!

;On to the code:

reset
;reset the workspace
hideturtle
;hide me!
penup
;don't draw
lower 3000
;'lower' into the distance

forever [

lower 10
;move the 'star turtle' deeper into the scene

setposition {-1500 + random 3000 -500 + random 1000 zpos}
;flat-ish galaxy

;curly braces denote a 'soft list', a list that
;is evaluated and created upon execution

randomfillcolor setpencolor fillcolor
;spots and other shapes use the fill color
;which randomfillcolor randomly chooses
;we set the pencolor to the fill color
;for the gradient, because we're only

spot 0.1 * (1 + random 50)
;make a randomly-sized star
;between 0.1 and 5 turtle units in size

cam:forward 10
;the camera turtle points towards
;what it's looking at, so moving
;forward decreases its z position
;(in its default orientation)

]
;do this forever and ever

END

```