2210880
/
Hennen-und-Fuechse
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: 2210880:main
Branches Tags
2210880:main
2210880:nico
2210880:robin
2210880:kaisellmann
2210880:cedric
..
compare: 2210880:kaisellmann
Branches Tags
2210880:main
2210880:nico
2210880:robin
2210880:kaisellmann
2210880:cedric

No commits in common. "main" and "kaisellmann" have entirely different histories.
main ... kaisellman

24 changed files with 368 additions and 2442 deletions
Show Stats Expand all files Collapse all files

BIN
.DS_Store vendored
View File

Binary file not shown.

11
.project
View File

@ -14,15 +14,4 @@
<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>

6
src/.classpath 100644
View File

@ -0,0 +1,6 @@
<?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>

17
src/.project 100644
View File

@ -0,0 +1,17 @@
<?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>

6
src/domain/.gitignore vendored 100644
View File

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

2
src/domain/Bot.java
View File

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

66
src/domain/BotEasyFuchs.java
View File

@ -1,70 +1,16 @@
package domain;
import java.util.ArrayList;
import java.util.Random;
public class BotEasyFuchs extends Bot {
public BotEasyFuchs() {
}
@Override
public String zugBestimmen(Spiel spiel, Spielfigur fuchs) {
String zug;
char[][] spielbrettArray = spiel.getSpielbrettArray();
ArrayList<String> spielfigurExistiert = new ArrayList<>();
public String zugBestimmen() {
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;
return "Ich bins der Einfache Fuchs Bot";
}
} 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;
}
}

42
src/domain/BotEasyHenne.java
View File

@ -1,44 +1,14 @@
package domain;
import java.util.ArrayList;
import java.util.Random;
public class BotEasyHenne extends Bot {
public BotEasyHenne() {
}
@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;
public String zugBestimmen() {
return "Ich bins der Einfache Hennen Bot";
}
} 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;
}
}

28
src/domain/BotHardFuchs.java
View File

@ -1,7 +1,5 @@
package domain;
import java.util.Arrays;
public class BotHardFuchs extends Bot {
public BotHardFuchs() {
@ -9,30 +7,8 @@ public class BotHardFuchs extends Bot {
}
@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();
public String zugBestimmen() {
return "Ich bins der Harte Fuchs Bot";
}
}

28
src/domain/BotHardHenne.java
View File

@ -1,7 +1,5 @@
package domain;
import java.util.Arrays;
public class BotHardHenne extends Bot {
public BotHardHenne() {
@ -9,30 +7,8 @@ public class BotHardHenne extends Bot {
}
@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();
public String zugBestimmen() {
return "Ich bins der Harte Hennen Bot";
}
}

2
src/domain/BotMediumFuchs.java
View File

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

2
src/domain/BotMediumHenne.java
View File

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

17
src/domain/Computer.java
View File

@ -1,17 +0,0 @@
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
}
}

357
src/domain/Fuchs.java
View File

@ -1,368 +1,13 @@
package domain;
import java.util.ArrayList;
public class Fuchs extends Spielfigur {
public Fuchs() {
}
public void moveSpielfigur(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel) {
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;
}
}
public boolean isValidMove(String zug) {
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');
}
}
}
}

129
src/domain/Hennen.java
View File

@ -6,133 +6,8 @@ public class Hennen extends Spielfigur {
}
public void moveSpielfigur(int neueStartY, int neueStartX, int neueZielY, int neueZielX, Spiel spiel) {
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;
}
public boolean isValidMove(String zug) {
System.out.println("Hennenmethode aufgerufen");
return false;
}
}

1108
src/domain/Spiel.java
View File

File diff suppressed because it is too large Load Diff

9
src/domain/Spielfigur.java
View File

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

1
src/facade/.gitignore vendored 100644
View File

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

358
src/facade/Spielsystem.java
View File

@ -7,21 +7,17 @@ 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;
private Spielfigur henne;
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.spiel = new Spiel(spielname);
@ -29,82 +25,8 @@ public class Spielsystem {
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 spiel.getSpielname();
}
public boolean getSpielfigurComputer() {
if (computer instanceof Hennen) {
return true;
} else {
return false;
}
}
public boolean getSpielfigurSpieler() {
if (spieler instanceof Hennen) {
return true;
} else {
return false;
}
return spielname;
}
public Spielfigur getHenne() {
@ -123,297 +45,51 @@ public class Spielsystem {
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");
// true = Spieler1 | false = Spieler2
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 boolean isValidMove(String zug) {
// return this.isValidMove(zug);
// }
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();
}
}
return "H";
}
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) {
// public void moveSpielfigur(String zug) {
//
// }
if (kiLevel == 0 && computer instanceof Hennen) {
public void kiGenerieren(int spielerwahl, int kiLevel) {
if (kiLevel == 0 && spielerwahl == 1) {
ki = new BotEasyHenne();
} else if (kiLevel == 1 && computer instanceof Hennen) {
} else if ( kiLevel == 1 && spielerwahl == 1) {
ki = new BotMediumHenne();
} else if (kiLevel == 2 && computer instanceof Hennen) {
} else if (kiLevel == 2 && spielerwahl == 1) {
ki = new BotHardHenne();
} else if (kiLevel == 0 && computer instanceof Fuchs) {
} else if (kiLevel == 0 && spielerwahl == 2) {
ki = new BotEasyFuchs();
} else if (kiLevel == 1 && computer instanceof Fuchs) {
} else if ( kiLevel == 1 && spielerwahl == 2) {
ki = new BotMediumFuchs();
} else if (kiLevel == 2 && computer instanceof Fuchs) {
} else if (kiLevel == 2 && spielerwahl == 2) {
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++;
}
}
}

1
src/infrastructure/.gitignore vendored 100644
View File

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

8
src/infrastructure/Persistenz.java
View File

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

1
src/main/.gitignore vendored 100644
View File

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

1
src/ui/.gitignore vendored 100644
View File

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

344
src/ui/UI.java
View File

@ -4,6 +4,7 @@ import java.util.Scanner;
import facade.Spielsystem;
public class UI {
private Spielsystem spielsystem;
Scanner sc = new Scanner(System.in);
@ -16,7 +17,8 @@ public class UI {
private void hauptmenü() {
System.out.println("Willkommen beim Spiel des Jahres: " + spielsystem.getSpielname() + "!");
mainloop: while (true) {
mainloop:
while (true) {
System.out.println();
System.out.println("--------");
System.out.println("Hauptmenü:");
@ -38,19 +40,12 @@ public class UI {
try {
switch(input) {
case 1:
gameloop();
break;
case 1: gameloop(); break;
//case 2: spielstandLaden(); break;
case 2:
regelnAnzeigen();
break;
case 2: regelnAnzeigen(); break;
//case 7: highscoreAnzeigen(); break;
case 8:
creditsAnzeigen();
break;
case 9:
break mainloop;
case 8: creditsAnzeigen(); break;
case 9: break mainloop;
}
} catch (Exception e) {
System.err.println(e.getLocalizedMessage());
@ -59,10 +54,12 @@ public class UI {
System.out.println("Auf Wiedersehen!");
}
// hauptmenü
// case 1:
private void gameloop() {
gameloop: while (true) {
gameloop:
while(true) {
System.out.println();
System.out.println("--------");
System.out.println("Spielmenü:");
@ -83,14 +80,9 @@ public class UI {
try {
switch(input) {
case 1:
pVP();
break;
case 2:
pVE();
break;
case 9:
break gameloop;
case 1: pVP(); break;
case 2: pVE(); break;
case 9: break gameloop;
}
} catch(Exception e) {
System.err.println(e.getLocalizedMessage());
@ -108,37 +100,12 @@ public class UI {
}
// gameloop
// case 1:
private void pVP() {
System.out.println("Spieler 1, wollen Sie als 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 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);
}
@ -152,9 +119,6 @@ public class UI {
int spielerwahl = Integer.parseInt(sc.nextLine());
System.out.println();
spielsystem.spielerBestimmen(spielerwahl);
spielsystem.computerBestimmen(spielerwahl);
boolean werBeginnt = werBeginnt();
System.out.println("Auf welchen Schwierigkeitsgrad wollen Sie spielen?");
@ -166,19 +130,14 @@ public class UI {
int kiLevel = Integer.parseInt(sc.nextLine());
System.out.println();
spielsystem.start(werBeginnt, kiLevel);
start(werBeginnt, kiLevel);
start(werBeginnt, spielerwahl, kiLevel);
}
public void start2Spieler(boolean werBeginnt, int spieler1Wahl, int spieler2Wahl) {
int counter = 0;
private void start(boolean werBeginnt, int spielerwahl, int kiLevel) {
boolean zugFuchs = false;
boolean zugHenne = false;
boolean erfolgreicherZug;
boolean erfolgreich;
boolean freiesFeld;
boolean erfolgreichGepusht;
String zugPushHenne = "";
String zug;
if (werBeginnt == true) {
@ -187,158 +146,7 @@ public class UI {
zugFuchs = true;
}
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;
}
} 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;
}
spielsystem.kiGenerieren(spielerwahl, kiLevel);
System.out.println("Das Spiel wurde gestartet!");
if (kiLevel == 0) {
@ -353,26 +161,25 @@ public class UI {
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);
if (zugHenne == true && spielerwahl == 1) {
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);
zug = spielsystem.getBot().zugBestimmen();
//System.out.println(zug);
//Kontrolle des Zuges sollte im Bot gemacht werden
//erfolgreicherZug = spielsystem.getHenne().isValidMove(zug);
spielsystem.getHenne().moveSpielfigur(zug);
zugHenne = false;
zugFuchs = true;
}
// Zug Henne Spieler
else if (zugHenne == true && spielfigurSpieler == true) {
spielsystem.setAktivenSpieler(true);
else if (zugHenne == true && spielerwahl == 2) {
System.out.println("Die Hennen sind am Zug:");
System.out.println("Spieler Sie sind dran");
do {
@ -381,7 +188,7 @@ public class UI {
System.out.print("> ");
zug = sc.nextLine();
System.out.println();
erfolgreicherZug = spielsystem.isValidMove(zug);
erfolgreicherZug = spielsystem.getHenne().isValidMove(zug);
if (erfolgreicherZug == false) {
System.out.println("Ihre Zugeingabe: -" + zug + "- war leider kein valider Zug!");
@ -390,29 +197,14 @@ public class UI {
}
} while (erfolgreicherZug == false);
spielsystem.myMove(zug);
spielsystem.getHenne().moveSpielfigur(zug);
zugHenne = false;
zugFuchs = true;
}
// Zug Fuchs Spieler
else if (zugFuchs == true && spielfigurSpieler == false) {
spielsystem.setAktivenSpieler(true);
else if (zugFuchs == true && spielerwahl == 1) {
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:");
@ -420,7 +212,7 @@ public class UI {
System.out.print("> ");
zug = sc.nextLine();
System.out.println();
erfolgreicherZug = spielsystem.isValidMove(zug);
erfolgreicherZug = spielsystem.getFuchs().isValidMove(zug);
if (erfolgreicherZug == false) {
System.out.println("Ihre Zugeingabe: -" + zug + "- war leider kein valider Zug!");
@ -429,90 +221,34 @@ public class UI {
}
} while (erfolgreicherZug == false);
spielsystem.myMove(zug);
spielsystem.getFuchs().moveSpielfigur(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;
}
} 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);
else if (zugFuchs == true && spielerwahl == 2) {
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);
zug = spielsystem.getBot().zugBestimmen();
//System.out.println(zug);
//Kontrolle des Zuges sollte im Bot gemacht werden
//erfolgreicherZug = spielsystem.getFuchs().isValidMove(zug);
spielsystem.getFuchs().moveSpielfigur(zug);
zugHenne = true;
zugFuchs = false;
if (spielsystem.fuchsUmzingelt() == true) {
spielsystem.killFuchs();
}
}
//nach jedem Zug das Spielbrett ausgeben
spielsystem.printBoard();
} while (spielsystem.isRunning() == true);
} while (spielsystem.isWon() == false);
}
private boolean werBeginnt() {
System.out.println("Sollen die Füchse oder Hennen beginnen?");
System.out.println("1 -> Füchse beginnen");
@ -523,11 +259,9 @@ public class UI {
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;
}