Wandering Letters

globals
[
  text        ;; text to be written
  left-edge   ;; pxcor of leftmost column where letters can go
  right-edge  ;; ditto for rightmost
]

turtles-own
[
  word-length ;; the length of the word the turtle is in
  num-word    ;; the number the turtle's word is in the text
  leader      ;; the turtle with the character before this turtle's character
  new-line?   ;; whether we should start a new line or not
]

;; setup the variables and the View

to setup
  clear-all
  set text (word "These are the times that try men's souls. "
                ;; the next two sentences each contain all 26
                ;; letters of the alphabet!  (which makes them
                ;; good for testing typewriters)
                "The quick brown fox jumped over the lazy dog. "
                "Pack my box with five dozen liquor jugs.")
  draw-margins
  ;; make the turtles "disappear" using a shape that has nothing
  ;; in it.  we can't use hide-turtle since we want to be able to see the
  ;; turtle's label
  set-default-shape turtles "blank"
  ;; create enough turtles to have one for every character in text
  crt (length text)
  [
    set word-length 0
    set leader nobody
    set new-line? false
    scatter
  ]
  setup-letters
  reset-ticks
end 

to scatter  ;; turtle procedure
  setxy random-xcor random-ycor
end 

to draw-margins
  ask patches
    [ ifelse (pxcor = left-margin + min-pxcor) or
             (pxcor = max-pxcor - right-margin)
        [ set pcolor red ]
        [ set pcolor black ] ]
end 

;; assign the letters to the turtles, determine who leads them,
;; and set how long each word is

to setup-letters
  let remaining-text text
  let word-count 1
  let prev-letter nobody

  ask turtles
  [
    set label first remaining-text
    set leader prev-letter
    set num-word word-count
    if label = " "
    [
      set word-count word-count + 2
      set num-word num-word + 1
    ]
    set remaining-text but-first remaining-text
    set prev-letter self
  ]

  let index 1
  repeat word-count
  [
    let turtles-in-word turtles with [num-word = index]
    ask turtles-in-word
      [ set word-length count turtles-in-word ]
    set index index + 1
  ]
end 

;; the main procedure called by the GO forever button

to go
  update-margins
  ask turtles
  [
    set new-line? false
    pick-heading  ;; choose the heading to the appropriate patch
    ;; if the turtle is not satisfied with where it is in
    ;; relation to its leader, go forward a bit
    ifelse happy?
      [ move-to patch-here ]  ;; move to center of patch
      [ fd 0.5 ]
  ]
  tick
end 

;; updates the left-edge and right-edge variables to match the margin
;; sliders, and redraws the margins if necessary

to update-margins
  if left-edge != left-margin + min-pxcor + 1
    [ set left-edge left-margin + min-pxcor + 1
      draw-margins ]
  if right-edge != max-pxcor - right-margin - 1
    [ set right-edge max-pxcor - right-margin - 1
      draw-margins ]
end 

;; set the heading of the turtle to the appropriate patch

to pick-heading
  ifelse leader = nobody
    ;; first letter goes to upper-leftmost patch
    [ face patch left-edge max-pycor ]
    ;; other patches head toward patch to the right of leader's patch
    [
      let p [patch-at 1 0] of leader
      if p != nobody
      [ face p ]
      ifelse right-edge - left-edge < word-length
      [
        ;; if our word is too long for the width of text,
        ;; check to see if the patch to the right of the leader is on or over
        ;; the right margin
        if [pxcor] of leader >= right-edge
        [
          ;; if it is change the heading to the beginning of the next line
          set new-line? true
          face patch left-edge new-line-pycor
        ]
      ]
      [
        ;; if our word is short enough to fit on a single line but there is not
        ;; enough room on this particular line, try to word wrap.  that is to say,
        ;; if the turtle is at the beginning of a word and the word is too long to
        ;; be completed on a single line given the starting point of the word,
        ;; have the leader of the word, move to the next line.
        if (num-word != [num-word] of leader) and
           ([pxcor] of leader + word-length >= right-edge)
        [
          ;; if it is change the heading to the beginning of the next line
          set new-line? true
          face patch left-edge new-line-pycor
        ]
      ]
  ]
end 

;; reports pycor of the new line the turtle is supposed to go to
;; based on the location of its leader and the width of the text

to-report new-line-pycor  ;; turtle procedure
  ifelse abs ([pycor] of leader - line-spacing) > max-pycor
    [ report [pycor] of leader ]
    [ report [pycor] of leader - line-spacing ]
end 

;; reports true if turtle is satisifed with its current position

to-report happy?  ;; turtle procedure
  if leader = nobody  ;; if the turtle is the first letter...
    ;; ...is it on the upper-left-most patch that it can be?
    [ report (pxcor = left-edge) and (pycor = max-pycor) ]
  ifelse new-line?  ;; do we want to start a new-line?
    ;; is the turtle at the beginning of the next line?
    [ report (pxcor = left-edge) and (pycor = new-line-pycor) ]
      ;; is the turtle on the patch to the right of its leader?
    [ report patch-at -1 0 = [patch-here] of leader ]
end 


; Copyright 1997 Uri Wilensky.
; See Info tab for full copyright and license.