src/appletbots/Agent.java

   1 /*
   2  * Copyright (c) 2002 Erik Rasmussen - All Rights Reserverd
   3  */
   4 package appletbots;
   5
   6 import appletbots.geometry.Vector;
   7
   8 import java.awt.*;
   9 import java.util.ArrayList;
  10 import java.util.List;
  11
  12 /**
  13  * This class represents an Agent in a appletbots world.
  14  *
  15  * @author Erik Rasmussen
  16  */
  17 public abstract class Agent extends WorldObject
  18 {
  19         /**
  20          * The distance the agent can see
  21          */
  22         protected int sight;
  23         /**
  24          * The maximum amount of acceleration for this agent
  25          */
  26         protected double maxAcceleration;
  27         /**
  28          * The world in which the agent exists
  29          */
  30         protected World world;
  31         /**
  32          * The agent's acceleration
  33          */
  34         private Vector acceleration = new Vector(0, 0);
  35
  36         /**
  37          * The color to paint the velocity vector
  38          */
  39         protected Color velocityVectorColor;
  40         /**
  41          * The color to paint the acceleration vector
  42          */
  43         protected Color accelerationVectorColor;
  44
  45         /**
  46          * Constructs a new agent with the following default values:<br>
  47          * size = 5<br>
  48          * sight = 60<br>
  49          * maxSpeed = 5.0<br>
  50          * maxAcceleration = 3.0<br>
  51          */
  52         public Agent()
  53         {
  54                 this(5, 60, 5, 3);
  55         }
  56
  57         /**
  58          * Constructs an agent with the given parameters
  59          *
  60          * @param size            The agent's radius
  61          * @param sight           The distance the agent can see
  62          * @param maxSpeed        The maximum speed the agent can travel
  63          * @param maxAcceleration The maximum acceleration for this agent
  64          */
  65         public Agent(final int size, final int sight, final double maxSpeed, final double maxAcceleration)
  66         {
  67                 super(size, maxSpeed, size, Color.white);
  68                 this.sight = sight;
  69                 this.maxAcceleration = maxAcceleration;
  70         }
  71
  72         /**
  73          * Returns the distance this agent can see
  74          *
  75          * @return The distance this agent can see
  76          */
  77         public int getSight()
  78         {
  79                 return sight;
  80         }
  81
  82         /**
  83          * Tells the agent what world he is in.  This is called by
  84          * World.addAgent().
  85          *
  86          * @param world The world the agent exists in
  87          */
  88         public void setWorld(final World world)
  89         {
  90                 this.world = world;
  91         }
  92
  93         /**
  94          * Returns a random acceleration vector
  95          *
  96          * @return A random acceleration vector
  97          */
  98         public final Vector getRandomAcceleration()
  99         {
 100                 return Vector.getRandom(Math.random() * maxAcceleration);
 101         }
 102
 103         /**
 104          * Returns the agent's acceleration.  Note that the vector returned is a
 105          * clone of the internal object, so changing the returned vector will not
 106          * affect the agent's acceleration.  To modify the agent's acceleration,
 107          * use setAcceleration(Vector).
 108          *
 109          * @return The agent's acceleration
 110          */
 111         public Vector getAcceleration()
 112         {
 113                 return (Vector) acceleration.clone();
 114         }
 115
 116         /**
 117          * Sets the agent's acceleration vector.  If the given vector has a
 118          * magnitude greater than the agent's maxAcceleration, then the vector is
 119          * scaled down to the maxAcceleration.
 120          *
 121          * @param acceleration The agent's acceleration
 122          */
 123         protected void setAcceleration(final Vector acceleration)
 124         {
 125                 this.acceleration = (Vector) acceleration.clone();
 126                 if (this.acceleration.getLength() > maxAcceleration)
 127                         this.acceleration = this.acceleration.setLength(maxAcceleration);
 128         }
 129
 130         /**
 131          * Returns the agent's maximum acceleration
 132          *
 133          * @return The agent's maximum acceleration
 134          */
 135         public double getMaxAcceleration()
 136         {
 137                 return maxAcceleration;
 138         }
 139
 140         /**
 141          * Returns an array of vectors that should be drawn at the time this agent
 142          * is painted
 143          *
 144          * @return An array of vectors that should be drawn at the time this agent
 145          *         is painted
 146          */
 147         public VectorToDraw[] getVectorsToDraw()
 148         {
 149                 final List vectorsToDraw = new ArrayList();
 150                 if (accelerationVectorColor != null)
 151                         vectorsToDraw.add(new VectorToDraw(getAcceleration().multiply(size), accelerationVectorColor));
 152                 if (velocityVectorColor != null)
 153                         vectorsToDraw.add(new VectorToDraw(world.getVelocity(this).multiply(size), velocityVectorColor));
 154                 final VectorToDraw[] vectorsToDrawArray = new VectorToDraw[vectorsToDraw.size()];
 155                 for (int i = 0; i < vectorsToDraw.size(); i++)
 156                         vectorsToDrawArray[i] = (VectorToDraw) vectorsToDraw.get(i);
 157                 return vectorsToDrawArray;
 158         }
 159
 160         /**
 161          * Sets a flag to let the agent know whether or not to draw his
 162          * acceleration vector
 163          *
 164          * @param showAcceleration Whether or not to draw the acceleration vector
 165          */
 166         public void setShowAcceleration(final boolean showAcceleration)
 167         {
 168                 accelerationVectorColor = showAcceleration ? Color.magenta : null;
 169         }
 170
 171         /**
 172          * Returns whether or not the agent's acceleration vector will be drawn
 173          *
 174          * @return Whether or not the agent's acceleration vector will be drawn
 175          */
 176         public boolean getShowAcceleration()
 177         {
 178                 return accelerationVectorColor != null;
 179         }
 180
 181         /**
 182          * Sets a flag to let the agent know whether or not to draw his velocity
 183          * vector
 184          *
 185          * @param showVelocity Whether or not to draw the velocity vector
 186          */
 187         public void setShowVelocity(final boolean showVelocity)
 188         {
 189                 velocityVectorColor = showVelocity ? Color.orange : null;
 190         }
 191
 192         /**
 193          * Returns whether or not the agent's velocity vector will be drawn
 194          *
 195          * @return Whether or not the agent's velocity vector will be drawn
 196          */
 197         public boolean getShowVelocity()
 198         {
 199                 return velocityVectorColor != null;
 200         }
 201
 202         /**
 203          * The method invoked to allow the agent to observe the world and
 204          * optionally modify his acceleration to try to achieve a goal.
 205          */
 206         public abstract void observeWorld();
 207 }