static boolean
rundenAuswertung() { // wertet die Runde aus und gibt zurück, ob der Spieler weiterspielen
// will
boolean error = true;
String eingabe;
int eingabeID = 0;
System.out.println("Die Runde ist vorbei, hier die Auswertung:");
spieler1.punkte += spieler2.punke();
spieler2.punkte += spieler1.punke();
System.out.println("Spieler1 hat " + spieler1.punkte + " Punkte!");
System.out.println("Spieler2 hat " + spieler2.punkte + " Punkte!");
System.out.println(
"Sind du und deine Mitspielerin nach einer demokratischen Enscheidung zu einer Entscheidung über den weiteren Verlauf des Spiels gekommen?\nBitte teile dem Spiel nun eure Entscheidung mit!");
do {
System.out.println(
"Um weiter zu spielen: [0]. Um abzubrechen: [1]\n Bitte nun die Auswahl eingeben!");
eingabe = scanner.nextLine();
if (eingabe.matches("^[0]|^[1]")) {
eingabeID = Integer.parseInt(eingabe);
error = false;
} else {
error = true;
}
} while (error);
runde = 0;
switch (eingabeID) {
case 0:
return true; // weiterspielen
case 1:
return false; // spiel abbrechen
default:
return false; // fehler ^^
}
}
public static void main(String[] args) {
boolean weiterSpielen = true;
while (weiterSpielen) {
if (runde == 0 && spiel == 0) {
intro();
}
if (runde == 0) {
startStapel();
stapel.zieheErsteKarte();
scrollTerminal();
}
if (runde % 2 == 0) { // entscheidet ob Spielerin1 oder Spielerin2 an der reihe ist
spieler1.Zug();
} else {
spieler2.Zug();
}
System.out.println("");
System.out.println("Setze fort in 3 sek");
warten(3000);
scrollTerminal();
warten(500);
runde++;
if (spieler1.karten.length() == 0) {
System.out.println("Spielerin 1 hat gewonnen!");
weiterSpielen = rundenAuswertung();
spiel++;
} else if (spieler2.karten.length() == 0) {
System.out.println("Spielerin 2 hat gewonnen!");
weiterSpielen = rundenAuswertung();
spiel++;
}
}
}
/**
* Verarbeitet den Klick auf den Button "Aufgeben" aus der GUI, wobei dabei der Spieler, welcher
* aufgeben geklickt hat, noch ermittelt werden muss. Da der Spieler, welcher aufgeben geklickt
* hat, auf jedenfall verloren hat. Wird das Ergebnis des Spiels sofort in die Statistik
* eingetragen.
*/
@SuppressWarnings("static-access")
public void aufgegebenGeklickt() {
try {
this.lnkStatistik = lnkStatistik.gibStatistik();
} catch (StatistikException e) {
lnkGUI.zeigeFehlerAn(
"Die Statistikdatei ist fehlerhaft, Ihre Statistik wurde zurückgesetzt.");
}
Spieler spieler1, spieler2;
spieler1 = lnkSpielstand.gibSpieler1();
spieler2 = lnkSpielstand.gibSpieler2();
if (spieler1.equals(lnkSpielstand.gibAktuellenSpieler())) {
lnkStatistik.aktualisiereEintrag(
spieler2, Spielausgang.sieg, this.gibStatistikunterteilung());
lnkStatistik.aktualisiereEintrag(
spieler1, Spielausgang.aufgegeben, this.gibStatistikunterteilung());
this.lnkSpielstand.setzeSpielAusgang(Zustand.weiss);
} else {
lnkStatistik.aktualisiereEintrag(
spieler1, Spielausgang.sieg, this.gibStatistikunterteilung());
lnkStatistik.aktualisiereEintrag(
spieler2, Spielausgang.aufgegeben, this.gibStatistikunterteilung());
this.lnkSpielstand.setzeSpielAusgang(Zustand.schwarz);
}
lnkSpiel.setzeEnde(true);
lnkGUI.actionPerformed(new java.awt.event.ActionEvent(this, 0, "Spiel_MenueEnde"));
}
/**
* Methode, die vom Spielstand aufgerufen wird, wenn ein Zug durchgeführt wurde. Es wird
* überprüft, ob im Spiel das Attribut „zuEnde“ gesetzt ist; in dem Fall wird spielEnde() zum
* Ermitteln des Gewinners durchgeführt. Falls nicht, wird die GUI über den Spielerwechsel
* informiert, um den nächsten Spieler zum Zug aufzufordern. Sonst wird das Spielende eingeleitet.
* Zusätzlich wird ein boolean-Wert übergeben, der angibt, ob der Spieler an der Reihe die KI ist,
* damit die GUI ggf. Buttons sperren kann. Falls der Spieler keine KI ist, ist die Methode hier
* beendet. In dem Fall, dass der aktuelle Spieler KI ist und zuletzt kein Redo durchgeführt wurde
* (Redo-Flag auf false), wird die Zug-Methode der KI ausgeführt, die einen Spielzug zurückgibt.
* Dieser Spielzug wird anschließend mit der „fuehreSpielzugAus“-Methode vom Spiel angewandt.
*
* @param spielstand Wird durch das Observerpattern beim update der Methode als geupdatetes Objekt
* übergeben
* @param aktSpieler gibt den aktuellen Spieler an
*/
public synchronized void update(Observable observable, Object aktSpieler) {
if (observable instanceof Spielstand) {
// Spielstand update
Spieler spieler = (Spieler) aktSpieler;
if (spieler == null) {
// weil notify nicht vernünftig implementiert wurde ...
spieler = this.lnkSpielstand.gibAktuellenSpieler();
}
// GUI
this.lnkGUI.spiel_redoButtonAktivieren(this.lnkSpielstand.istRedoMoeglich());
this.lnkGUI.spiel_undoButtonAktivieren(this.lnkSpielstand.istUndoMoeglich());
this.lnkGUI.spiel_setzePunkteSpieler1(
this.lnkSpielstand.gibPunkte(this.lnkSpielstand.gibSpieler1()));
this.lnkGUI.spiel_setzePunkteSpieler2(
this.lnkSpielstand.gibPunkte(this.lnkSpielstand.gibSpieler2()));
this.lnkGUI.spiel_spielerWechsel(spieler);
// KI
if (spieler.gibTyp() != SpielerTyp.mensch
&& !this.kiDarfNichtSetzen
&& !lnkSpiel.istSpielZuEnde()) {
this.lnkKIHaupt.erzeugeSpielzug();
}
if (lnkSpiel.istSpielZuEnde()) {
this.spielEnde();
}
} else if (observable instanceof KI) {
// KI update
try {
this.lnkSpiel.fuehreSpielzugAus(this.lnkKIHaupt.gibSpielzug());
} catch (UngueltigerZugException e) {
System.out.println(
"Wir haben mist gemacht, die KI kann nicht vernünftig spielen!\n" + e.gibRegelBruch());
}
}
}
@Test
public void testIsComputerIstTrueWennNameComputerIst() {
Spieler sp = new Spieler();
sp.setName(Spieler.COMPUTER);
assertTrue(sp.isComputer());
}
/**
* Die Methode beschreibt den �berlauf
*
* @param neuePosition
* @param figurId
* @return neuePosition, figurId
*/
@Override
public int ueberlauf(int neuePosition, int figurId) {
int hit = 0;
if (neuePosition > 39) {
for (int i = 0; i < figurenUeberlauf.size(); i++) {
if (spielerAmZug.getFigur(figurId) == figurenUeberlauf.get(i)
&& spielerAmZug.getFigur(figurId).getPosition().getTyp() != FeldTyp.Endfeld) {
// throw new RuntimeException("Figur will 2 mal ueber 0 laufen!");
}
}
figurenUeberlauf.add(spielerAmZug.getFigur(figurId));
hatUeberlauf = true;
return (neuePosition - 40);
}
for (int i = 0; i < figurenUeberlauf.size(); i++) {
if (spielerAmZug.getFigur(figurId) == figurenUeberlauf.get(i)
&& spielerAmZug.getFigur(figurId).getPosition().getTyp() != FeldTyp.Endfeld) {
hit++;
}
}
if (hit != 0) {
hatUeberlauf = true;
} else {
hatUeberlauf = false;
}
return neuePosition;
}
@Test
public void testIsComputerIstFalseWennNameNichtComputerIst() {
Spieler sp = new Spieler();
sp.setName("Hugo");
assertFalse(sp.isComputer());
}
/**
* Verarbeitet den Klick auf den Button "laden" aus der GUI, indem die GUI diese Methode aufruft.
* Der Klick wird durch Delegation an die Spielklasse aufgelöst.
*/
public void laden() {
this.lnkSpielstand = this.lnkGUI.laden_gibSpielstand();
// Laden des Spielstandes in Spiel
this.lnkSpiel = new Spiel(this.lnkSpielstand);
Variante var = this.lnkSpielstand.gibVariante();
Spieler spieler1 = this.lnkSpielstand.gibSpieler1();
Spieler spieler2 = this.lnkSpielstand.gibSpieler2();
if (var instanceof Steinschlag) {
this.lnkGUI.spiel_buttonsFuerSteinschlagKonfigurieren();
if (this.lnkSpielstand.gibSpieler1().gibTyp() == SpielerTyp.leicht) {
this.lnkKIHaupt =
new KI(
spieler1,
new Leicht(lnkSpielstand.gibSpieler1().gibFarbe(), new KIVariante(var)),
this.lnkSpiel.gibSpielbrett());
} else if (this.lnkSpielstand.gibSpieler1().gibTyp() == SpielerTyp.schwer) {
this.lnkKIHaupt =
new KI(
spieler1,
new Schwer(lnkSpielstand.gibSpieler1().gibFarbe(), new KIVariante(var)),
this.lnkSpiel.gibSpielbrett());
}
if (this.lnkSpielstand.gibSpieler2().gibTyp() == SpielerTyp.leicht) {
this.lnkKIHaupt =
new KI(
spieler2,
new Leicht(lnkSpielstand.gibSpieler1().gibFarbe(), new KIVariante(var)),
this.lnkSpiel.gibSpielbrett());
} else if (this.lnkSpielstand.gibSpieler2().gibTyp() == SpielerTyp.schwer) {
this.lnkKIHaupt =
new KI(
spieler2,
new Schwer(lnkSpielstand.gibSpieler2().gibFarbe(), new KIVariante(var)),
this.lnkSpiel.gibSpielbrett());
}
} else {
// Spieler auf Mensch setzen, da unsere KI kein Klassisch kann.
spieler1.setzeTyp(SpielerTyp.mensch);
spieler2.setzeTyp(SpielerTyp.mensch);
}
// Observer setzen
this.lnkSpiel.gibSpielbrett().addObserver(lnkGUI);
this.lnkSpielstand.addObserver(this);
if (this.lnkKIHaupt != null) {
this.lnkKIHaupt.addObserver(this);
}
// Update vom Spielbrett machen, falls Spieler hinzugefügt wurden.
this.lnkSpiel.gibSpielbrett().updateUI();
this.kiDarfNichtSetzen = false;
this.update(lnkSpielstand, lnkSpielstand.gibAktuellenSpieler());
}
private Spielausgang gibSpielausgang(Spieler spieler) {
Spieler spieler1, spieler2;
spieler1 = this.lnkSpielstand.gibSpieler1();
spieler2 = this.lnkSpielstand.gibSpieler2();
if (this.lnkSpiel.gibPunkte(spieler1) > this.lnkSpiel.gibPunkte(spieler2)) {
if (spieler.equals(spieler1)) return Spielausgang.sieg;
else return Spielausgang.niederlage;
} else if (this.lnkSpiel.gibPunkte(spieler1) < this.lnkSpiel.gibPunkte(spieler2)) {
if (spieler.equals(spieler1)) return Spielausgang.niederlage;
else return Spielausgang.sieg;
} else {
return Spielausgang.unentschieden;
}
}
/**
* F�gt dem Spiel einen Spieler hinzu.
*
* @param spieler Der Spieler, der hinzugef�gt werden soll.
*/
@Override
public void spielerHinzufuegen(String name, int f, int KI) {
if (!spielHatBegonnen) {
if (spieler == null) {
throw new RuntimeException("Spieler existiert nicht!");
}
Spieler spieler;
FarbEnum farbe = null;
switch (f) {
case 0:
farbe = FarbEnum.rot;
break;
case 1:
farbe = FarbEnum.blau;
break;
case 2:
farbe = FarbEnum.gruen;
break;
case 3:
farbe = FarbEnum.gelb;
break;
default:
throw new RuntimeException("Farbe existiert nicht!");
}
switch (KI) {
case 0:
spieler = new Spieler(name, farbe, null, spielbrett);
break;
case 1:
spieler = new Spieler(name, farbe, null, spielbrett);
KI_aggressiv ofKI = new KI_aggressiv(spieler, this);
spieler.setKI(ofKI);
break;
case 2:
spieler = new Spieler(name, farbe, null, spielbrett);
KI_defensiv defKI = new KI_defensiv(spieler, this);
spieler.setKI(defKI);
break;
default:
throw new RuntimeException("Spieler konnte nicht erstellt werden!");
}
this.spieler.add(spieler);
}
}
/**
* Wird aufgerufen, wenn der User versucht seine eigene Figur zu schlagen.
*
* @param neuePosition Die neue Position der Figur.
* @param sf Die Spielfigur
* @return boolean Boolscher R�ckgabewert
*/
@Override
public boolean userIstDumm(int neuePosition, int figurId) {
if ((spielbrett.getFeld(neuePosition).getFigur() != null)
&& (spielbrett.getFeld(neuePosition).getFigur().getFarbe() == spielerAmZug.getFarbe()))
return true;
return false;
}
/**
* Hilfsmethode fuer CSV
*
* @return String s, vorgefertigter String
*/
public String csvString() {
String s = "";
for (int i = 0; i < spieler.size(); i++) {
s +=
spieler.get(i).getName()
+ ";"
+ spieler.get(i).getFarbe()
+ ";"
+ spieler.get(i).getKIWert()
+ ";"
+ spieler.get(i).getFigur(0).getPosition().getId()
+ ";"
+ figurenUeberlauf.contains(spieler.get(i))
+ ";"
+ spieler.get(i).getFigur(1).getPosition().getId()
+ ";"
+ figurenUeberlauf.contains(spieler.get(i))
+ ";"
+ spieler.get(i).getFigur(2).getPosition().getId()
+ ";"
+ figurenUeberlauf.contains(spieler.get(i))
+ ";"
+ spieler.get(i).getFigur(3).getPosition().getId()
+ ";"
+ figurenUeberlauf.contains(spieler.get(i))
+ ";\n";
}
s += spielerAmZug.getName();
return s;
}
/**
* Methode gibt die ID der Figur zurueck auf einem feld
*
* @param int feld feld das ueberprueft wird
* @return int i id der Figur
*/
public int figurIdAufFeld(int feld) {
if (spielbrett.getFeld(feld).getFigur() != null) {
for (int i = 0; i < 4; i++) {
if (spielerAmZug.getFigur(i) == spielbrett.getFeld(feld).getFigur()) {
return i;
}
}
}
throw new RuntimeException("Keine Figur ausgewaehlt!");
}
public void
zieheErsteKarte() { // Generierung der ersten Karte und intitialisieren aller
// Stapelvariablen (WENN DIE OBERSTE KARTE BEIM DEBUGGEN HIER VERÄNDERT
// WIRD, MÜSSEN AUCH DIE ANDEREN VARIABLEN (aktuelleFarbe, aktuelleID)
// ANGEPASST WERDEN!!!!!)
obersteKarte =
spieler1
.zieheKarte(); // benutzen der Kartenziehung eines Spielers um eine Karte zu
// generieren
aktuelleFarbe = obersteKarte.charAt(1);
aktuelleID = obersteKarte.charAt(0);
ziehFlag = 0;
}
/**
* Diese Methode ueberprueft ob der Zug auf das Endfeld gueltig ist
*
* @param neuePosition
* @return boolean
*/
@Override
public boolean zugGueltigEndfeld(int neuePosition) {
switch (spielerAmZug.getFarbe()) {
case rot:
if (neuePosition < 4 && hatUeberlauf) {
for (int i = 0; i < 4; i++) {
if (figurAufFeld(68 + i) && i < neuePosition) {
return false;
}
}
return true;
}
case blau:
if (neuePosition < 14 && hatUeberlauf) {
for (int i = 0; i < 4; i++) {
if (figurAufFeld(56 + i) && i < neuePosition - 9) {
return false;
}
}
return true;
}
case gruen:
if (neuePosition < 24 && hatUeberlauf) {
for (int i = 0; i < 4; i++) {
if (figurAufFeld(64 + i) && i < neuePosition - 19) {
return false;
}
}
return true;
}
case gelb:
if (neuePosition < 34 && hatUeberlauf) {
for (int i = 0; i < 4; i++) {
if (figurAufFeld(60 + i) && i < neuePosition - 29) {
return false;
}
}
return true;
}
default:
return false;
}
}
/**
* Die Methode beschreibt ob die Figuren die Grenze ueberschreiten
*
* @param neuePosition
* @return boolean
*/
@Override
public boolean grenzUeberschreitung(int neuePosition) {
switch (spielerAmZug.getFarbe()) {
case rot:
if (neuePosition > 39) return true;
return false;
case blau:
if (neuePosition > 9 && hatUeberlauf) return true;
return false;
case gruen:
if (neuePosition > 19 && hatUeberlauf) return true;
return false;
case gelb:
if (neuePosition > 29 && hatUeberlauf) return true;
return false;
default:
throw new RuntimeException("Spieler hat keine Farbe!");
}
}
/**
* Diese Methode ueberprueft ob der Spieler mit dem Zug das Endfeld erreichen kann
*
* @param neuePosition
* @return boolean
*/
@Override
public boolean kannEndfeldErreichen(int neuePosition) {
switch (spielerAmZug.getFarbe()) {
case rot:
if (neuePosition >= 0 && hatUeberlauf) return true;
return false;
case blau:
if (neuePosition > 9 && hatUeberlauf) return true;
return false;
case gruen:
if (neuePosition > 19 && hatUeberlauf) return true;
return false;
case gelb:
if (neuePosition > 29 && hatUeberlauf) return true;
return false;
default:
return false;
}
}
/**
* Die Methode weist die Endfelder zu
*
* @param neuePosition
* @return neue Position
*/
@Override
public int endfeld(int neuePosition) {
switch (spielerAmZug.getFarbe()) {
case rot:
if (68 + neuePosition <= 71) return (68 + neuePosition);
return neuePosition;
case blau:
if (56 + neuePosition - 10 <= 59) return (56 + (neuePosition - 10));
return neuePosition;
case gruen:
if (64 + neuePosition - 20 <= 67) return (64 + (neuePosition - 20));
return neuePosition;
case gelb:
if (60 + neuePosition - 30 <= 63) return (60 + (neuePosition - 30));
return neuePosition;
default:
throw new RuntimeException("Fehler beim betreten des Endfeldes!");
}
}
/** Die Methode beendet einen Zug. */
public void zugBeenden() {
int zaehler = 0;
for (int i = 0; i < 4; i++) {
if (spielerAmZug.getFigur(i).getPosition().getTyp() == FeldTyp.Endfeld) {
zaehler++;
}
}
if (zaehler == 4) {
spielGewonnen(spielerAmZug);
}
for (int i = 0; i < spieler.size(); i++) {
if (count == spieler.size()) {
spielerAmZug = spieler.get(count - spieler.size());
darfWuerfeln = true;
count = 1;
break;
} else {
spielerAmZug = spieler.get(count);
darfWuerfeln = true;
count = count + 1;
break;
}
}
}
/**
* fragt das Spiel nach den erlangten Punkten der einzelnen Spieler und entscheidet wer gewonnen
* hat und trägt das Ergebniss in die Statistik ein. Hilfsmethode von Update.
*/
@SuppressWarnings("static-access")
private void aktualisiereStatistik() {
try {
this.lnkStatistik = lnkStatistik.gibStatistik();
} catch (StatistikException e) {
this.lnkGUI.zeigeFehlerAn(
"Die Statistikdatei ist fehlerhaft, Ihre Statistik wurde zurückgesetzt.");
}
this.lnkGUI.setzeSteinNichtSetzbar(true);
Spieler spieler1, spieler2;
spieler1 = lnkSpielstand.gibSpieler1();
spieler2 = lnkSpielstand.gibSpieler2();
this.lnkStatistik.aktualisiereEintrag(
spieler1, this.gibSpielausgang(spieler1), this.gibStatistikunterteilung());
this.lnkStatistik.aktualisiereEintrag(
spieler2, this.gibSpielausgang(spieler2), this.gibStatistikunterteilung());
/*
if (this.lnkSpiel.gibPunkte(spieler1) > this.lnkSpiel.gibPunkte(spieler2)) {
this.lnkStatistik.aktualisiereEintrag(spieler1, Spielausgang.sieg,
Statistikunterteilung.Steinschlag);
this.lnkStatistik.aktualisiereEintrag(spieler2,
Spielausgang.niederlage, Statistikunterteilung.Steinschlag);
this.lnkGUI.spiel_setzeNachricht(spieler1.gibName()
+ " hat gewonnen!");
this.lnkSpielstand.setzeSpielAusgang(Zustand.schwarz);
} else if (this.lnkSpiel.gibPunkte(spieler1) < this.lnkSpiel
.gibPunkte(spieler2)) {
this.lnkStatistik.aktualisiereEintrag(spieler2, Spielausgang.sieg,
Statistikunterteilung.Steinschlag);
this.lnkStatistik.aktualisiereEintrag(spieler1,
Spielausgang.niederlage, Statistikunterteilung.Steinschlag);
this.lnkGUI.spiel_setzeNachricht(spieler2.gibName()
+ " hat gewonnen!");
this.lnkSpielstand.setzeSpielAusgang(Zustand.weiss);
} else {
this.lnkStatistik.aktualisiereEintrag(spieler2,
Spielausgang.unentschieden,
Statistikunterteilung.Steinschlag);
this.lnkStatistik.aktualisiereEintrag(spieler1,
Spielausgang.unentschieden,
Statistikunterteilung.Steinschlag);
this.lnkGUI.spiel_setzeNachricht("Es steht unentschieden.");
this.lnkSpielstand.setzeSpielAusgang(Zustand.frei);
}
*/
try {
this.lnkStatistik.speichern();
} catch (Exception e) {
this.lnkGUI.zeigeFehlerAn("Die Statistik konnte nicht gespeichert werden");
}
this.lnkGUI.actionPerformed(new java.awt.event.ActionEvent(this, 0, "Spiel_Ende"));
if (this.lnkSpiel.gibPunkte(spieler1) > this.lnkSpiel.gibPunkte(spieler2)) {
this.lnkGUI.spiel_setzeNachricht(spieler1.gibName() + " hat gewonnen!");
} else if (this.lnkSpiel.gibPunkte(spieler1) < this.lnkSpiel.gibPunkte(spieler2)) {
this.lnkGUI.spiel_setzeNachricht(spieler2.gibName() + " hat gewonnen!");
} else {
this.lnkGUI.spiel_setzeNachricht("Es steht unentschieden.");
}
this.lnkGUI.spiel_setzePunkteSpieler1(this.lnkSpiel.gibPunkte(spieler1));
this.lnkGUI.spiel_setzePunkteSpieler2(this.lnkSpiel.gibPunkte(spieler2));
}
/**
* Hier wird der Gewinner zur�ckgegeben
*
* @return String gewinner
*/
public String getGewinner() {
if (gewinner == null) {
return null;
} else return gewinner.getName();
}
// F�r die TestKlasse. Sp�ter l�schen!
public String benutzeKI() {
if (spielerAmZug.getKI() == null) throw new RuntimeException("Spieler hat keine KI!");
return spielerAmZug.getKI().kalkuliereSpielzug();
}
/**
* startet ein neues Spiel, indem es zunächst einen neuen Spielstand mit den vorher vom Benutzer
* gemachten und an den Controller übermittelten Informationen erstellt. Dieser erstellt wiederum
* die beiden Spieler. Der fertige Spielstand wird anschließend vom neu erzeugten Spiel geladen.
* Bei Bedarf werden anschließend zusätzlich KIs erzeugt, die je einen Spieler erhalten.
*/
public void neuesSpielStarten() {
Spieler spieler1, spieler2;
Variante var;
// 1. Spieler soll immer schwarz sein
spieler1 = new Spieler(Zustand.schwarz, lnkGUI.neuesSpiel_gibSpieler1Name(), SpielerTyp.mensch);
spieler2 = new Spieler(Zustand.weiss, lnkGUI.neuesSpiel_gibSpieler2Name(), SpielerTyp.mensch);
// Variante erzeugen
if (this.lnkGUI.neuesSpiel_gibVariante() == go.gui.NeuesSpiel.SPIELART_STEINSCHLAG) {
var = new Steinschlag();
this.lnkGUI.spiel_buttonsFuerSteinschlagKonfigurieren();
} else {
var = new Klassisch();
}
// Spielstand erzeugen
this.lnkSpielstand = new Spielstand(spieler1, spieler2, var, lnkGUI.neuesSpiel_gibGroesse());
// Spiel erzeugen
this.lnkSpiel =
new Spiel(var, lnkSpielstand, var.initialisiereSpielbrett(lnkGUI.neuesSpiel_gibGroesse()));
// KI erzeugen
switch (lnkGUI.neuesSpiel_gibKI()) {
case leicht:
if (lnkGUI.neuesSpiel_gibKIFarbe() == Zustand.schwarz) {
spieler1.setzeTyp(SpielerTyp.leicht);
lnkKIHaupt =
new KI(
spieler1,
new Leicht(lnkGUI.neuesSpiel_gibKIFarbe(), new KIVariante(var)),
this.lnkSpiel.gibSpielbrett());
} else {
spieler2.setzeTyp(SpielerTyp.leicht);
lnkKIHaupt =
new KI(
spieler2,
new Leicht(lnkGUI.neuesSpiel_gibKIFarbe(), new KIVariante(var)),
this.lnkSpiel.gibSpielbrett());
}
break;
case schwer:
if (lnkGUI.neuesSpiel_gibKIFarbe() == Zustand.schwarz) {
spieler1.setzeTyp(SpielerTyp.schwer);
lnkKIHaupt =
new KI(
spieler1,
new Schwer(lnkGUI.neuesSpiel_gibKIFarbe(), new KIVariante(var)),
this.lnkSpiel.gibSpielbrett());
} else {
spieler2.setzeTyp(SpielerTyp.schwer);
lnkKIHaupt =
new KI(
spieler2,
new Schwer(lnkGUI.neuesSpiel_gibKIFarbe(), new KIVariante(var)),
this.lnkSpiel.gibSpielbrett());
}
break;
}
// Observer setzen
this.lnkSpiel.gibSpielbrett().addObserver(lnkGUI);
this.lnkSpielstand.addObserver(this);
if (this.lnkKIHaupt != null) {
this.lnkKIHaupt.addObserver(this);
}
// Update vom Spielbrett machen, falls Spieler hinzugefügt wurden.
this.lnkSpiel.gibSpielbrett().updateUI();
this.update(lnkSpielstand, lnkSpielstand.gibAktuellenSpieler());
}
static void startStapel() {
spieler1.generiereKarten();
spieler2.generiereKarten();
}
/** Die Methode ueberpreuft ob der Spieler sich auf dem Endfeld bewegen darf */
@Override
public boolean zugGueltigAufEndfeld(int neuePosition, int n) {
int x = 0;
switch (spielerAmZug.getFarbe()) {
case rot:
x = 71 - spielerAmZug.getFigur(n).getPosition().getId();
if (spielerAmZug.getFigur(n).getPosition().getId() + getBewegungsWert() > 71) {
return false;
} else {
for (int i = spielerAmZug.getFigur(n).getPosition().getId();
i < spielerAmZug.getFigur(n).getPosition().getId() + getBewegungsWert();
i++) {
if (figurAufFeld(i + 1)) {
return false;
}
}
return true;
}
case blau:
x = 59 - spielerAmZug.getFigur(n).getPosition().getId();
if (spielerAmZug.getFigur(n).getPosition().getId() + getBewegungsWert() > 59) {
return false;
} else {
for (int i = spielerAmZug.getFigur(n).getPosition().getId();
i < spielerAmZug.getFigur(n).getPosition().getId() + getBewegungsWert();
i++) {
if (figurAufFeld(i + 1)) {
return false;
}
}
return true;
}
case gruen:
x = 67 - spielerAmZug.getFigur(n).getPosition().getId();
if (spielerAmZug.getFigur(n).getPosition().getId() + getBewegungsWert() > 67) {
return false;
} else {
for (int i = spielerAmZug.getFigur(n).getPosition().getId();
i < spielerAmZug.getFigur(n).getPosition().getId() + getBewegungsWert();
i++) {
if (figurAufFeld(i + 1)) {
return false;
}
}
return true;
}
case gelb:
x = 63 - spielerAmZug.getFigur(n).getPosition().getId();
if (spielerAmZug.getFigur(n).getPosition().getId() + getBewegungsWert() > 63) {
return false;
} else {
for (int i = spielerAmZug.getFigur(n).getPosition().getId();
i < spielerAmZug.getFigur(n).getPosition().getId() + getBewegungsWert();
i++) {
if (figurAufFeld(i + 1)) {
return false;
}
}
return true;
}
default:
return false;
}
}
// Durchfuehrung eines Spiels
public void spielen() {
// Spielvorbereitung
this.schiedsrichter.initialisiereSpiel();
// es wird gemaess der Spielregeln gezogen;
// nach jedem Spielzug kontrolliert der Schiedsrichter
Spieler aktuellerSpieler = this.schiedsrichter.werIstAmZug();
while (true) {
Spielzug zug;
try {
zug = aktuellerSpieler.naechsterSpielzug();
} catch (Exception exc) {
// wenn waehrend der Ausfuehrung der Methode ein
// Fehler auftritt, hat der Spieler verloren
this.schiedsrichter.schreib(
"Spieler "
+ aktuellerSpieler.liefereSpielerTyp()
+ " hat die folgende Exception erzeugt\n"
+ " und damit verloren: "
+ exc.toString());
return; // Spielende
}
if (!this.schiedsrichter.istSpielzugOk(aktuellerSpieler, zug)) {
this.schiedsrichter.schreib(
"Spieler "
+ aktuellerSpieler.liefereSpielerTyp()
+ " hat sich nicht an die\n"
+ "Spielregeln gehalten und damit\n"
+ "verloren!");
return; // Spielende
}
if (this.schiedsrichter.istSpielBeendet()) {
// die verbliebenen Koerner muessen noch in die
// Kalahs gepackt werden
Spieler spielerA = this.schiedsrichter.getSpielerA();
spielerA.sammleResteUndBringSieZumKalah();
if (!this.schiedsrichter.istEndzustandVonSpielerAOk()) {
this.schiedsrichter.schreib(
"Spieler A"
+ " hat sich nicht an die\n"
+ "Spielregeln gehalten und damit\n"
+ "verloren!");
return; // Spielende
}
Spieler spielerB = this.schiedsrichter.getSpielerB();
spielerB.sammleResteUndBringSieZumKalah();
if (!this.schiedsrichter.istEndzustandVonSpielerBOk()) {
this.schiedsrichter.schreib(
"Spieler B"
+ " hat sich nicht an die\n"
+ "Spielregeln gehalten und damit\n"
+ "verloren!");
return; // Spielende
}
// Siegerehrung
Spieler sieger = this.schiedsrichter.liefereSieger();
if (sieger == null) {
this.schiedsrichter.schreib("Unentschieden!");
// zur Belohnung duerfen die Hamster noch die
// Koerner in ihren Kalahs fressen
aktuellerSpieler.spielBeenden(false);
Spieler gegner = this.schiedsrichter.liefereGegner(aktuellerSpieler);
gegner.spielBeenden(false);
} else {
int punkteA = this.schiedsrichter.getPunkteA();
int punkteB = this.schiedsrichter.getPunkteB();
this.schiedsrichter.schreib(
"Endstand: "
+ punkteA
+ " : "
+ punkteB
+ "\n"
+ "Spieler "
+ sieger.liefereSpielerTyp()
+ " hat gewonnen!");
// zur Belohnung duerfen die Hamster noch die
// Koerner in ihren Kalahs fressen
sieger.spielBeenden(true);
Spieler gegner = this.schiedsrichter.liefereGegner(sieger);
gegner.spielBeenden(false);
}
return; // Spielende
}
// naechste Runde
aktuellerSpieler = schiedsrichter.werIstAmZug();
}
}
