2210892
/
WIZARD_PR2_DOP22
forked from 2211945/WIZARD_PR2_DOP
1
0
Fork 0
Code Pull Requests Activity

Merge branch 'main' into iss#6

Kai Sellmann 2023-11-07 10:37:16 +01:00
parent 4b4ebbfbe4 f13e1208ba
commit 9fa2f7f4ae
24 changed files with 855 additions and 172 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.

2
.gitignore vendored
View File

@ -10,3 +10,5 @@
# Jar dateien
/lib
.idea
/Main.class
/RendomTest.class

3
.vscode/settings.json vendored 100644
View File

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

BIN
Bild 2.jpeg 100644
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 951 KiB

BIN
Bild.jpeg 100644
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 948 KiB

7
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;
}
@ -20,4 +20,9 @@ public enum Kartenfarbe {
return farbe;
}
@Override
public String toString() {
return getFarbe();
}
}

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

47
Domain/Karten/Magierkarte.java
View File

@ -10,47 +10,44 @@ import Domain.Enums.Kartenfarbe;
public class Magierkarte extends Karte {
// Statische Konstanten
private final static String NAME = "Zauberer";
// Statische Attribute
// Attribute des Objekts
private Kartenfarbe farbe;
private String bezeichnung;
private String name;
// Konstruktoren
public Magierkarte() {
super();
}
public Magierkarte(int id) {
super(id);
setName();
public Magierkarte(Kartenfarbe farbe, String bezeichnung) {
super();
setFarbe(farbe);
setBezeichnung(bezeichnung);
}
// Statische Methoden
// Getter und Setter
public void setFarbe(Kartenfarbe farbe) {
this.farbe = farbe;
}
public Kartenfarbe getFarbe() {
return this.farbe;
}
public int getId() {
return Karte.getId_card();
return super.getId();
}
public void setBezeichnung(String bezeichnung) {
this.bezeichnung = bezeichnung;
}
public String getBezeichnung () {
return this.bezeichnung;
}
// @Overrides
private void setName() {
this.name = NAME;
}
public String getName() {
return this.name;
}
// @Overrides
@Override
public String toString() {
return "ID " + this.getId() + ": " + this.getName();
}
// Public Methoden
// Private Methoden

41
Domain/Karten/Narrenkarte.java
View File

@ -11,45 +11,44 @@ import Domain.Enums.Kartenfarbe;
public class Narrenkarte extends Karte {
// Statische Konstanten
private final static String NAME = "Narr";
// Statische Attribute
// Attribute des Objekts
private Kartenfarbe farbe;
private String bezeichnung;
private String name;
// Konstruktoren
public Narrenkarte() {
super();
}
public Narrenkarte(int id) {
super(id);
setName();
public Narrenkarte(Kartenfarbe farbe, String bezeichnung) {
super();
setFarbe(farbe);
setBezeichnung(bezeichnung);
}
// Statische Methoden
// Getter und Setter
public int getId() {
return Karte.getId_card();
return super.getId();
}
public void setFarbe(Kartenfarbe farbe) {
this.farbe = farbe;
}
public Kartenfarbe getFarbe() {
return this.farbe;
private void setName() {
this.name = NAME;
}
public void setBezeichnung(String bezeichnung) {
this.bezeichnung = bezeichnung;
public String getName() {
return this.name;
}
public String getBezeichnung() {
return this.bezeichnung;
public void setNarrenkarteanzahl(int narrenkarteanzahl) {
narrenkarteanzahl++;
}
// @Overrides
@Override
public String toString() {
return "ID " + this.getId() + ": " + this.getName();
}
// Public Methoden
// Private Methoden

33
Domain/Karten/Zahlenkarte.java
View File

@ -6,6 +6,8 @@ written on: 05 / 10 / 2023 at: 23:30
*/
package Domain.Karten;
import Domain.Enums.Kartenfarbe;
public class Zahlenkarte extends Karte {
/*------------------------------------------*/
@ -19,11 +21,22 @@ public class Zahlenkarte extends Karte {
/*------------------------------------------*/
// Attribute jedes Objektes
/*------------------------------------------*/
private Kartenfarbe farbe;
private int kartenNummer;
/*------------------------------------------*/
// Konstruktoren (default und spezifische)
/*------------------------------------------*/
public Zahlenkarte(int id) {
super(id);
}
public Zahlenkarte(int id, Kartenfarbe farbe, int kartenNummer) {
super(id);
setFarbe(farbe);
setKartenNummer(kartenNummer);
}
/*------------------------------------------*/
// statische Methoden
/*------------------------------------------*/
@ -32,6 +45,26 @@ public class Zahlenkarte extends Karte {
// Getter und Setter
/*------------------------------------------*/
public int getId() {
return super.getId();
}
public void setFarbe(Kartenfarbe farbe) {
this.farbe = farbe;
}
public Kartenfarbe getFarbe() {
return farbe;
}
public void setKartenNummer(int kartenNummer) {
this.kartenNummer = kartenNummer;
}
public int getKartenNummer() {
return kartenNummer;
}
/*------------------------------------------*/
// @Overrides
/*------------------------------------------*/

150
Domain/Kartenstapel.java
View File

@ -6,74 +6,142 @@ written on: 05 / 10 / 2023 at: 23:42
*/
package Domain;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Random;
import java.util.HashMap;
import Domain.Enums.Kartenfarbe;
import Domain.Karten.*;
public class Kartenstapel {
/*------------------------------------------*/
// statische Konstanten
/*------------------------------------------*/
// Statische Konstanten
/*------------------------------------------*/
// statische Attribute(zB. zähler)
/*------------------------------------------*/
// Statische Attribute
private static int kartenzählen = 1;
// Attribute der Objekte
/*------------------------------------------*/
// Attribute jedes Objektes
/*------------------------------------------*/
/**
* Die HashMap besitzt alle Karten in sortierter Reihenfolge Die ArrayList wird
* durch Zufall erzeugt und gibt den Key der HashMap wieder. D.h.
*/
private HashMap<Integer, Karte> kartensortiert = new HashMap<>();
private Karte[] kartenStapel = new Karte[60];
/*------------------------------------------*/
// Konstruktoren (default und spezifische)
/*------------------------------------------*/
private HashMap<Integer, Karte> kartengemischt = new HashMap<>();
// Konstruktoren
public Kartenstapel() {
kartensortiert.clear();
// Erstelle Magierkarten
for (int i = 1; i <= 4; i++) {
kartensortiert.put(i, new Magierkarte(i));
}
// Erstelle Narrenkarten
for (int i = 5; i <= 8; i++) {
kartensortiert.put(i, new Narrenkarte(i));
}
// Erstelle Charakterkarten MENSCH
for (int i = 9; i <= 21; i++) {
kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.MENSCH, i - 8));
}
// Erstelle Charakterkarten ELF
for (int i = 22; i <= 34; i++) {
kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ELF, i - 21));
}
// Erstelle Charakterkarten RIESE
for (int i = 35; i <= 47; i++) {
kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.RIESE, i - 34));
}
// Erstelle Charakterkarten ZWERG
for (int i = 48; i <= 60; i++) {
kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47));
}
/*------------------------------------------*/
// statische Methoden
/*------------------------------------------*/
/*------------------------------------------*/
}
// Statische Methoden
// Getter und Setter
/*------------------------------------------*/
public Karte getKartesortiert(Integer index) {
return kartensortiert.get(index);
}
// Overrides
// Public Methoden
/**
* Ausgabe des ersten Elements des Stapels.
* Die Collection der HashMap 'kartensortiert'.
*
* @return erstes Element
* @return Die Kartenreferenzen der HashMap.
*/
public Karte getObersteKarte() {
return kartenStapel[0];
public Collection<Karte> getKartenstapelSortiert() {
return kartensortiert.values();
}
public Collection<Karte> getKartenstapelGemischt() {
return kartengemischt.values();
}
/**
* Ausgabe der Stapelgroesse.
* Methode für die Testklasse KartenstapelTest, um die Sortierung Visuell zu
* bestätigen. Kann nach Finalem Test und Freigabe gelöscht oder auskommentiert
* werden.
*
* @return laenge des Kartenstapels-Arrays
* @return 'kg' Eine Namensliste des gemischten Kartenstapel
*/
public int getAnzahlKarten() {
return kartenStapel.length;
public HashMap<Integer, String> getStatusGemischt() {
HashMap<Integer, String> kg = new HashMap<>();
for (int i = 1; i <= 60; i++) {
kg.put(i, ((String) kartengemischt.get(i).toString()));
}
return kg;
}
/*------------------------------------------*/
// @Overrides
/*------------------------------------------*/
/*------------------------------------------*/
// öffentliche Methoden
/*------------------------------------------*/
/**
* Methode mischen(): beinhaltet eine ArrayList 'zahlen' die Zahlenwerte von 1
* bis 60 zur Verfügung stellt.
*
* @code Mit Random wird ein Zufallsindex gewählt. 'kartensortiert' und
* 'kartengemsicht' sind zwei HashMap. 'kartensortiert' beinhaltet alle
* Karten in einer initialisierten Reihenfolge. 'kartengemischt' wird
* durch die @code Random 'zufall' befüllt.
*
*/
public void mischen() {
ArrayList<Integer> zahlen = new ArrayList<>();
for (int i = 1; i <= 60; i++) {
zahlen.add(i);
}
Random zufall = new Random();
for (int i = 0; i < 60; i++) {
int index = zufall.nextInt(zahlen.size());
int schlüsselzahl = zahlen.get(index);
kartengemischt.put(i + 1, kartensortiert.get(schlüsselzahl));
zahlen.remove(index);
}
/*------------------------------------------*/
// Hilfsmethoden (privat)
/*------------------------------------------*/
for(Karte k : kartengemischt.values()) {
System.out.println(k.toString());
}
}
//
/**
* Methode getObersteKarte(): Hier wird der Reihe nach die jeweils oberste Karte
* an den Spieler verteilt, bzw. am Ende des Verteilens der Trumpf gezogen,
* falls noch eine Karte auf dem Stapel liegen sollte. Hierzu wird die Runde,
* als Ausgangswert genommen.
*/
public Object getObersteKarte() {
Object k = kartengemischt.values().toArray()[0];
kartengemischt.remove(k);
return k;
}
/**
*
*/
// Private Methoden
}

19
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
@ -23,10 +23,11 @@ public class Spieler implements Serializable {
/*------------------------------------------*/
// Attribute jedes Objektes
/*------------------------------------------*/
private int id;
private int id = 0;
private String name;
private int vorhersage;
private Geschlecht geschlecht;
//
/*------------------------------------------*/
// Konstruktoren (default und spezifische)
@ -48,8 +49,18 @@ public class Spieler implements Serializable {
*/
public Spieler(int id, String name, Geschlecht geschlecht) {
this();
if (id < 6) {
setId(id);
setName(name);
} 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) {
setName(name); // Es wird geprüft, ob Name größer 2 Zeichen
} else {
throw new RuntimeException("Der Name muss länger als 2 Buchstaben sein.");
}
setGeschlecht(geschlecht);
}
@ -109,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
}

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

@ -6,6 +6,35 @@ written on: 10 / 10 / 2023 at: 21:18
*/
package Test.Domain.Karten;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import Domain.Karten.Magierkarte;
public class MagierkarteTest {
@Test
public void vierMagier() {
Magierkarte m1 = new Magierkarte(1);
Magierkarte m2 = new Magierkarte(2);
Magierkarte m3 = new Magierkarte(3);
Magierkarte m4 = new Magierkarte(4);
assertEquals("Zauberer", m1.getName());
assertTrue(1 == m1.getId());
assertEquals("Zauberer", m2.getName());
assertTrue(2 == m2.getId());
assertEquals("Zauberer", m3.getName());
assertTrue(3 == m3.getId());
assertEquals("Zauberer", m4.getName());
assertTrue(4 == m4.getId());
assertEquals("ID 1: Zauberer", m1.toString());
}
}

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

@ -6,6 +6,34 @@ written on: 10 / 10 / 2023 at: 21:18
*/
package Test.Domain.Karten;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import Domain.Karten.Narrenkarte;
public class NarrenkarteTest {
@Test
public void vierNarren() {
Narrenkarte n1 = new Narrenkarte(5);
Narrenkarte n2 = new Narrenkarte(6);
Narrenkarte n3 = new Narrenkarte(7);
Narrenkarte n4 = new Narrenkarte(8);
assertEquals(n1.getName(), "Narr");
assertTrue(5 == n1.getId());
assertEquals(n2.getName(), "Narr");
assertTrue(6 == n2.getId());
assertEquals(n3.getName(), "Narr");
assertTrue(7 == n3.getId());
assertEquals(n4.getName(), "Narr");
assertTrue(8 == n4.getId());
assertEquals("ID 5: Narr", n1.toString());
}
}

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

@ -6,6 +6,82 @@ written on: 10 / 10 / 2023 at: 21:18
*/
package Test.Domain.Karten;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.HashMap;
import org.junit.Test;
import org.junit.jupiter.api.BeforeAll;
import Domain.Enums.Kartenfarbe;
import Domain.Karten.Karte;
import Domain.Karten.Zahlenkarte;
public class ZahlenkarteTest {
@Test
public void zahlenkartentesten() {
HashMap<Integer, Karte> zk = new HashMap<>();
for (int i = 1; i <= 8; i++) {
zk.put(i, null);
}
for (int i = 9; i <= 21; i++) {
zk.put(i, new Zahlenkarte(i, Kartenfarbe.MENSCH, i - 8));
}
for (int i = 22; i <= 34; i++) {
zk.put(i, new Zahlenkarte(i, Kartenfarbe.ELF, i - 21));
}
for (int i = 35; i <= 47; i++) {
zk.put(i, new Zahlenkarte(i, Kartenfarbe.RIESE, i - 34));
}
for (int i = 48; i <= 60; i++) {
zk.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47));
}
// Testen der Charakterkarten MENSCH
assertEquals(1, ((Zahlenkarte) zk.get(9)).getKartenNummer());
assertEquals(13, ((Zahlenkarte) zk.get(21)).getKartenNummer());
assertEquals(5, ((Zahlenkarte) zk.get(13)).getKartenNummer());
assertEquals(17, ((Zahlenkarte) zk.get(17)).getId());
assertTrue(Kartenfarbe.MENSCH == ((Zahlenkarte) zk.get(17)).getFarbe());
// Testen der Charakterkarten ELF
assertEquals(1, ((Zahlenkarte) zk.get(22)).getKartenNummer());
assertEquals(13, ((Zahlenkarte) zk.get(34)).getKartenNummer());
assertEquals(11, ((Zahlenkarte) zk.get(32)).getKartenNummer());
assertEquals(28, ((Zahlenkarte) zk.get(28)).getId());
assertTrue(Kartenfarbe.ELF == ((Zahlenkarte) zk.get(28)).getFarbe());
// Testen der Charakterkarten RIESE
assertEquals(1, ((Zahlenkarte) zk.get(35)).getKartenNummer());
assertEquals(13, ((Zahlenkarte) zk.get(47)).getKartenNummer());
assertEquals(3, ((Zahlenkarte) zk.get(37)).getKartenNummer());
assertEquals(41, ((Zahlenkarte) zk.get(41)).getId());
assertTrue(Kartenfarbe.RIESE == ((Zahlenkarte) zk.get(41)).getFarbe());
// Testen der Charakterkarten ZWERG
assertEquals(1, ((Zahlenkarte) zk.get(48)).getKartenNummer());
assertEquals(13, ((Zahlenkarte) zk.get(60)).getKartenNummer());
assertEquals(6, ((Zahlenkarte) zk.get(53)).getKartenNummer());
assertEquals(53, ((Zahlenkarte) zk.get(53)).getId());
assertTrue(Kartenfarbe.ZWERG == ((Zahlenkarte) zk.get(53)).getFarbe());
}
}

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

12
Test/Domain/SpielerTest.java
View File

@ -12,18 +12,25 @@ import Domain.Spieler;
import Domain.Enums.Geschlecht;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
public class SpielerTest {
Spieler spieler = new Spieler(0, "Herbert", Geschlecht.M, 0);
Spieler spieler2 = new Spieler(1, "Heinz", Geschlecht.M, 0);
Spieler spieler3 = new Spieler(2, "Ulrike", Geschlecht.W, 0);
Spieler spieler4 = new Spieler(3, "HerrFrau", Geschlecht.D, 0);
Spieler spieler5 = new Spieler(4, "", Geschlecht.KI, 0);
Spieler spieler6 = new Spieler(5, "", Geschlecht.KI, 0);
@Test
public void idTest() {
assertEquals(0, spieler.getId());
assertEquals(1, spieler2.getId());
assertEquals(2, spieler3.getId());
assertEquals(3, spieler4.getId());
assertEquals(4, spieler5.getId());
assertEquals(5, spieler6.getId());
}
@Test
@ -42,6 +49,11 @@ public class SpielerTest {
assertEquals("Herbert", spieler.getName());
spieler.setName("Heinz");
assertEquals("Heinz", spieler.getName());
assertEquals("", spieler5.getName()); //Kein Name notwendig, da KI.
}
@Test
public void exceptionsTest() {
assertThrows(RuntimeException.class, () -> new Spieler(6, "", Geschlecht.KI, 0));
}
}

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