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(); } }