Merge remote-tracking branch 'refs/remotes/origin/master' into Ast

Update des Branches erfolgt, um das Debugging zu erleichtern.

.vscode/settings.json

@@ -1,14 +1,17 @@
 // Place your settings in this file to overwrite default and user settings.
 {
 	"files.exclude": {
+		// IDE Einstellungen
 		"**/.git": true,
 		"**/.DS_Store": true,
+		"**/.vscode": true,
+		// Greenfoot Dateien
+		"project.greenfoot": true,
 		"*.class": true,
 		"*.ctxt": true,
-		"project.greenfoot": true,
-		"**/.vscode": true,
-		"*.ods": true,
-		"*.xls": true,
-		"*.xlsx": true
+		// Excel Tabellen
+		"**/*.ods": true,
+		"**/*.xls": true,
+		"**/*.xlsx": true
 	}
 }

ArmySchubser.java

@@ -0,0 +1,95 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import greenfoot.MouseInfo.*;
+import javax.swing.JOptionPane;
+
+/**
+ * Schubst Einheiten umher.
+ * 
+ * @author MaxiJohl, GruenerWal
+ * @version 0.3.0
+ */
+
+public class ArmySchubser extends Map_World
+{    
+    static Province savedProvince = null;
+
+    /**
+     * Konstruktor für ArmySchubser.
+     * 
+     * NICHT BENUTZEN!
+     * Sämtliche benötigten Methoden sind static!
+     */
+    public ArmySchubser(String[] playerList, int[] colorList)
+    {
+        super(playerList,colorList);
+    }
+
+    /**
+     * Nimmt zwei Provinzen entgegen, und fragt, wieviele Einheiten vom ersten zum zweiten Eintrag verschoben werden sollen.
+     * Überprüft, ob eine Verschiebung möglich ist und führt sie bei Erfolg aus.
+     */
+    public static void moveEntities(Province sourceProvince, Province destinationProvince)
+    {
+        String toMoveString = JOptionPane.showInputDialog(null, "Wieviele Einheiten willst du verschieben?");
+        Integer entitiesToMove = Integer.valueOf(toMoveString);
+
+        if ( (sourceProvince.getEntityCount() - entitiesToMove) > 0)
+        {
+            sourceProvince.removeFromEntities(entitiesToMove);
+            destinationProvince.addToEntities(entitiesToMove);
+        }
+
+        if ( (sourceProvince.getEntityCount() - entitiesToMove) <= 0 )
+        {
+            JOptionPane.showMessageDialog(null,"Du hast nicht genügend Einheiten, um die gewünschte Anzahl von " + sourceProvince.getDisplayName() + " nach " + destinationProvince.getDisplayName() + " zu verschieben, Köhler.");
+        }
+    }
+
+    /**
+     * Speichert ein gegebene Provinz als savedProvince ein, insofern dieser Platz nicht bereits belegt ist.
+     * Ist er das, so wird überprüft, ob eine neue, an savedProvince angrenzende Provinz angeklickt wurde.
+     * Ist dies der Fall, werden beide Provinzen an moveEntities übergeben.
+     */
+    public static void useProvincesToMove(Province givenProvince)
+    {
+        if (savedProvince == null)
+        {
+            savedProvince = givenProvince;
+        }
+
+        if (savedProvince != null && givenProvince != savedProvince)
+        {
+            if (givenProvince.isProvinceNear(savedProvince.getID()) == true)
+            {
+                moveEntities(savedProvince,givenProvince);
+            }
+            
+            else
+            {
+                savedProvince = null;
+            }
+        }      
+    }
+
+    /**
+     * Überprüft, ob eine Provinz angeklickt wurde.
+     * Wenn ja, wird diese als clickedProvince eingespeichert und useProvincesToMove aufgerufen.
+     * 
+     * Kommt nachher in die GeneralMap!
+     */
+    public void act() 
+    {
+        Province clickedProvince = null;
+        
+        for ( int i = 1; i <= provinceCount; i++)
+        {
+            if (provinces[i].hasClicked() == true)
+            {
+                clickedProvince = provinces[i];
+                useProvincesToMove(clickedProvince);
+                break;
+            }
+        }
+    }
+}
+

Button.java

@@ -1,19 +1,166 @@
 import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.awt.Color;
 
 /**
- * Write a description of class Menue_Button here.
- * 
- * @author (your name) 
- * @version (a version number or a date)
+	Diese Klasse stellt einen Button dar.
+	Als funktionelles Vorbild dafür hält der Button aus dem .NET-Framework für UWP-Apps dar.
+
+	@author Felix Stupp
+	@version 20.05.2016
+*/
+public class Button extends GUI_Interface {
+	
+	private boolean autoSize = false;
+	private int textSize = 32; // as default text size
+	private String text = "";
+	
+	private ButtonEvent handler;
+	
+	/**
+		Erstellt einen Button mit dem gegebenen Text und der zugehörigen Textgröße.
+		@param txt Der Text, den der Button darstellen soll.
+		@param size Die Textgröße, in der der Button den Text darstellen soll.
+	*/
+	public Button(String txt, int size) {
+		text = txt;
+		textSize = size;
+		redraw();
+	}
+	/**
+		Erstellt einen Button mit dem gegebenen Objekt als Event-Handler.
+		@param h Der Handler mit dem Interface ButtonEvent implementiert.
+	*/
+	public Button(ButtonEvent h) {
+		handler = h;
+		redraw();
+	}
+	/**
+		Erstellt einen Button mit dem gegebenen Text, der zugehörigen Textgröße und dem gegebenen Objekt als Event-Handler.
+		@param txt Der Text, den der Button darstellen soll.
+		@param size Die Textgröße, in der der Button den Text darstellen soll.
+		@param h Der Handler mit dem Interface ButtonEvent implementiert.
+	*/
+	public Button(String txt, int size, ButtonEvent h) {
+		text = txt;
+		textSize = size;
+		handler = h;
+		redraw();
+	}
+	
+	/**
+		Fragt ab, ob ein Klick auf den Button gekommen ist.
+		Wird intern von Greenfoot benötigt.
+	*/
+	public void act() {
+		if(Greenfoot.mouseClicked(this) && handler != this) {
+			handler.buttonClicked(this);
+		}
+	}
+	
+	/**
+		Gibt zurück, ob die Größe des Buttons von dem Text bestimmt werden soll.
+		@return Wert der AutoSize-Eigenschaft
+	*/
+	public boolean getAutoSize() {
+		return autoSize;
+	}
+	/**
+		Legt fest, ob die Größe des Buttons von dem Text bestimmt werden soll.
+		Wird der Wert auf TRUE geändert, erfolgt automatisch ein Redraw des Objekts.
+		@param b Der neue Wert der AutoSize-Eigenschaft.
+	*/
+	public void setAutoSize(boolean b) {
+		autoSize = b;
+		if(autoSize) {
+			redraw();
+		}
+	}
+	
+	/**
+		Gibt die aktelle Textgröße zurück.
+		@return Aktuelle Textgröße
+	*/
+	public int getTextSize() {
+		return textSize;
+	}
+	/**
+		Legt eine neue Textgröße fest.
+		@param s Neue Textgröße
+		@return Gibt an, ob sich die Textgröße geändert hat. Bei TRUE erfolgte bereits ein Redraw.
+	*/
+	public boolean setTextSize(int s) {
+		if(textSize != s && s > 0) {
+			textSize = s;
+			redraw();
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+		Gibt den aktuellen Text zurück.
+		@return Der aktuelle Text
 	*/
-public class Button extends GUI_Interface
-{
+	public String getText() {
+		return text;
+	}
 	/**
-     * Act - do whatever the Menue_Button wants to do. This method is called whenever
-     * the 'Act' or 'Run' button gets pressed in the environment.
+		Setzt den darzustellenden Text auf den neuen Wert.
+		@param s Der neue Text
+		@return Gibt an, ob sich der Text geändert hat. Bei TRUE erfolgte bereits ein Redraw.
 	*/
-    public void act() 
-    {
-        // Add your action code here.
+	public boolean setText(String s) {
+		if(text != s) {
+			text = s;
+			redraw();
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+		Gibt den aktuellen EventHandler des Buttons zurück.
+		@return Der Handler als ButtonEvent
+	*/
+	public ButtonEvent getHandler() {
+		return handler;
+	}
+	/**
+		Setzt den EventHandler auf ein neues Objekt.
+		@param h Der Handler mit implementiertem ButtonEvent-Interface
+	*/
+	public void setHandler(ButtonEvent h) {
+		handler = h;
+	}
+	/**
+		Entfernt den aktuellen EventHandler, um die Ausführung zukünftiger Events zu verhindern.
+	*/
+	public void removeHandler() {
+		handler = null;
+	}
+	
+	/**
+		Zeichnet das GreenfootImage des Buttons erneut und zeigt es an.
+	*/
+	public void redraw() {
+		GreenfootImage tI = new GreenfootImage(text,textSize,foreC,backC);
+		if(autoSize) {
+			sx = tI.getWidth() + (6 * 2) + 4;
+			sy = tI.getHeight() + (6 * 2) + 4;
+		}
+		GreenfootImage all = new GreenfootImage(sx,sy);
+		Color gray = new Color(133,133,133,255);
+		Color black = new Color(0,0,0,255);
+		Color trans = new Color(0,0,0,0);
+		Utils.drawInsideRectangle(all,gray,0);
+		Utils.drawInsideRectangle(all,black,2);
+		Utils.drawInsideRectangle(all,gray,6);
+		Utils.drawInsideRectangle(all,black,7);
+		all.setColorAt(0,0,trans);
+		all.setColorAt(sx-1,0,trans);
+		all.setColorAt(0,sy-1,trans);
+		all.setColorAt(sx-1,sy-1,trans);
+		all.drawImage(tI,(sx-tI.getWidth())/2,(sy-tI.getHeight())/2);
+		setImage(all);
 	}
 }

ButtonEvent.java

@@ -0,0 +1,14 @@
+import greenfoot.*;
+
+/**
+ * Dieses Interface stellt einen Zugriff auf Methoden für die Eventverarbeitung bei Buttons.
+ * Jede Klasse, die als Event-Handler dienen will, muss dieses Interface implementieren.
+ * 
+ * @author Felix Stupp 
+ * @version 26.04.2016
+ */
+public interface ButtonEvent {
+	
+	public void buttonClicked(Button obj);
+	
+}

CurrentPlayerArrow.java

@@ -1,38 +0,0 @@
-import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
-
-/**
- * Write a description of class CurrentPlayerArrow here.
- * 
- * @author (your name) 
- * @version (a version number or a date)
- */
-public class CurrentPlayerArrow extends GUI_Interface
-{
-    /**
-     * Act - do whatever the CurrentPlayerArrow wants to do. This method is called whenever
-     * the 'Act' or 'Run' button gets pressed in the environment.
-     */
-    public void act() 
-    {
-        // Add your action code here.
-    }
-
-    public void CurrentPlayerArrow(int currentPlayer, int playerNumber)
-    {
-        switch (currentPlayer) {
-            case 1 : 
-            setLocation(120,100);
-            break;
-            case 2 : 
-            setLocation(120,100 + (825 / playerNumber));
-            break;
-            case 3 :
-            setLocation(120,100 + (825 / playerNumber)*2);            
-            break;
-            case 4 : 
-            setLocation(120,100 + (825 / playerNumber)*3);
-            break;
-
-        }
-    }
-}

DefenderDices.java

@@ -0,0 +1,17 @@
+import greenfoot.*;
+import java.util.Arrays;   // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.awt.Color;
+
+/**
+	Erstellt eine gegebene Anzahl an DefenderDice's, welche dann nebeneinander eingereiht werden.
+
+	@author Felix Stupp
+	@version 15.06.2016
+*/
+public class DefenderDices extends DicesList {
+
+	public DefenderDices(int count) {
+        super(count, 2, new Color(0,0,0), (new Color(255,255,255)));
+	}
+
+}

Dice.java

@@ -1,19 +1,89 @@
 import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
 
 /**
- * Write a description of class Dice here.
- * 
- * @author (your name) 
- * @version (a version number or a date)
+	Stellt einen Würfel (von 1-6) dar, welcher in der Welt sichtbar dargestellt werden soll.
+
+	@author Felix Stupp
+	@version 13.06.2016
+ */
+public class Dice extends GUI_Interface {
+
+	private int number = 0;
+
+	/**
+		Erstellt einen Würfel mit dem Startwert 0 (für noch nicht verwendet).
+	*/
+	public Dice() {
+		redraw();
+	}
+
+	/**
+		Erstellt einen Würfel mit einem bestimmten Startwert, welcher sofort sichtbar ist.
+	*/
+	public Dice(int startNumber) {
+		number = startNumber;
+		redraw();
+	}
+
+	/**
+		Gibt die aktuelle Zahl, die der Würfel anzeigt, aus. Gibt die Methode 0 zurück, heißt dies, dass der Würfel noch nicht gewürfelt wurde.
+		@return Die aktuelle Augenzahl oder 0
+	*/
+	public int getNumber() {
+		return number;
+	}
+
+	/**
+		Legt die Größe des Würfels als Quadrat fest.
+	*/
+	public void setSizeAsSquare(int l) {
+		setSize(l,l);
+	}
+
+	/**
+		Würfelt den Würfel, erneuert die Darstellung und gibt die neue Augenzahl zurück.
 	*/
-public class Dice extends Actor
-{
+	public int roll() {
+		number = (int) (Math.floor(Math.random()*6)+1);
+		redraw();
+		return number;
+	}
+
 	/**
-     * Act - do whatever the Dice wants to do. This method is called whenever
-     * the 'Act' or 'Run' button gets pressed in the environment.
+		Zeichnet auf dem gegebenen GreenfootImage ein Oval an der gegebenen Stelle multipliziert mit der einheitlichen Größe.
 	*/
-    public void act() 
-    {
-        // Add your action code here.
+	private void fO(GreenfootImage i, int eX, int eY, int x, int y) {
+		i.fillOval(eX*x,eY*y,eX*2,eY*2);
+	}
+
+	/**
+		Erneuert die Darstellung des Würfels.
+	*/
+	public void redraw() {
+		// einheitliche Größe X und Y (ein Vierzehntel der gesamten Breite und Höhe)
+		int eX = (int) Math.round(sx/8);
+		int eY = (int) Math.round(sy/8);
+		// Vereinfachung für die Augenzahl
+		int a = number;
+		GreenfootImage i = new GreenfootImage(sx,sy);
+		i.setColor(new java.awt.Color(0,0,0,0));
+		i.clear();
+		i.setColor(backC);
+		i.fillShape(new java.awt.geom.RoundRectangle2D.Double(0,0,sx,sy,eX,eY));
+		i.setColor(foreC);
+		// das "else" fehlt absichtlich
+		if(a==1||a==3||a==5) { //Mittlerer Punkt
+			fO(i,eX,eY,3,3);
+		} if(a>1) { //Punkte links-oben und rechts-unten
+			fO(i,eX,eY,1,1);
+			fO(i,eX,eY,5,5);
+		} if(a>3) { //Punkte links-unten und rechts-oben
+			fO(i,eX,eY,1,5);
+			fO(i,eX,eY,5,1);
+		} if(a>5) { //Punkte links-mitte und rechts-mitte
+			fO(i,eX,eY,1,3);
+			fO(i,eX,eY,5,3);
+		}
+		setImage(i);
 	}
 }

Dice_Defender.java

@@ -1,3 +1,9 @@
+/*
+    Hinweis zum Verbleib der Klasse:
+    Diese Klasse soll, da sie zurzeit weder vollständig, noch in Verwendung, noch in der Architektur definiert ist, zum Beta-Meilenstein entfernt werden.
+    Sollte die Klasse jedoch zuvor noch Verwendung finden, wird sie nach Absprache mit den jeweiligen Autoren/Benutzern in die Architektur aufgenommen.
+*/
+
 import greenfoot.*;
 import java.util.Arrays;   // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
 

Dice_Offender.java

@@ -1,3 +1,9 @@
+/*
+    Hinweis zum Verbleib der Klasse:
+    Diese Klasse soll, da sie zurzeit weder vollständig, noch in Verwendung, noch in der Architektur definiert ist, zum Beta-Meilenstein entfernt werden.
+    Sollte die Klasse jedoch zuvor noch Verwendung finden, wird sie nach Absprache mit den jeweiligen Autoren/Benutzern in die Architektur aufgenommen.
+*/
+
 import greenfoot.*;
 import java.util.Arrays;   // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
 

DicesList.java

@@ -0,0 +1,63 @@
+import greenfoot.*;
+
+/**
+	Erstellt eine gegebene Anzahl an Dices's, welche dann nebeneinander eingereiht werden.
+
+	@author Felix Stupp
+	@version 15.06.2016
+*/
+public abstract class DicesList extends Actor {
+	
+	private final static int SQUARESIZE = 100; // Anpassbar
+	private Dice[] dices;
+
+	public DicesList(int count, int max, java.awt.Color bC, java.awt.Color fC) {
+		setImage(new GreenfootImage(2,2));
+		if(count < 1) {
+			count = 1;
+		} else if (count > max) {
+			count = max;
+		}
+		for(int i = 1; i < count; i++) {
+			Dice d = new Dice();
+			d.setBackColor(bC);
+			d.setForeColor(fC);
+			d.setSizeAsSquare(SQUARESIZE);
+			dices[i] = d;
+		}
+	}
+
+	protected void addedToWorld(World w) {
+		for(int i = 0; i < dices.length; i++) {
+			w.addObject(dices[i],getX()+(SQUARESIZE*(6/5)*i),getY());
+		}
+		//w.removeObject(this); // Zeile auskommentieren, wenn die Debug-Phase vorbei ist.
+	}
+
+	public int[] getNumbers() {
+		int[] n = new int[dices.length];
+		for(int i = 0; i < dices.length; i++) {
+			n[i] = dices[i].getNumber();
+		}
+		Utils.sortDesc(n);
+		return n;
+	}
+
+	public int[] roll() {
+		int[] n = new int[dices.length];
+		for(int i = 0; i < dices.length; i++) {
+			n[i] = dices[i].roll();
+		}
+		Utils.sortDesc(n);
+		return n;
+	}
+
+	public void removeAll() {
+		for(int i = 0; i < dices.length; i++) {
+			dices[i].getWorld().removeObject(dices[i]);
+		}
+		getWorld().removeObject(this);
+		dices = new Dice[0];
+	}
+
+}

GUI_Interface.java

@@ -1,19 +1,106 @@
 import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.awt.Color;
 
 /**
- * Write a description of class GUI_Interface here.
- * 
- * @author (your name) 
- * @version (a version number or a date)
+	Oberklasse für sämtliche GUI Objekte, wie Labels und Buttons
+	
+	@author Felix Stupp 
+	@version 04.06.2016
 */
-public class GUI_Interface extends Actor
+public abstract class GUI_Interface extends Actor
 {
 	/**
-     * Act - do whatever the GUI_Interface wants to do. This method is called whenever
-     * the 'Act' or 'Run' button gets pressed in the environment.
+		Die Breite des Objektes
 	*/
-    public void act() 
-    {
-        // Add your action code here.
+	protected int sx = 20;
+	/**
+		Die Höhe des Objektes
+	*/
+	protected int sy = 20;
+	/**
+		Die Hintergrundfarbe des Objektes
+	*/
+	protected Color backC = Color.BLACK;
+	/**
+		Die Vordergrundfarbe (meist die Textfarbe) des Objektes
+	*/
+	protected Color foreC = Color.WHITE;
+	
+	/**
+		Gibt die Breite des Objektes zurück.
+		@return Die aktuelle Breite
+	*/
+	public int getWidth() {
+		return sx;
+	}
+	/**
+		Gibt die Höhe des Objektes zurück.
+		@return Die aktuelle Höhe
+	*/
+	public int getHeight() {
+		return sy;
+	}
+	/**
+		Legt die Größe des Objektes neu fest und zeichnet es danach damit neu.
+		Je nach Objekttyp kann diese Größe wieder vom Objekt selbst angepasst werden, falls nötig.
+		@param w Die neue Breite
+		@param h Die neue Höhe
+	*/
+	public void setSize(int w, int h) {
+		if(w < 1 || h < 1) {
+			return;
+		}
+		sx = w;
+		sy = h;
+		redraw();
+	}
+	
+	/**
+		Gibt die aktuelle Hintergrundfarbe des Objektes zurück.
+		@return Die aktuelle Hintergrundfarbe als System.awt.Color
+	*/
+	public Color getBackColor() {
+		return backC;
+	}
+	/**
+		Legt die Hintergrundfarbe des Objektes fest.
+		@param c Die neue Hintergrundfarbe als System.awt.Color
+		@return Gibt an, ob diese Farbe unterschiedlich zur bisherig genutzten Farbe wahr. Bei TRUE erfolgte bereits ein Redraw.
+	*/
+	public boolean setBackColor(Color c) {
+		if(!c.equals(backC)) {
+			backC = c;
+			redraw();
+			return true;
+		}
+		return false;
 	}
+	
+	/**
+		Gibt die aktuelle Vordergrundfarbe (meist die Textfarbe) des Objektes zurück.
+		@return Die aktuelle Vordergrundfarbe als System.awt.Color
+	*/
+	public Color getForeColor() {
+		return foreC;
+	}
+	/**
+		Legt die Vordergrundfarbe (meist die Textfarbe) des Objektes fest.
+		@param c Die neue Vordergrundfarbe als System.awt.Color
+		@return Gibt an, ob diese Farbe unterschiedlich zur bisherig genutzten Farbe wahr. Bei TRUE erfolgte bereits ein Redraw.
+	*/
+	public boolean setForeColor(Color c) {
+		if(!c.equals(foreC)) {
+			foreC = c;
+			redraw();
+			return true;
+		}
+		return false;
+	}
+	
+	public void act() {}
+	
+	/**
+		Diese Funktion soll die erneute Zeichnung des Objekts erzwingen und wird daher auch von (fast) allen set-Methoden aufgerufen, sollte der neue Wert sich von dem alten unterscheiden.
+	*/
+	public abstract void redraw();
 }

GeneralMap.java

@@ -1,104 +1,134 @@
 import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.lang.Math;
 
 /**
- * Oberklasse für verschiedene Maps;
- * neue Maps werden als Unterklasse dieser Klasse eingefügt.
- * 
- * @author GruenerWal, MaxiJohl
- * @version 0.2.0
+	Oberklasse für verschiedene Maps;
+	neue Maps werden als Unterklasse dieser Klasse eingefügt.
+
+	@author GruenerWal, MaxiJohl, Felix Stupp
+	@version 0.3.0
 */
-public class GeneralMap extends World
+public abstract class GeneralMap extends World
 {
-    /**
-     *  Felder, im Moment nur Anzahl der Provinzen
-     *  Später evtl. weitere Werte wie Schwierigkeit denkbar
+	/*
+		Felder, im Moment nur Anzahl der Provinzen
+		Später evtl. weitere Werte wie Schwierigkeit denkbar
 	 */
 
-    protected int provinzen;    
+	private final int X_OFFSET = 0; // Verschiebt die Provinzen nach rechts
+	private final int Y_OFFSET = 0; // Verschiebt die Provinzen nach unten
 
-    /** Konstruktor für nicht weiter definierte Map, sollte im Moment nicht benutzt werden.
-     * Später als Konstruktor für Default-Map denkbar.
+	/*
+		Die einzelnen Positionen der Provinzen wird mit SCALE_VALUE/10000 multipliziert.
+		Dies ist nützlich, wenn die Karte beispielsweise nur noch 80% der Originalgröße bei ihrer Darstellung groß ist.
+		Bei diesem Beispiel wäre hier, neben dem Offset oben, der Wert 0.8 einzutragen.
 	*/
-    public GeneralMap(int x, int y, int p)
-    {    
+	private final double SCALE_VALUE = 1;
+
+	protected Province[] provinces;
+	protected Player[] players;
+	
+	protected int currentPlayer = 0;
+	
 	/**
-         * Erstellt eine leere Karte mit den übergebenen Eigenschaften
-         * @param x X-Ausdehnung der Welt
-         * @param y Y-Ausdehnung
-         * @param p Kantenlänge der Felder in Pixeln
+		Erstellt eine GeneralMap mit allen Eigenschaften und initialisiert die Arrays für Provinzen und Spieler.
+		@param backImage Das Hintergrundbild, welches von dieser Klasse geladen und dargestellt wird.
+		@param playerList Die Liste mit den Namen der Spieler
+		@param colorList Die Liste mit den Farben der Spieler
 	*/
+	public GeneralMap(String backImage, String[] playerList, int[] colorList)
+	{    
         super(1600,900,1);
-        addObject(new Menue_Button(),100,38);
-        addObject(new Roll_Button(),84,835);
-        addObject(new Roll_Button(),1513,835);
+		players = new Player[playerList.length];
+		for (int i = 0; i < playerList.length; i++) {
+			players[i] = new Player(i,playerList[i],colorList[i]);
 		}
-
-    static GeneralMap generateMap(int mapID)
-    {
-        //Platzhalter
-        return null;
 	}
 	
-    int getPlayerCount()
-    {
-        //Platzhalter
-        return 4;
+	/**
+		Fügt alle Provinzen aus dem Array der Welt an der entsprechden Stelle zu.
+	*/
+	protected void initProvinces() {
+		for(int i = 1; i < provinces.length; i++) {
+			addObject(provinces[i],((int) Math.floor(provinces[i].getXPos() * SCALE_VALUE)) + X_OFFSET,((int) Math.floor(provinces[i].getYPos() * SCALE_VALUE)) + Y_OFFSET);
 		}
-
-    String getPlayerName()
-    {
-        //Platzhalter
-        return null;
 	}
 
-    String getPlayerName(int plID)
+	/**
+		Gibt die Anzahl der vorhandenen Spieler aus.
+	*/
+	public int getPlayerCount()
 	{
-        //Platzhalter
-        return null;
+		return players.length;
 	}
 	
-    int getPlayerStars()
+	/**
+		Gibt den Namen des aktuellen Spielers aus.
+		@return Der Name des aktuellen Spielers
+	*/
+	public String getPlayerName()
 	{
-        //Platzhalter
-        return 0;
+		return players[currentPlayer].getDisplayName();
 	}
 	
-    int getProvinceOwner(int prID)
+	/**
+		Gibt den Namen des Spielers aus, dem dessen ID gehört.
+		@param plID Die ID des zu findenden Spielers
+		@return Der Name des Spielers
+	*/
+	public String getPlayerName(int plID)
 	{
-        //Platzhalter
-        return 0;
+		return players[plID].getDisplayName();
 	}
 	
-    int[] getProvinceOwners()
+	/**
+		Gibt die Anzahl der Sterne des aktuellen Spielers zurück.
+		@return Die Anzahl der Sterne des aktuellen Spielers
+	*/
+	public int getPlayerStars()
 	{
-        //Platzhalter; viel Arbeit :3
-        int[] provinceOwners = new int[1];
-        provinceOwners[0] = 0;
-        return provinceOwners;
+		return players[currentPlayer].getStars();
 	}
 	
-    int getProvinceEntityCount(int prID)
+	/**
+		Gibt die ID des Spielers zurück, dem die gefragte Provinz gehört.
+		@param prID Die gefragte Provinz
+	*/
+	public int getProvinceOwner(int prID)
 	{
-        //Platzhalter
-        return 0;
+		if(prID < 1 || prID > provinces.length) {
+			return -1;
 		}
-
-    int getProvincesEntityCounts(int[] prArr)
-    {
-        //Platzhalter
-        return 0;
+		return provinces[prID].getOwner();
 	}
 	
-    int getProvincesEntityCounts(boolean[] prArr)
+	/**
+		Gibt eine Liste mit allen Provinzen und deren Besitzern zurück.
+		@return Array mit der Provinz-ID als Index und dem Besitzer als Wert
+	*/
+	public int[] getProvinceOwners()
 	{
-        //Platzhalter
-        return 0;
+		int[] prOwners = new int[provinces.length];
+		for (int i = 1; i > provinces.length; i++) {
+			prOwners[i] = provinces[i].getOwner();
+		}
+		return prOwners;
 	}
 	
-    int getProvincesEntityCounts(int plID)
+	/**
+		Zählt die Anzahl der Einheiten von allen Provinzen zusammen, die einem bestimmten Spieler gehört.
+		@param playerID Die ID des Spielers, für den die Einheiten gezählt werden sollen.
+		@return Die Anzahl der Einheiten, die dem Spieler gehören.
+	*/
+	public int getProvinceEntityCount(int playerID)
 	{
-        //Platzhalter
-        return 0;
+		int c = 0;
+		for (int i = 1; i > provinces.length; i++) {
+			if(provinces[i].getOwner() == playerID) {
+				c = c + provinces[i].getEntityCount();
+			}
+		}
+		return c;
 	}
 
 }

Label.java

@@ -0,0 +1,103 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.awt.Color;
+
+/**
+	Zeigt einen Text an.
+	
+	@author Felix Stupp
+	@version 13.05.2016
+*/
+public class Label extends GUI_Interface {
+	
+	private boolean autoSize = true;
+	private int textSize = 32; // as default text size
+	private String text = "";
+	
+	/**
+		Erstellt ein neues Label mit dem gegebenen Text und der zugehörigen Textgröße.
+		@param txt Der darzustellende Text
+		@param size Die dazugehörige Textgröße
+	*/
+	public Label(String txt, int size) {
+		text = txt;
+		textSize = size;
+		redraw();
+	}
+	
+	/**
+		Gibt zurück, ob die Größe des Buttons von dem Text bestimmt werden soll.
+		@return Wert der AutoSize-Eigenschaft
+	*/
+	public boolean getAutoSize() {
+		return autoSize;
+	}
+	/**
+		Legt fest, ob die Größe des Buttons von dem Text bestimmt werden soll.
+		Wird der Wert auf TRUE geändert, erfolgt automatisch ein Redraw des Objekts.
+		@param b Der neue Wert der AutoSize-Eigenschaft.
+	*/
+	public void setAutoSize(boolean b) {
+		autoSize = b;
+		if(autoSize) {
+			redraw();
+		}
+	}
+	
+	/**
+		Gibt die aktelle Textgröße zurück.
+		@return Aktuelle Textgröße
+	*/
+	public int getTextSize() {
+		return textSize;
+	}
+	/**
+		Legt eine neue Textgröße fest.
+		@param s Neue Textgröße
+		@return Gibt an, ob sich die Textgröße geändert hat. Bei TRUE erfolgte bereits ein Redraw.
+	*/
+	public boolean setTextSize(int s) {
+		if(textSize != s && s > 0) {
+			textSize = s;
+			redraw();
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+		Gibt den aktuellen Text zurück.
+		@return Der aktuelle Text
+	*/
+	public String getText() {
+		return text;
+	}
+	/**
+		Setzt den darzustellenden Text auf den neuen Wert.
+		@param s Der neue Text
+		@return Gibt an, ob sich der Text geändert hat. Bei TRUE erfolgte bereits ein Redraw.
+	*/
+	public boolean setText(String s) {
+		if(text != s) {
+			text = s;
+			redraw();
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+		Zeichnet das GreenfootImage des Labels erneut und zeigt es an.
+	*/
+	public void redraw() {
+		GreenfootImage tI = new GreenfootImage(text,textSize,foreC,backC);
+		if(autoSize) {
+			sx = tI.getWidth();
+			sy = tI.getHeight();
+		}
+		GreenfootImage all = new GreenfootImage(sx,sy);
+		all.setColor(backC);
+		all.fill();
+		all.drawImage(tI,(sx-tI.getWidth())/2,(sy-tI.getHeight())/2);
+		setImage(all);
+	}
+}

Map_World.java

@@ -1,60 +1,45 @@
 import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
 
 /**
- * Klasse der Standard-Welt
- * (Also die normale Weltkarte mit allen Kontinenten)
- * 
- * @author GruenerWal, MaxiJohl
- * @version 0.3.0
+	Klasse der Standard-Welt
+	(Also die normale Weltkarte mit allen Kontinenten)
+
+	@author GruenerWal, MaxiJohl
+	@version 0.3.0
  */
 
 public class Map_World extends GeneralMap
 {
 	/**
-     * Anzahl der Provinzen.
+		Anzahl der Provinzen.
 	 */
 
 	int provinceCount = 42;
 
 	/** 
-     * Konstruktor der Weltkarte;
-     * konstruiert eine GeneralMap mit den Ausmassen 1600 auf 900 Pixel.
+		Konstruktor der Weltkarte;
+		konstruiert eine GeneralMap mit den Ausmassen 1600 auf 900 Pixel.
 	 */
 
-    public Map_World()
+	public Map_World(String[] playerList, int[] colorList)
 	{
-        super();
+		super("",playerList,colorList);
+		/*
+			Hier werden später sämtliche Provinzen der Standard-Map erstellt.
+			Dies funktioniert folgendermassen:
+			=================================================================
 		
-        Province[] provinces;
+			Dieses kürzere Format ersetzt den langen Code und sorgt eventuell sogar für einen Geschwindigkeitsschub. Dabei sollte diesselbe Funktionalität erhalten bleiben.
 			
-        /**
-         * Hier werden später sämtliche Provinzen der Standard-Map erstellt.
-         * Dies funktioniert folgendermassen:
-         * =================================================================
-         * 
-         * VERALTETER KOMMENTAR VON GruenerWal:
-         * Im Folgenden wird nun jede Provinz einzeln erstellt:
-         * |---
-         * nextProvinces = new int[<Anzahl angrenzende Provinzen>];
-         * <Zuweisung der angrenzenden Provinzen>
-         * provinces[<Provinz-ID>] = new Province(<Provinz-ID>,<Kontinent-ID>,<X-Position>,<Y-Position>,<Anzahl Sterne>,"<Anzeigename>",nextProvinces);
-         * addObject(provinces[<Provinz-ID>],<x-Position>,<y-Position>);
-         * ---|
-         * 
-         * =================================================================
-         * 
-         * NEUES FORMAT VON FELIX STUPP:
-         * Dieses kürzere Format ersetzt den langen Code und sorgt eventuell sogar für einen Geschwindigkeitsschub. Dabei sollte diesselbe Funktionalität erhalten bleiben.
-         * 
-         * provinces[<Provinz-ID>] = new Province(<Provinz-ID>,<Kontinent-ID>,<X-Position>,<Y-Position>,<Anzahl Sterne>,"<Anzeigename>", new int[] { <Liste aller Nachbarprovinzen> });
-         * 
-         * =================================================================
-         * Der Speicherplatz für provinces[0] bleibt leer, da es keine Provinz mit der ID 0 gibt!
-         * 
-         * Und ja, ich weiss, dass das scheisse viel Schreibarbeit ist.
-         * Aber da muss man durch, wir habens auch hinbekommen :P
-         * 
-         * ~GruenerWal
+			provinces[<Provinz-ID>] = new Province(<Provinz-ID>,<Kontinent-ID>,<X-Position>,<Y-Position>,<Anzahl Sterne>,"<Anzeigename>", new int[] { <Liste aller Nachbarprovinzen> });
+		
+			=================================================================
+			Der Speicherplatz für provinces[0] bleibt leer, da es keine Provinz mit der ID 0 gibt!
+		
+			Und ja, ich weiss, dass das scheisse viel Schreibarbeit ist.
+			Aber da muss man durch, wir habens auch hinbekommen :P
+		
+			~GruenerWal
 		 */
 
 		// Festlegung der Provinz-Anzahl
@@ -118,9 +103,6 @@ public class Map_World extends GeneralMap
 		provinces[41] = new Province(41 , 6 , 1000, 595 , 1 , "Ost Australien" , new int[] {40 , 42});
 		provinces[42] = new Province(42 , 6 , 934 , 628 , 1 , "West Australien" , new int[] {40 , 41 , 39});
 
-        for (int c = 1; c <= provinceCount; c++)
-        {
-            addObject(provinces[c],provinces[c].getXPos(),provinces[c].getYPos());
-        }
+		initProvinces();
 	}
 }

Menue_Button.java

@@ -1,3 +1,9 @@
+/*
+    Hinweis zum Verbleib der Klasse:
+    Diese Klasse soll, da sie zurzeit weder vollständig, noch in Verwendung, noch in der Architektur definiert ist, zum Beta-Meilenstein entfernt werden.
+    Sollte die Klasse jedoch zuvor noch Verwendung finden, wird sie nach Absprache mit den jeweiligen Autoren/Benutzern in die Architektur aufgenommen.
+*/
+
 import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
 
 /**
@@ -8,6 +14,10 @@ import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
  */
 public class Menue_Button extends Button
 {
+    public Menue_Button(ButtonEvent h) {
+        super(h);
+    }
+    
     /**
      * Act - do whatever the Menue_Button wants to do. This method is called whenever
      * the 'Act' or 'Run' button gets pressed in the environment.

OffenderDices.java

@@ -0,0 +1,17 @@
+import greenfoot.*;
+import java.util.Arrays;   // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.awt.Color;
+
+/**
+	Erstellt eine gegebene Anzahl an OffenderDice's, welche dann nebeneinander eingereiht werden.
+
+	@author Felix Stupp
+	@version 15.06.2016
+*/
+public class OffenderDices extends DicesList {
+
+	public OffenderDices(int count) {
+        super(count, 3, new Color(255,0,0), (new Color(255,255,255)));
+	}
+
+}

Player.java

@@ -0,0 +1,200 @@
+import greenfoot.*;
+
+/**
+ * Write a description of class Player here.
+ * 
+ * @author (Genosse Betakevin und Genosse Julien) 
+ * @version (version 666)
+ */
+public class Player extends Actor
+{
+    @Override public GeneralMap getWorld(){
+        return (GeneralMap) super.getWorld();
+    }
+    int stars=0;
+    int add=0;
+    int id=0;
+    int provZahl=0;
+    int provVgl=0;
+    int [] stats = new int [6];
+    boolean [] pBesitzer = new boolean [42];
+    boolean gotProv = false;
+    boolean lostProv = false;
+
+    private String n;
+    private int c;
+    //definiert die ID und Namens Variable
+    public Player( int identity,String name, int color)
+    {
+        n = name;
+        id = identity;
+        c = color;
+    }
+    //gibt die Spieler ID zurück
+    public int getID()
+    {
+        return id;
+    }
+    // gibt den Spielernamen zurück
+    public String getDisplayName ()
+    {
+        return n;
+    }
+    //gibt die Sternenanzahl zurück
+    public int getStars ()
+    {
+        return stars;
+    }
+    // erhöht die Sternenzahl um eine random ausgewählte Anzahl von 1-3
+    public void  addToStars ()
+    {  
+
+        int rand;
+        int pre;
+        rand = (int)(1+6*Math.random());
+        if (rand == 1 || rand == 2|| rand == 3)
+        {
+            add = 1;
+        }
+        if (rand == 4|| rand == 5)
+        {
+            add = 2;
+        }
+        if (rand == 6)
+        {
+            add = 3;
+        }
+        if (gotProv== true)
+        {
+            pre = stars;
+            stars+=add;
+            System.out.println("Deine vorherige Sternenanzahl betrug " + pre + ".");
+            System.out.println("Du hast " + add + " Sterne erhalten.");
+            System.out.println("Deine aktuelle Sternenanzahl beträgt " + stars + ".");
+
+        }
+    }
+    //eine Methode um addToStars zu testen
+    public void add ()
+    {
+        addToStars();
+    }
+    //eine für das Testen gedachte Methode, die die Anzahl der Sterne auf ein gewünschtes Maß setzt
+    public int setStars (int set)
+    {
+        stars = set;
+        return stars;
+    }
+    //eine Methode, die das Abziehen von Sternen testet und, wenn das Ergebnis >= 0 ist, die Sternenanzahl um eine gewählte Anzahl verringert
+    public int removeFromStars(int sub)
+    {
+        int s;
+
+        s = stars - sub;
+        if (s>=0)
+        {
+            stars = s;
+        }
+        else 
+        {
+            System.out.println ("Du hast nur " + stars + " Sterne, du kannst also nicht " + sub + " Sterne abziehen");
+        }
+        return stars;
+    }
+
+    public int getProvinceCount ()
+    { 
+        GeneralMap w= getWorld();
+        int[] provinces = w.getProvinceOwners();
+        for (int x=0; x<=42; x++ )
+        {
+            if ( provinces [x] ==id)
+            {
+                provZahl++;
+
+            }
+        }
+        if(stats[2] < provZahl)
+        {
+            stats[2]=provZahl;
+
+        }
+        return provZahl;
+    }
+
+    public void gotEntities(int gotEnt)
+    {
+        stats[3]+= gotEnt;
+    }
+    public void lostEntity()
+    {
+        stats[4]+=1;
+    }
+    private void maxEntities(int entNumber)
+    {
+        if (stats[5]< entNumber)
+        {
+            stats[5]=entNumber;
+        }
+    }
+    public boolean[] getMyProvinces()
+    {
+        GeneralMap w= getWorld();
+        int[] provinces = w.getProvinceOwners();
+        for (int x=0; x<=42; x++)
+        {
+            if (provinces[x]== id)
+            {
+                pBesitzer[x]=true;
+            }
+            else 
+            {
+                pBesitzer[x]=false;
+            }
+
+        }
+        return pBesitzer;
+    }
+
+    private void gotlostProvince()
+    {
+        if (provVgl== provZahl)
+        {
+            gotProv = false;
+            lostProv =false;
+
+        }
+        if(provVgl< provZahl)
+        {
+            gotProv = true;
+            lostProv = false;
+            stats[0]+=1;
+        }
+        if (provVgl > provZahl) 
+        {
+            gotProv = false;
+            lostProv = true;
+            stats[1]+=1;
+        }
+        provVgl = provZahl;
+    }
+
+    public boolean getGotProvince ()
+    {
+        return gotProv;  
+    }
+
+    public boolean getLostProvince()
+    {
+        return lostProv; 
+    }
+    public int[] getStatistics()
+    {
+        return stats;
+    }
+    private void redrawPlayer()
+    {
+        //Platzhalter
+     int x=0;   
+    }
+}

Province.java

@@ -1,14 +1,18 @@
-import greenfoot.*;
-import java.awt.Color;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.awt.Color;
 
 /**
  * Write a description of class Province here.
  * 
- * @author GruenerWal
+ * @author GruenerWal, Felix Stupp
  * @version 0.0.2
  */
 public class Province extends Actor
 {
+    @Override public GeneralMap getWorld() {
+        return (GeneralMap) super.getWorld();
+    }
+    
     private int stars = 1;
     private int provinceID;
     private String displayName;
@@ -19,13 +23,16 @@ public class Province extends Actor
     private int yPos;
     private int eCount;
     
+    private boolean clicked = false;
+    
     /**
-     * leere Act-Methode
-     * (Für später; falls die Provinz bestimmte Aktionen ausführen sollte.)
+     * Überprüft, ob die Provinz angeklickt wurde.
      */
     public void act() 
     {
-        // GruenerWal war hier :3
+        if(Greenfoot.mouseClicked(this)) {
+            clicked = true;
+        }
     }
 
     // Haupt-Konstruktor
@@ -39,22 +46,22 @@ public class Province extends Actor
             stars = st;
         }
         displayName = s1;
-        // Der Teil, der sich um die Konvertierung des int-Array in ein boolean-Array kümmert.
+        // Der Teil, der sich um die Konvertierung des int-Array in ein boolean-Array kümmert.
         int maxNum = 0;
-        for(int i = 0; i >= ia1.length; i++) {
+        for(int i = 0; i < ia1.length; i++) {
             if(maxNum < ia1[i]) {
                 maxNum = ia1[i];
             }
         }
-        nextProvinces = new boolean[ia1.length];
-        for(int i = 0; i >= ia1.length; i++) {
+        nextProvinces = new boolean[maxNum+1];
+        for(int i = 0; i < ia1.length; i++) {
             if(ia1[i] >= 0) {
                 nextProvinces[ia1[i]] = true;
             }
         }
     }
 
-    // Zweiter Konstruktor, um auch das boolean-Array gegebenenfalls verwenden zu könnnen.
+    // Zweiter Konstruktor, um auch das boolean-Array gegebenenfalls verwenden zu könnnen.
     public Province(int pID, int cID, int x, int y, int st, String s1, boolean[] ba1)
     {
         provinceID = pID;
@@ -92,7 +99,7 @@ public class Province extends Actor
         return continentID;
     }
 
-    // Fragt ab, ob die angegebene Provinz in der Nähe von dieser liegt.
+    // Fragt ab, ob die angegebene Provinz in der Nähe von dieser liegt.
     public boolean isProvinceNear(int i) {
         if(i >= nextProvinces.length) {
             return false;
@@ -118,7 +125,7 @@ public class Province extends Actor
         return owner;
     }
 
-    // Setzt den Owner, benötigt String
+    // Setzt den Owner, benötigt String
     public void setOwner(int o)
     {
         if(o < -1) {
@@ -157,100 +164,106 @@ public class Province extends Actor
 
     public void redrawProvince()
     {
-        int schriftgröße;
-        schriftgröße = 20;
+        int textSize;
+        textSize = 20;
         GreenfootImage province = new GreenfootImage(100,100);   
-        GreenfootImage provinceName = new GreenfootImage(displayName,schriftgröße,new Color(0,0,0),new Color(1.0f,1.0f,1.0f,0.5f));
+        GreenfootImage provinceName = new GreenfootImage(displayName,textSize,new Color(0,0,0),new Color(1.0f,1.0f,1.0f,0.5f));
         province.drawImage(provinceName,0,0);
-        oDecide(province,schriftgröße);        
+        oDecide(province,textSize);        
     }
 
-    public void oDecide(GreenfootImage province,int schriftgröße)
+    public void oDecide(GreenfootImage province,int textSize)
     {
         String ownerString;
         switch(owner)
         {
             case 1:
             ownerString = "schwarz";
-            eCalculate(province,ownerString,schriftgröße);
+            eCalculate(province,ownerString,textSize);
             break;
             case 2:
             ownerString = "rot";
-            eCalculate(province,ownerString,schriftgröße);
+            eCalculate(province,ownerString,textSize);
             break;
             case 3:
             ownerString = "blau";
-            eCalculate(province,ownerString,schriftgröße);
+            eCalculate(province,ownerString,textSize);
             break;
             case 4:
             ownerString = "gelb";
-            eCalculate(province,ownerString,schriftgröße);
+            eCalculate(province,ownerString,textSize);
             break;
             case 5:
             ownerString = "gr++n";
-            eCalculate(province,ownerString,schriftgröße);
+            eCalculate(province,ownerString,textSize);
             break;
             case 6:
             ownerString = "lila";
-            eCalculate(province,ownerString,schriftgröße);
+            eCalculate(province,ownerString,textSize);
 
         }
         
     }
 
-    private void eCalculate(GreenfootImage province, String ownerString,int schriftgröße)
+    private void eCalculate(GreenfootImage province, String ownerString,int textSize)
     {
         int eCountTanks = eCount / 5;
         GreenfootImage tank = new GreenfootImage("images\\dickebertaskal-" + ownerString + ".png");
-        tank.scale(schriftgröße,schriftgröße);
+        tank.scale(textSize,textSize);
         if(eCountTanks <= 3)
         {
             if(eCountTanks == 1)
             {
-                province.drawImage(tank,0,schriftgröße);                 
+                province.drawImage(tank,0,textSize);                 
             }
             if(eCountTanks == 2)
             {
-                province.drawImage(tank,0,schriftgröße);
-                province.drawImage(tank,17,schriftgröße);  
+                province.drawImage(tank,0,textSize);
+                province.drawImage(tank,17,textSize);  
             }
             if(eCountTanks == 3)
             {
-                province.drawImage(tank,0,schriftgröße);
-                province.drawImage(tank,schriftgröße,schriftgröße);  
-                province.drawImage(tank,schriftgröße,schriftgröße); 
+                province.drawImage(tank,0,textSize);
+                province.drawImage(tank,textSize,textSize);  
+                province.drawImage(tank,textSize,textSize); 
             }
         }
         else
         {
-            GreenfootImage eCountTanksImage = new GreenfootImage(Integer.toString(eCountTanks) + "x",schriftgröße,Color.CYAN,new Color(1.0f,1.0f,1.0f,0.5f));
-            province.drawImage(eCountTanksImage,0,schriftgröße);
-            province.drawImage(tank,45,schriftgröße);
+            GreenfootImage eCountTanksImage = new GreenfootImage(Integer.toString(eCountTanks) + "x",textSize,Color.CYAN,new Color(1.0f,1.0f,1.0f,0.5f));
+            province.drawImage(eCountTanksImage,0,textSize);
+            province.drawImage(tank,45,textSize);
         }
         int eCountHorse = (eCount - (eCountTanks * 5))/3;
         GreenfootImage horse = new GreenfootImage("images\\pferdreiterskal-" + ownerString + ".png");
-        horse.scale(schriftgröße,schriftgröße);
+        horse.scale(textSize,textSize);
         if(eCountHorse == 1)
         {
-            province.drawImage(horse,0,2 * schriftgröße);           
+            province.drawImage(horse,0,2 * textSize);           
         }
         GreenfootImage Inf = new GreenfootImage("images\\infanterieskal-" + ownerString + ".png");
         int eCountInf = eCount - (eCountTanks * 5) - (eCountHorse * 3);
-        Inf.scale(schriftgröße,schriftgröße);
+        Inf.scale(textSize,textSize);
         if(eCountInf <= 4)
         {
             if(eCountInf == 1)
             {
-                province.drawImage(Inf,0,3* schriftgröße);
+                province.drawImage(Inf,0,3* textSize);
             }
             if(eCountInf == 2)
             {
-                province.drawImage(Inf,0,3 * schriftgröße);
-                province.drawImage(Inf,25,3 * schriftgröße);  
+                province.drawImage(Inf,0,3 * textSize);
+                province.drawImage(Inf,25,3 * textSize);  
             }           
         }
         setImage(province);
     }
 
+    public boolean hasClicked() {
+        boolean b = clicked;
+        clicked = false;
+        return b;
+    }
+    
 }
 

README.md

@@ -4,6 +4,8 @@ Zweiundvierzig
 Dieses Projekt soll zu einem von Risiko inspiriertem Java Computer Spiel werden.
 Genutzt wird hierfür die Umgebung von [Greenfoot](http://www.greenfoot.org/overview) von der Universität von Kent.
 
-[Link zum Architekturplan](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/architektur.md)
+[Link zum Architekturplan auf dem aktuellen Branch](planung/architektur.md)
+
+[Link zur Funktionsliste auf dem aktuellen Branch](planung/funktionsliste.md)
 
 **Weitere Informationen hier werden folgen.**

Roll_Button.java

@@ -1,3 +1,9 @@
+/*
+    Hinweis zum Verbleib der Klasse:
+    Diese Klasse soll, da sie zurzeit weder vollständig, noch in Verwendung, noch in der Architektur definiert ist, zum Beta-Meilenstein entfernt werden.
+    Sollte die Klasse jedoch zuvor noch Verwendung finden, wird sie nach Absprache mit den jeweiligen Autoren/Benutzern in die Architektur aufgenommen.
+*/
+
 import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
 
 /**
@@ -8,6 +14,10 @@ import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
  */
 public class Roll_Button extends Button
 {
+    public Roll_Button(ButtonEvent h) {
+        super(h);
+    }
+    
     /**
      * Act - do whatever the Würfel_Button_Angriff wants to do. This method is called whenever
      * the 'Act' or 'Run' button gets pressed in the environment.

Utils.java

@@ -1,34 +1,75 @@
 import greenfoot.*;
+import java.awt.Color;
+import java.util.*;
 
 /**
- * Diese Klasse enthält nur statische Funktionen, welche für euch als Unterstützung gedacht sind. Damit könnt ihr dann hoffentlich viele Code-Zeilen sparen. :)
- * 
- * @author Zocker1999_NET
- * @version 1
+	Diese Klasse enthält nur statische Funktionen, welche für euch als Unterstützung gedacht sind. Damit könnt ihr dann hoffentlich viele Code-Zeilen sparen. :)
+
+	@author Zocker1999_NET
+	@version 15.06.2016
  */
 public final class Utils {
 	
-	//Kopiert ein Array eines (annäherend) beliebigen Types.
+	/**
+		Kopiert ein boolean-Array und übergibt diese.
+		@param a Das zu kopierende Array
+		@return Die Kopie des Arrays
+	*/
 	public static boolean[] copyArray(boolean[] a) {
 		boolean[] b = new boolean[a.length];
-		for(int i = 0; i >= a.length; i++) {
+		for(int i = 0; i < a.length; i++) {
 			b[i] = a[i];
 		}
 		return b;
 	}
+	/**
+		Kopiert ein int-Array und übergibt diese.
+		@param a Das zu kopierende Array
+		@return Die Kopie des Arrays
+	*/
 	public static int[] copyArray(int[] a) {
 		int[] b = new int[a.length];
-		for(int i = 0; i >= a.length; i++) {
+		for(int i = 0; i < a.length; i++) {
 			b[i] = a[i];
 		}
 		return b;
 	}
+	/**
+		Kopiert ein String-Array und übergibt diese.
+		@param a Das zu kopierende Array
+		@return Die Kopie des Arrays
+	*/
 	public static String[] copyArray(String[] a) {
 		String[] b = new String[a.length];
-		for(int i = 0; i >= a.length; i++) {
+		for(int i = 0; i < a.length; i++) {
 			b[i] = a[i];
 		}
 		return b;
 	}
 	
+	/**
+		Zeichnet innerhalb eines GreenfootImage ein gefülltes Rechteck in der gegebenen Farbe und mit dem gegebenen Abstand zum Rand.
+		@param i Das GreenfootImage, in dem gezeichnet werden soll.
+		@param c Die Farbe, in der das gefüllte Rechteck gezeichnet werden soll.
+		@param b Der Abstand zum Rand der Grafik.
+	*/
+	public static void drawInsideRectangle(GreenfootImage i, Color c, int b) {
+		int sx = i.getWidth();
+		int sy = i.getHeight();
+		i.setColor(c);
+		i.fillRect(b,b,sx-(2*b),sy-(2*b));
+	}
+	
+	/**
+		Sortiert ein int[]-Array absteigend.
+		@param a Das zu sortierende Array
+	*/
+	public static void sortDesc(int[] a) {
+		Arrays.sort(a);
+		int[] b = copyArray(a);
+		for(int i = (a.length - 1); i >= 0; i--) {
+			a[i] = b[i];
+		}
+	}
+
 }

planung/README.md

@@ -1,7 +1,7 @@
 Planung
 =======
 
-Hier sind nun für unser Team sämtliche Dokumente, die während der Planung des Projekts aufgetretten sind oder noch werden, zu finden. Eventuell wird noch zusätzliche Software wie Word benötigt, um diese Dateien anzeigen zu können.
+Hier sind nun für unser Team sämtliche Dokumente, die während der Planung des Projekts aufgetreten sind oder noch werden, zu finden. Eventuell wird noch zusätzliche Software wie Word benötigt, um diese Dateien anzeigen zu können.
 
 Dasselbe lässt sich hier nochmal mit Office Integration bei mir in OneDrive anzeigen:
 [Hier klicken](https://onedrive.live.com/redir?resid=C26B53478C4AFFD1!238212&authkey=!ADhY-TMN8w_Egjc&ithint=folder%2cjpg OneDrive von Felix Stupp)

planung/architektur.md

@@ -1,74 +1,70 @@
 # Architekturplan Zweiundvierzig
 
-**Version: 2**
+**Letztes Update: 15.06.2016** (TT.MM.JJJJ / DD.MM.YYYY)
 
-**Stand: 10.04.2016** (TT.MM.JJJJ / DD.MM.YYYY)
+[Hier die offizielle Version vom Master-Branch sehen](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/architektur.md)
 
-[Hier die neuste offizielle Version vom Master-Branch sehen](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/architektur.md)
+[Hier zur übersichtlichen Funktionsliste auf dem aktuellen Branch](funktionsliste.md)
 
-[Hier zur übersichtlicheren Funktionsliste](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/funktionsliste.md)
+Dieser Plan wird verfasst und regelmäßig gepflegt durch *Felix Stupp*. Das Alter der vorliegenden Version ist am Datum am Dateianfang zu erkennen.
 
-Hier ein möglicher Architekturplan von *Felix Stupp*.
-Dieser Plan wird regelmäßig angepasst, oben am Datum zu erkennen.
+## Erklärung zur Architektur
 
-Hier werden alle Klassen und deren öffentliche Methoden und Eigenschaften zusammengefasst.
-Auch zu sehen ist der Author / sind die Authoren der Klasse, um bei Fragen diese kontaktieren zu können.
+Hier werden alle Klassen mit deren öffentliche Methoden (**public** und **protected**) und den vorgesehenen Eigenschaften (nur **private**) festgehalten.
 
-**Alle Anfragen aufgrund von Architekturänderungen erst an mich weitergeben, damit ich dies mit den jeweiligen Authoren besprechen kann!**
-Die Authoren sollen nur Fragen zu bisher vorhandenen Methoden erhalten.
+**Alle Fragen zur Architektur oder auch Änderungsvorschläge gerne an mich weitergeben.** Ich werde dies dann behandeln und gegebenfalls auch Änderungen an der Architektur durchführen.
 
-### Erklärung
+### Wichtige Infos
 
-Die englischen Begriffe *World* und *Actor* stehen für die gegebenen Oberklassen von Greenfoot.
+- **Bitte kommentiert all eure Methoden nach dem Java-Standard, damit diese in der automatisch generierten Dokumentation auch mit einer kurzen Erklärung auftauchen.**
+- **Die Provinz-ID und somit auch die Indexe der Arrays beginnen dafür erst bei 1!**
 
-### Generell
+### Hinweise
 
-- Allgemein wird vom Konstruktor erwartet, dass er alle feste Eigenschaften einer Klasse in der Reihenfolge, wie hier in den Listen vorzufinden, und als die angegebenen Typen annimmt und korrekt speichert. Es kann aber auch spezifische Konstruktoren geben.
+- Die englischen Begriffe *World* und *Actor* stehen für die gegebenen Oberklassen von Greenfoot.
+- Alle Methoden sind meist als **public** zu sehen und werden hauptsächlich von anderen Klassen aufgerufen.
+- Die Kategorie **Privat Eigenschaften** wird nur aufgelistet, wenn die Klasse von mehreren Autoren geschrieben wird/wurde oder die Klasse noch geschrieben werden muss.
 
-### Tipps
+### Abkürzungen
 
-- Alle Klassen, die als Actor agieren, müssen teilweise mit ihrer Welt interagieren. Um diese richtig gleich richtig entgegen nehmen zu können und auf die Features zugreifen zu können, kann euch folgender Code Snippet helfen. Einfach einfügen und **getWorld()** wird euch besser helfen können.
+- **GUI** ([Graphical User Interface](https://de.wikipedia.org/wiki/Grafische_Benutzeroberfl%C3%A4che)): Beschreibt die Möglichkeit, durch welche ein Benutzer gewöhnlicherweise mit Programmen interagieren kann.
 
+### Tipps
 
-	@Overrides private GeneralMap getWorld() {
+- Falls euere Aufgabe die Umsetzung einer Methode ist, die hier bereits beschrieben wird, müsst ihr nicht diesselben Parameterbezeichner verwenden, wie sie hier verwendet wurden. Falls aus diesem Bezeichner jedoch nicht mehr die Bedeutung des Parameters ausgeht, muss dies in einem Java-Documentation Kommentar erklärt werden.
+- Alle Klassen, die als Actor agieren und **nur** in der auf der *GeneralMap* beziehungsweise der Unterklassen dieser Klasse eingesetzt werden, müssen teilweise mit dieser Welt interagieren. Um die aktuelle Welt sofort im richtigen Typ zu bekommen, damit auf unsere Funktionen zugegriffen werden können, kann euch folgender Code Snippet helfen. Einfach in die Klassen einfügen einfügen und **getWorld** () wird euch besser helfen können.
+``` java
+@Override public GeneralMap getWorld() {
 	return (GeneralMap) super.getWorld();
 }
+```
+- Arbeitet bitte, wenn möglich, mit der *Utils*-Klasse, diese kann helfen den Code übersichtlicher und kürzer zu gestalten, da häufige und allgemein umsetzbare Aufgaben über diese einheitlich abgearbeitet werden sollen. Das Debuggen wird somit auch einfacher, sowohl für mich als auch für euch selbst.
+- Ihr könnt auch ab und zu in die Dokumentationen der offiziellen Java-Bibliotheken schauen, falls ihr denkt, dass es bereits eine Methode geben sollte für den Vorgang, den ihr sonst selbst programmieren müsstet.
 
-- Schaut bitte in die *Utils*-Klasse hinein, diese kann euch den Code übersichtlicher gestalten, da häufige Methoden in dieser gebündelt werden sollen.
-
-### Explizite Eigenschaften
-
-Explizite Eigenschaften sind speziell Eigenschaften, die von der Klasse selbst gehalten werden und bevorzugt auch nur von ihr festgehalten werden.
-
-Beispiel:
-
-Ein Spieler besitzt zwar Provinzen, nur ist dies eine Eigenschaft der Provinz und nicht vom Spieler.
-Der Spieler kann mithilfe der Welt dann herausfinden, welche Provinzen ihm gehören.
+---
 
-## Inhalt
+## Klassenverzeichnis
 
 ### Worlds
 
+- World für den Spielstart
 - *GeneralMap*
 - Alle spezifischen Maps
 	- *Map_World* (gesamte Weltkarte)
-- *MainMenu*
-- *GameOptions*
 
 ### Actors
 
-- *Province* (von Achim)
+- *Province*
 - *Player*
-- *Dice* (Würfel)
-
-### Sonstige Actors (Control Elemente)
 
 - *GUI_Interface*
 	- *Label*
 	- *Button*
-	- *Menue_Button*
-	- *Roll_Button*
-- *CurrentPlayerArrow*
+	- *Dice*
+
+- *DicesList*
+	- *OffenderDices*
+	- *DefenderDices*
 
 ### Sonstige
 
@@ -76,15 +72,13 @@ Der Spieler kann mithilfe der Welt dann herausfinden, welche Provinzen ihm gehö
 
 ---
 
-## MainMenu
+## Spielstart
 
-Stellt eine *World* als Hauptmenü dar, bekommmt die Aufgabe, die einzelnen Menüpunkte anzuzeigen. Aktiviert gegebenenfalls andere *Worlds*.
+Diese *World* hat die Aufgabe, zum einen den Titelbildschirm (mit einem schönen Hintergrundbild, welches später noch optional gezeichnet wird) des Spiels anzeigt, daraufhin ein Menü mit den Möglichkeiten, ein Spiel zu starten oder zu laden (der Button für das Laden eines Speicherstand's bleibt vorerst ohne Funktion, auch optional geplant). Beim Erstellen eines neuen Spiels soll man sowohl die Möglichkeit bekommen, die Eigenschaften der Spieler und die der Map auszuwählen.
 
----
-
-## GameOptions
+Dies kann entweder in verschiedenen *World*'s gelöst werden, als auch in einer einzelnen. Dies bleibt euch zusammen mit dem Design diesem Menü überlassen.
 
-Eine *World*, welche das Optionsmenü vor dem Start eines Spiels anzeigt. Diese erstellt dann eine Weltkarte über **generateMap()** und übergibt diese Greenfoot als neue *World*.
+Ich schlage euch vor, die bereits von mir erstellen Steuerelemente *Label* und *Button* zu verwenden. Diese sollten die Arbeit für euch wesentlich erleichtern, genauso wie das Schreiben von neuen Steuerelementen, falls ihr bemerken sollte, dass ihr diese öfters braucht als einmal. Diese sollten dann auch selbst von der Oberklasse *GUI_Interface* erben.
 
 ---
 
@@ -94,39 +88,54 @@ Alle spezifischen Maps erben von dieser Oberklasse.
 Diese Klasse ist für Greenfoot die aktive *World* im laufenden Spiel und auch für die Anzeigen links/rechts/unten verantwortlich.
 Die erbenden Unterklassen legen dann das Hintergrundbild, die Provinzen, und weitere spezifische Eigenschaften der Karten dar.
 Diese Oberklasse kümmert sich dabei um die Anzeigen, die Spielmechanik und die Speicherung der Spieler und Provinzen.
+Auch, wenn diese Klasse einen Konstruktor besitzt, ist dieser nur für die Unterklassen, also für die spezifischen Maps, als Vereinfachung gedacht.
+
+### Konstruktorparameter
+
+Als ersten Parameter wird die *GeneralMap* den Dateinamen des Hintergrundbilds der Map als *String* erwarten, welches automatisch von der jeweiligen Map-Klasse übergeben wird. Die folgenden Parameter werden von allen Map-Klassen, inklusive der *GeneralMap*, erwartet. Die Unterklassen sollen hierbei alles 1:1 weitergeben.
+
+1. Spielerliste mit den Namen als *String[]*
+2. Liste mit den jeweiligen "Farben" der Spieler als *int[]*
+
+#### Hintergrundbild
+
+Dies soll von den Konstruktoren der spezifischen Maps weitergegeben werden. Der Dateiname ist dort jeweils angepasst und direkt im Code als Konstante angegebenen. Diese Oberklasse übernimmt dann alle Aktionen, um es im Hintergrund der GUI Grafik anzuzeigen.
+
+#### Spielerliste und "Farben"-Liste
 
-### Spezifischer Konstruktor
+Die beiden Arrays sollen Grundinformationen zu den Spielern weitergeben. Weitere Informationen zu den "Farben" sind bei der *Player*-Klasse zu finden.
 
-Für diese Klasse wird der Konstruktor nicht direkt von den Eigenschaften festgelegt, sondern muss folgende Argumente annehmen:
+### Private Eigenschaften
 
-1. Spielerliste mit den Namen **String[]**
-2. ...
+- Spielerliste (*Player[]*, der Index entspricht der Spieler ID, *anfangend bei 0*)
+- Provinzliste (*Province[]*, als **protected** definiert, der Index entspricht der Provinz ID, *anfangend bei 1*)
 
-### Explizite Eigenschaften
+#### Spielerliste
 
-- Spielerliste (**Player[]**, der Index ist die Spieler ID, *anfangend bei 0*)
-- Provinzliste (**Province[]**, der Index ist die Provinz ID, *anfangend bei 0*)
-- aktueller Spieler (**int**)
+Diese Liste soll alle *Player*-Objekte für die Spieler enthalten, welche dann auch als Actor links von der Karte zu sehen sein sollten.
 
-### Zusätzliche Methoden
+#### Provinzliste
 
-- **static GeneralMap generateMap(int mapID, ...)**
+Die Provinzliste enthält alle Provinzobjekte, die auf der Karte zu sehen sind. Diese wird erst vom Konstruktor der spezifischen Maps gefüllt.
 
-- **int getPlayerCount()**
-- **String getPlayerName()**
-- **String getPlayerName(int)**
-- **int getPlayerStars()**
+### Protected Methoden
 
-- **int getProvinceOwner(int)**
-- **int[] getProvinceOwners()**
-- **int getProvinceEntityCount(int)**
-- **int getProvincesEntityCounts(int[])**
-- **int getProvincesEntityCounts(boolean[])**
-- **int getProvincesEntityCounts(int)**
+- *void* **initProvinces** ()
 
-#### generateMap()
+#### initProvinces()
 
-Diese statische Funktion generiert eine Map mit der gegebenen ID. Die **...**-Argumente sind dabei alle Argumente, die an dessen Konstruktor weitergegeben werden müssen.
+Diese Methode soll das Hinzufügen der Provinzen an die richtige Position auf der *World* übernehmen (nicht ins Array). Diese Methode sucht sich alle Provinzen aus dem Array *Province[]* **provinces**.
+
+### Public Methoden
+
+- *int* **getPlayerCount** ()
+- *String* **getPlayerName** ()
+- *String* **getPlayerName** ( *int* playerID )
+- *int* **getPlayerStars** ()
+
+- *int* **getProvinceOwner** ( *int* provinceID )
+- *int[]* **getProvinceOwners** ()
+- *int* **getProvinceEntityCount** ( *int* playerID )
 
 #### getPlayerCount()
 
@@ -150,50 +159,43 @@ Gibt ein Array mit allen Provinzen (deren ID als Indexen) und den Spieler IDs al
 
 #### getProvinceEntityCount()
 
-Gibt die Anzahl der Einheiten aus einer bestimmten Provinz zurück. Bei falschen Indexen muss eine 0 zurückgegeben werden.
-
-#### getProvincesEntityCounts()
-
-Zählt die Einheiten aus mehreren Provinzen zusammen und gibt die Summe davon aus.
-
-Die **int[]** Variante bekommt dabei in einem Array als Werte die IDs der Provinzen, von denen sie es zählen soll, unabhängig vom Besitzer.
-
-Die **boolean[]** Variante bekommt ein Array, bei dem die Indexen die Provinzen angeben und der **boolean**-Wert, ob diese Provinz mitgezählt werden soll.
-
-Die **int** Variante bekommt nur die ID des Spielers und zählt dabei alle Einheiten, die er besitzt.
+Gibt die Anzahl der Einheiten von einer bestimmten Provinz zurück. Bei falschen Indexen muss eine 0 zurückgegeben werden.
 
 ---
 
 ## Spezifische Maps
+*extends GeneralMap*
 
-Alle Maps erben von *GeneralMap*
+Diese Unterklassen enthalten Informationen wie das Hintergrundbild der jeweiligen Map als auch die Anordnung der Provinzen auf der Map.
 
-### Spezifischer Konstruktor
+### Konstruktorparameter
 
-Die Konstruktoren der Unterklassen rufen erst mit den gegebenen Argumenten den *super*-Konstruktor auf, um danach die spezifischen Dinge festlegen zu können (Provinzen bspw.)
+Diese Konstruktorparameter müssen nur zu dieser weitergeleitet werden. Für weitere Informationen bitte bei der *GeneralMap* nachschlagen.
 
 ---
 
 ## Province
+*extends Actor*
 
-Wird verwaltet von Achim.
 Speichert Informationen zu den einzelnen Provinzen ab und stellt diese später auch als *Actor* dar.
 
-### Explizite Eigenschaften
+### Konstruktorparameter
 
-- Provinznummer (über Konstruktor festgelegt, **int**)
-- Kontinentnummer (über Konstruktor festgelegt, **int**)
-- X/Y-Position auf der Karte (über Konstruktor festgelegt; **int**,**int**)
-- Anzeigename (über Konstruktor festgelegt, **String**)
-- Sterne (über Konstruktor festgelegt, **int**)
-- Angrenzende Provinzen (über Konstruktor als **int[]** festgelegt, als **boolean[]** gespeichert)
-- Besitzer
-- Einheitenanzahl
+0. Provinznummer als *int*
+0. Kontinentnummer als *int*
+0. X-Position auf der Karte als *int*
+0. Y-Position auf der Karte als *int*
+0. Anzeigename als *String*
+0. Sterne als *int*
+0. Angrenzende Provinzen als *int[]* (als als *boolean[]* gespeichert)
+
+#### Provinz-ID
+
+Stellt die ID der Provinz dar.
 
-#### Provinz-ID und Kontinent-ID
+#### Kontinent-ID
 
-- Stellt die ID der Provinz dar und ist mit **int getID()** abrufbar.
-- Stellt die ID des Kontinentes dar und ist mit **int getContinentID()** abrufbar.
+Stellt die ID des Kontinentes dar.
 
 #### Position
 
@@ -204,26 +206,34 @@ Sind nach dem Erstellen der Provinz nicht mehr abrufbar.
 
 Dies ist der Name, der auf der Karte und bei Events im Zusammenhang mit dieser Provinz angezeigt wird.
 
-Kann über **String getDisplayName()** abgerufen werden, falls benötigt.
-
 #### Sterne
 
-Dieser Wert wird für die zufällige Verteilung von Einheiten benötigt (laut Achim).
-
-Über **int getStars()** soll dieser Wert abrufbar sein.
+Dieser Wert wird für die zufällige Verteilung von Einheiten benötigt. Er ist fest für eine Provinz festgeschrieben.
 
 #### Angrenzende Provinzen
 
-Dies ist ein Array von allen Provinzen, die es gibt (Provinznummer als Index), diese jeweils mit einem **Boolean**-Wert, der festlegt, ob ein Kampf oder ein Weitergeben von Einheiten möglich ist.
-
+Dies ist ein Array von allen Provinzen, die es gibt (Provinznummer als Index), diese jeweils mit einem *boolean*-Wert, der festlegt, ob ein Kampf oder ein Weitergeben von Einheiten möglich ist.
+```java
 boolean[] nearProvinces;
+```
+Dem Konstruktor wird stattdessen ein *int[]* mit allen angrenzenden Provinzen als Werte übergeben werden, dieses wird dann automatisch konvertiert.
 
-Dem Konstruktor kann stattdessen auch ein **int[]** mit allen angrenzenden Provinzen als Werte übergeben werden, dieses wird dann automatisch konvertiert.
+### Private Eigenschaften
 
-Über die Methode **boolean isProvinceNear(int)** kann man sich die Einträge einzeln als Booleans ausgeben lassen.
+- Provinznummer
+- Kontinentnummer
+- X/Y-Position auf der Karte
+- Anzeigename
+- Sterne
+- Angrenzende Provinzen
+
+- Besitzer
+- Einheitenanzahl
 
 #### Besitzer
 
+Diese Variable speichert den aktuellen Besitzer.
+
 Über die Methode **int getOwner()** bekommt ihr den aktuellen Besitzer zurück (-1 = keiner, 0 = Spieler 1, ...).
 
 Die Methode **boolean setOwner(int)** speichert einen neuen Besitzer ab. Sie gibt den Erfolg des Setzens zurück, falls also die Zahl kleiner -1 oder größer gleich als die Spieleranzahl sein sollte, wird die Änderung nicht durchgeführt und es wird **false** zurückgegeben.
@@ -232,29 +242,131 @@ Die Methode **boolean setOwner(int)** speichert einen neuen Besitzer ab. Sie gib
 
 Diese Eigenschaft speichert, wie viele Einheiten auf diesem Feld stehen (natürlich welche, die dem Besitzer gehören).
 
-Die Methoden **int getEntityCount()**, **int addToEntities(int)**, **int removeFromEntities(int)** und **int setEntityCount(int)** sollten genügend Möglichkeiten für Änderungen bieten.
-Alle Methoden geben nach ihrem Aufruf den nun aktuellen Wert zurück.
+### Public Methoden
+
+- *int* **getXPos** ()
+- *int* **getYPos** ()
+- *int* **getID** ()
+- *int* **getContinentID** ()
+- *String* **getDisplayName** ()
+- *int* **getStars** ()
+
+- *boolean* **isProvinceNear** ( *int* provinceID )
+
+- *int* **getOwner** ()
+- *boolean* **setOwner** ( *int* playerID )
+
+- *int* **getEntityCount** ()
+- *int* **addToEntities** ( *int* entityCountToAdd )
+- *int* **removeFromEntities** ( *int* entityCountToRemove )
+- *int* **setEntityCount** ( *int* newEntityCount)
+
+- *boolean* **hasClicked** ()
+
+- *void* **redrawProvince** ()
+
+#### getXPos()
+
+Gibt die in der Provinz hinterlegte X-Position zurück.
+
+#### getYPos()
+
+Gibt die in der Provinz hinterlegte Y-Position zurück.
+
+#### getID()
+
+Gibt die Provinz-ID dieser Provinz zurück.
+
+#### getContinentID()
+
+Gibt die Kontinent-ID dieser Provinz zurück.
+
+#### getDisplayName()
+
+Gibt den Anzeigenamen dieser Provinz zurück.
+
+#### getStars()
+
+Gibt die hinterlegte Anzahl an Sternen dieser Provinz zurück.
+
+#### isProvinceNear()
+
+Gibt zurück, ob die angebenene Provinz mit dieser Provinz benachbart ist, umn beispielsweise Einheiten verschieben zu können.
+
+#### getOwner()
+
+Gibt die Spieler-ID des aktuellen Besitzer der Provinz als *int* zurück. **-1** bedeutet, dass diese Provinz aktuell keinen Besitzer hat.
+
+#### setOwner()
+
+Legt einen neuen Besitzer für diese Provinz fest. Bei Erfolg gibt die Methode **true** zurück. Sollte die ID für keinen Spieler stehen, wird die Methode **false** zurückgeben und nichts an dem gespeicherten Wert ändern.
+
+#### getEntityCount()
+
+Gibt die aktuelle Einheitenanzahl auf dieser Provinz zurück.
+
+#### addToEntities()
+
+Addiert die gegebene Anzahl der Einheiten auf die gespeicherte Anzahl drauf, speichert den neuen Wert ab und gibt diesen zurück.
+
+#### removeFromEntities()
 
-### Zusätzliche Methoden
+Subtrahiert die gegebene Anzahl der Einheiten von die gespeicherte Anzahl ab, speichert den neuen Wert ab und gibt diesen zurück. Bei einem neuen Wert von unter 0 wird dies nicht abspeichert, aber dennoch wird der noch aktuellen Wert zurückgeben.
 
-- **redrawProvince()**
+#### setEntityCount()
 
-#### redrawProvince
+Setzt einen neuen festen Wert für die Einheitenanzahl fest und gibt diesen wieder zurück. Bei gegebenen Werten unter 0 wird dies nicht abspeichert, aber dennoch wird der noch aktuellen Wert zurückgeben.
+
+#### hasClicked()
+
+Gibt zurück, ob seid dem letzten Aufruf dieser Methode diese Provinz von der Maus angeklickt wurde.
+
+#### redrawProvince()
 
 Wird von der Karte oder von internen Methoden aufgerurfen, um alle sichtbaren Eigenschaften erneut zu zeichnen.
 
 ---
 
 ## Player
+*extends Actor*
+
+Stellt die Spieler da, speichert Informationen zu diesen ab.
+
+### Konstruktorparameter
+
+0. Spieler-ID als *int*
+0. Anzeigename als *String*
+0. "Farbe" als *int*
+
+#### Spielernummer
 
-Stellt die Spieler da, speichert Informationen zu diesen ab. Wird von der Weltkarte als *Actor* behandelt.
+Wird bei der Welt intern benötigt und stellt die Position im Menü und in den Arrays dar.
 
-### Explizite Eigenschaften
+#### Anzeigename
+
+Ist der lesbare Name des Spielers, damit nicht nur "Spieler 1", ... usw. zu sehen ist.
+
+#### "Farbe"
+
+Dies soll die "Farbe" eines Spielers festlegen. *Falls euch ein besserer Name für diese Eigenschaft einfällt, bitte mir weitergeben.*
+
+### Private Eigenschaften
+
+- Spielernummer
+- Anzeigename
+- "Farbe"
 
-- Spielernummer (über Konstruktor festgelegt, **int**)
-- Anzeigename (über Konstruktor festgelegt, **String**)
 - Sternanzahl
 - Statistiken
+
+#### Sternanzahl
+
+Die Anzahl der Sterne, die ein Spieler besitzt und gegebenenfalls dann in Einheiten umtauschen kann.
+
+#### Statistik
+
+Die Statistik soll Events festhalten, um nach einem Spiel verschiedene Werte einsehen zu können. Diese werden von der Welt durch spezielle Funktionen erhöht. Die Reihenfolge, in der die Statistiken angegeben werden, ist wie folgt festgelegt:
+
 1. Eroberte Provinzen
 2. Verlorene Provinzen
 3. Einflussmaximum (maximale Provinzenanzahl, nach einem Zug zu überprüfen)
@@ -262,43 +374,78 @@ Stellt die Spieler da, speichert Informationen zu diesen ab. Wird von der Weltka
 5. Verlorene Einheiten
 6. Maximale Einheitenanzahl (nach einem Zug zu überprüfen)
 
-#### Spielernummer
+### Public Methoden
 
-Wird bei der Welt intern benötigt und stellt die Position im Menü und in den Arrays an.
+- *int* **getID** ()
+- *String* **getDisplayName** ()
 
-**int getID()** gibt diese wieder zurück.
+- *int* **getStars** ()
+- *int* **addToStars** ( *int* starsToAdd )
+- *int* **removeFromStars** ( *int* starsToRemove )
+- *int* **setStars** ( *int* newStarsCount )
+- *boolean* **canStarsRemoved** ( *int* requiredStarsCount )
 
-#### Anzeigename
+- *int[]* **getStatistics** ()
+	- *void* **gotProvince** ()
+	- *void* **lostProvince** ()
+	- *void* **gotEntities** ( *int* addedEntities )
+	- *void* **lostEntity** ()
 
-Ist der lesbare Name des Spielers, damit nicht nur "Spieler 1", ... usw. zu sehen ist.
+- *boolean[]* **getMyProvinces** ()
+- *int* **getProvinceCount** ()
+- *void* **redrawPlayer** ()
 
-**String getDisplayName()** gibt diesen zurück.
+#### getID()
 
-#### Sternanzahl
+Gibt die Spieler-ID dieses Spielers zurück.
 
-Die Anzahl der Sterne, die ein Spieler besitzt und gegebenenfalls dann in Einheiten umtauschen kann.
+#### getDisplayName()
 
-**int getStars()**, **int addToStars(int)**, **int removeFromStars(int)**, **int setStars(int)** sind zum Bearbeiten des Werts da. Auch sie geben danach den nun aktuellen Wert zurück.
+Gibt den Anzeigenamen des Spielers zurück.
 
-**boolean canStarsRemoved(int)** gibt zurück, ob der Spieler diese Anzahl an Sternen verwenden kann (Vereinfachung).
+#### getStars()
 
-#### Statistik
+Gibt die aktuelle Anzahl der Sterne, die der Spieler besitzt, zurück.
+
+#### addToStars()
+
+Addiert die gegebene Anzahl der Sterne auf die gespeicherte Anzahl drauf, speichert den neuen Wert ab und gibt diesen zurück.
+
+#### removeFromStars()
 
-Die Statistik soll Events festhalten, um nach einem Spiel verschiedene Werte einsehen zu können. Diese werden von der Welt mit speziellen Funktionen erhöht. Zurückgegeben sollen diese als **int[]**-Array in der Reihenfolge, wie sie oben in der Liste auftretten. Es wird auch vorgeschlagen, sie so zu speichern.
+Subtrahiert die gegebene Anzahl der Sterne von die gespeicherte Anzahl ab, speichert den neuen Wert ab und gibt diesen zurück. Bei einem neuen Wert von unter 0 wird dies nicht abspeichert, aber dennoch wird der noch aktuellen Wert zurückgeben.
 
-**int[] getStatistics()** gibt diese Liste zurück, damit sie von der Welt angezeigt werden kann.
+#### setStars()
 
-**gotProvince()**, **lostProvince()**, **gotEntities(int)**, **lostEntity()**
+Setzt einen neuen festen Wert für die Sternenanzahl fest und gibt diesen wieder zurück. Bei gegebenen Werten unter 0 wird dies nicht abspeichert, aber dennoch wird der noch aktuellen Wert zurückgeben.
 
-### Zusätzliche Methoden
+#### canStarsRemoved()
 
-- **boolean[] getMyProvinces()**
-- **int getProvinceCount()**
-- **redrawPlayer()**
+Prüft, ob die gegebenene Anzahl an Sternen von dem Spieler abgezogen werden könnte. Falls ja, wird **true** zurückgegebenen, sonst **false**
+
+#### getStatistics()
+
+Gibt in derselben Reihenfolge wie für die Statistik angegeben die aktuelllen Werte zurück als *int[]*-Array
+
+#### gotProvince()
+
+Wird von der Welt aufgerufen, sobald dieser Spieler eine Provinz erobert hat. Diese Methode erhöht dann den entsprechenden Wert in der Statistik um 1.
+
+#### lostProvinze()
+
+Wird von der Welt aufgerufen, sobald dieser Spieler eine Provinz verloren hat. Diese Methode erhöht dann den entsprechenden Wert in der Statistik um 1.
+
+#### gotEntities()
+
+Wird von der Welt aufgerufen, sobald dieser Spieler Einheiten dazubekommt. Diese Methode erhöht dann den entsprechenden Wert in der Statistik um die gegebenene Anzahl.
+
+#### lostEntity()
+
+Wird von der Welt aufgerufen, sobald dieser Spieler im Kampf eine Einheit verliert. Diese Methode erhöht dann den entsprechenden Wert in der Statistik um 1.
 
 #### getMyProvinces()
 
-Diese Methode hat die Aufgabe, eine Liste aller Provinzen zurückzugeben, wobei jede Provinz mit einem **boolean**-Wert gesagt bekommt, ob sie dem Spieler gehört oder nicht.
+Diese Methode hat die Aufgabe, eine Liste aller Provinzen zurückzugeben, wobei jede Provinz mit einem *boolean*-Wert gesagt bekommt, ob sie dem Spieler gehört oder nicht.
 
 Diese Methode muss zwingend mit der Welt interagieren, um diese Informationen zu bekommen.
 
@@ -312,61 +459,421 @@ Erzwingt das erneute Zeichnen des Player Objekts, um alle sichtbaren Eigenschaft
 
 ---
 
-## Dice
+## DicesList
+*extends Actor*
+
+Erstellt die gegebene Anzahl an Würfeln nebeneinander und bietet die gemeinsame Verwaltung dieser. Diese Klasse ist nur als *abstract* Oberklasse zu *OffenderDices* & *DefenderDices* gedacht und ist daher selbst nicht verwendbar, dennoch sich hier alle Methoden, die ihr braucht, definiert. Die Unterklassen legen nur die Farbe der Würfel und die maximale Anzahl fest.
+
+### Verwendung
+
+Nachdem ihr euch für eine Unterklasse entschieden habt, erstellt ihr eine neue Instanz von dieser und übergibt ihr die Anzahl der Würfel, die ihr darstellen wollt (diese Zahl kann größer als die erlaubte Anzahl an Würfel sein, dies wird **automatisch korrigiert**, beim Angreifer auf 3, beim Verteidiger auf 2). Bei zu kleinen Zahlen wird auf 1 korrigiert.
+```java
+DicesList offenders = new OffenderDices(5); // Wird korrigiert auf '3'
+DicesList defenders = new DefenderDices(-3); // Wird korrigiert auf '1'
+```
+Die nun erstellte Instanz solltet ihr einer Welt hinzufügen, um die Würfel sehen zu können. Achtet dabei auf die Position, die ihr der Welt übergibt.
+```java
+addObject(offenders,200,800);
+```
+Nun könnt ihr mit den Methoden **getNumbers** und **roll** alle Würfel parallel steuern.
+```java
+int[] zahlenAng = offenders.roll();
+int[] zahlenVer = defenders.getNumbers();
+if(zahlenAng[1] > zahlenVer[1]) {
+	// Angreifer gewinnt
+} else {
+	// Verteidiger gewinnt
+}
+```
+Solltet ihr die Würfel nicht mehr brauchen und ihr möchtet sie entfernen, reicht ein simpler Aufruf von **removeAll**.
+```java
+offenders.removeAll();
+offenders = null; // muss nicht sein, gehört aber zum sauberen Programmieren dazu
+```
 
-Stellt einen Würfel als *Actor* dar (vergleichbar mit dem Würfel aus dem Spiel 10000).
+### Konstruktorparameter
 
-### Eigenschaften
+1. Anzahl der Würfel als *int* (Weiterleitung des Konstruktors von den Unterklassen)
+2. Maximale Anzahl als *int* (fester Wert der Unterklasse)
+3. Hintergundfarbe als *java.awt.Color* (fester Wert der Unterklasse)
+4. Vordergrundfarbe als *java.awt.Color* (fester Wert der Unterklasse)
 
-- Augenzahl
+### Protected Methoden
 
-#### Augenzahl
+- *void* **addedToWorld** ( *World* world )
+
+#### addedToWorld()
+
+Diese Methode wird von Greenfoot selbst aufgerufen, sobald dieser Actor einer Welt hinzugefügt wurde und kümmert sich folgend darum, seine eigenen Würfel auch der Welt hinzuzufügen an derselben Position.
 
-Diese Zahl zeigt der Würfel gerade an und kann mit **int getNumber()** abgerufen werden.
+### Public Methoden
 
-### Zusätzliche Methoden
+- *int[]* **getNumbers** ()
+- *int[]* **roll** ()
 
-- **int roll()**
+- *void* **removeAll** ()
+
+#### getNumbers()
+
+Gibt die Augenzahlen aller Würfel in sortierter Reihenfolge (absteigend) aus.
 
 #### roll()
 
-Berechnet eine Zufallszahl von 1 bis 6, speichert diese ab und gibt sie auch so gleich zurück. Ändert auch die Anzeige des Würfels.
+Würfelt alle Würfel erneut und gibt die neuen Augenzahlen in sortierter Reihenfolge (absteigend) aus.
+
+#### removeAll()
+
+Entfernt alle Würfel aus ihrer Welt und löscht anschließend die Liste. Die Instanz ist danach nicht mehr zu verwenden.
+
+## OffendersDices
+*extends DicesList*
+
+Erstellt eine Liste von Würfeln mit roter Hintergrundfarbe. Es sind maximal 3 Würfel erlaubt. Zur Verwendung, siehe *DicesList*.
+
+### Konstruktorparamter
+
+1. Anzahl der Würfel als *int* (wird korrigiert; siehe *DicesList*-Konstruktor)
+
+## DefenderDices
+*extends DicesList*
+
+Erstellt eine Liste von Würfeln mit schwarzer Hintergrundfarbe. Es sind maximal 2 Würfel erlaubt. Zur Verwendung, siehe *DicesList*.
+
+### Konstruktorparamter
+
+1. Anzahl der Würfel als *int* (wird korrigiert; siehe *DicesList*-Konstruktor)
 
 ---
 
 ## GUI_Interface
+*extends Actor*
+
+Die Oberklasse für alle Interface-Objekte wie Buttons und Labels. Diese Klasse ist als *abstract* definiert. Diese Klasse besitzt als *abstract* definierte Methoden, welche zwingend von den erbendenen Klassen ersetzt werden muss.
+
+### Protected Eigenschaften
+
+- *int* **sx**
+- *int* **sy**
+
+#### sx
 
-Die Oberklasse für alle Interfaces.
+Gibt die Breite des Objektes an (Größe in X-Richtung, **S**ize**X**). Nur für Methoden der erbenden Objekte selbst gedacht.
 
-Besitzt noch keine relevanten Eigenschaften
+#### sy
+
+Gibt die Höhe des Objektes an (Größe in Y-Richtung, **S**ize**Y**). Nur für Methoden der  erbenden Objekte selbst gedacht.
+
+### Public Methoden
+
+- *int* **getWidth** ()
+- *int* **getHeight** ()
+- *void* **setSize** ( *int* width , *int* height )
+
+- *java.awt.Color* **getBackColor** ()
+- *boolean* **setBackColor** ( *java.awt.Color* newBackColor)
+- *java.awt.Color* **getForeColor** ()
+- *boolean* **setForeColor** ( *java.awt.Color* newForeColor)
+
+#### getWidth()
+
+Gibt die Breite des Objektes zurück.
+
+#### getHeight()
+
+Gibt die Höhe des Objektes zurück.
+
+#### setSize()
+
+Ändert die Größe des Objektes. Eventuell wird das Objekt diese Größenänderung nicht übernehmen wollen (siehe *autoSize* Eigenschaften bei diesen, falls vorhanden).
+
+#### getBackColor()
+
+Gibt die aktuelle Hintergrundfarbe des Objektes zurück.
+
+#### setBackColor()
+
+Legt eine neue Hintergrundfarbe für dieses Objekt fest.
+
+#### getForeColor()
+
+Gibt die aktuelle Vordergrundfarbe (meist Textfarbe) des Objektes zurück.
+
+#### setForeColor()
+
+Legt eine neue Vordergrundfarbe (meist Textfarbe) für dieses Objekt fest.
+
+### Abstract Public Methoden
+
+- *void* redraw()
+
+#### redraw()
+
+Durch diese Methode soll die erneute Zeichnung des Objektes verlangen können. Viele der **set**-Methoden rufen daher bei einer erfolgreichen Änderung diese Methode auf.
 
 ---
 
 ## Label
+*extends GUI_Interface*
 
 Zeigt einen Text auf dem Bildschirm an. Zuvor wurde dieses Objekt "Text" genannt, "Label" ist der fachlichere Ausdruck dafür.
 
-### Eigenschaften
+### Konstruktorparameter
 
-- Anzeigetext (**String**; kann vom Konstruktor entgegen genommen werden, sonst ist der Standardtext "" zu sehen)
+0. Anzeigetext als *String*
+0. Textgröße als *int*
 
 #### Anzeigetext
 
-Dieser Text wird von dem Actor aus zu sehen sein.
-Mit **String getText()** und **String setText(String)** bekommt Zugriff darauf.
+Gibt den Text an, den das Label darstellen soll.
+
+#### Textgröße
+
+Gibt die Textgröße an, in der das Label den Anzeigetext darstellen soll.
+
+### Private Eigenschaften
+
+- Anzeigetext
+- Textgröße
+
+- Automatische Größenanpassung
+
+#### Automatische Größenanpassung
+
+Diese Eigenschaft des Labels legt fest, ob es seine Größe dynamisch an den darzustellenden Text automatisch anpassen soll. Dies kann euch die Arbeit mit diesem erleichtern, kann aber auch zu Problemen bei der Darstellung mehrerer Objekte nebeneinander erschweren, da diese sich eventuell überlappen könnten.
+
+### Public Methoden
+
+- *boolean* **getAutoSize** ()
+- *void* **setAutoSize** ( *boolean* newValue )
+- *int* **getTextSize** ()
+- *boolean* **setTextSize** ( *int* newSize )
+- *String* **getText** ()
+- *boolean* **setText** ( *String* newText )
+
+- *void* **redraw** ()
+
+#### getAutoSize()
+
+Gibt an, ob das Label seine Größe automatisch an den Inhalt anpasst.
+
+#### setAutoSize()
+
+Legt fest, ob das Label seine Größe automatisch an den Inhalt anpassen soll. Falls die Eigenschaft damit aktiviert werden sollte, erfolgt automatisch ein Aufruf der **redraw**-Methode.
+
+#### getTextSize()
+
+Gibt die aktuelle Textgröße zurück.
+
+#### setTextSize()
+
+Legt eine neue Textgröße fest.
+
+#### getText()
+
+Gibt den aktuellen Anzeigetext zurück.
+
+#### setText()
+
+Legt einen neuen Anzeigetext zurück.
+
+#### redraw()
+
+Erneuert die Darstellung des Labels mit seinem Anzeigetext auf der Welt. Hiermit wird gegebenfalls auch die Größe des Labels automatisch angepasst.
 
 ---
 
 ## Button
+*extends GUI_Interface*
+
+Stellt einen Button mit einem Text dar. Dieses Objekt kann dazu ein Event auslösen, sobald darauf geklickt wurde.
+
+### Konstruktorparameter
+
+Hier gibt es mehrere Möglichkeiten, eine Instanz der Klasse *Button* zu erstellen:
+
+Methode 1:
+1. Anzeigetext als *String*
+2. Textgröße als *int*
+
+Methode 2:
+1. EventHandler als *ButtonEvent*
+
+Methode 3:
+1. Anzeigetext als *String*
+2. Textgröße als *int*
+3. EventHandler als *ButtonEvent*
+
+#### Anzeigetext
+
+Gibt den Text an, den das Label darstellen soll.
+
+#### Textgröße
+
+Gibt die Textgröße an, in der das Label den Anzeigetext darstellen soll.
+
+#### EventHandler
+
+Hierfür muss die Instanz einer Klasse übergeben werden, welche das Interface *ButtonEvent* implementiert und damit eine Funktion namens *void* **buttonClicked** ( *Button* button ) besitzt. Folgend ein Beispiel für eine Klassendefinition, die eine Methode mit diesem Namen besitzt, die dann von dem Button aufgerufen wird, sobald dieser angeklickt wurde.
+
+```java
+public class TestClass implements ButtonEvent {
+	Button button1 = new Button("Button 1",10,self);
+	Button button1 = new Button("Button 2",10,self);
+	public void buttonClicked(Button b) {
+		// Hier steht nun, was passieren soll, wenn IRGENDEIN Button angeklickt wird, der eine Instanz von dieser Klasse als EventHandler zugewiesen bekommen hat.
+		if(b == button1) {
+			// mein erster Button
+		} else if(b == button2) {
+			// mein zweiter Button
+		}
+	}
+}
+```
+
+### Private Eigenschaften
 
-Die Hauptklasse für Buttons, wird durch Erbung spezifiziert.
+- Anzeigetext
+- Textgröße
+- EventHandler
+
+- Automatische Größenanpassung
+
+#### Automatische Größenanpassung
+
+Diese Eigenschaft des Buttons legt fest, ob es seine Größe dynamisch an den darzustellenden Text automatisch anpassen soll. Dies kann euch die Arbeit mit diesem erleichtern, kann aber auch zu Problemen bei der Darstellung mehrerer Objekte nebeneinander erschweren, da diese sich eventuell überlappen könnten.
+
+### Public Methoden
+
+- *boolean* **getAutoSize** ()
+- *void* **setAutoSize** ( *boolean* newValue )
+- *int* **getTextSize** ()
+- *boolean* **setTextSize** ( *int* newSize )
+- *String* **getText** ()
+- *boolean* **setText** ( *String* newText )
+
+- *ButtonEvent* **getHandler** ()
+- *void* **setHandler** ( *ButtonEvent* newEventHandler )
+- *void* **removeHandler** ()
+
+- *void* **redraw** ()
+
+#### getAutoSize()
+
+Gibt an, ob der Button seine Größe automatisch an den Inhalt anpasst.
+
+#### setAutoSize()
+
+Legt fest, ob der Button seine Größe automatisch an den Inhalt anpassen soll. Falls die Eigenschaft damit aktiviert werden sollte, erfolgt automatisch ein Aufruf der **redraw**-Methode.
+
+#### getTextSize()
+
+Gibt die aktuelle Textgröße zurück.
+
+#### setTextSize()
+
+Legt eine neue Textgröße fest.
+
+#### getText()
+
+Gibt den aktuellen Anzeigetext zurück.
+
+#### setText()
+
+Legt einen neuen Anzeigetext zurück.
+
+#### getHandler()
+
+Gibt den aktuellen EventHandler des Buttons zurück. Falls keiner vorhanden ist, wird **null** zurückgegeben.
+
+#### setHandler()
+
+Legt einen neuen EventHandler für den Button fest. Der alte EventHandler wird damit überschrieben.
+
+#### removeHandler()
+
+Deaktiviert den aktuellen EventHandler, damit keine Events mehr ausgelöst werden können.
+
+#### redraw()
+
+Erneuert die Darstellung des Buttons mit seinem Anzeigetext auf der Welt. Hiermit wird gegebenfalls auch die Größe des Buttons automatisch angepasst.
+
+---
+
+## Dice
+*extends GUI_Interface*
+
+### Konstruktorparameter
+
+Methode 1: **keine Parameter**
+
+Methode 2:
+1. Startwert für die gespeicherte Augenzahl als *int*
+
+#### Startwert
+
+Dieser Wert wird im Voraus beim Dice hinterlegt, damit er diese direkt anzeigen kann. Wird dieser Wert nicht angegeben, wird als Augenzahl **0** hinterlegt, stehend für: noch nicht gewürfelt.
+
+### Private Eigenschaften
+
+- Augenzahl
+
+#### Augenzahl
+
+Der Wert, der beim letzten Würfeln gewürfelt wurde. Dieser Wert wird vom Würfel auch visuell dargestellt.
+
+### Public Methoden
+
+- *int* **getNumber** ()
+
+- *void* **setSizeAsSquare** ( *int* length )
+
+- *int* **roll** ()
+
+- *void* **redraw** ()
+
+#### getNumber()
+
+Gibt die aktuell gespeicherte und somit auch visuell sichtbare Augenzahl zurück.
+
+#### setSizeAsSquare()
+
+Legt die Größe des Würfels als Quadraht fest. Nur beim Verhältnis 1:1 von Länge:Breite kann eine verzerrungsfreie Darstellung garantiert werden. Vergleichbar mit folgender Zeile:
+```java
+dice.setSize(length,length)
+```
+
+#### roll()
+
+Würfelt den Würfel, speichert die neue Augenzahl ab und erneurt die visuelle Darstellung des Dice.
+
+#### redraw()
+
+Erneuert die visuelle Darstellung des Dice.
 
 ---
 
 ## Utils
 
-Eine finale Klasse mit vielen kleinen Methoden, die den restlichen Code verkleinern und besser lesbar gestalten soll. Ergänzungen in Form von eigenen Funktionen dürfen selbst eingebracht werden.
+Eine finale Klasse mit vielen kleinen Methoden, die den restlichen Code verkleinern und besser lesbar gestalten soll. Ergänzungen in Form von eigenen Funktionen dürfen **selbst** eingebracht werden. Alle Methoden dieser Klasse sollen *public* und *static* sein.
+
+### Static Methoden
+
+- *boolean[]* **copyArray** ( *boolean[]* array )
+- *int[]* **copyArray** ( *int[]* array )
+- *String[]* **copyArray** ( *String[]* array )
+
+- *void* **drawInsideRectangle** ( *GreenfootImage* i, *Color* c, *int* b )
+
+- *void* **sortDesc** ( **int[]** array )
+
+#### copyArray()
+
+Kopiert ein Array des Types *boolean*, *int* oder *String* mit identischer Größe.
+
+#### drawInsideRectangle()
+
+Zeichnet innerhalb eines *GreenfootImage* ein Rechteck gefüllt mit der angegebenen Farbe. Es besitzt zu allen Seiten den gegebenen Abstand zum Rand des Image.
 
-### copyArray()
+#### sortDesc()
 
-Kopiert ein Array des Types **boolean**, **int** oder **String** mit identischer Größe.
+Sortiert ein *int[]*-Array absteigend.

planung/funktionsliste.md

@@ -1,92 +1,165 @@
 # Funktionsliste Zweiundvierzig
 
-**Version: 2**
+**Letztes Update: 15.06.2016** (TT.MM.JJJJ / DD.MM.YYYY)
 
-**Stand: 10.04.2016** (TT.MM.JJJJ / DD.MM.YYYY)
+[Hier die offizielle Version vom Master-Branch sehen](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/funktionsliste.md)
 
-[Hier die neuste offizielle Version vom Master-Branch sehen](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/funktionsliste.md)
+[Hier zum gesamten Architekturplan auf dem aktuellen Branch](architektur.md)
 
-[Hier zum gesamten Architekturplan](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/architektur.md)
+Hier einfach eine grobe Übersicht über alle Methoden und eventuellen Variabled, die jede Klasse als *public* oder *protected* besitzen soll beziehungsweise bereits besitzt.
+Weitere Informationen zu den Methoden findet ihr in der Architektur oder, falls die Methoden bereits vorhanden ist, in der Dokumentation, die von Greenfoot automatisch erstellt wird (durch die InCode Dokumentation).
 
-Hier einfach eine grobe Übersicht über alle Funktionen, die jede Klasse als Public / Protected besitzen soll.
+Falls euere Aufgabe die Umsetzung einer Methode ist, die hier bereits beschrieben wird, müsst ihr nicht diesselben Parameterbezeichner verwenden, wie sie hier verwendet wurden. Falls aus diesem Bezeichner jedoch nicht mehr die Bedeutung des Parameters ausgeht, muss dies in einem Java-Documentation Kommentar erklärt werden.
 
-Dies könnt auch als Checkliste nehmen, um zu sehen, ob ihr bereits alle Funktionen im Code präsent habt.
+Dies könnt auch als Checkliste verwenden, um zu sehen, ob ihr bereits alle Methodenn im Code präsent habt.
 
-## GeneralMap
+## GeneralMap (extends World)
 
-- **static GeneralMap generateMap(int mapID, ...)**
+- *GeneralMap* ( *String* backgroundImage, *String[]* playerList, *int[]* colorList )
 
-- **int getPlayerCount()**
-- **String getPlayerName()**
-- **String getPlayerName(int)**
-- **int getPlayerStars()**
-- **int getProvinceOwner(int)**
-- **int[] getProvinceOwners()**
-- **int getProvinceEntityCount(int)**
-- **int getProvincesEntityCounts(int[])**
-- **int getProvincesEntityCounts(boolean[])**
-- **int getProvincesEntityCounts(int)**
+- protected *void* **initProvinces** ()
 
-## Province
+- *int* **getPlayerCount** ()
+- *String* **getPlayerName** ()
+- *String* **getPlayerName** ( *int* playerID )
+- *int* **getPlayerStars** ()
 
-- **Province(int, int, int, int, int, String, int[])**
-- **Province(int, int, int, int, int, String, boolean[])**
+- *int* **getProvinceOwner** ( *int* provinceID )
+- *int[]* **getProvinceOwners** ()
+- *int* **getProvinceEntityCount** ( *int* playerID )
 
-- **int getID()**
-- **int getContinentID()**
-- **boolean isProvinceNear(int)**
-- **String getDisplayName()**
-- **int getStars()**
-- **int getOwner()**
-- **setOwner(int)**
-- **int getEntityCount()**
-- **int addToEntities(int)**
-- **int removeFromEntities(int)**
-- **int setEntityCount(int)**
+## Province (extends Actor)
 
-- **redrawProvince()**
+- *Province* ( *int* provinceID, *int* continentID, *int* xPos, *int* yPos, *String* displayName, *int* stars, *int[]* neighbourProvinces )
 
-## Player
+- *int* **getXPos** ()
+- *int* **getYPos** ()
+- *int* **getID** ()
+- *int* **getContinentID** ()
+- *String* **getDisplayName** ()
+- *int* **getStars** ()
 
-- **Player(int, String)**
+- *boolean* **isProvinceNear** ( *int* provinceID )
 
-- **int getID()**
-- **String getDisplayName()**
-- **int getStars()**
-- **int addToStars(int)**
-- **int removeFromStars(int)**
-- **int setStars(int)**
-- **boolean cnaStarsRemoved(int)**
+- *int* **getOwner** ()
+- *boolean* **setOwner** ( *int* playerID )
 
-- **int[] getStatistics()**
-- **gotProvince()**
-- **lostProvince()**
-- **gotEntities(int)**
-- **lostEntity()**
+- *int* **getEntityCount** ()
+- *int* **addToEntities** ( *int* entityCountToAdd )
+- *int* **removeFromEntities** ( *int* entityCountToRemove )
+- *int* **setEntityCount** ( *int* newEntityCount)
 
-- **boolean[] getMyProvinces()**
-- **int getProvinceCount()**
-- **redrawPlayer()**
+- *boolean* **hasClicked** ()
 
-## Dice
+- *void* **redrawProvince** ()
 
-- **Dice()**
+## Player (extends Actor)
 
-- **int getNumber()**
+- *Player* ( *int* playerID, *String* displayName, *int* playerColor )
 
-- **int roll()**
+- *int* **getID** ()
+- *String* **getDisplayName** ()
 
-## GUI_Interface
+- *int* **getStars** ()
+- *int* **addToStars** ( *int* starsToAdd )
+- *int* **removeFromStars** ( *int* starsToRemove )
+- *int* **setStars** ( *int* newStarsCount )
+- *boolean* **canStarsRemoved** ( *int* requiredStarsCount )
 
-*Noch unvollständig*
+- *int[]* **getStatistics** ()
+	- *void* **gotProvince** ()
+	- *void* **lostProvince** ()
+	- *void* **gotEntities** ( *int* addedEntities )
+	- *void* **lostEntity** ()
 
-## Label
+- *boolean[]* **getMyProvinces** ()
+- *int* **getProvinceCount** ()
+- *void* **redrawPlayer** ()
 
-*Noch unvollständig*
+## DicesList (extends Actor)
 
-- **String getText()**
-- **String setText(String)**
+- *DicesList* ( *int* count, *int* maxCount, *java.awt.Color* backColor, *java.awt.Color* foreColor )
 
-## Button
+- *int[]* **getNumbers** ()
+- *int[]* **roll** ()
 
-*Noch unvollständig*
+- *void* **removeAll** ()
+
+## OffenderDices (extends Actor)
+
+- *OffenderDices* ( *int* count )
+
+## DefenderDices (extends Actor)
+
+- *DefenderDices* ( *int* count )
+
+## GUI_Interface (extends Actor)
+
+- protected *int* **sx**
+- protected *int* **sy**
+
+- *int* **getWidth** ()
+- *int* **getHeight** ()
+- *void* **setSize** ( *int* width , *int* height )
+
+- *java.awt.Color* **getBackColor** ()
+- *boolean* **setBackColor** ( *java.awt.Color* newBackColor)
+- *java.awt.Color* **getForeColor** ()
+- *boolean* **setForeColor** ( *java.awt.Color* newForeColor)
+
+- abstract *void* **redraw** ()
+
+## Label (extends GUI_Interface)
+
+- *Label* ( *String* text, *int* textSize )
+
+- *boolean* **getAutoSize** ()
+- *void* **setAutoSize** ( *boolean* newValue )
+- *int* **getTextSize** ()
+- *boolean* **setTextSize** ( *int* newSize )
+- *String* **getText** ()
+- *boolean* **setText** ( *String* newText )
+
+- *void* **redraw** ()
+
+## Button (extends GUI_Interface)
+
+- *Button* ( *String* text, *int* textSize )
+- *Button* ( *ButtonEvent* eventHandler )
+- *Button* ( *String* text, *int* textSize, *ButtonEvent* eventHandler )
+
+- *boolean* **getAutoSize** ()
+- *void* **setAutoSize** ( *boolean* newValue )
+- *int* **getTextSize** ()
+- *boolean* **setTextSize** ( *int* newSize )
+- *String* **getText** ()
+- *boolean* **setText** ( *String* newText )
+
+- *ButtonEvent* **getHandler** ()
+- *void* **setHandler** ( *ButtonEvent* newEventHandler )
+- *void* **removeHandler** ()
+
+- *void* **redraw** ()
+
+## Dice (extends GUI_Interface)
+
+- *Dice* ()
+- *Dice* ( *int* startNumber )
+
+- *int* **getNumber** ()
+
+- *void* **setSizeAsSquare** ( *int* length )
+
+- *int* **roll** ()
+
+- *void* **redraw** ()
+
+## Utils
+
+- static *boolean[]* **copyArray** ( *boolean[]* array )
+- static *int[]* **copyArray** ( *int[]* array )
+- static *String[]* **copyArray** ( *String[]* array )
+
+- static *void* **drawInsideRectangle** ( *GreenfootImage* i, *Color* c, *int* b )
+
+- static *void* **sortDesc** ( **int[]** array )

project.greenfoot

@@ -1,8 +1,147 @@
-#Greenfoot project file
+#Greenfoot properties
+#Sun May 29 22:05:35 CEST 2016
+editor.fx.0.height=700
+target2.width=100
+target8.name=Map_World
+target11.y=190
+target11.x=10
+class.GUI_Interface.superclass=greenfoot.Actor
+target1.type=ClassTarget
+target7.showInterface=false
 mainWindow.height=600
+target6.typeParameters=
+target1.height=50
+class.Dice_Offender.superclass=Dice
+target8.y=70
+target8.x=170
+dependency2.type=UsesDependency
+target5.type=ClassTarget
+target6.y=10
+target6.x=120
+target1.showInterface=false
+target4.y=310
+target4.x=10
+target4.showInterface=false
+target9.type=ClassTarget
+target2.y=250
+target2.x=10
+target10.type=ClassTarget
+target8.height=50
+target11.height=50
+target10.typeParameters=
+dependency4.from=Map_World
+class.Weltenauswahl.superclass=Spieloptionen
+target1.name=Dice
+target10.showInterface=false
+class.Map_World.superclass=GeneralMap
+target4.typeParameters=
+target5.name=Province
+world.lastInstantiated=Map_World
+class.Dice.superclass=greenfoot.Actor
 mainWindow.width=800
-mainWindow.x=10
+readme.width=47
+class.Dice_Defender.superclass=Dice
+class.GeneralMap.superclass=greenfoot.World
+class.CurrentPlayerArrow.superclass=GUI_Interface
+target9.name=Button
+target5.height=50
+target10.name=Dice_Offender
+target2.type=ClassTarget
+dependency1.to=Utils
+dependency3.type=UsesDependency
+target2.height=50
+target2.typeParameters=
+target6.type=ClassTarget
+editor.swing.0.height=700
+class.Spieloptionen.superclass=greenfoot.World
+target9.typeParameters=
+target11.type=ClassTarget
+version=2.8.0
+editor.fx.0.y=0
+editor.fx.0.x=0
+target2.showInterface=false
+dependency1.from=Province
 mainWindow.y=10
+editor.swing.0.y=0
+mainWindow.x=10
+editor.swing.0.x=78
+target5.showInterface=false
+target8.showInterface=false
+target7.typeParameters=
+target2.name=GUI_Interface
+readme.name=@README
+class.Menue_Button.superclass=Button
+editor.swing.0.width=701
+target6.name=CurrentPlayerArrow
+target9.height=50
+target12.y=190
+target12.x=190
+editor.fx.0.width=700
+target11.showInterface=false
+target10.y=130
+target10.x=100
+dependency2.to=Menue_Button
+target12.width=90
+target11.name=Utils
+target12.height=50
+class.Province.superclass=greenfoot.Actor
+target9.y=130
+target9.x=10
+target3.type=ClassTarget
+target6.height=50
+target7.y=70
+target7.x=70
+target11.typeParameters=
+target5.y=310
+target5.x=130
+dependency4.type=UsesDependency
+target7.type=ClassTarget
+target10.width=110
+target3.y=250
+target3.x=120
+target11.width=80
+target3.height=50
+target1.y=190
+target1.x=100
+target12.type=ClassTarget
+target5.typeParameters=
+dependency2.from=GeneralMap
 project.charset=UTF-8
-version=2.8.0
-world.lastInstantiated=GUI_Ingame
+target3.showInterface=false
+class.Spieleranzahl.superclass=Spieloptionen
+target3.name=Menue_Button
+target6.showInterface=false
+target3.typeParameters=
+target9.showInterface=false
+dependency3.to=Roll_Button
+target7.name=GeneralMap
+package.numDependencies=4
+package.numTargets=12
+target12.name=Roll_Button
+dependency1.type=UsesDependency
+target4.type=ClassTarget
+target12.showInterface=false
+target8.width=90
+target9.width=80
+target7.height=50
+target8.type=ClassTarget
+class.Button.superclass=GUI_Interface
+target6.width=140
+target10.height=50
+target7.width=90
+class.Roll_Button.superclass=Button
+dependency3.from=GeneralMap
+target1.typeParameters=
+target3.width=110
+target4.width=110
+target8.typeParameters=
+target5.width=80
+dependency4.to=Province
+class.Utils.superclass=
+target4.name=Dice_Defender
+readme.y=10
+readme.x=10
+target4.height=50
+readme.height=58
+target12.typeParameters=
+target1.width=80