Poker

[BreVDD]

Hallo!

Ik zou graag een pokerspel maken. Ik heb geprobeerd om het zelf te maken maar het lukt helemaal niet, wat ik al heb :

Ik heb 3 array’s gemaakt: int kaarten_midden[5] (omdat er 5 kaarten in het midden komen te liggen)
Int Kaarten_personen1[5] (5 personen 1ste kaart van de 2 in handen)
Int kaarten_personen2[5] (5 personen 1ste kaart van de 2 in handen)

Nu ken ik de kaarten een getal toe aan die kaarten tussen de 1-13 (11 = boer, 12 = dame, 13 = koning ) met een random-functie:

 kaarten_personen1[1] = (rand() % 12) + 1

Het probleem is alleen dat via deze functie ook een nul** kan ontstaan, ik weet helemaal niet hoe dit komt want ik heb al eerder de zelfde random-functie gebruikt en door de + 1 kan het toch nooit nul worden?

Mijn 2de probleem is dat ik ook eroor moet zorgen dat er klaver, pieken, harten en koeken moet worden toegekend aan de kaarten. Dit zou ik ook doen met een array.

int kaarten_midden_soort[5] (omdat er 5 kaarten in het midden komen te liggen)
Int Kaarten_personen1_soort[5] (5 personen 1ste kaart van de 2 in handen)
Int kaarten_personen2_soort[5] (5 personen 1ste kaart van de 2 in handen)
Dan ook via een random-fuctie de kaarten een waarde tussen de 1-4 (voor de 4 soorten). (mss is het mogelijk om een random te maken met woorden?).

Maar dan moet ik er nog voor zorgen dat er maar 4 azen, 4 * 2 , … en maar 1 maal een cijfer van de zelfde soort is en dat lukt me helemaal niet. Mss heeft iemand een idee. Of op een ander manier tewerk gaan.

Ik kan er wel al voor zorgen dat wanneer de computer een nieuw getal kiest hij niet telkens hetzelfde getal kies via:

srand( (unsigned)time(0) );

** Als ik : “GETAL1 = (rand() % 8) + 1;” doe dan kom ik nooit nul uit?! Komt dat zoms door de array.

Alvast bedankt,

Groetjes
Brecht

Ik werk met Visual C++ 2008 Express Edition

Sorry voor al de vragen in een keer.

 

[Palmpje]

Je zou inderdaad geen 0 moeten krijgen bij (rand % n) + 1 want rand geeft een antwoord in [0 .. 32767], de rest is 0 ... (deler-1) en 1 erbij is dus 1 ... deler.
Dat ligt dan vast aan iets anders wat ik niet kan zien aan de code die je geeft.

Een pak kaarten schudden is wat je wilt doen.
Nummer de kaarten van 0 t/m 51.
De eerste 13 (0 .. 12) zijn de schoppen etc..

Vul eerst een array - de stapel kaarten met de getallen 0 .. 51
Dan ga je de kaarten delen. Makkelijkst is de kaart op de hoogste plaats (51) te verwisselen met een random plaats in het interval 0 .. 51
Vervolgens de kaart op de één na hoogste plaats (50) verwisselen met een random plaats in het interval 0 .. 50
Enzovoorts. Een kaart kan dus op de oorspronkelijke plaats blijven staan.

Dan heb je geschud. Kaarten kun je daarna in volgorde delen.

 

[BreVDD]

...

Vul eerst een array - de stapel kaarten met de getallen 0 .. 51
Dan ga je de kaarten delen. Makkelijkst is de kaart op de hoogste plaats (51) te verwisselen met een random plaats in het interval 0 .. 51
Vervolgens de kaart op de één na hoogste plaats (50) verwisselen met een random plaats in het interval 0 .. 50
Enzovoorts. Een kaart kan dus op de oorspronkelijke plaats blijven staan.

Dan heb je geschud. Kaarten kun je daarna in volgorde delen.

Bedankt voor de reactie, zou je juist een voorbeeld kunnen geven van dat delen want dat versta ik niet echt mss met getalllen tot aan 10 ofzo.

Alvast bedankt

 

[bzub]

Je kan ook gebruik maken van standaard functies, zie volgend voorbeeld:

#include <algorithm>

#include <iostream>
#include <time.h>
using namespace std;

const static int DECK_SIZE = 52; // aantal kaarten in een deck

void init_deck(int* deck); // zal de array die het deck 
							//voorstelt initialiseren (1 ... 52)

int main(void)
{	
	int deck[DECK_SIZE]; // array die het deck voorstelt

	init_deck(deck); // initialiseer het deck
	// deze lijn is normaal duidelijk voor je?
	srand((unsigned int) time(NULL));
	/**
	 * Deze functie doet het werk en zit gewoon in de standaard 
	 * libraries, dus waarom het wiel opnieuw uitvinden:).
         * het startpunt van de array meegeven (de naam) en het eindpunt
         * (naam + lengte) volstaat.
	 * meer uitleg: http://www.sgi.com/tech/stl/random_shuffle.html
	 */
	random_shuffle(deck, deck + DECK_SIZE);
	// gewoon een eenvoudige manier op de array uit te printen
	// een for lus is natuurlijk evengoed.
	copy(deck, deck + DECK_SIZE, ostream_iterator<int>(cout,  " "));

	return 0;
} 

// niet echt van belang en normaal duidelijk?
void init_deck(int* deck)
{
	for(int i = 0; i < DECK_SIZE; ++i)
	{
		deck[i] = i+1;
	}
}

Het is me ook niet echt duidelijk hoe je een 0 kan krijgen, daarvoor zou je de code eens moeten posten. Niet dat het echt veel uitmaakt, je kan de kaarten evengoed nummeren van 0 - 51, 0 - 12 harten, 13 - 25 ruiten, 26 - 38 schoppen en 39 - 51 klaveren, anyway
hopelijk helpt het wat.

Ik denk dat palm het volgende bedoelde (ik kan me natuurlijk wel vergissen):

#include <algorithm>

#include <iostream>
#include <time.h>
using namespace std;

const static int DECK_SIZE = 52; // aantal kaarten in een deck

void init_deck(int* deck); // zal de array die het deck 
							//voorstelt initialiseren (1 ... 52)
void shuffle(int* deck); // zal de array randomiseren
void swap(int* deck, int pos_old, int pos_new); // zal de kaarten van positie veranderen
int main(void)
{	
	int deck[DECK_SIZE]; // array die het deck voorstelt

	init_deck(deck); // initialiseer het deck
	shuffle(deck);
	// gewoon een eenvoudige manier op de array uit te printen
	// een for lus is natuurlijk evengoed.
	copy(deck, deck + DECK_SIZE, ostream_iterator<int>(cout,  " "));

	return 0;
} 

// niet echt van belang en normaal duidelijk?
void init_deck(int* deck)
{
	for(int i = 0; i < DECK_SIZE; ++i)
	{
		deck[i] = i+1;
	}
}

void shuffle(int* deck)
{
	srand((unsigned int) time(NULL));

	/** 
	 * volgens mij maakt het niet uit of je nu 
	 * van de laatste positie of van de eerste
	 * positie begint (maar ik kan me vergissen).
	 */
	int hulp;
	for(int i = DECK_SIZE - 1; i >= 0; --i)
	{
		// nieuwe positie voor de kaart op
		// positie i in de rij
		hulp = rand() % 52;
		// verwissel de kaart op positie i
		// met die van positie hulp
               // ja kan hier ook een if-test zetten
               // zodat alleen wordt geswapt als i != hulp
               
		swap(deck, i, hulp);
	}
}

void swap(int* deck, int pos_old, int pos_new)
{
	// is wel duidelijk denk ik?
	// er zijn efficiëntere maniere,
	// ja kan bijvoorbeeld gewoon
	// 2 integer pointers doorgeven 
	// en deze swappen
	// maar op deze manier is het duidelijk
	// dat je in een array swapt.
	// Het zou kunnen dat er in
	// de stl library een swap functie is
	// maar ik ben er niet zeker van op 
	// het moment.
	int hulp = deck[pos_old];
	deck[pos_old] = deck[pos_new];
	deck[pos_new] = hulp;
}

 

[BreVDD]

...

Bedankt voor de goede uitleg !!!

Maar nog juist 1 vraagje wat is "initialiseren ". Mss een stomme vraag maar ik ken nog niet echt super veel van C++.

 

[bzub]

Bedankt voor de goede uitleg !!!

Maar nog juist 1 vraagje wat is "initialiseren ". Mss een stomme vraag maar ik ken nog niet echt super veel van C++.

Wel als je over variabelen spreekt dan zijn er over het algemeen twee fases, de declaratie en
de initialisatie. In de declaratie fase geef je een naam aan de variabele en in de initialisatie fase waarde geef je een beginwaarde aan de variabele.
Een voorbeeldje:

int var1; // declaratie van een integer variabele genaamd var 1
var1 = 2; // initialisatie van var1 met waarde 2

int var2 = 3; // declaratie en initialisatie in 1 stap

initialiseren in de code die ik gegeven heb komt er op neer van de waarden 1 - 52 toe te kennen aan de array van integers 'deck'

Hopelijk is het een beetje duidelijk?

 

[NLScotty]

je zou ook een class kunnen maken van de pot met alle kaarten, en dan bevrienden klassen die dan spelers zijn en uit de hoofdclass de kaarten halen

class Hoofdklass
Private:
int totaal_aantal_kaarten = 52 \\ of hoeveel je er ook wilt
Public:
etcetc

class Hoofdklasse :: Speler_1