Problem Solving with Data Structures using Java: A Multimedia Approach

1
Problem Solving with Data Structures using Java
A Multimedia Approach

• Chapter 15 Introducing UML and Continuous
  Simulations

2
Chapter Objectives
3
A simulation is an executed model

• Setting up a simulation is a process of modeling
  the world (real or fantasy) to be simulated.
• A Greenfoot world is a simulation.
• That model is realized in terms of objects.
• Some of our modeling techniques
• Aggregation
• Generalization and specialization
• We use the same modeling techniques in all
  object-oriented programming!
• Its all simulation.

4
Aggregation

• Some objects are made up of other objects.
• Cars have engines
• People have livers and lungs
• These internal things are objects, too!
• Livers dont directly mess with the innards of
  lungs!
• We call this aggregation
• Putting references to some objects inside of
  other objects.

5
Generalization and Specialization

• There are general and specialized forms of real
  world objects.
• Cells are biological objects that have membranes
  and a nucleus and mitochondria and
• Blood, lung, and liver cells are all cells but
  have specialized functions.
• The superclass-subclass relationship is a way of
  modeling general forms of objects and specialized
  forms of objects

6
Making it concreteWolves eating deer
7
Running the simulation

• Welcome to DrJava.
• gt run WolfDeerSimulation
• gtgtgt Timestep 0
• Wolves left 5
• Deer left 20
• gtgtgt Timestep 1
• Wolves left 5
• Deer left 20
• ltSIGH!gt A deer died...
• gtgtgt Timestep 2
• Wolves left 5
• Deer left 19
• gtgtgt Timestep 3
• Wolves left 5
• Deer left 19
• ltSIGH!gt A deer died...
• gtgtgt Timestep 4
• Wolves left 5
• Deer left 18

8
An Example Simulation

• The WolfDeerSimulation is a continuous
  simulation.
• Each moment in time is simulated.
• It has no resources.
• It is a predator-prey simulation
• A common real world (ecological) situation.
• There are parameters to change to explore under
  what conditions predators and prey survive and in
  what numbers.

9
The Model of this Simulation
WolfDeerSimulation Knows the list of wolves and
deer KnowsHow to run() each moment in time
Turtle
LLNode
AgentNode Knows its turtle (agent) KnowsHow to
get/set agent, to remove an agent
Wolf KnowsHow to act(), and to find the closest
deer.
Deer KnowsHow to act() and die
10
Complicated Set of Relationships in this Model

• Wolf and Deer are kinds of Turtle
• Specializations of Turtle
• AgentNode is a kind of LLNode
• AgentNodes each have one Turtle (Wolf or Deer)
  inside it.
• WolfDeerSimulation has two AgentNodes for the
  lists of live wolves and deer.
• Each Wolf and Deer knows what simulation its in.

11
A UML Class Diagram
12
Unified Modeling Language (UML)

• This is a UML class diagram.
• A graphical notation for describing the
  relationships between classes in a model.
• UML is a standard that describes several
  different kinds of diagrams.
• Collaboration diagrams How objects work together
  and how they call on one another.
• Sequence diagrams What the order of events are
  in an object system.

13
A class in a UML class diagram
Name of the class
Instance variables or fields What the class
instances know - means private.
Operations or methods What the instances know
how means public
14
Generalization-specialization relationships
A Deer is a subclass of Turtle Its a
specialization of Turtle
15
Association or Reference Relation
A Wolf knows its WolfDeerSimulation, through the
field mySim. Each wolf is in only 1 simulation A
WolfDeerSimulation has a list of wolves. 0
to infinite (many)
16
A Class Diagram describes the Model, without the
Code
17
WolfDeerSimulation

• public class WolfDeerSimulation
• / Linked lists for tracking wolves and deer /
• private AgentNode wolves
• private AgentNode deer
• / Accessors for wolves and deer /
• public AgentNode getWolves()return wolves
• public AgentNode getDeer()return deer

Why private? Only the simulation should know its
wolves and deer.
18
The main run() method

• public void run()
• World w new World()
• w.setAutoRepaint(false)
• // Start the lists
• wolves new AgentNode()
• deer new AgentNode()
• // create some deer
• int numDeer 20
• for (int i 0 i lt numDeer i)
• deer.add(new AgentNode(new Deer(w,this)))

We want to control when the world updates itself.
AgentNodes contain the Deer
19
Head and Rest

• Wolves and deer are AgentNodesbut the real
  content starts at getNext().
• We call this the head of the list.
• Its a placeholder.
• We call the rest the rest or body of the list.
• This makes it possible to remove a node, even if
  its the first one in the list.

wolves
Head getNext
Rest getNext
Rest getNext
Rest getNext
20
Make some wolves

• // create some wolves
• int numWolves 5
• for (int i 0 i lt numWolves i)
• wolves.add(new AgentNode(new
  Wolf(w,this)))

21
Start our simulation loop

• // declare a wolf and deer
• Wolf currentWolf null
• Deer currentDeer null
• AgentNode currentNode null
• // loop for a set number of timesteps (50
  here)
• for (int t 0 t lt 50 t)
• // loop through all the wolves
• currentNode (AgentNode) wolves.getNext()
• while (currentNode ! null)
• currentWolf (Wolf) currentNode.getAgent(
  )
• currentWolf.act()
• currentNode (AgentNode)
  currentNode.getNext()

Whats going on here? Its our AgentNodes that
are in a linked list. Each one of them contains
(aggregation!) a Wolf. Have to pull the Wolf out
to get it to act()
22
Give the deer a chance to act

• // loop through all the deer
• currentNode (AgentNode) deer.getNext()
• while (currentNode ! null)
• currentDeer (Deer) currentNode.getAgent(
  )
• currentDeer.act()
• currentNode (AgentNode)
  currentNode.getNext()

Same unpackaging going on here.
23
Show us what happened

• // repaint the world to show the movement
• w.repaint()
• // Let's figure out where we stand...
• System.out.println("gtgtgt Timestep "t)
• System.out.println("Wolves left
  "wolves.getNext().count())
• System.out.println("Deer left
  "deer.getNext().count())
• // Wait for one second
• //Thread.sleep(1000)

Does the simulation go too fast? Could make the
thread of execution sleep for 1000 milliseconds,
but would have to add some exception handling.
24
Implementing a Wolf

• import java.awt.Color
• import java.util.Random
• import java.util.Iterator
• /
• Class that represents a wolf. The wolf class
• tracks all the living wolves with a linked
  list.
• _at_author Barb Ericson ericson_at_cc.gatech.edu
• /
• public class Wolf extends Turtle
• /////////////// fields //////////////////////
• / class constant for the color /
• private static final Color GRAY new
  Color(153,153,153)
• / class constant for probability of NOT
  turning /
• protected static final double PROB_OF_STAY
  1.0/10

A final is something that wont change A
constant. Its used to make code more readable
yet easy-to-change. Private vs. Protected? Use
Protected if your subclasses will need to access
(new kinds of wolves?)
Constants are typically all-caps
25
More Wolf fields

• / class constant for top speed (max num steps
  can move in a timestep) /
• protected static final int MAX_SPEED 60
• / My simulation /
• protected WolfDeerSimulation mySim
• / random number generator /
• protected static Random randNumGen new
  Random()

Currently final. Did you want to make it
variable? Do wolves get slower as they get hungry?
There is more than one kind of random. Treating
it as an object makes it easier to have different
kinds later.
26
Constructors

• ////////////////////////////// Constructors
  ////////////////////////
• /
• Constructor that takes the model display
  (the original
• position will be randomly assigned)
• _at_param modelDisplayer thing that displays
  the model
• _at_param mySim my simulation
• /
• public Wolf (ModelDisplay modelDisplayer,WolfDee
  rSimulation thisSim)
• super(randNumGen.nextInt(modelDisplayer.getWid
  th()),
• randNumGen.nextInt(modelDisplayer.getHei
  ght()),
• modelDisplayer)
• init(thisSim)
• / Constructor that takes the x and y and a
  model
• display to draw it on
• _at_param x the starting x position

Remember that a constructor must match its
superclass, if you want to use super(). These
are like the ones in Turtle.
Whats a ModelDisplay? The abstract superclass of
the World.
27
Using a RandomPseudoRandom Number Generator
28
Initialize a Wolf

• ////////////////// methods //////////////////////
  //////////////////
• /
• Method to initialize the new wolf object
• /
• public void init(WolfDeerSimulation thisSim)
• // set the color of this wolf
• setColor(GRAY)
• // turn some random direction
• this.turn(randNumGen.nextInt(360))
• // set my simulation
• mySim thisSim

Get an integer at most 360
29
Is there a Deer to eat?

• public AgentNode getClosest(double
  distance,AgentNode list)
• // get the head of the deer linked list
• AgentNode head list
• AgentNode curr head
• AgentNode closest null
• Deer thisDeer
• double closestDistance 0
• double currDistance 0
• // loop through the linked list looking for
  the closest deer
• while (curr ! null)
• thisDeer (Deer) curr.getAgent()
• currDistance thisDeer.getDistance(
  this.getXPos(),this.getYPos())
• if (currDistance lt distance)
• if (closest null currDistance lt
  closestDistance)

Walk this through in English to see that its
doing what you think it should.
is OR
30
Modeling what a Wolf does

• /
• Method to act during a time step
• pick a random direction and move some random
  amount up to top speed
• /
• public void act()
• // get the closest deer within some specified
  distance
• AgentNode closeDeer getClosest(30,
• (AgentNode)
  mySim.getDeer().getNext())
• if (closeDeer ! null)
• Deer thisDeer (Deer) closeDeer.getAgent()
  
• this.moveTo(thisDeer.getXPos(),
• thisDeer.getYPos())
• thisDeer.die()

Why getNext()? Because we need the body of the
list, and thats after the head.
getClosest returns an AgentNode, so we have to
get the Deer out of it with getAgent()
31
If cant eat, then move

• else
• // if the random number is gt prob of NOT
  turning then turn
• if (randNumGen.nextFloat() gt PROB_OF_STAY)
• this.turn(randNumGen.nextInt(360))
• // go forward some random amount
• forward(randNumGen.nextInt(MAX_SPEED))

Get a random integer at most 360. Then at most
MAX_SPEED
32
Deer

• import java.awt.Color
• import java.util.Random
• /
• Class that represents a deer. The deer class
• tracks all living deer with a linked list.
• _at_author Barb Ericson ericson_at_cc.gatech.edu
• /
• public class Deer extends Turtle
• /////////////// fields //////////////////////
• / class constant for the color /
• private static final Color BROWN new
  Color(116,64,35)
• / class constant for probability of NOT
  turning /
• private static final double PROB_OF_STAY
  1.0/5

33
Deer fields (instance variables)

• / class constant for top speed (max num steps
  can move in a timestep) /
• private static final int MAX_SPEED 50
• / random number generator /
• private static Random randNumGen new
  Random()
• / the simulation I'm in /
• private WolfDeerSimulation mySim

34
DeerConstructors

• ////////////////////////////// Constructors
  ////////////////////////
• /
• Constructor that takes the model display
  (the original
• position will be randomally assigned
• _at_param modelDisplayer thing which will
  display the model
• /
• public Deer (ModelDisplay modelDisplayer,WolfDee
  rSimulation thisSim)
• super(randNumGen.nextInt(modelDisplayer.getWid
  th()),
• randNumGen.nextInt(modelDisplayer.getHei
  ght()),
• modelDisplayer)
• init(thisSim)
• / Constructor that takes the x and y and a
  model
• display to draw it on
• _at_param x the starting x position
• _at_param y the starting y position

Nothing new here
35
Initializing a Deer

• /
• Method to initialize the new deer object
• /
• public void init(WolfDeerSimulation thisSim)
• // set the color of this deer
• setColor(BROWN)
• // turn some random direction
• this.turn(randNumGen.nextInt(360))
• // know my simulation
• mySim thisSim

Nothing new here
36
What Deer Do

• /
• Method to act during a time step
• pick a random direction and move some random
  amount up to top speed
• /
• public void act()
• // if the random number is gt prob of NOT
  turning then turn
• if (randNumGen.nextFloat() gt PROB_OF_STAY)
• this.turn(randNumGen.nextInt(360))
• // go forward some random amount
• forward(randNumGen.nextInt(MAX_SPEED))

Nothing new here
37
When Deer Die

• /
• Method that handles when a deer dies
• /
• public void die()
• // Leave a mark on the world where I died...
• this.setBodyColor(Color.red)
• // Remove me from the "live" list
• mySim.getDeer().remove(this)
• // ask the model display to remove this
• // Think of this as "ask the viewable world
  to remove this turtle"
• //getModelDisplay().remove(this)
• System.out.println("ltSIGH!gt A deer died...")

Why dont we have to say getNext() before the
remove()?
If you want the body and its trail to disappear
38
AgentNodes

• AgentNodes contain Turtles
• Thats aggregation
• Its a subclass of LLNode
• Its a specialization of LLNode

39
AgentNode implementation

• /
• Class to implement a linked list of
  Turtle-like characters.
• (Maybe "agents"?)
• /
• public class AgentNode extends LLNode
• /
• The Turtle being held
• /
• private Turtle myTurtle

40
AgentNode constructors

• / Two constructors One for creating the head
  of the list
• , with no agent
• /
• public AgentNode() super()
• /
• One constructor for creating a node with an
  agent
• /
• public AgentNode(Turtle agent)
• super()
• this.setAgent(agent)

41
AgentNode getter/setter

• /
• Setter for the turtle
• /
• public void setAgent(Turtle agent)
• myTurtle agent
• /
• Getter for the turtle
• /
• public Turtle getAgent()return myTurtle

42
AgentNode Remove node where Turtle is found

• /
• Remove the node where this turtle is found.
• /
• public void remove(Turtle myTurtle)
• // Assume we're calling on the head
• AgentNode head this
• AgentNode current (AgentNode)
  this.getNext()
• while (current ! null)
• if (current.getAgent() myTurtle)
• // If found the turtle, remove that node
• head.remove(current)
• current (AgentNode) current.getNext()

Its just like other linked list removes, but now
were looking for the node that contains the
input turtle.
43
Think about it

• What if AgentNodes contained Objects?
• Object is a class that is the superclass of all
  classes (even if not explicitly extended).
• AgentNodes that contain Objects could be general
  linked lists that contain anything
• Just cast things as you need them as you pull
  them out.

44
Back to the simulationWhat might we change?

• Wolves that arent always hungry?
• Having wolves that chase deer?Have deer run from
  wolves?
• And how do we look at the results?

Well deal with hunger first, then with
comparing, then with running towards/away.
45
Creating a Hungry Wolf

• /
• A class that extends the Wolf to have a Hunger
  level.
• Wolves only eat when they're hungry
• /
• public class HungryWolf extends Wolf
• /
• Number of cycles before I'll eat again
• /
• private int satisfied
• / class constant for number of turns before
  hungry /
• private static final int MAX_SATISFIED 3

46
Need tomatch

• /
• Constructor that takes the model display
  (the original
• position will be randomly assigned)
• _at_param modelDisplayer thing that displays
  the model
• _at_param mySim my simulation
• /
• public HungryWolf (ModelDisplay
  modelDisplayer,WolfDeerSimulation thisSim)
• super(modelDisplayer,thisSim)
• / Constructor that takes the x and y and a
  model
• display to draw it on
• _at_param x the starting x position
• _at_param y the starting y position
• _at_param modelDisplayer the thing that
  displays the model
• _at_param mySim my simulation
• /
• public HungryWolf (int x, int y, ModelDisplay
  modelDisplayer,

47
Initializing a HungryWolf

• /
• Method to initialize the hungry wolf object
• /
• public void init(WolfDeerSimulation thisSim)
• super.init(thisSim)
• satisfied MAX_SATISFIED

48
What a HungryWolf does

• /
• Method to act during a time step
• pick a random direction and move some random
  amount up to top speed
• /
• public void act()
• // Decrease satisfied time, until hungry
  again
• satisfied--
• // get the closest deer within some specified
  distance
• AgentNode closeDeer getClosest(30,
• (AgentNode)
  mySim.getDeer().getNext())
• if (closeDeer ! null)
• // Even if deer close, only eat it if
  you're hungry.
• if (satisfied lt 0)
• Deer thisDeer (Deer) closeDeer.getAgent()
  
• this.moveTo(thisDeer.getXPos(),
• thisDeer.getYPos())

If there is a Deer near, then check if youre
hungry, and only theneat and get full
49
And if no Deer are near

• else
• // if the randome number is gt prob of
  turning then turn
• if (randNumGen.nextFloat() gt PROB_OF_TURN)
• this.turn(randNumGen.nextInt(360))
• // go forward some random amount
• forward(randNumGen.nextInt(maxSpeed))

Nothing new here
50
Changing the Simulation to make HungryWolves (in
run())

• // create some wolves
• int numWolves 5
• for (int i 0 i lt numWolves i)
• wolves.add(new AgentNode(new
  HungryWolf(w,this)))

Everything else just works, because HungryWolf is
a kind of Wolf
51
Writing to a Text File

• We have to create a stream that allows us access
  to a file.
• Were going to want to write strings to it.
• Were going to have to handle things going
  wrongexceptional events like the filename being
  wrong or the disk failing.
• Heres how

52
Input and Output Streams - java.io

• Java handles input and output through sequential
  streams of bits
• Programs can read from a stream or write to a
  stream

Source or Destination
Program
100110
Byte Data Character Data
File
String
Array
53
Standard Input and Output

• We have been using System.out.println to print
  output to a PrintStream (standard output).
• System.out.println(First Name firstName)
• There is also a System.err PrintStream that can
  be used to write to the standard error output.
• System.err.println(Error no file name given)
• You can use System.in to read a byte or bytes
  from an InputStream (standard input).
• int numGrades System.in.read()

54
Chaining Input and Output Classes

• Often input or output classes are chained
• Passing one type of input/output class to the
  constructor for another
• One common thing is to chain a processing class
  with a data sink class
• Like a BufferedReader or BufferedWriter and a
  FileReader or FileWriter
• new BufferedReader(new FileReader(fileName))

55
Exceptions

• Exceptions are disruptions in the normal flow of
  a program. Exception is short for exceptional
  event.
• The programmer is required to handle checked
  exceptions in Java
• like trying to read from a file that doesnt
  exist
• Run-time exceptions do not have to be handled by
  the programmer
• like trying to invoke a method on a object
  reference that is null
• Children of RuntimeException

56
Try and Catch

• Use a try catch clause to catch an exception
• try
• code that can cause exceptions
• catch (ExceptionClassName varName)
• code to handle the exception
• catch (ExceptionClassName varName)
• code to handle the exception
• You can catch several exceptions
• Make the most general one last
• All exceptions are children of the class Exception

57
Try and Catch If the file isnt there

• What if you want to know if a file isnt found
• That you are trying to read from
• If this occurs you might want to use a
  JFileChooser to let the user pick the file
• You also want to handle any other error
• try
• code that can cause the exception
• catch (FileNotFoundException ex)
• code to handle when the file isnt found
• catch (Exception ex)
• code to handle the exception

58
Catching Exceptions

• A catch clause will catch the given Exception
  class and any subclasses of it.
• So to catch all exceptions use
• try
• code that can throw the exception
• catch (Exception e)
• System.err.println(Exception
  e.getMessage())
• System.err.println(Stack Trace is)
• e.printStackTrace()
• You can create your own exceptions by subclassing
  Exception or a child of Exception.

You can print the error message and the stack
trace (the list of all currently running methods)
59
The optional finally clause

• A try and catch statement can have a finally
  clause
• Which will always be executed
• Will happen if no exceptions
• Will happen even if exceptions occur
• try
• code that can cause the exception
• catch (FileNotFoundException ex)
• code to handle when the file isnt found
• finally
• code to always be executed

60
Writing to a File

• Use a try-catch clause to catch exceptions
• Create a buffered writer from a file writer
• writer new BufferedWriter(new
  FileWriter(fileName))
• Write the data
• writer.write(data)
• Close the buffered writer
• writer.close()

61
Reading Lines of Character Data

• Enclose the code in a try and catch clause
• Catch FileNotFoundException if the file doesnt
  exist
• And you may want to give the user a chance to
  specify a new file
• Catch Exception to handle all other errors
• Create a buffered reader from a file reader for
  more efficient reading
• File names are relative to the current directory
• Loop reading lines from the buffered reader until
  the line is null
• Do something with the data
• Close the buffered reader

62
Reading from File Example

• BufferedReader reader null
• String line null
• // try to read the file
• try
• // create the buffered reader
• reader new BufferedReader(new
  FileReader(fileName))
• // loop reading lines till the line is null
  (end of file)
• while ((line reader.readLine()) ! null)
• // do something with the line
• // close the buffered reader
• reader.close()
• catch (Exception ex)

63
Adding an Output File to WolfDeerSimulation

• / A BufferedWriter for writing to /
• public BufferedWriter output
• /
• Constructor to set output to null
• /
• public WolfDeerSimulation()
• output null

64
Opening the File

• /
• Open the input file and set the
  BufferedWriter to speak to it.
• /
• public void openFile(String filename)
• // Try to open the file
• try
• // create a writer
• output new BufferedWriter(new
  FileWriter(filename))
• catch (Exception ex)
• System.out.println("Trouble opening the
  file " filename)
• // If any problem, make it null again
• output null

65
Changing the time loop

• // Let's figure out where we stand...
• System.out.println("gtgtgt Timestep "t)
• System.out.println("Wolves left
  "wolves.getNext().count())
• System.out.println("Deer left
  "deer.getNext().count())
• // If we have an open file, write the
  counts to it
• if (output ! null)
• // Try it
• try
• output.write(wolves.getNext().count()"\
  t"deer.getNext().count())
• output.newLine()
• catch (Exception ex)
• System.out.println("Couldn't write the
  data!")
• System.out.println(ex.getMessage())
• // Make output null so that we don't
  keep trying
• output null

66
After the timing loop

• // If we have an open file, close it and null
  the variable
• if (output ! null)
• try
• output.close()
• catch (Exception ex)
• System.out.println("Something went wrong
  closing the file")
• finally
• // No matter what, mark the file as
  not-there
• output null

67
Running the Simulation with a File

• Welcome to DrJava.
• gt WolfDeerSimulation wds new WolfDeerSimulation(
  )
• gt wds.openFile("D/cs1316/wds-run1.txt")
• gt wds.run()

68
Finding the file in Excel
69
Adding Labels for the Chart
70
Making Wolves and Deer Run

• What we do
• In Deer, if there is a Wolf within our smelling
  range, run in the opposite direction (turn
  towards, turn 180, move)
• In Wolf, if there is a Deer within our smelling
  range, run towards it.
• (Stays the same) If the Wolf gets close enough,
  gobble up the Deer.
• (Stays the same) For both, otherwise, wander
  aimlessly.

71
New constants for Deer

• / class constant for probability of NOT
  turning /
• private static final double PROB_OF_STAY 1/5
• / class constant for how far deer can smell
  /
• private static final double SMELL_RANGE 50
• / class constant for top speed (max num steps
  can move in a timestep) /
• private static final int maxSpeed 30

72
Deer-finding closest Wolf

• /
• Method to get the closest wolf within the
  passed distance
• to this deer. We'll search the input list of
  the kind
• of objects to compare to.
• /
• public AgentNode getClosest(double
  distance,AgentNode list)
• // get the head of the deer linked list
• AgentNode head list
• AgentNode curr head
• AgentNode closest null
• Wolf thisWolf
• double closestDistance 0
• double currDistance 0
• // loop through the linked list looking for
  the closest deer
• while (curr ! null)

Strikingly similar to Wolfs for find Deer, no?
73
Deer new act()

• /
• Method to act during a time step
• pick a random direction and move some random
  amount up to top speed
• /
• public void act()
• // get the closest wolf within the smell
  range
• AgentNode closeWolf getClosest(SMELL_RANGE,
• (AgentNode)
  mySim.getWolves().getNext())
• if (closeWolf ! null)
• Wolf thisWolf (Wolf) closeWolf.getAgent()
  
• // Turn to face the wolf
• this.turnToFace(thisWolf)
• // Now directly in the opposite direction
• this.turn(180)
• // How far to run? How about half of max
  speed??
• this.forward((int) (maxSpeed/2))

Does this match the English description we had a
few slides back?
Think about this in terms of the values that can
be changed and their relative values.
74
Wolf Constants

• / class constant for probability of NOT
  turning /
• protected static final double PROB_OF_STAY
  1/10
• / class constant for top speed (max num steps
  can move in a timestep) /
• protected static final int maxSpeed 40
• / class constant for how far wolf can smell
  /
• private static final double SMELL_RANGE 50
• / class constant for how close before wolf
  can attack /
• private static final double ATTACK_RANGE 30

75
How Wolfs smell deer

• /
• Method to act during a time step
• pick a random direction and move some random
  amount up to top speed
• /
• public void act()
• // get the closest deer within smelling range
• AgentNode closeDeer getClosest(SMELL_RANGE,
• (AgentNode)
  mySim.getDeer().getNext())
• if (closeDeer ! null)
• Deer thisDeer (Deer) closeDeer.getAgent()
  
• // Turn torward deer
• this.turnToFace(thisDeer)
• // How much to move? How about minimum of
  maxSpeed
• // or distance to deer?
• this.forward((int) Math.min(maxSpeed,
• thisDeer.getDistance(this.getXP
  os(),this.getYPos())))

76
The rest of normal Wolf actions

• // get the closest deer within the attack
  distance
• closeDeer getClosest(ATTACK_RANGE,
• (AgentNode)
  mySim.getDeer().getNext())
• if (closeDeer ! null)
• Deer thisDeer (Deer) closeDeer.getAgent()
  
• this.moveTo(thisDeer.getXPos(),
• thisDeer.getYPos())
• thisDeer.die()
• else // Otherwise, wander aimlessly
• // if the randome number is gt prob of NOT
  turning then turn
• if (randNumGen.nextFloat() gt PROB_OF_STAY)
• this.turn(randNumGen.nextInt(360))

77
Changes to WolfDeerSimulationNOTHING!

• We have the same interface as we used to have, so
  nothing changes in WolfDeerSimulation.
• Very powerful idea
• If changes to a class keep the interface the
  same, then all users of the class dont have to
  change at all.

78
Running the new simulation

• Welcome to DrJava.
• gt WolfDeerSimulation wds new WolfDeerSimulation(
  )
• gt wds.openFile("D/cs1316/wds-chase.txt")
• gt wds.run()

79
Explorations

• What does the relative speed of Deer and Wolves
  matter?
• Does it matter if Deer go faster? Wolves?
• What if Deer and Wolves can smell farther away?
• What if one can smell better than the other?
• Whats the effect of having more Deer or more
  Wolves?
• What if HungryWolves could starve (say at -10
  satisfaction)? Do more deer live?

80
Doing More Simulations

• How much code would be in common in every
  simulation wed build?
• We already have lots of duplication, e.g.,
  getClosest.
• Goal Can we make an Agent/Actor class and
  Simulation class that wed subclass with very
  little additional code to create new simulations?