Merge pull request #30 from HGE-IT-Course-2016/ArchitekturAnpassung

Dice Erweiterung, Architektur Anpassung und Fehlerbehebungen

ArmySchubser.java

@@ -15,8 +15,9 @@ public class ArmySchubser extends Map_World
      * Constructor for objects of class ArmySchubser.
      * 
      */
-    public ArmySchubser()
+    public ArmySchubser(String[] playerList, int[] colorList)
     {
+        super(playerList,colorList);
         // Hi.
     }
 
@@ -25,7 +26,7 @@ public class ArmySchubser extends Map_World
         Province firstProvince = null;
         Province secondProvince = null;
 
-        for ( int i = 0; i <= provinceCount; i++)
+        for ( int i = 1; i <= provinceCount; i++)
         {
             if (provinces[i].hasClicked() == true)
             {
@@ -34,7 +35,7 @@ public class ArmySchubser extends Map_World
             }
         }
 
-        for ( int i = 0; i <= provinceCount; i++)
+        for ( int i = 1; i <= provinceCount; i++)
         {
             if (provinces[i].hasClicked() == true && provinces[i] != firstProvince)
             {

DefenderDices.java

@@ -0,0 +1,16 @@
+import greenfoot.*;
+import java.util.Arrays;   // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+/**
+	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 Actor
-{
-    /**
-     * Act - do whatever the Dice 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 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 int roll() {
+		number = (int) (Math.floor(Math.random()*6)+1);
+		redraw();
+		return number;
+	}
+
+	/**
+		Zeichnet auf dem gegebenen GreenfootImage ein Oval an der gegebenen Stelle multipliziert mit der einheitlichen Größe.
+	*/
+	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);
+	}
+}

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

@@ -12,11 +12,11 @@ public abstract class GUI_Interface extends Actor
 	/**
 		Die Breite des Objektes
 	*/
-	protected int sx = 1;
+	protected int sx = 20;
 	/**
 		Die Höhe des Objektes
 	*/
-	protected int sy = 1;
+	protected int sy = 20;
 	/**
 		Die Hintergrundfarbe des Objektes
 	*/

GeneralMap.java

@@ -27,7 +27,11 @@ public abstract class GeneralMap extends World
 	*/
 	public GeneralMap(String backImage, String[] playerList, int[] colorList)
 	{    
-		
+        super(1600,900,1);
+		players = new Player[playerList.length];
+		for (int i = 0; i < playerList.length; i++) {
+			players[i] = new Player(i,playerList[i],colorList[i]);
+		}
 	}
 	
 	/**
@@ -35,7 +39,7 @@ public abstract class GeneralMap extends World
 	*/
 	public int getPlayerCount()
 	{
-		return playerList.length;
+		return players.length;
 	}
 	
 	/**
@@ -86,9 +90,9 @@ public abstract class GeneralMap extends World
 	{
 		int[] prOwners = new int[provinces.length];
 		for (int i = 1; i > provinces.length; i++) {
-			prOwners[i] = provinces.getOwner();
+			prOwners[i] = provinces[i].getOwner();
 		}
-		return pwOwners;
+		return prOwners;
 	}
 	
 	/**
@@ -104,6 +108,7 @@ public abstract class GeneralMap extends World
 				c = c + provinces[i].getEntityCount();
 			}
 		}
+		return c;
 	}
 
 }

Map_World.java

@@ -21,28 +21,14 @@ public class Map_World extends GeneralMap
      * konstruiert eine GeneralMap mit den Ausmassen 1600 auf 900 Pixel.
      */
 
-    public Map_World()
+    public Map_World(String[] playerList, int[] colorList)
     {
-        super(1600,900,1);
-        Province[] provinces;
-
-        /**
+        super("",playerList,colorList);
+        /*
          * 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> });

OffenderDices.java

@@ -0,0 +1,16 @@
+import greenfoot.*;
+import java.util.Arrays;   // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+/**
+	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

@@ -22,11 +22,13 @@ public class Player extends Actor
     boolean lostProv = false;
 
     private String n;
+    private int c;
     //definiert die ID und Namens Variable
-    public Player( int identity,String name)
+    public Player( int identity,String name, int color)
     {
         n = name;
         id = identity;
+        c = color;
     }
     //gibt die Spieler ID zurück
     public int getID()
@@ -39,12 +41,12 @@ public class Player extends Actor
         return n;
     }
     //gibt die Sternenanzahl zurück
-    private int getStars ()
+    public int getStars ()
     {
         return stars;
     }
     // erhöht die Sternenzahl um eine random ausgewählte Anzahl von 1-3
-    private void  addToStars ()
+    public void  addToStars ()
     {  
 
         int rand;
@@ -120,11 +122,11 @@ public class Player extends Actor
         return provZahl;
     }
 
-    private void gotEntities(int gotEnt)
+    public void gotEntities(int gotEnt)
     {
         stats[3]+= gotEnt;
     }
-    private void lostEntity()
+    public void lostEntity()
     {
         stats[4]+=1;
     }
@@ -135,7 +137,7 @@ public class Player extends Actor
             stats[5]=entNumber;
         }
     }
-    private boolean[] getMyProvinces()
+    public boolean[] getMyProvinces()
     {
         GeneralMap w= getWorld();
         int[] provinces = w.getProvinceOwners();
@@ -186,7 +188,7 @@ public class Player extends Actor
     {
         return lostProv; 
     }
-    private int[] getStatistics()
+    public int[] getStatistics()
     {
         return stats;
     }

Utils.java

@@ -1,11 +1,12 @@
 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 {
 	
@@ -59,4 +60,13 @@ public final class Utils {
 		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);
+		Collection.sort(a,Collections.reverseOrder());
+	}
+
 }

planung/architektur.md

@@ -1,6 +1,6 @@
 # Architekturplan Zweiundvierzig
 
-**Letztes Update: 04.06.2016** (TT.MM.JJJJ / DD.MM.YYYY)
+**Letztes Update: 15.06.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)
 
@@ -56,13 +56,15 @@ Hier werden alle Klassen mit deren öffentliche Methoden (**public** und **prote
 
 - *Province*
 - *Player*
-- *Dice*
-
-### GUI Objekte
 
 - *GUI_Interface*
-- *Label*
-- *Button*
+	- *Label*
+	- *Button*
+	- *Dice*
+
+- *DicesList*
+	- *OffenderDices*
+	- *DefenderDices*
 
 ### Sonstige
 
@@ -447,26 +449,89 @@ Erzwingt das erneute Zeichnen des Player Objekts, um alle sichtbaren Eigenschaft
 
 ---
 
-## Dice
+## DicesList
 *extends Actor*
 
-Stellt einen Würfel als *Actor* dar (vergleichbar mit dem Würfel aus unserem Projekt Zehntausend).
+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.
 
-### Private Eigenschaften
+### Verwendung
 
-- Augenzahl
+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
+```
 
-#### Augenzahl
+### Konstruktorparameter
 
-Diese Zahl zeigt der Würfel gerade an und kann mit **int getNumber()** abgerufen werden.
+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)
 
-### Zusätzliche Methoden
+### Protected Methoden
 
-- *int* **roll** ()
+- *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.
+
+### Public Methoden
+
+- *int[]* **getNumbers** ()
+- *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)
 
 ---
 
@@ -724,14 +789,81 @@ Erneuert die Darstellung des Buttons mit seinem Anzeigetext auf der Welt. Hiermi
 
 ---
 
+## 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. Alle Methoden dieser Klasse sollen *public* sein.
+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
 
-### copyArray()
+- *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()
+#### 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.
+
+#### sortDesc()
 
-Zeichnet innerhalb eines **GreenfootImage** ein Rechteck gefüllt mit der angegebenen Farbe. Es besitzt zu allen Seiten den gegebenen Abstand zum Rand des Image.
+Sortiert ein *int[]*-Array absteigend.

planung/funktionsliste.md

@@ -1,6 +1,6 @@
 # Funktionsliste Zweiundvierzig
 
-**Letztes Update: 04.06.2016** (TT.MM.JJJJ / DD.MM.YYYY)
+**Letztes Update: 15.06.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)
 
@@ -11,9 +11,9 @@ Weitere Informationen zu den Methoden findet ihr in der Architektur oder, falls
 
 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 Methodenn 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)
 
 - *GeneralMap* ( *String* backgroundImage, *String[]* playerList, *int[]* colorList )
 
@@ -28,7 +28,7 @@ Dies könnt auch als Checkliste nehmen, um zu sehen, ob ihr bereits alle Methode
 - *int[]* **getProvinceOwners** ()
 - *int* **getProvinceEntityCount** ( *int* playerID )
 
-## Province
+## Province (extends Actor)
 
 - *Province* ( *int* provinceID, *int* continentID, *int* xPos, *int* yPos, *String* displayName, *int* stars, *int[]* neighbourProvinces )
 
@@ -51,7 +51,7 @@ Dies könnt auch als Checkliste nehmen, um zu sehen, ob ihr bereits alle Methode
 
 - *void* **redrawProvince** ()
 
-## Player
+## Player (extends Actor)
 
 - *Player* ( *int* playerID, *String* displayName, *int* playerColor )
 
@@ -74,15 +74,24 @@ Dies könnt auch als Checkliste nehmen, um zu sehen, ob ihr bereits alle Methode
 - *int* **getProvinceCount** ()
 - *void* **redrawPlayer** ()
 
-## Dice
+## DicesList (extends Actor)
 
-- *Dice* ()
+- *DicesList* ( *int* count, *int* maxCount, *java.awt.Color* backColor, *java.awt.Color* foreColor )
 
-- *int* **getNumber** ()
+- *int[]* **getNumbers** ()
+- *int[]* **roll** ()
 
-- *int* **roll** ()
+- *void* **removeAll** ()
+
+## OffenderDices (extends Actor)
+
+- *OffenderDices* ( *int* count )
+
+## DefenderDices (extends Actor)
 
-## GUI_Interface
+- *DefenderDices* ( *int* count )
+
+## GUI_Interface (extends Actor)
 
 - protected *int* **sx**
 - protected *int* **sy**
@@ -98,7 +107,7 @@ Dies könnt auch als Checkliste nehmen, um zu sehen, ob ihr bereits alle Methode
 
 - abstract *void* **redraw** ()
 
-## Label (erweitert GUI_Interface)
+## Label (extends GUI_Interface)
 
 - *Label* ( *String* text, *int* textSize )
 
@@ -111,7 +120,7 @@ Dies könnt auch als Checkliste nehmen, um zu sehen, ob ihr bereits alle Methode
 
 - *void* **redraw** ()
 
-## Button (erweitert GUI_Interface)
+## Button (extends GUI_Interface)
 
 - *Button* ( *String* text, *int* textSize )
 - *Button* ( *ButtonEvent* eventHandler )
@@ -128,4 +137,27 @@ Dies könnt auch als Checkliste nehmen, um zu sehen, ob ihr bereits alle Methode
 - *void* **setHandler** ( *ButtonEvent* newEventHandler )
 - *void* **removeHandler** ()
 
-- *void* **redraw** ()
+- *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 )