Blackjack simple avec dev-cpp

Télécharger le projet
Commenter

Description

Et oui, encore un BlackJack avec Dev-cpp en interface DOS.

Source / Exemple : 


#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <cctype>

typedef enum { Trefles = 0, Carreaux, Coeur, Pike } Suit;
typedef enum { Continue, Win, Bust } State;
typedef struct  {
	Suit suit;
	char value;
} Card;

class Deck {
public:
	Deck() {
		cards = new Card[52];
		CreateDeck();
	}

	~Deck() {
		delete[] cards;
	}

	void CreateDeck() {
		for(int x = 0; x < 4; ++x) {
			for(int i = 1; i <= 13; ++i) {
				cards[i + (x * 13) - 1].suit = static_cast<Suit>(x);
				cards[i + (x * 13) - 1].value = i;
			}
		}
		deck = 52;
		MelangeDeck();
	}
			
	void MelangeDeck() {
		for(int x = 0; x < 4; ++x) {
			for(int i = 1; i <= 13; ++i) {
				std::swap(cards[i + (x * 13) - 1], cards[rand() % 52]);
			}
		}

		int melange = 3;
		do { 
			for(int x = 0; x < 2; ++x) { 
				for(int i = 1; i < 13; ++i) { 
					std::swap(cards[i + (x * 13) - 1], cards[(i+2) + (x * 13)]);
				}
			}
		} while(--melange);
	}

	Card DrawCard() {
		if(deck <= 0) {
			Card c = { static_cast<Suit>(-1), 0 };
			return c;
		}
		return cards[--deck];
	}

	void ShowCard(int i) {
		ShowCard(cards[i]);
	}

	void ShowCard(Card card) {
		Suit suit = card.suit;
		int value = card.value;

		switch(value) {
			case 1: std::cout << "As de "; break;
			case 11: std::cout << "Chevalier de "; break;
			case 12: std::cout << "Renne de "; break;
			case 13: std::cout << "Roi de "; break;
			default: std::cout << value << " de ";
		}

		switch(suit) {
			case Trefles: std::cout << "Trefles"; break;
			case Carreaux: std::cout << "Carreaux"; break;
			case Coeur: std::cout << "Coeur"; break;
			case Pike: std::cout << "Pike"; break;
		}
		std::cout << std::endl;
	}

private:
	Card *cards;
	int deck;
};

class BlackJack : public Deck {
public:
	BlackJack() {
		croupier.score = croupier.index = 0;
		croupier.cards = new Card[12];

		joueur.score = joueur.index = 0;
		joueur.cards = new Card[12];
	}

	~BlackJack() {
		delete[] croupier.cards;
		delete[] joueur.cards;
	}

	State give_joueur_card(void) {
		Card card = this->DrawCard();
		if(!card.value)
			return Bust;

		joueur.cards[joueur.index++] = card;
		joueur.score = count_cards(joueur.cards, joueur.index);

		if(joueur.score > 21)
			return Bust;
		else if(joueur.score == 21)
			return Win;

		return Continue;
	}

	State give_croupier_card(void) {
		Card card = this->DrawCard();
		if(!card.value)
			return Bust;

		croupier.cards[croupier.index++] = card;
		croupier.score = count_cards(croupier.cards, croupier.index);

		if(croupier.score > 21)
			return Bust;
		else if(joueur.score == 21)
			return Win;

		return Continue;
	}

	void show_joueur_cards(void) {
		std::cout << "         Cartes du joueur" << std::endl;
		ShowCards(joueur.cards, joueur.index);
		std::cout << std::endl;
	}

	void show_croupier_cards(bool show_all) {
		std::cout << "         Cartes du Croupier" << std::endl;
		if(show_all) {
			ShowCards(croupier.cards, croupier.index);
			std::cout << "Score: " << croupier.score;
		} else
			ShowCards(croupier.cards+1, croupier.index-1);

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

	int get_joueur_score(void) { return joueur.score; }
	int get_croupier_score(void) { return croupier.score; }

	void ShowCards(Card *cards, int size) {
		for(int i = 0; i < size; ++i)
			ShowCard(cards[i]);
	}

private:
	struct {
		int score, index;
		Card *cards;
	} croupier, joueur;

	int count_cards(Card *cards, int size) {
		int total = 0;
		bool CAs = false;

		for(int i = 0; i < size; ++i) {
			if(CAs && size > 2) {
				total -= 10;
				CAs = false;
			}

			if(cards[i].value == 1) {
				if((total + 11) < 21) {
					total += 10;
					CAs = true;
				}
				++total;
			} else if(cards[i].value >= 10)
				total += 10;
			else
				total += cards[i].value;
		}
		return total;
	}
};

int main(void)
{
	srand(time(0));
	BlackJack *jack = new BlackJack();
	bool busted = false, joueur_hit = true;
	State croup, joueur;
	std::string message = "";

	jack->give_croupier_card();
	jack->give_joueur_card();

	do { 
		int cscore = jack->get_croupier_score();
		if(cscore < 15) croup = jack->give_croupier_card();

		if(joueur_hit) joueur = jack->give_joueur_card();
		int jscore = jack->get_joueur_score();

		char b = 0;
		if(jscore <= 21 && cscore <= 21) {
			do {
				jack->show_croupier_cards(false);
				jack->show_joueur_cards();

				std::cout << "Que voulez vous faire?  " << jscore << ") [P=Prendre/L=Laisser] ";
				std::cin >> b; b = std::toupper(b);
			} while(b != 'P' && b != 'L');
		}
		joueur_hit = (b == 'P');

		if(!joueur_hit) {
			while(cscore < 15) {
				croup = jack->give_croupier_card();
				cscore = jack->get_croupier_score();
			}

			if(jscore > cscore || joueur == Win || croup == Bust)
				message = "Gagnant!!!";
			else if(cscore > jscore || croup == Win || joueur == Bust)
				message = "Perdu";
			else if(cscore == jscore)
				message = "Dommage";

			break;
		}
		busted = (joueur == Bust || croup == Bust);
	} while(!busted);

	std::cout << "+---- " << message << " ----+" << std::endl << std::endl;

	jack->show_croupier_cards(true);
	std::cout << std::endl;

	jack->show_joueur_cards();
	std::cout << "Score: " << jack->get_joueur_score() << std::endl;
              system("pause");
	return 0;
	
}
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.