Merge branch 'master' of github.com:Selebrator/omp-ha-2019

src/main/java/_9/_2/Lights.java

@@ -1,8 +1,6 @@
 package _9._2;
 
 import javafx.application.Application;
-import javafx.collections.ObservableList;
-import javafx.scene.Node;
 import javafx.scene.Scene;
 import javafx.scene.layout.GridPane;
 import javafx.scene.paint.Color;
@@ -15,48 +13,40 @@ import java.util.Optional;
 public class Lights extends Application {
 
 	private static final int DEFAULT_SIZE = 4;
-	private static final int GAP = 2;
 	private static final Paint ON = Color.YELLOW;
 	private static final Paint OFF = Color.WHITE;
 
 	@Override
-	public void start(Stage primaryStage) throws Exception {
+	public void start(Stage primaryStage) {
 		final int size = Optional.ofNullable(this.getParameters().getNamed().get("size"))
 				.map(Integer::parseInt).orElse(DEFAULT_SIZE);
+		Rectangle[][] positions = new Rectangle[size][size];
 		GridPane grid = new GridPane();
 		Scene scene = new Scene(grid, 600, 600);
-		scene.setFill(Color.BLACK);
+		primaryStage.setScene(scene);
-		grid.setHgap(GAP);
+		primaryStage.setTitle("Lights");
-		grid.setVgap(GAP);
+
-		for(int x = 0; x < size; x++) {
+		for(int row = 0; row < size; row++) {
-			for(int y = 0; y < size; y++) {
+			for(int column = 0; column < size; column++) {
-				Rectangle rec = new Rectangle(150, 150);
+				Rectangle rec = new Rectangle();
-				rec.heightProperty().bind(scene.heightProperty().subtract(size * GAP).divide(size));
-				rec.widthProperty().bind(scene.widthProperty().subtract(size * GAP).divide(size));
 				rec.setFill(OFF);
-				grid.add(rec, x, y);
+				rec.setStroke(Color.BLACK);
-			}
+				rec.heightProperty().bind(scene.heightProperty().divide(size).subtract(1)); // -1 for stroke
-		}
+				rec.widthProperty().bind(scene.widthProperty().divide(size).subtract(1));
-		for(int x = 0; x < size; x++) {
+				{
-			for(int y = 0; y < size; y++) {
+					final int x = row, y = column;
-				Rectangle rec = getNodeByRowColumnIndex(x, y, grid);
-				assert rec != null;
-				Rectangle up = getNodeByRowColumnIndex(x, y - 1, grid);
-				Rectangle down = getNodeByRowColumnIndex(x, y + 1, grid);
-				Rectangle left = getNodeByRowColumnIndex(x - 1, y, grid);
-				Rectangle right = getNodeByRowColumnIndex(x + 1, y, grid);
 					rec.setOnMouseClicked(event -> {
 						toggle(rec);
-					toggle(up);
+						toggle(getMatrixIndexSafe(positions, x, y - 1));
-					toggle(down);
+						toggle(getMatrixIndexSafe(positions, x, y + 1));
-					toggle(left);
+						toggle(getMatrixIndexSafe(positions, x - 1, y));
-					toggle(right);
+						toggle(getMatrixIndexSafe(positions, x + 1, y));
 					});
 				}
+				grid.add(rec, row, column);
+				positions[row][column] = rec;
+			}
 		}
-
-		primaryStage.setScene(scene);
-		primaryStage.setTitle("Lights");
 		primaryStage.show();
 	}
 
@@ -74,14 +64,10 @@ public class Lights extends Application {
 		}
 	}
 
-	public static <T extends Node> T getNodeByRowColumnIndex(final int column, final int row, GridPane gridPane) {
+	private static <T> T getMatrixIndexSafe(final T[][] positions, final int row, final int column) {
-		ObservableList<Node> children = gridPane.getChildren();
+		return (0 <= row && row < positions.length) && (0 <= column && column < positions[row].length)
-		for(Node node : children) {
+				? positions[row][column]
-			if(GridPane.getRowIndex(node) == row && GridPane.getColumnIndex(node) == column) {
+				: null;
-				return (T) node;
-			}
-		}
-		return null;
 	}
 
 	public static void main(String[] args) {

src/main/java/_9/_3/DrunkenPirate.java

@@ -0,0 +1,37 @@
+package _9._3;
+
+import provided._9.Captain;
+
+public class DrunkenPirate extends Captain {
+
+    public DrunkenPirate(Ship ship) {
+        super(ship);
+    }
+
+    @Override
+    public void commandShip() {
+        ShipEvent event = ShipEvent.getRandomShipEvent();
+        System.out.println(event);
+
+        switch (event) {
+            case SET_SAILS:
+                this.ship.setSails();
+                break;
+            case STRIKE_SAILS:
+                this.ship.strikeSails();
+                break;
+            case LOAD_CANNONS:
+                this.ship.loadCannons();
+                break;
+            case FIRE_CANNONS:
+                this.ship.fireCannons();
+                break;
+            case TURN_LEFT:
+                this.ship.turnLeft();
+                break;
+            case TURN_RIGHT:
+                this.ship.turnRight();
+                break;
+        }
+    }
+}

src/main/java/_9/_3/Observable.java

@@ -0,0 +1,40 @@
+package _9._3;
+
+import provided._9.Observer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class Observable {
+    private List<Observer> observers = new ArrayList<>();
+    private boolean changed = false;
+
+    public void addObserver(Observer o) {
+        this.observers.add(o);
+    }
+
+    public void removeObserver(Observer o) {
+        this.observers.remove(o);
+    }
+
+    protected void setChanged() {
+        changed = true;
+    }
+
+    private void clearChanged() {
+        changed = false;
+    }
+
+    public boolean isChanged() {
+        return changed;
+    }
+
+    public void notifyObservers(ShipEvent what) {
+        if (this.isChanged()) {
+            for (Observer observer : observers) {
+                observer.update(this, what);
+            }
+            this.clearChanged();
+        }
+    }
+}

src/main/java/_9/_3/Ship.java

@@ -0,0 +1,51 @@
+package _9._3;
+
+public class Ship extends Observable {
+    private boolean sailsSet = false;
+    private boolean cannonsLoaded = false;
+    private int heading = 0;
+
+    public void setSails() {
+        if (!sailsSet) {
+            sailsSet = true;
+            this.setChanged();
+            notifyObservers(ShipEvent.SET_SAILS);
+        }
+    }
+
+    public void strikeSails() {
+        if (sailsSet) {
+            sailsSet = false;
+            this.setChanged();
+            notifyObservers(ShipEvent.STRIKE_SAILS);
+        }
+    }
+
+    public void loadCannons() {
+        if (!cannonsLoaded) {
+            cannonsLoaded = true;
+            this.setChanged();
+            notifyObservers(ShipEvent.LOAD_CANNONS);
+        }
+    }
+
+    public void fireCannons() {
+        if (cannonsLoaded) {
+            cannonsLoaded = false;
+            this.setChanged();
+            notifyObservers(ShipEvent.FIRE_CANNONS);
+        }
+    }
+
+    public void turnLeft() {
+        heading = (heading - 90) % 180;
+        this.setChanged();
+        notifyObservers(ShipEvent.TURN_LEFT);
+    }
+
+    public void turnRight() {
+        heading = (heading + 90) % 360;
+        this.setChanged();
+        notifyObservers(ShipEvent.TURN_RIGHT);
+    }
+}

src/main/java/_9/_3/ShipEvent.java

@@ -0,0 +1,19 @@
+package _9._3;
+
+import java.util.Random;
+
+public enum ShipEvent {
+	
+	NO_EVENT,
+	SET_SAILS,
+	STRIKE_SAILS,
+	LOAD_CANNONS,
+	FIRE_CANNONS,
+	TURN_LEFT,
+	TURN_RIGHT;
+
+	public static ShipEvent getRandomShipEvent() {
+		Random random = new Random();
+		return values()[random.nextInt(values().length)];
+	}
+}

src/main/java/_9/_3/ShipLog.java

@@ -0,0 +1,32 @@
+package _9._3;
+
+import provided._9.Observer;
+
+public class ShipLog implements Observer {
+    private int heading = 0;
+    @Override
+    public void update(Observable who, ShipEvent what) {
+        switch (what) {
+            case SET_SAILS:
+                System.out.println("Sails set.");
+                break;
+            case STRIKE_SAILS:
+                System.out.println("Sails struck.");
+                break;
+            case LOAD_CANNONS:
+                System.out.println("Cannons loaded.");
+                break;
+            case FIRE_CANNONS:
+                System.out.println("Cannons fired.");
+                break;
+            case TURN_LEFT:
+                heading = (heading - 90) % 180;
+                System.out.println("Turned left. New heading " + heading + " degrees.");
+                break;
+            case TURN_RIGHT:
+                heading = (heading + 90) % 180;
+                System.out.println("Turned right. New heading " + heading + " degrees.");
+                break;
+        }
+    }
+}

src/main/java/provided/_9/Captain.java

@@ -0,0 +1,22 @@
+package provided._9;
+
+import _9._3.Ship;
+
+public abstract class Captain {
+	
+	protected Ship ship;
+	
+	public Captain(Ship ship) {
+		super();
+		this.ship = ship;
+	}
+
+	/**
+	 * Gibt ein Kommando an das Schiff.
+	 * Dieses Kommando wird erst auf der Konsole ausgegeben
+	 * und anschliessend wird die entsprechende Methode des
+	 * Schiffs aufgerufen.
+	 */
+	public abstract void commandShip();
+
+}

src/main/java/provided/_9/Observer.java

@@ -0,0 +1,10 @@
+package provided._9;
+
+import _9._3.Observable;
+import _9._3.ShipEvent;
+
+public interface Observer {
+	
+	void update(Observable who, ShipEvent what);
+
+}

src/main/java/provided/_9/ShipTest.java

@@ -0,0 +1,20 @@
+package provided._9;
+
+import _9._3.DrunkenPirate;
+import _9._3.Ship;
+import _9._3.ShipLog;
+
+public class ShipTest {
+
+	private static final int MAX_COMMANDS = 50;
+
+	public static void main(String[] args) {
+		Ship blackPearl = new Ship();
+		blackPearl.addObserver(new ShipLog());
+		Captain sparrow = new DrunkenPirate(blackPearl);
+		for (int i = 0; i < MAX_COMMANDS; i++) {
+			sparrow.commandShip();
+		}
+	}
+
+}