berechneRichtigeKoordinate geschrieben(aus isValidMove Henne entfernt) +

isValidMove Fuchs + killHenne + Zugriffe aufs Array

src/domain/Fuchs.java

@@ -1,15 +1,211 @@
 package domain;
 
+import java.util.ArrayList;
+
 public class Fuchs extends Spielfigur {
 	
 	public Fuchs() {
 		
 	}
 	
-	public boolean isValidMove(String zug, Spiel spiel) {
+	public boolean isValidMove(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel) {
-//	public static boolean isValidMove(String zug) {
+		
+		int schritteY = Math.abs(neueStartY - neueZielY);
+		int schritteX = Math.abs(neueStartX - neueZielX);
+		int anzahlSchritteZähler = 0;
+		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
+		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;
+		}
+		
+		// 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') {
+						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') {
+						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') {
+						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') {
+						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') {
+						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') {
+						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') {
+						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') {
+						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);
+		}
+	}
 }

src/domain/Hennen.java

@@ -7,43 +7,17 @@ public class Hennen extends Spielfigur {
 	}
 
 	// generell sehr fehleranfällig, mit Regex Filter Struktur vom String vorgeben
-	public boolean isValidMove(String zug, Spiel spiel) {
+	public boolean isValidMove(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel) {
-		char[][] spielbrettArray = new char[10][10];
-		spielbrettArray = spiel.getSpielbrettArray();
-		// Form vom Zug: "5,5 4,5"
-
-		// Zug wurde getätigt....
-		// Werte als Char
-
-		char startKoordinate1 = zug.charAt(0);
-		char startKoordinate2 = zug.charAt(2);
-		char zielKoordinate1 = zug.charAt(4);
-		char zielKoordinate2 = zug.charAt(6);
-
-		// Werte als int
-		int startKoord1 = Character.getNumericValue(startKoordinate1);
-		int startKoord2 = Character.getNumericValue(startKoordinate2);
-		int zielKoord1 = Character.getNumericValue(zielKoordinate1);
-		int zielKoord2 = Character.getNumericValue(zielKoordinate2);
-
-		int[] neueStartKoords = spiel.wandelPassendUm(startKoord1, startKoord2);
-		int[] neueZielKoords = spiel.wandelPassendUm(zielKoord1, zielKoord2);
-
-		// Werte angepasst auf unser Board, die Form des Zuges hat sich geändert von X,Y
-		// auf Y,X
-		int neueStartY = neueStartKoords[0];
-		int neueStartX = neueStartKoords[1];
-		int neueZielY = neueZielKoords[0];
-		int neueZielX = neueZielKoords[1];
 		
 		// Zug fehleingabe
-		if (neueStartKoords == null || neueZielKoords == null) {
+		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 (spielbrettArray[neueStartY][neueStartX] != 'X'
+		} else if (spiel.getSpielbrettArray()[neueStartY][neueStartX] != 'X'
-				|| spielbrettArray[neueZielY][neueZielX] != '\u25A1') {
+				|| spiel.getSpielbrettArray()[neueZielY][neueZielX] != '\u25A1') {
 			System.out.println("Symbole an stellen falsch");
 			return false;
 

src/domain/Spiel.java

@@ -53,8 +53,8 @@ public class Spiel {
 			spielbrettArray[2][1] = ' ';
 			spielbrettArray[2][2] = ' ';
 			spielbrettArray[2][3] = ' ';
-			spielbrettArray[2][4] = '\u25A1';
+			spielbrettArray[2][4] = 'X';
-			spielbrettArray[2][5] = '\u25A1';
+			spielbrettArray[2][5] = 'X';
 			spielbrettArray[2][6] = '\u25A1';
 			spielbrettArray[2][7] = ' ';
 			spielbrettArray[2][8] = ' ';
@@ -65,7 +65,7 @@ public class Spiel {
 			spielbrettArray[3][2] = '\u25A1';
 			spielbrettArray[3][3] = '\u25A1';
 			spielbrettArray[3][4] = '\u25A1';
-			spielbrettArray[3][5] = 'X';
+			spielbrettArray[3][5] = '\u25A1';
 			spielbrettArray[3][6] = '\u25A1';
 			spielbrettArray[3][7] = '\u25A1';
 			spielbrettArray[3][8] = '\u25A1';
@@ -90,7 +90,7 @@ public class Spiel {
 			spielbrettArray[5][5] = 'X';
 			spielbrettArray[5][6] = 'X';
 			spielbrettArray[5][7] = 'X';
-			spielbrettArray[5][8] = 'X';
+			spielbrettArray[5][8] = '\u25A1';
 			spielbrettArray[5][9] = 'X';
 
 			spielbrettArray[6][0] = '2';
@@ -108,7 +108,7 @@ public class Spiel {
 			spielbrettArray[7][1] = ' ';
 			spielbrettArray[7][2] = ' ';
 			spielbrettArray[7][3] = ' ';
-			spielbrettArray[7][4] = 'X';
+			spielbrettArray[7][4] = '\u25A1';
 			spielbrettArray[7][5] = 'X';
 			spielbrettArray[7][6] = 'X';
 			spielbrettArray[7][7] = ' ';
@@ -146,6 +146,14 @@ public class Spiel {
 		return spielbrettArray;
 	}
 	
+	public char getWertAusArray(int y, int x) {
+		return spielbrettArray[y][x];
+	}
+	
+	public void ändereWertImArray(int y, int x, char symbol) {
+		spielbrettArray[y][x] = symbol;
+	}
+	
 	public int[] wandelPassendUm(int umwandeln1, int umwandeln2) {
 		// Erlaubte Koordinaten sind:
 		// 3,0 / 4,0 / 5,0 - 3,1 / 4,1 / 5,1 - 3,2 / 4,2 / 5,2
@@ -580,7 +588,11 @@ public class Spiel {
 			return umgewandelt;
 		}
 		
-		return null;
+		//Fehlerwert ist 1000
+		int[] umgewandelt = new int[2];
+		umgewandelt[0] = 1000;
+		umgewandelt[1] = 1000;
+		return umgewandelt;
 
 	}
 

src/domain/Spielfigur.java

@@ -2,7 +2,7 @@ package domain;
 
 public abstract class Spielfigur {
 
-	public abstract boolean isValidMove(String zug, Spiel spiel);
+	public abstract boolean isValidMove(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel);
 //	public static boolean isValidMove(String zug) {
 //		return false;
 //	}

src/facade/Spielsystem.java

@@ -108,15 +108,47 @@ public class Spielsystem {
 		return true;
 	}
 	
-	// vorerst wird es ignoriert das static verlangt wird
 	public boolean isValidMove(String zug) {
+		int[] neueKoordinaten = berechneRichtigeKoordinaten(zug);
+		int neueStartY = neueKoordinaten[0];
+		int neueStartX = neueKoordinaten[1];
+		int neueZielY = neueKoordinaten[2];
+		int neueZielX = neueKoordinaten[3];
+		
 		if(aktiverSpieler == true) {
-			return spieler.isValidMove(zug, spiel);
+			return spieler.isValidMove(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
 		} else {
-			return computer.isValidMove(zug, spiel);
+			return computer.isValidMove(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
 		}
 	}
 	
+	public int[] berechneRichtigeKoordinaten(String zug) {
+		// Form vom Zug: "5,5 4,5"
+
+		// Zug wurde getätigt....
+		// Werte als Char
+
+		char startKoordinate1 = zug.charAt(0);
+		char startKoordinate2 = zug.charAt(2);
+		char zielKoordinate1 = zug.charAt(4);
+		char zielKoordinate2 = zug.charAt(6);
+
+		// Werte als int
+		int startKoord1 = Character.getNumericValue(startKoordinate1);
+		int startKoord2 = Character.getNumericValue(startKoordinate2);
+		int zielKoord1 = Character.getNumericValue(zielKoordinate1);
+		int zielKoord2 = Character.getNumericValue(zielKoordinate2);
+
+		int[] neueStartKoords = spiel.wandelPassendUm(startKoord1, startKoord2);
+		int[] neueZielKoords = spiel.wandelPassendUm(zielKoord1, zielKoord2);
+
+		// Werte angepasst auf unser Board, die Form des Zuges hat sich geändert von X,Y
+		// auf Y,X
+		int[] neueKoordinaten = {neueStartKoords[0], neueStartKoords[1], neueZielKoords[0], neueZielKoords[1]};
+		
+		return neueKoordinaten;
+	}
+	
 	public String yourMove() {
 		return ki.zugBestimmen();
 	}