Now that we've gone over all the major
components of the NetLogo interface

and how to create basic models,

we're actually going to create our very
first model.

And for this we're going to use a model of
a game that's quite interesting,

it talks a little bit about emergent
properties as well,

that's why we're going to start with
this one.

The game is called 'Heroes and Cowards',

at least that's what Uri Wilensky and I
call it.

It was used by the Fratelli Theatre Group
in the 1980s and 1990s

to explore emergent phenomena

and was presented at a conference called
'Embracing Complexity' in 1999.

Normally, to play the game you need a
group of people

and you have people actually act it out.

Here on the screen you can see a couple
of examples of that.

I'm hoping to get some video that I can
link to later

to show some examples of how the game is
actually played.

But it's a very simple game.

You get a group of people together...

and essentially you have everyone choose an
enemy and a friend randomly from the group

and then there are two stages to the game.

In the first stage, you're going to place
your friend between you and your enemy,

that's called the 'cowards' stage,

because you're trying to use your friend
to shield you from the enemy.

In the second stage, you're going to place
yourself between your friend and your enemy

and that's called the 'heroes' stage,

because you're trying to protect your
friend from your enemy.

What's interesting about this, as we'll
see as we build this model,

is that this creates <i>very</i> different
patterns of behaviour,

even though the rules are <i>almost</i> identical
between the 'heroes' and 'cowards' phases

the outcomes are quite dramatically
different.

So we're going to explore that.

But you don't really need to <i>know</i> the
emergent outcomes to build the model.

So let's build the model first, and then
we'll explore the outcomes.

So we're going to start building our model

The first thing we know we need to do is
to get some turtles in the world,

so let's go over to the code tab...

and we'll start creating a place for the
turtles to come in.

So we can do this by writing the stubs
that I always write right off the bat

'to setup' and 'to go'.

Then for the 'setup', the first command we
almost always have is 'clear-all',

as we talked about, which starts the model
over again

and destroys any variables and turtles
that are there.

And the last command in 'setup' is almost
always 'reset-ticks'

which we discussed, which resets the tick
counter back to zero

and tells NetLogo to start the tick
counter running.

Then one thing I often do, depending on
the the way I'm doing it,

is I ask the patches to set their patch
colour to white:

'ask patches [ set pcolor white ]'

This just creates a blank slate for the
world to exist in,

also it's easier to print the image of
turtles on a white background

than it is turtles on a black background.

So if you're printing out the results,
it's easier to have a white background.

I like to start to comment my code as I'm
writing it,

so I'm going to write a comment here that
this is a blank background:

';; blank background'

Then the next thing I'm going to do is
I'm going to create a set of turtles:

'create-turtles 100'

And I don't like to go too far before I
check to make sure my code is right,

so I'll hit the <i>check</i> tab to check the
syntax... everything seems ok...

I'll go back to the interface and I'll
type the word 'setup'

and it seems like it's doing what I expect
it to do at this point.

I could do some more in-depth debugging,

but this is a good place to add some more
code.

One thing I'm going to want to do right
away is to add some buttons...

so I'll add a button for 'setup'...

and I'll add a button for 'go', and we
want to make this a 'Forever' button,

so I'll click that 'Forever' button in
the button editor.

Now if I hit 'setup' I can run that code
again and again.

We're not quite done with the setup
code,

if you think about it from the perspective
of the 'Heroes and Cowards' model...

we want to create a bunch of agents
that are roaming around a space

and so the first thing we've got to do is
give them an initial place to exist,

and so we're going to set their x,y
coordinates to random x and y to start:

'setxy random-xcor random-ycor'

Now, we can see the model creates them
in random locations.

One other thing we mentioned is that there
are going to be two phases

there's going to be a 'Heroes' phase and
a 'Cowards' phase,

and so at this point we can think about
what those two phases might look like.

One way that we can easily do this is to
have the turtles change color

to indicate what phase they're in.

By doing that we have a more visual
representation of what is going on

So we're going to set what we're going to
call the turtles' <i>personalites</i>,

which is whether they are a hero or a
coward

and we're going to do that based on a
<i>chooser</i>, which we haven't created yet

we're just going to call it
'personalities'

it's going to be the global variable that
controls this,

and we're going to check if 
personalities equals "cowards"...

then we're going to set the
color to blue:

'if ( personalities = "cowards" ) [ set color blue ]'

and if personalities equals "heroes", we
will set the color to red:

'if ( personalities = "heroes" ) [ set color red ]'

If we check the syntax now, it will tell
nothing named 'personalities' is defined

and that's correct...

often we start creating code before we've
created all the variables to back it up.

So we can go over to the interface tab

and create a chooser for 'personalities'

So I'll name it 'personalities'

and we'll give it the choices of either
"cowards" or "heroes",

which is what we're checking for in our
code.

So now if we go back to the code, 'check'
will say OK.

And we can see if this works, because we
know that if we set it to "cowards"

then the turtles should set their color to
blue.

So we do that, and sure enough, it sets
the turtles color to blue,

and if we change it to "heroes" and we 
hit 'setup',

it sets the turtles color to red.

So that seems to be working correctly.

Now the last thing we should do - if you
remember the initial startup phase -

is we need each of the turtles or players
to choose a friend and an enemy.

So we can have them choose their friend
and enemy in the group.

There are some quick ways to do this.

We can have them set their friend to one
of the other turtles:

'set friend one-of other turtles'

and 'set enemy one-of other turtles'

So we're just choosing randomly.

You'll notice when I hit 'check' of course
it says nothing named 'FRIEND' is defined,

'friend' and 'enemy' aren't standard
turtle properties,

so we have to go up to the top and add
these in as turtle properties

as we described in the last few lectures:

'turtles-own [ friend enemy ]'

And now when we hit 'setup' they'll be
there.

We can now hit 'setup' again,

nothing appears to have changed, because
these are happening internally,

but what we can do is we can inspect
one of the turtles,

and sure enough, this is turtle 38 that
I'm inspecting

and there are variables 'friend' (turtle 28)
and 'enemy' (turtle 64) that are set up.

So let's pause there now we have the
'setup' routine pretty much done

and we'll start on how to make this model
actually work in the next talk.