Agent Based Force Vector Model of Social Influence

breed [actors actor]
breed [cogs cog]
breed [forces force]
breed [deltats deltat]
breed [cus cu]
directed-link-breed [ldts ldt]
directed-link-breed [fvecs fvec]

forces-own [
  mag    ;; size of vector
]

actors-own [
  fx     ;; x-component of force vector
  fy     ;; y-component of force vector
  xc     ;; real x-coordinate (in case agent leaves world). these are used for all calculations and then used to update xcor, ycor.
  yc     ;; real y-coordinate (in case agent leaves world)
  mass   ;; the actor's active mass
  massP  ;; passive mass
  dxc     ;; delta x coord change
  dyc     ;; delta y coord change
  dcn     ;; distance to closest neighbor calculate for each iteration.
  mag     ;; size of vector. Calculated for each iteration.
  angle   ;; angle of vector. Calculated for each iteration.
]

globals
[ center-of-mass-yc ;; y-coordinate of the center of mass. Used to recenter all agents around the center of mass of the whole population.
  center-of-mass-xc ;; x-coordinate of the center of mass
  maxforce          ;; max force on each iteration. Used to determine when to stop the simulation - when maxforce < min force cutoff
  maxdist           ;; max distance traveled in an iteration
  peakdist          ;; peak dist for an iteration. When dynamic dt is on: the max dist traveled is =< than the coalescence radius.
  meandist          ;; mean distance between all agents
  repulsive         ;; total repulsive force across all agents for each iteration
  attractive        ;; total attractive force
  agentcount        ;; count of actors
  meanxloc          ;; mass weighted x location for all agents
  meanyloc
  meanxsd           ;; mass weighted x location standard deviation for all agents
  meanysd
  meandistclosestneighbor   ;; mean distance to closest neighbor
  dcnsd             ;; standard deviation of distance to closest neighbor
  meandistorigin    ;; eman distance to the origin
  scale             ;; scale multiplier factor from a -1,1 world.
  masscale          ;; sise of agent scaled by mass (.1 for scale 1)
  totmass           ;; total mass of agents used for debugging only
  elapsed-time      ;; time elapsed is sum of dts
  iterations        ;; number of simulation iterations
  stopflag          ;; when set, stop simulation
  stopreason        ;; why the simulation was stopped
  mergeCount        ;; number of mergers in an iteration
  mergeTotMass      ;; merge mass for each iteration
  groups             ;; number of groups
  finaldt           ;; final dt at end of simulation
  record-view       ;; make movie of view
  record-interface  ;; make movie of interface
  forcescale        ;; how much to scale force vector size
  mominertia        ;; moment of inertia
  timestart         ;; start and end times for a run
  timeend
  oobcount          ;; count of agents that fall outside universe during setup
  rseedused         ;; random seed used for the run
  itcounter         ;; used to iterate past probability based endpoint to make sure everything is in a final stop condition
]


; Basic Model Design:
;   Setup initializes the model for a simulation run.
;     The spatial and mass distributions selected for the agents are set up
;     All necessary globals are initialized
;     Note: randomseed is initialized for repeatable runs


;;;;;;;;;;;;;;;;;;;;;;;;
;;; Setup Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;

to setup
  clear-all
;;  set timestart read-from-string remove "\n" (shell:exec "date" "+%s")
  set itcounter 0
  set oobcount 0
  set forcescale 40
  set scale 100
  set stopflag false
  set masscale .03
  set peakdist 0
  set dt 1
  set elapsed-time 0
  set iterations 0
  set-default-shape actors "circle"
  set record-view False
  set record-interface False
  ifelse randomseed != 0 [
    random-seed randomseed
    set rseedused randomseed
  ] [
   set rseedused new-seed
   random-seed rseedused
  ]
  create-actors number [
    ;;set color (  random 5  ) + (( random  14 ) * 10)
    set color (  random 9  ) + (( random  14 ) * 10)
    ;set color random 140
  ]
  ask patches [
    set pcolor white
  ]
  random-initial-setup
  if Geometry [
    doGeometry
  ]

  mass-setup
  set totmass 0
  ask actors [
    set totmass totmass + mass
  ]
  if NumberInjected > 0 [
    create-actors NumberInjected [
      set xc random-float (2 * scale) - scale
      set yc random-float (2 * scale) - scale
      setxy xc yc
      set mass InjectionMaxMass
      set massP InjectionMaxMass
      set size masstosize mass
    ]
  ]

  meanlocs
  ; center of gravity display
  create-cogs 1 [
    set xcor meanxloc
    set ycor meanyloc
    set color 15
    set pen-size 3
    pen-down
  ]
  ;; create identifier agent for center of universe
  create-cus 1 [
    set xcor 0
    set ycor 0
    set color yellow
    set shape "target"
    set size 5
  ]
  if xOrigin != 0 or yOrigin != 0 [
    ask actors [
      pen-up
      ifelse (xcor + xOrigin) > max-pxcor [
        set xcor max-pxcor - 1
      ][
        set xcor xcor + xOrigin
      ]
      ifelse (ycor + yOrigin) > max-pycor [
        set ycor max-pycor - 1
      ][
        set ycor ycor + yOrigin
      ]
      pen-down
    ]
  ]
  reset-ticks
end 

to random-initial-setup
  ask actors [
    if xSpatialDist = "Random" [
       set xcor random-float (2 * scale) - scale
    ]
    if ySpatialDist = "Random" [
       set ycor random-float (2 * scale) - scale
    ]
    if xSpatialDist = "Normal" [
       set xcor random-normal-in-bounds xMean (scale * xStd) (- scale) scale
    ]
    if ySpatialDist = "Normal" [
       set ycor random-normal-in-bounds yMean (scale * yStd) (- scale) scale
    ]
    if xSpatialDist = "Exponential" [
       set xcor random-exponential-pos-in-bounds xMean (- scale) scale
    ]
    if ySpatialDist = "Exponential" [
       set ycor random-exponential-pos-in-bounds yMean (- scale) scale
    ]
    set xc xcor
    set yc ycor
    if ShowForces [
      hatch-forces 1 [
        create-fvec-from myself [
          set thickness 1
          set color red
        ]
        hide-turtle
      ]
    ]
    if track [
      pen-down
    ]
  ]
end 

to mass-setup
  let locmass 0
  let locmassp 0
  ask actors [
    if active-mass-distribution = "Random"
      [ set locmass ( random-float maxmass ) ]
    if active-mass-distribution = "Normal"
      [ set locmass random-normal-in-bounds mass-mean mass-stddev 1 maxmass ]
    if active-mass-distribution = "Exponential"
      [ set locmass random-exponential-in-bounds mass-mean 1 maxmass ]
    if passive-mass-distribution = "Random"
      [ set locmassp ( random-float maxmass ) ]
    if passive-mass-distribution = "Normal"
      [ set locmassp random-normal-in-bounds pmass-mean pmass-stddev 1 maxmass ]
    if passive-mass-distribution = "Exponential"
      [ set locmassp random-exponential-in-bounds pmass-mean 1 maxmass ]
    ifelse PassiveMass [
      set mass locmass
      set massP locmassp
    ][
      set mass locmass
      set massP locmass
    ]
    set size masstosize mass
  ]
end 

to create-agent
  if mouse-down?
  [ let mx mouse-xcor
    let my mouse-ycor
    let mz 0
    if (not any? actors-on patch mx my )
    [
      create-actors 1
      [ set xc mx ;initial-position-x
        set yc my ;initial-position-y
        setxy xc yc
        set mass initial-mass
        set massp initial-mass
        set size masstosize mass
        set color agent-color
        if track [
          pen-down
        ]
      ]
      display
    ]
  ]
  while [mouse-down?]
  []
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Runtime Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;

; Runtime Design
;  There are several controls that determine what happens at runtime:
;    tickstop - set to a nonzero value, will stop the simulation when the number of iterations selected is reached
;    record-view or record-interface - start a movie creation for the run
;    AIB and MaxDT settings can both stop a simulation if those  values are reached. If this happens, a stopflag and
;      stopreason is set to indicate the end of the simulation. The go function checks this flag at the end of each iteration
;      and stops the simulation.
;
;  NOTE: the coordinates used for the simulation are defined agent variables xc, xy. The netlogo agent coordinates
;        are used to set xc, xy at the beginning of each iteration. Then xc, xy are used for all the movement calculations.
;        Agent xcor, ycor are set by function adjust-position after all the force and movement calculations are done.
;        This is done near the end of each iteration before plots are updated.
;  NOTE; for clarity of design and modularity, the ask actors functions is invoked for collision / merger checks,
;        force calculations, max movement calculations (for stopping conditions and dynamic dt setting),
;

to go
  if tickstop != 0 [
    if iterations > tickstop [
      set stopreason "ItStop"
;;      set timeend read-from-string remove "\n" (shell:exec "date" "+%s")
;;      movie
      stop
    ]
  ]
  if AgentStop != 0 [
    if AgentStop >= count actors [
      set stopreason "AgentCount"
      stop
    ]
  ]

;  if record-view or record-interface [
;    if vid:recorder-status = "inactive" [
;      vid:start-recorder
;    ]
;    movie-init
;  ]

  set attractive 0
  set repulsive 0
  set stopflag false
  set mergeCount 0
  set mergeTotMass 0
  ask actors
  [ set fx 0
    set fy 0
;    if xc != xcor [
;      user-message (word "xcor xc mismatch: " xcor " " xc)
;    ]
;    if yc != ycor [
;      user-message (word "ycor yc mismatch: " ycor " " yc)
;    ]
    set label int mass
    set label-color black
  ]
  set maxforce 0
  set maxdist 0
  set peakdist 0
  ;; must do all of these steps separately to get correct results
  ;; since all actors interact with one another

  ask actors [ check-for-collisions
    set label int mass ]
  meanlocation
  ask actors [ update-force ]
  ask actors [ peakdist-calc ]
  if ShowForces [
    show-force
  ]

  if peakdist = 0 [
    ifelse Infprob != 100 or ProbDist != "None" [
      set itcounter itcounter + 1
      if itcounter > 5000 [
        set stopflag true
        set stopreason "No movement"
        update-plots
      ]
      set peakdist 1
    ] [
        set stopflag true
        set stopreason "No movement"
        update-plots
    ]
  ]
  if stopflag [
;    set timeend read-from-string remove "\n" (shell:exec "date" "+%s")
;    movie
    stop
  ]
  if AdaptiveDT [
    set dt sqrt ( CoalescenseRadius / peakdist )
  ]
  ifelse DTStop != 0 and dt >= DTStop [
    set stopflag true
    set finaldt dt
    set stopreason "DTStop"
    update-plots
  ] [
    ask actors [ update-position ]
    update-plots
    set elapsed-time elapsed-time + dt
    set iterations iterations + 1
    tick-advance dt
  ]
end 

; if any agents are within coalescence radius, merge into one agent

to check-for-collisions
  ask other actors [
    if realdist self myself <= CoalescenseRadius [
        merge self myself
    ]
  ]
end 

; Merge two agents into one.
; Note: the position of the merged agent is the position of the agent with the larger mass.
;       the color of the merged agent is the color of the agent with the larger mass.

to merge [ a b ] ;; a merges with with b
  set mergeTotMass mergeTotMass + mass + [mass] of b
  let mergemass mass
  ;; user-message (word "aself " [who] of a " bself/myself " [who] of b)
;;  if [mergewith] of a = [mergewith] of b [
;;    user-message (word "Merging with each other " [who] of a " " [who] of b)
;;  ]
  if mass > [mass] of b [
    ask b [
      set color [color] of a
      set xc [xc] of a
      set yc [yc] of a
    ]
  ]
  ask b [
      set mass mass + mergemass
      set massP massP + [massP] of a
      set shape "triangle"
      set size masstosize mass
  ]
  set mergeCount mergeCount + 1
  ask a [
;;    user-message (word "Turtle " [who] of a " is dead now")
    die
  ]
end 

to update-force ;; Turtle Procedure
  ;; This is recursive over all the actors, each turtle asks this of all other actors
  ;; Note: the force calculations are for all the other agents, not the asking agent, i.e., myself
  ;;       the force of myself on all other agents is set in this procedure.
  ask other actors with [ (realdist self myself) <= AIB ] [
    sum-its-force-on-me myself
  ]
end 

; The force calculations are done. 'it' is the asking agent.
; Note: The force adjustment control determines the force direction.

to sum-its-force-on-me [it] ;; Turtle Procedure
  let distsq vecdistsq it self
  let dist sqrt distsq
  let ab adotb it self
  let fxt 0
  let fyt 0
  if forceAdj != "Normal" [
    ifelse forceAdj = "AttractOnly" [
      set ab abs ab
    ][ ifelse forceAdj = "Repulse" [
      set ab ( - abs ab )
    ][ ifelse forceAdj = "NoRepulse" [
          if ab < 0 [
            set ab 0
          ]
        ][ ifelse forceAdj = "NoAttract" [
            if ab > 0 [
              set ab 0
            ]
          ][
            set ab ( - ab )
          ]
  ]]]]
  set fxt g * ( (( [xc] of it - xc ) / dist) *  ( [mass] of it ) * ab ) / ( (dist ^ DistanceExponent)  )
  set fyt g * ( (( [yc] of it - yc ) / dist) *  ( [mass] of it ) * ab ) / ( (dist ^ DistanceExponent)  )
  set fx fx + fxt
  set fy fy + fyt
  ifelse ab >= 0 [
    set attractive attractive + sqrt ( fxt ^ 2 + fyt ^ 2)
  ] [
    set repulsive repulsive + sqrt ( fxt ^ 2 + fyt ^ 2)
  ]
;;  if debug
;;  [ user-message (word "who " who " it= " it " adotb " ab " dist " distsq  " fxdir " fxdir " fydir " fydir " fx " fx " fy " fy) ]
end 

; The position is update for the agent depending on the forces on the agent.
; Note: the force is divided by the mass of the agent being updated. The mass is considered to be
;       its passive mass / inertia to the movement.

to update-position ;; Turtle Procedure
  ;; As our system is closed, we can safely recenter the center of mass to the origin.
  let stopq false
  set dxc fx * ( dt ^ 2) / massP
  set dyc fy * ( dt ^ 2) / massP
  let dist sqrt ( dxc ^ 2 + dyc ^ 2)
  if dist > maxdist [
    set maxdist dist
  ]
  let newxc (xc + dxc)
  let newyc (yc + dyc)
  if abs(newxc) > max-pxcor [
    set shape "ghost"
  ]
  if abs(newyc) > max-pycor [
    set shape "ghost"
  ]
  set xc newxc
  set yc newyc
;;  if debug [
;;    if newxc < min-pxcor or newxc > max-pxcor or newyc < min-pycor or newyc > max-pycor [
;;      user-message (word "up who " who " dxc dxy " dxc " " dyc " newxc newrxy " xc " " yc " xcor ycor " xcor " " ycor)
;;    ]
;;  ]
  adjust-position
end 

; set agent coordinates from coordinate variables used to do all the force calculations.

to adjust-position ;; Turtle Procedure
  if shape != "ghost" [
    setxy xc yc
  ]
end 

to show-force
  if maxforce != 0 [
      let poshift forcescale / maxforce
      let tx 0
      let ty 0
      ask actors [
        ;;user-message (word "maxforce poshift who " maxforce " " poshift " " who " xcor ycor " xcor " " ycor )
        ask out-fvec-neighbors [
          ;;user-message (word "fvecnbr" who " xcor ycor " xcor " " ycor "myself xcor ycor " [xcor] of myself " " [ycor] of myself " who of myself " [who] of myself)
          set tx ( [xcor] of myself ) + ( [fx] of myself ) * poshift
          set ty ( [ycor] of myself ) + ( [fy] of myself ) * poshift
          ifelse ( abs tx ) < max-pxcor [
            set xcor tx
          ] [
            ifelse xcor < 0 [
              set xcor min-pxcor
            ] [
              set xcor max-pxcor
            ]
          ]
          ifelse ( abs ty ) < max-pycor [
            set ycor ty
          ] [
            ifelse xcor < 0 [
              set ycor min-pycor
            ] [
              set ycor max-pycor
            ]
          ]

          ;;show-turtle
        ]
      ]
    ]
    ask fvecs [
      show-link
    ]
end 

; calculate the square of the distance between two agents

to-report vecdistsq [a b]
  report ([xc] of a - [xc] of b) ^ 2 + ([yc] of a - [yc] of b) ^ 2
end 

; calculate the a dot b value of two agents

to-report adotb [a b]
   if infprob < random 100 [
;    probdebug "infprob" a b
    report 0
  ]
  if ProbDist != "None" [
    if ProbDist = "AttributeDiff" [
      let cosval abs (( ([xc] of a * [xc] of b) + [yc] of a * [yc] of b )/( vecmag a * vecmag b))
      if cosval < random-float 1 [
;        probdebug "AttrDiff" a b
        report 0
      ]
    ]
    if ProbDist = "DistanceProb" [
      let dist realdist a b
      let prob abs (AIB - dist) / AIB
      if prob < random-float 1 [
 ;       probdebug "ProbDist" a b
        report 0
      ]
    ]
  ]
  report ( ([xc] of a * [xc] of b) + [yc] of a * [yc] of b )
end 


; How who is out of the loop for this iteration

to probdebug [ r a b ]
  if count actors <= 3 [
    print ( word r " Zero FaOnb for iteration " iterations " a " [who] of a " b " [who] of b)
  ]
end 


; calculate distance between two agents

to-report realdist [a b]
  report sqrt ( ( [xc] of a - [xc] of b) ^ 2 + ([yc] of a - [yc] of b) ^ 2)
end 

; calculate the force on an agent

to-report force-on-me [it]
  report sqrt ( [fx] of it ^ 2 + [fy] of it  ^ 2  )
end 

; convert mass to size parameter for displaying agents proportional to their size.
; Note: this is done on a log scale

to-report masstosize [m]
  report scale * masscale * log m 10
end 

; generate a random distribution within the min max
; parameters given with the given mean and standard deviation

to-report random-normal-in-bounds [ mid dev mmin mmax ]
  let result random-normal mid dev
  if result < mmin or result > mmax [
    set oobcount oobcount + 1
    report random-normal-in-bounds mid dev mmin mmax
  ]
  report result
end 

; generate an exponential distribution within the min / max
; range given with the given mean. Move half the results to
; the negative coordinates since the universe is -max to +max

to-report random-exponential-pos-in-bounds [ distmean mmin mmax ]
  let result random-exponential distmean
  if result < mmin or result > mmax [
      set oobcount oobcount + 1
      report random-exponential-pos-in-bounds distmean mmin mmax
  ]
  if random 2 = 1
      [ set result ( - result) ]
  report result
end 

; generate an exponential distribution within the min / max
; range given with the given mean.

to-report random-exponential-in-bounds [ distmean mmin mmax ]
  let result random-exponential distmean
  if result < mmin or result > mmax [
    set oobcount oobcount + 1
    report random-exponential-in-bounds distmean mmin mmax
  ]
  report result
end 

; calculate the magnitude of the given vector / agent

to-report vecmag [vec]
  report sqrt ( ([xc] of vec) ^ 2  + ([yc] of vec) ^ 2)
end 

; calculate the distance to be traveled by the agent calling
; with a dt of 1. set the global max if distance exceeds the current maximum
; also set the global maxforce for this iteration

to peakdist-calc
  if force-on-me self > maxforce [
    set maxforce force-on-me self
  ]
  set dxc  fx / massP
  set dyc  fy / massP
  let dist sqrt ( dxc ^ 2 + dyc ^ 2 )
  if dist > peakdist [
    set peakdist dist
  ]
end 

to doGeometry
  let rval Pradius
  while [ rval <= Prange ] [
    let n 0
    repeat Nsides [
      let txc nextVx Pxcenter rval Nsides n
      let tyc nextVy Pycenter rval Nsides n
      if abs(txc) < max-pxcor and abs(tyc) < max-pycor [
        create-actors 1 [
          set xc txc
          set yc tyc
          setxy txc tyc
          if track [
            pen-down
          ]
        ]
        if fill [
          dofill txc tyc rval n
        ]
      ]
      ;; user-message ( word "x y side cos sin" txc " " tyc " "  n  " " cos (360 * n / Nsides) )
      set n n + 1


    ]
    set rval rval + Pstep
    if Pstep = 0 [
      set rval Prange + 1
    ]
  ]
end 

to dofill [txc tyc rval nth]
  let f filldistance
  loop [
    let ntxc nextVx Pxcenter rval Nsides (nth + 1)
    let ntyc nextVy Pycenter rval Nsides (nth + 1)
    let nx txc + f * sin ( atan (ntxc - txc) (ntyc - tyc))
    let ny tyc + f * sin ( atan (ntyc - tyc) (ntxc - txc))
    if abs nx > max (list abs ntxc abs txc) or abs ny > max (list abs ntyc abs tyc) [ stop ]
    create-actors 1 [
      set xc nx
      set yc ny
      setxy nx ny
      if track [
        pen-down
      ]
      set f f + filldistance
    ]
  ]
end 

to-report nextVx [v rv sides nth]
  report v + rv * precision cos (360 * nth / Nsides) 12
end 

to-report nextVy [v rv sides nth]
  report v + rv * precision sin (360 * nth / Nsides) 12
end 

to meanlocs

  let masscount 0
  let distorigin 0
  set meanxloc 0
  set meanyloc 0
  set agentcount count actors
  set mominertia 0
;  Calculate the mass weighted mean x and y locations of all the agents
;  Calculate distance to the origin for each agent for the mean distance to the origin calc.
;  Calculate the total mass of all the agents to get the mean x,y location divisor.
;  Set mag (size), angle of each agent
  ask actors [
    set meanxloc meanxloc + ( xc * mass )
    set meanyloc meanyloc + ( yc * mass )
    set masscount masscount + mass
    set mag vecmag self
    set distorigin distorigin + mag
    set angle atan xc yc
    set mominertia mominertia + mass * (mag ^ 2)
  ]
  set meandistorigin distorigin / agentcount  ;; mean distance to the origin of all the agents
  set meanxloc meanxloc / masscount     ; mass weighted mean of x,y locations of all the agents
  set meanyloc meanyloc / masscount
end 

; Calculate means, standard deviations, etc. for display.

to meanlocation

  set groups count actors with [ shape = "triangle"  or  shape = "ghost" ]

  meanlocs

  ask cogs [
    set xcor meanxloc
    set ycor meanyloc
    set color 15 + ( 10 * int ( iterations / 400 ))
  ]

; Calculate mean distance to neighbors for all the agents
; Calculate mean distance to closest neighbor for all agents
; For each agent, store the distance to closest neighbor
  let mindist 0
  let dcnsum 0
  let tempdist 0
  let mymeandist 0
  set meandist 0
  ask actors [
    set mindist 10 * scale
    set mymeandist 0
    ; Calculate the distance to closest neighbor.
    ; Sum mean distance to others for each agent.
    ask other actors [
      set tempdist realdist self myself
      if tempdist < mindist [
        set mindist tempdist
      ]
      set mymeandist mymeandist + tempdist
    ]
    set dcn mindist     ; set distance to closest neighbor
    set dcnsum dcnsum + mindist  ; sum dcns for mean calcs
    ; Then divide by agentcount -1 to not include self) to gat the mean dist to all agents
    ifelse agentcount = 1 [
      set meandist 0
      set dcnsum 0
    ][
      ; Note that distance to self is 0 and is not counted in calculating the mean, hence agent count - 1
      set meandist meandist + ( mymeandist / ( agentcount - 1 ) )  ; sum each agents mean distance to neighbors
    ]
  ]
  ; Get the means across all agents.
  set meandist meandist / agentcount  ; get mean distance to neighbor across all agents
  set meandistclosestneighbor dcnsum / agentcount

  ; Calculate the standard deviations for x, y, and dist to closest neighbor
  set dcnsd 0
  set meanxsd 0
  set meanysd 0
  ask actors [
    set meanxsd meanxsd + ( xc - meanxloc ) ^ 2
    set meanysd meanysd + ( yc - meanyloc ) ^ 2
    set dcnsd dcnsd + ( meandistclosestneighbor - dcn ) ^ 2
  ]
  set meanxsd sqrt ( meanxsd / agentcount )
  set meanysd sqrt ( meanysd / agentcount )
  set dcnsd sqrt ( dcnsd / agentcount )
end 

;; Center of Mass

to recenter
  find-center-of-mass
  ask actors
  [ set xc (xc - center-of-mass-xc)
    set yc (yc - center-of-mass-yc)
    adjust-position
  ]
end 

to find-center-of-mass
  if any? actors
  [ set center-of-mass-xc sum [mass * xc] of actors / sum [mass] of actors
    set center-of-mass-yc sum [mass * yc] of actors / sum [mass] of actors
  ]
end 

; Record the view as a movie
;to movie
;  if record-view [
;    vid:save-recording "view.mp4"
;    vid:stop
;  ]
;  if record-interface [
;    vid:save-recording "interface.mp4"
;    vid:stop
;  ]
;end

; Record the interface as a movie
;to movie-init
;  if record-view [
;    vid:record-view
;  ]
;  if record-interface [
;    vid:record-interface
;  ]
;end


;Copyright 2020 Moody Ahmad, G Jordan Maclay.
;Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License
;License details at https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
;Note: For full disclosure: This model base was the N-Bodies model in the Netlogo Sample Models library under Chemistry and Physics -> Mechanics -> unverified -> N-Bodies. That
;was a starting point. The model has been modified almost completely from the starting point.