Mehrere Zufallszahlen aus Arraymenge

[Gast]

Wie und Wann werden die beiden Funktionen aufgerufen ? Zeig mal noch diesen Code^^

[ipsec]

Unabhängig vom Fehler scheint mir dein System unnötig komplex. Warum nimmst du nicht z.B. ein 52-elementiges Integerarray, wobei jeder Wert die Position der Karte angibt (also z.B. array[13] == 0 heißt Karte 13 liegt im Deck, bei 1 hat sie Spieler 1, bei 2 Spieler 2 usw., bei -1 liegt sie in der Mitte).
Vorteil: jede Karte kann nur eine Position haben. Außerdem (und auch deswegen) wird das gesamte Handling leichter und der Code einfacher und solche Fehler (wo auch immer er jetzt liegt) schleichen sich schwerer ein bzw. werden leichter entdeckt.

Nebenbei wird auch weniger Speicher verbraucht und das System ist leichter für eine beliebige Anzahl Spieler erweiterbar, aber das sind erstmal Nebeneffekte.

[_LiFeMaKeR_]

Also Zufallskarte wird NUR in der Funktion "Neues Spiel aufgerufen" und Und neues SPiel selbst ist etwas kompliziert umgedacht xD:

// Rückgabevariable für das Menü
	int iMenuerueck = 0;

	iMenuerueck = Start (pBigblind, pSmallblind, pRate, pSchwierigkeitsgrad, iMenuerueck);
	if (iMenuerueck == 1)
	{
	Neuesspiel (pBigblind, pSmallblind, pRate, pSchwierigkeitsgrad, pRunde);	
	}
	else if (iMenuerueck == 2)
	{
		system ("cls");
		cout << "Spiel wird beendet\n";
	}
	return 0;
}

Das ist die "Main" Funktion die eine "Start" funktion ausführt (Musste ich umgehen da ich nicht wusste wie ich innerhalb einer Funktion die main Funktion aufrufe.

int Start (int *pBigblind, int *pSmallblind, int *pRate, int *pSchwierigkeitsgrad, int iMenuerueck)
{

	do		
	{
	iMenuerueck = Hauptmenue (iMenuerueck, pBigblind, pSmallblind, pRate, pSchwierigkeitsgrad);	
	} while (iMenuerueck == 0);

return iMenuerueck;
}

Die Start funktion wenn ich im Hauptmenü die "1" (Das heißt so viel wie Neues Spiel) drücke wird 1 zurückgegeben. Die Schleife ist nur dafür da damit sollte man im Hauptmenü eine eingabe machen die nicht logisch ist (nur 3 Menüpunkte also man gibt 5 ein) dann gibt das Hauptmenü 0 zurück und wird neu gestartet.

Klar gibt es viel einfachere System aber erstmal soll erstmal die Zufällige Ausgabe von der Karte gehen dann kann ich das gedachte System verbessern^^

[Gast]

hmm, also lösch mal srand überall und schreibt direkt am Anfang der main genau diese Zeile:

srand( time(NULL) );

Ansonsten kannst du das Programm auch wo hochladen, dass man sichs genauer anschaun kann... schaut doch etwas komplex aus :p

[knivil]

srand (timeGetTime ());

Diese Zeile nur einmal im Programm aufrufen, nicht fuer jedes Spiel neu. D.h hier:

int main() {
  srand (timeGetTime ());
  ..                       // dein restliches Programm
  return 0;
}

[padreigh]

Vielleicht wäre ein etwas "c++"iger Ansatz auch nett ... ich konnte mich nie mit struct's anfreunden.

- modelliere alle möglichen Karten
- modelliere Spieler (2 slots) && Geber (5 slots)
- modelliere ein Deck
-- implementiere Deck reset
-- implementiere Deck mischen
-- implementiere eine Karte aus Deck an Spieler geben
modelliere eine Pokervariante die 1 Geber, n Spieler und 1 Deck verwaltet

Deck zB ähnlich wie
http://wiki.forum.nokia.com/index.php/CS001142_-_Shuffling_data_using_STL_random_shuffle_algorithm

#include <iostream>
#include <string>

#include <vector>
#include <algorithm>

namespace Cards {

    enum values {  Two=2,        Three,      Four,       Five,        Six,        Seven,      Eight,     Nine,     Ten,
                   Jack,        Queen,      King,       Ace
        };

    // spades (♠), hearts (♥), diamonds (♦) and clubs (♣)
    enum colors { Diamond = 1, Heart , Spade , Club };

    std::string name(int v = Cards::Two, int c = Cards::Diamond, bool shortName=false)
    {
        const std::string val[] = { "Two", "Three", "Four","Five", "Six", "Seven", "Eight", "Nine", "Ten", 
                             "Jack", "Queen", "King","Ace" };
        const std::string col[] = { "Diamond", "Heart", "Spade", "Club" };
        const std::string colS[] =  {"♦", "♥", "♠", "♣"};
        const std::string valS[] =  {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

        // short naming
        if (shortName)
            return " "+valS[v-Cards::Two]+colS[c-Cards::Diamond];

        // long names
        return val[v-Cards::Two] + " of " + col[c-Cards::Diamond] + "s";
    }
};

class OneCard {
    bool isValid;
    int _value;
    int _color;
public:
    OneCard() : isValid(false),_value(0),_color(0) {};
    OneCard(int v, int c) :
            isValid(true), _value(v), _color(c)
    {}

    std::string name()      { if (isValid) return Cards::name(_value,_color);       else return ""; }
    std::string shortName() { if (isValid) return Cards::name(_value,_color,true);  else return ""; }

    int value() const { return _value;}
    int color() const {return _color;}
    bool valid() const {return isValid;}
};

class Deck {
    std::vector<OneCard> _deck;

public:
    Deck() : _deck(0)
    {
        _deck.reserve(52);
        for (int col = Cards::Diamond; col <= Cards::Club; ++col)
        {
            for(int val=Cards::Two val <= Cards::Ace; ++val)
            {
                _deck.push_back(OneCard(val,col));
            }
        }        

        std::cout << "Pack: " << std::endl;
        debug();
        shuffle();
        std::cout << "Shuffled: " << std::endl;

        debug();
    }

    void shuffle() { std::random_shuffle(_deck.begin(), _deck.end()); }

    void debug() {
        for (unsigned int i=0; i < _deck.size(); ++i)
            std::cout << _deck[i].shortName() << " ";

        std::cout << std::endl;
    }

    OneCard drawOne()
    {
        if (! _deck.empty())
        {
            OneCard card = _deck.back();
            _deck.pop_back();
            return card;
        } else return OneCard();  // invalid one
    }
} ;

class Player {
public:
    std::vector<OneCard> owns;
};

class Game {
    Deck deck;
    std::vector<Player> player;
    std::vector<OneCard> forAll;
public:
    Game(int playercount = 3, int cardcount = 2) : deck(Deck())
    {
        // create players
        for(int i=0; i< playercount; ++i)
        {
            Player p;
            player.push_back(p);
        }

        // deal cards
        for (int cards=0; cards < cardcount; ++cards)
            for(int i=0; i < playercount; ++i)
            {
                player[i].owns.push_back(deck.drawOne());
            }

        debug();
    }

    void debug() {
        for(unsigned int i=0; i < player.size(); ++i)
        {
            std::cout << "P: " <<  i << "\tcards:   ";

            for(unsigned int cards=0; cards < player[i].owns.size(); ++cards)
                std::cout << player[i].owns[cards].shortName() << " " ;

            std::cout << std::endl;
        }
        std::cout << "Next 5:\t";
        for (int ii=0;ii<5;++ii) std::cout << deck.drawOne().shortName() << " ";
        std::cout << std::endl;

    }
};

int main()
{
    srand(time(0));
    Game g(4,4);
}

edit: Muh³² ... sehr .... konstruktiv.

[muh³²]

padreigh schrieb:

Vielleicht wäre ein etwas "c++"iger Ansatz auch nett ... ich konnte mich nie mit struct's anfreunden.

- modelliere alle möglichen Karten
- modelliere Spieler (2 slots) && Geber (5 slots)
- modelliere ein Deck
-- implementiere Deck reset
-- implementiere Deck mischen
-- implementiere eine Karte aus Deck an Spieler geben
modelliere eine Pokervariante die 1 Geber, n Spieler und 1 Deck verwaltet

Deck zB ähnlich wie
http://wiki.forum.nokia.com/index.php/CS001142_-_Shuffling_data_using_STL_random_shuffle_algorithm

blaa blubb Modelier implementier und am ende braust du am besten alles nochmal neu.

[knivil]

Gibt es keine 10?

[padreigh]

knivil schrieb:

Gibt es keine 10?

Äöööhhmmm nee, ähh ja ... warn Test hab 4 Zeilen geändert, nun gibts ne 10

[_LiFeMaKeR_]

Hmm ja danke padreigh erstmal für dein ellenlanges Programm aber sry xD Wie ich schon am include sehe benutzt du Sachen die ich noch nicht gelernt habe und von denen ich noch nichts verstehe xD Trotzdem danke für die Hilfe^^

So hab das System hinter dem Spiel verändert gibt nur noch einen Array der die Karten verwaltet und wer sich fragt: Hey? wo ist timegettime hin? das ist im Moment am Anfang von der main-Funktion.

#include <iostream>
#include <windows.h>
#include <stdlib.h>

#pragma comment (lib, "winmm.lib")

using namespace std;

#include "Spiel.hpp"

void Neuesspiel (int *pBigblind, int *pSmallblind, int *pRate, int *pSchwierigkeitsgrad,
				 int *pRunde)
{

	// Spielarrays

	system("cls");
	int AKarten [52];										// Karten Array

		// Array Infos:
		// Wert 0	=	Karte ist im Deck
		// Wert 1	=	Karte ist Spielerkarte 1
		// Wert 2	=	Karte ist Spielerkarte 2
		// Wert 3	=	Karte ist Gegnerkarte 1
		// Wert 4	=	Karte ist Gegnerkarte 2
		// Wert 5	=	Karte ist Mittekarte 1
		// Wert 6	=	Karte ist Mittekarte 2
		// Wert 7	=	Karte ist Mittekarte 3
		// Wert 8	=	Karte ist Mittekarte 4
		// Wert 9	=	Karte ist Mittekarte 5

	int *p_Karten = &AKarten[0];						// Der Pointer des Karten Arrays

	for (int i=0; i < 51; i++)		// Schleife um jede Karte auf "0" (Ist im Deck) zu schreiben
	{
		AKarten[i] = 0;
	}

	// Variabeln
	int iRueckgabezufall;

	// Erste Karte ausgeben und als die erste Spielerkarte angeben
	iRueckgabezufall = Zufallskarte (p_Karten);
	AKarten [iRueckgabezufall] = 1;

	for (int u=0; u < 51; u++)
	{
		if (AKarten [u] == 1)
		{
			cout << "Das ist die " << u << " Position der ersten Spielerkarte.\n";
		}

	}
	iRueckgabezufall = 0;
	Sleep(500);
	// Zweite Karte ausgeben und als die Zweite Spielerkarte angeben
	iRueckgabezufall = Zufallskarte (p_Karten);
	AKarten [iRueckgabezufall] = 2;

	for (int u2=0; u2 < 51; u2++)
	{
		if (AKarten [u2] == 2)
		{
			cout << "Das ist die " << u2 << " Position der zweiten Spielerkarte.\n";
		}

	}
	iRueckgabezufall = 0;
	Sleep(500);

}

int Zufallskarte (int  *p_Karten)
{
	int iWhileende = 0;		// Variable um die Schleife zu beenden

	do
	{
		int iZufall;		

		iZufall = (rand()%52);

		for (int i=0; i < 51; i++)
		{
			if  (iZufall == i)
			{
				if (p_Karten [i] == 0)
				{
					iWhileende = 1;
					return i;
				}

			}
		}

	} while (iWhileende == 0);

	return 0;
}

Und hier nochmal die Header-Datei des Spiels:

// Headerdatei des eigentlichen Spiels

// Funktionen

void Neuesspiel (int *pBigblind, int *pSmallblind, int *pRate, int *pSchwierigkeitsgrad,
				 int *pRunde);

int Zufallskarte (int  *p_Karten);

Hmm wie ich gerade feststelle Funktioniert das Programm auf Zauberhafte Art xD auch mit mehr als 2 Karten^^ brauch nur noch eine Abfrage die das mehrfach aufkommen von Karten verhindert. ^^ Auch wenn irgendwie alles was ich Versucht habe mit eurer Hilfe nix gebracht hat und Das Programm nun Funktioniert wies soll, danke ich trotzdem vieeeeelllmals für die Hilfe von euch^^ Naja xD Programmieren ist und bleibt manchmal etwas seltsam xDDDDD

MFG _LiFeMaKeR_