Schweren Bot beendet, Upgrades könnte man noch einbauen. Vieles in der Spiel Klasse verändert.
parent
75bc558ff3
commit
96733d52b0
|
|
@ -16,6 +16,7 @@ public class BotEasyFuchs extends Bot {
|
|||
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()));
|
||||
|
||||
|
|
@ -28,10 +29,9 @@ public class BotEasyFuchs extends Bot {
|
|||
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') {
|
||||
|
||||
// noch zu ändern wenn der Fuchs auch diagonal nach Hennen Kill springen kann ----------------------------------------------
|
||||
|
||||
int neuY2 = neuY; int zähler1 = 0;
|
||||
do {
|
||||
if(zähler1 == 6) {
|
||||
|
|
@ -63,6 +63,8 @@ public class BotEasyFuchs extends Bot {
|
|||
|
||||
} while(fuchs.oberIsValidMove(zug, spiel) == false);
|
||||
|
||||
zug = altY + "," + altX + " " + neuY + "," + neuX;
|
||||
|
||||
return zug;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@ public class BotEasyHenne extends Bot {
|
|||
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()));
|
||||
|
||||
|
|
@ -36,6 +37,8 @@ public class BotEasyHenne extends Bot {
|
|||
|
||||
} while(henne.oberIsValidMove(zug, spiel) == false);
|
||||
|
||||
zug = altY + "," + altX + " " + neuY + "," + neuX;
|
||||
|
||||
return zug;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,32 +13,26 @@ public class BotHardFuchs extends Bot {
|
|||
char[][] spielbrettArray = spiel.getSpielbrettArray();
|
||||
char[][] kopieSpielbrett = Arrays.stream(spielbrettArray).map(char[]::clone).toArray(char[][]::new);
|
||||
|
||||
// ArrayList<String> alleZüge = new ArrayList<>();
|
||||
|
||||
// long start = System.currentTimeMillis();
|
||||
// alleZüge = spiel.alleZügeFuchs(kopieSpielbrett, spiel);
|
||||
// for (String züge : alleZüge) {
|
||||
// System.out.println(züge);
|
||||
// }
|
||||
// long end = System.currentTimeMillis();
|
||||
// System.out.println("--------------------------------------------------------");
|
||||
// System.out.println(end - start);
|
||||
// System.out.println("--------------------------------------------------------");
|
||||
|
||||
long start = System.currentTimeMillis();
|
||||
int bewertung = spiel.miniMax(kopieSpielbrett, null, 5, false, spiel);
|
||||
// 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(end - start);
|
||||
System.out.println("Benötigte Zeit für den Zug: " + (end - start));
|
||||
System.out.println("--------------------------------------------------------");
|
||||
|
||||
System.out.println();
|
||||
System.out.println(bewertung);
|
||||
System.out.println();
|
||||
System.out.println("HIER IST ENDE FÜR BOTHARDFUCHS! -----------------------------------------------------------------");
|
||||
System.out.println();
|
||||
// System.out.println(megaZug.bewertung);
|
||||
// System.out.println(megaZug.zug);
|
||||
System.out.println("Bester Zug: " + 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 "Ich bins der Harte Fuchs Bot";
|
||||
// return megaZug.zug;
|
||||
return spiel.getBesterZugBot();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,32 +13,26 @@ public class BotHardHenne extends Bot {
|
|||
char[][] spielbrettArray = spiel.getSpielbrettArray();
|
||||
char[][] kopieSpielbrett = Arrays.stream(spielbrettArray).map(char[]::clone).toArray(char[][]::new);
|
||||
|
||||
// ArrayList<String> alleZüge = new ArrayList<>();
|
||||
|
||||
// long start = System.currentTimeMillis();
|
||||
// alleZüge = spiel.alleZügeHennen(kopieSpielbrett, spiel);
|
||||
// for (String züge : alleZüge) {
|
||||
// System.out.println(züge);
|
||||
// }
|
||||
// long end = System.currentTimeMillis();
|
||||
// System.out.println("--------------------------------------------------------");
|
||||
// System.out.println(end - start);
|
||||
// System.out.println("--------------------------------------------------------");
|
||||
|
||||
long start = System.currentTimeMillis();
|
||||
int bewertung = spiel.miniMax(kopieSpielbrett, null, 5, true, spiel);
|
||||
// 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(end - start);
|
||||
System.out.println("Benötigte Zeit für den Zug: " + (end - start));
|
||||
System.out.println("--------------------------------------------------------");
|
||||
|
||||
System.out.println();
|
||||
System.out.println(bewertung);
|
||||
System.out.println();
|
||||
System.out.println("HIER IST ENDE FÜR BOTHARDHENNE! -----------------------------------------------------------------");
|
||||
System.out.println();
|
||||
// System.out.println(megaZug.bewertung);
|
||||
// System.out.println(megaZug.zug);
|
||||
System.out.println("Bester Zug: " + 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 "Ich bins der Harte Hennen Bot";
|
||||
// return megaZug.zug;
|
||||
return spiel.getBesterZugBot();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,11 +18,11 @@ public class Fuchs extends Spielfigur {
|
|||
String zwischenzug;
|
||||
boolean erfolgreicherZwischenzug;
|
||||
|
||||
System.out.println(anzahlZüge);
|
||||
// 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);
|
||||
// System.out.println(zwischenzug);
|
||||
int[] neueKoordinaten = spiel.berechneRichtigeKoordinaten(zwischenzug);
|
||||
int neueStartY = neueKoordinaten[0];
|
||||
int neueStartX = neueKoordinaten[1];
|
||||
|
|
@ -52,27 +52,27 @@ public class Fuchs extends Spielfigur {
|
|||
|
||||
// Zug fehleingabe
|
||||
if (neueStartY == 1000 || neueStartX == 1000 || neueZielY == 1000 || neueZielX == 1000) {
|
||||
System.out.println("Fehleingabe");
|
||||
System.out.println(neueStartY + " " + neueStartX +" "+neueZielY+" "+neueZielX);
|
||||
// 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));
|
||||
// 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));
|
||||
// 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!");
|
||||
// System.out.println("Einser Schritt erfolgreich!");
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -88,7 +88,7 @@ public class Fuchs extends Spielfigur {
|
|||
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");
|
||||
// System.out.println("Henne in Safe Zone = nicht killbar");
|
||||
return false;
|
||||
} else {
|
||||
zuTöteneHennen.add(i);
|
||||
|
|
@ -112,7 +112,7 @@ public class Fuchs extends Spielfigur {
|
|||
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");
|
||||
// System.out.println("Henne in Safe Zone = nicht killbar");
|
||||
return false;
|
||||
} else {
|
||||
zuTöteneHennen.add(i);
|
||||
|
|
@ -140,7 +140,7 @@ public class Fuchs extends Spielfigur {
|
|||
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");
|
||||
// System.out.println("Henne in Safe Zone = nicht killbar");
|
||||
return false;
|
||||
} else {
|
||||
zuTöteneHennen.add(neueZielY);
|
||||
|
|
@ -164,7 +164,7 @@ public class Fuchs extends Spielfigur {
|
|||
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");
|
||||
// System.out.println("Henne in Safe Zone = nicht killbar");
|
||||
return false;
|
||||
} else {
|
||||
zuTöteneHennen.add(neueZielY);
|
||||
|
|
@ -192,7 +192,7 @@ public class Fuchs extends Spielfigur {
|
|||
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");
|
||||
// System.out.println("Henne in Safe Zone = nicht killbar");
|
||||
return false;
|
||||
} else {
|
||||
zuTöteneHennen.add(y);
|
||||
|
|
@ -200,7 +200,7 @@ public class Fuchs extends Spielfigur {
|
|||
}
|
||||
// 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");
|
||||
// System.out.println("gerader Schritt war kein leeres Feld");
|
||||
|
||||
} else {
|
||||
return false;
|
||||
|
|
@ -217,7 +217,7 @@ public class Fuchs extends Spielfigur {
|
|||
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");
|
||||
// System.out.println("Henne in Safe Zone = nicht killbar");
|
||||
return false;
|
||||
} else {
|
||||
zuTöteneHennen.add(y);
|
||||
|
|
@ -241,7 +241,7 @@ public class Fuchs extends Spielfigur {
|
|||
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");
|
||||
// System.out.println("Henne in Safe Zone = nicht killbar");
|
||||
return false;
|
||||
} else {
|
||||
zuTöteneHennen.add(y);
|
||||
|
|
@ -265,7 +265,7 @@ public class Fuchs extends Spielfigur {
|
|||
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");
|
||||
// System.out.println("Henne in Safe Zone = nicht killbar");
|
||||
return false;
|
||||
} else {
|
||||
zuTöteneHennen.add(y);
|
||||
|
|
@ -290,7 +290,7 @@ public class Fuchs extends Spielfigur {
|
|||
|
||||
public void killHenne(ArrayList<Integer> zuTöteneHennen, Spiel spiel) {
|
||||
char symbol = '\u25A1';
|
||||
System.out.println(zuTöteneHennen);
|
||||
// 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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,59 +21,59 @@ public class Hennen extends Spielfigur {
|
|||
|
||||
// Zug fehleingabe
|
||||
if (neueStartY == 1000 || neueStartX == 1000 || neueZielY == 1000 || neueZielX == 1000) {
|
||||
System.out.println("Fehleingabe");
|
||||
System.out.println(neueStartY + " " + neueStartX + " " + neueZielY + " " + neueZielX);
|
||||
// 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");
|
||||
// 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");
|
||||
// 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");
|
||||
// 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");
|
||||
// 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");
|
||||
// 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");
|
||||
// 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");
|
||||
// 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");
|
||||
// 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");
|
||||
// System.out.println("darf nur ein feld nach vorne");
|
||||
return false;
|
||||
|
||||
}
|
||||
|
||||
System.out.println("Hennenmethode aufgerufen");
|
||||
// System.out.println("Hennenmethode aufgerufen");
|
||||
return true;
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,6 +5,8 @@ import java.util.Random;
|
|||
|
||||
public class Spiel {
|
||||
private String spielname;
|
||||
private String besterZugBot = null;
|
||||
private int gewünschteTiefe = 1;
|
||||
|
||||
// private char[][] spielbrettArray = new char[10][10];
|
||||
private char[][] spielbrettArray = new char[10][10];
|
||||
|
|
@ -18,6 +20,10 @@ public class Spiel {
|
|||
return spielname;
|
||||
}
|
||||
|
||||
String getBesterZugBot() {
|
||||
return besterZugBot;
|
||||
}
|
||||
|
||||
public void printBoard() {
|
||||
for (int i = 0; i < spielbrettArray.length; i++) {
|
||||
for (int j = 0; j < spielbrettArray[i].length; j++) {
|
||||
|
|
@ -170,9 +176,7 @@ public class Spiel {
|
|||
return spielbrettArray;
|
||||
}
|
||||
|
||||
|
||||
public char[][] getSpielbrettArray() {
|
||||
|
||||
return spielbrettArray;
|
||||
}
|
||||
|
||||
|
|
@ -187,30 +191,54 @@ public class Spiel {
|
|||
public String yourMove(Spiel spiel, Bot ki, Spielfigur computer) {
|
||||
String zug = ki.zugBestimmen(spiel, computer);
|
||||
|
||||
int[] neueKoordinaten = spiel.berechneRichtigeKoordinaten(zug);
|
||||
int neueStartY = neueKoordinaten[0];
|
||||
int neueStartX = neueKoordinaten[1];
|
||||
int neueZielY = neueKoordinaten[2];
|
||||
int neueZielX = neueKoordinaten[3];
|
||||
moveBotZug(spiel, zug, computer);
|
||||
|
||||
computer.moveSpielfigur(neueStartY, neueStartX, neueZielY, neueZielX, spiel);
|
||||
return botZugUmwandeln(zug);
|
||||
}
|
||||
|
||||
return zug;
|
||||
public void moveBotZug(Spiel spiel, String zug, Spielfigur computer) {
|
||||
// Spielbrett basierend auf getätigten Zug verändern
|
||||
if(computer instanceof Fuchs) {
|
||||
// wenn Fuchs eine Henne getötet hat geht es hier rein
|
||||
if(zug.length() != 7) {
|
||||
int anzahlZüge = zug.length() / 4;
|
||||
String zwischenzug;
|
||||
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), '\u25A1');
|
||||
|
||||
for(int zugZähler = 2, beginnChar = 4, endeChar = 12; zugZähler <= anzahlZüge; zugZähler += 2, beginnChar += 8, endeChar += 8) {
|
||||
zwischenzug = zug.substring(beginnChar, endeChar);
|
||||
|
||||
ändereWertImArray(Character.getNumericValue(zwischenzug.charAt(0)), Character.getNumericValue(zwischenzug.charAt(2)), '\u25A1');
|
||||
if(endeChar == zug.length()) {
|
||||
ändereWertImArray(Character.getNumericValue(zwischenzug.charAt(4)), Character.getNumericValue(zwischenzug.charAt(6)), 'O');
|
||||
}
|
||||
}
|
||||
// ansonsten hier
|
||||
} else {
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), '\u25A1');
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(4)), Character.getNumericValue(zug.charAt(6)), 'O');
|
||||
}
|
||||
// Zug von Henne
|
||||
} else {
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), '\u25A1');
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(4)), Character.getNumericValue(zug.charAt(6)), 'X');
|
||||
}
|
||||
}
|
||||
|
||||
// überprüfen wann und ob die Hennen gewonnen haben
|
||||
public boolean gewinnBedingungHennen() {
|
||||
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') {
|
||||
if (getWertAusArray(0, 4) == 'X' && getWertAusArray(0, 5) == 'X' && getWertAusArray(0, 6) == 'X'
|
||||
&& getWertAusArray(1, 4) == 'X' && getWertAusArray(1, 5) == 'X' && getWertAusArray(1, 6) == 'X'
|
||||
&& getWertAusArray(2, 4) == 'X' && getWertAusArray(2, 5) == 'X' && getWertAusArray(2, 6) == 'X') {
|
||||
return true;
|
||||
}
|
||||
int spielfigurExistiert = 0;
|
||||
|
||||
// wenn kein Fuchs mehr existiert, dann ist automatisch gewonnen
|
||||
for (int i = 0; i < spielbrettArray.length; i++) {
|
||||
for (int k = 0; k < spielbrettArray[i].length; k++) {
|
||||
if (spielbrettArray[i][k] == 'O') {
|
||||
for (int i = 0; i < spielbrettArray.length - 1; i++) {
|
||||
for (int k = 1; k < spielbrettArray[i].length; k++) {
|
||||
if (getWertAusArray(i, k) == 'O') {
|
||||
spielfigurExistiert++;
|
||||
}
|
||||
}
|
||||
|
|
@ -228,9 +256,9 @@ public class Spiel {
|
|||
public boolean gewinnBedingungFuchs() {
|
||||
int spielfigurExistiert = 0;
|
||||
|
||||
for (int i = 0; i < spielbrettArray.length; i++) {
|
||||
for (int k = 0; k < spielbrettArray[i].length; k++) {
|
||||
if (spielbrettArray[i][k] == 'X') {
|
||||
for (int i = 0; i < spielbrettArray.length - 1; i++) {
|
||||
for (int k = 1; k < spielbrettArray[i].length; k++) {
|
||||
if (getWertAusArray(i, k) == 'X') {
|
||||
spielfigurExistiert++;
|
||||
}
|
||||
}
|
||||
|
|
@ -247,10 +275,10 @@ public class Spiel {
|
|||
|
||||
// überprüfen wie viele Füchse momentan existieren, bei 2 ist Schluss, weil mehr können nicht gleichzeitig existieren
|
||||
if(spielfigur instanceof Fuchs) {
|
||||
for(int i = 0; i < spielbrettArray.length; i++ )
|
||||
for(int i = 0; i < spielbrettArray.length - 1; i++ )
|
||||
{
|
||||
for(int k = 0; k < spielbrettArray[i].length; k++ ){
|
||||
if(spielbrettArray[i][k] == 'O') {
|
||||
for(int k = 1; k < spielbrettArray[i].length; k++ ){
|
||||
if(getWertAusArray(i, k) == 'O') {
|
||||
spielfigurExistiert.add(i + "," + k);
|
||||
}
|
||||
}
|
||||
|
|
@ -263,10 +291,10 @@ public class Spiel {
|
|||
|
||||
// überprüfen wie viele Hennen momentan existieren, bei 27 ist Schluss, weil mehr können nicht gleichzeitig existieren
|
||||
if(spielfigur instanceof Hennen) {
|
||||
for(int i = 0; i < spielbrettArray.length; i++ )
|
||||
for(int i = 0; i < spielbrettArray.length - 1; i++ )
|
||||
{
|
||||
for(int k = 0; k < spielbrettArray[i].length; k++ ){
|
||||
if(spielbrettArray[i][k] == 'X') {
|
||||
for(int k = 1; k < spielbrettArray[i].length; k++ ){
|
||||
if(getWertAusArray(i, k) == 'X') {
|
||||
spielfigurExistiert.add(i + "," + k);
|
||||
}
|
||||
}
|
||||
|
|
@ -280,43 +308,84 @@ public class Spiel {
|
|||
}
|
||||
|
||||
// rekursiver Aufruf zum Vorhersagen und bewerten der möglichen Züge die der Computer und Mensch tätigen könnten
|
||||
public int miniMax(char[][] kopieSpielbrett, String zug, int tiefe, boolean maxPlayer, Spiel spiel) {
|
||||
int miniMax(char[][] kopieSpielbrett, String zug, int tiefe, int alpha, int beta, boolean maxPlayer, Spiel spiel) {
|
||||
Random rand = new Random();
|
||||
// megaZug megaZug = new megaZug(zug, 0);
|
||||
|
||||
// wenn Vorhersagungstiefe erreicht, dann aktuellen Zug bewerten
|
||||
if(tiefe == 0) {
|
||||
int bewertung = bewerteSpielzug(zug, maxPlayer);
|
||||
// System.out.println(bewertung);
|
||||
return bewertung;
|
||||
// megaZug.bewertung = bewerteSpielzug(zug, !maxPlayer);
|
||||
// return megaZug;
|
||||
return bewerteSpielzug(zug, !maxPlayer);
|
||||
}
|
||||
// wenn Henne dran ist, dann vorhersagen welche Züge die Henne tätigen könnte
|
||||
if(maxPlayer == true) {
|
||||
int maxWert = -9999;
|
||||
ArrayList<String> potenzielleZüge = getMoves(kopieSpielbrett, maxPlayer, spiel);
|
||||
// String besterZug = null;
|
||||
ArrayList<String> potenzielleZüge = getMoves(kopieSpielbrett, maxPlayer);
|
||||
|
||||
// mit einem bestimmten zufälligen Spielzug der Henne rekursiv vorhersagen wie optimal dieser ist
|
||||
do {
|
||||
if(potenzielleZüge.size() == 0) {
|
||||
System.out.println("Es existieren keine Hennen Züge mehr. Sehr sehr unwahrscheinlich");
|
||||
printBoard();
|
||||
break;
|
||||
}
|
||||
int index = rand.nextInt(potenzielleZüge.size());
|
||||
zug = potenzielleZüge.get(index);
|
||||
|
||||
// mit einem bestimmten Spielzug der Henne rekursiv vorhersagen wie optimal dieser ist
|
||||
for(int i = 0; i< potenzielleZüge.size(); i++) {
|
||||
zug = potenzielleZüge.get(i);
|
||||
// Henne verschieben simulieren
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), '\u25A1');
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(4)), Character.getNumericValue(zug.charAt(6)), 'X');
|
||||
|
||||
// megaZug = miniMax(kopieSpielbrett, zug, tiefe-1, alpha, beta, false, spiel);
|
||||
// if(megaZug.bewertung > alpha) {
|
||||
// alpha = megaZug.bewertung;
|
||||
// besterZug = zug;
|
||||
// if(tiefe == gewünschteTiefe) {
|
||||
// besterZugBot = zug;
|
||||
// }
|
||||
// }
|
||||
// megaZug.bewertung = alpha;
|
||||
// megaZug.zug = besterZug;
|
||||
|
||||
// rekursiv die Tiefe der Vorhersagung ändern
|
||||
int wert = miniMax(kopieSpielbrett, zug, tiefe-1, false, spiel);
|
||||
if(wert > maxWert) {
|
||||
maxWert = wert;
|
||||
int wert = miniMax(kopieSpielbrett, zug, tiefe-1, alpha, beta, false, spiel);
|
||||
|
||||
if(wert > alpha) {
|
||||
alpha = wert;
|
||||
if(tiefe == gewünschteTiefe) {
|
||||
besterZugBot = zug;
|
||||
}
|
||||
}
|
||||
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), 'X');
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(4)), Character.getNumericValue(zug.charAt(6)), '\u25A1');
|
||||
}
|
||||
return maxWert;
|
||||
|
||||
if(alpha >= beta) {
|
||||
// megaZug.bewertung = beta;
|
||||
// return megaZug;
|
||||
return beta;
|
||||
}
|
||||
potenzielleZüge.remove(index);
|
||||
} while(potenzielleZüge.size() > 0);
|
||||
|
||||
// return megaZug;
|
||||
return alpha;
|
||||
|
||||
// wenn Fuchs dran ist, dann vorhersagen welche Züge der Fuchs tätigen könnte
|
||||
} else {
|
||||
int minWert = 9999;
|
||||
ArrayList<String> potenzielleZüge = getMoves(kopieSpielbrett, maxPlayer, spiel);
|
||||
// String besterZug = null;
|
||||
ArrayList<String> potenzielleZüge = getMoves(kopieSpielbrett, maxPlayer);
|
||||
|
||||
// mit einem bestimmten Spielzug der Füchse rekursiv vorhersagen wie optimal dieser ist
|
||||
for(int i = 0; i< potenzielleZüge.size(); i++) {
|
||||
zug = potenzielleZüge.get(i);
|
||||
// mit einem bestimmten zufälligen Spielzug der Füchse rekursiv vorhersagen wie optimal dieser ist
|
||||
do {
|
||||
if(potenzielleZüge.size() == 0) {
|
||||
System.out.println("Es existieren keine Fuchs Züge mehr. Sehr sehr unwahrscheinlich");
|
||||
printBoard();
|
||||
break;
|
||||
}
|
||||
int index = rand.nextInt(potenzielleZüge.size());
|
||||
zug = potenzielleZüge.get(index);
|
||||
|
||||
// alle speziellen Züge werden gesondert aufgeteilt und verändern das Spielbrett gesondert
|
||||
if(zug.length() != 7) {
|
||||
|
|
@ -331,15 +400,30 @@ public class Spiel {
|
|||
zwischenzug = zug.substring(beginnChar, endeChar);
|
||||
|
||||
ändereWertImArray(Character.getNumericValue(zwischenzug.charAt(0)), Character.getNumericValue(zwischenzug.charAt(2)), '\u25A1');
|
||||
ändereWertImArray(Character.getNumericValue(zwischenzug.charAt(4)), Character.getNumericValue(zwischenzug.charAt(6)), 'O');
|
||||
if(endeChar == zug.length()) {
|
||||
ändereWertImArray(Character.getNumericValue(zwischenzug.charAt(4)), Character.getNumericValue(zwischenzug.charAt(6)), 'O');
|
||||
}
|
||||
}
|
||||
// megaZug = miniMax(kopieSpielbrett, zug, tiefe-1, alpha, beta, true, spiel);
|
||||
// if(megaZug.bewertung < beta) {
|
||||
// beta = megaZug.bewertung;
|
||||
// besterZug = zug;
|
||||
// if(tiefe == gewünschteTiefe) {
|
||||
// besterZugBot = zug;
|
||||
// }
|
||||
// }
|
||||
// megaZug.bewertung = beta;
|
||||
// megaZug.zug = besterZug;
|
||||
|
||||
// rekursiv die Tiefe der Vorhersagung ändern
|
||||
int wert = miniMax(kopieSpielbrett, zug, tiefe-1, true, spiel);
|
||||
if(wert > minWert) {
|
||||
minWert = wert;
|
||||
int wert = miniMax(kopieSpielbrett, zug, tiefe-1, alpha, beta, true, spiel);
|
||||
|
||||
if(wert < beta) {
|
||||
beta = wert;
|
||||
if(tiefe == gewünschteTiefe) {
|
||||
besterZugBot = zug;
|
||||
}
|
||||
}
|
||||
// der erste Wert im Zug wird sofort wieder rückgängig gemacht
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), 'O');
|
||||
|
||||
// Schleife um die Henne quasi wiederzubeleben und um den Fuchs wieder zurück zu verändern
|
||||
for(int zugZähler = 2, beginnChar = 4, endeChar = 12; zugZähler <= anzahlZüge; zugZähler += 2, beginnChar += 8, endeChar += 8) {
|
||||
|
|
@ -348,41 +432,262 @@ public class Spiel {
|
|||
ändereWertImArray(Character.getNumericValue(zwischenzug.charAt(0)), Character.getNumericValue(zwischenzug.charAt(2)), 'X');
|
||||
ändereWertImArray(Character.getNumericValue(zwischenzug.charAt(4)), Character.getNumericValue(zwischenzug.charAt(6)), '\u25A1');
|
||||
}
|
||||
// der erste Wert im Zug wird sofort wieder rückgängig gemacht
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), 'O');
|
||||
|
||||
if(beta <= alpha) {
|
||||
// megaZug.bewertung = alpha;
|
||||
// return megaZug;
|
||||
return alpha;
|
||||
}
|
||||
} else {
|
||||
// bei einem normalen Zug ohne eine Henne zu killen, wird das Spielbrett normal verändert
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), '\u25A1');
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(4)), Character.getNumericValue(zug.charAt(6)), 'O');
|
||||
|
||||
int wert = miniMax(kopieSpielbrett, zug, tiefe-1, true, spiel);
|
||||
if(wert > minWert) {
|
||||
minWert = wert;
|
||||
// megaZug = miniMax(kopieSpielbrett, zug, tiefe-1, alpha, beta, true, spiel);
|
||||
// if(megaZug.bewertung < beta) {
|
||||
// beta = megaZug.bewertung;
|
||||
// besterZug = zug;
|
||||
// if(tiefe == gewünschteTiefe) {
|
||||
// besterZugBot = zug;
|
||||
// }
|
||||
// }
|
||||
// megaZug.bewertung = beta;
|
||||
// megaZug.zug = besterZug;
|
||||
|
||||
// rekursiv die Tiefe der Vorhersagung ändern
|
||||
int wert = miniMax(kopieSpielbrett, zug, tiefe-1, alpha, beta, true, spiel);
|
||||
|
||||
if(wert < beta) {
|
||||
beta = wert;
|
||||
if(tiefe == gewünschteTiefe) {
|
||||
besterZugBot = zug;
|
||||
}
|
||||
}
|
||||
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(0)), Character.getNumericValue(zug.charAt(2)), 'O');
|
||||
ändereWertImArray(Character.getNumericValue(zug.charAt(4)), Character.getNumericValue(zug.charAt(6)), '\u25A1');
|
||||
|
||||
if(beta <= alpha) {
|
||||
// megaZug.bewertung = alpha;
|
||||
// return megaZug;
|
||||
return alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
return minWert;
|
||||
potenzielleZüge.remove(index);
|
||||
} while(potenzielleZüge.size() > 0);
|
||||
|
||||
// return megaZug;
|
||||
return beta;
|
||||
}
|
||||
}
|
||||
|
||||
// getätigten Spielzug bewerten
|
||||
public int bewerteSpielzug(String zug, boolean maxPlayer) {
|
||||
int bewertung = 5;
|
||||
int bewerteSpielzug(String zug, boolean maxPlayer) {
|
||||
int bewertung = 0;
|
||||
int altY, altX, neuY, neuX;
|
||||
|
||||
// prüfen ob der Zug von der Henne oder vom Fuchs stammt
|
||||
if(maxPlayer == true) {
|
||||
bewertung = 5;
|
||||
altY = Character.getNumericValue(zug.charAt(0));
|
||||
altX = Character.getNumericValue(zug.charAt(2));
|
||||
neuY = Character.getNumericValue(zug.charAt(4));
|
||||
neuX = Character.getNumericValue(zug.charAt(6));
|
||||
|
||||
// Henne nach oben gelaufen?
|
||||
if(neuY - altY == -1) {
|
||||
bewertung += 10;
|
||||
}
|
||||
// Henne in Safe Zone?
|
||||
if(henneInSafeZone(neuY, neuX) == true) {
|
||||
if(neuX - altX == -1 || neuX - altX == 1) {
|
||||
bewertung = -50;
|
||||
} else {
|
||||
bewertung += 10;
|
||||
}
|
||||
// Henne auf den 3 seitlichen Reihen
|
||||
} else {
|
||||
if(neuX <= 3 || neuX >= 7) {
|
||||
bewertung += -5;
|
||||
if(neuX <= 2 || neuX >= 8) {
|
||||
bewertung += -5;
|
||||
if(neuX <= 1 || neuX >= 9) {
|
||||
bewertung += -5;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Schleife zum prüfen für jede Stelle um Henne herum
|
||||
for(int y = neuY - 1; y < neuY + 2; y++) {
|
||||
if(y == -1) {
|
||||
y++;
|
||||
}
|
||||
if(y >= 9) {
|
||||
break;
|
||||
}
|
||||
for(int x = neuX - 1; x < neuX + 2; x++) {
|
||||
if(y == neuY && x == neuX || y == altY && x == altX || x == 0 || x >= 10) {
|
||||
if(x == 0) {
|
||||
x++;
|
||||
}
|
||||
if(y == neuY && x == neuX) {
|
||||
x++;
|
||||
}
|
||||
if(y == altY && x == altX) {
|
||||
x++;
|
||||
}
|
||||
if(y == neuY && x == neuX) {
|
||||
x++;
|
||||
}
|
||||
if(x >= 10 || x >= neuX + 2) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// kann eine Henne eine andere Henne vor dem Tod beschützen?
|
||||
if(getWertAusArray(y, x) == 'X') {
|
||||
if(y + (y - neuY) != -1 && y + (y - neuY) != 9 && x + (x - neuX) != 0 && x + (x - neuX) != 10 && x + (x - neuX) != 11) {
|
||||
if(getWertAusArray(y + (y - neuY), x + (x - neuX)) == 'O') {
|
||||
bewertung += 50;
|
||||
}
|
||||
}
|
||||
// kann der Fuchs diese Henne töten oder kann sie nicht übersprungen werden, weil dahinter schon etwas anderes steht?
|
||||
} else if(getWertAusArray(y, x) == 'O') {
|
||||
if(neuY + (neuY - y) != -1 && neuY + (neuY - y) != 9 && neuX + (neuX - x) != 0 && neuX + (neuX - x) != 10) {
|
||||
if(getWertAusArray(neuY + (neuY - y), neuX + (neuX - x)) == '\u25A1') {
|
||||
bewertung += -30;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// getätigten Spielzug auf Priorität überprüfen
|
||||
double [][] spielfeldBerwertungHenne = {{0, 0, 0, 0, 2.0, 2.0, 2.0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 2.0, 2.0, 2.0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 2.0, 2.0, 2.0, 0, 0, 0},
|
||||
{0, 1.2, 1.3, 1.4, 1.8, 1.9, 1.8, 1.4, 1.3, 1.2},
|
||||
{0, 1.1, 1.2, 1.3, 1.7, 1.8, 1.7, 1.3, 1.2, 1.1},
|
||||
{0, 1.0, 1.1, 1.2, 1.6, 1.7, 1.6, 1.2, 1.1, 1.0},
|
||||
{0, 0, 0, 0, 1.2, 1.3, 1.2, 0, 0, 0},
|
||||
{0, 0, 0, 0, 1.1, 1.2, 1.1, 0, 0, 0},
|
||||
{0, 0, 0, 0, 1.0, 1.1, 1.0, 0, 0, 0}};
|
||||
bewertung *= spielfeldBerwertungHenne[neuY][neuX];
|
||||
} else {
|
||||
if(zug.length() == 7) {
|
||||
altY = Character.getNumericValue(zug.charAt(0));
|
||||
altX = Character.getNumericValue(zug.charAt(2));
|
||||
neuY = Character.getNumericValue(zug.charAt(4));
|
||||
neuX = Character.getNumericValue(zug.charAt(6));
|
||||
} else {
|
||||
altY = Character.getNumericValue(zug.charAt(zug.length() - 12));
|
||||
altX = Character.getNumericValue(zug.charAt(zug.length() - 10));
|
||||
neuY = Character.getNumericValue(zug.charAt(zug.length() - 4));
|
||||
neuX = Character.getNumericValue(zug.charAt(zug.length() - 2));
|
||||
int hennen = (zug.length() - 4) / 8;
|
||||
// wie viele Hennen hat der Fuchs getötet?
|
||||
for(int i = 1; i <= hennen; i++) {
|
||||
bewertung += -500;
|
||||
}
|
||||
}
|
||||
// steht der Fuchs auf den obersten Feldern wo er keine Henne töten kann?
|
||||
if (neuY <= 1 && (neuX == 4 || neuX == 5 || neuX == 6)) {
|
||||
bewertung = 200;
|
||||
// steht der Fuchs auf den 3 äußeren Reihen?
|
||||
} else {
|
||||
if(neuX <= 3 || neuX >= 7) {
|
||||
bewertung += 5;
|
||||
if(neuX <= 2 || neuX >= 8) {
|
||||
bewertung += 5;
|
||||
if(neuX <= 1 || neuX >= 9) {
|
||||
bewertung += 5;
|
||||
}
|
||||
}
|
||||
}
|
||||
// steht der Fuchs ganz am äußeren Rand?
|
||||
if(neuY + (neuY - altY) == -1 || neuY + (neuY - altY) == 9 || neuX + (neuX - altX) == 0 || neuX + (neuX - altX) == 10) {
|
||||
bewertung += 30;
|
||||
}
|
||||
// Schleife zum prüfen für jede Stelle um Fuchs herum
|
||||
for(int y = neuY - 1; y < neuY + 2; y++) {
|
||||
if(y == -1) {
|
||||
y++;
|
||||
}
|
||||
if(y >= 9) {
|
||||
break;
|
||||
}
|
||||
for(int x = neuX - 1; x < neuX + 2; x++) {
|
||||
if(y == neuY && x == neuX || y == altY && x == altX || x == 0 || x >= 10) {
|
||||
if(x == 0) {
|
||||
x++;
|
||||
}
|
||||
if(y == neuY && x == neuX) {
|
||||
x++;
|
||||
}
|
||||
if(y == altY && x == altX) {
|
||||
x++;
|
||||
}
|
||||
if(y == neuY && x == neuX) {
|
||||
x++;
|
||||
}
|
||||
if(x >= 10 || x >= neuX + 2) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// um Fuchs leeres Feld oder Wand?
|
||||
if(getWertAusArray(y, x) == '\u25A1') {
|
||||
bewertung += 5;
|
||||
} else if(getWertAusArray(y, x) == ' ') {
|
||||
bewertung += 30;
|
||||
// kann Fuchs eine andere Henne überspringen?
|
||||
} else if(getWertAusArray(y, x) == 'X') {
|
||||
if(zug.length() == 7) {
|
||||
if(y + (y - neuY) != -1 && y + (y - neuY) != 9 && x + (x - neuX) != 0 && x + (x - neuX) != 10 && x + (x - neuX) != 11) {
|
||||
if(getWertAusArray(y + (y - neuY), x + (x - neuX)) == '\u25A1') {
|
||||
bewertung += -20;
|
||||
}
|
||||
}
|
||||
}
|
||||
bewertung += -5;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// getätigten Spielzug auf Priorität überprüfen
|
||||
double [][] spielfeldBerwertungFuchs = {{0, 0, 0, 0, 0.05, 0.05, 0.05, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0.1, 0.1, 0.1, 0, 0, 0},
|
||||
{0, 0, 0, 0, 1.35, 1.4, 1.35, 0, 0, 0},
|
||||
{0, 0.6, 0.8, 1.3, 1.85, 1.9, 1.85, 1.3, 0.8, 0.6},
|
||||
{0, 0.7, 1.0, 1.5, 1.9, 2.0, 1.9, 1.5, 1.0, 0.7},
|
||||
{0, 0.6, 0.8, 1.3, 1.8, 1.9, 1.8, 1.3, 0.8, 0.6},
|
||||
{0, 0, 0, 0, 0.8, 1.0, 0.8, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0.65, 0.7, 0.65, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0.5, 0.6, 0.5, 0, 0, 0}};
|
||||
// wenn Bewertung postiv, dann Prioritäten umkehren
|
||||
if(bewertung >= 0) {
|
||||
if(spielfeldBerwertungFuchs[neuY][neuX] < 1.0) {
|
||||
bewertung *= (2 - spielfeldBerwertungFuchs[neuY][neuX]);
|
||||
} else {
|
||||
bewertung *= (2.1 - spielfeldBerwertungFuchs[neuY][neuX]);
|
||||
}
|
||||
} else {
|
||||
bewertung *= spielfeldBerwertungFuchs[neuY][neuX];
|
||||
}
|
||||
}
|
||||
return bewertung;
|
||||
}
|
||||
|
||||
// Liste mit allen möglichen Zügen der Spielfigur erstellen
|
||||
public ArrayList<String> getMoves(char[][] kopieSpielbrett, boolean maxPlayer, Spiel spiel) {
|
||||
ArrayList<String> getMoves(char[][] kopieSpielbrett, boolean maxPlayer) {
|
||||
if(maxPlayer == true) {
|
||||
return alleZügeHennen(kopieSpielbrett, spiel);
|
||||
return alleZügeHennen(kopieSpielbrett);
|
||||
} else {
|
||||
return alleZügeFuchs(kopieSpielbrett, spiel);
|
||||
return alleZügeFuchs(kopieSpielbrett);
|
||||
}
|
||||
}
|
||||
|
||||
// packt alle möglichen Hennen Züge in eine ArrayList und übergibt sie getMoves
|
||||
public ArrayList<String> alleZügeHennen(char[][] kopieSpielbrett, Spiel spiel) {
|
||||
ArrayList<String> alleZügeHennen(char[][] kopieSpielbrett) {
|
||||
ArrayList<String> alleZüge = new ArrayList<>();
|
||||
ArrayList<String> spielfigurExistiert = new ArrayList<>();
|
||||
Spielfigur henne = new Hennen();
|
||||
|
|
@ -391,7 +696,13 @@ public class Spiel {
|
|||
|
||||
spielfigurExistiert = spielfigurExistiert(henne);
|
||||
|
||||
// solange die Schleife durchlaufen bis die Liste leer ist
|
||||
do {
|
||||
if(spielfigurExistiert.size() == 0) {
|
||||
System.out.println("Es existieren keine Hennen mehr. Sehr sehr unwahrscheinlich");
|
||||
printBoard();
|
||||
break;
|
||||
}
|
||||
int index = rand.nextInt(spielfigurExistiert.size());
|
||||
String random = spielfigurExistiert.get(index);
|
||||
|
||||
|
|
@ -401,11 +712,11 @@ public class Spiel {
|
|||
int neuY = altY;
|
||||
// links und rechts von der Henne frei?
|
||||
for(int x = altX - 1; x < altX + 2; x += 2) {
|
||||
if(x == 0 || x == 10) {
|
||||
if(x == 0 || x >= 10) {
|
||||
if(x == 0) {
|
||||
x += 2;
|
||||
}
|
||||
if(x == 10) {
|
||||
if(x >= 10) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -429,7 +740,7 @@ public class Spiel {
|
|||
}
|
||||
|
||||
// packt alle möglichen Fuchs Züge in eine ArrayList und übergibt sie getMoves
|
||||
public ArrayList<String> alleZügeFuchs(char[][] kopieSpielbrett, Spiel spiel) {
|
||||
ArrayList<String> alleZügeFuchs(char[][] kopieSpielbrett) {
|
||||
ArrayList<String> alleZüge = new ArrayList<>();
|
||||
ArrayList<String> spielfigurExistiert = new ArrayList<>();
|
||||
Spielfigur fuchs = new Fuchs();
|
||||
|
|
@ -437,7 +748,13 @@ public class Spiel {
|
|||
|
||||
spielfigurExistiert = spielfigurExistiert(fuchs);
|
||||
|
||||
// solange die Schleife durchlaufen bis die Liste leer ist
|
||||
do {
|
||||
if(spielfigurExistiert.size() == 0) {
|
||||
System.out.println("Es existieren keine Füchse mehr. Kann nicht passieren");
|
||||
printBoard();
|
||||
break;
|
||||
}
|
||||
int index = rand.nextInt(spielfigurExistiert.size());
|
||||
String random = spielfigurExistiert.get(index);
|
||||
|
||||
|
|
@ -451,7 +768,7 @@ public class Spiel {
|
|||
|
||||
// es wird rekursiv überprüft welche Züge ein bestimmter Fuchs gehen kann
|
||||
// rekursiv ist es nur damit der zurückgegebene String eine bestimmte Schreibweise hat
|
||||
public void rekursivFuchsZug(char[][] kopieSpielbrett, String startKoordinate, String zgeKoordinaten, ArrayList<String> alleZüge) {
|
||||
void rekursivFuchsZug(char[][] kopieSpielbrett, String startKoordinate, String zgeKoordinaten, ArrayList<String> alleZüge) {
|
||||
String zug = null;
|
||||
String neueStartkoordinate;
|
||||
|
||||
|
|
@ -460,31 +777,33 @@ public class Spiel {
|
|||
|
||||
// über und unter dem Fuchs überprüfen
|
||||
for(int y = altY - 1; y < altY + 2; y++) {
|
||||
if(y == -1 || y == 9) {
|
||||
if(y == -1 || y >= 9) {
|
||||
if(y == -1) {
|
||||
y++;
|
||||
}
|
||||
if(y == 9) {
|
||||
if(y >= 9) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// seitlich vom Fuchs überprüfen
|
||||
for(int x = altX - 1; x < altX + 2; x++) {
|
||||
if(y == altY && x == altX || x == 0 || x == 10) {
|
||||
if(y == altY && x == altX || x == 0 || x >= 10) {
|
||||
if(y == altY && x == altX) {
|
||||
x++;
|
||||
}
|
||||
if(x == 0) {
|
||||
x++;
|
||||
}
|
||||
if(x == 10) {
|
||||
if(x >= 10) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// wenn Feld leer, dann vermerken
|
||||
if(getWertAusArray(y, x) == '\u25A1') {
|
||||
zug = altY + "," + altX + " " + y + "," + x;
|
||||
alleZüge.add(zug);
|
||||
if(zgeKoordinaten == null) {
|
||||
zug = altY + "," + altX + " " + y + "," + x;
|
||||
alleZüge.add(zug);
|
||||
}
|
||||
}
|
||||
// wenn eine Henne zu killen ist und sich diese auf einem validen Feld befindet, dann rekursiv vermerken
|
||||
if(getWertAusArray(y, x) == 'X' && y - 1 != -1 && y + 1 != 9 && x - 1 != 0 && x + 1 != 10 && henneInSafeZone(y, x) == false) {
|
||||
|
|
@ -511,7 +830,7 @@ public class Spiel {
|
|||
ändereWertImArray(altY, altX, 'O'); ändereWertImArray(y, x, 'X'); ändereWertImArray((y + 1), (x + 1), '\u25A1');
|
||||
}
|
||||
} else {
|
||||
if(getWertAusArray(y - 1, x - 1) == '\u25A1') {
|
||||
if(getWertAusArray(y - 1, x + 1) == '\u25A1') {
|
||||
if(zgeKoordinaten == null) {
|
||||
zug = altY + "," + altX + " " + y + "," + x + " " + (y - 1) + "," + (x + 1) + " ";
|
||||
alleZüge.add(zug);
|
||||
|
|
@ -528,7 +847,7 @@ public class Spiel {
|
|||
}
|
||||
} else {
|
||||
if(y - altY == 1) {
|
||||
if(getWertAusArray(y + 1, x + 1) == '\u25A1') {
|
||||
if(getWertAusArray(y + 1, x - 1) == '\u25A1') {
|
||||
if(zgeKoordinaten == null) {
|
||||
zug = altY + "," + altX + " " + y + "," + x + " " + (y + 1) + "," + (x - 1) + " ";
|
||||
alleZüge.add(zug);
|
||||
|
|
@ -636,6 +955,29 @@ public class Spiel {
|
|||
return false;
|
||||
}
|
||||
|
||||
// wandelt explizit für den Bot den Zug um
|
||||
public String botZugUmwandeln(String zug) {
|
||||
String neuerZug;
|
||||
|
||||
// umwandeln für die besonderen Fuchs Züge
|
||||
if(zug.length() != 7) {
|
||||
int anzahlZüge = zug.length() / 4;
|
||||
String zwischenzug;
|
||||
|
||||
neuerZug = (Character.getNumericValue(zug.charAt(2)) - 1) + "," + (8 - Character.getNumericValue(zug.charAt(0)));
|
||||
|
||||
for(int zugZähler = 2, beginnChar = 3, endeChar = 7; zugZähler <= anzahlZüge; zugZähler += 1, beginnChar += 4, endeChar += 4) {
|
||||
zwischenzug = zug.substring(beginnChar, endeChar);
|
||||
|
||||
neuerZug = neuerZug + " " + (Character.getNumericValue(zwischenzug.charAt(3)) - 1) + "," + (8 - Character.getNumericValue(zwischenzug.charAt(1)));
|
||||
}
|
||||
// normales umwandeln
|
||||
} else {
|
||||
neuerZug = (Character.getNumericValue(zug.charAt(2)) - 1) + "," + (8 - Character.getNumericValue(zug.charAt(0))) + " " +
|
||||
(Character.getNumericValue(zug.charAt(6)) - 1) + "," + (8 - Character.getNumericValue(zug.charAt(4)));
|
||||
}
|
||||
return neuerZug;
|
||||
}
|
||||
// wandelt Koordinaten von Array Schreibweise in menschliche Schreibweise um
|
||||
public int[] wandelUmgekehrtUm(int umwandeln1, int umwandeln2, int umwandeln3, int umwandeln4) {
|
||||
int[] umgewandelt = new int[4];
|
||||
|
|
@ -656,3 +998,14 @@ public class Spiel {
|
|||
return umgewandelt;
|
||||
}
|
||||
}
|
||||
|
||||
// für wenn man die miniMax Fuktion mit einem Objekt statt int verwenden würde
|
||||
// class megaZug {
|
||||
// String zug;
|
||||
// int bewertung;
|
||||
|
||||
// public megaZug(String zug, int bewertung) {
|
||||
// this.zug = zug;
|
||||
// this.bewertung = bewertung;
|
||||
// }
|
||||
// }
|
||||
Loading…
Reference in New Issue