Mehrere Zufallszahlen aus Arraymenge

[_LiFeMaKeR_]

^^ ich verwende es doch nur einmal^^ Ich habe das srand nur 1 mal in der Funktion die für das neue Spiel zuständig ist (und die kann nur einmal durchlaufen werden)
und zwar direkt nach der geschweiften Klammer gestellt. Also so habe ich es geändert wie du sagst ist srand nur einmal gesetzt. Aber das Ergebnis verändert sich leider nicht^^

[Gast]

Poste mal nochmal Code

[_LiFeMaKeR_]

#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)
{
	srand (timeGetTime ());
	// Spielarrays

	system("cls");
	S_Deck ADeck [52];										// Deck Array
	struct S_Deck *p_Deck = &ADeck[0];						// Der Pointer des Deck Arrays
	S_Deck ASpielerkarte1 [52];								// Spielerkarte1 Array
	struct S_Deck *p_Spielerkarte1 = &ASpielerkarte1[0];	// Der Pointer des Spielerkarte1 Arrays
	S_Deck ASpielerkarte2 [52];								// Spielerkarte2 Array
	struct S_Deck *p_Spielerkarte2 = &ASpielerkarte2[0];	// Der Pointer des Spielerkarte2 Arrays
	S_Deck AGegnerkarte1 [52];								// Gegnerkarte1 Array
	struct S_Deck *p_Gegnerkarte1 = &AGegnerkarte1[0];		// Der Pointer des Gegnerkarte1 Arrays
	S_Deck AGegnerkarte2 [52];								// Gegnerkarte1 Array
	struct S_Deck *p_Gegnerkarte2 = &AGegnerkarte2[0];		// Der Pointer des Gegnerkarte2 Arrays
	S_Deck AMittelkarte1 [52];								// Mittelkarte1 Array
	struct S_Deck *p_Mittelkarte1 = &AMittelkarte1[0];		// Der Pointer des Mittelkarte1 Arrays
	S_Deck AMittelkarte2 [52];								// Mittelkarte2 Array
	struct S_Deck *p_Mittelkarte2 = &AMittelkarte2[0];		// Der Pointer des Mittelkarte2 Arrays
	S_Deck AMittelkarte3 [52];								// Mittelkarte3 Array
	struct S_Deck *p_Mittelkarte3 = &AMittelkarte3[0];		// Der Pointer des Mittelkarte3 Arrays
	S_Deck AMittelkarte4 [52];								// Mittelkarte4 Array
	struct S_Deck *p_Mittelkarte4 = &AMittelkarte4[0];		// Der Pointer des Mittelkarte4 Arrays
	S_Deck AMittelkarte5 [52];								// Mittelkarte5 Array
	struct S_Deck *p_Mittelkarte5 = &AMittelkarte5[0];		// Der Pointer des Mittelkarte5 Arrays

	for (int i1=0; i1 < 51; i1++)		// Schleife um jeden boolean im Deck auf True zu setzen
	{
		ADeck[i1].bVorhanden = true;
	}

	for (int i2=0; i2 < 51; i2++)		// Schleife um jeden boolean als erste Spielerkarte auf False zu setzen
	{
		ASpielerkarte1[i2].bVorhanden = false;
	}

	for (int i3=0; i3 < 51; i3++)		// Schleife um jeden boolean als zweite Spielerkarte auf False zu setzen
	{
		ASpielerkarte2[i3].bVorhanden = false;
	}

	for (int i4=0; i4 < 51; i4++)		// Schleife um jeden boolean als erste Gegnerkarte auf False zu setzen
	{
		AGegnerkarte1[i4].bVorhanden = false;
	}

	for (int i5=0; i5 < 51; i5++)		// Schleife um jeden boolean als zweite Gegnerkarte auf False zu setzen
	{
		AGegnerkarte2[i5].bVorhanden = false;
	}

	for (int i6=0; i6 < 51; i6++)		// Schleife um jeden boolean als erste Mittelkarte auf False zu setzen
	{
		AMittelkarte1[i6].bVorhanden = false;
	}

	for (int i7=0; i7 < 51; i7++)		// Schleife um jeden boolean als zweite Mittelkarte auf False zu setzen
	{
		AMittelkarte2[i7].bVorhanden = false;
	}

	for (int i8=0; i8 < 51; i8++)		// Schleife um jeden boolean als dritte Mittelkarte auf False zu setzen
	{
		AMittelkarte3[i8].bVorhanden = false;
	}

	for (int i9=0; i9 < 51; i9++)		// Schleife um jeden boolean als vierte Mittelkarte auf False zu setzen
	{
		AMittelkarte4[i9].bVorhanden = false;
	}

	for (int i10=0; i10 < 51; i10++)		// Schleife um jeden boolean als fünfte Mittelkarte auf False zu setzen
	{
		AMittelkarte5[i10].bVorhanden = false;
	}

	// Variabeln
	int iRueckgabezufall;

	// Erste Karte ausgeben und als die erste Spielerkarte angeben
	iRueckgabezufall = Zufallskarte (p_Deck);
	ASpielerkarte1 [iRueckgabezufall].bVorhanden = true;

	for (int u=0; u < 51; u++)
	{
		if (ASpielerkarte1 [u].bVorhanden == true)
		{
			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_Deck);
	ASpielerkarte2 [iRueckgabezufall].bVorhanden = true;

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

	}
	iRueckgabezufall = 0;
	Sleep(500);

}

int Zufallskarte (struct S_Deck *p_Deck)
{
	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_Deck [i].bVorhanden == true)
				{
					p_Deck [i].bVorhanden = false;
					iWhileende = 1;
					return i;
				}

			}
		}

	} while (iWhileende == 0);

	return 0;
}

Das ist die komplette Funktion für das neue Spiel vllt liegt der Fehler ja wo anders? ( Ach stört euch nicht an den übergegeben Variabeln in der Parameterliste da die jetzt noch nicht gebraucht werden tun die niemanden was^^

Nochmal zu dem System das ich mir ausgedacht hatte: Das Deck ist ein Array aus 52 Struckturen die jeweils eine bool inne haben welcher "bVorhanden" heißt. Dieser bool sagt mir ist die Karte noch im Deck? (true) oder nicht mehr (false).
Das gleicht gilt für die 2 Spielerkarten und die 2 Gegnerkarten und die 5 Mittelkarten (Doch hier heißt "True" = Spieler hat Karte und "False" = Spieler hat die Karte nicht. Jede Position innerhalb des Arrays ist eine der 52 Karten.

[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_