SE450: Model [2015/10/13]

Package documentation: myproject.model [private] myproject.util [private]

file:MP.java [source] [doc-public] [doc-private]

package myproject.model;

/**
 * Static class for model parameters.
 */
public class MP {
  private MP() {}
  /** Length of cars, in meters */
  public static double carLength = 10;
  /** Length of roads, in meters */
  public static double roadLength = 200;
  /** Maximum car velocity, in meters/second */
  public static double maxVelocity = 6;
}

file:Model.java [source] [doc-public] [doc-private]

package myproject.model;

import java.util.List;
import java.util.ArrayList;
import java.util.Observable;
import myproject.util.Animator;

/**
 * An example to model for a simple visualization.
 * The model contains roads organized in a matrix.
 * See {@link #Model(AnimatorBuilder, int, int)}.
 */
public class Model extends Observable {
  private List<Agent> agents;
  private Animator animator;
  private boolean disposed;
  private double time;

  /** Creates a model to be visualized using the <code>builder</code>.
   *  If the builder is null, no visualization is performed.
   *  The number of <code>rows</code> and <code>columns</code>
   *  indicate the number of {@link Light}s, organized as a 2D
   *  matrix.  These are separated and surrounded by horizontal and
   *  vertical {@link Road}s.  For example, calling the constructor with 1
   *  row and 2 columns generates a model of the form:
   *  <pre>
   *     |  |
   *   --@--@--
   *     |  |
   *  </pre>
   *  where <code>@</code> is a {@link Light}, <code>|</code> is a
   *  vertical {@link Road} and <code>--</code> is a horizontal {@link Road}.
   *  Each road has one {@link Car}.
   *
   *  <p>
   *  The {@link AnimatorBuilder} is used to set up an {@link
   *  Animator}.
   *  {@link AnimatorBuilder#getAnimator()} is registered as
   *  an observer of this model.
   *  <p>
   */
  public Model(AnimatorBuilder builder, int rows, int columns) {
    if (rows < 0 || columns < 0 || (rows == 0 && columns == 0)) {
      throw new IllegalArgumentException();
    }
    if (builder == null) {
      builder = new NullAnimatorBuilder();
    }
    this.agents = new ArrayList<Agent>();
    setup(builder, rows, columns);
    this.animator = builder.getAnimator();
    super.addObserver(animator);
  }

  /**
   * Run the simulation for <code>duration</code> model seconds.
   */
  public void run(double duration) {
    if (disposed)
      throw new IllegalStateException();
    for (int i=0; i<duration; i++) {
      time++;
      // iterate through a copy because agents may change during iteration...
      for (Agent a : agents.toArray(new Agent[0])) {
        a.run(time);
      }
      super.setChanged();
      super.notifyObservers();
    }
  }

  /**
   * Throw away this model.
   */
  public void dispose() {
    animator.dispose();
    disposed = true;
  }

  /**
   * Construct the model, establishing correspondences with the visualizer.
   */
  private void setup(AnimatorBuilder builder, int rows, int columns) {
    List<Road> roads = new ArrayList<Road>();
    Light[][] intersections = new Light[rows][columns];

    // Add Lights
    for (int i=0; i<rows; i++) {
      for (int j=0; j<columns; j++) {
        intersections[i][j] = new Light();
        builder.addLight(intersections[i][j], i, j);
        agents.add(intersections[i][j]);
      }
    }

    // Add Horizontal Roads
    boolean eastToWest = false;
    for (int i=0; i<rows; i++) {
      for (int j=0; j<=columns; j++) {
        Road l = new Road();
        builder.addHorizontalRoad(l, i, j, eastToWest);
        roads.add(l);
      }
      eastToWest = !eastToWest;
    }

    // Add Vertical Roads
    boolean southToNorth = false;
    for (int j=0; j<columns; j++) {
      for (int i=0; i<=rows; i++) {
        Road l = new Road();
        builder.addVerticalRoad(l, i, j, southToNorth);
        roads.add(l);
      }
      southToNorth = !southToNorth;
    }

    // Add Cars
    for (Road l : roads) {
      Car car = new Car();
      agents.add(car);
      l.accept(car);
    }
  }
}

file:Road.java [source] [doc-public] [doc-private]

package myproject.model;

import java.util.List;
import java.util.ArrayList;

/**
 * A road holds cars.
 */
public class Road {
  Road() { } // Created only by this package

  private List<Car> cars = new ArrayList<Car>();

  public void accept(Car d) {
    if (d == null) { throw new IllegalArgumentException(); }
    cars.add(d);
  }
  public List<Car> getCars() {
    return cars;
  }
}

file:Agent.java [source] [doc-public] [doc-private]

package myproject.model;

/**
 * Interface for active model objects.
 */
public interface Agent {
  public void run(double time);
}

file:Car.java [source] [doc-public] [doc-private]

package myproject.model;

/**
 * A car remembers its position from the beginning of its road.
 * Cars have random velocity and random movement pattern:
 * when reaching the end of a road, the dot either resets its position
 * to the beginning of the road, or reverses its direction.
 */
public class Car implements Agent {
  Car() { } // Created only by this package

  private boolean backAndForth = Math.round(Math.random())==1 ? true : false;
  private double position = (MP.roadLength-MP.carLength) * Math.random ();
  private double velocity = (int) Math.ceil(Math.random() * MP.maxVelocity);
  private java.awt.Color color = new java.awt.Color((int)Math.ceil(128 + Math.random()*127),(int)Math.ceil(128 + Math.random()*127),(int)Math.ceil(Math.random()*255));

  public double getPosition() {
    return position;
  }
  public java.awt.Color getColor() {
    return color;
  }
  public void run(double time) {
    if (backAndForth) {
      if (((position + velocity) < 0) || ((position + velocity) > (MP.roadLength-MP.carLength)))
        velocity *= -1;
    } else {
      if ((position + velocity) > (MP.roadLength-MP.carLength))
        position = 0;
    }
    position += velocity;
  }
}

file:Light.java [source] [doc-public] [doc-private]

package myproject.model;

/**
 * A light has a boolean state.
 */
public class Light implements Agent {
  Light() { } // Created only by this package

  private boolean state;

  public boolean getState() {
    return state;
  }
  public void run(double time) {
    if (time%40==0) {
      state = !state;
    }
  }
}

file:Animator.java [source] [doc-public] [doc-private]

package myproject.util;

import java.util.Observer;

/**
 * An interface for displaying simulations.
 */
public interface Animator extends Observer {
  public void dispose();
}

file:AnimatorBuilder.java [source] [doc-public] [doc-private]

package myproject.model;

import myproject.util.Animator;

/**
 * An interface for building a {@link Animator} for this {@link Model}.
 */
public interface AnimatorBuilder {
  /**
   *  Returns the {@link Animator}.
   *  This method may be called only once; subsequent calls throw an
   *  {@link IllegalStateException}.
   */
  public Animator getAnimator();
  /**
   *  Add the {@link Light} to the display at position <code>i,j</code>.
   */
  public void addLight(Light d, int i, int j);
  /**
   *  Add the horizontal {@link Road} to the display, west of position <code>i,j</code>.
   *  If <code>eastToWest</code> is true, then road position 0 is the eastmost position.
   *  If <code>eastToWest</code> is false, then road position 0 is the westmost position.
   */
  public void addHorizontalRoad(Road l, int i, int j, boolean eastToWest);
  /**
   *  Add the vertical {@link Road} to the display, north of position <code>i,j</code>.
   *  If <code>southToNorth</code> is true, then road position 0 is the southmost position.
   *  If <code>southToNorth</code> is false, then road position 0 is the northmost position.
   */
  public void addVerticalRoad(Road l, int i, int j, boolean southToNorth);
}

/**
 * Null object for {@link AnimatorBuilder}.
 */
class NullAnimatorBuilder implements AnimatorBuilder {
  public Animator getAnimator() { return new NullAnimator(); }
  public void addLight(Light d, int i, int j) { }
  public void addHorizontalRoad(Road l, int i, int j, boolean eastToWest) { }
  public void addVerticalRoad(Road l, int i, int j, boolean southToNorth) { }
}

/**
 * Null object for {@link Animator}.
 */
class NullAnimator implements Animator {
  public void update(java.util.Observable o, Object arg) { }
  public void dispose() { }
}