watershed-1.1.2

; Watershed Model and Terrain Generator
; Version 1.1.2
; James Steiner

globals
[ ; levels-changed ; obsolete, used to flag if levels changed, to notify 3d update
  peak  ; the highest level of all the patches
  middle ; the mean of the elev and level
  valley ; the lowest elev of all the patches
  spread ; the difference between the valley and peak
  vm ; the valley-middle line, used for coloring
  pm ; the peak-middle line, used for coloring
  depth ; the lowest elev or the greatest depth of the wet patches
  surface ; the elevation of the highest water
  ; both of the above normally equal to spread and peak
  _ticks ; count of flow-frames rendered, for by-eye estimation of fram rate
]

breed [ backdrops ]
breed [ nodes ]


nodes-own
[ my-patch ; the source patch linked to this node
  ox oy oe ; original coordinates
  px py pel ; projected coordinates
  pre-hide? ; part of the projection process
]

patches-own
[ elev   ; "surface" level
  level  ; "water" level, equals elev when dry
         ; may never be less than elev
  volume ; level - elev, the depth of the water, or the volume of water
  temp   ; used for various things
  temp2
  temp3
  neighbors-nowrap ; the neighbors, without edge-wrapping
]

to startup
;     river-valley
end 

to update-all
  ; apply color and, if required, labels
  no-display    ; freeze display while updating
  color-all ; apply color
  label-all ; apply labels
  display       ; refresh display
  ; set levels-changed 1
end 

to dry-all
  ; resets the "water" level to the elevation
  ; effectively drying the landscape
  ask patches
  [ set level elev ]
  calc-measures
  update-all
end 

to diffuse-elev-nowrap
  ask patches
  [ set level .5 * ( elev + mean [ elev ] of neighbors-nowrap )
  ]
  ask patches
  [ set elev level
  ]
end 

to define-neighbors-nowrap
  ask patches
  [ set neighbors-nowrap neighbors in-radius-nowrap 2
  ]
end 

to river-valley
  let lump-size 0
  let num-lumps 0

  ; generates a passable simulation of the elevations of a river valley
  ; flowing north to south
  clear-turtles
  clear-patches
  define-neighbors-nowrap

  note "creating valley contours"
  ; impress a valley shape
  ; store in LEVEL
  ask patches
  [ do-valley
  ]

  set valley min [ level ] of patches
  set peak max [ level ] of patches
  if valley = peak
  [ set valley valley - 2
    set peak peak + 2
  ]
  set spread peak - valley

  ;adjust valley to 0 .. 1
  ask patches
  [ set elev ( level - valley ) / spread  * max-pxcor]

  note "adding random lumps"
  dry-all wait .5


  set num-lumps  sqrt (world-width * world-height) * ( 1 - lumpiness * .01 )
  ask n-of num-lumps patches
  [ set lump-size 1 + max-pxcor * .01 * (random-float lumpiness)
    without-interruption
    [ ask patches in-radius-nowrap lump-size
      [ set elev elev + lump-size  - ( distance-nowrap myself )
      ]
    ]
  ]

  note "tilting landscape"
  dry-all wait .5

  ; tilt the landscape so everything runs downhill
  ; slope set by steepness
  ask patches
  [ set elev elev + (pycor / max-pycor ) * spread * steepness * .02 ]

  note ""
  dry-all
end 

to normalize-elev
  ; set min to 0, max to 100
  calc-measures
  ask patches
  [ ; set min to 0
    set elev (elev - valley )
    ; set max to max-pxcor
    set elev elev * 100 / spread
  ]
  ; adjust valley, peak, spread, middle
  set valley 0
  set peak max-pxcor
  set spread max-pxcor
end 

to do-valley
  let elev-east-west 0
  let elev-north-south 0
  let elev-meander 0
  let px% 0
  let py% 0
  let adj-px% 0
  let px-cos 0
  let sweep-width 0
  let meander-freq 0
  let pwr 0

   set pwr 1
   set px%       pxcor / max-pxcor ; pxcor ==> -1 .. 1
   set py%       1 - ( pycor + max-pycor ) / world-height ; pycor ==> 0 .. 1
   set sweep-width  .01 * meander% ; .25 + .25 * sin ( py% * 45 )
   set meander-freq  py% * 180 * 4
   set adj-px% ( (px% + sweep-width * sin ( meander-freq ) ) )
   set elev-meander (abs adj-px%)
   set level elev-meander
   ; set elev elev * ( 1 - scale) + level * elev-meander * scale
end 

to calc-measures
  ; caluclate peak, valley, spread
  set peak max [ elev ] of patches
  set valley min [ elev ] of patches
  if peak = valley
  [ set peak peak + 2
    set valley valley - 2
  ]
  set middle (peak + valley) * .5
  set spread abs ( peak - valley )
  set vm (valley + middle) * 0.5
  set pm (peak + middle) * 0.5

  ifelse altitude?
  [ set depth peak ]
  [ set depth spread ]
end 

to add-wall
  ; add wall along back / top to prevent water
  ; from flowing backwards wrapping from bottom, etc.

  ; first, caluclate peak, valley, spread
  set peak max [ elev ] of patches
  set valley min [ elev ] of patches
  set spread abs ( peak - valley )
  ; use values to elevate back edge %10 of depth of model

  ask patches with [ pycor = max-pycor ]
  [ set elev peak + spread * .1 ]

  ; scale it up
  ; ask patches
  ; [ set elev elev * 1000 ]

  dry-all
end 

to add-dam
  let height 0
  let spillway 0

  ; adds a dam-like structure to the map

  set height 1.3 * mean [ elev ] of patches
  set spillway  [elev] of patch 0 0 + ( height - [elev] of patch 0 0 ) * .5

  ask patches with [ pycor = 0 and abs pxcor < max-pxcor / 2.0 and elev < height ]
  [ set elev height ]
  ask patch 0 0
  [ set elev spillway ]
  dry-all
end 

to volcano
   let deepest 0
  let peaks 0

   ; build an irregular, circular island
   ; with a shallow center lagoon
   ; "clear patches"
   cp
   ; "clear turtles"
   ct
   ; "define neighbors no-wrap"
   define-neighbors-nowrap

   ; turn off river mode
   set river? false

   ; "create overall ring shape"
   ask patches
   [ ; get distance from center
     ; "doing math"

     set temp distancexy 0 0
     ; sin wave, 0 at center, peak in middle, 0 at corners
     set temp3 temp * 360 / 3 / max-pxcor
     ; scale as distance from edge
     set temp2  2 * sin ( temp * 180 / max-pxcor ) * ( max-pxcor - abs pxcor) / max-pxcor * ( max-pycor - abs pycor) / max-pycor
     set elev world-width * sin temp3 * temp2
   ]


   ; "add random peaks and dips, erode, repeat"
   repeat max-pxcor
   [ ; "picking peak/pit location"
     set [elev] of patch 0 0 (- world-width)
     set peaks n-of max-pxcor patches
     ; "talking to peaks"
     ask peaks
     [ ; "set temp"
       set temp random 2 * 2 - 1 ]
    ; "talking to peaks"
    ask peaks
     [ ; "set elev"
       without-interruption
       [ set elev elev + max-pxcor * temp
       ]
     ]
   ]
   repeat 4
   [ set [elev] of patch 0 0 (min-pxcor)
     diffuse-elev-nowrap
   ]
      ; add "stress ridges"

  ask patches
  [ ; get distance from center
    set temp distancexy 0 0
    ; get angle from center
    ifelse temp = 0
    [ set temp2 0 ]
    [ set temp2 ( towardsxy 0 0 + 180 )
      if temp2 > 360
      [ set temp2 temp2 - 360 ]
    ]
    ; pick number of ridges
    set temp3 temp2 * max-pxcor / 3
    set elev elev + max-pxcor * sin temp3 * sin temp * .2
  ]
   dry-all
end 

to rain
   ; add water to entire surface, using rain-rate slider
   ; adds depth of rain that is up to 1/10000 the height of the terrain
   ask patches
   [ set level level + rain-rate * spread * .0001 ]
   update-all
end  ; rain

to rain-hard
   ; adds depth of rain that is up to 1/1000 height of terrain

   ask patches
   [ set level level + rain-rate * spread * .001 ]
   update-all
end  ; rain-hard

to do-sources-and-drains
  ; adds water at top center of window
  if river?
  [ ask min-one-of patches with [ pycor = ( max-pycor - 1 ) ] [ elev ]
    [ set level level + source-rate
    ]
  ]
  if erupt?
  [ ask patch 0 0
    [ set level level + source-rate ]
  ]
  if drain?
  [ ; removes water from bottom
    ask patches with [ pycor = (- max-pycor) ]
    [ set level level - volume * .1
    ]
  ]
end  ; do-sources-and-drains

to evaporate-all
   ; reduce water level by "evap rate"
   ; which is linear and not proportional
   ; as it is due to surface area, not volume

   if e-rate > 0 and evap?
   [ ask patches with [ level > elev ]
     [ set level level - e-rate
       if level < elev
       [ ; don't allow level to be below elev!
         set level elev
       ]
     ]
   ]
end  ; evaporate-all

to flow-all
  evaporate-all
  ; to reduce flow bias created by natural netlogo patch code scheduling,
  ; only update 1 in 5 patches every turn
  ask patches with [ level > elev and random 5 = 0 ]
  [ flow-ver-1 ]
  ; add water every 5 turns
  if ticks mod 5 = 0
  [ do-sources-and-drains
    update-all
  ]
  set _ticks _ticks + 1
  if _ticks > 1000000 [ set _ticks 0 ]
end 

to flow-ver-1
; if any neighbors with lower  level
; pick random one of neigbors with LOWEST  level
; move 1/2 of difference in level to that neighbor
; (so both are at a level)
  let local-min 0
  let min-level 0
  let extra 0
  let portion 0
  let max-portion 0

  without-interruption
  [
  if level - elev > 0
  ; if I am wet...
  [ set min-level min [ level ] of (neighbors-nowrap)
    if level > min-level
    [ set local-min one-of (neighbors-nowrap) with [ level = min-level ]
      set extra level - min-level
      ifelse extra < .001
      ; if less than 1/1000 unit, it all flows down
      [ set portion extra
      ]
      [ set portion extra * .5
        ; if portion is more than is here, just take all of it
        if portion > ( level - elev )
        [ set portion level - elev
        ]
      ]
      ; adjust the levels
      set level level - portion
      ask local-min
      [ set level level + portion
      ]
    ]
  ]
  ]
end 

to label-all
  ; are labels requested?
  ifelse labels?
  [ ; yes. labels are requested
    ; ; altitude, or water depth?
    ifelse altitude?
    [ ; ; altitude / surface level
      ask patches
      [ set plabel (int (level))
      ]
    ]
    [ ; show depth
      ask patches
      [ set plabel (int (level - elev))
      ]
    ]
  ]
  [ ; no labels
    ; does patch 1 1 have a label?
    if [plabel] of patch 1 1 != ""
    [ ; it does, implying that all patches have labels.
      ; so, clear all labels
      ask patches [ set plabel "" ]
    ]
    ; this would seem to be faster than clearing all the labels every cycle
  ]
end 

to color-all

  ; prestore the value of "volume"
  every 0
  [ ; find peaks, valleys, etc. used later for colorer, scaling.
    ; calc-measures
  ]
  ifelse hide-water?
  [ ; use elev, not level, for display, and don't show water colors
    ifelse false-color?
    [ ; color using rainbow, to show-off contours
      ask patches
      [ set pcolor 20 + 7 * scale-color gray elev valley peak
      ]
    ]
    [ ask patches
      [ set pcolor get-earth-color
      ]
    ]
  ]
  [ ; use level for display, using water colors as needed.
    ask patches [ set volume level - elev ]
    ifelse false-color?
    [ ; color using rainbow, to show off contours
      ask patches
      [ set pcolor 20 + 7 * scale-color gray level valley peak
      ]
    ]
    [ ask patches
      [ set pcolor get-color
      ]
    ]
  ]
end 

to-report get-color-from [ agent ]
  let result 0

  ask agent [ set result get-color ]
  report result
end 

to-report get-color ; patch procedure
  ifelse volume <= 0
    [ report get-earth-color ]
    [ report get-water-color ]
end 

to-report get-water-color ; patch procedure
  ifelse altitude?
  [  report blue - 4 + .8 * scale-color gray level valley surface ]
  [ ifelse volume < .010 or erupt?
    [ report red  + 4 - .8 * scale-color gray volume 0 depth ]
    [ report blue + 4 - .8 * scale-color gray volume 0 depth ]
  ]
end 

to-report get-earth-color ; patch procedure
  ifelse elev <= vm
  [ report gray - 4 + .8 * scale-color gray elev valley middle ]
  [ ifelse elev <= pm
    [ report green - 4 + .8 * scale-color gray elev valley peak ]
    [ report brown - 4 + .8 * scale-color gray elev middle peak ]
  ]
end 

to setup-3d
  clear-turtles
  ; create a turtle to use as a backdrop to hide the patches
  ; (instead of coloring the patches black)
  create-backdrops 1
  [ setxy 0 0
    set color black + 1
    set shape "box-large"
    set size world-width
  ]
  ; these turtles, one for each patch
  ; show the points of elevation
  ask patches
  [ ; make a node turtle
    sprout 1
    [ set breed nodes
      set my-patch patch-here
      set color pcolor
      set shape "circle-large"
      set size 1.0
      set heading 0
      set ox xcor
      set oy ycor
      set oe level
    ]
  ]
  render-3d
end 

to render-3d
  let insetx 0
  let insety 0
  let insetw 0
  let inseth 0
  let insett 0
  let insetl 0
  let insetb 0
  let insetr 0

  if not any? backdrops [ stop ]
  set insetx max-pxcor * shift-x
  set insety max-pycor * shift-y
  set insetw max-pxcor * scale
  set inseth max-pycor * scale

  no-display
  ask backdrops
  [ setxy insetx insety
    set size insetw * 2.1
  ]
  ask nodes
  [ set oe [level] of my-patch
    set color [pcolor] of my-patch
    ; scale elevation so max-pxcor cubic volume fits into 1/2 screen-height
    set pel ( oe - valley ) / world-width * max-pycor + min-pycor * .5
    ; spin X
    set px ox * cos spin + oy * sin spin
    ; spin and tilt Y
    set py (oy * cos spin - ox * sin spin) * cos tilt + pel * sin tilt
    ; scale and adjust center
    set px px * scale
    set py py * scale
    set pre-hide? ( abs px > insetw or abs py > inseth)
    set px px + insetx
    set py py + insety
    set hidden? pre-hide? or ( abs px > max-pxcor or abs py > max-pycor )
    setxy px py
  ]
  display
end 

to clear-3d
   ask backdrops [ die ]
   ask nodes [ die ]
   update-all
end 

to note [ text ]
   ask patch 0 0
   [ ifelse text = ""
     [ set plabel "" ]
     [ set plabel text ]
   ]
end