Archives March 2021

turtleSpaces Model Web Viewer

On our journey to porting turtleSpaces to the Web (yes, that’s coming!), we’ve added a primitive, SHAREVECTORS “description (or |description|) that allows users to share their creations to the web. SHAREVECTORS will return a link to the turtleSpaces website where you can view a static model, as it was in turtleSpaces when you executed the SHAREVECTORS command.

Note that the camera in the web viewer is currently fixed to the Y axis and is oriented upward, and so you need to ensure your models are oriented that way (they should look correct if you issue a CAM:CS to return the camera turtle to its home position).

You can also embed the viewer (and your creation) into your own web page if you use the following bit of code:

<iframe src="" frameBorder="0" width="720" height="512" scrolling="no">

replacing YourSceneHere with the ID of your scene (the bit in the share URL after pict= and before the ” that follows it) which looks something like 8970c41a0c9a35553e6a2613f8b0516c67381e9a556beb647de84c09

Note: Due to limitations with WebGL, pen width is not currently supported.

You can click and drag to rotate the model, or use the scroll wheel to zoom in and out.

Here’s a few embedded examples:

Logo Fireworks

This Logo program uses hatchlings to create simple 2D fireworks. The turtle’s model is changed into an icosphere to simulate a launching firework, and then more hatchlings are used to create the starburst. The trails are merged back into the main turtle ‘track’ and the hatchlings are terminated, leaving the rendered drawing on-screen at the conclusion of the program.

Read through the code (and pay particular attention to the ;comments) to see how the program works. It is made up of two procedures: fireworks, and burst.

TO fireworks
  ;simple 2D fireworks
  repeat 5 + random 10 [
    ;launch at least 5 but not more
    ;than 14 fireworks
    ;pull up the turtle's pen
    ;return to [0 0 0]
    raise repcount
    ;raise the turtle so its lines
    ;don't overlap
    sety -100
    ;set the turtle's y position to
    hatch [left -60 + random 121 burst]
    ;hatch a new turtle, turn that
    ;turtle left some random value
    ;between -60 (same as right 60)
    ;and 60 degrees, then execute the
    ;burst procedure
    wait 30 + random 31
    ;wait between one half and one
    ;second before launching the next
  ;repeat until all fireworks launched

TO burst
  ;a single firework 'burst'
  ;originally called 'firwork' but
  ;that was a little confusing!
  penup hideturtle
  newmodel "firework [icosphere 1]
  setmodel "firework
  ;create and use a simple model
  ;made from a single icosphere
  ;set a random fill color
  ;models inherit the fill color
  ;if not otherwise set inside
  ;the model
  repeat 100 + random 601 [
    ;travel between 200 and 700
    ;turtle steps
    forward 1 - 0.002 * repcount
    ;move forward 1 step minus
    ;a fraction based on the current
    ;loop iteration. This has the
    ;effect of slowing us down
    ;over time (reduce velocity)
    sety ypos - 0.0005 * repcount
    ;change the y position of the
    ;turtle a fraction based on the
    ;current loop iteration, simulating
    ;very simple gravity
    sleep 2
    ;take a little nap
  ;repeat until finished travelling
  setpencolor fillcolor
  ;set the pen color to the fill color
  repeat 20 + random 21 [
    ;create between 20 and 40 fragments
    raise 0.01
    ;ensures seperation between
    ;overlapping lines
    hatch [
      ;draw lines
      right random 360
      ;turn right between 0 and 359
      make "steps 30 + random 71
      repeat :steps [
        ;travel between 30 and 100
        ;turtle steps
        ;setpenshade -15 + repcount / 5
        setpenshade -15 + 30 * (repcount / :steps)
        ;set the pen shade based on the
        ;loop iterations
        fd 1 - 0.002 * repcount
        ;move forward minus "drag"
        sety ypos - 0.01 * repcount
        ;apply fake gravity
      ;merge the hatchling's track
      ;(output) into the track of its
      ;permanent ancestor, in this case
    ;done with hatchling
  ;repeat until finished

turtleArt Thumbtack String Corkboard

This commented Logo source code creates a thumbtack, a cork board, and then draws random string art using them.

Read the ;comments to learn more about what the primitives do and what their shortcuts are.

Try some of the primitives out in turtleSpaces interactive mode (the myrtle prompt) and see what they do!

You can drag-select the source code and then paste it into the turtleSpaces editor (which you enter by typing ed and Enter or pressing control-shift-E) using control-shift-V (paste)

Then exit back to interactive mode using control-shift-O (save) and then type stringart and Enter to execute it.

Change elements of the code and see what happens!

TO tack
  ;create a thumbtack, or pushpin
  setfillcolor pick without 5 without 10 range [1 15]
  ;pick a number between 1 and 15 except 5 and 10
  cylinder 4 2 20
  ;cylinder takes width depth sides
  lower 2
  ;lowers the turtle eg moves beneath it
  cutcone 2 3 7 20
  ;cutcone takes topwidth bottomwidth depth sides
  lo 7
  ;lo is shortcut for lower
  cylinder 4 2 20
  lo 2
  setfc pick [5 10]
  ;setfc is shortcut for setfillcolor, the color
  ;used for painting shapes
  cylinder 1 5 8
  lo 5
  cone 1 1 8
  raise 16
  ;raises the turtle, eg moves above it
  ;all done!

TO corkboard
  ;create a corkboard to push our pins into
  setpos [-205 -116]
  setfillcolor 8 setfillshade -4
  ;setfillshade takes a range of -15 to 15
  forward 5 lo 3 slideright 5
  voxeloid 400 222 4
  ;voxeloid takes width height depth
  ;this creates the surface of our corkboard
  slideleft 5 ra 3 back 5
  setfs 6
  ; setfs is shortcut for setfillshade
  voxeloid 10 232 10
  ;this and subsequent voxeloids
  ;create the frame
  right 90
  sl 10
  ;sl is shortcut for slideleft
  voxeloid 10 410 10
  fd 400
  ;fd is shortcut for forward
  left 90
  bk 10
  ;bk is shortcut for back
  voxeloid 10 232 10
  fd 222 lt 90 bk 10
  ;lt is shortcut for left
  voxeloid 10 410 10
  ;that's all folks!

TO stringart
  ;resets the workspace
  snappy:run pick [
    [pullout 10]
    [pullout 30 orbitdown 70]
    [orbitleft 20 orbitdown 45 rollright 10 pullout 60 rr 10 sl 25 lo 40]
    ;rr is shortcut for rollright
    [orbitright 20 orbitdown 45 rollleft 10 pullout 60 rl 10 sr 25 lo 40]
    ;rl is shortcut for rollleft
  ;pick a camera sequence and execute it as
  ;snappy, the camera turtle
  ;if we need snappy to do more sophisticated
  ;things, we can store procedures inside him
  ;logo is all about having the freedom to do
  ;things in multiple ways!
  setpenwidth 1 + random 5
  ;sets the 'width' of the pen, from 1 to 5
  ;randps and randfs (aka randompenshade and randomfillshade)
  ;set a random shade between -12 and 12
  ;execute corkboard procedure
  repeat 20 + random 20  [
    ;do the following 20 + 0-19 times:
    ;shortcut for randompencolor
    setpos {-190 + random 380 -100 + random 200}
    ;move to a random position
    ;pu is shortcut for penup
    ;save the turtle state on the 'stack'
    ;you can have multiple states on the stack
    raise 10 + random 4 up -10 + random 20 rr -10 + random 20
    ;move into a semi-random position
    ;to give our tacks a more natural-looking
    ;moving in negative values moves the opposite
    ;direction, eg left -90 turns right 90 degrees
    ;execute tack procedure
    ;(create a tack)
    ;load the turtle state from the 'stack'
    ;this puts it back where and how it was when
    ;we pushed it
    ;pd is shortcut for pendown
    ;this will cause us to create a line to the
    ;next random position
  ;repeat the above however many times
  ;specified by 20 + random 20
  ;ta da!
  ;for extra credit, get some tacks, a corkboard, and some
  ;colored string and make some string art of your own!
  ;consider the angles the turtle would need to turn to travel
  ;along the line of string created between all the pins
  ;were the turtle to travel the string like driving
  ;down a road