Kartenspiel: Karten an Spieler verteilen

d0zer

Hallo Leute, da bin ich wieder.

Ich stehe nun vor einem neuen Problem. Ich soll ein Kartenspiel programmieren.

"Programmieren Sie die Grundlage für ein Kartenspiel (als Klasse kartenspiel):
● Eine Karte wird repräsentiert durch ihre Spielfarbe/Symbol (Kreuz, Pik, Herz, Karo)
und einen Wert (Sieben, Acht, Neun, Zehn, Bube, Dame, König, Ass).
● Ein Kartenspiel besteht aus einem Stapel von 32 Karten, die vollständig an vier
Spieler verteilt werden.

Ich habe nun das Mischen und die Anzeige aller Karten geschafft und überlege gerade wie ich die Karten an alle Spieler vollständig verteilen und danach ausgeben lassen kann.

"Karten austeilen: Implementieren Sie dafür eine Methode austeilen, welche
die Karten vollständig an die vier Spieler verteilt. Geben Sie am Ende die
Kontrollmeldung „Karten verteilt!“ auf dem Bildschirm aus."

"Karten eines Spielers ansehen: Implementieren Sie dafür ein weiteres Menü,
mit dessen Hilfe es möglich ist, einen der vier Spieler auszuwählen und dessen
Karten auf dem Bildschirm anzuzeigen. Die Ausgabe soll nur dann gemacht
werden, wenn die Karten zuvor verteilt worden sind (also nur, wenn zuletzt
Menüpunkt 2 und nicht Menüpunkt 1 gewählt wurde)."

Ich habe mir überlegt, pro Spieler 8 Karten zu verteilen und dann zum nächsten Spieler zu gehen und immer weiter.

Spieler 1: 1-8, Spieler 2: 9-16...

Doch wie realisiere ich das am Besten? Pro Spieler ein (zweidimensionales?) Array? Ich weiss echt nicht wie ich weiter verfahren soll. Ich hoffe, ihr könnt mir helfen

Das hier ist meine Kartenspiel.cpp

/* 
 * File:   Kartenspiel.cpp
 * Author: d0zer
 * 
 * Created on 18. Juni 2011, 12:15
 */

#include "Kartenspiel.h"
using namespace std;

Kartenspiel::Kartenspiel() {

    for (int reihe = 0; reihe <= 3; reihe++) //Schleife durch Reihe
    {
        for (int zeile = 0; zeile <= 7; zeile++) //Schleife durch Zeile der jeweiligen Reihe
        {
            Deck[reihe][zeile] = 0; //Setze Slot auf 0
        }
    }
    srand(time(0)); //Zufallsgenerator für die Zahlen
}

//Methode zum Karten mischen
void Kartenspiel::mischen() {

    int reihe;
    int zeile;
//Karten mischen
    for (int card = 1; card <= 32; card++) {
        do {
            reihe = rand() % 4;
            zeile = rand() % 8;
        } while (Deck[reihe][zeile] != 0);
        Deck[reihe][zeile] = card;
    } cout << endl << "Karten gemischt!" << endl;

  //gemischte Karten ausgeben
string farbe[4] = {"Herz", "Pik", "Kreuz", "Karo"};
    string wert[8] = {"Sieben", "Acht", "Neun", "Zehn", "Bube", "Dame", "Koenig", "Ass"};

    //gemischte Karten ausgeben
    for (int card = 1; card <= 32; card++) {
        for (int reihe = 0; reihe <= 3; reihe++) {
            for (int zeile = 0; zeile <= 7; zeile++) {
                if (Deck[reihe][zeile] == card) {
                    cout << setw(5) << right << wert[zeile] << " von " << setw(8) << left << farbe[reihe] << ( card % 2 == 0 ? '\n' : '\t' );
                }
            }
        }
    }
}

Kartenspiel::~Kartenspiel() {
}

Das hier ist meine Header Datei dazu:

/* 
 * File:   Kartenspiel.h
 * Author: d0zer
 *
 * Created on 18. Juni 2011, 12:15
 */

#ifndef KARTENSPIEL_H
#define	KARTENSPIEL_H

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <iomanip>
using namespace std;

class Kartenspiel {
public:
    Kartenspiel();
    virtual ~Kartenspiel();

    void mischen();
    void austeilen();

private:
    int Deck[4][8];
};

#endif	/* KARTENSPIEL_H */

SeppJ

Ich würde das an deiner Stelle ganz anders modellieren und ich glaube dein Lehrer möchte das auch:

● Eine Karte wird repräsentiert durch ihre Spielfarbe/Symbol (Kreuz, Pik, Herz, Karo)
und einen Wert (Sieben, Acht, Neun, Zehn, Bube, Dame, König, Ass).

Du sollst eine Klasse Karte schreiben, die einen dieser Werte annehmen kann.

● Ein Kartenspiel besteht aus einem Stapel von 32 Karten,

Und dann besteht ein Kartenspiel aus einem Container der die obigen Karten fassen kann. Zu Anfang packst du in das Spiel 32 verschiedene Karten.

die vollständig an vier
Spieler verteilt werden.

Und ein Spieler hat dann wiederum einen Container für seine Karten - seine Hand. Zum Verteilen nimmst du eine Karte aus dem Kartenspiel und gibst sie an die Hand des Spielers.

Ist dir klar, worauf ich hinaus möchte? Ich fürchte ein Beispiel wäre fast schon identisch mit einer Komplettlösung, weswegen ich es ungern bringen möchte.

d0zer

Hey

Danke erstmal für die Antwort.

Meinst du diese STL Contaier? Wenn ja, das hatten wir noch gar nicht. Ich denke nicht, dass er das meint.

In der Aufgabenstellung steht, dass wir ein Kartenspiel in der Klasse "Kartenspiel" programmieren sollen. Und dazu dann die Infos die ich schon gab.

Momentan weiss ich einfach nicht weiter, wie ich Werte und Farben von den Karten, den 4 Spielern zuordnen und dann ausgeben lassen kann. Ob ich für jeden Spieler 2 Arrays nehmen sollte zum Beispiel.

Alles so frustrierend

SeppJ

Es ist ganz egal, was für ein Container. Das Hauptproblem das ich sehe ist, dass deine Modellierung einer Karte ziemlich unpraktisch ist und du deswegen nicht zu einer Lösung kommst.

cout << setw(5) << right << wert[zeile] << " von " << setw(8) << left << farbe[reihe] << (card -1)/8 << ( card % 2 == 0 ? '\n' : '\t' );

Eine von vielen Lösungsansätzen. Warum, wieso, weshalb - da solltest du dir etwas einfallen lassen

wie heisst das heute - b.t.w.:
Kannst du das Mischen und die Anzeige in getrennte Funktionen packen?
Sieht dann besser aus.

Hier noch mal etwas schnell eingehacktes:

Wie oft in C oder C++ gibt es mehrere Lösungen.

ein Weg: das ganze Deck mischen und die Zuordnung Farbe und Zählwert danach per Division und Rest.

oder wie du das angefangen hast:

int Deck[Farbe][Zählwert][Spieler];

oder

//Methode zum Karten mischen
void Kartenspiel::mischen() {

    int reihe;
    int zeile;
//Karten mischen
    for (int card = 1; card <= 32; card++) {
        do {
            reihe = rand() % 4;
            zeile = rand() % 8;
        } while (Deck[reihe][zeile] != 0);
        Deck[reihe][zeile] = card;  // brauchst du den Wert "card" noch, sonst 
                                    // hier direkt an Spieler verteilen
Zeichen     } cout << endl << "Karten gemischt!" << endl;

oder

int DeckSpieler1[Farbe][Zählwert];
    int DeckSpieler2[Farbe][Zählwert];
    ...

oder noch andere Varianten

sollten Fehler drin sein - beseitigt die

so nun dürft ihr entscheiden
f.-th.

Scale

Gibt es denn nicht auch eine Möglichkeit ein Array z.b.: Deck[32] komplett mit den verschiedenen Karten zu füllen?

Kann man nicht die unten genannten Karten kombinieren und in das Array Deck[32] speichern?

farben[0] = "Kreuz";farben[1] = "Pik";farben[2] = "Herz";farben[3] = "Karo";

typen[0] = "Sieben"; typen[1] = "Acht"; typen[2] = "Neun"; typen[3] = "Zehn"; typen[4]= "Bube"; typen[5]= "Dame"; typen[6]= "König" ;typen[7] = "As";

Wenn ja, könnt ihr vielleicht einen Vorschlag dafür nennen?

Vielen Dank!

d0zer

Hallo Leute

Laut meinem Code stecken die Farben und die Werte nun in Reihe und Zeile.

Wie kriege ich die Farben und Werten aus den Reihen und Zeilen in ein Array[Farbe][Wert] ?

Belli

Du hast doch die Karten bereits in einem zweidimensionalen Array: int Deck[][];

und das macht das Ganze schwer handhabbar. Du solltest dringend über SeppJs Vorschlag nachdenken und eine weitere Datenstruktur, zB

struct Karte
{
    int farbe;
    int wert;
};

einführen. Davon erstellst Du im Konstruktor von Kartenspiel dann 32 unterschiedliche und definierst Dein Deck in der Klasse Kartenspiel dann:
Karte Deck[32];

Das sollte den Umgang mit den Karten sehr vereinfachen. Du könntest dann bei Bedarf für Karte den << - Operator noch überladen. Jeder Spieler bekommt dann seinen eigenen Satz Karten:

class Spieler
{
    ...
    Karte kartenSatz[8];
    ...
}