Compare commits
2 Commits
| Author | SHA1 | Date |
|---|---|---|
Philipp Kotte
|
c42fab25f6 | |
|
Philipp Kotte
|
fcce799d32 |
|
|
@ -10,5 +10,3 @@
|
|||
# Jar dateien
|
||||
/lib
|
||||
.idea
|
||||
/Main.class
|
||||
/RendomTest.class
|
||||
|
|
|
|||
|
|
@ -6,24 +6,13 @@ written on: 05 / 10 / 2023 at: 23:43
|
|||
*/
|
||||
package Domain.Block;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class Block {
|
||||
private ArrayList<Blockzeile> zeilen;
|
||||
public void addZeile(){
|
||||
|
||||
public Block(){
|
||||
this.zeilen = new ArrayList<>();
|
||||
}
|
||||
|
||||
public void addZeile(Blockzeile blockzeile) {
|
||||
zeilen.add(blockzeile);
|
||||
}
|
||||
|
||||
public Blockzeile[] getDaten() {
|
||||
if(zeilen.isEmpty()){
|
||||
System.out.println("Die Liste der Blockzeilen ist Leer. ");
|
||||
return zeilen.toArray(new Blockzeile[0]);
|
||||
}
|
||||
return zeilen.toArray(new Blockzeile[0]);
|
||||
return null;
|
||||
}
|
||||
//neues Kommentar
|
||||
}
|
||||
|
|
@ -6,25 +6,17 @@ written on: 05 / 10 / 2023 at: 23:44
|
|||
*/
|
||||
package Domain.Block;
|
||||
|
||||
import Domain.Spieler;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
public class Blockeintrag {
|
||||
private int punkte;
|
||||
private int stiche;
|
||||
private Spieler id;
|
||||
public int punkte;
|
||||
public int stiche;
|
||||
|
||||
public Blockeintrag() {
|
||||
|
||||
}
|
||||
|
||||
public Blockeintrag(int punkte, int stiche, Spieler id) {
|
||||
if(stiche < 0){
|
||||
throw new IllegalArgumentException("Ihre Stiche dürfen nicht im Negativen bereich sein");
|
||||
}
|
||||
this.stiche = stiche;
|
||||
public Blockeintrag(int punkte, int stiche) {
|
||||
this.punkte = punkte;
|
||||
this.id = id;
|
||||
this.stiche = stiche;
|
||||
}
|
||||
|
||||
public int getPunkte() {
|
||||
|
|
@ -36,9 +28,6 @@ public class Blockeintrag {
|
|||
}
|
||||
|
||||
public void setStiche(int stiche) {
|
||||
if (stiche < 0){
|
||||
throw new IllegalArgumentException("Ihre Stich dürfen nicht im Negative bereich sein");
|
||||
}
|
||||
this.stiche = stiche;
|
||||
}
|
||||
|
||||
|
|
@ -46,31 +35,4 @@ public class Blockeintrag {
|
|||
this.punkte = punkte;
|
||||
}
|
||||
|
||||
public Spieler getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object ob){
|
||||
if (this == ob) {
|
||||
return true;
|
||||
}
|
||||
if (ob == null || getClass() != ob.getClass()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
Blockeintrag andererEintrag = (Blockeintrag) ob;
|
||||
return this.punkte == andererEintrag.punkte && this.stiche == andererEintrag.stiche
|
||||
&& Objects.equals(this.id, andererEintrag.id);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return Objects.hash(punkte, stiche, id);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return getPunkte() + ", S: " + getStiche() + " | ";
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,8 +6,6 @@ written on: 05 / 10 / 2023 at: 23:44
|
|||
*/
|
||||
package Domain.Block;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class Blockzeile {
|
||||
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -23,21 +21,17 @@ public class Blockzeile {
|
|||
/*------------------------------------------*/
|
||||
|
||||
private int rundenNummer;
|
||||
private ArrayList<Blockeintrag> eintraege;
|
||||
private Blockeintrag[] eintraege;
|
||||
|
||||
/*------------------------------------------*/
|
||||
// Konstruktoren (default und spezifische)
|
||||
/*------------------------------------------*/
|
||||
|
||||
public Blockzeile(){
|
||||
|
||||
}
|
||||
|
||||
public Blockzeile(int rundenNummer, Blockeintrag eintrag) {
|
||||
public Blockzeile(int rundenNummer, int spielerAnzahl) {
|
||||
this.rundenNummer = rundenNummer;
|
||||
this.eintraege = new ArrayList<>();
|
||||
addEintrag(eintrag);
|
||||
this.eintraege = new Blockeintrag[spielerAnzahl];
|
||||
}
|
||||
|
||||
/*------------------------------------------*/
|
||||
// statische Methoden
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -45,13 +39,7 @@ public class Blockzeile {
|
|||
/*------------------------------------------*/
|
||||
// Getter und Setter
|
||||
/*------------------------------------------*/
|
||||
public int getRundenNummer() {
|
||||
return rundenNummer;
|
||||
}
|
||||
|
||||
public void setRundenNummer(int rundenNummer) {
|
||||
this.rundenNummer = rundenNummer;
|
||||
}
|
||||
/*------------------------------------------*/
|
||||
// @Overrides
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -60,27 +48,21 @@ public class Blockzeile {
|
|||
// öffentliche Methodes
|
||||
/*------------------------------------------*/
|
||||
|
||||
public void addEintrag(Blockeintrag eintrag) {
|
||||
if(eintraege != null){
|
||||
eintraege.add(eintrag);
|
||||
public void addEintrag(Blockeintrag be) {
|
||||
|
||||
for (int i = 0; i < eintraege.length; i++) {
|
||||
if (eintraege[i] == null) {
|
||||
eintraege[i] = be;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Blockeintrag[] getDaten() {
|
||||
return eintraege.toArray(new Blockeintrag[0]);
|
||||
return eintraege;
|
||||
}
|
||||
|
||||
/*------------------------------------------*/
|
||||
// Hilfsmethoden (privat)
|
||||
/*------------------------------------------*/
|
||||
|
||||
public Blockeintrag[] getValidDaten() {
|
||||
Blockeintrag[] dataArray = getDaten();
|
||||
|
||||
for (Blockeintrag eintrag : dataArray) {
|
||||
if (eintrag == null) {
|
||||
throw new IllegalStateException("Das Array ist leer");
|
||||
}
|
||||
}
|
||||
return dataArray;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,14 @@
|
|||
/*
|
||||
============================================================
|
||||
This is the "MagierTrumpfException" file from Author: Philipp Kotte
|
||||
written on: 26 / 10 / 2023 at: 15:35
|
||||
============================================================
|
||||
*/
|
||||
package Domain.Exceptions;
|
||||
|
||||
public class MagierTrumpfException extends SpielException {
|
||||
|
||||
public MagierTrumpfException(String message) {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
/*
|
||||
============================================================
|
||||
This is the "NarrenTrumpfException" file from Author: Philipp Kotte
|
||||
written on: 26 / 10 / 2023 at: 15:38
|
||||
============================================================
|
||||
*/
|
||||
package Domain.Exceptions;
|
||||
|
||||
public class NarrenTrumpfException extends SpielException {
|
||||
|
||||
public NarrenTrumpfException(String message) {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
|
|
@ -28,11 +28,12 @@ public abstract class SpielException extends Exception {
|
|||
}
|
||||
|
||||
public SpielException(int id, String message) {
|
||||
|
||||
this.message = message;
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public SpielException(String message) {
|
||||
|
||||
this.message = message;
|
||||
}
|
||||
|
||||
/*------------------------------------------*/
|
||||
|
|
|
|||
|
|
@ -6,7 +6,9 @@ written on: 05 / 10 / 2023 at: 23:28
|
|||
*/
|
||||
package Domain.Karten;
|
||||
|
||||
public abstract class Karte {
|
||||
import java.io.Serializable;
|
||||
|
||||
public abstract class Karte implements Serializable {
|
||||
|
||||
// Statische Konstanten
|
||||
|
||||
|
|
|
|||
|
|
@ -69,6 +69,11 @@ public class Zahlenkarte extends Karte {
|
|||
// @Overrides
|
||||
/*------------------------------------------*/
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "ID: " + this.getId() + " Typ: " + this.getFarbe() + " Wert: " + this.getKartenNummer();
|
||||
}
|
||||
|
||||
/*------------------------------------------*/
|
||||
// öffentliche Methodes
|
||||
/*------------------------------------------*/
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ written on: 05 / 10 / 2023 at: 23:42
|
|||
*/
|
||||
package Domain;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
|
@ -14,8 +15,7 @@ import java.util.HashMap;
|
|||
import Domain.Enums.Kartenfarbe;
|
||||
import Domain.Karten.*;
|
||||
|
||||
|
||||
public class Kartenstapel {
|
||||
public class Kartenstapel implements Serializable {
|
||||
|
||||
// Statische Konstanten
|
||||
|
||||
|
|
@ -29,7 +29,7 @@ public class Kartenstapel {
|
|||
*/
|
||||
private HashMap<Integer, Karte> kartensortiert = new HashMap<>();
|
||||
|
||||
private HashMap<Integer, Karte> kartengemischt = new HashMap<>();
|
||||
private ArrayList<Karte> kartengemischt = new ArrayList<>();
|
||||
|
||||
// Konstruktoren
|
||||
public Kartenstapel() {
|
||||
|
|
@ -59,7 +59,6 @@ public class Kartenstapel {
|
|||
kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47));
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
// Statische Methoden
|
||||
|
||||
|
|
@ -80,7 +79,7 @@ public class Kartenstapel {
|
|||
}
|
||||
|
||||
public Collection<Karte> getKartenstapelGemischt() {
|
||||
return kartengemischt.values();
|
||||
return kartengemischt;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -117,13 +116,9 @@ public class Kartenstapel {
|
|||
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));
|
||||
kartengemischt.add(kartensortiert.get(schlüsselzahl));
|
||||
zahlen.remove(index);
|
||||
}
|
||||
|
||||
for(Karte k : kartengemischt.values()) {
|
||||
System.out.println(k.toString());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -132,13 +127,12 @@ public class Kartenstapel {
|
|||
* 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);
|
||||
public Karte getObersteKarte() {
|
||||
Karte k = kartengemischt.get(0);
|
||||
kartengemischt.remove(0);
|
||||
return k;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -7,8 +7,11 @@ written on: 05 / 10 / 2023 at: 23:48
|
|||
package Domain;
|
||||
|
||||
import Domain.Enums.Geschlecht;
|
||||
import Domain.Karten.Karte;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class Spieler extends Object implements Serializable {
|
||||
|
||||
|
|
@ -27,6 +30,7 @@ public class Spieler extends Object implements Serializable {
|
|||
private String name;
|
||||
private int vorhersage;
|
||||
private Geschlecht geschlecht;
|
||||
private ArrayList<Karte> karten = new ArrayList<>();
|
||||
//
|
||||
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -163,6 +167,14 @@ public class Spieler extends Object implements Serializable {
|
|||
return vorhersage;
|
||||
}
|
||||
|
||||
public void addKarte(Karte k) {
|
||||
this.karten.add(k);
|
||||
}
|
||||
|
||||
public Karte[] getHandKarte() {
|
||||
return (Karte[]) this.karten.toArray();
|
||||
}
|
||||
|
||||
/*------------------------------------------*/
|
||||
// @Overrides
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -176,7 +188,13 @@ public class Spieler extends Object implements Serializable {
|
|||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return "ID: " + this.id + " Name: " + this.name + " (" + this.geschlecht + ")";
|
||||
String temp = "";
|
||||
temp += "ID: " + this.getId() + "\n";
|
||||
temp += "Name: " + this.getName() + "(" + this.getGeschlecht() + ")" + "\n";
|
||||
for (Karte k : this.karten) {
|
||||
temp += k.toString() + "\n";
|
||||
}
|
||||
return temp;
|
||||
}
|
||||
|
||||
/*------------------------------------------*/
|
||||
|
|
|
|||
|
|
@ -6,9 +6,13 @@ written on: 11 / 10 / 2023 at: 20:25
|
|||
*/
|
||||
package Domain;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
|
||||
import Domain.Enums.Kartenfarbe;
|
||||
import Domain.Karten.Karte;
|
||||
|
||||
public class Stich {
|
||||
public class Stich implements Serializable {
|
||||
/*------------------------------------------*/
|
||||
// statische Konstanten
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -20,9 +24,8 @@ public class Stich {
|
|||
/*------------------------------------------*/
|
||||
// Attribute jedes Objektes
|
||||
/*------------------------------------------*/
|
||||
private Karte[] karten;
|
||||
private int[] spielerID;
|
||||
private int kartenCount = 0;
|
||||
private ArrayList<Karte> karten;
|
||||
private Kartenfarbe trumpfFarbe;
|
||||
/*------------------------------------------*/
|
||||
// Konstruktoren (default und spezifische)
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -34,6 +37,11 @@ public class Stich {
|
|||
setSpielerAnzahl(spielerAnzahl);
|
||||
}
|
||||
|
||||
public Stich(int spielerAnzahl, Kartenfarbe trumpKartenfarbe) {
|
||||
setSpielerAnzahl(spielerAnzahl);
|
||||
setTurmpfFarbe(trumpKartenfarbe);
|
||||
}
|
||||
|
||||
/*------------------------------------------*/
|
||||
// statische Methoden
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -43,18 +51,19 @@ public class Stich {
|
|||
/*------------------------------------------*/
|
||||
|
||||
public void setSpielerAnzahl(int spielerAnzahl) {
|
||||
this.karten = new Karte[spielerAnzahl];
|
||||
this.spielerID = new int[spielerAnzahl];
|
||||
this.karten = new ArrayList<>(spielerAnzahl);
|
||||
}
|
||||
|
||||
public Karte[] getKarten() {
|
||||
return this.karten;
|
||||
public void setTurmpfFarbe(Kartenfarbe trumpfFarbe) {
|
||||
this.trumpfFarbe = trumpfFarbe;
|
||||
}
|
||||
|
||||
public Kartenfarbe getTrumpfFarbe() {
|
||||
return this.trumpfFarbe;
|
||||
}
|
||||
|
||||
public void addKarte(int spielerID, Karte karte) {
|
||||
this.karten[kartenCount] = karte;
|
||||
this.spielerID[kartenCount] = spielerID;
|
||||
kartenCount++;
|
||||
this.karten.add(karte);
|
||||
}
|
||||
|
||||
/*------------------------------------------*/
|
||||
|
|
@ -64,8 +73,8 @@ public class Stich {
|
|||
@Override
|
||||
public String toString() {
|
||||
String text = "";
|
||||
for (int i = 0; i < this.karten.length; i++) {
|
||||
text += this.karten[i].toString();
|
||||
for (int i = 0; i < this.karten.size(); i++) {
|
||||
text += this.karten.get(i).toString();
|
||||
}
|
||||
|
||||
return text;
|
||||
|
|
|
|||
|
|
@ -7,16 +7,25 @@ written on: 05 / 10 / 2023 at: 23:25
|
|||
package Facade;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.Scanner;
|
||||
|
||||
import Domain.Kartenstapel;
|
||||
import Domain.Spieler;
|
||||
import Domain.Stich;
|
||||
import Domain.Block.Block;
|
||||
import Domain.Enums.Geschlecht;
|
||||
import Domain.Enums.Kartenfarbe;
|
||||
import Domain.Exceptions.EmptyListException;
|
||||
import Domain.Exceptions.MagierTrumpfException;
|
||||
import Domain.Exceptions.NarrenTrumpfException;
|
||||
import Domain.Exceptions.SpielerNotFoundException;
|
||||
import Domain.Karten.Karte;
|
||||
import Domain.Karten.Magierkarte;
|
||||
import Domain.Karten.Narrenkarte;
|
||||
import Domain.Karten.Zahlenkarte;
|
||||
|
||||
public class Spiel implements Serializable {
|
||||
|
||||
|
|
@ -41,8 +50,8 @@ public class Spiel implements Serializable {
|
|||
private boolean istBeendet;
|
||||
private Spieler spielerAmZug;
|
||||
private int runde;
|
||||
private HashMap<Integer, Spieler> spieler = new HashMap<>();
|
||||
private HashMap<Integer, Stich> stiche = new HashMap<>();
|
||||
private ArrayList<Spieler> spieler = new ArrayList<>();
|
||||
private ArrayList<Stich> stiche = new ArrayList<>();
|
||||
private boolean[] id_check = { false, false, false, false, false, false };
|
||||
private Kartenstapel kartenstapel;
|
||||
private Block block;
|
||||
|
|
@ -55,16 +64,15 @@ public class Spiel implements Serializable {
|
|||
this.istGestartet = false;
|
||||
this.istBeendet = false;
|
||||
this.spielerAmZug = null;
|
||||
this.runde = 0;
|
||||
this.runde = 1;
|
||||
this.kartenstapel = new Kartenstapel();
|
||||
};
|
||||
/*--------------------------------------------------------*/
|
||||
// statische Methoden
|
||||
/*--------------------------------------------------------*/
|
||||
|
||||
/*--------------------------------------------------------*/
|
||||
// Getter und Setter
|
||||
/*--------------------------------------------------------*/
|
||||
/*--------------------------------------------------------
|
||||
statische Methoden
|
||||
--------------------------------------------------------*/
|
||||
/*--------------------------------------------------------
|
||||
Getter und Setter
|
||||
--------------------------------------------------------*/
|
||||
|
||||
public void setSpielGestartet(boolean gestarted) {
|
||||
this.istGestartet = gestarted;
|
||||
|
|
@ -82,9 +90,9 @@ public class Spiel implements Serializable {
|
|||
this.spielerAmZug = spieler;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------*/
|
||||
// @Overrides
|
||||
/*--------------------------------------------------------*/
|
||||
/*--------------------------------------------------------
|
||||
@Overrides
|
||||
--------------------------------------------------------*/
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
|
|
@ -100,7 +108,7 @@ public class Spiel implements Serializable {
|
|||
if (this.spieler.size() == 0) {
|
||||
text += "Noch keine Spieler vorhanden \n";
|
||||
} else {
|
||||
for (Spieler s : this.spieler.values()) {
|
||||
for (Spieler s : this.spieler) {
|
||||
text += "[" + s.getId() + "] " + s.getName() + " ("
|
||||
+ s.getGeschlecht() + ")" + "\n";
|
||||
|
||||
|
|
@ -118,9 +126,9 @@ public class Spiel implements Serializable {
|
|||
return text;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------*/
|
||||
// öffentliche Methodes
|
||||
/*--------------------------------------------------------*/
|
||||
/*--------------------------------------------------------
|
||||
öffentliche Methodes
|
||||
--------------------------------------------------------*/
|
||||
|
||||
public void addSpieler(String name, Geschlecht geschlecht) {
|
||||
int id = 1;
|
||||
|
|
@ -129,21 +137,17 @@ public class Spiel implements Serializable {
|
|||
}
|
||||
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;
|
||||
}
|
||||
this.spieler.add(temp);
|
||||
updateSpielerAmZug();
|
||||
}
|
||||
|
||||
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)) {
|
||||
public void removeSpieler(int index) throws SpielerNotFoundException, EmptyListException, RuntimeException {
|
||||
if (this.spieler.size() >= index) {
|
||||
this.spieler.remove(index);
|
||||
this.id_check[index - 1] = false;
|
||||
} else if (this.spieler.size() < index) {
|
||||
throw new SpielerNotFoundException("Dieser Spieler existiert nicht");
|
||||
} else if (this.spieler.values().size() == 0) {
|
||||
} else if (this.spieler.size() == 0) {
|
||||
throw new EmptyListException("Dise Liste ist Leer.");
|
||||
} else {
|
||||
throw new RuntimeException("Unkown Error");
|
||||
|
|
@ -154,25 +158,30 @@ public class Spiel implements Serializable {
|
|||
public String[] getAlleSpieler() {
|
||||
String[] spieler_text = new String[this.spieler.size()];
|
||||
int zähler = 0;
|
||||
for (Spieler s : this.spieler.values()) {
|
||||
for (Spieler s : this.spieler) {
|
||||
spieler_text[zähler] = s.toString();
|
||||
zähler++;
|
||||
}
|
||||
return spieler_text;
|
||||
}
|
||||
|
||||
public void starteSpiel() {
|
||||
public void starteSpiel() throws MagierTrumpfException, NarrenTrumpfException {
|
||||
// sing genügend Spieler angelegt?
|
||||
if (this.spieler.size() >= 3 && this.spieler.size() <= 6) {
|
||||
this.istGestartet = true;
|
||||
while (!this.istSpielBeendet()) {
|
||||
System.out.println("Das Spiel wurde gestartet.");
|
||||
|
||||
// Beginn der Runde
|
||||
// Stiche erstellen
|
||||
erstelleStiche(this.runde);
|
||||
// Karten für jeden Spieler verteilen
|
||||
|
||||
austeilen();
|
||||
// Karte k = this.kartenstapel.getObersteKarte();
|
||||
Karte k = new Magierkarte(0);
|
||||
if (k instanceof Magierkarte) {
|
||||
throw new MagierTrumpfException("Es wurde ein Magier als Trumpf gezogen");
|
||||
} else if (k instanceof Narrenkarte) {
|
||||
setTrumpf(null);
|
||||
throw new NarrenTrumpfException("Es wurde ein Narr als Trumpf gezogen");
|
||||
} else {
|
||||
Zahlenkarte zk = (Zahlenkarte) k;
|
||||
setTrumpf(zk.getFarbe());
|
||||
}
|
||||
// While loop mit der länge der anzahl Stiche für die jeweilige Runde
|
||||
|
||||
// Für jeden Durchgang des Loops wird der Stich ermittelt
|
||||
|
|
@ -184,22 +193,33 @@ public class Spiel implements Serializable {
|
|||
// 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");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Gibt den Spieler zurück, der am Zug ist.
|
||||
*
|
||||
* @return String[] -> name, id, geschlecht, vorhersage
|
||||
*/
|
||||
public String[] getSpielerAmZug() {
|
||||
return new String[1];
|
||||
Spieler s = this.spielerAmZug;
|
||||
String[] temp = { s.getName(), "" + s.getId(), s.getGeschlecht().toString(), "" + s.getVorhersage() };
|
||||
return temp;
|
||||
}
|
||||
|
||||
public boolean istSpielGestartet() {
|
||||
return this.istGestartet;
|
||||
}
|
||||
|
||||
public void setTrumpf(Kartenfarbe kf) {
|
||||
Stich s = (Stich) this.stiche.get(0);
|
||||
s.setTurmpfFarbe(kf);
|
||||
}
|
||||
|
||||
public boolean istSpielBeendet() {
|
||||
return this.istBeendet;
|
||||
}
|
||||
|
|
@ -216,18 +236,21 @@ public class Spiel implements Serializable {
|
|||
return this.runde;
|
||||
}
|
||||
|
||||
public void mischen() {
|
||||
|
||||
public void austeilen() {
|
||||
this.kartenstapel.mischen();
|
||||
for (int i = 0; i < this.runde; i++) {
|
||||
for (Spieler s : this.spieler) {
|
||||
Karte k = this.kartenstapel.getObersteKarte();
|
||||
if (k instanceof Magierkarte) {
|
||||
s.addKarte(((Magierkarte) k));
|
||||
} else if (k instanceof Zahlenkarte) {
|
||||
s.addKarte(((Zahlenkarte) k));
|
||||
} else {
|
||||
s.addKarte((Narrenkarte) k);
|
||||
}
|
||||
|
||||
public void austeilen() {
|
||||
|
||||
// Spieler 1 bekommt karten
|
||||
|
||||
// Spieler 2 bekommt Karten
|
||||
// ...
|
||||
|
||||
// letzer Spieler bekommt Karten
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -245,20 +268,42 @@ public class Spiel implements Serializable {
|
|||
|
||||
private void erstelleStiche(int runde) {
|
||||
for (int i = 0; i < runde; i++) {
|
||||
this.stiche.put(i + 1, new Stich(this.spieler.size()));
|
||||
this.stiche.add(new Stich(this.spieler.size()));
|
||||
}
|
||||
}
|
||||
|
||||
private void ermittleGewinner(Stich stich) {
|
||||
stich.getKarten();
|
||||
}
|
||||
/*
|
||||
* private void ermittleGewinner(Stich stich) {
|
||||
* stich.getKarten();
|
||||
* }
|
||||
*/
|
||||
|
||||
private void updateSpielerAmZug() {
|
||||
if (this.spieler.size() >= 1) {
|
||||
this.spielerAmZug = (Spieler) this.spieler.values().toArray()[0];
|
||||
this.spielerAmZug = this.spieler.get(0);
|
||||
} else {
|
||||
this.spielerAmZug = null;
|
||||
}
|
||||
}
|
||||
|
||||
private void updateSpielerList(Spieler gewinner) {
|
||||
ArrayList<Spieler> temp = new ArrayList<>(this.spieler.size());
|
||||
int start = 0;
|
||||
for (int i = 0; i < this.spieler.size(); i++) {
|
||||
if (this.spieler.get(i) == gewinner) {
|
||||
start = i;
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = start; i < this.spieler.size(); i++) {
|
||||
temp.add(this.spieler.get(i));
|
||||
}
|
||||
for (int i = 0; i < start; i++) {
|
||||
temp.add(this.spieler.get(i));
|
||||
}
|
||||
|
||||
this.spieler = temp;
|
||||
this.spielerAmZug = temp.get(0);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -6,96 +6,6 @@ written on: 10 / 10 / 2023 at: 21:17
|
|||
*/
|
||||
package Test.Domain.Block;
|
||||
|
||||
import Domain.Block.Block;
|
||||
import Domain.Block.Blockeintrag;
|
||||
import Domain.Block.Blockzeile;
|
||||
import Domain.Enums.Geschlecht;
|
||||
import Facade.Spiel;
|
||||
import org.junit.Test;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static junit.framework.TestCase.assertTrue;
|
||||
|
||||
public class BlockTest {
|
||||
Block block = new Block();
|
||||
Blockeintrag b1 = new Blockeintrag(20,0,null);
|
||||
Blockeintrag b2 = new Blockeintrag(30,1,null);
|
||||
Blockeintrag b3 = new Blockeintrag(40,2,null);
|
||||
Blockeintrag b4 = new Blockeintrag(20,0,null);
|
||||
Blockeintrag b5 = new Blockeintrag(30,1,null);
|
||||
Blockeintrag b6 = new Blockeintrag(40,2,null);
|
||||
|
||||
Blockzeile z1 = new Blockzeile(1,b1);
|
||||
Blockzeile z2 = new Blockzeile(2,b2);
|
||||
Blockzeile z3 = new Blockzeile(3, b3);
|
||||
Blockzeile z4 = new Blockzeile(1,b1);
|
||||
Blockzeile z5 = new Blockzeile(2,b2);
|
||||
Blockzeile z6 = new Blockzeile(3, b3);
|
||||
|
||||
/**
|
||||
* Testet die Methode addZeile in der Block-Klasse.
|
||||
* Überprüft, ob die Anzahl der Zeilen im Block nach dem Hinzufügen korrekt ist
|
||||
* und ob die hinzugefügte Zeile an der richtigen Position im Datenarray steht.
|
||||
*/
|
||||
@Test
|
||||
public void addZeileTest() {
|
||||
block.addZeile(z1);
|
||||
block.addZeile(z2);
|
||||
block.addZeile(z3);
|
||||
|
||||
z1.addEintrag(b1);
|
||||
z1.addEintrag(b2);
|
||||
z1.addEintrag(b3);
|
||||
z2.addEintrag(b1);
|
||||
z2.addEintrag(b2);
|
||||
z2.addEintrag(b3);
|
||||
z3.addEintrag(b1);
|
||||
z3.addEintrag(b2);
|
||||
z3.addEintrag(b3);
|
||||
|
||||
assertEquals(3,block.getDaten().length);
|
||||
assertTrue((z1 == block.getDaten()[0]) &&
|
||||
(z2 == block.getDaten()[1]) && (z3 == block.getDaten()[2]));
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Testet die Methode getDaten der Klasse Block. Überprüft, ob die Daten im
|
||||
* Block korrekt abgerufen werden können.
|
||||
*/
|
||||
@Test
|
||||
public void getDatenTest() {
|
||||
block.addZeile(z4);
|
||||
block.addZeile(z5);
|
||||
block.addZeile(z6);
|
||||
|
||||
z1.addEintrag(b4);
|
||||
z1.addEintrag(b5);
|
||||
z1.addEintrag(b6);
|
||||
z2.addEintrag(b4);
|
||||
z2.addEintrag(b5);
|
||||
z2.addEintrag(b6);
|
||||
z3.addEintrag(b4);
|
||||
z3.addEintrag(b5);
|
||||
z3.addEintrag(b6);
|
||||
|
||||
assertTrue((block.getDaten()[0].getDaten()[0].getPunkte() ==20)
|
||||
&& (block.getDaten()[0].getDaten()[0].getStiche() == 0)
|
||||
&& (block.getDaten()[1].getDaten()[0].getPunkte() == 30)
|
||||
&& (block.getDaten()[1].getDaten()[0].getStiche() == 1)
|
||||
&& (block.getDaten()[2].getDaten()[0].getPunkte() == 40)
|
||||
&& (block.getDaten()[2].getDaten()[0].getStiche() == 2));
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Testet die Methode getDaten der Klasse Block für einen leeren Block.
|
||||
* Überprüft, ob für einen leeren Block ein leeres Datenarray zurückgegeben
|
||||
* wird.
|
||||
*/
|
||||
@Test
|
||||
public void getDatenTestLeererBlock(){
|
||||
Block block2 = new Block();
|
||||
assertEquals(0, block2.getDaten().length);
|
||||
}
|
||||
}
|
||||
|
|
@ -6,39 +6,6 @@ written on: 10 / 10 / 2023 at: 21:17
|
|||
*/
|
||||
package Test.Domain.Block;
|
||||
|
||||
import Domain.Block.Blockeintrag;
|
||||
import org.junit.Test;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static org.junit.Assert.assertThrows;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
public class BlockeintragTest {
|
||||
@Test
|
||||
public void getPunkteTest(){
|
||||
Blockeintrag eintrag = new Blockeintrag(20,0,null);
|
||||
assertTrue((eintrag.getPunkte() == 20));
|
||||
eintrag.setPunkte(30);
|
||||
assertTrue((eintrag.getPunkte() == 30));
|
||||
eintrag.setPunkte(40);
|
||||
assertTrue((eintrag.getPunkte()== 40));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getStiche() {
|
||||
Blockeintrag eintrag = new Blockeintrag(30,1,null);
|
||||
assertEquals(1, eintrag.getStiche());
|
||||
eintrag.setStiche(2);
|
||||
assertEquals(2, eintrag.getStiche());
|
||||
eintrag.setStiche(3);
|
||||
assertEquals(3, eintrag.getStiche());
|
||||
}
|
||||
|
||||
//Exception Test hier schreiben
|
||||
@Test
|
||||
public void testNegativeStiche() throws Exception {
|
||||
assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(50, -3, null));
|
||||
assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(30,-1, null));
|
||||
assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(10, -4, null));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,102 +6,6 @@ written on: 10 / 10 / 2023 at: 21:17
|
|||
*/
|
||||
package Test.Domain.Block;
|
||||
|
||||
import Domain.Block.Block;
|
||||
import Domain.Block.Blockeintrag;
|
||||
import Domain.Block.Blockzeile;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public class BlockzeileTest {
|
||||
Block b = new Block();
|
||||
Blockeintrag e1 = new Blockeintrag(20,0,null);
|
||||
Blockeintrag e2 = new Blockeintrag(30,1,null);
|
||||
Blockeintrag e3 = new Blockeintrag(40,2,null);
|
||||
Blockeintrag e4 = new Blockeintrag(50,2, null);
|
||||
Blockeintrag e5 = new Blockeintrag(50, 2, null);
|
||||
Blockeintrag e6 = new Blockeintrag(40, 1, null);
|
||||
Blockzeile z1 = new Blockzeile(1, e1);
|
||||
Blockzeile z2 = new Blockzeile(2, e2);
|
||||
Blockzeile z3 = new Blockzeile(3, e3);
|
||||
|
||||
/**
|
||||
* testet addEintrag
|
||||
* Anmerkung assertEquals überprüft nicht ob der Eintrag richtig ist sondern ob das
|
||||
* Objekt eintrag1 im array liegt Eintrag wird in Blockeintrag auf Richtigkeit
|
||||
* getestet
|
||||
*/
|
||||
@Test
|
||||
public void addEintragTest() {
|
||||
Blockeintrag[] daten;
|
||||
|
||||
//1 Eintrag
|
||||
z1.addEintrag(e1);
|
||||
z1.addEintrag(e2);
|
||||
daten = z1.getDaten();
|
||||
assertEquals("addEintrag: 1 Eintrag", 3, daten.length);
|
||||
assertEquals("addEintrag: 1 Eintrag", e1, daten[1]);
|
||||
assertEquals("addEintrag: 1 Eintrag", e2, daten[2]);
|
||||
|
||||
//2 Eintrag
|
||||
z1.addEintrag(e3);
|
||||
z1.addEintrag(e4);
|
||||
daten = z1.getDaten();
|
||||
assertEquals("addEintrag: 2 Eintrag", 5, daten.length);
|
||||
assertEquals("addEintrag: 2 Eintrag", e3, daten[3]);
|
||||
assertEquals("addEintrag: 2 Eintrag", e4, daten[4]);
|
||||
|
||||
//3 Eintrag
|
||||
z1.addEintrag(e5);
|
||||
z1.addEintrag(e6);
|
||||
daten = z1.getDaten();
|
||||
assertEquals("addEintrag: 3 Eintrag", 7, daten.length);
|
||||
assertEquals("addEintrag: 3 Eintrag", e5, daten[5]);
|
||||
assertEquals("addEintrag: 3 Eintrag", e6, daten[6]);
|
||||
}
|
||||
|
||||
//Überprüfung ob Daten korrekt zurückgegeben werden
|
||||
@Test
|
||||
public void getDatenTest() {
|
||||
|
||||
z1.addEintrag(e1);
|
||||
z1.addEintrag(e2);
|
||||
|
||||
Blockeintrag[] daten = z1.getDaten();
|
||||
|
||||
assertEquals(3, daten.length);
|
||||
assertEquals(e1, daten[1]);
|
||||
assertEquals(e2, daten[2]);
|
||||
|
||||
z1.addEintrag(null);
|
||||
Blockeintrag[] daten1 = z1.getDaten();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void duplikateRunde() throws Exception{
|
||||
Blockeintrag e1 = new Blockeintrag(30,1,null);
|
||||
Blockeintrag e2 = new Blockeintrag(20,0,null);
|
||||
|
||||
Blockzeile z1 = new Blockzeile(4, e1);
|
||||
Blockzeile z2 = new Blockzeile(4, e2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void invalidRunde() throws Exception{
|
||||
Blockzeile z4 = new Blockzeile(-1, e1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void invalidRunde2() throws Exception{
|
||||
Blockzeile z5 = new Blockzeile(-3, e2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getRundenNummer(){
|
||||
assertEquals(3, z3.getRundenNummer());
|
||||
z3.setRundenNummer(4);
|
||||
assertEquals(4, z3.getRundenNummer());
|
||||
z3.setRundenNummer(5);
|
||||
assertEquals(5, z3.getRundenNummer());
|
||||
}
|
||||
}
|
||||
|
|
@ -7,33 +7,41 @@ 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.Enums.Kartenfarbe;
|
||||
import Domain.Karten.Magierkarte;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author sellm
|
||||
* @version
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
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);
|
||||
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", 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());
|
||||
assertEquals("Zauberer: MENSCH (BLAU).", m1.toString());
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,33 +7,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.Enums.Kartenfarbe;
|
||||
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);
|
||||
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.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());
|
||||
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");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,81 +7,81 @@ 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 {
|
||||
|
||||
/**
|
||||
* Die Objekterzeugung der HashMap und der Zahlenkarten
|
||||
* kann auch in ein @BeforeAll eingetragen werden.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Der @Test erzeugt Zahlenkarten von 1 bis 13. prüft aber
|
||||
* nur zwei Positionen in der HashMap, um die
|
||||
* Objektdaten zu validieren.
|
||||
*/
|
||||
@Test
|
||||
public void dreizehnZahlenkartenMENSCH() {
|
||||
|
||||
HashMap<Integer, Zahlenkarte> zm = new HashMap<Integer, Zahlenkarte>();
|
||||
Zahlenkarte zahlenkarte = null;
|
||||
for (int i = 1; i <= 13; i++) {
|
||||
zahlenkarte = new Zahlenkarte(Kartenfarbe.MENSCH, i);
|
||||
zm.put(i, zahlenkarte);
|
||||
}
|
||||
|
||||
assertEquals(zm.get(7).getKartenNummer(), 7);
|
||||
|
||||
assertEquals(zm.get(4).getKartenNummer(), 4);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void zahlenkartentesten() {
|
||||
|
||||
HashMap<Integer, Karte> zk = new HashMap<>();
|
||||
|
||||
for (int i = 1; i <= 8; i++) {
|
||||
zk.put(i, null);
|
||||
public void dreizehnZahlenkartenElf() {
|
||||
HashMap<Integer, Zahlenkarte> ze = new HashMap<Integer, Zahlenkarte>();
|
||||
Zahlenkarte zahlenkarte = null;
|
||||
for (int i = 1; i <= 13; i++) {
|
||||
zahlenkarte = new Zahlenkarte(Kartenfarbe.ELF, i);
|
||||
ze.put(i, zahlenkarte);
|
||||
}
|
||||
|
||||
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));
|
||||
assertEquals(ze.get(7).getKartenNummer(), 7);
|
||||
|
||||
assertEquals(ze.get(4).getKartenNummer(), 4);
|
||||
}
|
||||
|
||||
// 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());
|
||||
@Test
|
||||
public void dreizehnZahlenkartenZWERG() {
|
||||
HashMap<Integer, Zahlenkarte> zz = new HashMap<Integer, Zahlenkarte>();
|
||||
Zahlenkarte zahlenkarte = null;
|
||||
for (int i = 1; i <= 13; i++) {
|
||||
zahlenkarte = new Zahlenkarte(Kartenfarbe.ZWERG, i);
|
||||
zz.put(i, zahlenkarte);
|
||||
}
|
||||
|
||||
assertEquals(zz.get(7).getKartenNummer(), 7);
|
||||
|
||||
assertEquals(zz.get(4).getKartenNummer(), 4);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void dreizehnZahlenkartenRIESE() {
|
||||
HashMap<Integer, Zahlenkarte> zr = new HashMap<Integer, Zahlenkarte>();
|
||||
Zahlenkarte zahlenkarte = null;
|
||||
for (int i = 1; i <= 13; i++) {
|
||||
zahlenkarte = new Zahlenkarte(Kartenfarbe.RIESE, i);
|
||||
zr.put(i, zahlenkarte);
|
||||
}
|
||||
|
||||
assertEquals(zr.get(9).getKartenNummer(), 9);
|
||||
|
||||
assertEquals(zr.get(2).getKartenNummer(), 2);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,8 +10,8 @@ package UI;
|
|||
import Facade.Spiel;
|
||||
import Domain.Spieler;
|
||||
import Domain.Enums.Geschlecht;
|
||||
import Domain.Exceptions.EmptyListException;
|
||||
import Domain.Exceptions.SpielerNotFoundException;
|
||||
import Domain.Enums.Kartenfarbe;
|
||||
import Domain.Exceptions.*;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
|
|
@ -72,8 +72,59 @@ public class SpielCLI {
|
|||
}
|
||||
|
||||
private void spielStarten() {
|
||||
|
||||
String[] temp = this.spiel.getSpielerAmZug();
|
||||
System.out.println(temp[0] + " ist am Zug.");
|
||||
|
||||
try {
|
||||
this.spiel.starteSpiel();
|
||||
System.out.println("Noch nicht implementiert.");
|
||||
} catch (MagierTrumpfException mte) {
|
||||
|
||||
// Karten werden verteilt und trumpf wird festgelegt
|
||||
|
||||
System.out.println(mte.getMessage());
|
||||
System.out.println(temp[0] + " darf den Trumpf aussuchen.\n");
|
||||
boolean valid = false;
|
||||
while (!valid) {
|
||||
System.out.println("[1] Elf, [2] Mensch, [3] Zwerg, [4] Riese ");
|
||||
int choice;
|
||||
try {
|
||||
choice = Integer.parseInt(sc.nextLine());
|
||||
switch (choice) {
|
||||
case 1:
|
||||
spiel.setTrumpf(Kartenfarbe.ELF);
|
||||
valid = true;
|
||||
break;
|
||||
case 2:
|
||||
spiel.setTrumpf(Kartenfarbe.MENSCH);
|
||||
valid = true;
|
||||
break;
|
||||
case 3:
|
||||
spiel.setTrumpf(Kartenfarbe.ZWERG);
|
||||
valid = true;
|
||||
break;
|
||||
case 4:
|
||||
spiel.setTrumpf(Kartenfarbe.RIESE);
|
||||
valid = true;
|
||||
break;
|
||||
default:
|
||||
System.out.println("Diese Auswahl ist nicht erlaub");
|
||||
break;
|
||||
|
||||
}
|
||||
} catch (NumberFormatException nfe) {
|
||||
System.out.println("Dies war keine Nummer");
|
||||
}
|
||||
}
|
||||
} catch (NarrenTrumpfException nte) {
|
||||
System.out.println(nte.getMessage());
|
||||
System.out.println("Diese Runde wird ohne Trumpf gespielt.");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private void treffeVorhersage() {
|
||||
System.out.println("");
|
||||
}
|
||||
|
||||
private void addSpieler() {
|
||||
|
|
|
|||
Loading…
Reference in New Issue