Created Classes for Assignment 6

MV3302ClassCode/src/mv3302/SimpleMover.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package mv3302;
+
+import java.awt.geom.Point2D;
+import static java.lang.Double.NaN;
+import simkit.Schedule;
+import simkit.SimEntityBase;
+import simkit.smd.Mover;
+
+/**
+ *
+ * @author ahbuss
+ */
+public class SimpleMover extends SimEntityBase {
+
+    public static Point2D NaP = new Point2D.Double(NaN, NaN);
+
+    public Point2D initialLocation;
+
+    public double maxSpeed;
+
+    public Point2D lastStopLocation;
+
+    public Point2D velocity;
+
+    public Point2D destination;
+
+    public double startMoveTime;
+
+    public SimpleMover() {
+        lastStopLocation = (Point2D) NaP.clone();
+        velocity = (Point2D) NaP.clone();
+        destination = (Point2D) NaP.clone();
+    }
+
+    public SimpleMover(Point2D initialLocation, double maxSpeed) {
+        this();
+        setInitialLocation(initialLocation);
+        setMaxSpeed(maxSpeed);
+    }
+
+    @Override
+    public void reset() {
+        super.reset();
+        lastStopLocation.setLocation(initialLocation);
+        velocity.setLocation(0.0, 0.0);
+        destination.setLocation(NaP);
+        startMoveTime = 0.0;
+    }
+
+    public void doRun() {
+        firePropertyChange("lastStopLocation", getLastStopLocation());
+        firePropertyChange("velocity", getVelocity());
+        firePropertyChange("destination", getDestination());
+        firePropertyChange("startMoveTime", getStartMoveTime());
+    }
+
+    public void doMoveTo(Point2D newDestination) {
+        Point2D oldDestination = getDestination();
+        this.destination.setLocation(newDestination);
+        firePropertyChange("destination", oldDestination, getDestination());
+
+        if (lastStopLocation.distance(destination) > 0.0) {
+            waitDelay("StartMove", 0.0, this);
+        }
+    }
+
+    public void doStartMove(Mover mover) {
+        double oldStartMoveTime = getStartMoveTime();
+        startMoveTime = Schedule.getSimTime();
+        firePropertyChange("startMoveTime", oldStartMoveTime, getStartMoveTime());
+        double distance = lastStopLocation.distance(destination);
+        double a = getMaxSpeed() / distance;
+
+        Point2D oldVelocity = getVelocity();
+        velocity.setLocation(destination.getX() - lastStopLocation.getX(), destination.getY() - lastStopLocation.getY());
+        velocity.setLocation(a * velocity.getX(), a * velocity.getY());
+        firePropertyChange("velocity", oldVelocity, getVelocity());
+
+        waitDelay("EndMove", 1.0/a, mover);
+    }
+
+    public void doEndMove(Mover mover) {
+        double oldStartMoveTime = getStartMoveTime();
+        startMoveTime = Schedule.getSimTime();
+        firePropertyChange("startMoveTime", oldStartMoveTime, getStartMoveTime());
+
+        Point2D oldLastStopLocation = getLastStopLocation();
+        lastStopLocation.setLocation(destination);
+        firePropertyChange("lastStopLocation", oldLastStopLocation, getLastStopLocation());
+
+        Point2D oldVelocity = getVelocity();
+        velocity.setLocation(0.0, 0.0);
+        firePropertyChange("velocity", oldVelocity, getVelocity());
+    }
+    
+    public void doOrderStop(){
+        waitDelay("Stop", 0.0, this);
+    }
+    
+    public void doStop(Mover mover){
+        Point2D oldLastStopLocation = lastStopLocation;
+        lastStopLocation = getCurrentLocation();
+        firePropertyChange("lastStopLocation", oldLastStopLocation, lastStopLocation);
+        velocity.setLocation(0.0, 0.0);
+        interrupt("EndMove", mover);
+    }
+    
+    /**
+     * @return the NaP
+     */
+    public static Point2D getNaP() {
+        return NaP;
+    }
+
+    /**
+     * @param aNaP the NaP to set
+     */
+    public static void setNaP(Point2D aNaP) {
+        NaP = aNaP;
+    }
+
+    /**
+     * @return the initialLocation
+     */
+    public Point2D getInitialLocation() {
+        return (Point2D) initialLocation.clone();
+    }
+
+    /**
+     * @param initialLocation the initialLocation to set
+     */
+    public void setInitialLocation(Point2D initialLocation) {
+        this.initialLocation = (Point2D) initialLocation.clone();
+    }
+
+    /**
+     * @return the maxSpeed
+     */
+    public double getMaxSpeed() {
+        return maxSpeed;
+    }
+
+    /**
+     * @return the lastStopLocation
+     */
+    public Point2D getLastStopLocation() {
+        return (Point2D) lastStopLocation.clone();
+    }
+
+    /**
+     * @return the velocity
+     */
+    public Point2D getVelocity() {
+        return (Point2D) velocity.clone();
+    }
+
+    /**
+     * @return the destination
+     */
+    public Point2D getDestination() {
+        return (Point2D) destination.clone();
+    }
+
+    /**
+     * @return the startMoveTime
+     */
+    public double getStartMoveTime() {
+        return startMoveTime;
+    }
+
+    /**
+     * @param maxSpeed the maxSpeed to set
+     */
+    public void setMaxSpeed(double maxSpeed) {
+        if (maxSpeed < 0.0) {
+            throw new IllegalArgumentException("maxSpeed must be >= 0.0: " + maxSpeed);
+        }
+        this.maxSpeed = maxSpeed;
+    }
+
+    public Point2D getCurrentLocation() {
+        double updateTime = Schedule.getSimTime() - getStartMoveTime();
+        return new Point2D.Double(lastStopLocation.getX() + updateTime * velocity.getX(),
+                lastStopLocation.getY() + updateTime * velocity.getY());
+//        Point2D currentLocation = getVelocity();
+//        currentLocation.setLocation(currentLocation.getX() * updateTime, currentLocation.getY() * updateTime);
+//        currentLocation.setLocation(lastStopLocation.getX() + currentLocation.getX(), lastStopLocation.getY() + currentLocation.getY());
+//        return currentLocation;    
+
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s %s %s", getName(), getCurrentLocation(), getVelocity());
+    }
+
+    public String paramString() {
+        return super.toString();
+    }
+}

MV3302ClassCode/src/mv3302/SimplePathMoverManager.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package mv3302;
+
+import java.awt.geom.Point2D;
+import static java.lang.Double.NaN;
+import simkit.SimEntityBase;
+import simkit.smd.Mover;
+
+/**
+ *
+ * @author dansl
+ */
+public class SimplePathMoverManager extends SimEntityBase {
+
+    private boolean startOnRun;
+
+    protected Point2D[] path;
+
+    protected int nextIndex;
+
+    protected Point2D nextWaypoint;
+
+    public SimplePathMoverManager() {
+    }
+
+    public SimplePathMoverManager(Point2D[] path, boolean startOnRun) {
+        setPath(path);
+        setStartOnRun(startOnRun);
+    }
+
+    @Override
+    public void reset() {
+        super.reset();
+        nextIndex = 0;
+
+    }
+
+    public void doRun() {
+        int oldNextIndex = getNextIndex();
+        nextIndex -= 1;
+        firePropertyChange("nextIndex", getNextIndex());
+        nextWaypoint = new Point2D.Double(NaN, NaN);
+        if (isStartOnRun()) {
+            waitDelay("NextWP", 0.0);
+        }
+    }
+    
+    public void doNextWP(){
+        int oldNextIndex = getNextIndex();
+        nextIndex += 1;
+        firePropertyChange("nextIndex", getNextIndex());
+        Point2D oldNextWaypoint = getNextWaypoint();
+        nextWaypoint = path[nextIndex];
+        firePropertyChange("nextWaypoint", getNextWaypoint());
+        waitDelay("MoveTo", 0.0, nextWaypoint);
+    }
+    
+    public void doEndMove(Mover mover){
+        if (nextIndex < path.length -1){
+            waitDelay("NextWP", 0.0);
+        }
+        if (nextIndex == path.length -1){
+            waitDelay("Stop", 0.0);
+        }
+    }
+    
+    public void doStop(){
+    }
+
+    public void doOrderStop(){
+    }
+    
+    public void doMoveTo(Point2D nextWaypoint){
+    }
+    
+    /**
+     * @return the startOnRun
+     */
+    public boolean isStartOnRun() {
+        return startOnRun;
+    }
+
+    /**
+     * @param startOnRun the startOnRun to set
+     */
+    public void setStartOnRun(boolean startOnRun) {
+        this.startOnRun = startOnRun;
+    }
+
+    /**
+     * @return the path
+     */
+    public Point2D[] getPath() {
+        return path;
+    }
+
+    public Point2D getPath(int index) {
+        return path[index];
+    }
+
+    /**
+     * @param path the path to set
+     */
+    public void setPath(Point2D[] path) {
+        if (path.length > 0) {
+            this.path = path.clone();
+        } else {
+            throw new IllegalArgumentException("path must be at least lengt 1: " + path.length);
+        }
+    }
+
+    /**
+     * @return the nextIndex
+     */
+    public int getNextIndex() {
+        return nextIndex;
+    }
+
+    /**
+     * @return the nextWaypoint
+     */
+    public Point2D getNextWaypoint() {
+        return (Point2D) nextWaypoint;
+    }
+}

MV3302ClassCode/src/mv3302/SimplePatrolMoverManager.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package mv3302;
+
+import java.awt.geom.Point2D;
+import simkit.smd.Mover;
+
+/**
+ *
+ * @author dansl
+ */
+public class SimplePatrolMoverManager extends SimplePathMoverManager{
+
+    /**
+     * Zero-argument constructor
+     */
+    public SimplePatrolMoverManager() {
+    }
+
+    /**
+     * Instantiate with given given parameters
+     *
+     * @param path Given waypoints
+     * @param startOnRun true if start immediately
+     */
+    public SimplePatrolMoverManager(Point2D[] path, boolean startOnRun) {
+        super(path, startOnRun);
+    }
+        /**
+     * Increment nextIndex; if it is beyond the last index, modulo back to
+     * 0.<br>
+     * Schedule MoveTo with path[nextIndex] (using getter, since path is
+     * private)
+     */
+    @Override
+    public void doEndMove(Mover mover) {
+        waitDelay("NextWP", 0.0, getPath(nextIndex));
+    }
+    
+    @Override
+    public void doNextWP(){
+        int oldNextIndex = getNextIndex();
+        nextIndex = (nextIndex+1)%path.length;
+        firePropertyChange("nextIndex", oldNextIndex, getNextIndex());
+        Point2D oldNextWaypoint = getNextWaypoint();
+        nextWaypoint = path[nextIndex];
+        firePropertyChange("nextWaypoint", oldNextWaypoint, getNextWaypoint());
+        waitDelay("MoveTo", 0.0, nextWaypoint);        
+    }
+    
+    public void doMoveTo(Mover mover){
+    }
+    
+}

MV3302ClassCode/src/mv3302/SimpleRandomMoverManager.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package mv3302;
+
+import java.awt.geom.Point2D;
+import static java.lang.Double.NaN;
+import simkit.random.RandomVariate;
+import simkit.smd.Mover;
+
+/**
+ *
+ * @author dansl
+ */
+public class SimpleRandomMoverManager extends SimplePathMoverManager {
+
+    /**
+     * Array to generate coordinates randomly
+     */
+    public RandomVariate[] coordinateGenerator;
+
+    /**
+     * If true start immediately
+     */
+    public boolean startOnRun;
+
+    public SimpleRandomMoverManager() {
+    }
+
+    /**
+     * Instantiate with the given parameters
+     *
+     * @param coordinateGenerator Given random coordinate generator
+     * @param startOnRun true if starting immediately
+     */
+    public SimpleRandomMoverManager(RandomVariate[] coordinateGenerator,
+            boolean startOnRun) {
+        this.setCoordinateGenerator(coordinateGenerator);
+        this.setStartOnRun(startOnRun);
+    }
+
+    /**
+     * If startOnRun is true, generate random coordinates and schedule MoveTo
+     * with that destination
+     */
+    @Override
+    public void doRun() {
+        Point2D oldNextWaypoint = getNextWaypoint();
+        nextWaypoint = new Point2D.Double(NaN, NaN);
+        firePropertyChange("nextWaypoint", oldNextWaypoint, nextWaypoint);
+        if (isStartOnRun()) {
+            waitDelay("NextWP", 0.0);
+        }
+    }
+
+    @Override
+    public void doNextWP() {
+        Point2D oldNextWaypoint = getNextWaypoint();
+        nextWaypoint = new Point2D.Double(
+                coordinateGenerator[0].generate(),
+                coordinateGenerator[1].generate());
+        firePropertyChange("nextWaypoint", oldNextWaypoint, nextWaypoint);
+        waitDelay("MoveTo", 0.0, nextWaypoint);
+    }
+
+    @Override
+    public void doMoveTo(Point2D nextWayPoint) {
+    }
+
+    @Override
+    public void doEndMove(Mover mover) {
+        waitDelay("NextWP", 0.0);
+    }
+    
+    @Override
+    public void doStop(){
+        waitDelay("OrderStop", 0.0);
+    }
+    
+    @Override
+    public void doOrderStop(){
+    }
+
+    /**
+     * @return the coordinateGenerator
+     */
+    public RandomVariate[] getCoordinateGenerator() {
+        return coordinateGenerator.clone();
+    }
+
+    public RandomVariate getCoordinateGenerator(int index) {
+        return coordinateGenerator[index];
+    }
+
+    /**
+     * @param coordinateGenerator the coordinateGenerator to set
+     */
+    public void setCoordinateGenerator(RandomVariate[] coordinateGenerator) {
+        this.coordinateGenerator = coordinateGenerator.clone();
+    }
+
+    public void setCoordinateGenerator(int index, RandomVariate coordinateGenerator) {
+        this.coordinateGenerator[index] = coordinateGenerator;
+    }
+
+    /**
+     * @return the startOnRun
+     */
+    @Override
+    public boolean isStartOnRun() {
+        return startOnRun;
+    }
+
+    /**
+     * @param startOnRun the startOnRun to set
+     */
+    @Override
+    public void setStartOnRun(boolean startOnRun) {
+        this.startOnRun = startOnRun;
+    }
+
+}

MV3302ClassCode/src/mv3302/run/Assignment6.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Main.java to edit this template
+ */
+package mv3302.run;
+
+import java.awt.geom.Point2D;
+import mv3302.SimpleMover;
+import mv3302.SimplePathMoverManager;
+import mv3302.SimplePatrolMoverManager;
+import mv3302.SimpleRandomMoverManager;
+import simkit.Schedule;
+import simkit.random.RandomVariate;
+import simkit.random.RandomVariateFactory;
+import simkit.util.SimplePropertyDumper;
+
+/**
+ *
+ * @author dansl
+ */
+public class Assignment6 {
+
+    /**
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) {
+        Point2D initialLocation = new Point2D.Double(0.0, 250.0);
+        double maxSpeed = 30.0;
+
+        SimpleMover simpleMover = new SimpleMover(initialLocation, maxSpeed);
+        System.out.println(simpleMover);
+
+        Point2D[] path = new Point2D[]{
+            new Point2D.Double(-200.0, 0.0),
+            new Point2D.Double(-200.0, 250.0),
+            new Point2D.Double(200.0, 250.0),
+            new Point2D.Double(0.0, 250.0)};
+
+        SimplePathMoverManager simplePathMoverManager = new SimplePathMoverManager(path, true);
+        System.out.println(simplePathMoverManager);
+
+        Point2D initialLocation2 = new Point2D.Double(0.0, 150.0);
+        double maxSpeed2 = 40.0;
+        SimpleMover simpleMover2 = new SimpleMover(initialLocation2, maxSpeed2);
+        System.out.println(simpleMover2);
+
+        Point2D[] path2 = new Point2D[]{
+            new Point2D.Double(0.0, 300.0),
+            new Point2D.Double(0.0, -100.0)};
+
+        SimplePatrolMoverManager simplePatrolMoverManager = new SimplePatrolMoverManager(path2, true);
+        System.out.println(simplePatrolMoverManager);
+
+        //        The coordinate generators
+        RandomVariate[] coordinateGenerator = new RandomVariate[]{
+            RandomVariateFactory.getInstance("Uniform", -250.0, 250.0),
+            RandomVariateFactory.getInstance("Uniform", -100, 300.0)
+        };
+//        Note startOnRun is now true
+        SimpleRandomMoverManager simpleRandomMoverManager = new SimpleRandomMoverManager(coordinateGenerator,
+                true);
+        System.out.println(simpleRandomMoverManager);
+
+        Point2D initialLocation3 = new Point2D.Double(0.0, 0.0);
+        double maxSpeed3 = 50.0;
+        SimpleMover simpleMover3 = new SimpleMover(initialLocation3, maxSpeed3);
+        System.out.println(simpleMover3);
+
+        simpleMover.addSimEventListener(simplePathMoverManager);
+        simplePathMoverManager.addSimEventListener(simpleMover);
+
+//        simpleMover.addSimEventListener(simplePatrolMoverManager);
+//        simplePatrolMoverManager.addSimEventListener(simpleMover);
+//
+//        simpleMover.addSimEventListener(simpleRandomMoverManager);
+//        simpleRandomMoverManager.addSimEventListener(simpleMover);
+
+        SimplePropertyDumper simplePropertyDumper = new SimplePropertyDumper();
+        simpleMover.addPropertyChangeListener(simplePropertyDumper);
+        simplePathMoverManager.addPropertyChangeListener(simplePropertyDumper);
+
+        Schedule.setVerbose(true);
+
+//        Schedule.stopAtTime(10.5);
+        Schedule.reset();
+        simpleMover.waitDelay("MoveTo", 0.0);
+        simpleMover.waitDelay("OrderStop", 0.1);
+        simpleMover.waitDelay("Stop", 0.2);
+        simplePatrolMoverManager.waitDelay("Stop", 10.0);
+        simpleRandomMoverManager.waitDelay("Stop", 20.0);
+        Schedule.startSimulation();
+    }
+
+}