MalwarePropagationModel.nlogo

turtles-own
[
  node-clustering-coefficient   ;; and how close its neighbours are to being a complete graph
  distance-from-other-turtles   ;; list of distances of this node from other turtles
  ;; state of the computer during the virus propagation
  susceptible?
  infectious?
  attacked?
  ;; indicate whether the node was attacked by the one virus or the other
  antivirus1?
  antivirus2?
  ;; time counter during the attack state of a node
  attacked-at-tick
  ;; count the attacks of both viruses, together and separately
  attack-count
  attack1-count
  attack2-count
]

links-own
[
  rewired?                    ;; keeps track of whether the link has been rewired or not
]

globals
[
  clustering-coefficient               ;; clustering coefficient of the network (all turtles)
  average-path-length                  ;; average path length of the network
  clustering-coefficient-of-lattice    ;; clustering coefficient of the initial lattice
  average-path-length-of-lattice       ;; average path length of the initial lattice
  infinity                             ;; a very large number for distance between two turtles which
                                         ;; don't have a connected or unconnected path between them
  highlight-string                     ;; for node inspector
  connected-network?
]

;;;;;;;;;;;;;;;;;;;;;;;
;;;  Network Setup  ;;;
;;;;;;;;;;;;;;;;;;;;;;;

to startup
  set highlight-string ""
end

;; It sets up a network according to the chosen network type;
;; calls startup, do-calculations and infect-initial and resets the ticks.
to setup
  clear-all
  set infinity 99999  ;; just an arbitrary choice for a large number
  set-default-shape turtles "circle"
  startup

  if network-type = "small-world"[
    make-turtles

    ;; arrange them in a circle in order by who number
    layout-circle (sort turtles) max-pxcor - 0.5
    ;; set up a variable to determine if we still have a connected network
    ;; (in most cases we will since it starts out fully connected)
    let success? false
    while [not success?] [
      ;; we need to find initial values for lattice
      wire-them
      ;;calculate average path length and clustering coefficient for the lattice
      set success? do-calculations
    ]

    ;; setting the values for the initial lattice
    set clustering-coefficient-of-lattice clustering-coefficient
    set average-path-length-of-lattice average-path-length


    rewire-all

  ]

  if network-type = "scale-free"[
    make-node nobody        ;; first node, unattached
    make-node turtle 0      ;; second node, attached to first node
    let i 0
    while [ i < num-nodes - 2][
      set i  i + 1
      make-node find-partner         ;; find partner & use it as attachment point for new node
      layout
    ]
    let success? do-calculations
  ]

  if network-type = "computernetwork"[
    make-turtles
    setup-spatially-clustered-network
    let success? do-calculations
  ]

  infect-initial

  reset-ticks

end

to make-turtles
  create-turtles num-nodes [
    set color green
    set susceptible? true
    set infectious? false
    set attacked? false
    set antivirus1? false
    set antivirus2? false
    set attack-count 0
    set attack1-count 0
    set attack2-count 0
    set shape "cylinder"
  ]
end

;; scale-free network function creates one node with a connection to an old-node and moves towards it
to make-node [old-node]
  create-turtles 1
  [
    set color green
    set susceptible? true
    set infectious? false
    set attacked? false
    set antivirus1? false
    set antivirus2? false
    set attack-count 0
    set attack1-count 0
    set attack2-count 0
    set shape "cylinder"
    if old-node != nobody
      [ create-link-with old-node
        ;; position the new node near its partner
        move-to old-node
        fd 8
      ]
  ]
end

to-report find-partner
  report [one-of both-ends] of one-of links
end

;; layout the scale-free network during the creation animation
to layout
  ;; the number 3 here is arbitrary; more repetitions slows down the
  ;; model, but too few gives poor layouts
  repeat 3 [
    ;; the more turtles we have to fit into the same amount of space,
    ;; the smaller the inputs to layout-spring we'll need to use
    let factor sqrt count turtles
    ;; numbers here are arbitrarily chosen for pleasing appearance
    layout-spring turtles links (1 / factor) (7 / factor) (1 / factor)
    display  ;; for smooth animation
  ]
  ;; don't bump the edges of the world
  let x-offset max [xcor] of turtles + min [xcor] of turtles
  let y-offset max [ycor] of turtles + min [ycor] of turtles
  ;; big jumps look funny, so only adjust a little each time
  set x-offset limit-magnitude x-offset 0.1
  set y-offset limit-magnitude y-offset 0.1
  ask turtles [ setxy (xcor - x-offset / 2) (ycor - y-offset / 2) ]
end
to-report limit-magnitude [number limit]
  if number > limit [ report limit ]
  if number < (- limit) [ report (- limit) ]
  report number
end

;; sets up a spatially clustered computer network
to setup-spatially-clustered-network
  ask turtles[
    ; for visual reasons, we don't put any nodes *too* close to the edges
    setxy (random-xcor * 0.95) (random-ycor * 0.95)
  ]
  let num-links (average-node-degree * num-nodes) / 2
  while [count links < num-links ]
  [
    ask one-of turtles
    [
      let choice (min-one-of (other turtles with [not link-neighbor? myself])
                   [distance myself])
      if choice != nobody [ create-link-with choice ]
    ]
  ]
  ; make the network look a little prettier
  repeat 10
  [
    layout-spring turtles links 0.3 (world-width / (sqrt num-nodes)) 1
  ]
end


to rewire-all

  ;; make sure num-turtles is setup correctly; if not run setup first
  if count turtles != num-nodes [
    setup
  ]

  ;; set up a variable to see if the network is connected
  let success? false

  ;; if we end up with a disconnected network, we keep trying, because the APL distance
  ;; isn't meaningful for a disconnected network.
  while [not success?] [
    ;; kill the old lattice, reset neighbors, and create new lattice
    ask links [ die ]
    wire-them

    ask links [

      ;; whether to rewire it or not?
      if (random-float 1) < rewiring-probability
      [
        ;; "a" remains the same
        let node1 end1
        ;; if "a" is not connected to everybody
        if [ count link-neighbors ] of end1 < (count turtles - 1)
        [
          ;; find a node distinct from node1 and not already a neighbor of node1
          let node2 one-of turtles with [ (self != node1) and (not link-neighbor? node1) ]
          ;; wire the new edge
          ask node1 [ create-link-with node2 [ set rewired? true ] ]

          set rewired? true
        ]
      ]
      ;; remove the old edge
      if (rewired?)
      [
        die
      ]
    ]

    ;; check to see if the new network is connected and calculate path length and clustering
    ;; coefficient at the same time
    set success? do-calculations
  ]
end

;; infects the specified number of nodes and can be influenced by the outlier-hub coefficient
to infect-initial
  let max-connect [count link-neighbors] of max-one-of turtles [count link-neighbors]
  let max-turtle max-one-of turtles [(sum remove infinity distance-from-other-turtles) / (length remove infinity distance-from-other-turtles)]
  let max-avg [(sum remove infinity distance-from-other-turtles) / (length remove infinity distance-from-other-turtles)] of max-turtle
  let min-turtle min-one-of turtles with [count link-neighbors > 0] [(sum remove infinity distance-from-other-turtles) / (length remove infinity distance-from-other-turtles)]
  let min-avg [(sum remove infinity distance-from-other-turtles) / (length remove infinity distance-from-other-turtles)] of min-turtle
  while [count turtles with [infectious? = true] < infected-at-start] [
    ask turtle random num-nodes [
      let pairs (length remove infinity distance-from-other-turtles)
      let local-val (sum remove infinity distance-from-other-turtles) / pairs
      let prob 1
      let base 1
      if outlier-hub < 0 and (count link-neighbors > 0) [
        set prob (local-val / max-avg) * (1 / count link-neighbors)
        set base -1 * outlier-hub
      ]
      if outlier-hub > 0 and local-val > 0 and local-val <= max-avg [
        set prob (min-avg / local-val ) * (count link-neighbors / max-connect)
        set base outlier-hub
      ]
      if susceptible? and (random-float base <= prob) [
        set color orange
        set antivirus2? true
        if antivirus-propagation = true [
          if random-float 100 > proportion-red-purple [
            set color pink
            set antivirus1? true
            set antivirus2? false
          ]
        ]
        set susceptible? false
        set infectious? true
        set attacked? false
        set shape "circle"
      ]
    ]
  ]
end


;;;;;;;;;;;;;;;;;;;;;;
;;; Main Procedure ;;;
;;;;;;;;;;;;;;;;;;;;;;

to go
  ;color all turtles
  ask turtles with [susceptible? and  ((not antivirus1?) or (not patch-exploit))] [
    let i count link-neighbors with [infectious? and  (not antivirus1?)]
    if random-float 1 < i * h [
      set color orange
      set shape "circle"
    ]
  ]
  ask turtles with [infectious? and (not antivirus1?)] [
    if auto-cut = true [
      if random-float 1 < detection-probability [
        cut who
      ]
    ]
    if random-float 1 < a [
      set color red
      set attacked-at-tick ticks
    ]
    if random-float 1 < b [set color green]
  ]
  if antivirus-propagation = true [
    ask turtles with [susceptible? and ((not antivirus2?) or (not patch-exploit))] [
      let i count link-neighbors with [infectious? and (not antivirus2?)]
      if random-float 1 < i * h2 [
        set color pink
        set shape "circle"
      ]
    ]
    ask turtles with [infectious? and (not antivirus2?)] [
      if auto-cut = true [
        if random-float 1 < detection-probability [
          cut who
        ]
      ]
      if random-float 1 < a2 [
        set color violet
        set attacked-at-tick ticks
      ]
      if random-float 1 < b2 [set color green]
    ]
  ]

  ask turtles with [attacked?] [
    if attacked-at-tick + T + 1 = ticks [
      if color = red [
      set attack1-count attack1-count + 1
      ]
      if color = violet [
      set attack2-count attack2-count + 1
      ]
      set attack-count attack-count + 1
      set color green
      set attack-count attack-count + 1
      if auto-rewire = true [
        rewire who auto-rewire-probability
      ]
    ]
  ]
  ;change the status according to new color
  ask turtles with [color = green] [
    set susceptible? true
    set infectious? false
    set attacked? false
  ]
  ask turtles with [color = orange] [
    set susceptible? false
    set infectious? true
    set attacked? false
    set antivirus1? false
    set antivirus2? true
  ]
  ask turtles with [color = red] [
    set susceptible? false
    set infectious? false
    set attacked? true
  ]
  ask turtles with [color = pink] [
    set susceptible? false
    set infectious? true
    set attacked? false
    set antivirus1? true
    set antivirus2? false
  ]
  ask turtles with [color = violet] [
    set susceptible? false
    set infectious? false
    set attacked? true
  ]
  set connected-network? do-calculations
  ask turtles with [count link-neighbors = 0] [
    set shape "x"
  ]
  ask turtles with [count link-neighbors > 0] [
    set shape "circle"
  ]
  if not any? turtles with [(color = red) or (color = orange) or (color = violet) or (color = pink) ] [ stop ]
  tick
end

;;;;;;;;;;;;;;;;;;;;
;;; Calculations ;;;
;;;;;;;;;;;;;;;;;;;;

;; do-calculations reports true if the network is connected,
;;   and reports false if the network is disconnected.
to-report do-calculations

  ;; set up a variable so we can report if the network is disconnected
  let connected? true

  ;; find the path lengths in the network
  find-path-lengths

  let num-connected-pairs sum [length remove infinity (remove 0 distance-from-other-turtles)] of turtles

  ;; In a connected network on N nodes, we should have N(N-1) measurements of distances between pairs,
  ;; and none of those distances should be infinity.
  ;; If there were any "infinity" length paths between nodes, then the network is disconnected.
  ;; In that case, calculating the average-path-length doesn't really make sense.
  ifelse ( num-connected-pairs != (count turtles * (count turtles - 1) ))
  [
      set average-path-length infinity
      ;; report that the network is not connected
      set connected? false
  ]
  [
    set average-path-length (sum [sum distance-from-other-turtles] of turtles) / (num-connected-pairs)
  ]
  ;; find the clustering coefficient and add to the aggregate for all iterations
  find-clustering-coefficient

  ;; report whether the network is connected or not
  report connected?
end

to-report in-neighbourhood? [ hood ]
  report ( member? end1 hood and member? end2 hood )
end


to find-clustering-coefficient
  ifelse all? turtles [count link-neighbors <= 1]
  [
    ;; it is undefined
    ;; what should this be?
    set clustering-coefficient 0
  ]
  [
    let total 0
    ask turtles with [ count link-neighbors <= 1]
      [ set node-clustering-coefficient "undefined" ]
    ask turtles with [ count link-neighbors > 1]
    [
      let hood link-neighbors
      set node-clustering-coefficient (2 * count links with [ in-neighbourhood? hood ] /
                                         ((count hood) * (count hood - 1)) )
      ;; find the sum for the value at turtles
      set total total + node-clustering-coefficient
    ]
    ;; take the average
    set clustering-coefficient total / count turtles with [count link-neighbors > 1]
  ]
end


;; Path length computation
;; Implements the Floyd Warshall algorithm for All Pairs Shortest Paths
;; It is a dynamic programming algorithm which builds bigger solutions
;; from the solutions of smaller subproblems using memoization that
;; is storing the results.
;; It keeps finding incrementally if there is shorter path through
;; the kth node.
;; Since it iterates over all turtles through k,
;; so at the end we get the shortest possible path for each i and j.

to find-path-lengths
  ;; reset the distance list
  ask turtles
  [
    set distance-from-other-turtles []
  ]

  let i 0
  let j 0
  let k 0
  let node1 one-of turtles
  let node2 one-of turtles
  let node-count count turtles
  ;; initialize the distance lists
  while [i < node-count]
  [
    set j 0
    while [j < node-count]
    [
      set node1 turtle i
      set node2 turtle j
      ;; zero from a node to itself
      ifelse i = j
      [
        ask node1 [
          set distance-from-other-turtles lput 0 distance-from-other-turtles
        ]
      ]
      [
        ;; 1 from a node to it's neighbor
        ifelse [ link-neighbor? node1 ] of node2
        [
          ask node1 [
            set distance-from-other-turtles lput 1 distance-from-other-turtles
          ]
        ]
        ;; infinite to everyone else
        [
          ask node1 [
            set distance-from-other-turtles lput infinity distance-from-other-turtles
          ]
        ]
      ]
      set j j + 1
    ]
    set i i + 1
  ]
  set i 0
  set j 0
  let dummy 0
  while [k < node-count]
  [
    set i 0
    while [i < node-count]
    [
      set j 0
      while [j < node-count]
      [
        ;; alternate path length through kth node
        set dummy ( (item k [distance-from-other-turtles] of turtle i) +
                    (item j [distance-from-other-turtles] of turtle k))
        ;; is the alternate path shorter?
        if dummy < (item j [distance-from-other-turtles] of turtle i)
        [
          ask turtle i [
            set distance-from-other-turtles replace-item j distance-from-other-turtles dummy
          ]
        ]
        set j j + 1
      ]
      set i i + 1
    ]
    set k k + 1
  ]

end

;;;;;;;;;;;;;;;;;;;;;;;
;;; Edge Operations ;;;
;;;;;;;;;;;;;;;;;;;;;;;

;; creates a new lattice
to wire-them
  ;; iterate over the turtles
  let n 0
  while [n < count turtles]
  [
    ;; make edges with the very next neighbors
    make-edge turtle n
              turtle ((n + 1) mod count turtles)
    make-edge turtle n
              turtle ((n + 2) mod count turtles)
    set n n + 1
  ]
end

;; connects the two turtles
to make-edge [node1 node2]
  ask node1 [ create-link-with node2  [
    set rewired? false
  ] ]
end

;; rewire node n with probability x
to rewire [n x]
  let node1 turtle n
  if random-float 1 < x [
    if [ count link-neighbors ] of node1 < (count turtles / 2) [
      ;; find a node distinct from node1 and not already a neighbor of node1
      let potential-turtles turtles with [ (self != node1) and (not link-neighbor? node1)]
      let preferred-turtles turtles with [count link-neighbors = 0]
      let i 0
      let j (count link-neighbors * rewire-percentage / 100)
      while [ i < j ][
        ;; remove the old edge
        let potential-edges links with [ (end1 = node1) or (end2 = node1) ]
        if any? potential-edges [
          ask one-of potential-edges [ die ]
        ]
        set i i + 1
      ]
      let selected-turtles min-n-of i potential-turtles [attack-count]
      if patch-exploit = true and antivirus-propagation = true[
        ask node1[
          if color = red [
            set selected-turtles min-n-of i potential-turtles [attack1-count]
          ]
          if color = violet [
            set selected-turtles min-n-of i potential-turtles [attack2-count]
          ]
        ]
      ]
      if (prefer-disconnected)[
        ifelse (count preferred-turtles) >= i [
          set selected-turtles min-n-of i preferred-turtles [attack-count]
          if patch-exploit = true and antivirus-propagation = true[
            ask node1[
              if color = red [
                set selected-turtles min-n-of i preferred-turtles [attack1-count]
              ]
              if color = violet [
                set selected-turtles min-n-of i preferred-turtles [attack2-count]
              ]
            ]
          ]
        ][
          let diff i - (count preferred-turtles)
          set selected-turtles (turtle-set preferred-turtles (min-n-of diff potential-turtles [attack-count]))
          if patch-exploit = true and antivirus-propagation = true[
            ask node1[
              if color = red [
                set selected-turtles (turtle-set preferred-turtles (min-n-of diff potential-turtles [attack2-count]))
              ]
              if color = violet [
                set selected-turtles (turtle-set preferred-turtles (min-n-of diff potential-turtles [attack2-count]))
              ]
            ]
          ]
        ]
      ]
      ask selected-turtles [
        create-link-with node1 [ set color cyan  set rewired? true ]
      ]
    ]
  ]
end

;; cut all connections to / from node n
to cut [n]
  let node turtle n
  let potential-edges links with [ (end1 = node) or (end2 = node) ]
      if any? potential-edges [
        ask potential-edges [ die ]
      ]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Inspect & Infect with Mouse ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to highlight
  ;; remove any previous highlights
  ask turtles [set shape "circle"]
  ask links [ set color gray ]
  if mouse-inside? [ do-highlight ]
  display
end

to do-highlight
  ;; getting the node closest to the mouse
  let min-d min [distancexy mouse-xcor mouse-ycor] of turtles
  let node one-of turtles with [count link-neighbors > 0 and distancexy mouse-xcor mouse-ycor = min-d]
  if node != nobody
  [
    ;; highlight the chosen node
    ask node
    [
      set shape "circle 2"
      let pairs (length remove infinity distance-from-other-turtles)
      let local-val (sum remove infinity distance-from-other-turtles) / pairs
      let immune ""
      if antivirus1? = true and patch-exploit = true and antivirus-propagation = true [ set immune "immune to red | " ]
      if antivirus2? = true and patch-exploit = true and antivirus-propagation = true [ set immune "immune to purple | " ]
      if antivirus1? = false and antivirus2? = false [ set immune "uneffected | " ]
      if node-clustering-coefficient = "undefined"[
      set highlight-string (word immune attack-count " previous attacks | avg path length = " precision local-val 3
                                 " (for " pairs " turtles )")

      ]
      if not (node-clustering-coefficient = "undefined")[
      set highlight-string (word immune attack-count " previous attacks | clustering coefficient = " precision node-clustering-coefficient 3
                                 " | avg path length = " precision local-val 3
                                 " (for " pairs " turtles )")
      ]
    ]
    let neighbor-nodes [ link-neighbors ] of node
    let direct-links [ my-links ] of node
    ;; highlight neighbors
    ask neighbor-nodes
    [
      set shape "dot"

      ;; highlight edges connecting the chosen node to its neighbors
      ask my-links [
        ifelse (end1 = node or end2 = node)
        [
          set color blue ;
        ]
        [
          if (member? end1 neighbor-nodes and member? end2 neighbor-nodes)
            [ set color yellow ]
        ]
      ]
    ]
  ]
end

to infect-with-mouse
  if mouse-down? [
    let min-d min [distancexy mouse-xcor mouse-ycor] of turtles
    let node one-of turtles with [count link-neighbors > 0 and distancexy mouse-xcor mouse-ycor = min-d]
    if node != nobody[
      ask node [
        set color orange
        set susceptible? false
        set infectious? true
        set attacked? false
        set antivirus1? false
        set antivirus2? true
        set shape "circle"
      ]
    ]
  ]
end

to infect-pink-with-mouse
  if mouse-down? [
    let min-d min [distancexy mouse-xcor mouse-ycor] of turtles
    let node one-of turtles with [count link-neighbors > 0 and distancexy mouse-xcor mouse-ycor = min-d]
    if node != nobody[
      ask node [
        set color pink
        set susceptible? false
        set infectious? true
        set attacked? false
        set antivirus1? true
        set antivirus2? false
        set shape "circle"
      ]
    ]
  ]
end


;; The Small Worlds model and parts of the code are adapted from
;; Wilensky, U. (2005). NetLogo Small Worlds model. http://ccl.northwestern.edu/netlogo/models/SmallWorlds. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.
;; The Preferential Attachment / Scale Free model and parts of the code are adapted from
;; Wilensky, U. (2005). NetLogo Preferential Attachment model. http://ccl.northwestern.edu/netlogo/models/PreferentialAttachment. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.
;; The setup of a spatially clustered computer network was adapted from
;; Stonedahl, F. and Wilensky, U. (2008). NetLogo Virus on a Network model. http://ccl.northwestern.edu/netlogo/models/VirusonaNetwork. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

; See Info tab for full copyright and license.
@#$#@#$#@
GRAPHICS-WINDOW
307
10
893
597
-1
-1
17.52
1
10
1
1
1
0
0
0
1
-16
16
-16
16
1
1
1
ticks
30.0

SLIDER
4
59
146
92
num-nodes
num-nodes
10
150
100.0
1
1
NIL
HORIZONTAL

BUTTON
9
15
64
48
NIL
setup
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

SLIDER
5
98
141
131
rewiring-probability
rewiring-probability
0
1
0.21
0.01
1
NIL
HORIZONTAL

SLIDER
3
134
175
167
infected-at-start
infected-at-start
1
num-nodes - 1
25.0
1
1
NIL
HORIZONTAL

BUTTON
70
16
125
49
NIL
go
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
0

SLIDER
8
190
41
340
h
h
0
1
0.095
0.005
1
NIL
VERTICAL

SLIDER
55
191
88
341
a
a
0
1
0.2
0.005
1
NIL
VERTICAL

SLIDER
105
190
138
340
b
b
0
a
0.025
0.005
1
NIL
VERTICAL

INPUTBOX
143
283
193
343
T
5.0
1
0
Number

PLOT
907
16
1873
729
plot
time (ticks)
nodes
0.0
25.0
0.0
100.0
true
true
"" ""
PENS
"susceptible" 1.0 0 -10899396 true "" "plot count turtles with [susceptible?]"
"infectious" 1.0 0 -955883 true "" "plot count turtles with [infectious?]"
"attacked" 1.0 0 -2674135 true "" "plot count turtles with [attacked?]"
"effected" 1.0 0 -7500403 true "" "plot count turtles with [antivirus1? or antivirus2?]"
"disconnected" 1.0 0 -16777216 true "" "plot count turtles with [count link-neighbors = 0]"

MONITOR
675
694
750
739
Susceptible
count turtles with [susceptible?]
17
1
11

MONITOR
637
746
706
791
Infectious
count turtles with [infectious?]
17
1
11

MONITOR
717
748
780
793
Attacked
count turtles with [attacked?]
17
1
11

SWITCH
6
738
111
771
auto-rewire
auto-rewire
0
1
-1000

SLIDER
119
738
281
771
auto-rewire-probability
auto-rewire-probability
0
1
0.35
0.05
1
NIL
HORIZONTAL

SWITCH
7
676
99
709
auto-cut
auto-cut
0
1
-1000

SLIDER
106
677
281
710
detection-probability
detection-probability
0
1
0.003
0.001
1
NIL
HORIZONTAL

SLIDER
9
464
42
614
h2
h2
0
1
0.135
0.005
1
NIL
VERTICAL

SLIDER
56
463
89
613
a2
a2
0
1
0.12
0.005
1
NIL
VERTICAL

SLIDER
104
463
137
613
b2
b2
0
a2
0.025
0.005
1
NIL
VERTICAL

INPUTBOX
149
555
199
615
T2
4.0
1
0
Number

SWITCH
9
384
183
417
antivirus-propagation
antivirus-propagation
1
1
-1000

MONITOR
760
693
876
738
Effected by Purple
count turtles with [antivirus1?]
17
1
11

MONITOR
566
695
669
740
Effected by Red
count turtles with [antivirus2?]
17
1
11

MONITOR
311
697
427
742
Average Path Length
average-path-length
5
1
11

MONITOR
311
751
429
796
Clustering Coefficient
clustering-coefficient
5
1
11

SWITCH
145
468
258
501
patch-exploit
patch-exploit
0
1
-1000

SLIDER
7
424
179
457
proportion-red-purple
proportion-red-purple
0
100
50.0
1
1
NIL
HORIZONTAL

CHOOSER
153
48
304
93
network-type
network-type
"small-world" "scale-free" "computernetwork"
2

SLIDER
148
97
305
130
average-node-degree
average-node-degree
0
num-nodes - 1
99.0
1
1
NIL
HORIZONTAL

TEXTBOX
154
13
304
31
Network Setup
11
0.0
1

TEXTBOX
156
194
306
212
Virus (Red)
11
0.0
1

TEXTBOX
207
393
357
411
Antivirus (Purple)
11
0.0
1

TEXTBOX
9
656
159
674
Methods
11
0.0
1

TEXTBOX
312
676
462
694
Network Properties
11
0.0
1

TEXTBOX
565
673
715
691
Infection Status\n
11
0.0
1

BUTTON
311
624
384
657
Inspect Node
highlight
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

MONITOR
390
613
894
658
Node Properties
highlight-string
17
1
11

TEXTBOX
310
607
460
625
Inspector\n
11
0.0
1

SLIDER
154
777
281
810
rewire-percentage
rewire-percentage
0
100
100.0
1
1
NIL
HORIZONTAL

MONITOR
439
696
515
741
Disconnected
count turtles with [count link-neighbors = 0]
17
1
11

SWITCH
7
777
151
810
prefer-disconnected
prefer-disconnected
0
1
-1000

BUTTON
147
216
275
249
Infect Node by Click
infect-with-mouse
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

BUTTON
145
511
287
544
Infect Node by Click
infect-pink-with-mouse
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

SLIDER
183
133
306
166
outlier-hub
outlier-hub
-0.99
0.99
0.99
0.01
1
NIL
HORIZONTAL

@#$#@#$#@
# Complex Network Malware Propagation Model

## WHAT IS IT?

We live in the age of information and we store our information on computers. Interconnectivity of computers via the internet allows easy utilization and sharing of this information, but it also enables the spread of malicious software that is often designed to steal it. The high value of the data creates an “arms-race” dynamic between malware and cybersecurity software, where both parties continue to evolve and utilize diverse measures to gain an upper hand (Song 2008; Ladau et al., 2018). Traditional computer security measures focus on prevention, detection and neutralization of malware on an individual computer level. However, the key to effective defense is activation of multiple security layers, and continuous innovation in terms of security measures at different levels. In this research project, we employ complexity approach which allows us to test novel anti-virus measures that are designed at the system level. Specifically, we translate three virus-related interaction patterns observed in the context of ecology, and by simulating these interactions in the context of a computer network, we assess their effectiveness at allowing a safe network state to emerge. 
 
In recent years, malware has evolved in terms of its sophistication and threat, while the increasing use of mobile devices, home and car automation provides a fertile environment for its propagation (Hart et al., 2008). Self-propagating and evolving nature of computer viruses has led malware defense researchers to look into fields with equal or higher complexity for inspiration (Crandall et al., 2008). Biology, epidemiology and ecology have been particularly popular fields for generating new defense strategies, for instance, in simulating predator-prey dynamics or immunity-like anomaly detection (Ford et al., 2006; Suárez et al., 2018; Gorman et al. 2004). These attempts generally proposed defense mechanisms that operate within the computer or a local IT network, without explicitly including malware and dynamics that are typical for it.
 
To advance understanding of malware, Del Rey and colleagues (2019) have created a model that simulates malware behavior in different types of networks. While the model has provided a more nuanced insight into propagation of malware, it has not yet been applied in the context of malware defense. We propose such application in the present research project. We propose three ecology-inspired interaction patterns:
 
* Auto-cut
* Auto-rewire
* Pseudo-virus 
 
We integrate these measures within the replicated model.


## HOW IT WORKS

The main model is adapted from
del Rey, A. M., Dios, A. Q., Hernández, G., & Tabernero, A. B. (2019, June). Modeling the Spread of Malware on Complex Networks. In International Symposium on Distributed Computing and Artificial Intelligence (pp. 109-116). Springer, Cham.

"The epidemiological model proposed in this work is a compartmental model where the population of devices is divided into three classes or compartments: susceptible, infectious and attacked. Susceptible devices are those that have not been infected by the malware (the device is free of the malicious code); the infectious
devices are characterized because they have been reached by the malware but have not been attacked, and finally, attacked devices are those devices where the malware is carrying out its stealthy and malicious activity.
[...]

Note that a susceptible device becomes infectious when the malware reaches it (and, in our model, this depends on both the infection rate and the number of infectious neighbor devices); the infectious device c becomes attacked with probability a or susceptible with probability b << a (in this work it is supposed that the malware can remove itself if it does not find any neighbor host or the current host must not be attacked); finally, the attacked devices recover once the attacked period is finished. As a consequence, it is a SIAS model (Susceptible- Infectious-Attacked-Susceptible)."

## HOW TO USE IT

### Network Setup
Three different network types can be setup for the virus propagation: a small world network, a scale-free network through preferential attachment and a spatially clustered computer network. Accordingly, the rewiring probability and the average node degree for small world and spatially clustered networks can be changed. The total number of nodes can be altered, as well as the number of infected nodes and their distribution between hubs and outliers.

### Virus Settings
The parameters h, a, b and T can be set according to the model of del Rey, A. M., Dios, A. Q., Hernández, G., & Tabernero, A. B. (2019). The infection rate 0 ≤ h ≤ 1 has influence on the infection of a device free of malware. The targeted coefficient 0 ≤ a ≤ 1 defines the probability that the infectious device will be effectively attacked for a total amount of T ticks. The direct recovery from infectious comes at probability probability 0 ≤ b << a ≤ 1.
In addition, it is possible to infect nodes by clicking them having the according button activated.

### Antivirus Propagation
In this section, the propagation of an antivirus can be triggered. It will behave just like the normal virus, but the parameters h, a, b and T can be individually set for both. Also the proportion of the two viruses can be altered. Whether the two viruses patch the used exploit upon the first infection and thus bar the access to the node for the other virus can also be triggered here.

### Methods
The auto-cut  and auto-rewire method to counter the propagation of the virus can be triggered here. The detection probability determines how likely a node can detect being infected and cut all connections. The auto-rewire probability sets the probability of a node rewiring a certain percentage of nodes after an attack to avoid being infected again. For this rewiring, isolated or disconnected nodes can be preferred.

### Network and Node Inspector
The network and node inspector shows the network’s properties and infection status. Moreover, single nodes and their neighbours can be inspected by clicking the according button and hovering a node with the mouse.


## THINGS TO NOTICE

Our exploratory studies demonstrated that the robustness of the three types of network is contingent. In a more high-threat context, (i.e. more initial infected devices), a more aggressive virus (i.e. with a higher infection probability), and a targeted initial infection (i.e. initial infected device as a hub in the network), the propagation of the virus could not be eliminated without any defensive mechanisms in the small-world network and computer-network at least within 500 ticks observation (see Figure 3).  In other words, the virus persists in the small-world network and computer-network under these conditions.  And even though the scale-free network recovered automatically finally after more than 130 ticks , it took much more time to defeat the virus. This  results partially supported our assumption that the malware propagation cannot be eliminated automatically without any defensive mechanisms.

## THINGS TO TRY

To deal with the drawbacks of auto-cut and auto-rewiring mechanisms, We 1) exploratively combined the two functions, and 2) found the optimal auto-rewiring probability while auto-cut probability holds still. We conducted experiments with 100 repetitions for each auto-rewire probability value range from 0 to 1 with an interval of 0.05 in the three networks while all else holds the same. The experiments  revealed that the mechanism tends to be the most efficient in eliminating infection when auto rewiring probability is 0.05.
We then conducted the simulation study and experiments with auto-rewire-probability as 0.05. The results evidenced that this combination notably improved the performance of the defensive mechanism. Moreover, it increased the probability of retaining the original structure of the network, thus, interpreted as a networking consisting of computers connected via the internet, it could hold its efficiency when exchanging information. Additionally, the experiments show that it decreased the amount of the isolated devices on the average during the propagation (i.e. the average number of isolated nodes in each tick) and after the propagation (i.e. final number of isolated nodes).


## EXTENDING THE MODEL

The auto-rewire on its own has shown unwanted results as it facilitated the spread of the virus and changed the network structure, however, the combination of auto-cut and auto-rewire showed favorable results. It offered a possibility to control over both the amount of disconnected devices and the structure of the network while effectively eliminating the malware propagation.
Still, it would be interesting to see which mechanisms could potentially enhance the propagation of the virus and thus propose potential threats to the network and its structure. A more sophisticated rewiring algorithm could take more variables into account when reconnecting with other nodes to better maintain the initial structure of the network while still providing an efficient mechanism to eliminate the virus. Such questions could be discussed through an extended model in further researched based upon this work.


## RELATED MODELS

### Related model in the NetLogo Models Library
Stonedahl, F. and Wilensky, U. (2008). NetLogo Virus on a Network model. http://ccl.northwestern.edu/netlogo/models/VirusonaNetwork. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

### Virus Propagation on a Complex Network adapted from
del Rey, A. M., Dios, A. Q., Hernández, G., & Tabernero, A. B. (2019, June). Modeling the Spread of Malware on Complex Networks. In International Symposium on Distributed Computing and Artificial Intelligence (pp. 109-116). Springer, Cham.


## CODE DOCUMENTATION

### Variables
#### turtles-own
`node-clustering-coefficient`
It stores the local clustering coefficient of the node and how close its neighbours are to being a complete graph.

`distance-from-other-turtles`
It stores a list of distances of this node from other turtles.

`susceptible? | infectious? | attacked?`
The three Boolean variables represent the state of the computer during the virus propagation.

`antivirus1? | antivirus2?`
The two Boolean variables indicate whether the node was attacked by the one virus or the other. This is important for the propagation of an antagonistic virus especially if the two viruses patch the exploit of their host upon infection.

`attacked-at-tick`
It acts as a time counter during the attack state of a node.

`attack-count | attack1-count | attack2-count`
The three variables count the attacks of both viruses, together and separately.

#### links-own
`rewired?`
It keeps track of whether the link has been rewired or not.

#### globals
`clustering-coefficient | average-path-length | clustering-coefficient-of-lattice | average-path-length-of-lattice`
These four variables store the clustering coefficient and average path length of the initial lattice and the whole network throughout the simulation.

`infinity`
A very large number is used for distance between two turtles which don't have a connected or unconnected path between them.

`highlight-string`
This string is used by the node inspector functionality

`connected-network?`
This is a Boolean variable which indicates whether the overall network is fully connected.

### Procedures

#### Network Setup

The Small Worlds model and parts of the code are adapted from
Wilensky, U. (2005). NetLogo Small Worlds model. http://ccl.northwestern.edu/netlogo/models/SmallWorlds. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

The Preferential Attachment / Scale Free model and parts of the code are adapted from
Wilensky, U. (2005). NetLogo Preferential Attachment model. http://ccl.northwestern.edu/netlogo/models/PreferentialAttachment. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

The setup of a spatially clustered computer network was adapted from
Stonedahl, F. and Wilensky, U. (2008). NetLogo Virus on a Network model. http://ccl.northwestern.edu/netlogo/models/VirusonaNetwork. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

`startup`
It clears the highlight string.

`setup`
It sets up a network according to the chosen network type; calls startup, do-calculations and infect-initial and resets the ticks.

`make-turtles`
This procedure creates the number of nodes specified in susceptible state and reset counters.

`make-node`
This scale-free network procedure creates one node with a connection to an old-node and moves towards it.

`find-partner`
This scale-free network procedure finds a partner to be used as an attachment point for a newly made node.

`layout | limit-magnitude`
These functions are used to layout the scale-free network during the creation animation.

`setup-spatially-clustered-network`
This procedure sets up a spatially clustered computer network. 

`rewire-all`
This procedure is used to create a small world network.

`infect-initial`
This procedure infects the specified number of nodes and can be influenced by the outlier-hub coefficient.

#### Main Procedure

Virus Propagation on a Complex Network adapted from
del Rey, A. M., Dios, A. Q., Hernández, G., & Tabernero, A. B. (2019, June). Modeling the Spread of Malware on Complex Networks. In International Symposium on Distributed Computing and Artificial Intelligence (pp. 109-116). Springer, Cham.

`go`
The main procedure runs once per tick, colours all nodes and sets their new state according to the virus propagation model. The main procedure stops in case all nodes are green and thus in the idle susceptible state.

#### Calculations

The calculations in this model are adapted from
Wilensky, U. (2005). NetLogo Small Worlds model. http://ccl.northwestern.edu/netlogo/models/SmallWorlds. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

`do-calculations`
This procedure reports true if the network is connected.

`in-neighbourhood`
This procedure is used by find-clustering-coefficient and reports if a node is in the neighbourhood.

`find-clustering-coefficient`
This procedure calculates the clustering coefficient.

`find-path-lengths`
This procedure implements the Floyd Warshall algorithm for All Pairs Shortest Paths

#### Edge Operations

Some edge operations are adapted from
Wilensky, U. (2005). NetLogo Small Worlds model. http://ccl.northwestern.edu/netlogo/models/SmallWorlds. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

`wire-them`
This procedure is used to create the small world network.

`make-edge`
This procedure connects two turtles.

`rewire`
This procedure rewires a percentage of connections of a given node with the specified probability.

`cut`
This procedure cuts all connections of a given node.

#### Inspect & Infect with Mouse

The highlight operations are adapted from
Wilensky, U. (2005). NetLogo Small Worlds model. http://ccl.northwestern.edu/netlogo/models/SmallWorlds. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

`highlight`
This procedure prepares the graphics for the inspector and calls do-highlight when the mouse is inside the visualization.

`do-highlight`
This procedure is used to inspect the node closest to the mouse when the highlight procedure is active.

`infect-with-mouse`
This procedure lets the user infect a node (turn its state from susceptible to infected) by clicking it.

Vinfect-pink-with-mouseV
This procedure lets the user infect a by clicking it.


## CREDITS AND REFERENCES
### Authors
This model was developed and programmed in 2019 by [Lukas A. Haack](mailto:lukas_adrian.haack@tu-dresden.de) at Universiteit van Amsterdam with the support of Chenyue Wang and Izabelė Jonušaitė and supervision of dr. J.P. Bruggeman.

### The Small Worlds model and parts of the code are adapted from
Wilensky, U. (2005). NetLogo Small Worlds model. http://ccl.northwestern.edu/netlogo/models/SmallWorlds. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.
### The Preferential Attachment / Scale Free model and parts of the code are adapted from
Wilensky, U. (2005). NetLogo Preferential Attachment model. http://ccl.northwestern.edu/netlogo/models/PreferentialAttachment. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.
### The setup of a spatially clustered computer network was adapted from
Stonedahl, F. and Wilensky, U. (2008). NetLogo Virus on a Network model. http://ccl.northwestern.edu/netlogo/models/VirusonaNetwork. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

### Virus Propagation on a Complex Network adapted from
del Rey, A. M., Dios, A. Q., Hernández, G., & Tabernero, A. B. (2019, June). Modeling the Spread of Malware on Complex Networks. In International Symposium on Distributed Computing and Artificial Intelligence (pp. 109-116). Springer, Cham.

### Research based upon
Mazurczyk, W., Drobniak, S., & Moore, S. (2016). Towards a systematic view on cybersecurity ecology. In Combatting Cybercrime and Cyberterrorism (pp. 17-37). Springer, Cham.
@#$#@#$#@
default
true
0
Polygon -7500403 true true 150 5 40 250 150 205 260 250

airplane
true
0
Polygon -7500403 true true 150 0 135 15 120 60 120 105 15 165 15 195 120 180 135 240 105 270 120 285 150 270 180 285 210 270 165 240 180 180 285 195 285 165 180 105 180 60 165 15

arrow
true
0
Polygon -7500403 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

box
false
0
Polygon -7500403 true true 150 285 285 225 285 75 150 135
Polygon -7500403 true true 150 135 15 75 150 15 285 75
Polygon -7500403 true true 15 75 15 225 150 285 150 135
Line -16777216 false 150 285 150 135
Line -16777216 false 150 135 15 75
Line -16777216 false 150 135 285 75

bug
true
0
Circle -7500403 true true 96 182 108
Circle -7500403 true true 110 127 80
Circle -7500403 true true 110 75 80
Line -7500403 true 150 100 80 30
Line -7500403 true 150 100 220 30

butterfly
true
0
Polygon -7500403 true true 150 165 209 199 225 225 225 255 195 270 165 255 150 240
Polygon -7500403 true true 150 165 89 198 75 225 75 255 105 270 135 255 150 240
Polygon -7500403 true true 139 148 100 105 55 90 25 90 10 105 10 135 25 180 40 195 85 194 139 163
Polygon -7500403 true true 162 150 200 105 245 90 275 90 290 105 290 135 275 180 260 195 215 195 162 165
Polygon -16777216 true false 150 255 135 225 120 150 135 120 150 105 165 120 180 150 165 225
Circle -16777216 true false 135 90 30
Line -16777216 false 150 105 195 60
Line -16777216 false 150 105 105 60

car
false
0
Polygon -7500403 true true 300 180 279 164 261 144 240 135 226 132 213 106 203 84 185 63 159 50 135 50 75 60 0 150 0 165 0 225 300 225 300 180
Circle -16777216 true false 180 180 90
Circle -16777216 true false 30 180 90
Polygon -16777216 true false 162 80 132 78 134 135 209 135 194 105 189 96 180 89
Circle -7500403 true true 47 195 58
Circle -7500403 true true 195 195 58

circle
false
0
Circle -7500403 true true 0 0 300

circle 2
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240

cow
false
0
Polygon -7500403 true true 200 193 197 249 179 249 177 196 166 187 140 189 93 191 78 179 72 211 49 209 48 181 37 149 25 120 25 89 45 72 103 84 179 75 198 76 252 64 272 81 293 103 285 121 255 121 242 118 224 167
Polygon -7500403 true true 73 210 86 251 62 249 48 208
Polygon -7500403 true true 25 114 16 195 9 204 23 213 25 200 39 123

cylinder
false
0
Circle -7500403 true true 0 0 300

dot
false
0
Circle -7500403 true true 90 90 120

face happy
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 255 90 239 62 213 47 191 67 179 90 203 109 218 150 225 192 218 210 203 227 181 251 194 236 217 212 240

face neutral
false
0
Circle -7500403 true true 8 7 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Rectangle -16777216 true false 60 195 240 225

face sad
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 168 90 184 62 210 47 232 67 244 90 220 109 205 150 198 192 205 210 220 227 242 251 229 236 206 212 183

fish
false
0
Polygon -1 true false 44 131 21 87 15 86 0 120 15 150 0 180 13 214 20 212 45 166
Polygon -1 true false 135 195 119 235 95 218 76 210 46 204 60 165
Polygon -1 true false 75 45 83 77 71 103 86 114 166 78 135 60
Polygon -7500403 true true 30 136 151 77 226 81 280 119 292 146 292 160 287 170 270 195 195 210 151 212 30 166
Circle -16777216 true false 215 106 30

flag
false
0
Rectangle -7500403 true true 60 15 75 300
Polygon -7500403 true true 90 150 270 90 90 30
Line -7500403 true 75 135 90 135
Line -7500403 true 75 45 90 45

flower
false
0
Polygon -10899396 true false 135 120 165 165 180 210 180 240 150 300 165 300 195 240 195 195 165 135
Circle -7500403 true true 85 132 38
Circle -7500403 true true 130 147 38
Circle -7500403 true true 192 85 38
Circle -7500403 true true 85 40 38
Circle -7500403 true true 177 40 38
Circle -7500403 true true 177 132 38
Circle -7500403 true true 70 85 38
Circle -7500403 true true 130 25 38
Circle -7500403 true true 96 51 108
Circle -16777216 true false 113 68 74
Polygon -10899396 true false 189 233 219 188 249 173 279 188 234 218
Polygon -10899396 true false 180 255 150 210 105 210 75 240 135 240

house
false
0
Rectangle -7500403 true true 45 120 255 285
Rectangle -16777216 true false 120 210 180 285
Polygon -7500403 true true 15 120 150 15 285 120
Line -16777216 false 30 120 270 120

leaf
false
0
Polygon -7500403 true true 150 210 135 195 120 210 60 210 30 195 60 180 60 165 15 135 30 120 15 105 40 104 45 90 60 90 90 105 105 120 120 120 105 60 120 60 135 30 150 15 165 30 180 60 195 60 180 120 195 120 210 105 240 90 255 90 263 104 285 105 270 120 285 135 240 165 240 180 270 195 240 210 180 210 165 195
Polygon -7500403 true true 135 195 135 240 120 255 105 255 105 285 135 285 165 240 165 195

line
true
0
Line -7500403 true 150 0 150 300

line half
true
0
Line -7500403 true 150 0 150 150

pentagon
false
0
Polygon -7500403 true true 150 15 15 120 60 285 240 285 285 120

person
false
0
Circle -7500403 true true 110 5 80
Polygon -7500403 true true 105 90 120 195 90 285 105 300 135 300 150 225 165 300 195 300 210 285 180 195 195 90
Rectangle -7500403 true true 127 79 172 94
Polygon -7500403 true true 195 90 240 150 225 180 165 105
Polygon -7500403 true true 105 90 60 150 75 180 135 105

plant
false
0
Rectangle -7500403 true true 135 90 165 300
Polygon -7500403 true true 135 255 90 210 45 195 75 255 135 285
Polygon -7500403 true true 165 255 210 210 255 195 225 255 165 285
Polygon -7500403 true true 135 180 90 135 45 120 75 180 135 210
Polygon -7500403 true true 165 180 165 210 225 180 255 120 210 135
Polygon -7500403 true true 135 105 90 60 45 45 75 105 135 135
Polygon -7500403 true true 165 105 165 135 225 105 255 45 210 60
Polygon -7500403 true true 135 90 120 45 150 15 180 45 165 90

sheep
false
15
Circle -1 true true 203 65 88
Circle -1 true true 70 65 162
Circle -1 true true 150 105 120
Polygon -7500403 true false 218 120 240 165 255 165 278 120
Circle -7500403 true false 214 72 67
Rectangle -1 true true 164 223 179 298
Polygon -1 true true 45 285 30 285 30 240 15 195 45 210
Circle -1 true true 3 83 150
Rectangle -1 true true 65 221 80 296
Polygon -1 true true 195 285 210 285 210 240 240 210 195 210
Polygon -7500403 true false 276 85 285 105 302 99 294 83
Polygon -7500403 true false 219 85 210 105 193 99 201 83

square
false
0
Rectangle -7500403 true true 30 30 270 270

square 2
false
0
Rectangle -7500403 true true 30 30 270 270
Rectangle -16777216 true false 60 60 240 240

star
false
0
Polygon -7500403 true true 151 1 185 108 298 108 207 175 242 282 151 216 59 282 94 175 3 108 116 108

target
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240
Circle -7500403 true true 60 60 180
Circle -16777216 true false 90 90 120
Circle -7500403 true true 120 120 60

tree
false
0
Circle -7500403 true true 118 3 94
Rectangle -6459832 true false 120 195 180 300
Circle -7500403 true true 65 21 108
Circle -7500403 true true 116 41 127
Circle -7500403 true true 45 90 120
Circle -7500403 true true 104 74 152

triangle
false
0
Polygon -7500403 true true 150 30 15 255 285 255

triangle 2
false
0
Polygon -7500403 true true 150 30 15 255 285 255
Polygon -16777216 true false 151 99 225 223 75 224

truck
false
0
Rectangle -7500403 true true 4 45 195 187
Polygon -7500403 true true 296 193 296 150 259 134 244 104 208 104 207 194
Rectangle -1 true false 195 60 195 105
Polygon -16777216 true false 238 112 252 141 219 141 218 112
Circle -16777216 true false 234 174 42
Rectangle -7500403 true true 181 185 214 194
Circle -16777216 true false 144 174 42
Circle -16777216 true false 24 174 42
Circle -7500403 false true 24 174 42
Circle -7500403 false true 144 174 42
Circle -7500403 false true 234 174 42

turtle
true
0
Polygon -10899396 true false 215 204 240 233 246 254 228 266 215 252 193 210
Polygon -10899396 true false 195 90 225 75 245 75 260 89 269 108 261 124 240 105 225 105 210 105
Polygon -10899396 true false 105 90 75 75 55 75 40 89 31 108 39 124 60 105 75 105 90 105
Polygon -10899396 true false 132 85 134 64 107 51 108 17 150 2 192 18 192 52 169 65 172 87
Polygon -10899396 true false 85 204 60 233 54 254 72 266 85 252 107 210
Polygon -7500403 true true 119 75 179 75 209 101 224 135 220 225 175 261 128 261 81 224 74 135 88 99

wheel
false
0
Circle -7500403 true true 3 3 294
Circle -16777216 true false 30 30 240
Line -7500403 true 150 285 150 15
Line -7500403 true 15 150 285 150
Circle -7500403 true true 120 120 60
Line -7500403 true 216 40 79 269
Line -7500403 true 40 84 269 221
Line -7500403 true 40 216 269 79
Line -7500403 true 84 40 221 269

wolf
false
0
Polygon -16777216 true false 253 133 245 131 245 133
Polygon -7500403 true true 2 194 13 197 30 191 38 193 38 205 20 226 20 257 27 265 38 266 40 260 31 253 31 230 60 206 68 198 75 209 66 228 65 243 82 261 84 268 100 267 103 261 77 239 79 231 100 207 98 196 119 201 143 202 160 195 166 210 172 213 173 238 167 251 160 248 154 265 169 264 178 247 186 240 198 260 200 271 217 271 219 262 207 258 195 230 192 198 210 184 227 164 242 144 259 145 284 151 277 141 293 140 299 134 297 127 273 119 270 105
Polygon -7500403 true true -1 195 14 180 36 166 40 153 53 140 82 131 134 133 159 126 188 115 227 108 236 102 238 98 268 86 269 92 281 87 269 103 269 113

x
false
0
Polygon -7500403 true true 270 75 225 30 30 225 75 270
Polygon -7500403 true true 30 75 75 30 270 225 225 270
@#$#@#$#@
NetLogo 6.1.1
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
default
0.0
-0.2 0 0.0 1.0
0.0 1 1.0 0.0
0.2 0 0.0 1.0
link direction
true
0
Line -7500403 true 150 150 90 180
Line -7500403 true 150 150 210 180
@#$#@#$#@
0
@#$#@#$#@