diff options
Diffstat (limited to 'Week14 Route 66/src/com/camilstaps')
11 files changed, 876 insertions, 98 deletions
diff --git a/Week14 Route 66/src/com/camilstaps/route66/Car.java b/Week14 Route 66/src/com/camilstaps/route66/Car.java new file mode 100644 index 0000000..b118a3c --- /dev/null +++ b/Week14 Route 66/src/com/camilstaps/route66/Car.java @@ -0,0 +1,179 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2015 Camil Staps <info@camilstaps.nl> + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.camilstaps.route66; + +import java.awt.Color; +import java.awt.Graphics; +import java.util.Random; + +/** + * Class for an individual car + * + * @author Pieter Koopman, Camil Staps + */ +public class Car { + public static final int + CARWIDTH = 20, + CARLENGTH = 40, + MINCARSPACE = 5, + MINCARSPEED = 2, + MAXCARSPEED = 4; + + public static final Color[] carColours = {Color.red, Color.blue, Color.black, Color.gray, Color.green, + Color.pink, Color.orange, Color.magenta, Color.lightGray}; + + private final int speed, number; // speed and car-number + private final Direction direction; // driving direction, used by paint + private int location; // current location on the road + private final Color colour; // colour of this car + private final Random random; // here to ensure that every car gets a new + private final Driver driver; // this car's driver + private final Model model; // the model the car is in + + /** + * The constructor: + * - choose a random speed + * - set right location, direction and colour + * - create new Driver object + * + * @param number of the car + * @param model the model the car is in + */ + public Car(int number, Model model) { + this.number = number; + random = new Random(); + speed = MINCARSPEED + random.nextInt(MAXCARSPEED - MINCARSPEED + 1); + direction = Direction.intToDirection(number); + location = RoadView.WINDOWSIZE - 2 - (number/Model.DIRECTIONS) * (CARLENGTH + MINCARSPACE); + colour = carColours[number % carColours.length]; + this.model = model; + driver = new Driver(this, model); + } + + /** + * Get the driver + * @return + */ + public Driver getDriver() { + return driver; + } + + /** + * Get the direction + * @return + */ + public Direction getDirection() { + return direction; + } + + /** + * Get the number of this car + * @return + */ + public int getNumber() { + return number; + } + + /** + * Get the current location of this car + * @return + */ + public int getLocation() { + return location; + } + + /** + * Get the location the car would move to if it would move + * @return + */ + public int getNewLocation() { + return (location + speed) % RoadView.WINDOWSIZE; + } + + /** + * Move the car one step + */ + public void step() { + location = getNewLocation(); + //System.err.println("Car "); + model.update(); + } + + /** + * Is the car in front of the crossing? That is, is the car now not on the + * crossing but would it be there after the next step? + * @return + */ + public boolean isInFrontOfCrossing() { + return location < RoadView.getStartCrossing() && getNewLocation() >= RoadView.getStartCrossing(); + } + + /** + * Is the car on the crossing? + * @return + */ + public boolean isOnCrossing() { + return location > RoadView.getStartCrossing() && location - CARLENGTH < RoadView.getEndCrossing(); + } + + /** + * Paint this car + * @param g + */ + public void paint(Graphics g) { + int x, y, w, h; + switch (direction) { + case North: + x = RoadView.WINDOWSIZE / 2 + 1; + y = RoadView.WINDOWSIZE - location; + w = Car.CARWIDTH; + h = Car.CARLENGTH; + break; + case East: + x = location - Car.CARLENGTH; + y = RoadView.WINDOWSIZE / 2 + 1; + w = Car.CARLENGTH; + h = Car.CARWIDTH; + break; + case South: + x = RoadView.WINDOWSIZE / 2 - Car.CARWIDTH - 1; + y = location - Car.CARLENGTH; + w = Car.CARWIDTH; + h = Car.CARLENGTH; + break; + case West: + x = RoadView.WINDOWSIZE - location - 1; + y = RoadView.WINDOWSIZE / 2 - Car.CARWIDTH - 1; + w = Car.CARLENGTH; + h = Car.CARWIDTH; + break; + default: + x = y = w = h = 10; + } + g.setColor(colour); + g.fillRect(x, y, w, h); + g.setColor(Color.WHITE); + g.drawString(String.valueOf(number), x + w / 6, y + h / 2 + 4); + } +} diff --git a/Week14 Route 66/src/com/camilstaps/route66/Controller.java b/Week14 Route 66/src/com/camilstaps/route66/Controller.java new file mode 100644 index 0000000..e0eff83 --- /dev/null +++ b/Week14 Route 66/src/com/camilstaps/route66/Controller.java @@ -0,0 +1,95 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2015 Camil Staps <info@camilstaps.nl> + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.camilstaps.route66; + +import java.util.Random; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +/** + * Route66 Controller + * + * Use different threads for every driver + * + * @author Pieter Koopman, Camil Staps + */ +public class Controller { + private int delay = 120; // average sleep time + private final Model model; // the model + private final Random random; // a random generator + + /** + * The constructor of the controller + * @param model holds the cars + */ + public Controller(Model model) { + this.model = model; + random = new Random(); + } + + /** + * Tell the drivers of all cars in the model to start driving + */ + public void run() { + ExecutorService service = Executors.newCachedThreadPool(); + for (Car car : model.getCars()) { + Driver d = car.getDriver(); + d.setDelay(delay); + service.execute(d); + } + } + + /** + * Stop all cars + */ + public void stopCars() { + for (Car car : model.getCars()) { + car.getDriver().stopRunning(); + } + } + + /** + * Resume all cars + */ + public void resumeCars() { + for (Car car : model.getCars()) { + car.getDriver().resumeRunning(); + } + } + + public int getDelay() { + return delay; + } + + /** + * Set delay between maximum and minimum bounds + * @param d + */ + public void setDelay(int d) { + delay = Math.max(20, Math.min (2000, d)); + for (Car car : model.getCars()) { + car.getDriver().setDelay(delay); + } + } +} diff --git a/Week14 Route 66/src/com/camilstaps/route66/Crossing.java b/Week14 Route 66/src/com/camilstaps/route66/Crossing.java deleted file mode 100644 index 65e2527..0000000 --- a/Week14 Route 66/src/com/camilstaps/route66/Crossing.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (c) 2015 Camil Staps - */ -package com.camilstaps.route66; - -import OO14route66.Direction; -import OO14route66.Model; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * - * @author camilstaps - */ -public class Crossing { - - private final Model model; - private Direction allowed; - private boolean crossingWaiting = false; - private int requests = 0; - - public Crossing(Model model, Direction allowed) { - this.model = model; - this.allowed = allowed; - } - - public Direction getAllowed() { - return allowed; - } - - public synchronized void doSwitch() { - crossingWaiting = true; - while (!model.isCarsOnCrossing()); - System.err.println("Switching"); - if (allowed == Direction.East || allowed == Direction.West) { - allowed = Direction.North; - } else { - allowed = Direction.East; - } - requests = 0; - System.err.println("Switched to " + allowed); - crossingWaiting = false; - //notifyAll(); - } - - public boolean isAllowed(Direction direction) { - return !crossingWaiting && (direction == allowed || Direction.opposite(direction) == allowed); - } - - public boolean doRequest() { - //if (++requests >= 2) { - if (crossingWaiting) { - return false; - } - doSwitch(); - return true; - //} - //return false; - } - -} diff --git a/Week14 Route 66/src/com/camilstaps/route66/Direction.java b/Week14 Route 66/src/com/camilstaps/route66/Direction.java new file mode 100644 index 0000000..ef69caa --- /dev/null +++ b/Week14 Route 66/src/com/camilstaps/route66/Direction.java @@ -0,0 +1,89 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2015 Camil Staps <info@camilstaps.nl> + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.camilstaps.route66; + +/** + * OO1route66 initial class + * + * Enumeration class for driving directions + * + * @author Pieter Koopman, Camil Staps + */ +public enum Direction +{ + North, East, South, West; + + /** + * convert integer to direction + * if number of directions is 2 only East and West are used, + * otherwise all 4 directions are used + * @param i the integer + * @return the direction + */ + public static Direction intToDirection(int i) { + if (Model.DIRECTIONS == 2) { + switch (i % 2) { + case 0: return East; + default: return West; + } + } else { + switch (i % 4) { + case 0: return North; + case 1: return East; + case 2: return South; + default: return West; + } + } + } + + /** + * Get the opposite of a direction + * @param direction + * @return + */ + public static Direction opposite(Direction direction) { + switch (direction) { + case North: return South; + case South: return North; + case East: return West; + case West: return East; + default: return direction; + } + } + + /** + * override standard toString + * @return string representation of this value + */ + @Override + public String toString() { + switch (this) { + case North: return "North"; + case East: return "East"; + case South: return "South"; + case West: return "West"; + default: return "Unknown direction"; + } + } +} diff --git a/Week14 Route 66/src/com/camilstaps/route66/Driver.java b/Week14 Route 66/src/com/camilstaps/route66/Driver.java index 4a323cd..ff603c8 100644 --- a/Week14 Route 66/src/com/camilstaps/route66/Driver.java +++ b/Week14 Route 66/src/com/camilstaps/route66/Driver.java @@ -1,14 +1,33 @@ /* - * Copyright (c) 2015 Camil Staps + * The MIT License (MIT) + * + * Copyright (c) 2015 Camil Staps <info@camilstaps.nl> + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. */ package com.camilstaps.route66; -import OO14route66.Car; -import OO14route66.Model; import java.util.Random; /** * A Driver takes care its car doesn't collide + * * @author Camil Staps */ public class Driver implements Runnable { @@ -18,7 +37,7 @@ public class Driver implements Runnable { private final Random r; - private boolean running, waitingToCross = false; + private boolean running = false; private int delay; public Driver(Car car, Model model) { @@ -28,19 +47,22 @@ public class Driver implements Runnable { } /** - * Set running to false to disable driving altogether - * @param value + * Stop running */ - public void setRunning(boolean value) { - running = value; - } - - public void setWaitingToCross(boolean value) { - waitingToCross = value; + public void stopRunning() { + running = false; } - public boolean getWaitingToCross() { - return waitingToCross; + /** + * Resume running + */ + public void resumeRunning() { + if (running == false) { + synchronized (this) { + running = true; + notifyAll(); + } + } } /** @@ -53,11 +75,20 @@ public class Driver implements Runnable { } @Override - @SuppressWarnings("empty-statement") - public void run() { + /** + * Forever wait for safety, step and pause for a pseudorandom time. + */ + public synchronized void run() { running = true; while (true) { - while (!running || !model.isSafeLocation(car, car.getNewLocation())); + do { + while (!running) { + try { + wait(); + } catch (InterruptedException ex) { + } + } + } while (!model.isSafeLocation(car, car.getNewLocation())); car.step(); @@ -74,7 +105,7 @@ public class Driver implements Runnable { if (Math.abs((System.currentTimeMillis() / 1000) % Model.NUMBEROFCARS - car.getNumber()) < 2) { bonus = -50; } - Thread.sleep(Math.abs(r.nextInt(50) + delay + bonus)); + Thread.sleep(Math.abs(r.nextInt(100) + delay + bonus)); } catch (InterruptedException ex) {} } diff --git a/Week14 Route 66/src/com/camilstaps/route66/KeyHandler.java b/Week14 Route 66/src/com/camilstaps/route66/KeyHandler.java new file mode 100644 index 0000000..eb84b6f --- /dev/null +++ b/Week14 Route 66/src/com/camilstaps/route66/KeyHandler.java @@ -0,0 +1,39 @@ +package com.camilstaps.route66; + +import java.awt.event.KeyAdapter; +import java.awt.event.KeyEvent; + +/** + * Keyboard handler of views for controller. + * + * Pressing keys changes the controller. + * + * @author Pieter Koopman, Camil Staps + */ +public class KeyHandler extends KeyAdapter { + + private final Controller controller; + + public KeyHandler (Controller c) { + controller = c; + } + + /** + * on key down 'q' stop program + * on key down 's' stop the cars + * on key down '<' decrease delay + * on key down '>' increase delay + * on any other key activate the cars + * @param e the key event + */ + @Override + public void keyPressed(KeyEvent e) { + switch (e.getKeyChar()) { + case 'q': System.exit(0); + case 's': controller.stopCars(); break; + case '<': controller.setDelay(controller.getDelay() - 50); break; + case '>': controller.setDelay(controller.getDelay() + 50); break; + default : controller.resumeCars(); + } + } +} diff --git a/Week14 Route 66/src/com/camilstaps/route66/Model.java b/Week14 Route 66/src/com/camilstaps/route66/Model.java new file mode 100644 index 0000000..6e43e29 --- /dev/null +++ b/Week14 Route 66/src/com/camilstaps/route66/Model.java @@ -0,0 +1,189 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2015 Camil Staps <info@camilstaps.nl> + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.camilstaps.route66; + +import java.util.ArrayList; +import java.util.Observable; +import javax.swing.JFrame; + +/** + * Route 66 model with crossing + * + * The class model holds all cars in the simulation. + * + * @author Pieter Koopman, Camil Staps + */ +public class Model extends Observable { + + private final Car [] cars; + public static final int + DIRECTIONS = 4, + NUMBEROFCARS = 5 * DIRECTIONS; // total number of cars in system + + private final ArrayList<JFrame> views; + + /** + * Crossing attributes: + * + * allowed - which direction is currently allowed; if East is allowed, West + * is also allowed, etc. + * crossingWaiting - whether or not the crossing is waiting for cars to + * leave the crossing to switch (i.e. orange) + * lastCrossingChange - when the crossing switched the last time + * MIN_CROSS_TIME - the minimum time the crossing should wait before + * switching again after the last switch + */ + private Direction allowed = Direction.East; + private boolean crossingWaiting = false; + private long lastCrossingChange = 0; + private static final int MIN_CROSS_TIME = 1000; + + /** + * Constructor: create all cars + */ + public Model() { + views = new ArrayList<>(); + cars = new Car [NUMBEROFCARS]; + for (int c = 0; c < NUMBEROFCARS; c += 1) { + cars[c] = new Car(c, this); + } + } + + /** + * add the view to this model. It will be repainted upon an update + * @param view + */ + public void addView(JFrame view) { + views.add(view); + } + + public Car[] getCars() { + return cars; + } + + /** + * Get a car from the model + * @param i numbers of required car + * @return the car itself (not a copy) + */ + public Car getCar(int i) { + return cars[i]; + } + + /** + * Repaint all views, and notify all drivers to reconsider driving + */ + public synchronized void update() { + for (JFrame view: views) { + view.repaint(); + } + notifyAll(); + } + + /** + * Check if a location is safe for a car to go to. This should always be + * checked by a driver before actually driving. + * @param car + * @param requested_location + * @return + */ + public synchronized boolean isSafeLocation(Car car, int requested_location) { + // Check that we don't collide with the car in front of us + Car that_car = cars[car.getNumber() < DIRECTIONS ? car.getNumber() + NUMBEROFCARS - DIRECTIONS : car.getNumber() - DIRECTIONS]; + boolean ok = !(that_car.getLocation() > requested_location && + that_car.getLocation() < requested_location + Car.CARLENGTH + Car.MINCARSPACE); + + // If we have to wait for the crossing... well, do that. + if (car.isInFrontOfCrossing() && !isCrossingAllowed(car.getDirection())) { + ok = doCrossingRequest(); + } + + if (!ok) { + try { + wait(); + } catch (InterruptedException ex) {} + } + + return ok; + } + + /** + * Check if there are any cars on the crossing + * @return + */ + public synchronized boolean isCarsOnCrossing() { + for (Car car : cars) { + if (car.isOnCrossing()) { + return true; + } + } + return false; + } + + /** + * Switch the crossing + */ + public synchronized void doSwitchCrossing() { + crossingWaiting = true; + + while (isCarsOnCrossing()) { + try { + wait(); + } catch (InterruptedException ex) { + } + } + + if (allowed == Direction.East || allowed == Direction.West) { + allowed = Direction.North; + } else { + allowed = Direction.East; + } + + crossingWaiting = false; + lastCrossingChange = System.currentTimeMillis(); + } + + /** + * Check if crossing in some direction is allowed + * @param direction + * @return + */ + public synchronized boolean isCrossingAllowed(Direction direction) { + return !crossingWaiting && (direction == allowed || Direction.opposite(direction) == allowed); + } + + /** + * Try to switch the crossing + * This may return false without even trying to switch, if it's too early to + * ask (see {@link Model#MIN_CROSS_TIME}) or if a request has been made already. + * @return + */ + public synchronized boolean doCrossingRequest() { + if (crossingWaiting || System.currentTimeMillis() - lastCrossingChange < MIN_CROSS_TIME) { + return false; + } + doSwitchCrossing(); + return true; + } +} diff --git a/Week14 Route 66/src/com/camilstaps/route66/RoadView.java b/Week14 Route 66/src/com/camilstaps/route66/RoadView.java new file mode 100644 index 0000000..660d44e --- /dev/null +++ b/Week14 Route 66/src/com/camilstaps/route66/RoadView.java @@ -0,0 +1,127 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2015 Camil Staps <info@camilstaps.nl> + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.camilstaps.route66; + +import java.awt.Color; +import java.awt.Graphics; +import javax.swing.JFrame; +import javax.swing.JPanel; + +/** + * OO13route66 animation + * + * Yields a graphical view on all cars + * + * @author Pieter Koopman, Camil Staps + */ +public class RoadView extends JFrame +{ + JPanel panel; // the panel to draw the cars + public static final int WINDOWSIZE = 600; // the window size + private final Model model; // the model knows the position of cars + + /** + * A subclass of JPanel to draw the cars. + * This is a bit of a hack to ensure that this panel is painted correctly. + */ + private class CarPanel extends JPanel { + /** + * Constructor: just call the constructor of the base class + */ + public CarPanel() { + super(); + } + /** + * paint the roads and cars + * @param g Graphics to paint on + */ + @Override + public void paint (Graphics g) { + paintRoad(g); + paintCars(g); + } + } + /** + * The constructor of RoadView + * @param model + */ + RoadView(Model model) { + super("Route66 traffic simulator"); + this.model = model; + setSize(WINDOWSIZE, WINDOWSIZE); + setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); + panel = new CarPanel(); + add(panel); + } + /** + * Paint the view of the model graphically + * @param g + */ + @Override + public void paint(Graphics g) { + super.paint(g); + panel.repaint(); + } + /** + * Paint all cars + * @param g graphics to draw on + */ + private void paintCars (Graphics g) { + for (int i = 0; i < Model.NUMBEROFCARS; i += 1) { + model.getCar(i).paint(g); + } + } + + /** + * Paint the roads + * @param g graphics to draw on + */ + private void paintRoad (Graphics g) { + final int left = getStartCrossing(); + final int width = getEndCrossing() - left; + g.setColor(Color.white); // background + g.fillRect(0, 0, WINDOWSIZE, WINDOWSIZE); + g.setColor(Color.darkGray); // streets + g.fillRect(0, left, WINDOWSIZE, width); + if (Model.DIRECTIONS > 2) { // paint a crossing if there are 4 directions + g.fillRect(left, 0, width, WINDOWSIZE); + } + } + + /** + * Get the relevant half of the coordinate where the crossing starts + * @return + */ + public static int getStartCrossing() { + return (WINDOWSIZE / 2) - Car.CARWIDTH - 4; + } + + /** + * Get the relevant half of the coordinate where the crossing ends + * @return + */ + public static int getEndCrossing() { + return getStartCrossing() + 2 * Car.CARWIDTH + 8; + } +} diff --git a/Week14 Route 66/src/com/camilstaps/route66/Route66.java b/Week14 Route 66/src/com/camilstaps/route66/Route66.java new file mode 100644 index 0000000..8f9a2e9 --- /dev/null +++ b/Week14 Route 66/src/com/camilstaps/route66/Route66.java @@ -0,0 +1,44 @@ +package com.camilstaps.route66; + +/** + * OO1route66 initial class + * + * Route66 class constructs model, view and controller + * + * @author Pieter Koopman + */ +public class Route66 +{ + Controller controller; + /** + * the main method for OO13route66 + * @param args the command line arguments + */ + public static void main(String[] args) { + Route66 r66 = new Route66(); + } + + /** + * the main constructor: + * - creates model, controller and views + */ + public Route66() { + Model model = new Model(); + + RoadView rview = new RoadView(model); + TableView tview = new TableView(model); + model.addView(tview); + model.addView(rview); + + controller = new Controller(model); + + KeyHandler keyHandler = new KeyHandler(controller); + rview.addKeyListener(keyHandler); + tview.addKeyListener(keyHandler); + + tview.setVisible(true); + rview.setVisible(true); + + controller.run(); + } +} diff --git a/Week14 Route 66/src/com/camilstaps/route66/TableView.java b/Week14 Route 66/src/com/camilstaps/route66/TableView.java new file mode 100644 index 0000000..1aa38f7 --- /dev/null +++ b/Week14 Route 66/src/com/camilstaps/route66/TableView.java @@ -0,0 +1,65 @@ +package com.camilstaps.route66; + +import java.awt.Graphics; +import java.awt.GridLayout; +import javax.swing.JFrame; +import javax.swing.JLabel; +import javax.swing.JPanel; + +/** + * OO14route66 initial class + * @author Pieter Koopman + */ +public class TableView extends JFrame +{ + JPanel panel; + public static final int WINDOWWITDH = 100 * Model.DIRECTIONS, WINDOWHEIGTH = 200; + JLabel [] textLabels; + private final Model model; // for the positions of the cars + + /** + * The constructor of TableView + * @param model containing the position of the cars to display + * makes a panel with a gridLayout and a JLabel for each car in this panel + */ + TableView(Model model) { + super("Route66 table view"); + this.model = model; + setSize(WINDOWWITDH, WINDOWHEIGTH); + setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + panel = new JPanel(); + panel.setLayout(new GridLayout(Model.NUMBEROFCARS / Model.DIRECTIONS + 1, Model.DIRECTIONS)); + + for (int i = 0; i < Model.DIRECTIONS; i += 1) { // make table headings + panel.add(new JLabel(Direction.intToDirection(i).toString())); + } + + textLabels = new JLabel[Model.NUMBEROFCARS]; // make car info + for (int c = 0; c < Model.NUMBEROFCARS; c += 1) { + textLabels[c] = new JLabel(label(c)); + panel.add(textLabels[c]); + } + add(panel); + } + + /** + * update the JLabel for each car + * @param g + */ + @Override + public void paint(Graphics g) { + super.paint(g); + for (int c = 0; c < Model.NUMBEROFCARS; c += 1) { + textLabels[c].setText(label(c)); + } + } + + /** + * create a label for the given car number + * @param c: car number + * @return string representing the car information + */ + private String label(int c) { + return c + ": " + model.getCar(c).getLocation(); + } +} diff --git a/Week14 Route 66/src/com/camilstaps/route66/Week14Route66.java b/Week14 Route 66/src/com/camilstaps/route66/Week14Route66.java deleted file mode 100644 index 30b7bd2..0000000 --- a/Week14 Route 66/src/com/camilstaps/route66/Week14Route66.java +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (c) 2015 Camil Staps - */ -package com.camilstaps.route66; - -/** - * - * @author camilstaps - */ -public class Week14Route66 { - - /** - * @param args the command line arguments - */ - public static void main(String[] args) { - // TODO code application logic here - } - -} |