NetLogo Code issues (trying to ignite fire using hex cell aggregation) - netlogo

Question

We have a forest and randomized initial point of the fire set up, but the code fails to "ignite" (a function). Our goal is to have a hex cell aggregated model that can spread fire. Overall we want a forest fire that is more realistic by using hex cell aggregation.
Im positive that there is an issue with the eligibility or ignite function. Any help would be greatly appreciated! :)
CODE:
globals [
initial-trees ;; how many trees (green patches) we started with
burned-trees ;; how many have burned so far
switches ;; a list containing the number of switches that are on ;;[So this is the start of the weird hex cell aggregation approach, if you don't wanna use
eligibles ;; a list of cells which are eligible to be ignited ;; it that's all good, you just gotta delete like every instance of the words eligible,
] ;; switches, and all of the read-switches stuff below and on the interface and get it to run]
;; The "switches" list is used so a cell can quickly check its live
;; neighbors count against the six switches without having to actually
;; inspect the switches one by one. If the user flips a switch,
;; the list will be out of date, which is why we ask the user to
;; press the SETUP or READ-SWITCHES buttons after changing switches.
;; ;;[I figured that I'd include this from hex cell aggregation for easy potential reference]
;; The "eligibles" list is used so that when we are trying to decide
;; what cell will become alive next, we don't have to check every
;; cell. The list contains only those cells we know are eligible.
;; Every time a cell becomes alive, we remove it from the list.
;; We must also check that cell's neighbors to see if they need
;; to be added or removed from the list.
breed [cells cell] ;; used to define cells ;;[From hexagonal model examples]
breed [fires fire] ;; bright red turtles -- the leading edge of the fire ;;[From OG model]
breed [embers ember] ;; turtles gradually fading from red to near black ;;[From OG model]
cells-own [ ;;[All of cells-own is from hexagonal model examples]
hex-neighbors ;; agentset of 6 neighboring cells
live-neighbor-count ;; used to store a count of red neighbors
eligible? ;; used to see if cells are eligible for ignition or not
]
to setup
clear-all ;; clears grid
set-default-shape turtles "hex" ;; sets turtle shape to hexagonal ;;[Make sure to import the hex turtle shape from the library in Tools>"Turtle Shape Editor" first]
;; ask turtles with [(random-float 100) < density] ;; random selection from density
;; [ set color green ] ;; sets patch color to green
ask patches with [(random-float 100) < density] [ ;;[For the density parameter]
sprout-cells 1 [ ;;[For turtle creation]
set color green ;;[Grid color like the OG model]
set eligible? false
if pxcor mod 2 = 0 [ ;; if patch column is even, ;;[For converting the square grid to hexagonal]
set ycor ycor - 0.5 ;; shift it down by 0.5
]
]
]
ask cells [ ;;[Everything from here...]
ifelse pxcor mod 2 = 0 [ ;; setup for hex-neighbor agentsets
set hex-neighbors cells-on patches at-points [[0 1] [ 1 0] [ 1 -1]
[0 -1] [-1 -1] [-1 0]]
][
set hex-neighbors cells-on patches at-points [[0 1] [ 1 1] [ 1 0]
[0 -1] [-1 0] [-1 1]]
]
] ;;[...to here for hex-neighbors]
;; set tree counts
ask one-of turtles with [color = green] [ ;;[This can be moved to the go function and scrapped for a better approach if you want,
set color red] ;; just wanted to demonstrate that a random single hex could be picked to start the fire]
set initial-trees count turtles with [color = green];; counts the number of trees ;;[I felt like keeping counters for both of these but you can always remove/change them]
set burned-trees 0 ;; counts the number of burned trees
reset-ticks
end
to go ;;[Here's truly where all the problems lie haha]
if not any? turtles ;; either fires or embers
[ stop ] ;; ends simulation
ask fires ;; otherwise, continue
[ ask hex-neighbors with [color = green] ;;[I tried a number of approaches here to no avail, there are probably tons of ways to do this]
[ ignite ] ;; burn them
set breed embers ] ;; set them to fading burnt color
fade-embers ;; calls aesthetic function
tick
end
to ignite ;; patch procedure, creates fire ;;[This also is where things kinda ground to a halt for me lol]
set eligible? false ;; changes cell state
set eligibles remove self eligibles ;; removes cell from list
ask hex-neighbors [ ;; checks neighbors
set live-neighbor-count live-neighbor-count + 1 ;; adds to live neighbor count
if live-neighbor-count = 6 [ ;; if six neighbors active
ask patches [ ;; [sprout-fires only
sprout-fires 1 ;; works for patches]
[ set color red ] ;; sets cell color to red
]
]
update-eligibility ;; call for eligibility check
]
set pcolor black ;; sets patch color to black ;;[This needs to be affecting the turtle color but that creates problems I think lol]
set burned-trees burned-trees + 1 ;; adds to count of burned trees
end
to update-eligibility ;; cell procedure
ifelse eligible?
;; case 1: currently eligible
[
if not member? live-neighbor-count switches [ ;; checks if cell is in live count
set eligible? false ;; since not, change cell state
set eligibles remove self eligibles ;; and remove cell from list
]
]
;; case 2: not currently eligible
[
;; the check for hidden? ensures the cell isn't already alive
if hidden? and member? live-neighbor-count switches [ ;; [potential need ;;[This is right where the hex cells aggregation approach became too much for me lol,
set eligible? true ;; for use of hidden] ;; when everything got into hiding cells (I don't think the model should use hide/show)]
;; The order of the list doesn't matter, but in NetLogo
;; (as in Logo and Lisp generally), FPUT is much much ;;[This is directly from the hex cells aggregation example I think]
;; faster than LPUT.
set eligibles fput self eligibles ;; puts cell at start of list
]
]
end
to read-switches ;;[Admittedly I never got around to understanding how this works too well but somehow it's
set switches [] ;; more efficient, definitely might not be necessary though]
if one-neighbor? [ set switches lput 1 switches ]
if two-neighbors? [ set switches lput 2 switches ]
if three-neighbors? [ set switches lput 3 switches ]
if four-neighbors? [ set switches lput 4 switches ]
if five-neighbors? [ set switches lput 5 switches ]
if six-neighbors? [ set switches lput 6 switches ]
ask cells [
set eligible? hidden? and member? live-neighbor-count switches
]
set eligibles [self] of cells with [eligible?]
end
;; achieve fading color effect for the fire as it burns
to fade-embers ;; function for fading color of cells to show death ;;[This would be great to keep from the OG model but if it causes any issues you can delete it]
ask embers
[ set color color - 0.3 ;; make red darker
if color < red - 3.5 ;; are we almost at black?
[ set pcolor color ;;[I think this is where there's a problem of patches versus turtles]
die ] ]
end
We tried to take out the eligibility of ignition since we really don't need it, still won't run :(
We tried to redo the code of 'to go' and 'ignite' still won't budge.

Answer 1

As you transitioned from a patch fire model to hex cells using turtles, in you ignite procedure, should you have cells hatching fires instead of patches sprouting fires?