德州扑克小游戏（c++11及以上）

不想AC

2025-07-16 07:11:00

发布于：福建

72阅读

0回复

0点赞

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <map>
#include <set>
#include <limits>
#include <iomanip>

using namespace std;

// 扑克牌类
class Card {
	public:
		enum Suit { HEARTS, DIAMONDS, CLUBS, SPADES };
		enum Rank { TWO = 2, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE };

		Suit suit;
		Rank rank;

		Card(Suit s, Rank r) : suit(s), rank(r) {}

		string toString() const {
			string s;
			switch(rank) {
				case TWO:
					s = "2";
					break;
				case THREE:
					s = "3";
					break;
				case FOUR:
					s = "4";
					break;
				case FIVE:
					s = "5";
					break;
				case SIX:
					s = "6";
					break;
				case SEVEN:
					s = "7";
					break;
				case EIGHT:
					s = "8";
					break;
				case NINE:
					s = "9";
					break;
				case TEN:
					s = "10";
					break;
				case JACK:
					s = "J";
					break;
				case QUEEN:
					s = "Q";
					break;
				case KING:
					s = "K";
					break;
				case ACE:
					s = "A";
					break;
			}

			switch(suit) {
				case HEARTS:
					s += "红桃";
					break;
				case DIAMONDS:
					s += "方块";
					break;
				case CLUBS:
					s += "黑桃";
					break;
				case SPADES:
					s += "梅花";
					break;
			}
			return s;
		}

		// 重载小于运算符，用于排序
		bool operator<(const Card& other) const {
			return rank < other.rank;
		}
};

// 牌堆类
class Deck {
	private:
		vector<Card> cards;
		int currentIndex;

	public:
		Deck() {
			for (int s = Card::HEARTS; s <= Card::SPADES; s++) {
				for (int r = Card::TWO; r <= Card::ACE; r++) {
					cards.push_back(Card(static_cast<Card::Suit>(s), static_cast<Card::Rank>(r)));
				}
			}
			currentIndex = 0;
		}

		void shuffle() {
			srand(time(0));
			random_shuffle(cards.begin(), cards.end());
			currentIndex = 0;
		}

		Card dealCard() {
			if (currentIndex >= cards.size()) {
				throw out_of_range("Deck is empty");
			}
			return cards[currentIndex++];
		}

		void reset() {
			currentIndex = 0;
			shuffle();
		}

		int remainingCards() const {
			return cards.size() - currentIndex;
		}
};

// 手牌评估结果
struct HandValue {
	enum HandRank {
	    HIGH_CARD = 0,
	    ONE_PAIR,
	    TWO_PAIR,
	    THREE_OF_A_KIND,
	    STRAIGHT,
	    FLUSH,
	    FULL_HOUSE,
	    FOUR_OF_A_KIND,
	    STRAIGHT_FLUSH,
	    ROYAL_FLUSH
	};

	HandRank rank;
	vector<int> kickers; // 用于比较的踢脚牌

	// 用于比较两个手牌的大小
	bool operator<(const HandValue& other) const {
		if (rank != other.rank) {
			return rank < other.rank;
		}

		for (size_t i = 0; i < kickers.size(); i++) {
			if (kickers[i] != other.kickers[i]) {
				return kickers[i] < other.kickers[i];
			}
		}

		return false; // 完全相等
	}

	string rankToString() const {
		switch(rank) {
			case HIGH_CARD:
				return "High Card";
			case ONE_PAIR:
				return "One Pair";
			case TWO_PAIR:
				return "Two Pairs";
			case THREE_OF_A_KIND:
				return "Three of a Kind";
			case STRAIGHT:
				return "Straight";
			case FLUSH:
				return "Flush";
			case FULL_HOUSE:
				return "Full House";
			case FOUR_OF_A_KIND:
				return "Four of a Kind";
			case STRAIGHT_FLUSH:
				return "Straight Flush";
			case ROYAL_FLUSH:
				return "Royal Flush";
			default:
				return "Unknown";
		}
	}
};

// 手牌评估器
class HandEvaluator {
	public:
		static HandValue evaluateHand(const vector<Card>& cards) {
			vector<Card> sorted = cards;
			sort(sorted.rbegin(), sorted.rend()); // 降序排序

			// 检查同花和顺子
			bool isFlush = checkFlush(sorted);
			bool isStraight = checkStraight(sorted);
			int straightHighCard = 0;

			if (isStraight) {
				straightHighCard = getStraightHighCard(sorted);
			}

			// 皇家同花顺
			if (isFlush && isStraight && straightHighCard == Card::ACE) {
				return {HandValue::ROYAL_FLUSH, {Card::ACE}};
			}

			// 同花顺
			if (isFlush && isStraight) {
				return {HandValue::STRAIGHT_FLUSH, {straightHighCard}};
			}

			// 四条
			vector<int> ranks = getRanks(sorted);
			map<int, int> rankCount;
			for (int r : ranks) {
				rankCount[r]++;
			}

			// 查找四条
			for (auto it = rankCount.rbegin(); it != rankCount.rend(); ++it) {
				if (it->second == 4) {
					int fourRank = it->first;
					int kicker = 0;
					for (int r : ranks) {
						if (r != fourRank) {
							kicker = r;
							break;
						}
					}
					return {HandValue::FOUR_OF_A_KIND, {fourRank, kicker}};
				}
			}

			// 葫芦
			int threeRank = 0;
			int twoRank = 0;
			for (auto it = rankCount.rbegin(); it != rankCount.rend(); ++it) {
				if (it->second == 3 && threeRank == 0) {
					threeRank = it->first;
				} else if (it->second >= 2 && twoRank == 0) {
					twoRank = it->first;
				}
			}

			if (threeRank > 0 && twoRank > 0) {
				return {HandValue::FULL_HOUSE, {threeRank, twoRank}};
			}

			// 同花
			if (isFlush) {
				vector<int> highCards;
				for (const Card& card : sorted) {
					highCards.push_back(card.rank);
					if (highCards.size() == 5) break;
				}
				return {HandValue::FLUSH, highCards};
			}

			// 顺子
			if (isStraight) {
				return {HandValue::STRAIGHT, {straightHighCard}};
			}

			// 三条
			if (threeRank > 0) {
				vector<int> kickers;
				for (auto it = rankCount.rbegin(); it != rankCount.rend(); ++it) {
					if (it->first != threeRank) {
						kickers.push_back(it->first);
						if (kickers.size() == 2) break;
					}
				}
				return {HandValue::THREE_OF_A_KIND, {threeRank, kickers[0], kickers[1]}};
			}

			// 两对
			vector<int> pairRanks;
			for (auto it = rankCount.rbegin(); it != rankCount.rend(); ++it) {
				if (it->second == 2) {
					pairRanks.push_back(it->first);
				}
			}

			if (pairRanks.size() >= 2) {
				sort(pairRanks.rbegin(), pairRanks.rend());
				int kicker = 0;
				for (auto it = rankCount.rbegin(); it != rankCount.rend(); ++it) {
					if (it->second == 1 && it->first != pairRanks[0] && it->first != pairRanks[1]) {
						kicker = it->first;
						break;
					}
				}
				return {HandValue::TWO_PAIR, {pairRanks[0], pairRanks[1], kicker}};
			}

			// 一对
			if (pairRanks.size() == 1) {
				vector<int> kickers;
				for (auto it = rankCount.rbegin(); it != rankCount.rend(); ++it) {
					if (it->second == 1) {
						kickers.push_back(it->first);
						if (kickers.size() == 3) break;
					}
				}
				return {HandValue::ONE_PAIR, {pairRanks[0], kickers[0], kickers[1], kickers[2]}};
			}

			// 高牌
			vector<int> highCards;
			for (const Card& card : sorted) {
				highCards.push_back(card.rank);
				if (highCards.size() == 5) break;
			}
			return {HandValue::HIGH_CARD, highCards};
		}

	private:
		static bool checkFlush(const vector<Card>& cards) {
			map<Card::Suit, int> suitCount;
			for (const Card& card : cards) {
				suitCount[card.suit]++;
				if (suitCount[card.suit] >= 5) {
					return true;
				}
			}
			return false;
		}

		static bool checkStraight(const vector<Card>& cards) {
			if (cards.size() < 5) return false;

			set<int> uniqueRanks;
			for (const Card& card : cards) {
				uniqueRanks.insert(card.rank);
			}

			vector<int> sortedRanks(uniqueRanks.begin(), uniqueRanks.end());
			sort(sortedRanks.rbegin(), sortedRanks.rend());

			// 检查普通顺子
			int consecutive = 1;
			for (size_t i = 1; i < sortedRanks.size(); i++) {
				if (sortedRanks[i-1] == sortedRanks[i] + 1) {
					consecutive++;
					if (consecutive >= 5) {
						return true;
					}
				} else {
					consecutive = 1;
				}
			}

			// 检查A-5-4-3-2顺子
			if (sortedRanks.front() == Card::ACE) {
				vector<int> wheel = {Card::FIVE, Card::FOUR, Card::THREE, Card::TWO};
				bool hasWheel = true;
				for (int r : wheel) {
					if (uniqueRanks.find(r) == uniqueRanks.end()) {
						hasWheel = false;
						break;
					}
				}
				if (hasWheel) {
					return true;
				}
			}

			return false;
		}

		static int getStraightHighCard(const vector<Card>& cards) {
			set<int> uniqueRanks;
			for (const Card& card : cards) {
				uniqueRanks.insert(card.rank);
			}

			vector<int> sortedRanks(uniqueRanks.begin(), uniqueRanks.end());
			sort(sortedRanks.rbegin(), sortedRanks.rend());

			// 检查普通顺子
			int consecutive = 1;
			int highCard = sortedRanks[0];
			for (size_t i = 1; i < sortedRanks.size(); i++) {
				if (sortedRanks[i-1] == sortedRanks[i] + 1) {
					consecutive++;
					if (consecutive >= 5) {
						return highCard;
					}
				} else {
					consecutive = 1;
					highCard = sortedRanks[i];
				}
			}

			// 检查A-5-4-3-2顺子
			if (sortedRanks.front() == Card::ACE) {
				vector<int> wheel = {Card::FIVE, Card::FOUR, Card::THREE, Card::TWO};
				bool hasWheel = true;
				for (int r : wheel) {
					if (uniqueRanks.find(r) == uniqueRanks.end()) {
						hasWheel = false;
						break;
					}
				}
				if (hasWheel) {
					return Card::FIVE; // A-5-4-3-2顺子的高牌是5
				}
			}

			return 0;
		}

		static vector<int> getRanks(const vector<Card>& cards) {
			vector<int> ranks;
			for (const Card& card : cards) {
				ranks.push_back(card.rank);
			}
			sort(ranks.rbegin(), ranks.rend());
			return ranks;
		}
};

// 玩家基类
class Player {
	protected:
		string name;
		int chips;
		vector<Card> hand;
		bool folded;
		bool isHuman;

	public:
		Player(string n, int c, bool human = false) : name(n), chips(c), folded(false), isHuman(human) {}

		virtual ~Player() {}

		void dealCard(Card card) {
			hand.push_back(card);
		}

		void clearHand() {
			hand.clear();
			folded = false;
		}

		void fold() {
			folded = true;
		}

		bool isFolded() const {
			return folded;
		}

		string getName() const {
			return name;
		}

		int getChips() const {
			return chips;
		}

		void addChips(int amount) {
			chips += amount;
		}

		void deductChips(int amount) {
			chips -= amount;
		}

		const vector<Card>& getHand() const {
			return hand;
		}

		bool isHumanPlayer() const {
			return isHuman;
		}

		virtual int makeDecision(int currentBet, int minRaise) = 0;

		// 新增：换牌功能
		virtual void replaceCard(Deck& deck) = 0;

		void displayHand(bool showAll = false) const {
			cout << name << " (" << chips << " chips): ";
			if (folded) {
				cout << "Folded";
			} else if (showAll || isHuman) {
				for (const Card& card : hand) {
					cout << card.toString() << " ";
				}
			} else {
				cout << "?? ??";
			}
			cout << endl;
		}

		HandValue evaluateHand(const vector<Card>& communityCards) const {
			vector<Card> allCards = hand;
			allCards.insert(allCards.end(), communityCards.begin(), communityCards.end());
			return HandEvaluator::evaluateHand(allCards);
		}
};

// 人类玩家
class HumanPlayer : public Player {
	public:
		HumanPlayer(string name, int chips) : Player(name, chips, true) {}

		int makeDecision(int currentBet, int minRaise) override {
			cout << "\nYour turn, " << name << "! Current bet: " << currentBet << ", Your chips: " << chips << endl;
			cout << "Your hand: " << hand[0].toString() << " " << hand[1].toString() << endl;

			while (true) {
				cout << "Options: 1. Fold 2. Call (" << currentBet << ") 3. Raise" << endl;
				cout << "Enter choice: ";

				int choice;
				cin >> choice;

				if (cin.fail()) {
					cin.clear();
					cin.ignore(numeric_limits<streamsize>::max(), '\n');
					cout << "Invalid input. Please enter a number." << endl;
					continue;
				}

				switch(choice) {
					case 1: // Fold
						fold();
						return 0;

					case 2: // Call
						if (chips < currentBet) {
							cout << "You don't have enough chips to call. Going all-in!" << endl;
							int amount = chips;
							deductChips(amount);
							return amount;
						}
						deductChips(currentBet);
						return currentBet;

					case 3: { // Raise
						int raiseAmount;
						cout << "Enter raise amount (min " << minRaise << "): ";
						cin >> raiseAmount;

						if (raiseAmount < minRaise) {
							cout << "Raise amount too small. Minimum is " << minRaise << endl;
							continue;
						}

						int total = currentBet + raiseAmount;
						if (total > chips) {
							cout << "You don't have enough chips. Going all-in!" << endl;
							int amount = chips;
							deductChips(amount);
							return amount;
						}

						deductChips(total);
						return total;
					}

					default:
						cout << "Invalid choice. Please try again." << endl;
				}
			}
		}

		// 人类玩家换牌
		void replaceCard(Deck& deck) override {
			if (deck.remainingCards() < 3) {
				cout << "Not enough cards in deck for replacement." << endl;
				return;
			}

			cout << "\n--- REPLACEMENT ROUND ---" << endl;
			cout << "Your current hand: " << hand[0].toString() << " " << hand[1].toString() << endl;

			// 抽三张新牌
			vector<Card> options;
			for (int i = 0; i < 3; i++) {
				options.push_back(deck.dealCard());
			}

			cout << "Replacement options:\n";
			for (int i = 0; i < 3; i++) {
				cout << (i+1) << ". " << options[i].toString() << endl;
			}
			cout << "4. Keep current hand (no replacement)\n";

			while (true) {
				cout << "Choose an option (1-4): ";
				int choice;
				cin >> choice;

				if (choice >= 1 && choice <= 3) {
					// 选择替换哪张牌
					cout << "Which card to replace? (1 for first, 2 for second): ";
					int cardChoice;
					cin >> cardChoice;

					if (cardChoice == 1 || cardChoice == 2) {
						Card newCard = options[choice-1];
						Card oldCard = hand[cardChoice-1];
						hand[cardChoice-1] = newCard;

						cout << "Replaced " << oldCard.toString() << " with " << newCard.toString() << endl;
						cout << "New hand: " << hand[0].toString() << " " << hand[1].toString() << endl;
						break;
					} else {
						cout << "Invalid card choice." << endl;
					}
				} else if (choice == 4) {
					cout << "Keeping current hand.\n";
					break;
				} else {
					cout << "Invalid choice. Please enter 1-4.\n";
				}
			}
		}
};

// AI玩家
class AIPlayer : public Player {
	public:
		AIPlayer(string name, int chips) : Player(name, chips) {}

		int makeDecision(int currentBet, int minRaise) override {
			// 简单的AI决策逻辑
			double handStrength = evaluateHandStrength();
			double decisionFactor = static_cast<double>(rand()) / RAND_MAX;

			if (folded) {
				return 0;
			}

			// 如果当前下注超过一半筹码且手牌不强，弃牌
			if (currentBet > chips * 0.5 && handStrength < 0.4) {
				fold();
				return 0;
			}

			// 如果当前下注很高且手牌不强，弃牌
			if (currentBet > chips * 0.3 && handStrength < 0.3) {
				fold();
				return 0;
			}

			// 如果没人下注或手牌很强，可能加注
			if (currentBet == 0 || handStrength > 0.7) {
				if (decisionFactor < 0.3 && chips > minRaise) { // 30%概率加注
					int raise = minRaise + static_cast<int>((chips * 0.1 * decisionFactor));
					if (raise > chips) raise = chips;
					deductChips(raise);
					return raise;
				}
			}

			// 跟注
			if (currentBet > chips) {
				int amount = chips;
				deductChips(amount);
				return amount;
			}

			deductChips(currentBet);
			return currentBet;
		}

		// AI玩家换牌
		void replaceCard(Deck& deck) override {
			if (deck.remainingCards() < 3) {
				return;
			}

			// 抽三张新牌
			vector<Card> options;
			for (int i = 0; i < 3; i++) {
				options.push_back(deck.dealCard());
			}

			// 评估当前手牌强度
			double currentStrength = evaluateHandStrength();

			// 尝试每张替换选项
			double bestOptionStrength = currentStrength;
			int bestOptionIdx = -1;
			int bestCardToReplace = -1;

			for (int i = 0; i < 3; i++) {
				// 尝试替换第一张牌
				Card original0 = hand[0];
				hand[0] = options[i];
				double strength0 = evaluateHandStrength();
				hand[0] = original0;

				// 尝试替换第二张牌
				Card original1 = hand[1];
				hand[1] = options[i];
				double strength1 = evaluateHandStrength();
				hand[1] = original1;

				// 记录最佳选项
				if (strength0 > bestOptionStrength) {
					bestOptionStrength = strength0;
					bestOptionIdx = i;
					bestCardToReplace = 0;
				}
				if (strength1 > bestOptionStrength) {
					bestOptionStrength = strength1;
					bestOptionIdx = i;
					bestCardToReplace = 1;
				}
			}

			// 如果找到更好的牌则替换
			if (bestOptionStrength > currentStrength + 0.1) { // 需要显著提升
				Card newCard = options[bestOptionIdx];
				Card oldCard = hand[bestCardToReplace];
				hand[bestCardToReplace] = newCard;

				cout << name << " replaced " << oldCard.toString() << " with " << newCard.toString() << endl;
			} else {
				// 10%概率随机替换
				if (rand() % 10 == 0) {
					int cardToReplace = rand() % 2;
					int optionIdx = rand() % 3;

					Card newCard = options[optionIdx];
					Card oldCard = hand[cardToReplace];
					hand[cardToReplace] = newCard;

					cout << name << " randomly replaced " << oldCard.toString() << " with " << newCard.toString() << endl;
				} else {
					cout << name << " kept current hand." << endl;
				}
			}
		}

	private:
		double evaluateHandStrength() {
			// 简化的手牌强度评估
			int rank1 = hand[0].rank;
			int rank2 = hand[1].rank;
			int suit1 = hand[0].suit;
			int suit2 = hand[1].suit;

			// 对子
			if (rank1 == rank2) {
				// 高对更强
				double base = 0.8;
				if (rank1 >= Card::TEN) base += 0.15;
				else if (rank1 >= Card::SEVEN) base += 0.05;
				return base;
			}

			// 同花
			if (suit1 == suit2) {
				// 高牌同花更强
				double base = 0.6;
				int maxRank = max(rank1, rank2);
				if (maxRank >= Card::JACK) base += 0.2;
				else if (maxRank >= Card::NINE) base += 0.1;
				return base;
			}

			// 高牌
			double strength = 0.0;
			int maxRank = max(rank1, rank2);
			int minRank = min(rank1, rank2);

			if (maxRank >= Card::ACE) strength = 0.7;
			else if (maxRank >= Card::KING) strength = 0.6;
			else if (maxRank >= Card::QUEEN) strength = 0.55;
			else if (maxRank >= Card::JACK) strength = 0.5;
			else if (maxRank >= Card::TEN) strength = 0.45;
			else strength = 0.3;

			// 连牌加成
			if (abs(rank1 - rank2) == 1) {
				strength += 0.15;
			}
			// 同花加成
			if (suit1 == suit2) {
				strength += 0.1;
			}

			return strength;
		}
};

// 游戏类
class TexasHoldemGame {
	private:
		Deck deck;
		vector<Player*> players;
		vector<Card> communityCards;
		int pot;
		int currentBet;
		int dealerPosition;
		int smallBlind;
		int bigBlind;

	public:
		TexasHoldemGame(int numAI, int initialChips) : pot(0), currentBet(0), dealerPosition(0), smallBlind(5), bigBlind(10) {
			// 创建人类玩家
			players.push_back(new HumanPlayer("You", initialChips));

			// 创建AI玩家
			for (int i = 1; i <= numAI; i++) {
				players.push_back(new AIPlayer("AI Player " + to_string(i), initialChips));
			}

			deck.shuffle();
		}

		~TexasHoldemGame() {
			for (Player* p : players) {
				delete p;
			}
		}

		void startGame() {
			while (true) {
				cout << "\n\n===== NEW ROUND STARTING =====" << endl;
				resetRound();
				dealCards();
				postBlinds();

				// 翻牌前下注
				bettingRound();

				// 新增：换牌阶段
				if (countActivePlayers() > 1) {
					replacementRound();
				}

				// 如果多于一个玩家，发翻牌
				if (countActivePlayers() > 1) {
					dealFlop();
					bettingRound();

					// 发转牌
					if (countActivePlayers() > 1) {
						dealTurn();
						bettingRound();

						// 发河牌
						if (countActivePlayers() > 1) {
							dealRiver();
							bettingRound();
						}
					}
				}

				// 摊牌
				showDown();

				// 检查玩家是否还有筹码
				removeBankruptPlayers();

				// 如果只剩一个玩家，游戏结束
				if (players.size() == 1) {
					cout << "\nGame over! " << players[0]->getName() << " wins!" << endl;
					break;
				}

				// 移动庄家位置
				dealerPosition = (dealerPosition + 1) % players.size();

				// 询问是否继续
				cout << "\nPlay another round? (1=Yes, 0=No): ";
				int choice;
				cin >> choice;
				if (choice == 0) {
					break;
				}
			}
		}

	private:
		void resetRound() {
			pot = 0;
			currentBet = 0;
			communityCards.clear();
			deck.reset();

			for (Player* p : players) {
				p->clearHand();
			}
		}

		void dealCards() {
			// 每人发两张牌
			for (int i = 0; i < 2; i++) {
				for (Player* p : players) {
					p->dealCard(deck.dealCard());
				}
			}
		}

		void postBlinds() {
			int sbPos = (dealerPosition + 1) % players.size();
			int bbPos = (dealerPosition + 2) % players.size();

			Player* sb = players[sbPos];
			Player* bb = players[bbPos];

			int sbAmount = min(smallBlind, sb->getChips());
			int bbAmount = min(bigBlind, bb->getChips());

			sb->deductChips(sbAmount);
			bb->deductChips(bbAmount);

			pot += sbAmount + bbAmount;
			currentBet = bbAmount;

			cout << sb->getName() << " posts small blind: " << sbAmount << endl;
			cout << bb->getName() << " posts big blind: " << bbAmount << endl;
		}

		void bettingRound() {
			int startPos = (dealerPosition + 3) % players.size();
			int currentPos = startPos;
			int lastRaisePos = -1;
			int activePlayers = countActivePlayers();
			int playersActed = 0;

			while (playersActed < activePlayers && (lastRaisePos == -1 || currentPos != lastRaisePos)) {
				Player* currentPlayer = players[currentPos];

				if (!currentPlayer->isFolded() && currentPlayer->getChips() > 0) {
					displayGameState();
					int amount = currentPlayer->makeDecision(currentBet, bigBlind);

					if (amount > currentBet) {
						currentBet = amount;
						lastRaisePos = currentPos;
						playersActed = 0;
					}

					pot += amount;
					playersActed++;
				}

				currentPos = (currentPos + 1) % players.size();
			}

			currentBet = 0; // Reset current bet for next round
		}

		// 新增：换牌阶段
		void replacementRound() {
			cout << "\n--- REPLACEMENT PHASE ---" << endl;
			cout << "Each player can replace one card from three new options." << endl;

			for (Player* p : players) {
				if (!p->isFolded() && p->getChips() > 0) {
					p->replaceCard(deck);
				}
			}

			cout << "--- END OF REPLACEMENT PHASE ---" << endl;
		}

		void dealFlop() {
			deck.dealCard(); // Burn a card
			for (int i = 0; i < 3; i++) {
				communityCards.push_back(deck.dealCard());
			}

			cout << "\nFlop: ";
			displayCommunityCards();
		}

		void dealTurn() {
			deck.dealCard(); // Burn a card
			communityCards.push_back(deck.dealCard());

			cout << "\nTurn: ";
			displayCommunityCards();
		}

		void dealRiver() {
			deck.dealCard(); // Burn a card
			communityCards.push_back(deck.dealCard());

			cout << "\nRiver: ";
			displayCommunityCards();
		}

		void showDown() {
			cout << "\n===== SHOWDOWN =====" << endl;
			displayGameState(true);

			// 找出未弃牌的玩家
			vector<Player*> activePlayers;
			for (Player* p : players) {
				if (!p->isFolded()) {
					activePlayers.push_back(p);
				}
			}

			if (activePlayers.empty()) {
				cout << "All players folded! Pot remains for next round." << endl;
				return;
			}

			if (activePlayers.size() == 1) {
				// 只有一个玩家未弃牌，赢得底池
				activePlayers[0]->addChips(pot);
				cout << activePlayers[0]->getName() << " wins " << pot << " chips!" << endl;
			} else {
				// 评估所有玩家的手牌
				vector<pair<Player*, HandValue>> playerHands;
				for (Player* p : activePlayers) {
					HandValue hv = p->evaluateHand(communityCards);
					playerHands.push_back({p, hv});
				}

				// 找出最佳手牌
				auto bestHand = max_element(playerHands.begin(), playerHands.end(),
				[](const pair<Player*, HandValue>& a, const pair<Player*, HandValue>& b) {
					return a.second < b.second;
				});

				// 检查是否有多个赢家（平局）
				vector<Player*> winners;
				for (const auto& ph : playerHands) {
					if (!(ph.second < bestHand->second) && !(bestHand->second < ph.second)) {
						winners.push_back(ph.first);
					}
				}

				// 分配底池
				if (winners.size() == 1) {
					winners[0]->addChips(pot);
					cout << winners[0]->getName() << " wins " << pot << " chips with "
					     << bestHand->second.rankToString() << "!" << endl;
				} else {
					int share = pot / winners.size();
					for (Player* winner : winners) {
						winner->addChips(share);
					}
					cout << "Split pot! Winners (" << winners.size() << " players) each get "
					     << share << " chips with " << bestHand->second.rankToString() << "!" << endl;
				}
			}

			pot = 0;
		}

		void displayGameState(bool showAll = false) const {
			cout << "\nCurrent pot: " << pot << endl;
			cout << "Community cards: ";
			for (const Card& card : communityCards) {
				cout << card.toString() << " ";
			}
			cout << endl;

			for (const Player* p : players) {
				p->displayHand(showAll);
			}
		}

		void displayCommunityCards() const {
			for (const Card& card : communityCards) {
				cout << card.toString() << " ";
			}
			cout << endl;
		}

		int countActivePlayers() const {
			int count = 0;
			for (const Player* p : players) {
				if (!p->isFolded() && p->getChips() > 0) {
					count++;
				}
			}
			return count;
		}

		void removeBankruptPlayers() {
			for (auto it = players.begin(); it != players.end(); ) {
				if ((*it)->getChips() <= 0) {
					cout << (*it)->getName() << " is out of the game!" << endl;
					delete *it;
					it = players.erase(it);
				} else {
					++it;
				}
			}
		}
};

int main() {
	srand(time(0));

	cout << "Welcome to Texas Hold'em Poker with Card Replacement!" << endl;
	cout << "How many AI players? (1-5): ";
	int numAI;
	cin >> numAI;

	if (numAI < 1 || numAI > 5) {
		cout << "Invalid number. Setting to 3." << endl;
		numAI = 3;
	}

	TexasHoldemGame game(numAI, 1000);
	game.startGame();

	cout << "Thanks for playing!" << endl;
	return 0;
}

有帮助，赞一个

去预览

0/2000

全部评论 16

不想AC
666

2025-07-15 来自福建
1
不想AC
太棒了

2025-07-14 来自福建
1
‮🐱‍🚀
6

2025-07-18 来自广东
0
不想AC
wow

2025-07-17 来自福建
0
不想AC
要c++11及以上

2025-07-16 来自福建
0
夕阳的刻痕_王煜宸·皮皮虾
溯望月

2025-07-15 来自浙江
0
老登转世
226 39 C:\Users\Administrator\Desktop\未命名1.cpp [Error] expected ';' before 'it'

2025-07-15 来自四川
0
- ‮༺དༀ༒∞░∞༒ༀཌ༻
  回复老登转世
  没问题啊
  
  2025-07-17 来自浙江
  0
老登转世
226 14 C:\Users\Administrator\Desktop\未命名1.cpp [Error] 'it' does not name a type

2025-07-15 来自四川
0
老登转世
221 17 C:\Users\Administrator\Desktop\未命名1.cpp [Error] range-based 'for' loops are not allowed in C++98 mode

2025-07-15 来自四川
0
老登转世
215 58 C:\Users\Administrator\Desktop\未命名1.cpp [Error] converting to 'stdvector<int>' from initializer list would use explicit constructor 'stdvector<_Tp, _Alloc>vector(stdvector<_Tp, _Alloc>size_type, const value_type&, const allocator_type&) [with _Tp = int; _Alloc = stdallocator<int>; std::vector<_Tp, _Alloc>size_type = long long unsigned int; stdvector<_Tp, _Alloc>value_type = int; stdvector<_Tp, _Alloc>allocator_type = stdallocator<int>]'

2025-07-15 来自四川
0
老登转世
210 48 C:\Users\Administrator\Desktop\未命名1.cpp [Error] converting to 'stdvector<int>' from initializer list would use explicit constructor 'stdvector<_Tp, _Alloc>vector(stdvector<_Tp, _Alloc>size_type, const value_type&, const allocator_type&) [with _Tp = int; _Alloc = stdallocator<int>; std::vector<_Tp, _Alloc>size_type = long long unsigned int; stdvector<_Tp, _Alloc>value_type = int; stdvector<_Tp, _Alloc>allocator_type = stdallocator<int>]'

2025-07-15 来自四川
0
老登转世
116 39 C:\Users\Administrator\Desktop\未命名1.cpp [Error] 'out_of_range' was not declared in this scope

2025-07-15 来自四川
0
老登转世
编译单个文件...

文件名: C:\Users\Administrator\Desktop\未命名1.cpp

编译器名: TDM-GCC 4.9.2 64-bit Release

处理 C++ 源文件...

C++ 编译器: C:\Program Files (x86)\Dev-Cpp\MinGW64\bin\g++.exe

命令: g++.exe "C:\Users\Administrator\Desktop\未命名1.cpp" -o "C:\Users\Administrator\Desktop\未命名1.exe" -I"C:\Program Files (x86)\Dev-Cpp\MinGW64\include" -I"C:\Program Files (x86)\Dev-Cpp\MinGW64\x86_64-w64-mingw32\include" -I"C:\Program Files (x86)\Dev-Cpp\MinGW64\lib\gcc\x86_64-w64-mingw32\4.9.2\include" -I"C:\Program Files (x86)\Dev-Cpp\MinGW64\lib\gcc\x86_64-w64-mingw32\4.9.2\include\c++" -L"C:\Program Files (x86)\Dev-Cpp\MinGW64\lib" -L"C:\Program Files (x86)\Dev-Cpp\MinGW64\x86_64-w64-mingw32\lib" -static-libgcc
C:\Users\Administrator\Desktop\未命名1.cpp: In member function 'Card Deck::dealCard()':
C:\Users\Administrator\Desktop\未命名1.cpp:116:39: error: 'out_of_range' was not declared in this scope
throw out_of_range("Deck is empty");
^

C:\Users\Administrator\Desktop\未命名1.cpp: In static member function 'static HandValue HandEvaluatorevaluateHand(const stdvector<Card>&)':
C:\Users\Administrator\Desktop\未命名1.cpp:210:12: warning: extended initializer lists only available with -std=c11 or -std=gnu11
return {HandValueROYAL_FLUSH, {CardACE}};
^
C:\Users\Administrator\Desktop\未命名1.cpp:210:48: warning: extended initializer lists only available with -std=c11 or -std=gnu11
return {HandValueROYAL_FLUSH, {CardACE}};
^
C:\Users\Administrator\Desktop\未命名1.cpp:210:48: warning: extended initializer lists only available with -std=c11 or -std=gnu11
C:\Users\Administrator\Desktop\未命名1.cpp:210:48: error: converting to 'stdvector<int>' from initializer list would use explicit constructor 'stdvector<_Tp, _Alloc>vector(stdvector<_Tp, _Alloc>size_type, const value_type&, const allocator_type&) [with _Tp = int; _Alloc = stdallocator<int>; std::vector<_Tp,
2025-07-15 来自四川
0
老登转世
116行错了
throw out_of_range("Deck is empty ")；

2025-07-15 来自四川
0
- ‮༺དༀ༒∞░∞༒ༀཌ༻
  回复老登转世
  没问题。要11以上
  
  2025-07-17 来自浙江
  0
复仇者_帅童一定要记得退账号
%%%

2025-07-15 来自湖南
0
- 不想AC
  回复复仇者_帅童一定要记得退账号
  怎么说
  
  2025-07-15 来自福建
  1
AAA混泥土批发ppl哥
AI

2025-07-15 来自浙江
0

全部评论 16

编译单个文件...

处理 C++ 源文件...

热门讨论