Generare un mazzo di carte
https://stackoverflow.com/questions/234388
-
04-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Sto cercando di creare un semplice programma di blackjack. Purtroppo, sto avendo problemi subito con la generazione di un mazzo di carte.
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<char> deck;
char suit[] = {'h','d','c','s'};
char card[] = {'2','3','4','5','6','7','8','9','10','J','Q','K','A'};
for (int j=0; j<13; j++) {
for (int i=0; i<4; i++) {
deck.push_back(card[j] suit[i]);
}
}
return 0;
}
So che il mio problema inizia quando provo ad assegnare il valore '10' a un carattere. Ovviamente non sono riuscito a compilare questo, ma sono sicuro che quando provo ad assegnare i valori delle carte al mazzo vettoriale riceverò anche un errore poiché ho usato il tipo variabile 'char'. Sapere che tipo di tipo variabile usare mi sta uccidendo. Inoltre, 'deck.push_back (card [j] suit [i]);' essere il codice corretto per combinare la carta e il seme o devi mettere qualcosa tra carta [j] e seme [i]? Ti sarei grato se qualcuno di voi potesse guidarmi nella giusta direzione. Anche come piccola nota a margine, questo fa parte di un compito a casa, quindi per favore non darmi interi blocchi di codice. Grazie per il tuo aiuto.
Soluzione
Prova a creare una classe di carte con seme e carta come membro e impostala come tipo di vettore. Come
public class Card {
public:
Card(char suit, char card);
char suit, card;
};
int main() {
vector<Card> deck;
char suit[] = {'h','d','c','s'};
char card[] = {'2','3','4','5','6','7','8','9','T','J','Q','K','A'};
for (int j=0; j<13; j++) {
for (int i=0; i<4; i++) {
deck.push_back(new Card(card[j],suit[i]));
}
}
return 0;
}
usare anche enum invece di caratteri in seme e carta lo renderebbe più chiaro.
Altri suggerimenti
Penso che ciò che stai cercando di usare sia un'enumerazione. Renderà più chiaro il tuo codice e risolverà il tuo problema.
enum SUIT { HEART, CLUB, DIAMOND, SPADE };
enum VALUE { ONE, TWO, THREE, ..., TEN, JACK, QUEEN, KING};
Il modo in cui lo modelli dipende davvero da cosa stai cercando di fare.
Stai creando un gioco reale e le strutture dati devono solo supportare il gameplay?
In tal caso, creerei una classe di carte, con un campo enum per il seme e un tipo numerico (con valori da 1 a 13) per il valore nominale.
D'altra parte, se stai creando un'applicazione di analisi o un lettore AI, il modello potrebbe essere leggermente diverso.
Qualche anno fa, ho scritto un simulatore per calcolare le probabilità in vari scenari del Texas Holdem, e volevo che scricchiolasse i numeri DAVVERO rapidamente. Ho iniziato con un modello molto semplice (classe di carte, seme, ecc.) Ma dopo un sacco di profilazione e ottimizzazione, ho finito con una rappresentazione bit a bit.
Ogni carta aveva un valore di sedici bit, con i tredici bit di ordine superiore che rappresentano il valore nominale, i due bit di ordine inferiore che rappresentano il seme e con il bit [2] come bandiera speciale che indica un asso (usato solo in casi in cui l'asso potrebbe apparire in una scala A2345).
Ecco alcuni esempi:
0000000000001001 <---- Two of hearts
0100000000000011 <---- King of spades
1000000000000110 <---- Ace of diamonds
^^^^^^^^^^^^^ ("face-value" bits)
^ ("low-ace" flag)
^^ ("suit" bits)
Puoi immaginare come, con un design come questo, si accenda velocemente per cercare coppie, tris, e rettilinei (le vampate sono leggermente più complicate).
Non entrerò in tutte le operazioni particolari, ma basti dire che questo tipo di modello supporta milioni di operazioni al secondo ...
Ovviamente, tieni presente che in realtà non sto sostenendo che tu usi un design come questo in una semplice implementazione di gioco. L'unico motivo per cui ho finito con questo progetto è perché avevo bisogno di condurre enormi simulazioni statistiche.
Quindi pensa attentamente a come vuoi modellare:
- Ogni carta
- La mano di un giocatore
- L'intero mazzo
- Lo stato del tavolo ... comprese tutte le mani del giocatore (inclusi i giocatori che hanno diviso la loro mano iniziale), forse una scarpa a sei mazzi, la pila degli scarti, ecc.
Il modello di applicazione generale e gli obiettivi dell'applicazione in generale determineranno in larga misura i tipi di strutture di dati che saranno più appropriate.
Divertiti !!!
Usa 'T' invece di 10.
Hai provato a sostituire J con 11, Q con 12 e K con 13? Quindi è possibile utilizzare int egers anziché char acters. Sostituisci 11-13 con la lettera appropriata in seguito.
Bene, prima di tutto, il deck [0] è un carattere, eppure stai provando a riempire " 2h " dentro. (per il momento, ignoreremo che il modo in cui lo stai facendo è sbagliato.)
Fondamentalmente, dovrai rendere il mazzo un vector<std::string>. Rendi card un array di caratteri costanti * e converti gli elementi in stringa.
quindi usa:
deck.push_back(std::string(card[j]) + suit[i]);
Come menzionato da altri, puoi usare 'T' per dieci, J, Q e K per le figure. Per quanto riguarda push_back .. poiché deck è un vettore di caratteri, è possibile passare solo un carattere a push_back come argomento. Passare sia il valore della carta (1 ... 9, T, J, Q, K) che la sua suite non funziona.
Personalmente creerei una piccola struttura, per rappresentare una carta, con una proprietà Value e una Suite. Quindi, puoi rendere il tuo mazzo un vettore di Carte.
Modificato: correzione dell'ultima parola poiché la carta vettoriale (minore di) è stata resa come vettore (nulla).
Questo potrebbe non essere compilato, ma ecco l'approccio che avrei (e usato). Vorrai usare gli ints per rappresentare le tue carte, ma puoi facilmente astrarre questo in una classe. Che scriverò per te.
class Card
{
public:
enum ESuit
{
kSuit_Heart,
kSuit_Club,
kSuit_Diamond,
kSuit_Spade,
kSuit_Count
};
enum ERank
{
kRank_Ace,
kRank_Two,
kRank_Three,
kRank_Four,
kRank_Five,
kRank_Six,
kRank_Seven,
kRank_Eight,
kRank_Nine,
kRank_Ten,
kRank_Jack,
kRank_Queen,
kRank_King,
kRank_Count
};
static int const skNumCards = kSuit_Count * kRank_Count;
Card( int cardIndex )
: mSuit( static_cast<ESuit>( cardIndex / kRank_Count ) )
, mRank( static_cast<ERank>( cardIndex % kRank_Count ) )
{}
ESuit GetSuit() const { return mSuit );
ERank GetRank() const { return mRank );
private:
ESuit mSuit;
ERank mRank;
}
Ora è molto semplice aggiungere a questa classe per ottenere tutto ciò che desideri. Per generare l'elenco è semplice come di seguito.
rstl::vector<Card> mCards;
mCards.reserve( Card::skNumCards );
for ( int cardValue = 0; cardValue < Card::skNumCards; ++cardValue )
{
mCards.push_back( Card( cardValue ) );
}
Devi mescolare?
#include <algorithm>
std::random_shuffle( mCards.begin(), mCards.end() );
Che ne dici di vedere qual è il valore della prima carta?
if ( mCards[0].GetSuit() == Card::kRank_Club && mCards[0].GetRank() == Card::kRank_Ace )
{
std::cout << "ACE OF CLUBS!" << std::endl;
}
Non ho compilato nulla di tutto ciò, ma dovrebbe essere vicino.
Poiché si tratta di un programma di blackjack, aggiungerai e confronterai il valore delle carte.
Stando così le cose, puoi risparmiarti un po 'di programmazione e dolore aggiuntivi dando alle carte i valori int (1-13) invece di caratteri .
Quando ho creato la mia classe di mazzo di carte C ++ , Ho riscontrato alcuni problemi per conto mio. Prima di tutto stavo cercando di convertire la mia classe di mazzo di carte PHP in C ++, con un minimo di fortuna. Ho deciso di sedermi e di metterlo sulla carta. Ho deciso di scegliere una configurazione orientata agli oggetti, principalmente perché ritengo sia il più semplice da utilizzare per l'espansione. Uso gli oggetti Carta e Mazzo , quindi, per esempio, se vuoi mettere 10 mazzi nella Scarpa del tuo gioco del blackjack, tu potrei creare 10 mazzi, il che sarebbe abbastanza semplice, perché ho deciso di rendere tutto autonomo. In effetti, è così autonomo, per creare la tua scarpa il codice sarebbe:
#include "AnubisCards.cpp"
int main() {
Deck *shoe = new Deck(10);
}
Ma questo era per semplicità, non esattamente necessario nei giochi più piccoli in cui è necessario un solo mazzo.
IN QUALUNQUE MODO, il modo in cui I ha generato il mazzo è stato creando un array di 52 oggetti Carta. I mazzi sono abbastanza facili, perché sai che hai 4 semi e 13 carte in ogni seme , sai anche che hai 2,3,4,5 , 6,7,8,9,10, Jack, Queen, King, Ace in ogni singolo seme . Quelli non cambieranno mai. Quindi ho usato due loop, uno per il Suit e l'altro per il Valore .
Era qualcosa del genere:
for(int suit = 1; suit <= 4; suit++){
for(int card = 1; card <= 13; card++){
// Add card to array
}
}
Ora, noterai in ognuno di questi loop, utilizzo un valore intero. Il motivo è semplice, le carte sono numeri. 4 semi. 13 valori. Anche il valore numerico nel gioco del Blackjack. Valore facciale, fino a quando non si colpiscono le carte Face, che sono un valore numerico 10 fino a quando si colpisce un Asso che è un valore numerico 1 o 11. Tutto è numeri. Quindi puoi usare quei numeri non solo per assegnare il valore della carta, ma anche il seme della carta e il numero nella sequenza numerica.
Un'idea sarebbe quella di memorizzare una mappa nella classe Card, con il nome char o String delle carte, con 1,2,3 ... che sono gli indici per ognuna.
Vorrei seguire il suggerimento di Ross di usare numeri interi. La maggior parte dei giochi di carte prevede alcuni aspetti matematici, quindi è una rappresentazione migliore.
Converti in 'A' o 'ACE' ecc. in uscita.
Dato che si tratta di compiti a casa per C ++, suppongo che dovresti usare le classi. Altrimenti usa gli enum e, se fosse C, usa una struttura o qualcosa del genere.
E per alcuni giochi, a parte il valore in punti, vorresti memorizzare una sorta di rango per la carta, che dipenderà dalla modalità di gioco corrente.
Non ho mai usato la C in chiaro per sempre, ma intendo qualcosa del genere:
typedef struct struct_card {
unsigned short int suit:2;
unsigned short int card:4;
// unsigned short int valu:4;
} card;
int main() {
card a_card;
card std_deck[52];
const unsigned short int rummy_value[13] = {1,2,3,4,5,6,7,8,9,10,10,10,10};
const char *std_card_name[13] = {"Ace","Two","Three","Four","Five","Six",
"Seven","Eight","Nine","Ten","Jack","Queen","King"};
const char *std_suit_name[4] = {"Spades","Clubs","Hearts","Diamonds"};
int j, k, i=0;
for(j=0; j<4; j++){
for(k=0; k<13; k++){
a_card.suit=j; a_card.card=k;
std_deck[i++] = a_card;
}
}
//check our work
printf("In a game of rummy:\n");
for(i=0;i<52;i++){
printf(" %-5s of %-8s is worth %2d points.\n",
std_card_name[std_deck[i].card],
std_suit_name[std_deck[i].suit],
rummy_value[std_deck[i].card]);
}
//a different kind of game.
enum round_mode {SHEILD_TRUMP, FLOWER_TRUMP, BELL_TRUMP, ACORN_TRUMP, BOCK, GEISS} mode;
const card jass_deck[36]={
{0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},
{1,1},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},
{2,2},{2,1},{2,2},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},
{3,3},{3,1},{3,2},{3,3},{3,4},{3,5},{3,6},{3,7},{3,8},
};
#define JASS_V {11,0,0,0,0,10,2,3,4}
const unsigned short int jass_value[9] = JASS_V;
#define JASS_TRUMP_V {11,0,0,0,14,10,20,3,4}
const unsigned short int jass_trump_value[9] = JASS_TRUMP_V;
#define JASS_BOCK_V {11,0,0,8,0,10,2,3,4}
const unsigned short int jass_bock_value[9] = JASS_BOCK_V;
#define JASS_GEISS_V {0,11,0,8,0,10,2,3,4}
const unsigned short int jass_geiss_value[9] = JASS_GEISS_V;
const char *jass_card_name[9] = {"Ace","Six","Seven","Eight","Nine","Banner",
"Under","Ober","King"};
const char *jass_suit_name[4] = {"Sheilds","Flowers","Bells","Acorns"};
const unsigned short int jass_all_value[6][4][9] = {
{ JASS_TRUMP_V, JASS_V, JASS_V, JASS_V },
{ JASS_V, JASS_TRUMP_V, JASS_V, JASS_V },
{ JASS_V, JASS_V, JASS_TRUMP_V, JASS_V },
{ JASS_V, JASS_V, JASS_V, JASS_TRUMP_V },
{ JASS_BOCK_V, JASS_BOCK_V, JASS_BOCK_V, JASS_BOCK_V },
{ JASS_GEISS_V, JASS_GEISS_V, JASS_GEISS_V, JASS_GEISS_V }
};
//check our work 2: work goes on summer vacation
printf("In a game of jass with trump (Sheilds | Flowers | Bells | Acorns) | Bock | Geiss\n");
for(i=0;i<36;i++){
printf(" %-6s of %-7s is worth %8d%10d%8d%9d%8d%8d\n",
jass_card_name[jass_deck[i].card],
jass_suit_name[jass_deck[i].suit],
jass_all_value[SHEILD_TRUMP][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[FLOWER_TRUMP][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[BELL_TRUMP][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[ACORN_TRUMP][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[BOCK][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[GEISS][jass_deck[i].suit][jass_deck[i].card]);
}
return 0;
}
L'output è simile a:
In a game of rummy:
Ace of Spades is worth 1 points.
Two of Spades is worth 2 points.
Three of Spades is worth 3 points.
Four of Spades is worth 4 points.
Five of Spades is worth 5 points.
...
Nine of Diamonds is worth 9 points.
Ten of Diamonds is worth 10 points.
Jack of Diamonds is worth 10 points.
Queen of Diamonds is worth 10 points.
King of Diamonds is worth 10 points.
In a game of jass with trump (Sheilds | Flowers | Bells | Acorns) | Bock | Geiss
Ace of Sheilds is worth 11 11 11 11 11 0
Six of Sheilds is worth 0 0 0 0 0 11
Seven of Sheilds is worth 0 0 0 0 0 0
Eight of Sheilds is worth 0 0 0 0 8 8
Nine of Sheilds is worth 14 0 0 0 0 0
Banner of Sheilds is worth 10 10 10 10 10 10
...
Under of Acorns is worth 2 2 2 20 2 2
Ober of Acorns is worth 3 3 3 3 3 3
King of Acorns is worth 4 4 4 4 4 4
Il Blackjack è noioso. Questo codice viene compilato.
