breeds [ frogs trucks cars logs river-turtles pads ] ;; These are all the game pieces. 

;;;;;;;;;;;;;;;
;; Variables ;;
;;;;;;;;;;;;;;;

globals [
  action            ;; Last button pressed. Prevent the player from moving the frog until the
                    ;; the game is running.  Checks the status of this button every loop.
  dead?             ;; True when no frog lives are left - used to stop the game
  lives             ;; Remaining lives 
  level             ;; Current level  
  jumps             ;; Current number of jumps
  time-left         ;; Time remaining
  pads-done         ;; Number of frogs that have successfully reached the pads
  mouse-prev-state  ;; This tells you what the previous state of the mouse is (up or down).
                    ;; It it used to cause the player to have to click each time he or she
                    ;; wants to move the frog (as opposed to just holding down the button)
]

;; In NetLogo, all the breeds are "turtles".  This can be confusing because
;; there are also "turtles" in the game of Frogger -- they swim in the river.
;; To avoid confusion, we call those turtles "river-turtles".

turtles-own [ 
  speed            ;; The 'time' variable will be initialized to the value of 'speed' after the turtle moves
  time             ;; This keeps track of how many time loops have occured since the turtle last moved.
                   ;; It actually counts down from 'speed' to zero.  Once it reaches zero, the turtle
                   ;; moves foward one space
]

river-turtles-own [ 
  dive?            ;; True when the turtle dives 
]

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

to startup            ;; Setup is the 'New Game' button, this will setup the game.
  setup
end

to setup              ;; Initializes the game
  ca
  set action 0
  set dead? false
  set lives start-lives 
  set mouse-prev-state false  
  set-default-shape frogs "frog"
  set-default-shape cars "car"
  set-default-shape river-turtles "turtle"
  set level start-level
  next-level
end

to next-level        ;; This will call the appropriate level procedure, where the level is created
  draw-map
  if ( level = 1 )
    [ level-1 ]
  if ( level = 2 )
    [ level-2 ]
  if ( level = 3 )
    [ level-3 ]
  if ( level = 4 )
    [ level-4 ]
  if ( level = 5 )
    [ level-5 ]
  if ( level = 6 )
    [ user-message "Actually, that was the last level.\nPerhaps you should program some more :-)" 
      set dead? true]    
end

;; This will color the patches to make the grass, road, and river, and creates the frog.
;; The second line causes the grass to be various similar shades of green so it looks 
;; more like real grass. 

to draw-map
  cg
  ask patches
    [ set pcolor scale-color green ((random 500) + 5000) 0 9000 ]
  create-pads
  ask patches with [pycor <= screen-edge-y and pycor >= 3]
    [ set pcolor blue ]
  ask patches with [pycor <= -1 and pycor >= -5]
    [ set pcolor gray ]
  set pads-done 0
  create-custom-frogs 1 
    [ set color 53
      reset-frog
    ]
end

;; Initializes the frog by setting it to the right patch and facing the right direction

to reset-frog      
  setxy 0 (- screen-edge-y)
  set heading 0
  set jumps 0
  set time-left start-time
end

;; Creates the five pads equally spaced at the top of the board.
;; The second line uses the modulus operation to determine which x-cor
;; is divisible by three.  This is an easy way to have a pad created every
;; three patches.

to create-pads     
  set-default-shape pads "pad"
  ask patches with [pycor = screen-edge-y and pxcor mod 3 = 0]
    [ sprout 1
        [ set breed pads ]
    ]
end

to create-truck [ x y direction quickness ]   ;; Creates and initialzes a truck
  locals [ truckColor ]
  set truckColor (random 13 + 1) * 10 + 3
  ask patches with [(pxcor = x or pxcor = (x + 1)) and pycor = y]
    [ sprout 1 
        [ set breed trucks
          set color truckColor 
          set heading direction
          set speed quickness
          set time speed
          ifelse ((pxcor = x) xor (direction = 90))
            [ set shape "truck" ]
            [ set shape "truck2" ]
        ]
    ]
end

to create-car [x y direction quickness]     ;; Creates and initialzes a car
  create-custom-cars 1 
    [ set color (random 13 + 1) * 10 + 3
      setxy x y 
      set heading direction
      set speed quickness
      set time speed 
    ]
end

;; Creates and initializes a log.  The actual turtle is hidden because we want the
;; frog to always be on top of the log.  We don't want the log to hide the frog, so we
;; cause the hidden turtle to stamp the patch brown.  The last turtle in the line has
;; its pen down with a blue color.  This will redraw the river blue after the last part
;; of the log moves.

to create-log [x y leng quickness]        
  ask patches with [pycor = y and pxcor >= x and pxcor < (x + leng)]
    [ sprout 1
        [ set breed logs
          hideturtle
          set heading 90
          set speed quickness
          set time speed
          set pcolor brown
          if pxcor = x
            [ pendown
              set color blue
            ]
        ]
    ] 
end

to create-river-turtle [x y leng quickness]    ;; Creates and initializes a river-turtle
  ask patches with [pycor = y and pxcor >= x and pxcor < (x + leng)]
    [ sprout 1
        [ set breed river-turtles
          set heading 270
          set speed quickness
          set time speed
          set color 54
          set dive? false
        ]
    ] 
end

to make-river-turtle-dive [num]    ;; Causes a random river-turtle(s) to dive underwater.
  repeat num
    [ ask random-one-of river-turtles with [not dive?]
        [ set dive? true ]
    ]
end


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


to go            ;; The main Routine
  if dead?
    [ stop ]
  move
end

;; This is the time loop: every 0.1 seconds it decrements every turtle's 'time'
;; variable and check to see if it should move (when it reaches zero).  It then will
;; reset the 'time' if it is zero.  The logs and river-turtles need their own special 
;; procedure to move since they "carry" the frog with them.

to move
  move-frog          
  every 0.1
    [ ask turtles
        [ decrement-time ]
      ask turtles with [time = 0.0 and breed != frogs]
        [ set time speed
          ifelse (breed = logs)
            [ move-log ]
            [ ifelse (breed = river-turtles)
                [ move-river-turtle ]
                [ fd 1 ]
            ]
        ]
      check-frog
    ]
  check-mouse
end

;; This will decrement the 'time' for all non-frogs and it will decrement the 'time-left'
;; global variable.  The precision function is needed to verify there is only one decimal
;; place on the time variables.

to decrement-time   
  ifelse (breed = frogs)
    [ set time-left precision (time-left - 0.1) 1 ]
    [ set time precision (time - 0.1) 1 ]
end

;;  Every time loop, we need to see what the frog's status is (dead, on a pad, etc..)
;;  First it will need to see if it is on a pad and make sure there are no other frogs there
;;  (by checking the shape of the the pad).  Then you need to check to see if the frog is in
;;  a space where he should die.  Finally, it checks to see if the level is complete.

to check-frog
  ask frogs
    [ if any? pads-here with [shape = "pad"]
        [ ask pads-here 
            [ set shape "frog" 
              set heading 0
              set color 54 
              set pads-done (pads-done + 1)
            ]
          reset-frog 
        ]
      if ((any? trucks-here) or (any? cars-here) or (time-left <= 0) or
         ((pcolor-of patch-here = blue) and (count pads-here = 0) and
         (count river-turtles-here with [not hidden?] = 0)))           
        [ kill-frog ]
    ]
  if ( pads-done = 5 )
    [ set level (level + 1)
      set pads-done 0
      user-message "Congrats, all your frogs are safe!\nOn to level " + level + "..."
      next-level
    ]   
end

to kill-frog        ;; This is called when the frog dies, checks if the game is over
  set lives (lives - 1)       
  ifelse (lives = 0)
    [ user-message "Your frog died!\nYou have no more frogs!\nGAME OVER!"
      set dead? true 
      die
    ]
    [ user-message "Your frog died!\nYou have " + lives + " frogs left." 
      reset-frog
    ] 
end

;; This is a special procedure to move a log.  It needs to move any frogs that
;; are ontop of it.  It moves by stamping the patch brown- remember the turtles are hidden.

to move-log        
  ask frogs-here
    [ if (pxcor != screen-edge-x)
        [ setxy (xcor + 1) ycor ]
    ]
  fd 1
  if (pcolor = blue)
    [ stamp brown ]
end

;; This is a special procedure to move the river-turtles.  It needs to move any frogs that
;; are ontop of it.  However, to keep the frog "on top" of the turtle, the frog needs to move 
;; last - therefore, it needs to check for frogs where it "used to be".  In addition, the frog 
;; always needs to move (to remain ontop of the screen), so when you are at the screen edge, 
;; the frog needs to move and then move back.

to move-river-turtle    
  fd 1
  ask frogs-at 1 0
    [ setxy (pxcor - 1) ycor  
      if (xcor = screen-edge-x)
        [ setxy (xcor + 1) ycor ] 
    ]
  dive-river-turtle   
end 

;; If a river-turtle has been instructed to dive, this procedure will implement that.
;; It will also cause it to splash and rise back up.  It uses a random numbers to 
;; determine when it should dive and rise back up.  Theoritically, it will dive about 
;; every eighth move and stay down for about five moves, but this isn't always the case 
;; (the randomness is added for increasing the challenge of the game)

to dive-river-turtle    
  if dive?
    [ ifelse (hidden? and random 5 = 1)
        [ showturtle ]
        [ if ( shape = "splash" )
            [ set shape "turtle"
              hideturtle
            ]              
          if (shape = "turtle" and random 8 = 1)
            [ set shape "splash" ]
        ]
    ] 
end


;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Interface Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; This implements mouse support for the game.  It will check to see if the mouse button
;; is down and it wasn't down before (therefore you need to click each time you want the frog
;; to move)  The direction is rounded to only 90 degree directions.

to check-mouse     
  ask frogs
    [ if (mouse-down? and not mouse-prev-state)
        [ ifelse (round mouse-ycor != pycor)
            [ set heading towardsxy-nowrap pxcor mouse-ycor ]
            [ set heading towardsxy-nowrap mouse-xcor pycor ]          
          fd 1
          set jumps (jumps + 1)
          set mouse-prev-state true        
        ]
      if ((not mouse-down?) and mouse-prev-state )
        [ set mouse-prev-state false ]
    ]
end

to move-frog
  if (action != 0)
    [ if (action = 1)
        [ move-left ]
      if (action = 2)
        [ move-right ]
      if (action = 3)
        [ move-down ]
      if (action = 4)
        [ move-up ]
      set action 0
    ]
end

to move-left
  ask frogs with [xcor != (- screen-edge-x)]
    [ set heading 270 
      fd 1
      set jumps ( jumps + 1 )
    ]
  check-frog
end

to move-right
  ask frogs with [xcor != screen-edge-x]
    [ set heading 90 
      fd 1
      set jumps ( jumps + 1 )   
    ]
  check-frog
end

to move-up
  ask frogs with [ycor != screen-edge-y]
    [ set heading 0 
      fd 1
      set jumps ( jumps + 1 )   
    ]
  check-frog
end

to move-down
  ask frogs with [ycor != (- screen-edge-y)]
    [ set heading 180
      fd 1
      set jumps ( jumps + 1 )   
    ] 
  check-frog
end


;;;;;;;;;;;;;;
;;; Levels ;;;
;;;;;;;;;;;;;;

to level-1
  create-truck 5 -5 270 .9
  create-truck 0 -5 270 .9
  create-truck -8 -4 90 .9
  create-truck -5 -4 90 .9
  create-truck 2 -4 90 .9
  create-truck -3 -3 270 .8
  create-truck 6 -3 270 .8
  create-car 0 -2 90 .4 
  create-car -4 -2 90 .4
  create-car 8 -1 270 .2
  create-car 3 -1 270 .2 
  create-log 4 3 3 .6
  create-log -8 3 5 .6
  create-log 4 5 2 .7
  create-log -4 5 3 .7
  create-log 1 7 4 .3
  create-log -6 7 4 .3
  create-river-turtle 2 4 2 .4
  create-river-turtle -4 4 4 .4
  create-river-turtle 5 4 4 .4
  create-river-turtle -3 6 4 .5
  create-river-turtle 7 6 3 .5
end

to level-2
  create-truck 4 -5 270 .8
  create-truck -3 -5 270 .8
  create-truck 0 -4 90 .9
  create-truck -4 -4 90 .9
  create-truck -1 -3 270 .8
  create-truck 4 -3 270 .8
  create-truck -5 -3 270 .8
  create-car 0 -2 90 .2 
  create-car -4 -2 90 .2
  create-car 8 -2 90 .2
  create-car 6 -1 270 .4 
  create-car 2 -1 270 .4
  create-car -3 -1 270 .4 
  create-car -6 -1 270 .4 
  create-log 6 3 3 .6
  create-log -4 3 4 .6
  create-log 0 5 3 .3
  create-log -6 5 3 .3
  create-log 1 7 4 .5
  create-log 6 7 4 .5
  create-river-turtle 0 4 4 .3
  create-river-turtle 6 4 4 .3
  create-river-turtle 0 6 4 .4
  create-river-turtle 6 6 3 .4
  make-river-turtle-dive 1
end

to level-3
  create-truck -8 -5 270 .7
  create-truck -4 -5 270 .7
  create-truck 0 -5 270 .7
  create-truck -2 -4 90 .7
  create-truck 2 -4 90 .7
  create-truck -6 -4 90 .7
  create-truck -4 -3 270 .7
  create-truck 0 -3 270 .7
  create-truck 4 -3 270 .7
  create-car -3 -2 90 .2 
  create-car -5 -2 90 .2
  create-car 5 -2 90 .2
  create-car 1 -2 90 .2
  create-car 0 -1 270 .3 
  create-car 5 -1 270 .3
  create-car -7 -1 270 .3 
  create-car -3 -1 270 .3 
  create-log -6 3 4 .4
  create-log -2 5 3 .4
  create-log 5 5 3 .4
  create-log -4 7 2 .2
  create-log 0 7 2 .2
  create-log 4 7 2 .2
  create-river-turtle -4 4 4 .3
  create-river-turtle 5 4 4 .3
  create-river-turtle -1 6 3 .4
  create-river-turtle -8 6 3 .4
  make-river-turtle-dive 3
end

to level-4
  create-truck -8 -5 270 .5
  create-truck -2 -5 270 .5
  create-truck 6 -5 270 .5
  create-truck 4 -4 90 .6
  create-truck -1 -4 90 .6
  create-truck -6 -4 90 .6
  create-car -4 -3 270 .3
  create-car 0 -3 270 .3
  create-car 4 -3 270 .3
  create-car 7 -3 270 .3
  create-car -3 -2 90 .2 
  create-car -5 -2 90 .2
  create-car 5 -2 90 .2
  create-car 1 -2 90 .2
  create-car 0 -1 270 .3 
  create-car 5 -1 270 .3
  create-car -7 -1 270 .3 
  create-car -3 -1 270 .3 
  create-log -3 3 3 .3
  create-log -3 5 3 .3
  create-log -3 7 3 .3
  create-river-turtle -4 4 4 .3
  create-river-turtle 4 4 4 .3
  create-river-turtle -7 4 1 .3
  create-river-turtle -1 6 3 .4
  create-river-turtle -8 6 3 .4
  create-river-turtle 3 6 2 .4
  make-river-turtle-dive 4
end

to level-5
  create-car -4 -5 270 .3
  create-car 0 -5 270 .3
  create-car 4 -5 270 .3
  create-car 7 -5 270 .3
  create-car -3 -4 90 .2 
  create-car -5 -4 90 .2
  create-car 5 -4 90 .2
  create-car 1 -4 90 .2
  create-car 8 -4 90 .2
  create-car -4 -3 270 .3
  create-car 0 -3 270 .3
  create-car 4 -3 270 .3
  create-car 7 -3 270 .3
  create-car -3 -2 90 .2 
  create-car -5 -2 90 .2
  create-car 4 -2 90 .2
  create-car 1 -2 90 .2
  create-car 7 -2 90 .2
  create-car 0 -1 270 .3 
  create-car 5 -1 270 .3
  create-car -7 -1 270 .3 
  create-car -3 -1 270 .3 
  create-log -5 3 2 .2
  create-log 0 5 2 .1
  create-log -5 7 2 .2
  create-river-turtle -4 4 2 .3
  create-river-turtle 4 4 3 .3
  create-river-turtle -7 4 2 .3
  create-river-turtle -1 6 2 .3
  create-river-turtle -8 6 2 .3
  create-river-turtle 3 6 3 .3
  make-river-turtle-dive 5
end


; *** NetLogo Model Copyright Notice ***
;
; This model was created as part of the project:
; PARTICIPATORY SIMULATIONS: NETWORK-BASED DESIGN FOR SYSTEMS LEARNING IN
; CLASSROOMS.  The project gratefully acknowledges the support of the
; National Science Foundation (REPP program) -- grant number REC #9814682.
;
; Copyright 2002 by Uri Wilensky.  Updated 2002.  All rights reserved.
;
; Permission to use, modify or redistribute this model is hereby granted,
; provided that both of the following requirements are followed:
; a) this copyright notice is included.
; b) this model will not be redistributed for profit without permission
;    from Uri Wilensky.
; Contact Uri Wilensky for appropriate licenses for redistribution for
; profit.
;
; To refer to this model in academic publications, please use:
; Wilensky, U. (2002).  NetLogo Frogger model.
; http://ccl.northwestern.edu/netlogo/models/Frogger.
; Center for Connected Learning and Computer-Based Modeling,
; Northwestern University, Evanston, IL.
;
; In other publications, please use:
; Copyright 1998 by Uri Wilensky.  All rights reserved.  See
; http://ccl.northwestern.edu/netlogo/models/Frogger
; for terms of use.
;
; *** End of NetLogo Model Copyright Notice ***
@#$#@#$#@
GRAPHICS-WINDOW
327
10
677
381
8
8
20.0
1
10
1
1
1

CC-WINDOW
9
329
298
468
Command Center

BUTTON
348
431
415
468
LEFT
set action 1
NIL
1
T
OBSERVER
T

BUTTON
415
431
482
468
RIGHT
set action 2
NIL
1
T
OBSERVER
T

BUTTON
383
395
447
432
UP
set action 4
NIL
1
T
OBSERVER
T

BUTTON
384
467
448
504
DOWN
set action 3
NIL
1
T
OBSERVER
T

BUTTON
37
50
140
83
New Game
setup
NIL
1
T
OBSERVER
T

BUTTON
183
49
286
82
Start
go
T
1
T
OBSERVER
T

MONITOR
182
106
295
155
Frogs Left
lives
0
1

MONITOR
182
157
295
206
NIL
Level
0
1

MONITOR
182
208
295
257
Time Left
time-left
3
1

SLIDER
22
106
171
139
start-lives
start-lives
1
5
5
1
1
NIL

SLIDER
22
206
171
239
start-time
start-time
10
60
60
5
1
NIL

SLIDER
22
155
171
188
start-level
start-level
1
5
1
1
1
NIL

MONITOR
182
259
295
308
Frog Jumps
jumps
0
1

TEXTBOX
502
423
645
480
You may also move by clicking in the graphics window.

@#$#@#$#@
WHAT IS IT?
-----------
This model is based on the classic arcade game, Frogger.  The object of the game is to get the frog, found at the bottom of the screen, across the traffic and river to a safe lily pad at the top of the screen.

There are two main obstacles to overcome, the road and the river.  The road has cars and trucks moving at various speeds that are liable to run over the frog.  Once you have crossed the road safely, you must overcome the danger lurking in the river.  Unfortunately, you will die if you jump in the river, so you must keep moving towards the lily pads by jumping on the logs or sets of turtles moving back and forth in the river's current.

You must also avoid getting pushed off the edge of the screen by a log or turtle.  In addition, in the later levels, some of the turtles will dive under water -- if you happen to be standing on them you will drown!  Finally, you must also get across the board before the allotted amount of time runs out.


HOW TO USE IT
-------------
Buttons:
- NEW-GAME resets the game
- START starts the game
- The direction buttons (UP, DOWN, LEFT, RIGHT) will move your frog in that direction

Another way to move is to use your mouse.  Just click in the direction you want to move (one click per jump).  (If you click diagonally, the frog jumps up or down, not left or right.  This makes crossing the river easier.)

Monitors
- FROGS LEFT tells you how many remaining lives you have
- LEVEL monitors the current level you are playing
- TIME LEFT shows you how much time remains 
- FROG JUMPS tells you how many jumps you has taken

Sliders
 START-LIVES will determine how many lives you will start with
 START-TIME sets how much time you start out with
 START-LEVEL is used to determine which level you will start on

Identifying Things in the Board:
- Green Frog:      This is you.
- Truck:           This is a truck.  Avoid at all costs.  They are usually pretty slow.
- Car:             This is a car.  Avoid at all costs.  They are usually fast.
- Brown Squares:   This is a log.  You need to jump onto these to get across the river.
- Turtle:          This is a turtle.  You need to jump onto these.  Avoid ones that dive.
- Green Circles:   This is the lily pad.  You want to get on these to win the level.
- Blue Squares:    This is the river.  You can't land on this.
- Gray Squares:    This is the road.  You can jump on this, but watch out for vehicles.
- Green Patches:   This is grass.  You are pretty safe here.


THINGS TO TRY
-------------
See if you can get through all of the levels.

Try to beat your previous time.

Try to make as few jumps as possible in the time allotted.

Try to use as few lives as possible.


THINGS TO NOTICE
----------------
Determine how many jumps it would take to get across the board without obstacles.

Determine how many jumps it would take to get across the board with obstacles.

How does each of the two questions above related to the time it takes you to complete a level?

If you take just as many jumps with obstacles as without, why does it take different durations of time to get across?


EXTENDING THE MODEL
-------------------
Write your own levels by altering the code in the Procedures tab.

Add some bonuses or additional hazards.

Implement a scoring system.

Write a robot script that will move your frog automatically.


NETLOGO FEATURES
-----------------
This model uses breeds to implement the different moving game pieces.

The every command is used to control the speed of the game.

The user-message command presents messages to the user.

mouse-down?, mouse-xcor, and mouse-ycor are used to detect and handle mouse clicks.


RELATED MODELS
--------------
Pac Man, Tetris


CREDITS AND REFERENCES
----------------------
To refer to this model in academic publications, please use: Wilensky, U. (1998).  NetLogo Frogger model. http://ccl.northwestern.edu/netlogo/models/Frogger. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

In other publications, please use: Copyright 1998 by Uri Wilensky.  All rights reserved.  See http://ccl.northwestern.edu/netlogo/models/Frogger for terms of use.
@#$#@#$#@
default
true
0
Polygon -7566196 true true 150 5 40 250 150 205 260 250

car
true
0
Rectangle -7566196 true true 75 30 225 278
Polygon -7566196 true true 75 28 91 14 211 16 225 30 211 54 79 38
Rectangle -16711681 true false 93 114 209 128
Rectangle -16711681 true false 97 232 205 240
Line -16777216 false 97 144 97 212
Line -16777216 false 203 146 203 208
Line -16777216 false 99 36 199 36
Line -16777216 false 201 36 201 98
Line -16777216 false 97 36 97 92
Line -16777216 false 97 92 121 68
Line -16777216 false 121 68 171 68
Line -16777216 false 171 68 177 68
Line -16777216 false 177 68 199 90
Rectangle -7566196 true true 195 92 207 98
Rectangle -7566196 true true 199 94 205 100
Rectangle -7566196 true true 99 39 199 99
Line -16777216 false 111 91 183 91
Circle -256 true false 75 13 16
Circle -256 true false 209 15 16
Polygon -7566196 true true 75 27 89 15 109 15 109 31
Polygon -7566196 true true 91 23 79 27 81 31
Polygon -7566196 true true 209 15 225 31 219 37 187 27
Circle -256 true false 211 13 12
Polygon -7566196 true true 209 15 221 27 203 29
Line -16777216 false 99 37 99 39
Line -16777216 false 99 91 99 35
Circle -256 true false 75 11 13
Line -16777216 false 199 37 199 91
Rectangle -7566196 true true 90 33 98 95
Circle -256 true false 211 15 12
Rectangle -7566196 true true 195 31 205 95
Line -16777216 false 195 37 195 89
Rectangle -7566196 true true 93 35 101 95
Rectangle -7566196 true true 191 33 199 95
Rectangle -7566196 true true 95 33 101 43
Rectangle -7566196 true true 97 31 103 43
Rectangle -65536 true false 77 273 89 277
Rectangle -65536 true false 211 273 223 277
Rectangle -65536 true false 77 269 97 275
Rectangle -65536 true false 205 271 221 277
Rectangle -65536 true false 207 269 223 275
Rectangle -65536 true false 87 269 95 275
Rectangle -7566196 true true 87 39 217 89
Rectangle -7566196 true true 89 23 205 99
Rectangle -7566196 true true 128 61 214 111
Rectangle -7566196 true true 77 31 147 111
Rectangle -16777216 true false 89 15 209 17
Rectangle -16777216 true false 91 17 211 19
Rectangle -7566196 true true 91 51 213 113
Rectangle -7566196 true true 77 265 223 277
Rectangle -7566196 true true 97 16 199 24
Rectangle -16777216 true false 99 22 197 28

frog
true
0
Polygon -11352576 true false 149 12 115 32 89 60 75 134 89 210 131 224 149 224 169 224 211 210 225 134 209 56 179 26 149 12
Polygon -11352576 true false 93 60 35 72 17 114 33 118 47 80 87 74
Polygon -11352576 true false 81 180 43 214 67 260 85 258 57 216 85 192
Polygon -11352576 true false 209 62 261 68 283 110 267 110 253 78 211 72 209 62
Polygon -11352576 true false 219 172 261 212 231 260 215 250 245 216 215 184
Circle -1 true false 112 41 23
Circle -1 true false 165 40 23
Circle -16777216 true false 119 48 8
Circle -16777216 true false 173 48 8
Polygon -7566196 true true 149 11 115 33 87 59 31 69 11 119 35 125 49 89 85 83 75 133 81 179 39 215 65 263 87 259 61 215 83 193 87 209 127 223 171 223 211 211 217 185 239 215 209 249 231 263 263 209 217 169 225 131 215 73 251 85 263 115 287 115 263 63 207 53 179 25 149 11 149 11

pad
false
0
Polygon -16776961 true false 15 296 35 188 17 118 30 43 51 24 87 19 204 17 229 30 272 23 275 73 266 99 268 185 273 251 256 261 278 298
Polygon -16776961 true false 205 17 260 24 272 251 267 281 209 223
Circle -11352576 true false 51 124 65
Circle -11352576 true false 73 180 120
Circle -16711936 true false 102 39 143
Circle -11352576 true false 172 127 91
Circle -16711936 true false 34 168 74
Circle -16711936 true false 177 207 82
Circle -11352576 true false 46 25 79
Rectangle -16776961 true false 9 13 32 298
Polygon -16776961 true false 42 175 32 204 25 159
Rectangle -16776961 true false 24 13 42 44
Rectangle -16776961 true false 29 13 275 19
Rectangle -16776961 true false 264 13 284 299
Rectangle -16776961 true false 10 296 284 304
Polygon -11352576 true false 111 295 155 295 148 298
Polygon -11352576 true false 110 296 145 298
Polygon -11352576 true false 144 298 115 299 109 295 110 290
Polygon -16776961 true false 102 17 82 22 41 35 35 19 39 15
Polygon -16776961 true false 215 15 271 15 267 29
Polygon -16776961 true false 214 17 240 14 243 23 223 25
Rectangle -16776961 true false 16 18 279 342
Circle -16711936 true false 29 44 119
Circle -11352576 true false 50 138 168
Circle -16711936 true false 170 149 101
Circle -11352576 true false 129 29 123

splash
false
0
Polygon -1 true false 147 119 96 57 55 64 29 69 68 71 110 87
Polygon -1 true false 115 134 56 137 28 166 71 149
Polygon -1 true false 195 131 249 93 271 125 235 128
Polygon -1 true false 169 171 222 187 250 251 215 196
Polygon -1 true false 134 161 78 205 85 260 98 206
Circle -1 true false 111 110 72
Polygon -1 true false 148 110 195 127 207 154 153 183 101 159 111 132

truck
true
0
Rectangle -16777216 true false 45 60 255 196
Polygon -16777216 true false 45 58 75 28 225 28 255 58 235 90 63 90
Rectangle -16711681 true false 77 50 223 60
Rectangle -16777216 true false 121 194 181 216
Rectangle -16777216 true false 121 196 181 228
Rectangle -1 true false 45 224 255 302
Rectangle -7566196 true true 45 224 255 312
Rectangle -1 true false 45 224 253 302
Polygon -7566196 true true 45 196 253 196 253 54 225 26 77 26 43 60
Polygon -7566196 true true 43 60 43 196 75 196 75 56 43 60
Rectangle -16711681 true false 79 40 221 50
Circle -16777216 true false 51 168 20
Circle -16777216 true false 221 168 20
Rectangle -1 true false 203 224 255 312
Polygon -7566196 true true 233 196 255 196 255 56 225 26 245 170 245 190
Rectangle -16711681 true false 79 40 221 56

truck2
true
0
Rectangle -1 true false 45 0 255 282
Rectangle -7566196 true true 45 0 255 282
Rectangle -1 true false 45 0 255 282

turtle
true
0
Circle -11352576 true false 90 52 124
Circle -11352576 true false 90 70 119
Circle -11352576 true false 94 129 112
Polygon -11352576 true false 91 99 93 187 207 187 213 112 91 99
Polygon -7566196 true true 149 14 123 27 126 53 129 57 151 52 174 57 182 28
Polygon -7566196 true true 95 85 51 76 48 101 89 101
Polygon -7566196 true true 93 191 54 212 76 235 99 206
Polygon -7566196 true true 207 88 248 65 257 98
Polygon -7566196 true true 252 96 207 98 208 88 245 84
Polygon -7566196 true true 206 188 250 204 240 233 200 201 206 188
Circle -16777216 true false 133 30 7
Circle -16777216 true false 161 30 6
Line -7566196 true 149 79 149 192
Line -7566196 true 116 89 117 190
Line -7566196 true 190 89 190 184
Line -7566196 true 118 192 190 189
Line -7566196 true 117 89 145 79
Line -7566196 true 151 80 190 93
Line -7566196 true 117 122 148 113
Line -7566196 true 151 113 185 122
Line -7566196 true 119 160 185 158
Line -7566196 true 120 145 146 136
Line -7566196 true 146 136 188 143

@#$#@#$#@
NetLogo 2.0beta5
@#$#@#$#@
startup
@#$#@#$#@
@#$#@#$#@