2211945
/
WIZARD_PR2_DOP
2
0
Fork 1
Code Issues 8 Pull Requests 2 Packages Projects 1 Releases Wiki Activity

Stich klasse mit diversen Änderungen in der SpielCLI Spiel und weitere #38

Merged
2211945 merged 9 commits from Stich into main 2023-10-25 12:37:49 +02:00
Conversation 0 Commits 9 Files Changed 20
20 changed files with 617 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
.DS_Store vendored
View File

Binary file not shown.

3
.vscode/settings.json vendored 100644
View File

@ -0,0 +1,3 @@
{
"editor.defaultFormatter": "esbenp.prettier-vscode"
}

2
Domain/Enums/Kartenfarbe.java
View File

@ -12,7 +12,7 @@ public enum Kartenfarbe {
private String farbe;
private Kartenfarbe (String farbe) {
private Kartenfarbe(String farbe) {
this.farbe = farbe;
}

13
Domain/Exceptions/EmptyListException.java 100644
View File

@ -0,0 +1,13 @@
/*
============================================================
This is the "EmptyListException" file from Author: Philipp Kotte
written on: 16 / 10 / 2023 at: 07:54
============================================================
*/
package Domain.Exceptions;
public class EmptyListException extends SpielException {
public EmptyListException(String message) {
super(10, message);
}
}

65
Domain/Exceptions/SpielException.java 100644
View File

@ -0,0 +1,65 @@
/*
============================================================
This is the "SpielException" file from Author: Philipp Kotte
written on: 16 / 10 / 2023 at: 07:42
============================================================
*/
package Domain.Exceptions;
public abstract class SpielException extends Exception {
/*------------------------------------------*/
// statische Konstanten
/*------------------------------------------*/
/*------------------------------------------*/
// statische Attribute(zB. zähler)
/*------------------------------------------*/
/*------------------------------------------*/
// Attribute jedes Objektes
/*------------------------------------------*/
private String message;
private int id;
/*------------------------------------------*/
// Konstruktoren (default und spezifische)
/*------------------------------------------*/
public SpielException() {
}
public SpielException(int id, String message) {
}
public SpielException(String message) {
}
/*------------------------------------------*/
// statische Methoden
/*------------------------------------------*/
/*------------------------------------------*/
// Getter und Setter
/*------------------------------------------*/
/*------------------------------------------*/
// @Overrides
/*------------------------------------------*/
public String getMessage() {
return this.message;
}
public int getID() {
return this.id;
}
/*------------------------------------------*/
// öffentliche Methodes
/*------------------------------------------*/
/*------------------------------------------*/
// Hilfsmethoden (privat)
/*------------------------------------------*/
}

15
Domain/Exceptions/SpielerNotFoundException.java 100644
View File

@ -0,0 +1,15 @@
/*
============================================================
This is the "SpielerNotFoundException" file from Author: Philipp Kotte
written on: 16 / 10 / 2023 at: 07:50
============================================================
*/
package Domain.Exceptions;
public class SpielerNotFoundException extends SpielException {
public SpielerNotFoundException(String message) {
super(1, message);
}
}

17
Domain/Karten/Karte.java
View File

@ -11,22 +11,25 @@ public abstract class Karte {
// Statische Konstanten
// Statische Attribute
private static int id_card = 0;
private int id;
// Attribute des Ojektes
// Konstruktoren
public Karte() {
if (id_card < 60) {
id_card++;
}
public Karte(int id) {
this.id = id;
}
// Statische Methoden
public static int getId_card() {
return id_card;
}
// Getter und Setter
public int getId() {
return this.id;
}
// @Overrides

40
Domain/Karten/Magierkarte.java
View File

@ -6,25 +6,48 @@ written on: 05 / 10 / 2023 at: 23:41
*/
package Domain.Karten;
import Domain.Enums.Kartenfarbe;
public class Magierkarte extends Karte {
// Statische Konstanten
private static String TRUMPF_NAME = "Zauberer";
// Statische Attribute
// Attribute des Objekts
private Kartenfarbe kartenfarbe;
private String bezeichnung;
private static int magierkartenanzahl = 0;
// Konstruktoren
public Magierkarte() {
public Magierkarte(int id) {
super(id);
}
public Magierkarte(Kartenfarbe kartenfarbe, String bezeichnung) {
super();
setBezeichnung(TRUMPF_NAME);
setKartenfarbe(kartenfarbe);
setBezeichnung(bezeichnung);
}
// Statische Methoden
// Getter und Setter
public void setKartenfarbe(Kartenfarbe kartenfarbe) {
this.kartenfarbe = kartenfarbe;
}
public Kartenfarbe getKartenfarbe() {
return this.kartenfarbe;
}
public int getId() {
return this.getId();
}
public void setBezeichnung(String bezeichnung) {
this.bezeichnung = bezeichnung;
}
@ -33,10 +56,19 @@ public class Magierkarte extends Karte {
return this.bezeichnung;
}
public void setMagierkartenanzahl(int magierkartenanzahl) {
magierkartenanzahl++;
}
public int getMagierkartenanzahl() {
return magierkartenanzahl;
}
// @Overrides
@Override
public String toString() {
return this.getBezeichnung();
return this.getBezeichnung() + ": " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe().toString()
+ ").";
}
// Public Methoden

34
Domain/Karten/Narrenkarte.java
View File

@ -6,24 +6,43 @@ written on: 05 / 10 / 2023 at: 23:41
*/
package Domain.Karten;
import Domain.Enums.Kartenfarbe;
public class Narrenkarte extends Karte {
// Statische Konstanten
private static String TRUMPF_NAME = "Narr";
// Statische Attribute
// Attribute des Objekts
private Kartenfarbe kartenfarbe;
private String bezeichnung;
// Konstruktoren
public Narrenkarte() {
super();
setBezeichnung(TRUMPF_NAME);
public Narrenkarte(int id) {
super(id);
}
public Narrenkarte(Kartenfarbe farbe, String bezeichnung) {
super();
setKartenfarbe(farbe);
setBezeichnung(bezeichnung);
}
// Statische Methoden
// Getter und Setter
public int getId() {
return this.getId();
}
public void setKartenfarbe(Kartenfarbe farbe) {
this.kartenfarbe = farbe;
}
public Kartenfarbe getKartenfarbe() {
return this.kartenfarbe;
}
public void setBezeichnung(String bezeichnung) {
this.bezeichnung = bezeichnung;
@ -33,10 +52,15 @@ public class Narrenkarte extends Karte {
return this.bezeichnung;
}
public void setNarrenkarteanzahl(int narrenkarteanzahl) {
narrenkarteanzahl++;
}
// @Overrides
@Override
public String toString() {
return this.getBezeichnung();
return this.getBezeichnung() + ": " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe().toString()
+ ").";
}
// Public Methoden

19
Domain/Karten/Zahlenkarte.java
View File

@ -21,7 +21,7 @@ public class Zahlenkarte extends Karte {
/*------------------------------------------*/
// Attribute jedes Objektes
/*------------------------------------------*/
private Kartenfarbe kartenfarbe;
private Kartenfarbe farbe;
private int kartenNummer;
/*------------------------------------------*/
@ -31,9 +31,9 @@ public class Zahlenkarte extends Karte {
super();
}
public Zahlenkarte(Kartenfarbe kartenfarbe, int kartenNummer) {
public Zahlenkarte(Kartenfarbe farbe, int kartenNummer) {
super();
setKartenfarbe(kartenfarbe);
setFarbe(farbe);
setKartenNummer(kartenNummer);
}
@ -44,12 +44,12 @@ public class Zahlenkarte extends Karte {
/*------------------------------------------*/
// Getter und Setter
/*------------------------------------------*/
public void setKartenfarbe(Kartenfarbe kartenfarbe) {
this.kartenfarbe = kartenfarbe;
public void setFarbe(Kartenfarbe farbe) {
this.farbe = farbe;
}
public Kartenfarbe getKartenfarbe() {
return kartenfarbe;
public Kartenfarbe getFarbe() {
return farbe;
}
public void setKartenNummer(int kartenNummer) {
@ -63,10 +63,7 @@ public class Zahlenkarte extends Karte {
/*------------------------------------------*/
// @Overrides
/*------------------------------------------*/
@Override
public String toString() {
return "Charakterkarte: " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe() + ").";
}
/*------------------------------------------*/
// öffentliche Methodes
/*------------------------------------------*/

43
Domain/Kartenstapel.java
View File

@ -6,6 +6,11 @@ written on: 05 / 10 / 2023 at: 23:42
*/
package Domain;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import Domain.Enums.Kartenfarbe;
import Domain.Karten.*;
public class Kartenstapel {
@ -21,6 +26,12 @@ public class Kartenstapel {
/*------------------------------------------*/
// Attribute jedes Objektes
/*------------------------------------------*/
private boolean[][] belegung = {
{ false, false, false, false, false, false, false, false, false, false, false, false, false, false, false },
{ false, false, false, false, false, false, false, false, false, false, false, false, false, false, false },
{ false, false, false, false, false, false, false, false, false, false, false, false, false, false, false },
{ false, false, false, false, false, false, false, false, false, false, false, false, false, false, false }
};
private Karte[] kartenStapel = new Karte[60];
@ -29,6 +40,7 @@ public class Kartenstapel {
/*------------------------------------------*/
public Kartenstapel() {
mischen();
}
@ -74,6 +86,37 @@ public class Kartenstapel {
// Hilfsmethoden (privat)
/*------------------------------------------*/
private void Kartenverteilung() {
Random r = new Random();
List<Karte> karten = new ArrayList<>();
while (karten.size() < 60) {
int high = 4;
int low = 1;
int ultra_high = 15;
int x = r.nextInt(high - low) + low;
int y = r.nextInt(ultra_high - low) + low;
if (!belegung[x - 1][y - 1]) {
if (y == 1) {
karten.add(new Narrenkarte(x * y));
} else if (y == 15) {
karten.add(new Magierkarte(x * y));
} else {
if (x == 1) {
karten.add(new Zahlenkarte(Kartenfarbe.ZWERG, y));
} else if (x == 2) {
} else if (x == 3) {
} else if (x == 4) {
}
}
}
}
}
//
}

14
Domain/Spieler.java
View File

@ -10,7 +10,7 @@ import Domain.Enums.Geschlecht;
import java.io.Serializable;
public class Spieler implements Serializable {
public class Spieler extends Object implements Serializable {
/*------------------------------------------*/
// statische Konstanten
@ -27,6 +27,7 @@ public class Spieler implements Serializable {
private String name;
private int vorhersage;
private Geschlecht geschlecht;
//
/*------------------------------------------*/
// Konstruktoren (default und spezifische)
@ -50,17 +51,14 @@ public class Spieler implements Serializable {
this();
if (id < 6) {
setId(id);
}
else {
} else {
throw new RuntimeException("Es darf nur max 6 Spieler geben.");
}
if (geschlecht == Geschlecht.KI) {
setName(name); // Bei KI wird kein Name gesetzt. name = leerer String
}
else if (name.length() > 2) {
} else if (name.length() > 2) {
setName(name); // Es wird geprüft, ob Name größer 2 Zeichen
}
else {
} else {
throw new RuntimeException("Der Name muss länger als 2 Buchstaben sein.");
}
setGeschlecht(geschlecht);
@ -122,7 +120,7 @@ public class Spieler implements Serializable {
* @return String name
*/
public String getName() {
return name;
return this.name;
}
// geschlecht

82
Domain/Stich.java 100644
View File

@ -0,0 +1,82 @@
/*
============================================================
This is the "Stich" file from Author: Philipp Kotte
written on: 11 / 10 / 2023 at: 20:25
============================================================
*/
package Domain;
import Domain.Karten.Karte;
public class Stich {
/*------------------------------------------*/
// statische Konstanten
/*------------------------------------------*/
/*------------------------------------------*/
// statische Attribute(zB. zähler)
/*------------------------------------------*/
/*------------------------------------------*/
// Attribute jedes Objektes
/*------------------------------------------*/
private Karte[] karten;
private int[] spielerID;
private int kartenCount = 0;
/*------------------------------------------*/
// Konstruktoren (default und spezifische)
/*------------------------------------------*/
public Stich() {
}
public Stich(int spielerAnzahl) {
setSpielerAnzahl(spielerAnzahl);
}
/*------------------------------------------*/
// statische Methoden
/*------------------------------------------*/
/*------------------------------------------*/
// Getter und Setter
/*------------------------------------------*/
public void setSpielerAnzahl(int spielerAnzahl) {
this.karten = new Karte[spielerAnzahl];
this.spielerID = new int[spielerAnzahl];
}
public Karte[] getKarten() {
return this.karten;
}
public void addKarte(int spielerID, Karte karte) {
this.karten[kartenCount] = karte;
this.spielerID[kartenCount] = spielerID;
kartenCount++;
}
/*------------------------------------------*/
// @Overrides
/*------------------------------------------*/
@Override
public String toString() {
String text = "";
for (int i = 0; i < this.karten.length; i++) {
text += this.karten[i].toString();
}
return text;
}
/*------------------------------------------*/
// öffentliche Methodes
/*------------------------------------------*/
/*------------------------------------------*/
// Hilfsmethoden (privat)
/*------------------------------------------*/
}

118
Facade/Spiel.java
View File

@ -11,8 +11,12 @@ import java.util.HashMap;
import Domain.Kartenstapel;
import Domain.Spieler;
import Domain.Stich;
import Domain.Block.Block;
import Domain.Enums.Geschlecht;
import Domain.Exceptions.EmptyListException;
import Domain.Exceptions.SpielerNotFoundException;
import Domain.Karten.Karte;
public class Spiel implements Serializable {
@ -20,6 +24,11 @@ public class Spiel implements Serializable {
// statische Konstanten
/*--------------------------------------------------------*/
private static final String ANSI_RESET = "\u001B[0m";
private static final String ANSI_GREEN = "\u001B[32m";
private static final String ANSI_RED = "\u001B[31m";
public static final String ANSI_BLUE = "\u001B[34m";
/*--------------------------------------------------------*/
// statische Attribute(zB. zähler)
/*--------------------------------------------------------*/
@ -33,6 +42,7 @@ public class Spiel implements Serializable {
private Spieler spielerAmZug;
private int runde;
private HashMap<Integer, Spieler> spieler = new HashMap<>();
private HashMap<Integer, Stich> stiche = new HashMap<>();
private boolean[] id_check = { false, false, false, false, false, false };
private Kartenstapel kartenstapel;
private Block block;
@ -46,6 +56,7 @@ public class Spiel implements Serializable {
this.istBeendet = false;
this.spielerAmZug = null;
this.runde = 0;
this.kartenstapel = new Kartenstapel();
};
/*--------------------------------------------------------*/
// statische Methoden
@ -77,8 +88,34 @@ public class Spiel implements Serializable {
@Override
public String toString() {
return "Runde: " + getRunde() + ", Gestartet : " + (istSpielGestartet() ? "Ja " : "Nein ") + ", Beendet: "
+ (istSpielBeendet() ? "Ja" : "Nein") + ", Spieler am Zug: " + getSpielerAmZug()[0];
String text = "\n";
String header = "Systemausgabe--------------------------------\n";
String footer = "---------------------------------------------\n";
text += header;
text += "Runde: " + getRunde() + "\n";
text += "Gestartet : " + (istSpielGestartet() ? "Ja " : "Nein ") + "\n";
text += "Beendet: " + (istSpielBeendet() ? "Ja" : "Nein") + "\n";
text += "Spieler am Zug: "
+ (this.spielerAmZug == null ? "Noch keine Spieler vorhanden" : this.spielerAmZug.getName()) + "\n";
if (this.spieler.size() == 0) {
text += "Noch keine Spieler vorhanden \n";
} else {
for (Spieler s : this.spieler.values()) {
text += "[" + s.getId() + "] " + s.getName() + " ("
+ s.getGeschlecht() + ")" + "\n";
}
}
for (int i = 0; i < this.id_check.length; i++) {
if (this.id_check[i]) {
text += "idcheck" + ANSI_BLUE + " [" + i + "] " + ANSI_GREEN + this.id_check[i] + ANSI_RESET + " \n";
} else {
text += "idcheck" + ANSI_BLUE + " [" + i + "] " + ANSI_RED + this.id_check[i] + ANSI_RESET + " \n";
}
}
text += footer;
return text;
}
/*--------------------------------------------------------*/
@ -90,25 +127,69 @@ public class Spiel implements Serializable {
while (id_check[id - 1]) {
id++;
}
id_check[id - 1] = true;
Spieler temp = new Spieler(id, name, geschlecht);
this.spieler.put(id, temp);
System.out.println(this.spieler.get(id));
if (this.spielerAmZug == null) {
this.spielerAmZug = temp;
}
updateSpielerAmZug();
}
public void removeSpieler(int id_spieler) {
public void removeSpieler(int id_spieler) throws SpielerNotFoundException, EmptyListException, RuntimeException {
if (this.spieler.containsKey(id_spieler)) {
this.spieler.remove(id_spieler);
this.id_check[id_spieler - 1] = false;
} else if (!this.spieler.containsKey(id_spieler)) {
throw new SpielerNotFoundException("Dieser Spieler existiert nicht");
} else if (this.spieler.values().size() == 0) {
throw new EmptyListException("Dise Liste ist Leer.");
} else {
throw new RuntimeException("Unkown Error");
}
updateSpielerAmZug();
}
public String[] getAlleSpieler() {
String[] spieler_text = new String[this.spieler.size()];
for (int i = 0; i < this.spieler.size() - 1; i++) {
spieler_text[i] = this.spieler.get(i).toString();
int zähler = 0;
for (Spieler s : this.spieler.values()) {
spieler_text[zähler] = s.toString();
zähler++;
}
return spieler_text;
}
public void starteSpiel() {
// sing genügend Spieler angelegt?
if (this.spieler.size() >= 3 && this.spieler.size() <= 6) {
this.istGestartet = true;
// Gameloop?
while (!this.istSpielBeendet()) {
System.out.println("Das Spiel wurde gestartet.");
// Beginn der Runde
// Stiche erstellen
erstelleStiche(this.runde);
// Karten für jeden Spieler verteilen
// While loop mit der länge der anzahl Stiche für die jeweilige Runde
// Für jeden Durchgang des Loops wird der Stich ermittelt
// Wer gewonnen hat wird dann der Stich zugeordnet
// prüfen ob das Spiel zuende ist
// Der Spieler der jetzt am Zug ist, ist der der den letzten Stich gewonne hat
// Runde erhöhen
runde++;
}
} else {
System.out.println("Es fehlen " + (3 - this.spieler.size()) + " spieler");
}
}
public String[] getSpielerAmZug() {
@ -141,6 +222,13 @@ public class Spiel implements Serializable {
public void austeilen() {
// Spieler 1 bekommt karten
// Spieler 2 bekommt Karten
// ...
// letzer Spieler bekommt Karten
}
public void ausspielen(int idKarte) {
@ -155,4 +243,22 @@ public class Spiel implements Serializable {
// Hilfsmethoden (privat)
/*--------------------------------------------------------*/
private void erstelleStiche(int runde) {
for (int i = 0; i < runde; i++) {
this.stiche.put(i + 1, new Stich(this.spieler.size()));
}
}
private void ermittleGewinner(Stich stich) {
stich.getKarten();
}
private void updateSpielerAmZug() {
if (this.spieler.size() >= 1) {
this.spielerAmZug = (Spieler) this.spieler.values().toArray()[0];
} else {
this.spielerAmZug = null;
}
}
}

29
RendomTest.java 100644
View File

@ -0,0 +1,29 @@
/*
============================================================
This is the "RendomTest" file from Author: Philipp Kotte
written on: 20 / 10 / 2023 at: 08:26
============================================================
*/
import java.util.Random;
public class RendomTest {
// ----------------------------- Spiel
// ausspiele(int Kartenid){
// Karte temp = Spieler.getKarte(id)
// Stich.add(spielerAmZug.getId(), temp);
// }
// ------------------------------Stich
// Trumpf: Mensch
// spielerID: [3, 4, 1, 2]
// Karten: [Zwerg 4, Magier, narr, Magie]
//
// wo sind magier, false, true
// Karte -> Karten[1]
// Spieler -> spielerID[1]
//
// private void add(int Spielerid, int Kartenid){}
// spieler
}

22
Test/Domain/Karten/MagierkarteTest.java
View File

@ -23,21 +23,23 @@ public class MagierkarteTest {
@Test
public void vierMagier() {
Magierkarte m1 = new Magierkarte();
Magierkarte m2 = new Magierkarte();
Magierkarte m3 = new Magierkarte();
Magierkarte m4 = new Magierkarte();
Magierkarte m1 = new Magierkarte(Kartenfarbe.MENSCH, "Zauberer");
Magierkarte m2 = new Magierkarte(Kartenfarbe.ELF, "Zauberer");
Magierkarte m3 = new Magierkarte(Kartenfarbe.RIESE, "Zauberer");
Magierkarte m4 = new Magierkarte(Kartenfarbe.ZWERG, "Zauberer");
assertEquals(Kartenfarbe.MENSCH, m1.getKartenfarbe());
assertEquals("Zauberer", m1.getBezeichnung());
assertEquals("BLAU", Kartenfarbe.MENSCH.getFarbe());
assertEquals(Kartenfarbe.ELF, m2.getKartenfarbe());
assertEquals("Zauberer", m2.getBezeichnung());
assertEquals("GRÜN", Kartenfarbe.ELF.getFarbe());
assertEquals(Kartenfarbe.RIESE, m3.getKartenfarbe());
assertEquals("Zauberer", m3.getBezeichnung());
assertEquals("GELB", Kartenfarbe.RIESE.getFarbe());
assertEquals(Kartenfarbe.ZWERG, m4.getKartenfarbe());
assertEquals("Zauberer", m4.getBezeichnung());
assertEquals("ROT", Kartenfarbe.ZWERG.getFarbe());
assertEquals("Zauberer: MENSCH (BLAU).", m1.toString());

19
Test/Domain/Karten/NarrenkarteTest.java
View File

@ -7,23 +7,34 @@ written on: 10 / 10 / 2023 at: 21:18
package Test.Domain.Karten;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import Domain.Enums.Kartenfarbe;
import Domain.Karten.Narrenkarte;
public class NarrenkarteTest {
@Test
public void vierNarren() {
Narrenkarte n1 = new Narrenkarte();
Narrenkarte n2 = new Narrenkarte();
Narrenkarte n3 = new Narrenkarte();
Narrenkarte n4 = new Narrenkarte();
Narrenkarte n1 = new Narrenkarte(Kartenfarbe.MENSCH, "Narr");
Narrenkarte n2 = new Narrenkarte(Kartenfarbe.ELF, "Narr");
Narrenkarte n3 = new Narrenkarte(Kartenfarbe.RIESE, "Narr");
Narrenkarte n4 = new Narrenkarte(Kartenfarbe.ZWERG, "Narr");
assertEquals(n1.getKartenfarbe(), Kartenfarbe.MENSCH);
assertEquals(n2.getKartenfarbe(), Kartenfarbe.ELF);
assertEquals(n3.getKartenfarbe(), Kartenfarbe.RIESE);
assertEquals(n4.getKartenfarbe(), Kartenfarbe.ZWERG);
assertEquals(n1.getBezeichnung(), "Narr");
assertEquals(n2.getBezeichnung(), "Narr");
assertEquals(n3.getBezeichnung(), "Narr");
assertEquals(n4.getBezeichnung(), "Narr");
assertEquals(Kartenfarbe.MENSCH.getFarbe(), "BLAU");
assertEquals(Kartenfarbe.ELF.getFarbe(), "GRÜN");
assertEquals(Kartenfarbe.RIESE.getFarbe(), "GELB");
assertEquals(Kartenfarbe.ZWERG.getFarbe(), "ROT");
}
}

8
Test/Domain/Karten/ZahlenkarteTest.java
View File

@ -37,10 +37,8 @@ public class ZahlenkarteTest {
zm.put(i, zahlenkarte);
}
assertEquals(zm.get(7).getKartenfarbe(), Kartenfarbe.MENSCH);
assertEquals(zm.get(7).getKartenNummer(), 7);
assertEquals(zm.get(4).getKartenfarbe(), Kartenfarbe.MENSCH);
assertEquals(zm.get(4).getKartenNummer(), 4);
}
@ -53,10 +51,8 @@ public class ZahlenkarteTest {
ze.put(i, zahlenkarte);
}
assertEquals(ze.get(7).getKartenfarbe(), Kartenfarbe.ELF);
assertEquals(ze.get(7).getKartenNummer(), 7);
assertEquals(ze.get(4).getKartenfarbe(), Kartenfarbe.ELF);
assertEquals(ze.get(4).getKartenNummer(), 4);
}
@ -69,10 +65,8 @@ public class ZahlenkarteTest {
zz.put(i, zahlenkarte);
}
assertEquals(zz.get(7).getKartenfarbe(), Kartenfarbe.ZWERG);
assertEquals(zz.get(7).getKartenNummer(), 7);
assertEquals(zz.get(4).getKartenfarbe(), Kartenfarbe.ZWERG);
assertEquals(zz.get(4).getKartenNummer(), 4);
}
@ -86,10 +80,8 @@ public class ZahlenkarteTest {
zr.put(i, zahlenkarte);
}
assertEquals(zr.get(9).getKartenfarbe(), Kartenfarbe.RIESE);
assertEquals(zr.get(9).getKartenNummer(), 9);
assertEquals(zr.get(2).getKartenfarbe(), Kartenfarbe.RIESE);
assertEquals(zr.get(2).getKartenNummer(), 2);
}
}

2
Test/Domain/KartenstapelTest.java
View File

@ -8,8 +8,6 @@ package Test.Domain;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class KartenstapelTest {
@Test

125
UI/SpielCLI.java
View File

@ -8,11 +8,20 @@ written on: 05 / 10 / 2023 at: 23:25
package UI;
import Facade.Spiel;
import Domain.Spieler;
import Domain.Enums.Geschlecht;
import Domain.Exceptions.EmptyListException;
import Domain.Exceptions.SpielerNotFoundException;
import java.util.Scanner;
public class SpielCLI {
private static final String ANSI_RESET = "\u001B[0m";
private static final String ANSI_GREEN = "\u001B[32m";
private static final String ANSI_RED = "\u001B[31m";
public static final String ANSI_BLUE = "\u001B[34m";
Scanner sc = new Scanner(System.in);
private Spiel spiel;
@ -22,13 +31,15 @@ public class SpielCLI {
}
public void hauptmenue() {
mainloop: while (true) {
System.out.println("Hallo Wanderer");
System.out.println("Was sillst du tun");
System.out.println("--------Hauptmenü--------");
System.out.println("-1- Spiel starten");
System.out.println("-2- Spiel to String");
System.out.println("-3- Exit");
mainloop: while (true) {
print("");
print("--------Hauptmenü--------");
print(ANSI_BLUE + "-1-" + ANSI_RESET + " Spiel starten");
print(ANSI_BLUE + "-2-" + ANSI_RESET + " Spieler hinzufügen");
print(ANSI_BLUE + "-3-" + ANSI_RESET + " Spiel to String");
print(ANSI_BLUE + "-4-" + ANSI_RESET + " Spieler löschen");
print(ANSI_BLUE + "-5-" + ANSI_RESET + " Exit");
int input = 0;
@ -40,12 +51,18 @@ public class SpielCLI {
switch (input) {
case 1:
System.out.println("Noch nicht implementiert.");
spielStarten();
break;
case 2:
System.out.println(spiel.toString());
addSpieler();
break;
case 3:
System.out.println(spiel.toString());
break;
case 4:
spielerLöschen();
break;
case 5:
break mainloop;
case 0:
System.out.println("Diese eingabe ist nicht vergeben.");
@ -54,4 +71,96 @@ public class SpielCLI {
System.out.println("auf wiedersehen!");
}
private void spielStarten() {
this.spiel.starteSpiel();
System.out.println("Noch nicht implementiert.");
}
private void addSpieler() {
int spieler_anzahl = this.spiel.getAlleSpieler().length;
if (spieler_anzahl <= 5) {
System.out.println("Gib den Namen des Spielers an");
String name = sc.nextLine();
System.out.println("Gib das Geschlecht an.");
System.out.println("Männlich (M), Weiblich (W), Divers (D), KI (K)");
String geschlecht = sc.nextLine();
switch (geschlecht) {
case "W":
spiel.addSpieler(name, Geschlecht.W);
break;
case "M":
spiel.addSpieler(name, Geschlecht.M);
break;
case "D":
spiel.addSpieler(name, Geschlecht.D);
break;
case "K":
spiel.addSpieler(name, Geschlecht.KI);
break;
default:
System.out.println("Diese eingabe ist nicht gültig");
break;
}
} else {
System.out.println("Die Maximale Spieleranzahl ist erreicht.");
}
}
private void spielerLöschen() {
if (this.spiel.getAlleSpieler().length >= 1) {
System.out.println("Welchen Spieler willst du löschen?");
System.out.println("Gib die ID des Spielers an.");
String[] spieler = spiel.getAlleSpieler();
for (int i = 0; i < spieler.length; i++) {
System.out.println(spieler[i]);
}
int _id = Integer.parseInt(sc.nextLine());
// System.out.println(_id);
for (String s : spieler) {
if (s.contains("ID: " + _id)) {
System.out.println("Sicher das du " + s + " löschen willst?");
} else {
System.out.println("Diese Spieler ist nicht vorhanden!");
_id = 0;
}
}
boolean valid_choice = false;
while (!valid_choice) {
System.out.println("Ja [j] Nein [n]");
String wahl = sc.nextLine();
switch (wahl) {
case "j":
valid_choice = true;
try {
spiel.removeSpieler(_id);
System.out.println("Spieler löschen erfolgreich!");
} catch (SpielerNotFoundException | EmptyListException | RuntimeException e) {
System.out.println(e.getMessage());
}
break;
case "n":
System.out.println("Spieler löschen abgebrochen!");
valid_choice = true;
break;
default:
System.out.println("Diese Auswhal ist nicht gültig");
}
}
} else {
System.out.println("Es existieren keine Spieler zum löschen.");
}
}
private void print(String message) {
System.out.println(message);
}
}