# Kartenspiel "Krieg"



## Magistri (6. Jan 2021)

Hallo liebes Java-Forum,

wir haben die Aufgabe bekommen das Spiel Krieg, was auch unter anderen Namen bekannt ist, zu programmieren. Folgende Ausgabenstellung gab es:

Leider bin ich noch kein Profi in OOP, ein Konzept habe ich mir aber schon ausgedacht.

[CODE lang="java" title="Main"]public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Für 10 Runden wählen Sie die 1 für ein langes Spiel die 2");
        int wahl = sc.nextInt();
        Spiel s1 = new Spiel();

        s1.spielen(wahl);

    }[/CODE]
[CODE lang="java" title="Karte"]public class Karte {
    private int Wert;

    public Karte(int Wert) {
        this.Wert=Wert;
    }

    public int getWert() {
        return Wert;
    }

    public void setWert(int wert) {
        Wert = wert;
    }
}[/CODE]
[CODE lang="java" title="Spieler"]public class Spieler {
    private Deck karten;
    private Deck gewKarten;

}[/CODE]
[CODE lang="java" title="Deck/Stapel"]public class Deck {
    ArrayList<Karte> karten = new ArrayList<Karte>();

    public void mischen() {
        Collections.shuffle(karten);
    }

    public int getAnzahl() {
        int zahl=0;
        for (int i= 1; i<this.karten.size();i++) {
            zahl = i;
        }
        return zahl;
    }

    public void auflistenKarten() {
        for(Karte i:karten) {
            if(i instanceof Karte) {
                System.out.println(i);
            }
        }
    }
}[/CODE]

[CODE lang="java" title="Spiel"]public class Spiel {
    private Spieler eins;
    private Spieler zwei;

    public void vorbereiten() {
        //Karo Karten
        Karte karo7= new Karte(1);
        Karte karo8= new Karte(2);
        Karte karo9= new Karte(3);
        Karte karo10= new Karte(4);
        Karte karoBauer= new Karte(5);
        Karte karoDame= new Karte(6);
        Karte karoKoenig= new Karte(7);
        Karte karoAss= new Karte(8);
        //Pic Karten
        Karte pic7 = new Karte(1);
        Karte pic8 = new Karte(2);
        Karte pic9 = new Karte(3);
        Karte pic10 = new Karte(4);
        Karte picBauer = new Karte(5);
        Karte picDame = new Karte(6);
        Karte picKoenig = new Karte(7);
        Karte picAss = new Karte(8);
        //Herz Karten
        Karte herz7 = new Karte(1);
        Karte herz8 = new Karte(2);
        Karte herz9 = new Karte(3);
        Karte herz10 = new Karte(4);
        Karte herzBauer = new Karte(5);
        Karte herzDame = new Karte(6);
        Karte herzKoenig = new Karte(7);
        Karte herzAss = new Karte(8);
        //Kreuz Karten
        Karte kreuz7 = new Karte(1);
        Karte kreuz8 = new Karte(2);
        Karte kreuz9 = new Karte(3);
        Karte kreuz10 = new Karte(4);
        Karte kreuzBauer = new Karte(5);
        Karte kreuzDame = new Karte(6);
        Karte kreuzKoenig = new Karte(7);
        Karte kreuzAss = new Karte(8);

    }

    public void spielen(int t) {
        if(t==1) {
            vorbereiten();
            for (int i=0; i<10;i++) {

            }
        }else {

        }
    }
}[/CODE]
Nun komme ich leider nicht weiter dabei den Spielern die Karten zuzuweisen. Die Karten müssen ja quasi im Portfolio eines Spielers aufgenommen werden.
Idealerweise habe ich das so vor, dass in einer Schleife bevor die Karten aufgedeckt werden, dies bestätigt werden muss und man dann den Namen der Karte sieht und deren Wertung. Danach soll die höhere in das Deck gewonnenKarten des Spielers. Diese sollen am Ende, also entweder nach 10 Runden oder bis alle Karten gegeneinander ausgespielt wurden, gezählt werden.

Leider komme ich gerade nicht weiter, wie ich es am besten realisieren kann.
Ich hoffe mir kann geholfen werden.

MfG


----------



## kneitzel (6. Jan 2021)

Also bei dem Code fallen mir gleich ein paar Dinge auf:


```
public int getAnzahl() {
        int zahl=0;
        for (int i= 1; i<this.karten.size();i++) {
            zahl = i;
        }
        return zahl;
    }
```

Da brauchst Du keine Schleife: Das ist immer 0 oder ab karten.size() >0 kommt karten.size() - 1 dabei raus.
Also die Schleife brauchst du nicht. Und eigentlich sollte das doch einfach karten.size() sein, oder nicht?


```
for(Karte i:karten) {
            if(i instanceof Karte) {
                System.out.println(i);
            }
        }
```
i ist eine Variable vom Typ Karte. Daher ist eine Prüfung auf den Typ Karte unsinnig, denn wenn es keine Karte wäre, würde es gar nicht übersetzen...

bei der Methode vorbereiten erstellst du lauter Instanzen von Karte und speicherst diese in einer lokalen Variabel. Sobald die Methode vorbei ist, kommt der GC und schmeißt die Instanzen weg ... Das wirst Du nicht wollen, oder?

Und das ist auch eher eine Sache, die in Kartendeck gehört. Vorbereiten wäre doch dann eher, dass du die Karten erstellst um diese dann in einem Kartendeck zu speichern. Danach mischt du diese und verteilst die Karten auf beide Spieler ...

Dann hat der Spieler neben dem Kartenstapel und den gewonnenen Karten auch noch aufgedeckte Karten ... Das ist eine Modellierung, die Du Dir überlegen musst.


----------



## temi (7. Jan 2021)

Wenn man sich deine Klasse Karte anschaut, dann ist für das Spiel anscheinend nur der Kartenwert interessant. Es gibt ja nur eine Instanzvariable, die den Kartenwert enthält. Die Farbe wird ignoriert. Ein komplettes Deck mit Karten aus vier Farben enthält also einfach Karten mit den Werten 1 - 8 und das jeweils vier mal.

Im einfachsten Fall füllst du also ein komplettes Deck (deine Klasse) mit genau diesen Karten, mischt diese und teilst die Karten auf die zwei Spieler auf (z. B. abwechselnd ziehen, oder einfach Hälfte-Hälfte).

Dazu solltest du deine Klasse Deck erweitern. Du brauchst eine Methode, um eine Karte ins Deck zu legen und eine, um Karten aus dem Deck zu nehmen.


----------



## infos9 (8. Jan 2021)

Wann hat wer gewonnen? Wie wird eine nächste Runde gespielt? ...


----------



## Magistri (8. Jan 2021)

Genau es ist der Wert selber nur interessant. Ich würde dann vor jedem Durchlauf einmal den Namen des Objekts ausgeben wollen. Es besteht also keine Unterscheidung zwischen den Farben. Daher kann es auch zu Unentschieden kommen.
Vielleicht ist es auch sinnvoller jeweils die Farbe oder den Namen mit zu übergeben, um dies später einfach als Wert zu haben und beim Vergleich vorher anzuzeigen.

Die Frage ist ob man eine einfach eine Methode schreibt, der man jedes Objekt übergibt. Oder geht das noch effizienter?

[CODE lang="java" title="addCards"]public void addCards(Karte ka) {
        karten.add(ka);
    }[/CODE]


----------



## temi (8. Jan 2021)

Magistri hat gesagt.:


> Die Frage ist ob man eine einfach eine Methode schreibt, der man jedes Objekt übergibt. Oder geht das noch effizienter?


Ich würde mal mit einer Methode addCard() beginnen (Einzahl!).

Möglich ist vieles, aber ich würde mich damit erst mal nicht belasten, z. B. (hier Mehrzahl!)

```
void addCards(Card[] cards) // ein Array übergeben
void addCards(List<Card> cards) // eine Liste übergeben
```

Falls du mit Enumerationen arbeiten möchtest, die würden sich da gut anbieten ("Wert" muss du an deine Bedürfnisse anpassen)

```
public enum Farbe {
    KREUZ("Kreuz"), PIK("Pik"), HERZ("Herz"), KARO("Karo");

    private String info;

    Farbe(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return info;
    }
}

public enum Wert {

    SIEBEN("7"), ACHT("8"), NEUN("9"), ZEHN("10"), BUBE("Bube"), DAME("Dame"), KOENIG("König"), AS("As");

    private String info;

    Wert(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return info;
    }
}

public class Karte {

    private final Farbe farbe;
    private final Wert wert;

    public Karte(Farbe farbe, Wert wert) {
        this.farbe = farbe;
        this.wert = wert;
    }

    public Farbe getFarbe() {
        return farbe;
    }

    public Wert getWert() {
        return wert;
    }

    @Override
    public String toString() {
        return farbe + " " + wert;
    }
}
```

Damit lässt sich ganz einfach ein komplettes Deck erzeugen:

```
for (Farbe farbe : Farbe.values()){
    for (Wert wert : Wert.values()) {
        deck.add(new Karte(farbe, wert));
    }
}
```

Ohne Enumeration, würde ich für die Erzeugung des Decks die Farben und Werte je in ein entsprechendes Array stecken. Darüber kannst du dann, genauso wie bei der Enumvariante, mit zwei Schleifen iterieren und Karten erzeugen.


----------

