Bot Hard Zugausgabe geändert F+H

null-Pointer Exception

.project

@@ -14,4 +14,15 @@
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1669476271551</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>

src/.classpath

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="src" path=""/>
-	<classpathentry kind="output" path=""/>
-</classpath>

src/.project

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>src</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>

src/domain/.gitignore

@@ -1,6 +0,0 @@
-/Spiel.class
-/TestenFürFunktionen.class
-/Spielfigur.class
-/Fuchs.class
-/Hennen.class
-/Bot.class

src/domain/Bot.java

@@ -2,7 +2,6 @@ package domain;
 
 public abstract class Bot {
 
-	public void zugBestimmen() {
+	public abstract String zugBestimmen(Spiel spiel, Spielfigur spielfigur);
 	
 }
-}

src/domain/BotEasyFuchs.java

@@ -0,0 +1,70 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+public class BotEasyFuchs extends Bot {
+
+	@Override
+	public String zugBestimmen(Spiel spiel, Spielfigur fuchs) {
+		String zug;
+		char[][] spielbrettArray = spiel.getSpielbrettArray();
+		ArrayList<String> spielfigurExistiert = new ArrayList<>();
+
+		spielfigurExistiert = spiel.spielfigurExistiert(fuchs);
+
+		int altY, altX, neuY = 0, neuX = 0;
+		Random rand = new Random(); 
+
+		// zufällig prüfen ob irgendein Fuchs irgendwohin springen kann
+		do {
+			String random = spielfigurExistiert.get(rand.nextInt(spielfigurExistiert.size()));
+
+			altY = Character.getNumericValue(random.charAt(0));
+			altX = Character.getNumericValue(random.charAt(2));
+
+			do {
+				do {
+					neuY = rand.nextInt(((altY + 1) - (altY - 1)) + 1) + (altY - 1);
+					neuX = rand.nextInt(((altX + 1) - (altX - 1)) + 1) + (altX - 1);
+				} while(neuY == altY && neuX == altX || neuX == 0 || neuX == 10 || neuY == -1 || neuY == 9);
+
+				// zufällig prüfen ob Fuchs eine Henne überspringen könnte
+				if(spielbrettArray[neuY][neuX] == 'X') {
+
+					int neuY2 = neuY; int zähler1 = 0;
+					do {
+						if(zähler1 == 6) {
+							break;
+						}
+						neuY2 = rand.nextInt(((neuY + 1) - (neuY - 1)) + 1) + (neuY - 1);
+						zähler1++;
+					} while(neuY2 == altY || neuX == 0 || neuX == 10 || neuY == -1 || neuY == 9);
+
+					if(neuY2 == neuY){
+						int neuX2 = neuX; int zähler2 = 0;
+						do {
+							if(zähler2 == 6) {
+								break;
+							}
+							neuX2 = rand.nextInt(((neuX + 1) - (neuX - 1)) + 1) + (neuX - 1);
+							zähler2++;
+						} while(neuX2 == neuX || neuX2 == altX || neuX == 0 || neuX == 10 || neuY == -1 || neuY == 9);
+						neuX = neuX2;
+					}
+					neuY = neuY2;
+				}
+			
+			} while (neuX == 0 || neuX == 10 || neuY == -1 || neuY == 9); 
+
+			int[] koordinatenUmgewandelt = spiel.wandelUmgekehrtUm(altY, altX, neuY, neuX);
+			zug = koordinatenUmgewandelt[0] + "," + koordinatenUmgewandelt[1] + " " 
+				+ koordinatenUmgewandelt[2] + "," + koordinatenUmgewandelt[3];
+
+		} while(fuchs.oberIsValidMove(zug, spiel) == false);
+
+		zug = altY + "," + altX + " " + neuY + "," + neuX;
+
+		return zug;
+	}
+}

src/domain/BotEasyHenne.java

@@ -0,0 +1,44 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+public class BotEasyHenne extends Bot {
+
+	@Override
+	public String zugBestimmen(Spiel spiel, Spielfigur henne) {
+		String zug;
+		ArrayList<String> spielfigurExistiert = new ArrayList<>();
+
+		spielfigurExistiert = spiel.spielfigurExistiert(henne);
+
+		int altY, altX, neuY = 0, neuX = 0;
+		Random rand = new Random(); 
+
+		// zufällig prüfen ob irgendeine Henne irgendwohin springen kann
+		do {
+			String random = spielfigurExistiert.get(rand.nextInt(spielfigurExistiert.size()));
+
+			altY = Character.getNumericValue(random.charAt(0));
+			altX = Character.getNumericValue(random.charAt(2));
+
+			do {
+				neuY = altY;
+				neuX = rand.nextInt(((altX + 1) - (altX - 1)) + 1) + (altX - 1);
+			
+				if(neuX == altX) {
+					neuY = altY - 1;
+				}
+			} while (neuX == 0 || neuX == 10 || neuY == -1 || neuY == 9); 
+
+			int[] koordinatenUmgewandelt = spiel.wandelUmgekehrtUm(altY, altX, neuY, neuX);
+			zug = koordinatenUmgewandelt[0] + "," + koordinatenUmgewandelt[1] + " " 
+				+ koordinatenUmgewandelt[2] + "," + koordinatenUmgewandelt[3];
+
+		} while(henne.oberIsValidMove(zug, spiel) == false);
+
+		zug = altY + "," + altX + " " + neuY + "," + neuX;
+
+		return zug;
+	}
+}

src/domain/BotHardFuchs.java

@@ -0,0 +1,38 @@
+package domain;
+
+import java.util.Arrays;
+
+public class BotHardFuchs extends Bot {
+	
+	public BotHardFuchs() {
+		
+	}
+
+	@Override
+	public String zugBestimmen(Spiel spiel, Spielfigur fuchs) {
+		char[][] spielbrettArray = spiel.getSpielbrettArray();
+		char[][] kopieSpielbrett = Arrays.stream(spielbrettArray).map(char[]::clone).toArray(char[][]::new);
+
+		long start = System.currentTimeMillis();
+		// megaZug megaZug = spiel.miniMax(kopieSpielbrett, null, 7, -99999, 99999, false, spiel);
+
+		int bewertung = spiel.miniMax(kopieSpielbrett, null, 1, -99999, 99999, false, spiel);
+		long end = System.currentTimeMillis();
+		System.out.println("--------------------------------------------------------");
+		System.out.println("Benötigte Zeit für den Zug: " + (end - start));
+		System.out.println("--------------------------------------------------------");
+
+		System.out.println();
+		// System.out.println(megaZug.bewertung);
+		// System.out.println(megaZug.zug);
+		System.out.println("Bester Zug: " + spiel.botZugUmwandeln(spiel.getBesterZugBot()));
+		System.out.println("Bewertung vom Zug: " + bewertung);
+		// System.out.println();
+		// System.out.println("HIER IST ENDE FÜR BOTHARDFUCHS! -----------------------------------------------------------------");
+		// System.out.println();
+		
+		// return megaZug.zug;
+		return spiel.getBesterZugBot();
+	}
+
+}

src/domain/BotHardHenne.java

@@ -0,0 +1,38 @@
+package domain;
+
+import java.util.Arrays;
+
+public class BotHardHenne extends Bot {
+
+	public BotHardHenne() {
+		
+	}
+
+	@Override
+	public String zugBestimmen(Spiel spiel, Spielfigur henne) {
+		char[][] spielbrettArray = spiel.getSpielbrettArray();
+		char[][] kopieSpielbrett = Arrays.stream(spielbrettArray).map(char[]::clone).toArray(char[][]::new);
+
+		long start = System.currentTimeMillis();
+		// megaZug megaZug = spiel.miniMax(kopieSpielbrett, null, 7, -99999, 99999, true, spiel);
+
+		int bewertung = spiel.miniMax(kopieSpielbrett, null, 1, -99999, 99999, true, spiel);
+		long end = System.currentTimeMillis();
+		System.out.println("--------------------------------------------------------");
+		System.out.println("Benötigte Zeit für den Zug: " + (end - start));
+		System.out.println("--------------------------------------------------------");
+
+		System.out.println();
+		// System.out.println(megaZug.bewertung);
+		// System.out.println(megaZug.zug);
+		System.out.println("Bester Zug: " + spiel.botZugUmwandeln(spiel.getBesterZugBot()));
+		System.out.println("Bewertung vom Zug: " + bewertung);
+		// System.out.println();
+		// System.out.println("HIER IST ENDE FÜR BOTHARDHENNE! -----------------------------------------------------------------");
+		// System.out.println();
+
+		// return megaZug.zug;
+		return spiel.getBesterZugBot();
+	}
+
+}

src/domain/BotMediumFuchs.java

@@ -0,0 +1,14 @@
+package domain;
+
+public class BotMediumFuchs extends Bot {
+
+	public BotMediumFuchs() {
+		
+	}
+
+	@Override
+	public String zugBestimmen(Spiel spiel, Spielfigur spielfigur) {
+		return "Ich bins der Mittlere Fuchs Bot";
+	}
+
+}

src/domain/BotMediumHenne.java

@@ -0,0 +1,14 @@
+package domain;
+
+public class BotMediumHenne extends Bot {
+
+	public BotMediumHenne() {
+		
+	}
+
+	@Override
+	public String zugBestimmen(Spiel spiel, Spielfigur spielfigur) {
+		return "Ich bins der Mittlere Hennen Bot";
+	}
+
+}

src/domain/Computer.java

@@ -0,0 +1,17 @@
+package domain;
+
+public class Computer extends Spielfigur {
+
+	@Override
+	public boolean oberIsValidMove(String zug, Spiel spiel) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public void moveSpielfigur(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

src/domain/Fuchs.java

@@ -1,12 +1,368 @@
 package domain;
 
+import java.util.ArrayList;
+
 public class Fuchs extends Spielfigur {
 	
-	public int moveSpielfigur(int feldKey) {
+	public Fuchs() {
-		return super.moveSpielfigur(feldKey);
+		
 	}
 	
-	public boolean validMove(int startKey, int zielKey) {
+	public void moveSpielfigur(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel) {
-		return super.validMove(startKey, zielKey);
+		spiel.ändereWertImArray(neueStartY, neueStartX, '\u25A1');
+		spiel.ändereWertImArray(neueZielY, neueZielX, 'O');
+	}
+	
+	public boolean oberIsValidMove(String zug, Spiel spiel) {
+		int anzahlZüge = (zug.length() - 3) / 4;
+		String zwischenzug;
+		boolean erfolgreicherZwischenzug;
+		
+		// System.out.println(anzahlZüge);
+		
+		for(int zugZähler = 1, beginnChar = 0, endeChar = 7; zugZähler <= anzahlZüge; zugZähler++, beginnChar = beginnChar + 4, endeChar = endeChar + 4) {
+			zwischenzug = zug.substring(beginnChar, endeChar);
+			// System.out.println(zwischenzug);
+			int[] neueKoordinaten = spiel.berechneRichtigeKoordinaten(zwischenzug);
+			int neueStartY = neueKoordinaten[0];
+			int neueStartX = neueKoordinaten[1];
+			int neueZielY = neueKoordinaten[2];
+			int neueZielX = neueKoordinaten[3];
+			
+			erfolgreicherZwischenzug = isValidMove(neueStartY, neueStartX, neueZielY, neueZielX, spiel, zugZähler);
+			
+			if (erfolgreicherZwischenzug == false) {
+				return false;
 			}
 		}
+		
+		return true;
+	}
+	
+	public boolean isValidMove(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel, int zugZähler) {
+		
+		int schritteY = Math.abs(neueStartY - neueZielY);
+		int schritteX = Math.abs(neueStartX - neueZielX);
+		int anzahlSchritteZähler = 0;
+		boolean henneInSafeZone;
+		ArrayList<Integer> zuTöteneHennen = new ArrayList<>();
+		
+		//System.out.println("schritte Y: " + schritteY);
+		//System.out.println("schritte X: " + schritteX);
+		
+		// Zug fehleingabe
+		if (neueStartY == 1000 || neueStartX == 1000 || neueZielY == 1000 || neueZielX == 1000) {
+			// System.out.println("Fehleingabe");
+			// System.out.println(neueStartY + " " + neueStartX +" "+neueZielY+" "+neueZielX);
+			return false;
+		}
+			
+		// Fehler Spielsymbol beim Start oder Ziel falsch (nur beim ersten Durchgang nach O testen)
+		if (zugZähler == 1) {
+			if (spiel.getWertAusArray(neueStartY, neueStartX) != 'O' || spiel.getWertAusArray(neueZielY, neueZielX) != '\u25A1') {
+			// System.out.println("Symbole an stellen falsch " + spiel.getWertAusArray(neueStartY, neueStartX) + " " + spiel.getWertAusArray(neueZielY, neueZielX));
+			return false;
+			}
+		} else {
+			if (spiel.getWertAusArray(neueZielY, neueZielX) != '\u25A1') {
+				// System.out.println("Symbol an der Endstelle falsch " + spiel.getWertAusArray(neueZielY, neueZielX));
+				return false;
+			}
+		}
+		
+		// Valider Zug einser Schritt
+		if (schritteY <= 1 && schritteX <= 1) {
+			// System.out.println("Einser Schritt erfolgreich!");
+			return true;
+		}
+		
+		// Valide und nicht Valide Züge > 1 Schritte
+		// Schritte nur auf Y Achse mit Hennen killen
+		if ((schritteY % 2) == 0 && schritteX == 0) {
+			// in Richtung nach unten
+			if (neueStartY < neueZielY) {
+				for(int i = neueStartY + 1; i <= neueZielY; i++) {
+					anzahlSchritteZähler++;
+					//System.out.println(spiel.getWertAusArray(i, neueZielX));
+					// ungerade Schritte müssen freie Felder sein
+					if ((anzahlSchritteZähler % 2) != 0 && spiel.getWertAusArray(i, neueZielX) == 'X') {
+						henneInSafeZone = henneInSafeZone(i, neueZielX);
+						if (henneInSafeZone == true) {
+							// System.out.println("Henne in Safe Zone = nicht killbar");
+							return false;
+						} else {
+							zuTöteneHennen.add(i);
+							zuTöteneHennen.add(neueZielX);
+						}
+					// gerade Schritte müssen freie Felder sein
+					} else if ((anzahlSchritteZähler % 2) == 0 && spiel.getWertAusArray(i, neueZielX) == '\u25A1') {
+
+					} else {
+						return false;
+					}
+				}
+				killHenne(zuTöteneHennen, spiel);
+				return true;
+				
+			// in Richtung nach oben	
+			} else {
+				for(int i = neueStartY - 1; i >= neueZielY; i--) {
+					anzahlSchritteZähler++;
+					// ungerade Schritte müssen freie Felder sein
+					if ((anzahlSchritteZähler % 2) != 0 && spiel.getWertAusArray(i, neueZielX) == 'X') {
+						henneInSafeZone = henneInSafeZone(i, neueZielX);
+						if (henneInSafeZone == true) {
+							// System.out.println("Henne in Safe Zone = nicht killbar");
+							return false;
+						} else {
+							zuTöteneHennen.add(i);
+							zuTöteneHennen.add(neueZielX);
+						}
+					// gerade Schritte müssen freie Felder sein
+					} else if ((anzahlSchritteZähler % 2) == 0 && spiel.getWertAusArray(i, neueZielX) == '\u25A1') {
+
+					} else {
+						return false;
+					}
+				}
+				killHenne(zuTöteneHennen, spiel);
+				return true;
+			}
+		}
+		
+		// Schritte nur auf X Achse mit Hennen killen
+		if ((schritteX % 2) == 0 && schritteY == 0) {
+			// in Richtung nach rechts
+			if (neueStartX < neueZielX) {
+				for(int i = neueStartX + 1; i <= neueZielX; i++) {
+					anzahlSchritteZähler++;
+					// ungerade Schritte müssen freie Felder sein
+					if ((anzahlSchritteZähler % 2) != 0 && spiel.getWertAusArray(neueZielY, i) == 'X') {
+						henneInSafeZone = henneInSafeZone(neueZielY, i);
+						if (henneInSafeZone == true) {
+							// System.out.println("Henne in Safe Zone = nicht killbar");
+							return false;
+						} else {
+							zuTöteneHennen.add(neueZielY);
+							zuTöteneHennen.add(i);
+						}
+					// gerade Schritte müssen freie Felder sein
+					} else if ((anzahlSchritteZähler % 2) == 0 && spiel.getWertAusArray(neueZielY, i) == '\u25A1') {
+
+					} else {
+						return false;
+					}
+				}
+				killHenne(zuTöteneHennen, spiel);
+				return true;
+				
+			// in Richtung nach links	
+			} else {
+				for(int i = neueStartX - 1; i >= neueZielX; i--) {
+					anzahlSchritteZähler++;
+					// ungerade Schritte müssen freie Felder sein
+					if ((anzahlSchritteZähler % 2) != 0 && spiel.getWertAusArray(neueZielY, i) == 'X') {
+						henneInSafeZone = henneInSafeZone(neueZielY, i);
+						if (henneInSafeZone == true) {
+							// System.out.println("Henne in Safe Zone = nicht killbar");
+							return false;
+						} else {
+							zuTöteneHennen.add(neueZielY);
+							zuTöteneHennen.add(i);
+						}
+					// gerade Schritte müssen freie Felder sein
+					} else if ((anzahlSchritteZähler % 2) == 0 && spiel.getWertAusArray(neueZielY, i) == '\u25A1') {
+
+					} else {
+						return false;
+					}
+				}
+				killHenne(zuTöteneHennen, spiel);
+				return true;
+			}
+		}
+		
+		// Schritte diagonal mit Hennen killen
+		if ((schritteX % 2) == 0 && (schritteY % 2) == 0 && schritteX == schritteY) {
+			// in Richtung nach rechts oben
+			if (neueStartY > neueZielY && neueStartX < neueZielX) {
+				for(int y = neueStartY - 1, x = neueStartX + 1; y >= neueZielY && x <= neueZielX; y--, x++) {
+					anzahlSchritteZähler++;
+					// ungerade Schritte müssen freie Felder sein
+					if ((anzahlSchritteZähler % 2) != 0 && spiel.getWertAusArray(y, x) == 'X') {
+						henneInSafeZone = henneInSafeZone(y, x);
+						if (henneInSafeZone == true) {
+							// System.out.println("Henne in Safe Zone = nicht killbar");
+							return false;
+						} else {
+							zuTöteneHennen.add(y);
+							zuTöteneHennen.add(x);
+						}
+					// gerade Schritte müssen freie Felder sein
+					} else if ((anzahlSchritteZähler % 2) == 0 && spiel.getWertAusArray(y, x) == '\u25A1') {
+						// System.out.println("gerader Schritt war kein leeres Feld");
+
+					} else {
+						return false;
+					}
+				}
+				killHenne(zuTöteneHennen, spiel);
+				return true;
+				
+			// in Richtung nach rechts unten	
+			} else if (neueStartY < neueZielY && neueStartX < neueZielX) {
+				for(int y = neueStartY + 1, x = neueStartX + 1; y <= neueZielY && x <= neueZielX; y++, x++) {
+					anzahlSchritteZähler++;
+					// ungerade Schritte müssen freie Felder sein
+					if ((anzahlSchritteZähler % 2) != 0 && spiel.getWertAusArray(y, x) == 'X') {
+						henneInSafeZone = henneInSafeZone(y, x);
+						if (henneInSafeZone == true) {
+							// System.out.println("Henne in Safe Zone = nicht killbar");
+							return false;
+						} else {
+							zuTöteneHennen.add(y);
+							zuTöteneHennen.add(x);
+						}
+					// gerade Schritte müssen freie Felder sein
+					} else if ((anzahlSchritteZähler % 2) == 0 && spiel.getWertAusArray(y, x) == '\u25A1') {
+
+					} else {
+						return false;
+					}
+				}
+				killHenne(zuTöteneHennen, spiel);
+				return true;
+
+			// in Richtung nach links oben	
+			} else if (neueStartY > neueZielY && neueStartX > neueZielX) {
+				for(int y = neueStartY - 1, x = neueStartX - 1; y >= neueZielY && x >= neueZielX; y--, x--) {
+					anzahlSchritteZähler++;
+					// ungerade Schritte müssen freie Felder sein
+					if ((anzahlSchritteZähler % 2) != 0 && spiel.getWertAusArray(y, x) == 'X') {
+						henneInSafeZone = henneInSafeZone(y, x);
+						if (henneInSafeZone == true) {
+							// System.out.println("Henne in Safe Zone = nicht killbar");
+							return false;
+						} else {
+							zuTöteneHennen.add(y);
+							zuTöteneHennen.add(x);
+						}
+					// gerade Schritte müssen freie Felder sein
+					} else if ((anzahlSchritteZähler % 2) == 0 && spiel.getWertAusArray(y, x) == '\u25A1') {
+
+					} else {
+						return false;
+					}
+				}
+				killHenne(zuTöteneHennen, spiel);
+				return true;
+				
+			// in Richtung nach links unten	
+			} else if (neueStartY < neueZielY && neueStartX > neueZielX) {
+				for(int y = neueStartY + 1, x = neueStartX - 1; y <= neueZielY && x >= neueZielX; y++, x--) {
+					anzahlSchritteZähler++;
+					// ungerade Schritte müssen freie Felder sein
+					if ((anzahlSchritteZähler % 2) != 0 && spiel.getWertAusArray(y, x) == 'X') {
+						henneInSafeZone = henneInSafeZone(y, x);
+						if (henneInSafeZone == true) {
+							// System.out.println("Henne in Safe Zone = nicht killbar");
+							return false;
+						} else {
+							zuTöteneHennen.add(y);
+							zuTöteneHennen.add(x);
+						}
+					// gerade Schritte müssen freie Felder sein
+					} else if ((anzahlSchritteZähler % 2) == 0 && spiel.getWertAusArray(y, x) == '\u25A1') {
+
+					} else {
+						return false;
+					}
+				}
+				killHenne(zuTöteneHennen, spiel);
+				return true;
+			}
+		}
+		
+		System.out.println("Fuchsmethode aufgerufen");
+		return false;
+	}
+	
+	
+	public void killHenne(ArrayList<Integer> zuTöteneHennen, Spiel spiel) {
+		char symbol = '\u25A1';
+		// System.out.println(zuTöteneHennen);
+		for (int y = 0, x = 1; x < zuTöteneHennen.size(); y = y + 2, x = x + 2) {
+			spiel.ändereWertImArray(zuTöteneHennen.get(y), zuTöteneHennen.get(x), symbol);
+		}
+	}
+	
+	public boolean henneInSafeZone(int yAchse, int xAchse) {
+		//Henne ist in der Safe Zone und darf nicht mehr gekillt werden:
+		if (yAchse <= 2 && (xAchse == 4 || xAchse == 5 || xAchse == 6)) {
+			return true;
+		}
+		
+		//Henne darf getötet werden
+		return false;
+	}
+	
+	public static boolean fuchsUmzingelt(Spiel spiel) {
+		//Füchse mit Koordinaten finden
+		for (int yAchse = 0; yAchse <= 8; yAchse++ ) {
+			for (int xAchse = 1; xAchse <= 9; xAchse++ ) {
+				if (spiel.getWertAusArray(yAchse, xAchse) == 'O') {
+					//gefundenen Fuchs prüfen
+					for (int y = (yAchse - 1); y <= (yAchse + 1); y++) {
+						for (int x = (xAchse - 1); x <= (xAchse + 1); x++) {
+							if (y < 0 || y > 9 || x < 1 || x > 10 || (x == xAchse && y == yAchse)) {
+								//nichts prüfen weil nicht mehr im Spielbrett
+							} else {
+								if (spiel.getWertAusArray(y, x) == '\u25A1') {
+									return false;
+								}
+							}
+						}
+					}
+					return true;
+
+				}
+			}
+		}
+		return true;
+	}
+	
+	public static void killFuchs(Spiel spiel) {
+		ArrayList<Integer> fuchskoordinaten = new ArrayList<>();
+		
+		//Füchse mit Koordinaten finden
+		for (int yAchse = 0; yAchse <= 8; yAchse++ ) {
+			for (int xAchse = 1; xAchse <= 9; xAchse++ ) {
+				if (spiel.getWertAusArray(yAchse, xAchse) == 'O') {
+					fuchskoordinaten.add(yAchse);
+					fuchskoordinaten.add(xAchse);
+				}
+			}	
+		}
+		
+		//gefundenen Fuchs prüfen und killen
+		for(int i = 0; i < fuchskoordinaten.size(); i = i + 2) {
+			boolean fuchsKill = true;
+			for (int y = (fuchskoordinaten.get(i) - 1); y <= (fuchskoordinaten.get(i) + 1); y++) {
+				for (int x = (fuchskoordinaten.get(i+1) - 1); x <= (fuchskoordinaten.get(i+1) + 1); x++) {
+					if (y < 0 || y > 9 || x < 1 || x > 10 || (x == fuchskoordinaten.get(i+1) && y == fuchskoordinaten.get(i))) {
+						//nichts prüfen weil nicht mehr im Spielbrett
+					} else {
+						if (spiel.getWertAusArray(y, x) == '\u25A1') {
+							fuchsKill = false;
+						}
+					}
+				}
+			}
+			if (fuchsKill == true) {
+				spiel.ändereWertImArray(fuchskoordinaten.get(i), fuchskoordinaten.get(i+1), '\u25A1');
+			}
+		}
+
+	}
+	
+}

src/domain/Hennen.java

@@ -2,11 +2,137 @@ package domain;
 
 public class Hennen extends Spielfigur {
 
-	public int moveSpielfigur(int feldKey) {
+	public Hennen() {
-		return super.moveSpielfigur(feldKey);
+
 	}
 
-	public boolean validMove(int startKey, int zielKey) {
+	public void moveSpielfigur(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel) {
-		return super.validMove(startKey,  zielKey);
+		spiel.ändereWertImArray(neueStartY, neueStartX, '\u25A1');
+		spiel.ändereWertImArray(neueZielY, neueZielX, 'X');
+	}
+
+	// generell sehr fehleranfällig, mit Regex Filter Struktur vom String vorgeben
+	public boolean oberIsValidMove(String zug, Spiel spiel) {
+		int[] neueKoordinaten = spiel.berechneRichtigeKoordinaten(zug);
+		int neueStartY = neueKoordinaten[0];
+		int neueStartX = neueKoordinaten[1];
+		int neueZielY = neueKoordinaten[2];
+		int neueZielX = neueKoordinaten[3];
+
+		// Zug fehleingabe
+		if (neueStartY == 1000 || neueStartX == 1000 || neueZielY == 1000 || neueZielX == 1000) {
+			// System.out.println("Fehleingabe");
+			// System.out.println(neueStartY + " " + neueStartX + " " + neueZielY + " " + neueZielX);
+			return false;
+
+			// Fehler Spielsymbol beim Start oder Ziel falsch
+		} else if (spiel.getSpielbrettArray()[neueStartY][neueStartX] != 'X'
+				|| spiel.getSpielbrettArray()[neueZielY][neueZielX] != '\u25A1') {
+			// System.out.println("Symbole an stellen falsch");
+			return false;
+
+			// Henne darf nicht zurückgehen, ZielY muss kleiner als Start sein
+		} else if (neueZielY > neueStartY) {
+			// System.out.println("darf nicht rückwärts gehen");
+			return false;
+
+			// Henne darf seitlich gehen, nach rechts
+		} else if (neueStartX < neueZielX) {
+			if ((neueStartY == neueZielY) && ((neueStartX + 1) != neueZielX)) {
+				// System.out.println("darf nur ein feld seitwärts gehen");
+				return false;
+
+				// Henne darf nicht diagonal nach rechts oben
+			} else if (((neueStartY - 1) == neueZielY) && ((neueStartX + 1) == neueZielX)) {
+				// System.out.println("darf nicht diagonal");
+				return false;
+
+			} else if (((neueStartY - neueZielY) > 1) || ((neueZielX - neueStartX) > 1)) {
+				// System.out.println("wäre mehr als ein feld nach vorn/diagonal");
+				return false;
+			}
+			// Henne darf seitlich gehen, nach links
+		} else if (neueStartX > neueZielX) {
+			if ((neueStartY == neueZielY) && ((neueStartX - 1) != neueZielX)) {
+				// System.out.println("darf nur ein feld seitwärts gehen");
+				return false;
+
+				// Henne darf nicht diagonal nach links oben
+			} else if (((neueStartY - 1) == neueZielY) && ((neueStartX - 1) == neueZielX)) {
+				// System.out.println("darf nicht diagonal");
+				return false;
+
+			} else if (((neueStartY - neueZielY) > 1) || ((neueStartX - neueZielX) > 1)) {
+				// System.out.println("wäre mehr als ein feld nach vorn/diagonal");
+				return false;
+			}
+			// Henne darf nur einen Schritt nach vorn
+		} else if ((neueStartY - 1) != neueZielY) {
+			// System.out.println("darf nur ein feld nach vorne");
+			return false;
+
+		}
+
+		// System.out.println("Hennenmethode aufgerufen");
+		return true;
+
+	}
+
+	public static boolean hennenRespawn(Spiel spiel, int counter) {
+		int istGeradeGespawnt = 0;
+		int zähleHennen = 0;
+		char[][] spielbrettArray = spiel.getSpielbrettArray();
+		int zähler = counter;
+		if (zähler >= 1) {
+			return false;
+		}
+
+		// Zähle die Hennen auf dem Feld
+		for (int i = 0; i < spielbrettArray.length; i++) {
+			for (int j = 0; j < spielbrettArray[i].length; j++) {
+				if (spielbrettArray[i][j] == 'X') {
+					zähleHennen++;
+				}
+			}
+		}
+		// Abfrage max. Anzahl Hennen
+		if (zähleHennen >= 27) {
+			System.out.println("Maximale Anzahl Hennen auf dem Feld, es kann keine Spawnen.");
+			return false;
+		}
+
+		// Abfrage ob ein Feld im unteren Bereich frei ist
+		for (int i = 8; i >= 6; i--) {
+			for (int j = 4; j <= 6; j++) {
+				if (istGeradeGespawnt == 1) {
+					break;
+				}
+				if (spielbrettArray[i][j] == '\u25A1') {
+					spiel.ändereWertImArray(i, j, 'X');
+					System.out.println("an der Stelle " + i + ", " + j + " ist eine neue Henne gespawnt");
+					istGeradeGespawnt = 1;
+				}
+
+			}
+		}
+		// Abfrage ob ein Feld in der mitte frei ist
+		for (int i = 5; i >= 3; i--) {
+			for (int j = 1; j <= 9; j++) {
+				if (istGeradeGespawnt == 1) {
+					break;
+				}
+				if (spielbrettArray[i][j] == '\u25A1') {
+					spiel.ändereWertImArray(i, j, 'X');
+					System.out.println("an der Stelle " + i + ", " + j + " ist eine neue Henne gespawnt");
+					istGeradeGespawnt = 1;
+
+				}
+
+			}
+		}
+		if (istGeradeGespawnt == 1) {
+			istGeradeGespawnt = 0;
+		}
+		return false;
 	}
 }

src/domain/Spielfigur.java

@@ -2,19 +2,11 @@ package domain;
 
 public abstract class Spielfigur {
 
-	public int selectSpielfigur(int feldKey) {
+	public abstract boolean oberIsValidMove(String zug, Spiel spiel);
-		return feldKey;
+//	public static boolean isValidMove(String zug) {
-	}
+//		return false;
+//	}
 
-	public int moveSpielfigur(int feldKey) {
+	public abstract void moveSpielfigur(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel);
-		return feldKey;
-	}
 	
-	public boolean findeSpielfigur(int feldKey) {
-		return false;
-	}
-	
-	public boolean validMove(int startKey, int zielKey) {
-		return false;
-	}
 }

src/domain/TestenFürFunktionen.java

@@ -1,10 +0,0 @@
-package domain;
-
-public class TestenFürFunktionen {
-
-	public static void main(String[] args) {
-		// TODO Auto-generated method stub
-
-	}
-
-}

src/facade/.gitignore

@@ -1 +0,0 @@
-/Spielsystem.class

src/facade/Spielsystem.java

@@ -1,33 +1,419 @@
 package facade;
 
-import java.util.ArrayList;
+import domain.Bot;
-import java.util.HashMap;
+import domain.BotEasyFuchs;
-
+import domain.BotEasyHenne;
+import domain.BotHardFuchs;
+import domain.BotHardHenne;
+import domain.BotMediumFuchs;
+import domain.BotMediumHenne;
+import domain.Computer;
+import domain.Fuchs;
+import domain.Hennen;
 import domain.Spiel;
+import domain.Spielfigur;
 
 public class Spielsystem {
-	private String spielname;
-	
 	private Spiel spiel;
-	//wird benötigt wenn mehrere Spiele angelegt werden sollen
+	private Spielfigur henne;
-	//private ArrayList<Spiel> alleSpiele = new ArrayList<>();
+	private Spielfigur fuchs;
+	private Spielfigur spieler;
+	private Spielfigur spieler2;
+	private Spielfigur computer;
+	private Bot ki;
+	private boolean aktiverSpieler;
 
 	public Spielsystem(String spielname) throws Exception {
-		this.spielname = spielname;
+		this.spiel = new Spiel(spielname);
+		this.henne = new Hennen();
+		this.fuchs = new Fuchs();
+	}
+
+	public void spielerBestimmen(int spielerwahl) {
+		if (spielerwahl == 1) {
+			spieler = new Fuchs();
+		} else if (spielerwahl == 2) {
+			spieler = new Hennen();
+		} else {
+			// Scheiße
+		}
+	}
+
+	public void spielerBestimmen2Spieler(int spielerwahl) {
+		if (spielerwahl == 1) {
+			spieler = new Fuchs();
+			spieler2 = new Hennen();
+			computer = new Computer();
+		} else if (spielerwahl == 2) {
+			spieler = new Hennen();
+			spieler2 = new Fuchs();
+			computer = new Computer();
+		}
+
+	}
+
+	public void start2Spieler(boolean werBeginnt) {
+		spiel.generiereSpielbrett();
+
+	}
+
+	public void computerBestimmen(int spielerwahl) {
+		if (spielerwahl == 2) {
+			computer = new Fuchs();
+		} else if (spielerwahl == 1) {
+			computer = new Hennen();
+		} else {
+			// Scheiße
+		}
+	}
+
+	public void setAktivenSpieler(boolean überprüfung) {
+		if (überprüfung == true) {
+			// aktiverSpieler ist der Spieler
+			aktiverSpieler = true;
+		} else {
+			// aktiverSpieler ist der Computer
+			aktiverSpieler = false;
+		}
+	}
+
+	public void setAktivenSpieler2Spieler(boolean überprüfung) {
+		if (überprüfung == true) {
+			// aktiverSpieler ist der Spieler
+			aktiverSpieler = true;
+		} else {
+			// aktiverSpieler ist der Computer
+			aktiverSpieler = false;
+		}
 	}
 
 	public String getSpielname() {
-		return spielname;
+		return spiel.getSpielname();
 	}
 
-	public HashMap<Integer, Character> spielAnlegen(String spielstandName) {
+	public boolean getSpielfigurComputer() {
-		this.spiel = new Spiel(spielstandName);
+		if (computer instanceof Hennen) {
-		HashMap<Integer, Character> spielbrett = spiel.generiereSpielbrett();
+			return true;
+		} else {
+			return false;
+		}
+	}
 
-		//wird benötigt wenn mehrere Spiele angelegt werden sollen
+	public boolean getSpielfigurSpieler() {
-		//alleSpiele.add(spiel);
+		if (spieler instanceof Hennen) {
+			return true;
+		} else {
+			return false;
+		}
+	}
 
-		return spielbrett;
+	public Spielfigur getHenne() {
+		return henne;
+	}
+
+	public Spielfigur getFuchs() {
+		return fuchs;
+	}
+
+	public Bot getBot() {
+		return ki;
+	}
+
+	public void printBoard() {
+		spiel.printBoard();
+	}
+
+	public boolean fuchsUmzingelt() {
+		return Fuchs.fuchsUmzingelt(spiel);
+	}
+
+	public void killFuchs() {
+		Fuchs.killFuchs(spiel);
+	}
+
+	public boolean gewinnBedingungHennen() {
+		return spiel.gewinnBedingungHennen();
+	}
+
+	public boolean gewinnBedingungFuchs() {
+		return spiel.gewinnBedingungFuchs();
+	}
+
+	public boolean isWon() {
+		if (gewinnBedingungHennen() == true) {
+			System.out.println("Hennen haben gewonnen");
+			whoWon();
+			return true;
+		} else if (gewinnBedingungFuchs() == true) {
+			System.out.println("Füchse haben gewonnen");
+			whoWon();
+			return true;
+		}
+		return false;
+	}
+
+	public boolean isRunning() {
+		if (isWon() == false) {
+			return true;
+		}
+		return false;
+	}
+
+	public boolean whoWon() {
+		if (gewinnBedingungFuchs() == true) {
+			if (spieler instanceof Fuchs) {
+				System.out.println("Spieler 1 gewinnt");
+				return true;
+
+			} else {
+				System.out.println("Spieler 2 gewinnt");
+				return false;
+			}
+		} else {
+			if (spieler instanceof Hennen) {
+				System.out.println("Spieler 1 gewinnt");
+				return true;
+
+			} else {
+				System.out.println("Spieler 2 gewinnt");
+				return false;
+			}
+		}
+	}
+
+	public boolean isValidMove(String zug) {
+		if (aktiverSpieler == true) {
+			return spieler.oberIsValidMove(zug, spiel);
+		} else {
+			return computer.oberIsValidMove(zug, spiel);
+		}
+	}
+
+	public boolean isValidMoveHenne(String zug) {
+		if (spieler instanceof Hennen) {
+			return spieler.oberIsValidMove(zug, spiel);
+		} else if (spieler2 instanceof Hennen) {
+			return spieler2.oberIsValidMove(zug, spiel);
+		}
+		return false;
+	}
+
+
+	public boolean isValidMoveFüchse(String zug) {
+		if (spieler instanceof Fuchs) {
+			return spieler.oberIsValidMove(zug, spiel);
+		} else if (spieler2 instanceof Fuchs) {
+			return spieler2.oberIsValidMove(zug, spiel);
+		}
+		return false;
+	}
+
+	// Noch falsche Ausgabe vom Zug (Array statt wie bei Eingabe vom Spieler)
+	// <---------------------------------------------------------------------
+
+	public String yourMove() {
+		String zug = spiel.yourMove(spiel, ki, computer);
+
+		return zug;
+	}
+
+	public void myMove2Spieler(String zug, String figur) {
+		char[][] spielbrettArray = spiel.getSpielbrettArray();
+
+		String moveZug = moveZugBestimmen(zug);
+		System.out.println(moveZug);
+
+		int[] neueKoordinaten = spiel.berechneRichtigeKoordinaten(moveZug);
+		int neueStartY = neueKoordinaten[0];
+		int neueStartX = neueKoordinaten[1];
+		int neueZielY = neueKoordinaten[2];
+		int neueZielX = neueKoordinaten[3];
+
+		if (figur.equals("Fuchs")) {
+			if (spieler instanceof Fuchs) {
+				spieler.moveSpielfigur(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
+			} else if (spieler2 instanceof Fuchs) {
+				spieler2.moveSpielfigur(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
+			}
+		} else if (figur.equals("Henne")) {
+			if (spieler instanceof Hennen) {
+				spieler.moveSpielfigur(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
+				checkRespawn();
+
+			} 
+			if (spieler2 instanceof Hennen) {
+				spieler2.moveSpielfigur(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
+				checkRespawn();
+
+			}
 		}
 
 	}
+
+	public void myMove(String zug) {
+		char[][] spielbrettArray = spiel.getSpielbrettArray();
+		int counterObersteReihe = 0;
+		int counterMittlereReihe = 0;
+		int counterUntereReihe = 0;
+
+		String moveZug = moveZugBestimmen(zug);
+		System.out.println(moveZug);
+
+		int[] neueKoordinaten = spiel.berechneRichtigeKoordinaten(moveZug);
+		int neueStartY = neueKoordinaten[0];
+		int neueStartX = neueKoordinaten[1];
+		int neueZielY = neueKoordinaten[2];
+		int neueZielX = neueKoordinaten[3];
+
+		if (aktiverSpieler == true) {
+			spieler.moveSpielfigur(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
+			// Check ob eine Henne respawnen kann, nachdem die oberste Reihe gefüllt wurde
+			if (spielbrettArray[0][4] == 'X' && spielbrettArray[0][5] == 'X' && spielbrettArray[0][6] == 'X') {
+				Hennen.hennenRespawn(spiel, counterObersteReihe);
+				counterObersteReihe++;
+			}
+			// Check ob die oberere und die mittlere Reihe gefüllt wurden mit dem Zug
+			if ((spielbrettArray[0][4] == 'X' && spielbrettArray[0][5] == 'X' && spielbrettArray[0][6] == 'X')
+					&& (spielbrettArray[1][4] == 'X' && spielbrettArray[1][5] == 'X' && spielbrettArray[1][6] == 'X')) {
+				Hennen.hennenRespawn(spiel, counterMittlereReihe);
+				counterMittlereReihe++;
+			}
+			// für die Vollständigkeit trotzdem dazu, obwohl der Fall nicht eintreten kann,
+			// da die Hennen dann gewonnen haben
+			if (spielbrettArray[0][4] == 'X' && spielbrettArray[0][5] == 'X' && spielbrettArray[0][6] == 'X'
+					&& spielbrettArray[1][4] == 'X' && spielbrettArray[1][5] == 'X' && spielbrettArray[1][6] == 'X'
+					&& spielbrettArray[2][4] == 'X' && spielbrettArray[2][5] == 'X' && spielbrettArray[2][6] == 'X') {
+				Hennen.hennenRespawn(spiel, counterUntereReihe);
+				counterUntereReihe++;
+			}
+
+		} else {
+			computer.moveSpielfigur(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
+		}
+	}
+
+	public String moveZugBestimmen(String zug) {
+		int zugLänge = zug.length();
+		return "" + zug.charAt(0) + zug.charAt(1) + zug.charAt(2) + " " + zug.charAt(zugLänge - 3)
+				+ zug.charAt(zugLänge - 2) + zug.charAt(zugLänge - 1);
+
+	}
+
+	public void start(boolean werBeginnt, int kiLevel) {
+
+		if (kiLevel == 0 && computer instanceof Hennen) {
+			ki = new BotEasyHenne();
+		} else if (kiLevel == 1 && computer instanceof Hennen) {
+			ki = new BotMediumHenne();
+		} else if (kiLevel == 2 && computer instanceof Hennen) {
+			ki = new BotHardHenne();
+		} else if (kiLevel == 0 && computer instanceof Fuchs) {
+			ki = new BotEasyFuchs();
+		} else if (kiLevel == 1 && computer instanceof Fuchs) {
+			ki = new BotMediumFuchs();
+		} else if (kiLevel == 2 && computer instanceof Fuchs) {
+			ki = new BotHardFuchs();
+		} else {
+			// Fehleingabe
+		}
+
+		spiel.generiereSpielbrett();
+
+//		UI.start(werBeginnt, kiLevel);
+	}
+
+	public boolean findeHenne(String henneGewählt) {
+
+		char[][] spielbrett = spiel.getSpielbrettArray();
+
+		char startKoordinate1 = henneGewählt.charAt(0);
+		char startKoordinate2 = henneGewählt.charAt(2);
+
+		// Werte als int
+		int koordX = Character.getNumericValue(startKoordinate1);
+		int koordY = Character.getNumericValue(startKoordinate2);
+
+		int[] neueKoordinaten = spiel.wandelPassendUm(koordX, koordY);
+
+		int neuesX = neueKoordinaten[1];
+		int neuesY = neueKoordinaten[0];
+
+		if (spielbrett[neuesY][neuesX] == 'X') {
+			System.out.println("Henne gefunden");
+			return true;
+		} else {
+			System.out.println("Keine Henne an der gewählten Stelle");
+			return false;
+		}
+
+	}
+
+	public boolean findeFreiesFeld(String pushHenne) {
+		char[][] spielbrett = spiel.getSpielbrettArray();
+
+		char startKoordinate1 = pushHenne.charAt(0);
+		char startKoordinate2 = pushHenne.charAt(2);
+
+		// Werte als int
+		int koordX = Character.getNumericValue(startKoordinate1);
+		int koordY = Character.getNumericValue(startKoordinate2);
+
+		int[] neueKoordinaten = spiel.wandelPassendUm(koordX, koordY);
+
+		int neuesX = neueKoordinaten[1];
+		int neuesY = neueKoordinaten[0];
+
+		if (spielbrett[neuesY][neuesX] == '\u25A1') {
+			System.out.println("freies Feld gefunden");
+			return true;
+		} else {
+			System.out.println("Keine kein freies Feld an der gewählten Stelle");
+			return false;
+		}
+
+	}
+
+	public boolean pushHenne(String zugPushHenne) {
+		char[][] spielbrett = spiel.getSpielbrettArray();
+
+		int[] neueKoordinaten = spiel.berechneRichtigeKoordinaten(zugPushHenne);
+		int neueStartY = neueKoordinaten[0];
+		int neueStartX = neueKoordinaten[1];
+		int neueZielY = neueKoordinaten[2];
+		int neueZielX = neueKoordinaten[3];
+
+		spiel.ändereWertImArray(neueZielY, neueZielX, 'X');
+		spiel.ändereWertImArray(neueStartY, neueStartX, '\u25A1');
+
+		return true;
+
+	}
+
+	public void checkRespawn() {
+		char[][] spielbrettArray = spiel.getSpielbrettArray();
+		int counterObersteReihe = 0;
+		int counterMittlereReihe = 0;
+		int counterUntereReihe = 0;
+
+		// Check ob eine Henne respawnen kann, nachdem die oberste Reihe gefüllt wurde
+		if (spielbrettArray[0][4] == 'X' && spielbrettArray[0][5] == 'X' && spielbrettArray[0][6] == 'X') {
+			Hennen.hennenRespawn(spiel, counterObersteReihe);
+			counterObersteReihe++;
+		}
+		// Check ob die oberere und die mittlere Reihe gefüllt wurden mit dem Zug
+		if ((spielbrettArray[0][4] == 'X' && spielbrettArray[0][5] == 'X' && spielbrettArray[0][6] == 'X')
+				&& (spielbrettArray[1][4] == 'X' && spielbrettArray[1][5] == 'X' && spielbrettArray[1][6] == 'X')) {
+			Hennen.hennenRespawn(spiel, counterMittlereReihe);
+			counterMittlereReihe++;
+		}
+		// für die Vollständigkeit trotzdem dazu, obwohl der Fall nicht eintreten kann,
+		// da die Hennen dann gewonnen haben
+		if (spielbrettArray[0][4] == 'X' && spielbrettArray[0][5] == 'X' && spielbrettArray[0][6] == 'X'
+				&& spielbrettArray[1][4] == 'X' && spielbrettArray[1][5] == 'X' && spielbrettArray[1][6] == 'X'
+				&& spielbrettArray[2][4] == 'X' && spielbrettArray[2][5] == 'X' && spielbrettArray[2][6] == 'X') {
+			Hennen.hennenRespawn(spiel, counterUntereReihe);
+			counterUntereReihe++;
+
+		}
+	}
+}

src/infrastructure/.gitignore

@@ -1 +0,0 @@
-/Persistenz.class

src/infrastructure/Persistenz.java

@@ -2,9 +2,9 @@ package infrastructure;
 
 public class Persistenz {
 
-	public static void main(String[] args) {
+	// public static void main(String[] args) {
-		// TODO Auto-generated method stub
+	// 	// TODO Auto-generated method stub
-
+
-	}
+	// }
 
 }

src/main/.gitignore

@@ -1 +0,0 @@
-/Main.class

src/ui/.gitignore

@@ -1 +0,0 @@
-/UI.class

src/ui/UI.java

@@ -1,7 +1,7 @@
 package ui;
 
-import java.util.HashMap;
 import java.util.Scanner;
+
 import facade.Spielsystem;
 
 public class UI {
@@ -16,22 +16,19 @@ public class UI {
 	private void hauptmenü() {
 		System.out.println("Willkommen beim Spiel des Jahres: " + spielsystem.getSpielname() + "!");
 
-		mainloop: 
+		mainloop: while (true) {
-			while (true) {
 			System.out.println();
 			System.out.println("--------");
 			System.out.println("Hauptmenü:");
 			System.out.println("1 -> Neues Spiel starten");
-				System.out.println("2 -> Alten Spielstand laden");
+			System.out.println("2 -> Regeln anzeigen");
-				System.out.println("3 -> Regeln anzeigen");
-				System.out.println("7 -> Highscore anzeigen");
 			System.out.println("8 -> Credits anzeigen");
 
 			System.out.println("9 -> Beenden");
 			System.out.println();
 			System.out.print("> ");
-				int input = 0;
 
+			int input = 0;
 			try {
 				input = Integer.parseInt(sc.nextLine());
 				System.out.println();
@@ -41,12 +38,19 @@ public class UI {
 
 			try {
 				switch (input) {
-					case 1: spielStarten(); gameloop(); break;
+				case 1:
-					case 2: spielstandLaden(); break;
+					gameloop();
-					case 3: regelnAnzeigen(); break;
+					break;
-					case 7: highscoreAnzeigen(); break;
+				// case 2: spielstandLaden(); break;
-					case 8: creditsAnzeigen(); break;
+				case 2:
-					case 9: break mainloop;
+					regelnAnzeigen();
+					break;
+				// case 7: highscoreAnzeigen(); break;
+				case 8:
+					creditsAnzeigen();
+					break;
+				case 9:
+					break mainloop;
 				}
 			} catch (Exception e) {
 				System.err.println(e.getLocalizedMessage());
@@ -55,15 +59,15 @@ public class UI {
 		System.out.println("Auf Wiedersehen!");
 	}
 
+	// hauptmenü
+	// case 1:
 	private void gameloop() {
-		gameloop:
+		gameloop: while (true) {
-			while(true) {
 			System.out.println();
 			System.out.println("--------");
 			System.out.println("Spielmenü:");
-				System.out.println("1 -> Einspieler auswählen");
+			System.out.println("1 -> Player vs. Player");
-				System.out.println("2 -> Mehrspieler auswählen");
+			System.out.println("2 -> Player vs. KI");
-				System.out.println("3 -> KI Schwierigkeit auswählen");
 
 			System.out.println("9 -> Zurück");
 			System.out.println();
@@ -79,10 +83,14 @@ public class UI {
 
 			try {
 				switch (input) {
-					case 1: break;
+				case 1:
-					case 2: break;
+					pVP();
-					case 3: break;
+					break;
-					case 9: break gameloop;
+				case 2:
+					pVE();
+					break;
+				case 9:
+					break gameloop;
 				}
 			} catch (Exception e) {
 				System.err.println(e.getLocalizedMessage());
@@ -90,43 +98,439 @@ public class UI {
 		}
 	}
 
-	// hauptmenü
+	// case 2:
+	private void regelnAnzeigen() {
+
+	}
+
+	// case 8:
+	private void creditsAnzeigen() {
+
+	}
+
+	// gameloop
 	// case 1:
-	private void spielStarten() {
+	private void pVP() {
-		//Evtl. wichtig für später, um Spielstände anzulegen und zu persistieren
+		System.out.println("Spieler 1, wollen Sie als die Füchse oder Hennen spielen?");
-		System.out.println("Bitte vergeben Sie Ihren Spielstand einen Namen: \n");
+		System.out.println("1 -> Füchse spielen");
+		System.out.println("2 -> Hennen spielen");
+		System.out.println();
 		System.out.print("> ");
-		String spielstandName = sc.nextLine();
+		int spieler1Spielt = Integer.parseInt(sc.nextLine());
+		int spieler2Spielt = 0;
+		switch (spieler1Spielt) {
+		case 1:
+			spielsystem.spielerBestimmen2Spieler(spieler1Spielt);
+			spieler2Spielt = 2;
+			System.out.println();
+			System.out.println("Sie haben sich für die Füchse entschieden.");
+			System.out.println("Spieler 2 spielt somit die Hennen. ");
+			System.out.println();
+			break;
+		case 2:
+			spielsystem.spielerBestimmen2Spieler(spieler1Spielt);
+			spieler2Spielt = 1;
+			System.out.println();
+			System.out.println("Sie haben sich für die Hennen entschieden.");
+			System.out.println("Spieler 2 spielt somit die Füchse. ");
+			System.out.println();
+			break;
+		}
+		boolean werBeginnt = werBeginnt();
+		spielsystem.start2Spieler(werBeginnt);
+		start2Spieler(werBeginnt, spieler1Spielt, spieler2Spielt);
+
+	}
+
+	// case 2:
+	private void pVE() {
+		System.out.println("Wollen Sie als Spieler die Füchse oder Hennen spielen?");
+		System.out.println("1 -> Füchse spielen");
+		System.out.println("2 -> Hennen spielen");
+		System.out.println();
+		System.out.print("> ");
+		int spielerwahl = Integer.parseInt(sc.nextLine());
 		System.out.println();
 
-		HashMap<Integer, Character> spielbrett = spielsystem.spielAnlegen(spielstandName);
+		spielsystem.spielerBestimmen(spielerwahl);
+		spielsystem.computerBestimmen(spielerwahl);
 
-		//Spielbrett ausgeben
+		boolean werBeginnt = werBeginnt();
-		int zähler = 0;
+
-		for (int i = 0; i < spielbrett.size(); i++) {
+		System.out.println("Auf welchen Schwierigkeitsgrad wollen Sie spielen?");
-			if (zähler == 9) {
+		System.out.println("0 -> easy");
-				System.out.println(spielbrett.get(i));
+		System.out.println("1 -> medium");
-				zähler = 0;
+		System.out.println("2 -> hard");
+		System.out.println();
+		System.out.print("> ");
+		int kiLevel = Integer.parseInt(sc.nextLine());
+		System.out.println();
+
+		spielsystem.start(werBeginnt, kiLevel);
+		start(werBeginnt, kiLevel);
+	}
+
+	public void start2Spieler(boolean werBeginnt, int spieler1Wahl, int spieler2Wahl) {
+		int counter = 0;
+		boolean zugFuchs = false;
+		boolean zugHenne = false;
+		boolean erfolgreicherZug;
+		boolean erfolgreich;
+		boolean freiesFeld;
+		boolean erfolgreichGepusht;
+		String zugPushHenne = "";
+		String zug;
+
+		if (werBeginnt == true) {
+			zugHenne = true;
 		} else {
-				System.out.print(spielbrett.get(i) + " ");
+			zugFuchs = true;
-				zähler++;
-			}
-		}
 		}
 
-	public void spielstandLaden() {
+		System.out.println("Das Spiel wurde gestartet!");
+		System.out.println();
+		System.out.println("Das Startspielbrett sieht wie folgt aus:");
+		System.out.println();
+		spielsystem.printBoard();
+		System.out.println();
+
+		do {
+			// wenn Henne beginnt
+			if (zugHenne == true) {
+
+				// spielsystem.setAktivenSpieler(true);
+				System.out.println("Die Hennen sind am Zug:");
+				System.out.println("Spieler Sie sind dran");
+				do {
+					System.out.println("Bitte geben Sie Ihren Zug ein:");
+					System.out.println();
+					System.out.print("> ");
+					zug = sc.nextLine();
+					System.out.println();
+					erfolgreicherZug = spielsystem.isValidMoveHenne(zug);
+
+					if (erfolgreicherZug == false) {
+						System.out.println("Ihre Zugeingabe: -" + zug + "- war leider kein valider Zug!");
+						System.out.println("Sie sind weiterhin am Zug");
+						System.out.println();
+					}
+				} while (erfolgreicherZug == false);
+
+				spielsystem.myMove2Spieler(zug,"Henne");
+				zugHenne = false;
+				zugFuchs = true;
+
+
+				// wenn Fuchs beginnt
+			} else if (zugFuchs == true) {
+				// spielsystem.setAktivenSpieler(true);
+				System.out.println("Die Füchse sind am Zug:");
+
+				if (spielsystem.fuchsUmzingelt() == true) {
+					System.out.println();
+					System.out.println("Mindestens einer Ihrer Füchse in umzingelt!");
+					System.out.println(
+							"Wenn Sie nichts dagegen tun können, wird dieser Fuchs am Ende des Zuges eliminiert.");
+					System.out.println();
+				}
+
+				System.out.println("Bitte wählen Sie entweder (1) normaler Zug oder (2) Sonderzug Push Henne");
+				System.out.println("Denken Sie daran, dass Sie den Sonderzug nur - 1x - benutzen können!");
+				int eingabe = Integer.parseInt(sc.nextLine());
+				switch (eingabe) {
+				case 1:
+					System.out.println("Spieler Sie sind dran");
+					do {
+						System.out.println("Bitte geben Sie Ihren Zug ein:");
+						System.out.println();
+						System.out.print("> ");
+						zug = sc.nextLine();
+						System.out.println();
+						erfolgreicherZug = spielsystem.isValidMoveFüchse(zug);
+
+						if (erfolgreicherZug == false) {
+							System.out.println("Ihre Zugeingabe: -" + zug + "- war leider kein valider Zug!");
+							System.out.println("Sie sind weiterhin am Zug");
+							System.out.println();
+						}
+					} while (erfolgreicherZug == false);
+
+					spielsystem.myMove2Spieler(zug, "Fuchs");
+
+					zugHenne = true;
+					zugFuchs = false;
+					break;
+				case 2:
+					if (counter == 1) {
+						System.out.println("Sonderzug wurde schon verbraucht. ");
+						break;
+					}
+					do {
+						System.out.println("Sonderzug gewählt. ");
+						System.out.println("Bitte wählen Sie die Henne, die Sie bewegen möchten: ");
+						String henneGewählt = sc.nextLine();
+						erfolgreich = spielsystem.findeHenne(henneGewählt);
+
+						if (erfolgreich == false) {
+							System.out.println("Ihre Zugeingabe -" + henneGewählt + "- war leider kein valider Zug!");
+							System.out.println("Sie sind weiterhin am Zug");
+							System.out.println();
+
+						} else if (erfolgreich == true) {
+							zugPushHenne += henneGewählt;
 
 						}
 
-	public void regelnAnzeigen() {
+					} while (erfolgreich == false);
+					do {
+						System.out.println("Henne wurde erfolgreich gewählt. Wo soll sie hingeschoben werden? ");
+						String pushHenne = sc.nextLine();
+						freiesFeld = spielsystem.findeFreiesFeld(pushHenne);
+
+						if (freiesFeld == false) {
+							System.out.println("Ihre Zugeingabe -" + pushHenne + "- war leider kein valider Zug!");
+							System.out.println("Sie sind weiterhin am Zug");
+							System.out.println();
+
+						} else if (freiesFeld == true) {
+							zugPushHenne += " " + pushHenne;
+							counter++;
+						}
+
+					} while (freiesFeld == false);
+					erfolgreichGepusht = spielsystem.pushHenne(zugPushHenne);
+					System.out.println("Henne wurde erfolgreich geschoben. ");
+					zugHenne = true;
+					zugFuchs = false;
+					break;
+
+				}
+				if (spielsystem.fuchsUmzingelt() == true) {
+					System.out.println();
+					System.out.println("Leider ist noch ein Fuchs umzingelt!");
+					System.out.println("Dieser wird nun ausgelöscht.");
+					System.out.println();
+					spielsystem.killFuchs();
+				}
+			}
+
+			// nach jedem Zug das Spielbrett ausgeben
+			spielsystem.printBoard();
+
+		} while (spielsystem.isRunning() == true);
+	}
+
+	public void start(boolean werBeginnt, int kiLevel) {
+		boolean zugFuchs = false;
+		boolean zugHenne = false;
+		boolean spielfigurComputer = spielsystem.getSpielfigurComputer();
+		boolean spielfigurSpieler = spielsystem.getSpielfigurSpieler();
+		boolean erfolgreicherZug;
+		boolean erfolgreich;
+		boolean freiesFeld;
+		boolean erfolgreichGepusht;
+		String zugPushHenne = "";
+		int counter = 0;
+
+		String zug;
+
+		if (werBeginnt == true) {
+			zugHenne = true;
+		} else {
+			zugFuchs = true;
+		}
+
+		System.out.println("Das Spiel wurde gestartet!");
+		if (kiLevel == 0) {
+			System.out.println("Sie haben den Schwierigkeitsgrad -easy- ausgewählt");
+		} else if (kiLevel == 1) {
+			System.out.println("Sie haben den Schwierigkeitsgrad -medium- ausgewählt");
+		} else if (kiLevel == 2) {
+			System.out.println("Sie haben den Schwierigkeitsgrad -hard- ausgewählt");
+		}
+
+		System.out.println();
+		System.out.println("Das Startspielbrett sieht wie folgt aus:");
+		System.out.println();
+		spielsystem.printBoard();
+		System.out.println();
+
+		do {
+			// Zug Henne KI
+			if (zugHenne == true && spielfigurComputer == true) {
+				spielsystem.setAktivenSpieler(false);
+				System.out.println("Die Hennen sind am Zug:");
+				System.out.println("Die KI macht Ihren Zug");
+				System.out.println();
+				zug = spielsystem.yourMove();
+				System.out.println();
+				System.out.println("Die KI hat folgenden Zug gemacht: " + zug);
+
+				zugHenne = false;
+				zugFuchs = true;
+			}
+
+			// Zug Henne Spieler
+			else if (zugHenne == true && spielfigurSpieler == true) {
+				spielsystem.setAktivenSpieler(true);
+				System.out.println("Die Hennen sind am Zug:");
+				System.out.println("Spieler Sie sind dran");
+				do {
+					System.out.println("Bitte geben Sie Ihren Zug ein:");
+					System.out.println();
+					System.out.print("> ");
+					zug = sc.nextLine();
+					System.out.println();
+					erfolgreicherZug = spielsystem.isValidMove(zug);
+
+					if (erfolgreicherZug == false) {
+						System.out.println("Ihre Zugeingabe: -" + zug + "- war leider kein valider Zug!");
+						System.out.println("Sie sind weiterhin am Zug");
+						System.out.println();
+					}
+				} while (erfolgreicherZug == false);
+
+				spielsystem.myMove(zug);
+				zugHenne = false;
+				zugFuchs = true;
+			}
+
+			// Zug Fuchs Spieler
+			else if (zugFuchs == true && spielfigurSpieler == false) {
+				spielsystem.setAktivenSpieler(true);
+				System.out.println("Die Füchse sind am Zug:");
+
+				if (spielsystem.fuchsUmzingelt() == true) {
+					System.out.println();
+					System.out.println("Mindestens einer Ihrer Füchse in umzingelt!");
+					System.out.println(
+							"Wenn Sie nichts dagegen tun können, wird dieser Fuchs am Ende des Zuges eliminiert.");
+					System.out.println();
+				}
+
+				System.out.println("Bitte wählen Sie entweder (1) normaler Zug oder (2) Sonderzug Push Henne");
+				System.out.println("Denken Sie daran, dass Sie den Sonderzug nur - 1x - benutzen können!");
+				int eingabe = Integer.parseInt(sc.nextLine());
+				switch (eingabe) {
+				case 1:
+					System.out.println("Spieler Sie sind dran");
+					do {
+						System.out.println("Bitte geben Sie Ihren Zug ein:");
+						System.out.println();
+						System.out.print("> ");
+						zug = sc.nextLine();
+						System.out.println();
+						erfolgreicherZug = spielsystem.isValidMove(zug);
+
+						if (erfolgreicherZug == false) {
+							System.out.println("Ihre Zugeingabe: -" + zug + "- war leider kein valider Zug!");
+							System.out.println("Sie sind weiterhin am Zug");
+							System.out.println();
+						}
+					} while (erfolgreicherZug == false);
+
+					spielsystem.myMove(zug);
+
+					zugHenne = true;
+					zugFuchs = false;
+					break;
+				case 2:
+					if (counter == 1) {
+						System.out.println("Sonderzug wurde schon verbraucht. ");
+						break;
+					}
+					do {
+						System.out.println("Sonderzug gewählt. ");
+						System.out.println("Bitte wählen Sie die Henne, die Sie bewegen möchten: ");
+						String henneGewählt = sc.nextLine();
+						erfolgreich = spielsystem.findeHenne(henneGewählt);
+
+						if (erfolgreich == false) {
+							System.out.println("Ihre Zugeingabe -" + henneGewählt + "- war leider kein valider Zug!");
+							System.out.println("Sie sind weiterhin am Zug");
+							System.out.println();
+
+						} else if (erfolgreich == true) {
+							zugPushHenne += henneGewählt;
 
 						}
 
-	public void highscoreAnzeigen() {
+					} while (erfolgreich == false);
+					do {
+						System.out.println("Henne wurde erfolgreich gewählt. Wo soll sie hingeschoben werden? ");
+						String pushHenne = sc.nextLine();
+						freiesFeld = spielsystem.findeFreiesFeld(pushHenne);
+
+						if (freiesFeld == false) {
+							System.out.println("Ihre Zugeingabe -" + pushHenne + "- war leider kein valider Zug!");
+							System.out.println("Sie sind weiterhin am Zug");
+							System.out.println();
+
+						} else if (freiesFeld == true) {
+							zugPushHenne += " " + pushHenne;
+							counter++;
+						}
+
+					} while (freiesFeld == false);
+					erfolgreichGepusht = spielsystem.pushHenne(zugPushHenne);
+					System.out.println("Henne wurde erfolgreich geschoben. ");
+					zugHenne = true;
+					zugFuchs = false;
+					break;
+
+				}
+				if (spielsystem.fuchsUmzingelt() == true) {
+					System.out.println();
+					System.out.println("Leider ist noch ein Fuchs umzingelt!");
+					System.out.println("Dieser wird nun ausgelöscht.");
+					System.out.println();
+					spielsystem.killFuchs();
+				}
+			}
+
+			// Zug Fuchs KI
+			else if (zugFuchs == true && spielfigurComputer == false) {
+				spielsystem.setAktivenSpieler(false);
+				System.out.println("Die Füchse sind am Zug:");
+				System.out.println("Die KI macht Ihren Zug");
+				System.out.println();
+				zug = spielsystem.yourMove();
+				System.out.println();
+				System.out.println("Die KI hat folgenden Zug gemacht: " + zug);
+
+				zugHenne = true;
+				zugFuchs = false;
+
+				if (spielsystem.fuchsUmzingelt() == true) {
+					spielsystem.killFuchs();
+				}
+			}
+
+			// nach jedem Zug das Spielbrett ausgeben
+			spielsystem.printBoard();
+
+		} while (spielsystem.isRunning() == true);
 
 	}
 
-	public void creditsAnzeigen() {
+	private boolean werBeginnt() {
+		System.out.println("Sollen die Füchse oder Hennen beginnen?");
+		System.out.println("1 -> Füchse beginnen");
+		System.out.println("2 -> Hennen beginnen");
+		System.out.println();
+		System.out.print("> ");
+		int werBeginnt = Integer.parseInt(sc.nextLine());
+		System.out.println();
+
+		if (werBeginnt == 1) {
+			System.out.println("Füchse beginnen.");
+			// Füchse starten
+			return false;
+		} else {
+			System.out.println("Hennen beginnen.");
+			// Hennen starten
+			return true;
+		}
+	}
 
 }
-}