forked from 2211945/WIZARD_PR2_DOP
Merge branch 'main' into iss#6
commit
9fa2f7f4ae
|
|
@ -10,3 +10,5 @@
|
|||
# Jar dateien
|
||||
/lib
|
||||
.idea
|
||||
/Main.class
|
||||
/RendomTest.class
|
||||
|
|
|
|||
|
|
@ -0,0 +1,3 @@
|
|||
{
|
||||
"editor.defaultFormatter": "esbenp.prettier-vscode"
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 951 KiB |
|
|
@ -20,4 +20,9 @@ public enum Kartenfarbe {
|
|||
return farbe;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return getFarbe();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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)
|
||||
/*------------------------------------------*/
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
/*------------------------------------------*/
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
/*------------------------------------------*/
|
||||
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
|
|
@ -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());
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,8 +8,6 @@ package Test.Domain;
|
|||
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public class KartenstapelTest {
|
||||
|
||||
@Test
|
||||
|
|
|
|||
|
|
@ -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
125
UI/SpielCLI.java
|
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue