So we have our model set up, the turtles
are there,

but we haven't written the 'go' code at
all

in order to get the model up and running
in terms of the model actions.

So we're going to start that. We already
have a stub here for 'to go',

and we're just going to do something very
simple,

we going to ask the turtles, if the color
is blue, then act cowardly:

'if (color = blue) [ act-cowardly ]'

because that's what we set it to up in the
setup routine.

And if the color is red, then act bravely;

'if (color = red) [ act-bravely ]'

'act-cowardly' and 'act-bravely' are not
built in NetLogo commands

so when we check it's going to say
'Nothing named ACT-COWARDLY has been defined'

so the next thing we have to do...

oops - almost forgot - we need to add a
'tick' at the end of our 'go'

that tells NetLogo that we're done with
that iteration of the 'go' loop

and it's time to go on to the next one.

What we need to do now is define
'act-cowardly' and 'act-bravely'.

Actually, at this point the model will
run, it's just not going to do anything

as we haven't put anything in these
procedure commands.

So when we hit 'go' you'll see the ticks
run but nothing else happens.

So now we need to define 'act-bravely'
and 'act-cowardly',

Let's start with 'act-bravely' because
that one's a little bit easier.

So what does it mean to act bravely
from the modelling perspective?

'Acting bravely' means to move toward the
mid-point of your friend and your enemy.

One way to think about it is to imagine an
invisible line...

connecting your friend to your enemy,

and you're going to move to the middle of
that line.

The original rules aren't very clear as to
exactly the middle of that line

but the middle makes sense because that
way even as other people move...

you're likely to be there in the middle.

So how can we do this? We can use the 
'facexy' command we looked at last time,

and we can say let's take the x coordinate
of our friend

and add it to the x coordinate of our
enemy, and then divide it by two:

'facexy ([xcor] of friend + [xcor] of enemy) / 2'

and that's going to tell us the x value that's
half way between my friend and my enemy.

because whatever those two x coordinates
are, if I average them I get the mid point.

Then we're going to also at the same time
set the y coordinate to the mid point:

'([ycor] of friend + [ycor] of enemy) / 2'

And then we'll add a move forward:
'fd 0.1'

we could do 'forward 1' but that makes the
animation jerky

so we'll just have it move a little bit
slower.

So that's what it means to act bravely,

and now if you look back at the code and
trace it through

if we have the system set up for 'heroes'
that should work already.

So let's go back over to the interface, 
hit 'setup', hit 'go'...

and sure enough you see some action
going on.

So we've written the 'act-bravely', we've
written the 'setup',

and now we need to write the 
'act-cowardly' command.

So what does this look like?

Cowardly action has the focal agent move
in such a way...

that the friend is between them and the
enemy.

So one way we could think of this is...

we figure out how far away the friend is
away from the enemy,

and then project a point on the other side
of the friend...

that is the point we're going to try and
aim to move towards.

So we're going to move away from the enemy
on the other side of the friend.

We can use this 'facexy' command again,

and the first thing we need to figure out
is where is our friend located...

because we need to move to the other side
of them,

and then we're going to move in such a
way that we're going to move <i>past</i> them...

the distance they are away from the enemy,

So to do that we can take the x coordinate
of the friend,

and subtract off the x coordinate of the
enemy:

'facexy [xcor] of friend + ([xcor] of friend - [xcor] of enemy )'

and this should give us a position on the
other side of the friend.

And then we can do the same thing for the
y coordinate:

'[ycor] of friend + ([ycor] of friend - [ycor] of enemy)'

And once we've done that we just need to
do the 'fd 0.1'

so that we actually move in that direction,
not just face in that direction.

Now we should have all the code we need
up and running to get our model working.

So now we can ask the question,

what <i>is</i> the emergent property when we run
the 'heroes' code,

as opposed to the emergent property when
when we run the 'cowards' code?

So, we hit 'setup' and we select 'heroes',

and as you can see the point quickly
collapses to the middle of the space.

If we select 'cowards' instead, then we
get very different action...

we get this action where everyone is
spread out all over the place.

In fact, this is in a world where we have
wrapping turned on,

so everyone's moving everywhere.

If we go in 'Model Settings' and we turn
wrapping off,

which would be more like the game being
played in a bounded room,

then we get <i>another</i> different, interesting
behaviour,

everyone moves to the edges of the room.

So why is this happening?

If you think about it a little bit, in the
'cowards' case...

you're trying to move as far away as
possible,

and <i>everyone's</i> trying to move as far away
as possible,

so they're moving farther and farther away
from each other,

and as a result they eventually hit the
borders of the room

which is as far as they can get.

In the 'heroes' case, everyone is trying
to move <i>between</i> someone and someone else

and so as everyone tries to do that they
move closer and closer to each other

until they collapse into a ball in the
middle of the room.

So that's the basic idea of the 'Heroes
and Cowards' model.

In the next set of talks, we're going to
talk a bit about extending it,

about some of the things that this model
teaches us,

and about how to document the model.

But at this point you've now created one
of your first models...

so congratulations!