battle_of_sabis.nlogox

<?xml version="1.0" encoding="utf-8"?>
<model version="NetLogo 7.0.2" snapToGrid="false">
  <code><![CDATA[;;;;; DECLARATIONS ;;;;;
breed [legionaries legionary]
breed [leaders leader]
breed [nervii nervii-warrior]
breed [baggage-trains baggage-train]

globals [
  river-amplitude river-halfwidth river-wavelength   ; making river visuals
  river-phase river-offset-y bank-width              ; making river visuals
  dispersion-factor                                  ; dispersion of legions based on compression chosen by user (IV)
  marching?                                          ; track if romans are marching
  nervii-attack-started?                             ; track if nervii have begun their attack
  nervii-attack-start-tick                           ; tick when nervii attack began
  first-roman-aware?                                 ; track if first Roman has become aware
  first-aware-roman                                  ; the first Roman who spotted a Nervii
  first-aware-tick                                   ; save the tick when the first roman became aware
  ambush-bonus                                       ; damage multiplier when attacking romans with statuses != ready
  baggage-awareness-penalty                          ; ticks per baggage ahead of the legion (awareness)
  roman-awareness-radius                             ; LOS in patches for romans becoming aware of nervii
  agent-size                                         ; global agent size (combatant) variable
  baggage-size                                       ; global baggage size variable
  marching-speed                                     ; initial marching speed of romans + baggage
  charge-speed                                       ; initial charge/running speed
  short-attack-range                                 ; shortsword/slashing sword attack range
  long-attack-range                                  ; javelin/pilum attack range
  readiness-times                                    ; store total readiness times
  total-legionaries-at-start                         ; total num legionaries at start to % number of romans who became ready
  legionaries-reached-ready                          ; count of legionaries who reached ready status
  unaware-to-aware-times                             ; store unaware > awareness times
  aware-to-orders-times                              ; store aware > orders received times
  orders-to-ready-times                              ; store times from orders-received > ready
  victory-state                                      ; victory or loss status
  victory-tick                                       ; store tick for win/loss from simulation start
]

patches-own [
  water?
  bank?
  forest?
]

legionaries-own [
  legion-id           ; to link a unit to its legion and legion leader to receive orders
  is-veteran?         ; track if veteran or rookie - veterans are more likely to have higher combat-skill and armor quality
  health              ; track health - start 90-100 stochastic
  opponent-defense    ; determines amount of damage to mitigate
  combat-skill        ; determines amount of damage to deal per tick when in combat. Formula: DPS = ((Accuracy of attacker * Lethality of weapon) / attack time avg in seconds ) ; later multiplied by (1 - Opponent's opponent-defense)
  weapon-type         ; determines range of weapon (80% of units will be shorswords, 20% pilums (javelins))
  speed               ; starts at usual march speed with a baggage train (~1.27m/s), run at 3m/s after aware, slow for melee, and slow regular speed over time
  formation-position  ; position in the marching column, IV
  status              ; unaware, aware, orders-received, ready
                      ; Time between unaware -> aware dependent on Roman's first contact and awareness-latency
                      ; Time between aware -> orders received dependent on order-latency
                      ; Time between orders-received -> ready for battle dependent on readiness-speed
  readiness-speed     ; speed at which unit becomes ready for battle after being given orders; (probability; veterans are faster)
  order-latency       ; time from awareness to given orders, represents confusion described by caesar with compact columns; increases with higher compactness
  awareness-latency   ; time from first Roman awareness to that unit's awareness of battle; increases with distance from first roman's awareness of battle, simulating a messenger going back to warn the legions or visual/audible awareness
  time-to-readiness   ; counted to measure number of ticks from first roman aware to status "ready", determined at runtime
  aware-tick          ; store tick when roman becomes aware
  orders-tick         ; store tick when roman becomes orders-received
  ready-tick          ; store tick when roman becomes ready
  nervii-targeting-me ; track the nervii targeting this roman
  target-nervii       ; the nervii this roman is attacking
  blocked-by-baggage? ; can't move forward due to baggage
]

leaders-own [
  legion-id                  ; link leader to its subordinates to give orders
  is-veteran? 
  health
  opponent-defense
  combat-skill
  weapon-type
  speed
  formation-position
  status                     ; unaware, aware, orders-issued, ready
  order-consideration-time   ; time from aware -> giving orders, probability of faster if veteran
  awareness-latency          ; time from first Roman awareness to this leader's awareness
  readiness-speed            ; speed at which unit becomes ready for battle after being given orders; random between 5 and 10 seconds for leaders after issuing orders
  nervii-targeting-me        ; track the nervii are targeting this roman
  target-nervii              ; the nervii this leader is attacking
  blocked-by-baggage?        ; can't move forward due to baggage
  legion-isolation-penalty   ; isolation penalty for legion's performance if no other legions in LOS
] 

baggage-trains-own [
  legion-id                  ; associated legion; determines direction to march
  speed                      
  formation-position         ; where to place baggage based on formation order IV chosen
  status                     ; unaware -> aware of battle. unaware == marching behind legion, aware == moving to side
  awareness-latency          ; time until baggage becomes aware
  side-movement-target       ; x-coordinate to move to when getting out of way
  down-movement-target       ; y coord to move when getting out of way
  has-cleared-path?          ; track if baggage has moved far enough and may stop
]

nervii-own [
  is-attacking?              ; tracks if nervii are attacking, set to false initially then true once roman within a certain distance of sight line
  health
  combat-skill               ; increases depending on ambush bonus, if the roman attacked isn't "Ready"
  opponent-defense           ; lower than Romans, very little armor historically, probability between 0 and 0.1
  speed                      ; run/sprint when charging, slows over time
  target-roman               ; the specific roman our nervii agent is currently pursuing
  romans-targeting-me        ; track romans that are targeting this nervii
  blocked-by-baggage?
]

;;;;; SETUP & GO main loop ;;;;;

to setup
  clear-all
  resize-world -125 125 -175 100      ; 10m x 10m patches
  set agent-size 1.5                  ; gives each soldier in the 80 soldiers in an agent about 3 sqmeters of space
  set baggage-size 12                 ; approx size of a legion 1:1 ratio, 14,336 sqmeters
  set marching-speed 0.127            ; est. 1.27 meters per second while marching with baggage train
  set charge-speed 0.3                ; est 3 m/s once aware of battle
  set-default-river-params
  color-terrain
  create-forest
  setup-agents
  set marching? false
  set nervii-attack-started? false
  set nervii-attack-start-tick -1
  set first-roman-aware? false
  set first-aware-roman nobody
  set first-aware-tick -1
  set ambush-bonus 2                  ; 2x damage from ambush - devastating initial blow according to Caesar
  set roman-awareness-radius 10       ; LOS in dust/debris/chaos: ~100 meters
  set short-attack-range 0.1          ; 1 meter for shortswords/slashing swords
  set long-attack-range 1.5           ; 15 meters for pilums
  set baggage-awareness-penalty 180   ; ~3 min per baggage in between legion and battle
  set readiness-times []              ; init readiness times to mean later
  set unaware-to-aware-times []        
  set aware-to-orders-times []        
  set orders-to-ready-times []        
  set total-legionaries-at-start count legionaries
  set legionaries-reached-ready 0
  set victory-state "In progress"
  set victory-tick -1
  reset-ticks
end

to go
  if not marching? [
    set marching? true ; start by marching romans towards river
  ]
  
  ; check if any roman has reached the trigger point for ambush (pycor >= 30) (within 300 meters of forest start)
  check-ambush-trigger
  
  ;; roman state transitions
  ; unaware -> aware
  check-first-roman-awareness
  update-roman-awareness
  update-baggage-awareness
  ; aware -> orders-received
  process-leader-orders
  process-legionary-orders
  ; orders-received -> ready
  process-legionary-readiness
  
  ; Nervii behavior
  ask nervii [
    ifelse is-attacking? [
      ; Nervii are attacking - move toward closest available Roman
      nervii-attack-movement
      
    ] [
      ; Stay hidden in forest - no movement yet
    ]
  ]
  
  ; romans march toward river
  march-romans
  
  
  ; COMBAT
  nervii-combat
  roman-combat
  
  ; Remove dead agents
  remove-dead-agents
  
  ; update victory status if battle is won
  update-victory
  if victory-state != "In progress" [ 
    plot-readiness-histogram
    stop 
  ]
  
  tick
end


;;;;; TERRAIN SETUP ;;;;;
;; patch represents: 10 meters x 10 meters
;; tick represents: 1 second
to set-default-river-params
  if river-amplitude = 0 [ set river-amplitude 2 ]
  if river-halfwidth  = 0 [ set river-halfwidth 2.5 ]
  if river-wavelength = 0 [ set river-wavelength 10 ]  
  if river-phase      = 0 [ set river-phase 0 ]
  if river-offset-y   = 0 [ set river-offset-y 29 ] ; center of river ~290m away (edge was ~300 paces from forest line)
  if bank-width       = 0 [ set bank-width 1 ]
end

to color-terrain
  ask patches [
    set forest? false  
    set water? in-river? self
    set bank? (not water?) and any? neighbors with [ in-river? self ]
    set pcolor
      ifelse-value water? [ blue + 1 ]
      [ ifelse-value bank? [ brown + 2 ] [ green ] ]
  ]
end

to create-forest
  ask n-of 200 patches with [ not water? and not bank? and pycor > 60 ] [
    set pcolor 53 
    set forest? true
    ask patches in-radius 5 with [ not water? and not bank? ] [
      set pcolor 53
      set forest? true
    ]
  ]
end


to-report river-center-y [x]
  report river-offset-y + river-amplitude * sin (x * river-wavelength + river-phase)
end

to-report in-river? [p]
  let cx river-center-y ([pxcor] of p)
  report abs(([pycor] of p) - cx) <= river-halfwidth
end

to-report river-patches
  report patches with [ water? ]
end

to-report bank-patches
  report patches with [ bank? ]
end

;;;;; AGENT SETUP ;;;;;

to setup-agents
  ; compactness-of-legions: 0.0 = highly dispersed, 1.0 = highly compact
  set dispersion-factor (1 - compactness-of-legions) * 32 + 13 ; Range from 13 patches horizontally and across to 45
  ; legion is approx 13 patches x 11 patches in total W/H, and so dispersion from center effectively means that 13 patches legions are literally right next to each other horizontally and only a few meters away vertically.
  ; most compact = legion CENTERS are 130 meters away from each other horizontally/vertically. (Legion EDGES 0 meters away from each other(minus the size of baggage between))
  ; most disperse = legion centers are 450 meters away horizontally/vertically.
  
  ; setup romans based on IVs: formation order and dispersion
  setup-roman-formation
  
  ; setup nervii in the forest
  setup-nervii
end

to setup-roman-formation
  let formation-order get-formation-order
  
  ; starting positions
  let current-y 0
  let formation-index 0
  let left-y current-y
  let right-y current-y
  
  ; baggage starting positions
  let in-baggage-section false
  let baggage-y 0
  let baggage-count 0
  
  ; create agents according to formation order and dispersion-factor IVs
  foreach formation-order [ unit-spec ->
    let unit-type item 0 unit-spec
    let legion-num item 1 unit-spec
    
    if unit-type = "legion" [
      if in-baggage-section [
        set in-baggage-section false
      ]
      
      ; column positions: dispersion-factor apart
      let column-x 0
      let legion-y 0
  
      ; handling for Caesar's order - veteran legions in single row
      ifelse roman-order = "Caesar's order" and legion-num <= 6 [
        ; legions 1-6 in a single horizontal row
        ; legion spacing: dispersion-factor betwn centers
        let legion-position (legion-num - 3.5)
        set column-x legion-position * dispersion-factor
        set legion-y 0  
    
        ; set positions for baggage/rookie legions
        if legion-num = 6 [
          set left-y legion-y - dispersion-factor
          set right-y left-y
        ]
      ] [
        ; expected order: standard Roman two column placement
        ifelse legion-num mod 2 = 1 [
          ; left column
          set column-x (- dispersion-factor / 2)
          set legion-y left-y
        ] [
          ; right column
          set column-x (dispersion-factor / 2)
          set legion-y right-y
        ]
      ]
  
      ; create legion leader
      create-leaders 1 [
        set legion-id legion-num
        set is-veteran? (legion-num <= 6)
        set shape "triangle"
        set color 45
        set size agent-size + 0.5
        setxy column-x legion-y
        set heading 0
        set formation-position formation-index
        set blocked-by-baggage? false
        initialize-leader-params
      ]
  
      ; create legionaries and chunk them with their legion
      let legionaries-per-side 7  
      let agent-spacing agent-size + 0.1
      let current-legionary 0
      
      create-legionaries 55 [
        set legion-id legion-num
        set is-veteran? (legion-num <= 6)
        set shape "square"
        set color red
        set size agent-size
        
        let row floor (current-legionary / 8)
        let col current-legionary mod 8
        
        let offset-x (col - 7 / 2.0) * agent-spacing
        let offset-y (row - 6 / 2.0) * agent-spacing
        
        let jitter-x (random-float 0.3) - 0.15
        let jitter-y (random-float 0.3) - 0.15
        
        setxy (column-x + offset-x + jitter-x) (legion-y + offset-y + jitter-y)
        
        set heading 0
        set formation-position formation-index
        set blocked-by-baggage? false
        initialize-legionary-params
        
        set current-legionary current-legionary + 1
      ]
  
      ; use dispersion factor to determine spacing - only for standard two-column
      if roman-order = "Caesar's order" and legion-num > 6 [
        if legion-num mod 2 = 0 [
          set left-y left-y - dispersion-factor
          set right-y right-y - dispersion-factor
        ]
      ]
      
      if roman-order = "Expected order" [
        ; have to place baggage between, continue
      ]
      
      set formation-index formation-index + 1
    ]
    
    ; set baggage order and distance based on each order
    if unit-type = "baggage" [
      if not in-baggage-section and roman-order = "Caesar's order" [
        set in-baggage-section true
        set baggage-y left-y
        set baggage-count 0
      ]
      
      if roman-order = "Caesar's order" [
        let row floor (baggage-count / 4)
        let col baggage-count mod 4
        
        let baggage-spacing baggage-size
        let baggage-x (col - 1.5) * baggage-spacing
        
        let min-spacing baggage-size
        
        ; calc spacing above baggage section
        let spacing-above (dispersion-factor * 0.5)
        if spacing-above < min-spacing [
          set spacing-above min-spacing
        ]
        
        let first-row-y baggage-y + (dispersion-factor - spacing-above)
        let baggage-y-pos first-row-y - (row * baggage-spacing)
        
        create-baggage-trains 1 [
          set legion-id legion-num
          set shape "circle"
          set color 17
          set size baggage-size
          setxy baggage-x baggage-y-pos
          set heading 0
          set formation-position formation-index
          set speed marching-speed
          set status "unaware"
          set awareness-latency -1
          set side-movement-target 0
          set has-cleared-path? false
        ]
        
        set baggage-count baggage-count + 1
        
        if baggage-count = 8 [
          ; calculate spacing below baggage section
          let spacing-below (dispersion-factor * 0.5)
          if spacing-below < min-spacing [
            set spacing-below min-spacing
          ]
          
          ; second row is at: first-row-y - baggage-spacing
          set left-y first-row-y - baggage-spacing - spacing-below
          set right-y left-y
        ]
      ]
      
      if roman-order = "Expected order" [
        let column-x 0
        let baggage-y-pos 0
        
        let min-spacing baggage-size
        
        let spacing-around-baggage (dispersion-factor * 0.5)
        if spacing-around-baggage < min-spacing [
          set spacing-around-baggage min-spacing
        ]
        
        ifelse legion-num mod 2 = 1 [
          set column-x (- dispersion-factor / 2)
          set baggage-y-pos left-y - spacing-around-baggage
        ] [
          set column-x (dispersion-factor / 2)
          set baggage-y-pos right-y - spacing-around-baggage
        ]
        
        create-baggage-trains 1 [
          set legion-id legion-num
          set shape "circle"
          set color 17
          set size baggage-size
          setxy column-x baggage-y-pos
          set heading 0
          set formation-position formation-index
          set speed marching-speed
          set status "unaware"
          set awareness-latency -1
          set side-movement-target 0
          set down-movement-target 0
          set has-cleared-path? false
        ]
        
        ifelse legion-num mod 2 = 1 [
          set left-y baggage-y-pos - spacing-around-baggage
        ] [
          set right-y baggage-y-pos - spacing-around-baggage
        ]
      ]
      set formation-index formation-index + 1
    ]
  ]
end

to-report get-formation-order
  ; returns list to represent orders
  if roman-order = "Caesar's order" [
    ; legions 1-6, all baggage, legions 7-8
    report (list
      ["legion" 1] ["legion" 2] ["legion" 3] 
      ["legion" 4] ["legion" 5] ["legion" 6]
      ["baggage" 1] ["baggage" 2] ["baggage" 3]
      ["baggage" 4] ["baggage" 5] ["baggage" 6]
      ["baggage" 7] ["baggage" 8]
      ["legion" 7] ["legion" 8]
    )
  ]
  
  if roman-order = "Expected order" [
    ; baggage behind its legion in expected
    report (list
      ["legion" 1] ["baggage" 1]
      ["legion" 2] ["baggage" 2]
      ["legion" 3] ["baggage" 3]
      ["legion" 4] ["baggage" 4]
      ["legion" 5] ["baggage" 5]
      ["legion" 6] ["baggage" 6]
      ["legion" 7] ["baggage" 7]
      ["legion" 8] ["baggage" 8]
    )
  ]
  
  ; default to Caesar's order
  report (list
    ["legion" 1] ["legion" 2] ["legion" 3] 
    ["legion" 4] ["legion" 5] ["legion" 6]
    ["baggage" 1] ["baggage" 2] ["baggage" 3]
    ["baggage" 4] ["baggage" 5] ["baggage" 6]
    ["baggage" 7] ["baggage" 8]
    ["legion" 7] ["legion" 8]
  )
end

to initialize-legionary-params
  ; init roman combatants
  set health 90 + random-float 10 ; 90-100
  
  ; 80% shortswords, 20% long-range pilums
  ifelse random-float 1.0 < 0.8 [
    set weapon-type "short-range" ; 0.1 patch distance range (1 meter)
  ] [
    set weapon-type "long-range" ; 1.5 patch distance range (15 meter)
  ]
  
  ; vet stats 
  if is-veteran? [
    ifelse weapon-type = "short-range" [
      ; Vet with Shortsword
      set opponent-defense 0.45 + random-float 0.1      ; avg vet with shortsword opponent-defense = 50% (+- 5%)
      ; DPS = ((Accuracy of attacker * Lethality of weapon) / attack time avg in seconds) effect of opponent's armor determined during attack
      set combat-skill 18.5 + random-float 5            ; (0.7 * 0.6) / 2 seconds = 0.21. = 21 (+- 2.5)
    ] [
      ; Vet with Javelin
      set opponent-defense 0.25 + random-float 0.1      ; half armor quality - no shield when using pilum (30% +-5)
      set combat-skill 8.75 + random-float 5            ; (0.5 * 0.9) / 4 seconds = 0.1125 == 11.25 (+-2.5)
    ]
  ]

  ; rookie stats
  if not is-veteran? [
    ifelse weapon-type = "short-range" [
      ; Rookie with Shortsword
      set opponent-defense 0.35 + random-float 0.1    ; avg rookie with shortsword opponent-defense = 40% (+- 5%)
      set combat-skill 8 + random-float 5             ; (0.35 * 0.6) / 2 seconds = 0.105 => 10.5 (+-2.5) (rookies accuracy approx half of vet's)
    ] [
      ; Rookie with Javelin
      set opponent-defense 0.15 + random-float 0.1    ; avg rookie with jav armor quality = 20% (half. no shield)
      set combat-skill 3.125 + random-float 5         ; (0.25 * 0.9) / 4 seconds = 0.05625 ==> 5.625 (+- 2.5 points)
    ] 
  ]
  
  set nervii-targeting-me 0  ; no nervii targeting him at beginning
  set target-nervii nobody   ; not targeting anyone yet
  set order-latency -1 ; not yet init
  set readiness-speed -1 ; not yet init
  set time-to-readiness -1 ;not yet init
  set aware-tick -1 
  set orders-tick -1
  set ready-tick -1
  
  set speed marching-speed

  set status "unaware"
end

; init roman leaders
to initialize-leader-params
  set health 90 + random-float 10 ; 90-100
  
  set weapon-type "short-range" ; typically, leaders did not throw javelins
  
  if is-veteran? [
      set opponent-defense 0.45 + random-float 0.1      ; avg vet with shortsword opponent-defense = 50% (+- 5%)
      set combat-skill 18.5 + random-float 5            ; (0.7 * 0.6) / 2 seconds = 0.21. = 21 (+- 2.5)
  ]
  if not is-veteran? [
      set opponent-defense 0.35 + random-float 0.1      ; avg rookie with shortsword opponent-defense = 40% (+- 5%)
      set combat-skill 8 + random-float 5               ; (0.35 * 0.6) / 2 seconds = 0.105 => 10.5 (+-2.5) (rookies accuracy approx half of vet's)
  ]  
  
  set nervii-targeting-me 0  
  set target-nervii nobody
  
  set readiness-speed 5 + random 10
  
  set legion-isolation-penalty 1.0 ; default - no penalty
  
  set weapon-type "short-range"
  set speed marching-speed
  ; turns to 0.3 when fighting/aware
  set status "unaware"
end

;;;; SETUP NERVII ;;;;;

to setup-nervii
  ; 313 nervii agents (~25,040 warriors historically / 80) organized in tribal clusters in forest patches
    let forest-patches-list patches with [
    forest? = true and 
    pxcor >= -30 and pxcor <= 30 and ; nervii were close together according to hisotrical sources, despite being in different tribes
    pycor >= 65 and pycor <= 75
  ]
  
  if any? forest-patches-list [
    ; ~6 tribal clusters
    let num-tribes 6
    let nervii-per-tribe floor (313 / num-tribes)
    
    repeat num-tribes [
      ; pick a central location for this tribe
      let tribe-center one-of forest-patches-list
      
      ; create warriors
      create-nervii nervii-per-tribe [
        set shape "square"
        set color violet
        set size agent-size
        
        ; position= loosely near tribe center
        move-to tribe-center
        
        let offset-distance random-float 10
        let offset-angle random-float 360
        let new-x [pxcor] of tribe-center + offset-distance * sin offset-angle
        let new-y [pycor] of tribe-center + offset-distance * cos offset-angle
        
        ; forest bounds
        if new-x < -35 [ set new-x -35 ]
        if new-x > 35 [ set new-x 35 ]
        if new-y < 60 [ set new-y 60 ]
        if new-y > 80 [ set new-y 80 ]
        
        let target-patch patch new-x new-y
        ifelse [forest?] of target-patch = true [
          setxy new-x new-y
        ] [
          setxy [pxcor] of tribe-center [pycor] of tribe-center
        ]
        
        set is-attacking? false
        set health 90 + random-float 10 ; 90-100
        set opponent-defense 0.05 + random-float 0.1 ; only a shield used if any. typically very minimal armor 10% +- 5%
        set combat-skill 10 + random-float 5         ; (0.5 * 0.5)/2 seconds = 0.125 -> 12.5 pts (+- 2.5), ends up being a little higher than rookie roman
        set speed charge-speed; 
        set heading 180 ; facing south toward romans
        set target-roman nobody
        set romans-targeting-me 0
        set blocked-by-baggage? false

      ]
    ]
  ]
end


;;;;; AGENT MOVEMENT ;;;;;
to march-romans
  ; romans begin marching northward
  ; speed determined by terrain
  
  ; movement depends on status
  ask legionaries with [status = "unaware"] [    
    let terrain-speed get-terrain-speed
    move-avoiding-baggage (speed * terrain-speed)
    set heading 0
  ]
  
  ask leaders with [status = "unaware"] [
    let terrain-speed get-terrain-speed
    move-avoiding-baggage (speed * terrain-speed)
    set heading 0

  ]
  
  ; aware and orders-received legionaries slow down to organize
  ask legionaries with [status = "aware" or status = "orders-received"] [
    let terrain-speed get-terrain-speed
    move-avoiding-baggage (speed * 0.5 * terrain-speed)
    set heading 0  ; Keep marching north
  ]
  
  ask leaders with [status = "aware" or status = "orders-issued"] [
    let terrain-speed get-terrain-speed
    move-avoiding-baggage (speed * 0.5 * terrain-speed)
    set heading 0

  ]
  
  ; ready legionaries move toward attackers or find enemies
 ask legionaries with [status = "ready"] [
  let attackers nervii with [target-roman = myself and is-attacking?]
  
  ifelse any? attackers [
    ; move toward attacker
    let nearest-attacker min-one-of attackers [distance myself]
    face nearest-attacker
    let terrain-speed get-terrain-speed
    let dist-to-target distance nearest-attacker
    
    ; slow down when close ...avoid overshooting
    ifelse dist-to-target <= 0.5 [
      ; if theyre close to attacker, slow down to fight
      move-avoiding-baggage (speed * 0.3 * terrain-speed)
    ] [
      ; forward speed * terrain-speed
      move-avoiding-baggage (speed * terrain-speed)
    ]
  ] [
   ; if i already have a target, move toward it
    ifelse target-nervii != nobody and is-turtle? target-nervii [
      face target-nervii
      let terrain-speed get-terrain-speed
      let dist-to-target distance target-nervii
      ifelse dist-to-target <= 0.5 [
        ; if theyre close to target, slow down to fight
        move-avoiding-baggage (speed * 0.3 * terrain-speed)
      ] [
        move-avoiding-baggage (speed * terrain-speed)
      ]
    ] [
      ; otherwise search nearby for new enemies
      let nearby-nervii nervii with [is-attacking?] in-radius 15
        
      if not any? nearby-nervii [
          set nearby-nervii nervii with [is-attacking?] in-radius 25
      ]
        
      if not any? nearby-nervii [
          set nearby-nervii nervii with [is-attacking?] in-radius 40
      ]
        
      if any? nearby-nervii [
        let nearest-nervii min-one-of nearby-nervii [distance myself]
        face nearest-nervii
        let terrain-speed get-terrain-speed
        let dist-to-target distance nearest-nervii
        ifelse dist-to-target <= 0.5 [
            move-avoiding-baggage (speed * 0.3 * terrain-speed)
        ] [
            move-avoiding-baggage (speed * terrain-speed)
        ]
      ]
    ]
  ]
]

  ; same movement as legionaries for combat
ask leaders with [status = "ready"] [
  let attackers nervii with [target-roman = myself and is-attacking?]
  
  ifelse any? attackers [
    let nearest-attacker min-one-of attackers [distance myself]
    face nearest-attacker
    let terrain-speed get-terrain-speed
    let dist-to-target distance nearest-attacker
    
    ifelse dist-to-target <= 0.5 [
        move-avoiding-baggage (speed * 0.3 * terrain-speed)
    ] [
        move-avoiding-baggage (speed * terrain-speed)
    ]
  ] [
    ifelse target-nervii != nobody and is-turtle? target-nervii [
      face target-nervii
      let terrain-speed get-terrain-speed
      let dist-to-target distance target-nervii
      ifelse dist-to-target <= 0.5 [
          move-avoiding-baggage (speed * 0.3 * terrain-speed)
      ] [
          move-avoiding-baggage (speed * terrain-speed)
      ]
    ] [
      let nearby-nervii nervii with [is-attacking?] in-radius 15
        
      if not any? nearby-nervii [
          set nearby-nervii nervii with [is-attacking?] in-radius 25
      ]
        
      if not any? nearby-nervii [
          set nearby-nervii nervii with [is-attacking?] in-radius 40
      ]
        
      if any? nearby-nervii [
        let nearest-nervii min-one-of nearby-nervii [distance myself]
        face nearest-nervii
        let terrain-speed get-terrain-speed
        let dist-to-target distance nearest-nervii
        ifelse dist-to-target <= 0.5 [
            move-avoiding-baggage (speed * 0.3 * terrain-speed)
        ] [
            move-avoiding-baggage (speed * terrain-speed)
        ]
      ]
    ]
  ]
]
  
  ; move to the side and down, baggage is massive and slow
  ask baggage-trains [
    ifelse status = "aware" [
      if not has-cleared-path? [
        let target-dist distancexy side-movement-target down-movement-target
        
        if target-dist > 0.5 [
          ; move towards target
          set heading towardsxy side-movement-target down-movement-target
          forward (speed * 0.5) 
        ]
        
        ; check if arrived
        if target-dist <= 0.5 [
          set has-cleared-path? true
          set color yellow ; indicate that path is clear
        ]
      ]
    ] [
      ; normal marching when unaware
      let terrain-speed get-terrain-speed
      forward speed * terrain-speed
      set heading 0
    ]
  ]
  
end

to-report get-terrain-speed
  ; get speed mult based on terrain type
  let current-patch patch-here
  
  if [water?] of current-patch [
    report 0.6  ; 60% speed in water
  ]
  
  if [bank?] of current-patch [
    report 0.8 ; 80% of speed in bank
  ]
  
  if [forest?] of current-patch [
    report 0.7  ; 70% speed in forest
  ]
  
  report 1.0  ; normal terrain
end

;;;;; ROMAN STATUS CHANGES ;;;;;

;;; UNAWARE -> AWARE ;;;
to check-first-roman-awareness
    ; check if first roman has been made aware of attack
  if not first-roman-aware? [
    ; visible == not in forest and within 10 patches (~100 meters)
    let all-romans (turtle-set legionaries leaders)
    
    ask all-romans with [status = "unaware"] [
      let visible-nervii nervii in-radius roman-awareness-radius with [
        is-attacking? and 
        not [forest?] of patch-here
      ]
      
      if any? visible-nervii [
        ; first roman to spot nervii
        set status "aware"
        set speed charge-speed ; increase speed to running once aware
        set color orange  ; indicates awareness
        
        set first-roman-aware? true
        set first-aware-roman self
        set first-aware-tick ticks  ; save tick number first roman became aware to track awareness times
        
        ; once first roman aware, calculate awareness-latency for all other romans based on distance from first aware Roman 
        ; represents approx rider travel time or audible/visual latency if within shouting/discernable distance
        calculate-awareness-latency
        calculate-baggage-awareness-latency
        
        stop 
      ]
    ]
  ]
end

to calculate-awareness-latency
; once first roman becomes aware, this calculates how long until each agent becomes aware
 ask (turtle-set legionaries leaders) with [status = "unaware"] [
   let dist distance first-aware-roman
   
   ; count baggage trains between this Roman and the battle
   let f baggage-in-front-factor legion-id
   
    ; base awareness - on foot or mule -> legion behind, no cavalry as they were wiped at beginning
    ; run speed: 3 m/s avg
    ; time = distance / speed
    ; time = (dist * 10 meters) / 3 patches p tick
    ; to do: diminish run speed over time
    ; anywhere from 10-30 seconds added, getting through column
   let base (dist * 10 / 3) + 10 + random-float 20
   
   ; awareness latency accounts for distance and baggage between
   set awareness-latency base + (f * baggage-awareness-penalty)
 ]
end

to calculate-baggage-awareness-latency
  ; slow reacts due to equipment load and size
  ask baggage-trains with [status = "unaware"] [
    let dist distance first-aware-roman
    set awareness-latency (dist * 10 / 3) + 20 + random-float 20
  ]
end

to update-baggage-awareness
  ; baggage trains become aware, attempt to hang back or get out of way
  if first-roman-aware? [
    ask baggage-trains with [status = "unaware"] [
      let should-become-aware false
      
      let visible-nervii nervii in-radius roman-awareness-radius with [
        is-attacking? and 
        not [forest?] of patch-here
      ]
      
      if any? visible-nervii [
        set should-become-aware true
      ]
      
      if not should-become-aware [
        if awareness-latency > 0 [
          set awareness-latency awareness-latency - 1
        ]
        
        if awareness-latency <= 0 [
          set should-become-aware true
        ]
      ]
      
      if should-become-aware [
        set status "aware"
        set color white ; aware baggage
        
        let side-distance 20 ; aim to move away to the side and down
        let down-distance 20
        
        ifelse xcor < 0 [
          set side-movement-target xcor - side-distance
        ] [
          set side-movement-target xcor + side-distance
        ]
        
        set down-movement-target ycor - down-distance
      ]
     
    ]
  ]
end

to update-roman-awareness
  ; romans become aware when:
  ; 1. they see nervii nearby (after battle start, caesar implies dust/debris/chaos greatly impacted LOS, so if battle has already started, visibility lowers by 0.25)
  ; 2. awareness-latency expires
  
  if first-roman-aware? [
    ask (turtle-set legionaries leaders) with [status = "unaware"] [
      let should-become-aware false
      
      ; can they see battle/nervii? 
      ; account for baggage visibility and LOS
      let candidate-nervii nervii in-radius roman-awareness-radius with [
        is-attacking? and 
        not [forest?] of patch-here
      ]
      
      ; filter out nervii blocked by baggage
      let me-roman self  ; save ref to this roman
      let visible-nervii candidate-nervii with [
        [has-clear-line-of-sight-to? myself] of me-roman
      ]
      
      if any? visible-nervii [
        set should-become-aware true
      ]
      
      ; check if awareness latency has expired
      if not should-become-aware [
        if awareness-latency > 0 [
          set awareness-latency awareness-latency - 1
        ]
        
        if awareness-latency <= 0 [
          set should-become-aware true
        ]
      ]
    
      ; if any condition met, become aware
      if should-become-aware [
        set status "aware"
        set speed charge-speed 
        set color orange
        
        ; if leader, add order consideration time
        if breed = leaders [
          set order-consideration-time 5 + random 20  
        ]
        
        ; track time from first roman aware to this roman being aware
        if breed = legionaries [
          set aware-tick ticks
          set unaware-to-aware-times lput (ticks - first-aware-tick) unaware-to-aware-times
        ]
      ]
    ]
  ]
end

to-report baggage-in-front-factor [lid]
  if roman-order = "Expected order" [
    ifelse (lid mod 2 = 1) [
      ;; odd legion IDs 1,3,5,7 baggage ahead are odd IDs < lid ; get num baggage ahead
      report floor ((lid - 1) / 2)
    ] [
      ;; even legion IDs 2,4,6,8 get num of baggage ahead
      report floor ((lid - 2) / 2)
    ]
  ]
  if roman-order = "Caesar's order" [
    ifelse lid <= 6 [ 
      report 0                  ;; all vets ahead of the baggage block
    ] [   
      if compactness-of-legions > 0.75 [
        report 4                 ;; rookies 7 and 8 are fully masked by block of baggage at high compactness - 2 rows of 4 columns of baggage
      ]
      if compactness-of-legions > 0.5
      [
        report 2               ;; rookies 7 and 8 are halfway masked by the block when compactness is between 0.5 - 0.75 - one column of 2 rows
      ]
      if compactness-of-legions > 0.25
      [
        report 1               ;; rookies 7 and 8 are halfway masked by the block when compactness is lower than 0.5 half column of 2 rows
      ]
      report 0.5               ;; rookies 7 and 8 are barely masked by block when compactness is lower than 0.25 - 1/4 column of 2 rows
    ]
  ]
  report 0
end


to-report has-clear-line-of-sight-to? [target-agent]
  let target-x [xcor] of target-agent
  let target-y [ycor] of target-agent
  
  ; check if any baggage is in the way - rough
  ; to do: make this more accurate
  let is-blocked any? baggage-trains with [
    (ycor > min (list [ycor] of myself target-y) and 
     ycor < max (list [ycor] of myself target-y)) and
    (abs (xcor - [xcor] of myself) < baggage-size)
  ]
  
  report not is-blocked
end

;;; AWARE -> ORDERS-RECEIVED ;;;
to process-leader-orders
  ; aware leaders count down their order-consideration-time and then give orders
  ask leaders with [status = "aware"] [
    if order-consideration-time > 0 [
      set order-consideration-time order-consideration-time - 1
    ]
    
    if order-consideration-time <= 0 [
      set status "orders-issued"
      set color yellow 
    ]
  ]
end

to process-legionary-orders
  ; aware legionaries check if leader has given orders
  ask legionaries with [status = "aware"] [
    let my-legion-id legion-id
    let my-leader one-of leaders with [legion-id = my-legion-id]
    
    let leader-exists (my-leader != nobody)
    
    ifelse leader-exists and ([status] of my-leader = "orders-issued" or [status] of my-leader = "ready") [
      ; order latency not yet init? calc now.
      if order-latency < 0 [
        let dist-from-leader distance my-leader
  
        ; compactness causes confusion - caesar attributes a lot of confusion about processing orders from the closeness of his legions
        ; removing penalty from legions with edges not within earshot of each other
        let compactness-penalty 0
        if compactness-of-legions > 0.8 [ ; when compactness = 0.8, legion centers are ~200meters away from each other, no audibility/visibility so compactness penalty would not apply.
          ; Caesar complained of compactness causing consufion chaos, no room to form up/grab weapons, unclear orders => assumption of 5-10 min based on his account. Avg 7.5
          ; at highest compactness, legions directly next to each other, approx 7.5 min of confusion (+-30 second)
          ; squaring for non-linear effects mimicking real compactness results as even just being 100 meters away = exponentially less confusion
          set compactness-penalty ((compactness-of-legions * compactness-of-legions) * (435 + random 30))
        ]
             
        ; veterans handle chaos much better
        let chaos-modifier 1.0
        ifelse is-veteran? [
          set chaos-modifier 1.0 ; 
        ] [
          set chaos-modifier 2.0 ; at highest compactness, confusion time double for rookies
        ]
        
        let base (compactness-penalty * chaos-modifier)
        
        set order-latency (base + dist-from-leader + random-float 10) ; incorporate distance from legion leader and a random num seconds up to 10 for realism
      ]
      
      ; count down order-latency
      if order-latency > 0 [
        set order-latency order-latency - 1
      ]
      
      ; receive orders
      if order-latency <= 0 [
        set status "orders-received"
        set color cyan
        
        ; track time from aware -> orders-received
        set orders-tick ticks
        set aware-to-orders-times lput (ticks - aware-tick) aware-to-orders-times
        
        ; initialize readiness speed then count down until ready
        ifelse is-veteran? [
          set readiness-speed 10 + random 20 ; vets ready in 10 to 30 seconds; trained to fight ambushes
        ] [
          set readiness-speed 30 + random 30 ; rookies ready in 30 to 60 seconds
        ]
        
      ]
      ] [
    ; leader is dead or missing - legions need to self organize. veterans can self-organize faster
    if not leader-exists [
        
      ; order latency not yet init? calc now.
      if order-latency < 0 [
  
        ; same compactness confusion penalty as above
        let compactness-penalty 0
        if compactness-of-legions > 0.8 [ 
            ; Caesa
          set compactness-penalty ((compactness-of-legions * compactness-of-legions) * (435 + random 30))
        ]
             
        let chaos-modifier 1.0
        ifelse is-veteran? [
          set chaos-modifier 1.0 ; 
        ] [
          set chaos-modifier 2.0 
        ]
        
        let base (compactness-penalty * chaos-modifier)
        
        set order-latency (base + random-float 10) 
      
        ; init with penalty for no leader
        ifelse is-veteran? [
          set order-latency (order-latency + 20 + random-float 20)  ; veterans can self-organize faster (extra 20-40 seconds)
        ] [
          set order-latency (order-latency + 40 + random-float 60)  ; rookies struggle more (extra 40-60 seconds)
        ]
      ]
      
      ; count down and transition
      if order-latency > 0 [
        set order-latency order-latency - 1
      ]
      
      if order-latency <= 0 [
        set status "orders-received"
        set color cyan
          
        ; track time from aware -> orders-received
        set orders-tick ticks
        set aware-to-orders-times lput (ticks - aware-tick) aware-to-orders-times
        
        ifelse is-veteran? [
          set readiness-speed 10 + random 20 ; same readiness speed as above after orders given
        ] [
          set readiness-speed 30 + random 30 ; same readiness speed as above after orders given
        ]
      ]
    ]
  ]
] 
end

;; ORDERS-RECEIVED -> READY
to process-legionary-readiness
  ask legionaries with [status = "orders-received"] [
    if readiness-speed > 0 [
      set readiness-speed readiness-speed - 1
    ]
    
    if readiness-speed <= 0 [
      set status "ready"
      set color red
      set time-to-readiness ticks - first-aware-tick                               ; time from roman first aware to roman ready
      set readiness-times lput (ticks - first-aware-tick) readiness-times          ; save to readiness-times list
      set legionaries-reached-ready legionaries-reached-ready + 1                  ; increment counter for # of legionaries who reached "ready"
      set orders-to-ready-times lput (ticks - orders-tick) orders-to-ready-times   ; track # ticks from orders received -> ready
      set ready-tick ticks
    ]
  ]
  
  ask leaders with [status = "orders-issued"] [
    if readiness-speed > 0 [
      set readiness-speed readiness-speed - 1
    ]
    
    if readiness-speed <= 0 [
      set status "ready"
      set color red  
      
      ; calculate isolation penalty for legion
      set legion-isolation-penalty calculate-legion-isolation-penalty
    ]
  ]
end

to-report calculate-legion-isolation-penalty
  ; support range (+ 15 patches, needs to include size of roman legion as legion leaders are at the center of each)
  ; historically, isolated units performed worse
  let support-range roman-awareness-radius + 15 ;
  let my-legion legion-id
  let my-x xcor
  let my-y ycor
  
  ; count supporting legions manually
  let support-count 0
  
  ask leaders with [legion-id != my-legion and distance myself < support-range] [
    let ally-x xcor
    let ally-y ycor
    
    let blocked? any? baggage-trains with [
      ycor > min (list my-y ally-y) and
      ycor < max (list my-y ally-y) and
      abs (xcor - my-x) < baggage-size
    ]
    
    if not blocked? [
      set support-count support-count + 1
    ]
  ]
  
  let penalty-mult 0.5
  if support-count >= 1 [ set penalty-mult 0.75 ]
  if support-count >= 2 [ set penalty-mult 1.0 ]
  
  report penalty-mult
end


;;;; TARGET-FINDING ;;;;;
to check-ambush-trigger
  ; check if any roman reached within 200-300m (~30 patches) of forest
  if not nervii-attack-started? [
    let romans-at-trigger (turtle-set legionaries leaders) with [pycor >= 35]
    
    if any? romans-at-trigger [
      ; trigger nervii ambush
      set nervii-attack-started? true
      set nervii-attack-start-tick ticks
      
      ; set nerviis to charge
      ask nervii [
        set is-attacking? true
        set speed charge-speed ; running at romans started
      ]
    ]
  ]
end

; nervii strategy - wipe out front legions first
; historical sig- they were EXPECTING expected order with hgiher dispersion, aiming to take legions one row at a time
; searching for close romans - not necessarily closest to remain realistic/human
to nervii-attack-movement
  let need-new-target false
  
  if target-roman = nobody [
    set need-new-target true
  ]
  
  ; Switch target if dead, too far, or oversaturated
  if target-roman != nobody [
    if not is-turtle? target-roman or [nervii-targeting-me] of target-roman >= 6 [
      if target-roman != nobody and is-turtle? target-roman [
        ask target-roman [set nervii-targeting-me nervii-targeting-me - 1]
      ]
      set need-new-target true
    ]
  ]
  
  if need-new-target [
    ; find available Romans in range
    let available-romans (turtle-set legionaries leaders) in-radius 15
    
    if not any? available-romans [
      set available-romans (turtle-set legionaries leaders) in-radius 25
    ]
    
    if not any? available-romans [
      set available-romans (turtle-set legionaries leaders) in-radius 40
    ]
    
    if not any? available-romans [
      set available-romans (turtle-set legionaries leaders)
    ]
    
    if any? available-romans [
      ; PACK TACTICS: find Romans that other Nervii are already attacking
      let romans-under-attack available-romans with [nervii-targeting-me > 0 and nervii-targeting-me < 4]
      
      let target-pool nobody
      
      ; Highest prio: Join existing attacks (pack/swarm behavior)
      ifelse any? romans-under-attack [
        ; Filter for frontmost legion
        let legion-ids-under-attack remove-duplicates [legion-id] of romans-under-attack
        let frontmost-attacked-legion -1
        let highest-y -9999
        
        foreach legion-ids-under-attack [ lid ->
          let legion-members romans-under-attack with [legion-id = lid]
          if any? legion-members [
            let avg-y mean [pycor] of legion-members
            if avg-y > highest-y [
              set highest-y avg-y
              set frontmost-attacked-legion lid
            ]
          ]
        ]
        
        ; join pack on frontmost legion under attack
        let pack-targets romans-under-attack with [legion-id = frontmost-attacked-legion]
        
        ; prefer unready within pack
        let unready-pack pack-targets with [status != "ready"]
        ifelse any? unready-pack [
          set target-pool unready-pack
        ] [
          set target-pool pack-targets
        ]
        
      ] [
        ; PRIO 2: no packs yet: start new attack on frontmost legion
        let legion-ids remove-duplicates [legion-id] of available-romans
        let frontmost-legion-id -1
        let highest-avg-y -9999
        
        foreach legion-ids [ lid ->
          let legion-members available-romans with [legion-id = lid]
          if any? legion-members [
            let avg-y mean [pycor] of legion-members
            if avg-y > highest-avg-y [
              set highest-avg-y avg-y
              set frontmost-legion-id lid
            ]
          ]
        ]
        
        let priority-romans available-romans with [legion-id = frontmost-legion-id]
        let unready-front priority-romans with [status != "ready"]
        
        ifelse any? unready-front [
          set target-pool unready-front
        ] [
          ifelse any? priority-romans [
            set target-pool priority-romans
          ] [
            set target-pool available-romans
          ]
        ]
      ]
      
      ; Pick best target from pool
      if any? target-pool [
        let max-y-pool max [pycor] of target-pool
        
        let best-target min-one-of target-pool [
          ((max-y-pool - pycor) * 15) +           ; closest height-wise
          (pack-score-for nervii-targeting-me) +  ; pack coordination
          (distance myself * 3)                   ; distance
        ]
        
        set target-roman best-target
        ask target-roman [set nervii-targeting-me nervii-targeting-me + 1]
      ]
    ]
  ]
  
  ; move toward target/front legion
  ifelse target-roman != nobody and is-turtle? target-roman [
    face target-roman
    let terrain-speed get-terrain-speed
    
    let dist-to-target distance target-roman
    ifelse dist-to-target <= 0.5 [
      ;forward (speed * 0.3 * terrain-speed)
      move-avoiding-baggage (speed * 0.3 * terrain-speed)
    ] [
      ;forward speed * terrain-speed
      move-avoiding-baggage (speed * terrain-speed)
    ]
  ] [
    ; No local target - find frontmost legion globally
    let global-target find-frontmost-legion-target
    
    ifelse global-target != nobody [
      face global-target
      let terrain-speed get-terrain-speed
      ;forward speed * terrain-speed
      move-avoiding-baggage (speed * terrain-speed)
    ] [
      ; no Romans at all? charge south
      set heading 180
      let terrain-speed get-terrain-speed
      ;forward speed * terrain-speed
      move-avoiding-baggage (speed * terrain-speed)
    ]
  ]
end

to-report pack-score-for [num-attackers]
  ; pack tactics helper
  if num-attackers = 0 [ report 30 ]      ; alone = avoid
  if num-attackers = 1 [ report -30 ]     ; 1 attacker = best 
  if num-attackers = 2 [ report -20 ]     ; 2 attackers = good
  if num-attackers = 3 [ report -10 ]     ; 3 attackers = ok
  if num-attackers >= 4 [ report 100 ]    ; oversaturated = avoid
  report 0  ; fallback
end

to-report find-frontmost-legion-target
  ; when no Romans nearby, look at all Romans to find frontmost legion
  let all-romans (turtle-set legionaries leaders)
  
  if not any? all-romans [
    report nobody
  ]
  
  let legion-ids remove-duplicates [legion-id] of all-romans
  
  let frontmost-legion-id -1
  let highest-avg-y -9999
  
  foreach legion-ids [ lid ->
    let legion-members all-romans with [legion-id = lid]
    if any? legion-members [
      let avg-y mean [pycor] of legion-members
      if avg-y > highest-avg-y [
        set highest-avg-y avg-y
        set frontmost-legion-id lid
      ]
    ]
  ]
  
  ; return a Roman from frontmost legion, preferred close to me
  let frontmost-romans all-romans with [legion-id = frontmost-legion-id]
  
  if any? frontmost-romans [
    report min-one-of frontmost-romans [distance myself]
  ]
  
  report nobody
end

;;;; COMBAT ;;;;;
to nervii-combat
  ask nervii with [is-attacking? and target-roman != nobody] [
    if is-turtle? target-roman [
      let dist-to-target distance target-roman
      
      ; if within weapon range, attack
      if dist-to-target <= short-attack-range [
        let base-damage combat-skill
        let actual-damage 0
        
        ; ambush bonus if target not ready, lower defense if roman not ready, no shield, may not have armor fully on, etc.
        ifelse [status] of target-roman != "ready" [
          set base-damage base-damage * ambush-bonus
          set actual-damage base-damage * (1 - [opponent-defense * 0.25] of target-roman)
        ] [
          set actual-damage base-damage * (1 - [opponent-defense] of target-roman)
        ]
       
        ask target-roman [
          set health health - actual-damage
        ]
      ]
    ]
  ]
end

to roman-combat
  ; romans fight poorly if not ready
  
  ask legionaries [
    ; find target - if not "ready", can only fight back what is attacking me
    manage-roman-target

    if target-nervii != nobody and is-turtle? target-nervii [
      
      ; attack if in attack range
      let attack-range 0
      ifelse weapon-type = "short-range" [
        set attack-range short-attack-range
      ] [
        set attack-range long-attack-range
      ]
      
      let dist-to-target distance target-nervii
      
      if dist-to-target <= attack-range [
        
        let effective-combat-skill combat-skill
        
        if compactness-of-legions > 0.9 [
          set effective-combat-skill (effective-combat-skill * 0.7) ; 30% penalty for overly compact, Caesar complained that his legions didn't have room to fight/form up.
        ]
        
        if status != "ready" [
          set effective-combat-skill (effective-combat-skill * 0.1) ; 90% penalty if not ready
        ]
        
        if status = "ready" [
          ; look up legion's isolation penalty from leader
          let my-leader one-of leaders with [legion-id = [legion-id] of myself]
          if my-leader != nobody [
            set effective-combat-skill effective-combat-skill * [legion-isolation-penalty] of my-leader
          ]
        ]

        let actual-damage effective-combat-skill * (1 - [opponent-defense] of target-nervii)
        
        ask target-nervii [
          set health health - actual-damage
        ]
      ]
    ]
  ]
  
  ask leaders [
    manage-roman-target
    
    if target-nervii != nobody and is-turtle? target-nervii [
      let attack-range short-attack-range 
      let dist-to-target distance target-nervii
      
      if dist-to-target <= attack-range [
        
        let effective-combat-skill combat-skill
        
        if compactness-of-legions > 0.9 [
          set effective-combat-skill (effective-combat-skill * 0.7) ; 30% penalty for overly compact, Caesar complained that his legions didn't have room to fight/form up.
        ]
        
        if status != "ready" [
          set effective-combat-skill (effective-combat-skill * 0.1) ; 90% penalty if not ready
        ]
        
        if status = "ready" [
          ; look up legion's isolation penalty from leader
          set effective-combat-skill effective-combat-skill * legion-isolation-penalty
        ]
        
        let actual-damage effective-combat-skill * (1 - [opponent-defense] of target-nervii)
        
        ask target-nervii [
          set health health - actual-damage
        ]
      ]
    ]
  ]
end


to manage-roman-target
  let need-new-target false
  
  if target-nervii = nobody [
    set need-new-target true
  ]
  
  if target-nervii != nobody [
    if not is-turtle? target-nervii [
      set need-new-target true
      set target-nervii nobody
    ]
  ]
  
  ; highest priority - fight what is attacking me.
  ; romans can fight what is attacking them even if not ready
  if target-nervii = nobody or need-new-target [
    let my-attackers nervii with [target-roman = myself and is-attacking?]
    if any? my-attackers [
      let new-target min-one-of my-attackers [distance myself]
      
      ; decrement old target's counter
      if target-nervii != nobody and is-turtle? target-nervii [
        ask target-nervii [ set romans-targeting-me romans-targeting-me - 1 ]
      ]
      
      set target-nervii new-target
      ask target-nervii [ set romans-targeting-me romans-targeting-me + 1 ]
      set need-new-target false 
    ]
  ]
  
  ; if "ready", I can find a new target
  ; else, can only fight whats attacking me
  if status = "ready" and need-new-target [
    let nearby-nervii nervii with [is-attacking?] in-radius 15
    
    ; if none nearby, widen search radius
    if not any? nearby-nervii [
      set nearby-nervii nervii with [is-attacking?] in-radius 25
    ]
    
    ; if none nearby, widen search radius
    if not any? nearby-nervii [
      set nearby-nervii nervii with [is-attacking?] in-radius 40
    ]
    
    if not any? nearby-nervii [
      set nearby-nervii nervii with [is-attacking?]
    ]
    
    if any? nearby-nervii [
      let new-target min-one-of nearby-nervii [romans-targeting-me + (distance myself * 0.5)]
      
      if target-nervii != nobody and is-turtle? target-nervii [
        ask target-nervii [ set romans-targeting-me romans-targeting-me - 1 ]
      ]
      
      set target-nervii new-target
      ask target-nervii [ set romans-targeting-me romans-targeting-me + 1 ]
    ]
  ]
end

to remove-dead-agents
  ask legionaries with [health <= 0] [
    ask nervii with [target-roman = myself] [
      set target-roman nobody
    ]
    die
  ]
  
  ask leaders with [health <= 0] [
    ask nervii with [target-roman = myself] [
      set target-roman nobody
    ]
    die
  ]
  
  ask nervii with [health <= 0] [
    ask legionaries with [target-nervii = myself] [
      set target-nervii nobody
    ]
    ask leaders with [target-nervii = myself] [
      set target-nervii nobody
    ]
    die
  ]
end

;;; MOVEMENT HELPERS ;;;;
to move-avoiding-baggage [step]
  if step <= 0 [ stop ]
  let nx xcor + (step * sin heading)
  let ny ycor + (step * cos heading)

  ; keep world bounds
  if patch nx ny = nobody [ stop ]

  if collides-with-baggage-at? nx ny [
    set blocked-by-baggage? true
    
    ; Turn towards vertical center and try to move in that direction
    let avoidance-heading towardsxy 0 ycor
    let avoid-nx xcor + (step * sin avoidance-heading)
    let avoid-ny ycor + (step * cos avoidance-heading)
    
    ; Check if the avoidance move is valid
    if patch avoid-nx avoid-ny != nobody [
      if not collides-with-baggage-at? avoid-nx avoid-ny [
        setxy avoid-nx avoid-ny
        set blocked-by-baggage? false
      ]
    ]
    stop
  ]

  set blocked-by-baggage? false
  setxy nx ny
end

; baggage trains were huge and bulky-blocked movement
to-report collides-with-baggage-at? [nx ny]
  report any? baggage-trains with [
    distancexy nx ny < (([size] of myself) / 2 + (size / 2) + 0.2)
  ]
end

;;;; REPORTERS FOR ANALYSIS ;;;;;
to-report romans-left
  report (count legionaries + count leaders)
end

to-report nervii-left
  report count nervii
end

; time to readiness DVs
to-report mean-time-to-readiness
  ifelse length readiness-times > 0 [
    report mean readiness-times
  ] [
    report 0
  ]
end

to-report mean-unaware-to-aware-time
  ifelse length unaware-to-aware-times > 0 [
    report mean unaware-to-aware-times 
  ] [ report 0 ]
end

to-report mean-aware-to-orders-time
  ifelse length aware-to-orders-times > 0 [
    report mean aware-to-orders-times
  ] [ report 0 ]
end

to-report mean-orders-to-ready-time
  ifelse length orders-to-ready-times > 0 [
    report mean orders-to-ready-times
  ] [ report 0 ]
end

to-report percent-legionaries-ready
  ifelse total-legionaries-at-start > 0 [
    report (legionaries-reached-ready / total-legionaries-at-start) * 100
  ] [
    report 0
  ]
end

to-report romans-by-status [status-name]
  report count legionaries with [status = status-name] + count leaders with [status = status-name]
end

; to monitor for victory DV
to update-victory
  if victory-state != "In progress" [ stop ]
  let r romans-left
  let n nervii-left

  if (n = 0) and (r > 0) [
    set victory-state "Roman Win"
    set victory-tick ticks
    stop
  ]
  if (r = 0) and (n > 0) [
    set victory-state "Nervii Win"
    set victory-tick ticks
    stop
  ]
  if (r = 0) and (n = 0) [
    set victory-state "Both decimated"
    set victory-tick ticks
    stop
  ]
end

;;;; PLOTTING ;;;;; 
to plot-readiness-histogram 
  set-current-plot "Readiness Timeline" 
  clear-plot 
   
  ; 3 bars
  set-plot-x-range 0 3
   
  ; precision 0 y axis
  let max-val max (list mean-unaware-to-aware-time mean-aware-to-orders-time  
                        mean-orders-to-ready-time) 
  if max-val > 0 [ 
    set-plot-y-range 0 precision (max-val * 1.1) 0
  ] 
  
  let step 0.05  
   
  ; unaware to aware
  set-current-plot-pen "Unaware->Aware"
  set-plot-pen-mode 1  ; bar mode
  foreach (range 0 mean-unaware-to-aware-time step) [ _y ->
    plotxy 0.5 _y
  ]
   
  ; aware to orders
  set-current-plot-pen "Aware->Orders"
  set-plot-pen-mode 1  
  foreach (range 0 mean-aware-to-orders-time step) [ _y ->
    plotxy 1.25 _y
  ]
   
  ;orders to ready
  set-current-plot-pen "Orders->Ready"
  set-plot-pen-mode 1  
  foreach (range 0 mean-orders-to-ready-time step) [ _y ->
    plotxy 2 _y
  ]
end
]]></code>
  <widgets>
    <view x="357" wrappingAllowedX="false" y="20" frameRate="30.0" minPycor="-175" height="691" showTickCounter="true" patchSize="2.5" fontSize="10" wrappingAllowedY="false" width="628" tickCounterLabel="ticks" maxPycor="100" updateMode="0" maxPxcor="125" minPxcor="-125"></view>
    <monitor x="242" precision="17" y="328" height="60" fontSize="11" width="100" display="Nervii left">nervii-left</monitor>
    <monitor x="135" precision="17" y="251" height="60" fontSize="11" width="207" display="Battle victory status">victory-state</monitor>
    <button x="287" y="183" height="40" disableUntilTicks="false" forever="true" kind="Observer" width="55" display="go">go</button>
    <chooser x="85" y="112" height="60" variable="roman-order" current="0" width="257" display="roman-order">
      <choice type="string" value="Caesar's order"></choice>
      <choice type="string" value="Expected order"></choice>
    </chooser>
    <slider x="85" step="0.01" y="49" max="1" width="257" display="compactness-of-legions" height="50" min="0" direction="Horizontal" default="1.0" variable="compactness-of-legions"></slider>
    <plot x="20" autoPlotX="true" yMax="10.0" autoPlotY="true" yAxis="Units left alive" y="471" xMin="0.0" height="230" legend="false" xMax="10.0" yMin="0.0" width="323" xAxis="Time (ticks)" display="Forces over time">
      <setup></setup>
      <update></update>
      <pen interval="1.0" mode="0" display="Romans" color="-10873583" legend="true">
        <setup></setup>
        <update>plot count legionaries + count leaders</update>
      </pen>
      <pen interval="1.0" mode="0" display="Nervii" color="-11783835" legend="true">
        <setup></setup>
        <update>plot count nervii</update>
      </pen>
    </plot>
    <monitor x="994" precision="17" y="356" height="60" units="%" fontSize="11" width="162" display="% Romans reached &quot;ready&quot;">precision(percent-legionaries-ready) 2</monitor>
    <monitor x="994" precision="17" y="279" height="60" fontSize="11" width="163" display="Mean Time to Readiness">precision(mean-time-to-readiness) 2</monitor>
    <note x="1169" y="280" backgroundDark="0" fontSize="12" width="168" markdown="false" height="61" textColorDark="-1" textColorLight="-16777216" backgroundLight="0">Average ticks to "ready" status since first roman became aware of the battle</note>
    <note x="1169" y="353" backgroundDark="0" fontSize="12" width="169" markdown="false" height="62" textColorDark="-1" textColorLight="-16777216" backgroundLight="0">Percentage of romans who reached "ready" status by battle end</note>
    <button x="198" y="183" height="40" disableUntilTicks="false" forever="false" kind="Observer" width="74" display="setup">setup</button>
    <monitor x="135" precision="17" y="328" height="60" fontSize="11" width="100" display="Romans left">romans-left</monitor>
    <monitor x="133" precision="17" y="400" height="60" units="%" fontSize="11" width="209" display="Legionaries left alive">precision (count legionaries / total-legionaries-at-start * 100) 2</monitor>
    <plot x="994" autoPlotX="false" yMax="600.0" autoPlotY="true" yAxis="Mean Time (seconds)" y="20" xMin="0.0" height="244" legend="true" xMax="3.0" yMin="0.0" width="341" xAxis="Readiness Phase" display="Readiness Timeline">
      <setup></setup>
      <update></update>
      <pen interval="0.5" mode="1" display="Unaware-&gt;Aware" color="-955883" legend="true">
        <setup></setup>
        <update></update>
      </pen>
      <pen interval="0.5" mode="1" display="Aware-&gt;Orders" color="-11221820" legend="true">
        <setup></setup>
        <update></update>
      </pen>
      <pen interval="0.5" mode="1" display="Orders-&gt;Ready" color="-2674135" legend="true">
        <setup></setup>
        <update></update>
      </pen>
    </plot>
  </widgets>
  <info>## WHAT IS IT?

(a general understanding of what the model is trying to show or explain)

## HOW IT WORKS

(what rules the agents use to create the overall behavior of the model)

## HOW TO USE IT

(how to use the model, including a description of each of the items in the Interface tab)

## THINGS TO NOTICE

(suggested things for the user to notice while running the model)

## THINGS TO TRY

(suggested things for the user to try to do (move sliders, switches, etc.) with the model)

## EXTENDING THE MODEL

(suggested things to add or change in the Code tab to make the model more complicated, detailed, accurate, etc.)

## NETLOGO FEATURES

(interesting or unusual features of NetLogo that the model uses, particularly in the Code tab; or where workarounds were needed for missing features)

## RELATED MODELS

(models in the NetLogo Models Library and elsewhere which are of related interest)

## CREDITS AND REFERENCES

(a reference to the model's URL on the web if it has one, as well as any other necessary credits, citations, and links)</info>
  <turtleShapes>
    <shape name="default" rotatable="true" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="5"></point>
        <point x="40" y="250"></point>
        <point x="150" y="205"></point>
        <point x="260" y="250"></point>
      </polygon>
    </shape>
    <shape name="airplane" rotatable="true" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="0"></point>
        <point x="135" y="15"></point>
        <point x="120" y="60"></point>
        <point x="120" y="105"></point>
        <point x="15" y="165"></point>
        <point x="15" y="195"></point>
        <point x="120" y="180"></point>
        <point x="135" y="240"></point>
        <point x="105" y="270"></point>
        <point x="120" y="285"></point>
        <point x="150" y="270"></point>
        <point x="180" y="285"></point>
        <point x="210" y="270"></point>
        <point x="165" y="240"></point>
        <point x="180" y="180"></point>
        <point x="285" y="195"></point>
        <point x="285" y="165"></point>
        <point x="180" y="105"></point>
        <point x="180" y="60"></point>
        <point x="165" y="15"></point>
      </polygon>
    </shape>
    <shape name="arrow" rotatable="true" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="0"></point>
        <point x="0" y="150"></point>
        <point x="105" y="150"></point>
        <point x="105" y="293"></point>
        <point x="195" y="293"></point>
        <point x="195" y="150"></point>
        <point x="300" y="150"></point>
      </polygon>
    </shape>
    <shape name="box" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="285"></point>
        <point x="285" y="225"></point>
        <point x="285" y="75"></point>
        <point x="150" y="135"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="135"></point>
        <point x="15" y="75"></point>
        <point x="150" y="15"></point>
        <point x="285" y="75"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="15" y="75"></point>
        <point x="15" y="225"></point>
        <point x="150" y="285"></point>
        <point x="150" y="135"></point>
      </polygon>
      <line endX="150" startY="285" marked="false" color="255" endY="135" startX="150"></line>
      <line endX="15" startY="135" marked="false" color="255" endY="75" startX="150"></line>
      <line endX="285" startY="135" marked="false" color="255" endY="75" startX="150"></line>
    </shape>
    <shape name="bug" rotatable="true" editableColorIndex="0">
      <circle x="96" y="182" marked="true" color="-1920102913" diameter="108" filled="true"></circle>
      <circle x="110" y="127" marked="true" color="-1920102913" diameter="80" filled="true"></circle>
      <circle x="110" y="75" marked="true" color="-1920102913" diameter="80" filled="true"></circle>
      <line endX="80" startY="100" marked="true" color="-1920102913" endY="30" startX="150"></line>
      <line endX="220" startY="100" marked="true" color="-1920102913" endY="30" startX="150"></line>
    </shape>
    <shape name="butterfly" rotatable="true" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="165"></point>
        <point x="209" y="199"></point>
        <point x="225" y="225"></point>
        <point x="225" y="255"></point>
        <point x="195" y="270"></point>
        <point x="165" y="255"></point>
        <point x="150" y="240"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="165"></point>
        <point x="89" y="198"></point>
        <point x="75" y="225"></point>
        <point x="75" y="255"></point>
        <point x="105" y="270"></point>
        <point x="135" y="255"></point>
        <point x="150" y="240"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="139" y="148"></point>
        <point x="100" y="105"></point>
        <point x="55" y="90"></point>
        <point x="25" y="90"></point>
        <point x="10" y="105"></point>
        <point x="10" y="135"></point>
        <point x="25" y="180"></point>
        <point x="40" y="195"></point>
        <point x="85" y="194"></point>
        <point x="139" y="163"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="162" y="150"></point>
        <point x="200" y="105"></point>
        <point x="245" y="90"></point>
        <point x="275" y="90"></point>
        <point x="290" y="105"></point>
        <point x="290" y="135"></point>
        <point x="275" y="180"></point>
        <point x="260" y="195"></point>
        <point x="215" y="195"></point>
        <point x="162" y="165"></point>
      </polygon>
      <polygon color="255" filled="true" marked="false">
        <point x="150" y="255"></point>
        <point x="135" y="225"></point>
        <point x="120" y="150"></point>
        <point x="135" y="120"></point>
        <point x="150" y="105"></point>
        <point x="165" y="120"></point>
        <point x="180" y="150"></point>
        <point x="165" y="225"></point>
      </polygon>
      <circle x="135" y="90" marked="false" color="255" diameter="30" filled="true"></circle>
      <line endX="195" startY="105" marked="false" color="255" endY="60" startX="150"></line>
      <line endX="105" startY="105" marked="false" color="255" endY="60" startX="150"></line>
    </shape>
    <shape name="car" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="300" y="180"></point>
        <point x="279" y="164"></point>
        <point x="261" y="144"></point>
        <point x="240" y="135"></point>
        <point x="226" y="132"></point>
        <point x="213" y="106"></point>
        <point x="203" y="84"></point>
        <point x="185" y="63"></point>
        <point x="159" y="50"></point>
        <point x="135" y="50"></point>
        <point x="75" y="60"></point>
        <point x="0" y="150"></point>
        <point x="0" y="165"></point>
        <point x="0" y="225"></point>
        <point x="300" y="225"></point>
        <point x="300" y="180"></point>
      </polygon>
      <circle x="180" y="180" marked="false" color="255" diameter="90" filled="true"></circle>
      <circle x="30" y="180" marked="false" color="255" diameter="90" filled="true"></circle>
      <polygon color="255" filled="true" marked="false">
        <point x="162" y="80"></point>
        <point x="132" y="78"></point>
        <point x="134" y="135"></point>
        <point x="209" y="135"></point>
        <point x="194" y="105"></point>
        <point x="189" y="96"></point>
        <point x="180" y="89"></point>
      </polygon>
      <circle x="47" y="195" marked="true" color="-1920102913" diameter="58" filled="true"></circle>
      <circle x="195" y="195" marked="true" color="-1920102913" diameter="58" filled="true"></circle>
    </shape>
    <shape name="circle" rotatable="false" editableColorIndex="0">
      <circle x="0" y="0" marked="true" color="-1920102913" diameter="300" filled="true"></circle>
    </shape>
    <shape name="circle 2" rotatable="false" editableColorIndex="0">
      <circle x="0" y="0" marked="true" color="-1920102913" diameter="300" filled="true"></circle>
      <circle x="30" y="30" marked="false" color="255" diameter="240" filled="true"></circle>
    </shape>
    <shape name="cow" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="200" y="193"></point>
        <point x="197" y="249"></point>
        <point x="179" y="249"></point>
        <point x="177" y="196"></point>
        <point x="166" y="187"></point>
        <point x="140" y="189"></point>
        <point x="93" y="191"></point>
        <point x="78" y="179"></point>
        <point x="72" y="211"></point>
        <point x="49" y="209"></point>
        <point x="48" y="181"></point>
        <point x="37" y="149"></point>
        <point x="25" y="120"></point>
        <point x="25" y="89"></point>
        <point x="45" y="72"></point>
        <point x="103" y="84"></point>
        <point x="179" y="75"></point>
        <point x="198" y="76"></point>
        <point x="252" y="64"></point>
        <point x="272" y="81"></point>
        <point x="293" y="103"></point>
        <point x="285" y="121"></point>
        <point x="255" y="121"></point>
        <point x="242" y="118"></point>
        <point x="224" y="167"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="73" y="210"></point>
        <point x="86" y="251"></point>
        <point x="62" y="249"></point>
        <point x="48" y="208"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="25" y="114"></point>
        <point x="16" y="195"></point>
        <point x="9" y="204"></point>
        <point x="23" y="213"></point>
        <point x="25" y="200"></point>
        <point x="39" y="123"></point>
      </polygon>
    </shape>
    <shape name="cylinder" rotatable="false" editableColorIndex="0">
      <circle x="0" y="0" marked="true" color="-1920102913" diameter="300" filled="true"></circle>
    </shape>
    <shape name="dot" rotatable="false" editableColorIndex="0">
      <circle x="90" y="90" marked="true" color="-1920102913" diameter="120" filled="true"></circle>
    </shape>
    <shape name="face happy" rotatable="false" editableColorIndex="0">
      <circle x="8" y="8" marked="true" color="-1920102913" diameter="285" filled="true"></circle>
      <circle x="60" y="75" marked="false" color="255" diameter="60" filled="true"></circle>
      <circle x="180" y="75" marked="false" color="255" diameter="60" filled="true"></circle>
      <polygon color="255" filled="true" marked="false">
        <point x="150" y="255"></point>
        <point x="90" y="239"></point>
        <point x="62" y="213"></point>
        <point x="47" y="191"></point>
        <point x="67" y="179"></point>
        <point x="90" y="203"></point>
        <point x="109" y="218"></point>
        <point x="150" y="225"></point>
        <point x="192" y="218"></point>
        <point x="210" y="203"></point>
        <point x="227" y="181"></point>
        <point x="251" y="194"></point>
        <point x="236" y="217"></point>
        <point x="212" y="240"></point>
      </polygon>
    </shape>
    <shape name="face neutral" rotatable="false" editableColorIndex="0">
      <circle x="8" y="7" marked="true" color="-1920102913" diameter="285" filled="true"></circle>
      <circle x="60" y="75" marked="false" color="255" diameter="60" filled="true"></circle>
      <circle x="180" y="75" marked="false" color="255" diameter="60" filled="true"></circle>
      <rectangle endX="240" startY="195" marked="false" color="255" endY="225" startX="60" filled="true"></rectangle>
    </shape>
    <shape name="face sad" rotatable="false" editableColorIndex="0">
      <circle x="8" y="8" marked="true" color="-1920102913" diameter="285" filled="true"></circle>
      <circle x="60" y="75" marked="false" color="255" diameter="60" filled="true"></circle>
      <circle x="180" y="75" marked="false" color="255" diameter="60" filled="true"></circle>
      <polygon color="255" filled="true" marked="false">
        <point x="150" y="168"></point>
        <point x="90" y="184"></point>
        <point x="62" y="210"></point>
        <point x="47" y="232"></point>
        <point x="67" y="244"></point>
        <point x="90" y="220"></point>
        <point x="109" y="205"></point>
        <point x="150" y="198"></point>
        <point x="192" y="205"></point>
        <point x="210" y="220"></point>
        <point x="227" y="242"></point>
        <point x="251" y="229"></point>
        <point x="236" y="206"></point>
        <point x="212" y="183"></point>
      </polygon>
    </shape>
    <shape name="fish" rotatable="false" editableColorIndex="0">
      <polygon color="-1" filled="true" marked="false">
        <point x="44" y="131"></point>
        <point x="21" y="87"></point>
        <point x="15" y="86"></point>
        <point x="0" y="120"></point>
        <point x="15" y="150"></point>
        <point x="0" y="180"></point>
        <point x="13" y="214"></point>
        <point x="20" y="212"></point>
        <point x="45" y="166"></point>
      </polygon>
      <polygon color="-1" filled="true" marked="false">
        <point x="135" y="195"></point>
        <point x="119" y="235"></point>
        <point x="95" y="218"></point>
        <point x="76" y="210"></point>
        <point x="46" y="204"></point>
        <point x="60" y="165"></point>
      </polygon>
      <polygon color="-1" filled="true" marked="false">
        <point x="75" y="45"></point>
        <point x="83" y="77"></point>
        <point x="71" y="103"></point>
        <point x="86" y="114"></point>
        <point x="166" y="78"></point>
        <point x="135" y="60"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="30" y="136"></point>
        <point x="151" y="77"></point>
        <point x="226" y="81"></point>
        <point x="280" y="119"></point>
        <point x="292" y="146"></point>
        <point x="292" y="160"></point>
        <point x="287" y="170"></point>
        <point x="270" y="195"></point>
        <point x="195" y="210"></point>
        <point x="151" y="212"></point>
        <point x="30" y="166"></point>
      </polygon>
      <circle x="215" y="106" marked="false" color="255" diameter="30" filled="true"></circle>
    </shape>
    <shape name="flag" rotatable="false" editableColorIndex="0">
      <rectangle endX="75" startY="15" marked="true" color="-1920102913" endY="300" startX="60" filled="true"></rectangle>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="90" y="150"></point>
        <point x="270" y="90"></point>
        <point x="90" y="30"></point>
      </polygon>
      <line endX="90" startY="135" marked="true" color="-1920102913" endY="135" startX="75"></line>
      <line endX="90" startY="45" marked="true" color="-1920102913" endY="45" startX="75"></line>
    </shape>
    <shape name="flower" rotatable="false" editableColorIndex="0">
      <polygon color="1504722175" filled="true" marked="false">
        <point x="135" y="120"></point>
        <point x="165" y="165"></point>
        <point x="180" y="210"></point>
        <point x="180" y="240"></point>
        <point x="150" y="300"></point>
        <point x="165" y="300"></point>
        <point x="195" y="240"></point>
        <point x="195" y="195"></point>
        <point x="165" y="135"></point>
      </polygon>
      <circle x="85" y="132" marked="true" color="-1920102913" diameter="38" filled="true"></circle>
      <circle x="130" y="147" marked="true" color="-1920102913" diameter="38" filled="true"></circle>
      <circle x="192" y="85" marked="true" color="-1920102913" diameter="38" filled="true"></circle>
      <circle x="85" y="40" marked="true" color="-1920102913" diameter="38" filled="true"></circle>
      <circle x="177" y="40" marked="true" color="-1920102913" diameter="38" filled="true"></circle>
      <circle x="177" y="132" marked="true" color="-1920102913" diameter="38" filled="true"></circle>
      <circle x="70" y="85" marked="true" color="-1920102913" diameter="38" filled="true"></circle>
      <circle x="130" y="25" marked="true" color="-1920102913" diameter="38" filled="true"></circle>
      <circle x="96" y="51" marked="true" color="-1920102913" diameter="108" filled="true"></circle>
      <circle x="113" y="68" marked="false" color="255" diameter="74" filled="true"></circle>
      <polygon color="1504722175" filled="true" marked="false">
        <point x="189" y="233"></point>
        <point x="219" y="188"></point>
        <point x="249" y="173"></point>
        <point x="279" y="188"></point>
        <point x="234" y="218"></point>
      </polygon>
      <polygon color="1504722175" filled="true" marked="false">
        <point x="180" y="255"></point>
        <point x="150" y="210"></point>
        <point x="105" y="210"></point>
        <point x="75" y="240"></point>
        <point x="135" y="240"></point>
      </polygon>
    </shape>
    <shape name="house" rotatable="false" editableColorIndex="0">
      <rectangle endX="255" startY="120" marked="true" color="-1920102913" endY="285" startX="45" filled="true"></rectangle>
      <rectangle endX="180" startY="210" marked="false" color="255" endY="285" startX="120" filled="true"></rectangle>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="15" y="120"></point>
        <point x="150" y="15"></point>
        <point x="285" y="120"></point>
      </polygon>
      <line endX="270" startY="120" marked="false" color="255" endY="120" startX="30"></line>
    </shape>
    <shape name="leaf" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="210"></point>
        <point x="135" y="195"></point>
        <point x="120" y="210"></point>
        <point x="60" y="210"></point>
        <point x="30" y="195"></point>
        <point x="60" y="180"></point>
        <point x="60" y="165"></point>
        <point x="15" y="135"></point>
        <point x="30" y="120"></point>
        <point x="15" y="105"></point>
        <point x="40" y="104"></point>
        <point x="45" y="90"></point>
        <point x="60" y="90"></point>
        <point x="90" y="105"></point>
        <point x="105" y="120"></point>
        <point x="120" y="120"></point>
        <point x="105" y="60"></point>
        <point x="120" y="60"></point>
        <point x="135" y="30"></point>
        <point x="150" y="15"></point>
        <point x="165" y="30"></point>
        <point x="180" y="60"></point>
        <point x="195" y="60"></point>
        <point x="180" y="120"></point>
        <point x="195" y="120"></point>
        <point x="210" y="105"></point>
        <point x="240" y="90"></point>
        <point x="255" y="90"></point>
        <point x="263" y="104"></point>
        <point x="285" y="105"></point>
        <point x="270" y="120"></point>
        <point x="285" y="135"></point>
        <point x="240" y="165"></point>
        <point x="240" y="180"></point>
        <point x="270" y="195"></point>
        <point x="240" y="210"></point>
        <point x="180" y="210"></point>
        <point x="165" y="195"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="135" y="195"></point>
        <point x="135" y="240"></point>
        <point x="120" y="255"></point>
        <point x="105" y="255"></point>
        <point x="105" y="285"></point>
        <point x="135" y="285"></point>
        <point x="165" y="240"></point>
        <point x="165" y="195"></point>
      </polygon>
    </shape>
    <shape name="line" rotatable="true" editableColorIndex="0">
      <line endX="150" startY="0" marked="true" color="-1920102913" endY="300" startX="150"></line>
    </shape>
    <shape name="line half" rotatable="true" editableColorIndex="0">
      <line endX="150" startY="0" marked="true" color="-1920102913" endY="150" startX="150"></line>
    </shape>
    <shape name="pentagon" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="15"></point>
        <point x="15" y="120"></point>
        <point x="60" y="285"></point>
        <point x="240" y="285"></point>
        <point x="285" y="120"></point>
      </polygon>
    </shape>
    <shape name="person" rotatable="false" editableColorIndex="0">
      <circle x="110" y="5" marked="true" color="-1920102913" diameter="80" filled="true"></circle>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="105" y="90"></point>
        <point x="120" y="195"></point>
        <point x="90" y="285"></point>
        <point x="105" y="300"></point>
        <point x="135" y="300"></point>
        <point x="150" y="225"></point>
        <point x="165" y="300"></point>
        <point x="195" y="300"></point>
        <point x="210" y="285"></point>
        <point x="180" y="195"></point>
        <point x="195" y="90"></point>
      </polygon>
      <rectangle endX="172" startY="79" marked="true" color="-1920102913" endY="94" startX="127" filled="true"></rectangle>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="195" y="90"></point>
        <point x="240" y="150"></point>
        <point x="225" y="180"></point>
        <point x="165" y="105"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="105" y="90"></point>
        <point x="60" y="150"></point>
        <point x="75" y="180"></point>
        <point x="135" y="105"></point>
      </polygon>
    </shape>
    <shape name="plant" rotatable="false" editableColorIndex="0">
      <rectangle endX="165" startY="90" marked="true" color="-1920102913" endY="300" startX="135" filled="true"></rectangle>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="135" y="255"></point>
        <point x="90" y="210"></point>
        <point x="45" y="195"></point>
        <point x="75" y="255"></point>
        <point x="135" y="285"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="165" y="255"></point>
        <point x="210" y="210"></point>
        <point x="255" y="195"></point>
        <point x="225" y="255"></point>
        <point x="165" y="285"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="135" y="180"></point>
        <point x="90" y="135"></point>
        <point x="45" y="120"></point>
        <point x="75" y="180"></point>
        <point x="135" y="210"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="165" y="180"></point>
        <point x="165" y="210"></point>
        <point x="225" y="180"></point>
        <point x="255" y="120"></point>
        <point x="210" y="135"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="135" y="105"></point>
        <point x="90" y="60"></point>
        <point x="45" y="45"></point>
        <point x="75" y="105"></point>
        <point x="135" y="135"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="165" y="105"></point>
        <point x="165" y="135"></point>
        <point x="225" y="105"></point>
        <point x="255" y="45"></point>
        <point x="210" y="60"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="135" y="90"></point>
        <point x="120" y="45"></point>
        <point x="150" y="15"></point>
        <point x="180" y="45"></point>
        <point x="165" y="90"></point>
      </polygon>
    </shape>
    <shape name="sheep" rotatable="false" editableColorIndex="15">
      <circle x="203" y="65" marked="true" color="-1" diameter="88" filled="true"></circle>
      <circle x="70" y="65" marked="true" color="-1" diameter="162" filled="true"></circle>
      <circle x="150" y="105" marked="true" color="-1" diameter="120" filled="true"></circle>
      <polygon color="-1920102913" filled="true" marked="false">
        <point x="218" y="120"></point>
        <point x="240" y="165"></point>
        <point x="255" y="165"></point>
        <point x="278" y="120"></point>
      </polygon>
      <circle x="214" y="72" marked="false" color="-1920102913" diameter="67" filled="true"></circle>
      <rectangle endX="179" startY="223" marked="true" color="-1" endY="298" startX="164" filled="true"></rectangle>
      <polygon color="-1" filled="true" marked="true">
        <point x="45" y="285"></point>
        <point x="30" y="285"></point>
        <point x="30" y="240"></point>
        <point x="15" y="195"></point>
        <point x="45" y="210"></point>
      </polygon>
      <circle x="3" y="83" marked="true" color="-1" diameter="150" filled="true"></circle>
      <rectangle endX="80" startY="221" marked="true" color="-1" endY="296" startX="65" filled="true"></rectangle>
      <polygon color="-1" filled="true" marked="true">
        <point x="195" y="285"></point>
        <point x="210" y="285"></point>
        <point x="210" y="240"></point>
        <point x="240" y="210"></point>
        <point x="195" y="210"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="false">
        <point x="276" y="85"></point>
        <point x="285" y="105"></point>
        <point x="302" y="99"></point>
        <point x="294" y="83"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="false">
        <point x="219" y="85"></point>
        <point x="210" y="105"></point>
        <point x="193" y="99"></point>
        <point x="201" y="83"></point>
      </polygon>
    </shape>
    <shape name="square" rotatable="false" editableColorIndex="0">
      <rectangle endX="270" startY="30" marked="true" color="-1920102913" endY="270" startX="30" filled="true"></rectangle>
    </shape>
    <shape name="square 2" rotatable="false" editableColorIndex="0">
      <rectangle endX="270" startY="30" marked="true" color="-1920102913" endY="270" startX="30" filled="true"></rectangle>
      <rectangle endX="240" startY="60" marked="false" color="255" endY="240" startX="60" filled="true"></rectangle>
    </shape>
    <shape name="star" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="151" y="1"></point>
        <point x="185" y="108"></point>
        <point x="298" y="108"></point>
        <point x="207" y="175"></point>
        <point x="242" y="282"></point>
        <point x="151" y="216"></point>
        <point x="59" y="282"></point>
        <point x="94" y="175"></point>
        <point x="3" y="108"></point>
        <point x="116" y="108"></point>
      </polygon>
    </shape>
    <shape name="target" rotatable="false" editableColorIndex="0">
      <circle x="0" y="0" marked="true" color="-1920102913" diameter="300" filled="true"></circle>
      <circle x="30" y="30" marked="false" color="255" diameter="240" filled="true"></circle>
      <circle x="60" y="60" marked="true" color="-1920102913" diameter="180" filled="true"></circle>
      <circle x="90" y="90" marked="false" color="255" diameter="120" filled="true"></circle>
      <circle x="120" y="120" marked="true" color="-1920102913" diameter="60" filled="true"></circle>
    </shape>
    <shape name="tree" rotatable="false" editableColorIndex="0">
      <circle x="118" y="3" marked="true" color="-1920102913" diameter="94" filled="true"></circle>
      <rectangle endX="180" startY="195" marked="false" color="-1653716737" endY="300" startX="120" filled="true"></rectangle>
      <circle x="65" y="21" marked="true" color="-1920102913" diameter="108" filled="true"></circle>
      <circle x="116" y="41" marked="true" color="-1920102913" diameter="127" filled="true"></circle>
      <circle x="45" y="90" marked="true" color="-1920102913" diameter="120" filled="true"></circle>
      <circle x="104" y="74" marked="true" color="-1920102913" diameter="152" filled="true"></circle>
    </shape>
    <shape name="triangle" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="30"></point>
        <point x="15" y="255"></point>
        <point x="285" y="255"></point>
      </polygon>
    </shape>
    <shape name="triangle 2" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="150" y="30"></point>
        <point x="15" y="255"></point>
        <point x="285" y="255"></point>
      </polygon>
      <polygon color="255" filled="true" marked="false">
        <point x="151" y="99"></point>
        <point x="225" y="223"></point>
        <point x="75" y="224"></point>
      </polygon>
    </shape>
    <shape name="truck" rotatable="false" editableColorIndex="0">
      <rectangle endX="195" startY="45" marked="true" color="-1920102913" endY="187" startX="4" filled="true"></rectangle>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="296" y="193"></point>
        <point x="296" y="150"></point>
        <point x="259" y="134"></point>
        <point x="244" y="104"></point>
        <point x="208" y="104"></point>
        <point x="207" y="194"></point>
      </polygon>
      <rectangle endX="195" startY="60" marked="false" color="-1" endY="105" startX="195" filled="true"></rectangle>
      <polygon color="255" filled="true" marked="false">
        <point x="238" y="112"></point>
        <point x="252" y="141"></point>
        <point x="219" y="141"></point>
        <point x="218" y="112"></point>
      </polygon>
      <circle x="234" y="174" marked="false" color="255" diameter="42" filled="true"></circle>
      <rectangle endX="214" startY="185" marked="true" color="-1920102913" endY="194" startX="181" filled="true"></rectangle>
      <circle x="144" y="174" marked="false" color="255" diameter="42" filled="true"></circle>
      <circle x="24" y="174" marked="false" color="255" diameter="42" filled="true"></circle>
      <circle x="24" y="174" marked="true" color="-1920102913" diameter="42" filled="false"></circle>
      <circle x="144" y="174" marked="true" color="-1920102913" diameter="42" filled="false"></circle>
      <circle x="234" y="174" marked="true" color="-1920102913" diameter="42" filled="false"></circle>
    </shape>
    <shape name="turtle" rotatable="true" editableColorIndex="0">
      <polygon color="1504722175" filled="true" marked="false">
        <point x="215" y="204"></point>
        <point x="240" y="233"></point>
        <point x="246" y="254"></point>
        <point x="228" y="266"></point>
        <point x="215" y="252"></point>
        <point x="193" y="210"></point>
      </polygon>
      <polygon color="1504722175" filled="true" marked="false">
        <point x="195" y="90"></point>
        <point x="225" y="75"></point>
        <point x="245" y="75"></point>
        <point x="260" y="89"></point>
        <point x="269" y="108"></point>
        <point x="261" y="124"></point>
        <point x="240" y="105"></point>
        <point x="225" y="105"></point>
        <point x="210" y="105"></point>
      </polygon>
      <polygon color="1504722175" filled="true" marked="false">
        <point x="105" y="90"></point>
        <point x="75" y="75"></point>
        <point x="55" y="75"></point>
        <point x="40" y="89"></point>
        <point x="31" y="108"></point>
        <point x="39" y="124"></point>
        <point x="60" y="105"></point>
        <point x="75" y="105"></point>
        <point x="90" y="105"></point>
      </polygon>
      <polygon color="1504722175" filled="true" marked="false">
        <point x="132" y="85"></point>
        <point x="134" y="64"></point>
        <point x="107" y="51"></point>
        <point x="108" y="17"></point>
        <point x="150" y="2"></point>
        <point x="192" y="18"></point>
        <point x="192" y="52"></point>
        <point x="169" y="65"></point>
        <point x="172" y="87"></point>
      </polygon>
      <polygon color="1504722175" filled="true" marked="false">
        <point x="85" y="204"></point>
        <point x="60" y="233"></point>
        <point x="54" y="254"></point>
        <point x="72" y="266"></point>
        <point x="85" y="252"></point>
        <point x="107" y="210"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="119" y="75"></point>
        <point x="179" y="75"></point>
        <point x="209" y="101"></point>
        <point x="224" y="135"></point>
        <point x="220" y="225"></point>
        <point x="175" y="261"></point>
        <point x="128" y="261"></point>
        <point x="81" y="224"></point>
        <point x="74" y="135"></point>
        <point x="88" y="99"></point>
      </polygon>
    </shape>
    <shape name="wheel" rotatable="false" editableColorIndex="0">
      <circle x="3" y="3" marked="true" color="-1920102913" diameter="294" filled="true"></circle>
      <circle x="30" y="30" marked="false" color="255" diameter="240" filled="true"></circle>
      <line endX="150" startY="285" marked="true" color="-1920102913" endY="15" startX="150"></line>
      <line endX="285" startY="150" marked="true" color="-1920102913" endY="150" startX="15"></line>
      <circle x="120" y="120" marked="true" color="-1920102913" diameter="60" filled="true"></circle>
      <line endX="79" startY="40" marked="true" color="-1920102913" endY="269" startX="216"></line>
      <line endX="269" startY="84" marked="true" color="-1920102913" endY="221" startX="40"></line>
      <line endX="269" startY="216" marked="true" color="-1920102913" endY="79" startX="40"></line>
      <line endX="221" startY="40" marked="true" color="-1920102913" endY="269" startX="84"></line>
    </shape>
    <shape name="wolf" rotatable="false" editableColorIndex="0">
      <polygon color="255" filled="true" marked="false">
        <point x="253" y="133"></point>
        <point x="245" y="131"></point>
        <point x="245" y="133"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="2" y="194"></point>
        <point x="13" y="197"></point>
        <point x="30" y="191"></point>
        <point x="38" y="193"></point>
        <point x="38" y="205"></point>
        <point x="20" y="226"></point>
        <point x="20" y="257"></point>
        <point x="27" y="265"></point>
        <point x="38" y="266"></point>
        <point x="40" y="260"></point>
        <point x="31" y="253"></point>
        <point x="31" y="230"></point>
        <point x="60" y="206"></point>
        <point x="68" y="198"></point>
        <point x="75" y="209"></point>
        <point x="66" y="228"></point>
        <point x="65" y="243"></point>
        <point x="82" y="261"></point>
        <point x="84" y="268"></point>
        <point x="100" y="267"></point>
        <point x="103" y="261"></point>
        <point x="77" y="239"></point>
        <point x="79" y="231"></point>
        <point x="100" y="207"></point>
        <point x="98" y="196"></point>
        <point x="119" y="201"></point>
        <point x="143" y="202"></point>
        <point x="160" y="195"></point>
        <point x="166" y="210"></point>
        <point x="172" y="213"></point>
        <point x="173" y="238"></point>
        <point x="167" y="251"></point>
        <point x="160" y="248"></point>
        <point x="154" y="265"></point>
        <point x="169" y="264"></point>
        <point x="178" y="247"></point>
        <point x="186" y="240"></point>
        <point x="198" y="260"></point>
        <point x="200" y="271"></point>
        <point x="217" y="271"></point>
        <point x="219" y="262"></point>
        <point x="207" y="258"></point>
        <point x="195" y="230"></point>
        <point x="192" y="198"></point>
        <point x="210" y="184"></point>
        <point x="227" y="164"></point>
        <point x="242" y="144"></point>
        <point x="259" y="145"></point>
        <point x="284" y="151"></point>
        <point x="277" y="141"></point>
        <point x="293" y="140"></point>
        <point x="299" y="134"></point>
        <point x="297" y="127"></point>
        <point x="273" y="119"></point>
        <point x="270" y="105"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="-1" y="195"></point>
        <point x="14" y="180"></point>
        <point x="36" y="166"></point>
        <point x="40" y="153"></point>
        <point x="53" y="140"></point>
        <point x="82" y="131"></point>
        <point x="134" y="133"></point>
        <point x="159" y="126"></point>
        <point x="188" y="115"></point>
        <point x="227" y="108"></point>
        <point x="236" y="102"></point>
        <point x="238" y="98"></point>
        <point x="268" y="86"></point>
        <point x="269" y="92"></point>
        <point x="281" y="87"></point>
        <point x="269" y="103"></point>
        <point x="269" y="113"></point>
      </polygon>
    </shape>
    <shape name="x" rotatable="false" editableColorIndex="0">
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="270" y="75"></point>
        <point x="225" y="30"></point>
        <point x="30" y="225"></point>
        <point x="75" y="270"></point>
      </polygon>
      <polygon color="-1920102913" filled="true" marked="true">
        <point x="30" y="75"></point>
        <point x="75" y="30"></point>
        <point x="270" y="225"></point>
        <point x="225" y="270"></point>
      </polygon>
    </shape>
  </turtleShapes>
  <linkShapes>
    <shape name="default" curviness="0.0">
      <lines>
        <line x="-0.2" visible="false">
          <dash value="0.0"></dash>
          <dash value="1.0"></dash>
        </line>
        <line x="0.0" visible="true">
          <dash value="1.0"></dash>
          <dash value="0.0"></dash>
        </line>
        <line x="0.2" visible="false">
          <dash value="0.0"></dash>
          <dash value="1.0"></dash>
        </line>
      </lines>
      <indicator>
        <shape name="link direction" rotatable="true" editableColorIndex="0">
          <line endX="90" startY="150" marked="true" color="-1920102913" endY="180" startX="150"></line>
          <line endX="210" startY="150" marked="true" color="-1920102913" endY="180" startX="150"></line>
        </shape>
      </indicator>
    </shape>
  </linkShapes>
  <previewCommands>setup repeat 75 [ go ]</previewCommands>
  <experiments>
    <experiment name="caesars-1.0" repetitions="100" sequentialRunOrder="true" runMetricsEveryStep="false">
      <setup>setup</setup>
      <go>go</go>
      <exitCondition>victory-state != "In progress"</exitCondition>
      <metrics>
        <metric>romans-left</metric>
        <metric>nervii-left</metric>
        <metric>victory-state</metric>
        <metric>mean-time-to-readiness</metric>
        <metric>mean-unaware-to-aware-time</metric>
        <metric>mean-aware-to-orders-time</metric>
        <metric>mean-orders-to-ready-time</metric>
        <metric>percent-legionaries-ready</metric>
      </metrics>
      <constants>
        <enumeratedValueSet variable="roman-order">
          <value value="&quot;Caesar's order&quot;"></value>
        </enumeratedValueSet>
        <enumeratedValueSet variable="compactness-of-legions">
          <value value="1"></value>
        </enumeratedValueSet>
      </constants>
    </experiment>
    <experiment name="expected-0.1" repetitions="100" sequentialRunOrder="true" runMetricsEveryStep="false">
      <setup>setup</setup>
      <go>go</go>
      <exitCondition>victory-state != "In progress"</exitCondition>
      <metrics>
        <metric>romans-left</metric>
        <metric>nervii-left</metric>
        <metric>victory-state</metric>
        <metric>mean-time-to-readiness</metric>
        <metric>mean-unaware-to-aware-time</metric>
        <metric>mean-aware-to-orders-time</metric>
        <metric>mean-orders-to-ready-time</metric>
        <metric>percent-legionaries-ready</metric>
      </metrics>
      <constants>
        <enumeratedValueSet variable="roman-order">
          <value value="&quot;Expected order&quot;"></value>
        </enumeratedValueSet>
        <enumeratedValueSet variable="compactness-of-legions">
          <value value="0.1"></value>
        </enumeratedValueSet>
      </constants>
    </experiment>
    <experiment name="caesars-0.75" repetitions="100" sequentialRunOrder="true" runMetricsEveryStep="false">
      <setup>setup</setup>
      <go>go</go>
      <exitCondition>victory-state != "In progress"</exitCondition>
      <metrics>
        <metric>romans-left</metric>
        <metric>nervii-left</metric>
        <metric>victory-state</metric>
        <metric>mean-time-to-readiness</metric>
        <metric>mean-unaware-to-aware-time</metric>
        <metric>mean-aware-to-orders-time</metric>
        <metric>mean-orders-to-ready-time</metric>
        <metric>percent-legionaries-ready</metric>
      </metrics>
      <constants>
        <enumeratedValueSet variable="roman-order">
          <value value="&quot;Caesar's order&quot;"></value>
        </enumeratedValueSet>
        <enumeratedValueSet variable="compactness-of-legions">
          <value value="0.75"></value>
        </enumeratedValueSet>
      </constants>
    </experiment>
  </experiments>
</model>