Add some more descriptions and images, split up pages

README.md

-# FlowerWarsPP
+# Herkunft
 FlowerWarsPP ist eine Variation des Spiels [Ponte del Diavolo](https://www.brettspielnetz.de/spielregeln/ponte+del+diavolo.php).
 
-# Motivation
+# Geschichte
 Die Gebrüder Gartenpfleger Torsten und Torben streiten sich um Tamara und möchten sie durch das Herrichten einer hübschen Gartenlandschaft
 beeindrucken. Leider müssen sich die beiden die Wiese hierfür teilen. Wer schafft es die meisten Gärten zu bepflanzen und diese zu
 verzieren indem sie durch Gräben miteinander verbunden werden?
 
-# Das Spiel
-FlowerWarsPP ist ein Spiel für zwei Spieler, die mit den Farben **Rot** und **Blau** spielen. Das Ziel beider Spieler ist es 
-eine Wiese so weit wie möglich mit Gärten zu bepflanzen.
+# FlowerWars
 
-# Das Spielbrett
-Gespielt wird auf einem dreieckigen Spielbrett mit einer Seitenlänge `3 <= n <= 30`.
-Die Gitterpunkte, im Folgenden **Punkte** genannt, werden mit Spalten- und Zeilenkoordinaten versehen, wobei unten links die 
-Koordinate `1,1` liegt. 
-
-Hier ist ein Spielbrett der Größe `n = 3` dargestellt:
-
-![Spielbrett der Groesse 3](specification/images/board-3-empty.png)
-
-Das Spielfeld stellt eine dreieckige Wiese dar, die wiederum in kleine dreieckige Teilflächen aufgeteilt ist.
-
-Die von drei Punkten eingeschlossenen Flächen werden können mit **Blumen** bepflanzt werden. Auf der Kante von 
-einem Punkt zu einem direkten Nachbarn kann ein Wassergraben, kurz 
-**Graben**, gebaut werden. Ein Punkt hat hierbei stets maximal `6` direkte Nachbarn. Blumen und Gräben sind die 
-Hauptbestandteile von FlowerWarsPP.
-
-![Spielbrett der Groesse 3](specification/images/board-3-situation1.png)
-
-Auf diesem Spielbrett ist folgende Situation gezeigt:
-
-- Der rote Spieler hat Blumen auf (`1,1`, `2,1`, `1,2`) und (`2,1`, `3,1`, `2,2`)
-- Der blaue Spieler hat eine Blume auf (`1,3`, `2,3`, `1,4`)
-- Der rote Spieler hat einen Graben von `1,2` nach `2,2`, mit der seine beiden Blumen verbunden werden
-
-# Zugregeln
-- Der rote Spieler hat den ersten Zug, danach wird beginnend mit dem blauen Spieler abwechselnd weiter gezogen.
-- In einem Zug muss der Spieler sich entscheiden ob er **zwei** Blumen pflanzen *oder* **einen** Graben bauen möchte.
-    - Die beiden Blumen können beliebig auf dem Spielbrett positioniert werden, müssen jedoch
-    auf leeren Feldern unter Einhaltung der nachfolgenden Regeln für Blumenbeete, Gärten und Gräben
-    gebaut werden.
-    - Gräben müssen immer zwei eigene Blumen verbinden, genauer zwei Eckpunkte von Feldern, in denen eigene Blumen gepflanzt sind.
-- Darüber hinaus kann ein Spieler zu einem beliebigen Zeitpunkt aufgeben, der andere Spieler gewinnt dann das Spiel.
-    
-## Gärten
-- Eine Ansammlung von `4` gleichfarbigen Blumen, die sich an den Seiten berühren, nennt man
-einen **Garten**. Ein Garten besteht immer aus exakt `4` Blumen.
-- Eine Ansammlung von `1`, `2` oder `3` Blumen nennt man ein **Blumenbeet**. Ein Blumenbeet
-kann nie `5` Blumen oder mehr umfassen.
-- Ein Garten darf weder mit einem anderen eigenen Garten noch mit einem anderen eigenen Blumenbeet
-gemeinsame Eckpunkte haben. Das heißt in anderen Worten, dass Gärten eigene Gärten oder Blumenbeete nicht 
-über eine gleiche Seite berühren dürfen (weil dadurch automatisch die Gartengröße überschritten würde) und
-auch nicht über einen gemeinsamen Eckpunkt.
-- Blumenbeete dürfen sich über Eckpunkte berühren.
-- Blumenbeete dürfen nur dann zu einem Garten ausgebaut werden, wenn ...
-    - ... sie dann nicht mehr als `4` Blumen enthalten.
-    - ... sie dann keine weiteren eigenen Gärten oder Blumenbeete berühren.
-- Diese Abstandsregeln gelten nicht für Blumenbeete und Gärten unterschiedlicher Farbe. Blumenbeete und Gärten
-unterschiedlicher Farbe dürfen beliebig nebeneinander liegen oder sich über Eckpunkte berühren.
-
-## Gräben
-- Ein Graben verbindet zwei Blumen über dessen Eckpunkte. Diese Verbindung darf maximal einen Schritt
-entlang der Gitternetzlinien des Spielfeldes lang sein.
-- Ein *Punkt* kann nur ein Grabenende tragen und ist somit für zukünftige Gräben blockiert.
-- Die beiden Felder, die sich mit dem Graben eine gemeinsame Seite teilen, müssen beim Bau
-des Grabens leer sein. Dieselben Felder gelten nach Bau des Grabens als unfruchtbar und dürfen
-von keinen Blumen, unabhängig von der Farbe, bepflanzt werden. Auf den Bau von Gräben haben
-unfruchtbare *Felder* keinen Einfluss.
-
-# Spielende
-- Kann ein Spieler keinen Zug mehr machen, endet das Spiel sofort.
-- Kann ein Spieler keine 2 Blumen mehr anpflanzen und verzichtet auf das Bauen eines Grabens, kann er das Spiel beenden.
-- Nach Zugende werden für beide Spieler die Punkte nach diesen Regeln ermittelt:
-    - Ein einzelner Garten, der nicht über einen Graben mit anderen Gärten verbunden ist,
-    zählt `p(1) = 1` Punkt.
-    - Miteinander verbundene Gärten (auch über einfache Blumenbeete hinweg) geben `p(n)` Punkte, wobei `n`
-    die Anzahl der verbundenen Gärten beschreibt: `p(n) = p(n-1) + n`
-    
-- Bei Punktegleichstand endet das Spiel unentschieden.
-
-# ASCII board design
-```
-                   /\
-                  /  \
-                 /    \
-                /  ++  \
-               /  ++++  \
-              /__________\
-             /\          /\
-            /  \  ++++  /  \
-           /    \  ++  /    \
-          /  **  \    /      \
-         /  ****  \  /        \
-        /__________\/__________\
-       /\          /+          /\
-      /  \  ****  /  +        /  \
-     /    \  **  /    +      /    \
-    /  **  \    /      +    /  ++  \
-   /  ****  \  /        +  /  ++++  \
-  /__________\/__________+/__________\
-```
-
-# Kompilieren und Starten
-Das Projekt basiert auf dem Build-System **Maven**. Folgendermaßen kann ein ausführbares jar-Archiv erzeugt werden:
-```
-mvn compile assembly:single
-```
-Dieses erzeugte Jar-Archiv kann wie folgt gestartet werden:
-```
-java -jar target/NAME_OF_THE_JAR_FILE.jar -size <BOARD_SIZE>
-```
\ No newline at end of file
+- [Spielregeln](specification/rules.md)
+- [Hilfestellungen zur Implementierung](specification/implementation-tips.md)
+- [Computerspieler Strategie](specification/simple-strategy.md)

dummy-game/flowerwarspp/preset/Ditch.java

@@ -4,6 +4,10 @@ import java.io.*;
 import java.util.*;
 
 public class Ditch implements Serializable, Comparable<Ditch> {
+    private static final long serialVersionUID = 1L;
+
+    // ------------------------------------------------------------
+
     private Position[] positions;
 
     // ------------------------------------------------------------

dummy-game/flowerwarspp/preset/Flower.java

@@ -4,6 +4,8 @@ import java.io.*;
 import java.util.*;
 
 public class Flower implements Serializable, Comparable<Flower> {
+    private static final long serialVersionUID = 1L;
+
     public static final int COMBINATIONS = Position.COMBINATIONS * 2 * Position.COMBINATIONS;
 
     // ------------------------------------------------------------

dummy-game/flowerwarspp/preset/Move.java

@@ -4,6 +4,10 @@ import java.io.*;
 import java.util.*;
 
 public class Move implements Serializable, Comparable<Move> {
+    private static final long serialVersionUID = 1L;
+
+    // ------------------------------------------------------------
+
     private MoveType type;
     private Flower[] flowers;
     private Ditch ditch;

dummy-game/flowerwarspp/preset/Player.java

@@ -3,8 +3,8 @@ package flowerwarspp.preset;
 import java.rmi.*;
 
 public interface Player extends Remote {
-    Move request() throws Exception;
-    void confirm(Status status) throws Exception;
-    void update(Move opponentMove, Status status) throws Exception;
-    void init(int boardSize, PlayerColor color) throws Exception;
+    Move request() throws Exception, RemoteException;
+    void confirm(Status status) throws Exception, RemoteException;
+    void update(Move opponentMove, Status status) throws Exception, RemoteException;
+    void init(int boardSize, PlayerColor color) throws Exception, RemoteException;
 }

dummy-game/flowerwarspp/preset/Position.java

 package flowerwarspp.preset;
 
-import javafx.geometry.*;
-
 import java.io.*;
 
 public class Position implements Serializable, Comparable<Position> {
+    private static final long serialVersionUID = 1L;
+
     public static final int MAX_VALUE = 31;
     public static final int COMBINATIONS = MAX_VALUE * MAX_VALUE;
 
@@ -50,7 +50,8 @@ public class Position implements Serializable, Comparable<Position> {
         if (!string.startsWith("(") || !string.endsWith(")"))
             throw new PositionFormatException("wrong outer format! correct format is: (COLUMN,ROW)");
 
-        String[] parts = string.substring(1, string.length() - 1).split(",");
+        String[] parts = string.substring(1, string.length() - 1)
+                               .split(",");
 
         if (parts.length != 2)
             throw new PositionFormatException("wrong number of arguments! correct format is: (COLUMN,ROW)");
@@ -58,7 +59,7 @@ public class Position implements Serializable, Comparable<Position> {
         try {
             return new Position(Integer.parseInt(parts[0]), Integer.parseInt(parts[1]));
         } catch (NumberFormatException e) {
-            throw new PositionFormatException("wrong number format! correct format is: (COLUMN,ROW)");
+            throw new PositionFormatException("wrong number format! valid numbers are 1 to " + MAX_VALUE, e);
         }
     }