DLA Alternate Linear

globals [
  next-color  ;; this is the next color we'll use when a new aggregate starts
              ;; (when a particle touches the bottom edge of the world)
]

breed [ movers mover ]     ;; gray particles zooming down from the top
breed [ stayers stayer ]   ;; colored particles that stay where they are


;; throughout, we assume that the turtles are all of size 1.
;; to support different-sized turtles, minor adjustments
;; would be needed.

to setup
  clear-all
  set-default-shape turtles "circle"  ;; applies to both breeds
  set next-color gray                 ;; first aggregate will be gray
  reset-ticks
end 

to go
  ;; if any aggregates reach the top of the world, we're done
  if any? stayers with [pycor = max-pycor] [
    ask movers [ die ]
    stop
  ]
  ;; make one new falling particle per tick
  make-mover
  ;; we sort the green particles by who number, because we
  ;; need to make sure that closer particles move before farther
  ;; particles, otherwise we could get wrong results when two
  ;; greens are very close together.  SORT reports a list and
  ;; not an agentset (since agentsets are always in random
  ;; order), so we use FOREACH to iterate over the sorted list
  foreach sort movers [ ask ? [ move ] ]
  tick
end 

to make-mover
  create-movers 1 [
    ;; start at a random location along the top edge
    setxy random-xcor max-pycor
    ;; head down
    set heading 180
  ]
end 

to move  ;; mover procedure
  ;; any greens within a 2 step radius are potential
  ;; candidates for colliding with.  (Remember, in-radius
  ;; measures the distances between turtles' centers; but
  ;; we're checking for how far apart the edges are, hence
  ;; the 2 step radius: 1 is the sum of the two radii, and
  ;; another 1 for the distance from edge to edge.)  The
  ;; closest one we find is the one we actually collide with.
  let blocker min-one-of (stayers in-radius 2)
               [ collision-distance myself ]
  ;; if there's nothing within 2 steps, then we're free
  ;; to take a step forward
  if blocker = nobody
    [ fd 1
      if ycor = min-pycor
       [ set breed stayers
         set color next-color
         ;; the next aggregate that starts will be a new color
         set next-color next-color + 10 ]
      stop ]
  ;; see how far away the one we're about to collide with is.
  let dist [collision-distance myself] of blocker
  ;; if it's more than one step away, we're still free to
  ;; take a step forward.
  if dist > 1
    [ fd 1
      stop ]
  ;; otherwise, go forward until we're just touching the
  ;; "blocker", then cease any further motion
  fd dist
  set breed stayers
  ;; turn the same color as the particle we touched
  set color [color] of blocker
end 

to fall  ;; mover procedure
  fd min list 1 (ycor + max-pycor)
end 

;; essentially what all this math does is compute the intersection
;; point between a line and a circle.  the line is the straight path the
;; center point of the moving particle is following.  the circle is
;; a circle of radius 1 around the center of the stationary particle.
;; see http://mathworld.wolfram.com/Circle-LineIntersection.html
;; The details of the math are hard to follow, but the gist of it
;; is that the system of two equations, one for the circle and one
;; for the line, can be combined into a single quadratic equation,
;; and then that equation can be solved by the quadratic formula.
;; Note the strong resemblance of the formulas on the web page
;; to the quadratic formula.

to-report collision-distance [ incoming ]  ;; stayer procedure
  let x1 [xcor] of incoming - xcor
  let y1 [ycor] of incoming - ycor
  let d-x sin [heading] of incoming
  let d-y cos [heading] of incoming
  let x2 x1 + d-x
  let y2 y1 + d-y
  let big-d x1 * y2 - x2 * y1
  let discriminant 1 - big-d ^ 2
  ;; if the discriminant isn't positive, then there is no collision.
  if discriminant <= 0
    [ report false ]
  ;; the line and the circle will intersect at two points.  we find
  ;; both points, then look to see which one is closer
  let new-x-1 (   big-d *  d-y + sign-star d-y * d-x * sqrt discriminant)
  let new-y-1 ((- big-d) * d-x + abs       d-y       * sqrt discriminant)
  let new-x-2 (   big-d *  d-y - sign-star d-y * d-x * sqrt discriminant)
  let new-y-2 ((- big-d) * d-x - abs       d-y       * sqrt discriminant)
  let distance1 sqrt ((x1 - new-x-1) ^ 2 + (y1 - new-y-1) ^ 2)
  let distance2 sqrt ((x1 - new-x-2) ^ 2 + (y1 - new-y-2) ^ 2)
  ifelse distance1 < distance2
    [ report distance1 ]
    [ report distance2 ]
end 

to-report sign-star [ x ]
  report ifelse-value (x < 0) [-1] [1]
end 


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