using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public enum PlayerAction
{
Look = 0,
Compare = 1,
Call = 2,
Raise = 3,
Fold = 4
}
public enum HandRank
{
HighCard = 0,
Pair = 1,
Flush = 3,
Straight = 2,
StraightFlush = 4,
ThreeOfAKind = 5
}
public class GameManager : MonoBehaviour
{
public static GameManager Instance;
[Header("游戏设置")]
public int smallBlind = 10;
public int bigBlind = 20;
public int maxRaiseMultiplier = 4;
[Header("组件引用")]
public PokerUIManager uiManager;
[Header("游戏状态")]
public Player[] players;
public int currentPlayerIndex = 0;
public int startingPlayerIndex = 0;
public int currentRound = 1;
public int pot = 0;
public int currentBet = 10;
public bool isBlindBetting = true;
// 私有变量
private List<Card> deck = new List<Card>();
// ==================== Unity生命周期方法 ====================
private void Awake()
{
InitializeSingleton();
}
private IEnumerator Start()
{
yield return InitializeGameManager();
}
// ==================== 初始化方法 ====================
/// <summary>
/// 初始化单例模式
/// </summary>
private void InitializeSingleton()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(gameObject);
}
}
/// <summary>
/// 初始化游戏管理器
/// </summary>
private IEnumerator InitializeGameManager()
{
Debug.Log("GameManager启动");
yield return null;
uiManager = FindFirstObjectByType<PokerUIManager>();
if (uiManager == null)
{
Debug.LogError("找不到PokerUIManager!");
yield break;
}
Debug.Log("自动找到PokerUIManager: " + uiManager.gameObject.name);
InitializeGame();
}
/// <summary>
/// 初始化游戏
/// </summary>
private void InitializeGame()
{
players = new Player[2];
players[0] = new Player(0, 2000);
players[1] = new Player(1, 2000);
StartNewRound();
}
/// <summary>
/// 开始新一轮游戏
/// </summary>
private void StartNewRound()
{
ResetGameState(); // 这里应该确保重置 currentRound = 1
ShuffleDeck();
DealCards();
PlaceInitialBets();
SetupRoundUI();
startingPlayerIndex = (startingPlayerIndex + 1) % 2;
}
/// <summary>
/// 重置游戏状态
/// </summary>
private void ResetGameState()
{
currentRound = 1; // 确保这一行存在且正确执行
pot = 0;
currentBet = smallBlind;
isBlindBetting = true;
foreach (Player player in players)
{
player.hasFolded = false;
player.cards.Clear();
}
Debug.Log($"新一轮开始,当前回合: {currentRound}"); // 添加调试信息
}
/// <summary>
/// 设置回合UI
/// </summary>
private void SetupRoundUI()
{
PlaySound(AudioManager.Instance.PlayChipSound);
UpdateUI();
currentPlayerIndex = startingPlayerIndex;
if (uiManager != null)
{
uiManager.UpdateGameInfo(pot, currentBet, isBlindBetting, currentPlayerIndex,
new int[] { players[0].money, players[1].money });
}
SetActionButtonsInteractable(true);
}
// ==================== 牌组管理 ====================
/// <summary>
/// 洗牌
/// </summary>
private void ShuffleDeck()
{
deck.Clear();
// 创建一副新牌
for (int suit = 0; suit < 4; suit++)
{
for (int rank = 0; rank < 13; rank++)
{
deck.Add(new Card(suit, rank));
}
}
// 随机洗牌
for (int i = 0; i < deck.Count; i++)
{
Card temp = deck[i];
int randomIndex = Random.Range(i, deck.Count);
deck[i] = deck[randomIndex];
deck[randomIndex] = temp;
}
}
/// <summary>
/// 发牌
/// </summary>
private void DealCards()
{
Debug.Log("开始发牌,牌堆数量: " + deck.Count);
for (int i = 0; i < 2; i++)
{
if (players[i] == null)
{
Debug.LogError("玩家 " + i + " 为null!");
continue;
}
for (int j = 0; j < 3; j++)
{
if (deck.Count == 0)
{
Debug.LogError("牌堆空了!");
return;
}
players[i].cards.Add(deck[0]);
deck.RemoveAt(0);
}
Debug.Log("玩家 " + i + " 获得3张牌");
}
}
// ==================== 下注管理 ====================
/// <summary>
/// 玩家下初始底注
/// </summary>
private void PlaceInitialBets()
{
foreach (Player player in players)
{
player.AddToPot(smallBlind);
pot += smallBlind;
}
}
/// <summary>
/// 跟注
/// </summary>
private void Call(Player player)
{
int callAmount = isBlindBetting ? currentBet : currentBet * 2;
if (player.money >= callAmount)
{
player.AddToPot(callAmount);
pot += callAmount;
PlaySound(AudioManager.Instance.PlayChipSound);
}
else
{
// 钱不够,全下
player.AddToPot(player.money);
pot += player.money;
}
}
/// <summary>
/// 加注
/// </summary>
private void Raise(Player player)
{
int baseBet = isBlindBetting ? currentBet : currentBet * 2;
int raiseAmount = Mathf.Min(baseBet * 2, player.money);
int maxAllowedRaise = currentBet * maxRaiseMultiplier;
raiseAmount = Mathf.Min(raiseAmount, maxAllowedRaise);
if (player.money >= raiseAmount)
{
player.AddToPot(raiseAmount);
pot += raiseAmount;
currentBet = isBlindBetting ? currentBet * 2 : currentBet * 2;
Debug.Log($"玩家{player.id + 1}加注: {raiseAmount}, 当前注: {currentBet}");
PlaySound(AudioManager.Instance.PlayChipSound);
}
else
{
// 钱不够,全下
player.AddToPot(player.money);
pot += player.money;
Debug.Log($"玩家{player.id + 1}全下: {player.money}");
}
}
// ==================== 玩家动作处理 ====================
/// <summary>
/// 处理玩家动作
/// </summary>
public void OnPlayerAction(int action)
{
PlayerAction playerAction = (PlayerAction)action;
Player currentPlayer = players[currentPlayerIndex];
switch (playerAction)
{
case PlayerAction.Look: LookCards(currentPlayer); break;
case PlayerAction.Compare: CompareCards(); break;
case PlayerAction.Call: Call(currentPlayer); break;
case PlayerAction.Raise: Raise(currentPlayer); break;
case PlayerAction.Fold: Fold(currentPlayer); break;
}
SetActionButtonsInteractable(false);
UpdateUI();
CheckGameEnd();
if (!CheckRoundEnd())
{
SwitchToNextPlayer();
}
}
/// <summary>
/// 切换到下一个玩家
/// </summary>
private void SwitchToNextPlayer()
{
currentPlayerIndex = (currentPlayerIndex + 1) % 2;
if (uiManager != null)
{
uiManager.UpdateGameInfo(pot, currentBet, isBlindBetting, currentPlayerIndex,
new int[] { players[0].money, players[1].money });
}
SetActionButtonsInteractable(true);
}
/// <summary>
/// 看牌
/// </summary>
private void LookCards(Player player)
{
if (uiManager != null)
{
uiManager.RevealPlayerCards(player.id, player.cards);
}
isBlindBetting = false;
UpdateUI();
PlaySound(AudioManager.Instance.PlayCardRevealSound);
}
/// <summary>
/// 弃牌
/// </summary>
private void Fold(Player player)
{
player.hasFolded = true;
int winnerIndex = (player.id + 1) % 2;
EndRound(winnerIndex);
}
// ==================== 游戏逻辑判断 ====================
/// <summary>
/// 检查回合是否结束
/// </summary>
private bool CheckRoundEnd()
{
Debug.Log($"检查回合结束: 当前回合 {currentRound}, 最大回合 7");
if (currentRound >= 7)
{
Debug.Log("回合达到7,开始比牌");
CompareCards();
return true;
}
currentRound++;
Debug.Log($"回合未结束,增加到回合 {currentRound}");
return false;
}
/// <summary>
/// 比较牌型
/// </summary>
private void CompareCards()
{
int winnerIndex = PokerHandEvaluator.CompareHands(players[0].cards, players[1].cards);
EndRound(winnerIndex);
}
/// <summary>
/// 计算手牌分数
/// </summary>
private int CalculateHandScore(List<Card> cards)
{
int score = 0;
foreach (Card card in cards)
{
score += card.rank + 2; // rank 0=2, 1=3, ..., 12=A
}
return score;
}
/// <summary>
/// 检查游戏是否结束
/// </summary>
private void CheckGameEnd()
{
for (int i = 0; i < 2; i++)
{
if (players[i].money <= 0)
{
int winnerIndex = (i + 1) % 2;
if (uiManager != null)
{
uiManager.ShowGameOverPanel(winnerIndex);
}
SetActionButtonsInteractable(false);
return;
}
}
}
// ==================== 回合管理 ====================
/// <summary>
/// 结束回合
/// </summary>
private void EndRound(int winnerIndex)
{
players[winnerIndex].money += pot;
pot = 0;
if (uiManager != null)
{
uiManager.ProcessRoundEndEffects(winnerIndex);
}
UpdateUI();
SetActionButtonsInteractable(false);
PlaySound(AudioManager.Instance.PlayWinSound);
}
/// <summary>
/// 继续到下一轮
/// </summary>
public void ContinueToNextRound()
{
for (int i = 0; i < 2; i++)
{
if (players[i].money <= 0)
{
if (uiManager != null)
{
uiManager.ShowGameOverPanel((i + 1) % 2);
}
return;
}
}
StartNewRound();
if (uiManager != null)
{
uiManager.ResetAllCards();
}
}
// ==================== UI管理 ====================
/// <summary>
/// 更新UI信息
/// </summary>
private void UpdateUI()
{
if (uiManager != null)
{
uiManager.UpdateGameInfo(pot, currentBet, isBlindBetting, currentPlayerIndex,
new int[] { players[0].money, players[1].money });
}
}
/// <summary>
/// 设置动作按钮交互状态
/// </summary>
private void SetActionButtonsInteractable(bool interactable)
{
if (uiManager != null)
{
uiManager.SetActionButtonsInteractable(interactable);
}
}
// ==================== 工具方法 ====================
/// <summary>
/// 播放音效
/// </summary>
private void PlaySound(System.Action soundAction)
{
if (AudioManager.Instance != null)
{
soundAction?.Invoke();
}
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class PokerUIManager : MonoBehaviour
{
[Header("玩家区域")]
public GameObject player1Area;
public GameObject player2Area;
public Image[] player1Cards;
public Image[] player2Cards;
[Header("信息显示")]
public Text potText;
public Text currentBetText;
public Text playerTurnText;
public Text player1MoneyText;
public Text player2MoneyText;
[Header("动作按钮")]
public GameObject actionButtonsPanel;
public Button lookButton;
public Button compareButton;
public Button callButton;
public Button raiseButton;
public Button foldButton;
[Header("其他UI")]
public Button continueButton;
public GameObject gameOverPanel;
public Text gameOverText;
[Header("卡牌设置")]
public float blindCardSpacing = 40f;
public float revealedCardSpacing = 120f;
public Sprite cardBackSprite;
[Header("动画设置")]
public float cardRevealDuration = 0.3f;
public float cardMoveDuration = 0.4f;
// 原始位置记录
private Vector3[] player1OriginalPositions;
private Vector3[] player2OriginalPositions;
private Vector3[] player1OriginalLocalPositions;
private Vector3[] player2OriginalLocalPositions;
// ==================== Unity生命周期方法 ====================
private void Awake()
{
CheckAndFindCardReferences();
SaveOriginalPositions();
}
private void Start()
{
InitializeUI();
HideGameOverPanel();
}
// ==================== 初始化方法 ====================
/// <summary>
/// 初始化UI界面
/// </summary>
private void InitializeUI()
{
CheckAndFindCardReferences();
SetupButtonTexts();
BindButtonEvents();
LoadCardBackSprite();
ResetAllCards();
SetActionButtonsInteractable(false);
if (continueButton != null) continueButton.gameObject.SetActive(false);
Debug.Log("UI初始化完成");
}
/// <summary>
/// 设置按钮文本
/// </summary>
private void SetupButtonTexts()
{
if (lookButton != null) lookButton.GetComponentInChildren<Text>().text = "看牌";
if (compareButton != null) compareButton.GetComponentInChildren<Text>().text = "比牌";
if (callButton != null) callButton.GetComponentInChildren<Text>().text = "跟注";
if (raiseButton != null) raiseButton.GetComponentInChildren<Text>().text = "加注";
if (foldButton != null) foldButton.GetComponentInChildren<Text>().text = "弃牌";
if (continueButton != null) continueButton.GetComponentInChildren<Text>().text = "继续";
}
/// <summary>
/// 绑定按钮事件
/// </summary>
private void BindButtonEvents()
{
if (lookButton != null) lookButton.onClick.AddListener(() => OnActionButtonClick(0));
if (compareButton != null) compareButton.onClick.AddListener(() => OnActionButtonClick(1));
if (callButton != null) callButton.onClick.AddListener(() => OnActionButtonClick(2));
if (raiseButton != null) raiseButton.onClick.AddListener(() => OnActionButtonClick(3));
if (foldButton != null) foldButton.onClick.AddListener(() => OnActionButtonClick(4));
if (continueButton != null) continueButton.onClick.AddListener(OnContinueButtonClicked);
}
/// <summary>
/// 加载卡牌背面图片
/// </summary>
private void LoadCardBackSprite()
{
if (cardBackSprite == null)
{
cardBackSprite = Resources.Load<Sprite>("Cards/CardBack");
if (cardBackSprite == null)
{
Debug.LogError("无法加载卡牌背面图片!");
}
}
}
// ==================== 卡牌引用管理 ====================
/// <summary>
/// 检查并查找卡牌引用
/// </summary>
private void CheckAndFindCardReferences()
{
if (player1Cards == null || player1Cards.Length != 3)
{
FindPlayerCardImages(0);
}
if (player2Cards == null || player2Cards.Length != 3)
{
FindPlayerCardImages(1);
}
}
/// <summary>
/// 查找玩家卡牌图片组件
/// </summary>
private void FindPlayerCardImages(int playerIndex)
{
GameObject playerArea = playerIndex == 0 ? player1Area : player2Area;
if (playerArea != null)
{
Image[] allImages = playerArea.GetComponentsInChildren<Image>(true);
List<Image> cardImages = new List<Image>();
foreach (Image image in allImages)
{
if (image.GetComponent<Button>() == null && image.transform.parent != actionButtonsPanel?.transform)
{
cardImages.Add(image);
}
}
if (cardImages.Count >= 3)
{
if (playerIndex == 0)
{
player1Cards = new Image[3];
for (int i = 0; i < 3; i++) player1Cards[i] = cardImages[i];
Debug.Log("找到Player1卡牌: " + player1Cards.Length);
}
else
{
player2Cards = new Image[3];
for (int i = 0; i < 3; i++) player2Cards[i] = cardImages[i];
Debug.Log("找到Player2卡牌: " + player2Cards.Length);
}
}
else
{
Debug.LogError($"玩家{playerIndex + 1}区域中没有找到足够的卡牌Image组件!需要3个,找到{cardImages.Count}个");
}
}
else
{
Debug.LogError($"玩家{playerIndex + 1}区域未设置!");
}
}
/// <summary>
/// 保存卡牌原始位置
/// </summary>
private void SaveOriginalPositions()
{
if (player1Cards == null || player1Cards.Length < 3 || player2Cards == null || player2Cards.Length < 3)
{
Debug.LogWarning("卡牌数组未正确初始化,无法保存位置");
return;
}
player1OriginalPositions = new Vector3[3];
player2OriginalPositions = new Vector3[3];
player1OriginalLocalPositions = new Vector3[3];
player2OriginalLocalPositions = new Vector3[3];
// 现在:Positions = [null, null, null]
for (int i = 0; i < 3; i++)
{
if (i < player1Cards.Length && player1Cards[i] != null)
{
player1OriginalPositions[i] = player1Cards[i].transform.position;
player1OriginalLocalPositions[i] = player1Cards[i].transform.localPosition;
}
if (i < player2Cards.Length && player2Cards[i] != null)
{
player2OriginalPositions[i] = player2Cards[i].transform.position;
player2OriginalLocalPositions[i] = player2Cards[i].transform.localPosition;
}
}
}
// ==================== 按钮事件处理 ====================
/// <summary>
/// 动作按钮点击事件
/// </summary>
private void OnActionButtonClick(int actionIndex)
{
if (AudioManager.Instance != null)
{
AudioManager.Instance.PlayButtonClickSound();
}
if (GameManager.Instance != null)
{
GameManager.Instance.OnPlayerAction(actionIndex);
}
}
/// <summary>
/// 继续按钮点击事件
/// </summary>
private void OnContinueButtonClicked()
{
if (continueButton != null) continueButton.gameObject.SetActive(false);
if (GameManager.Instance != null) GameManager.Instance.ContinueToNextRound();
}
// ==================== 游戏信息更新 ====================
/// <summary>
/// 更新游戏信息显示
/// </summary>
public void UpdateGameInfo(int pot, int currentBet, bool isBlindBetting, int currentPlayerIndex, int[] playerMoney)
{
if (potText != null) potText.text = $"底池: {pot}";
if (currentBetText != null) currentBetText.text = $"当前注: {currentBet} {(isBlindBetting ? "(闷牌)" : "(明牌)")}";
if (playerTurnText != null) playerTurnText.text = $"玩家 {currentPlayerIndex + 1} 回合";
if (player1MoneyText != null) player1MoneyText.text = $"玩家1: {playerMoney[0]}";
if (player2MoneyText != null) player2MoneyText.text = $"玩家2: {playerMoney[1]}";
}
// ==================== 卡牌动画效果 ====================
/// <summary>
/// 显示玩家卡牌(带动画)
/// </summary>
public void RevealPlayerCards(int playerIndex, List<Card> cards)
{
if (cards == null || cards.Count < 3) return;
Image[] targetCards = playerIndex == 0 ? player1Cards : player2Cards;
StartCoroutine(RevealCardsCoroutine(targetCards, cards, playerIndex));
}
/// <summary>
/// 卡牌显示协程
/// </summary>
private IEnumerator RevealCardsCoroutine(Image[] targetCards, List<Card> cards, int playerIndex)
{
for (int i = 0; i < 3; i++)
{
if (i < targetCards.Length && targetCards[i] != null && i < cards.Count)
{
yield return StartCoroutine(RevealCardWithAnimation(targetCards[i], cards[i].GetCardSprite()));
yield return new WaitForSeconds(0.1f);
}
}
AdjustCardSpacing(playerIndex, true);
}
/// <summary>
/// 单张卡牌显示动画
/// </summary>
public IEnumerator RevealCardWithAnimation(Image cardImage, Sprite cardSprite)
{
if (cardImage == null) yield break;
float elapsed = 0f;
while (elapsed < cardRevealDuration / 2)
{
elapsed += Time.deltaTime;
cardImage.transform.localScale = new Vector3(
Mathf.Lerp(1f, 0f, elapsed / (cardRevealDuration / 2)),
1f, 1f);
yield return null;
}
cardImage.sprite = cardSprite;
elapsed = 0f;
while (elapsed < cardRevealDuration / 2)
{
elapsed += Time.deltaTime;
cardImage.transform.localScale = new Vector3(
Mathf.Lerp(0f, 1f, elapsed / (cardRevealDuration / 2)),
1f, 1f);
yield return null;
}
cardImage.transform.localScale = Vector3.one;
}
/// <summary>
/// 调整卡牌间距
/// </summary>
public void AdjustCardSpacing(int playerIndex, bool isRevealed)
{
Image[] targetCards = playerIndex == 0 ? player1Cards : player2Cards;
Vector3[] originalLocalPositions = playerIndex == 0 ? player1OriginalLocalPositions : player2OriginalLocalPositions;
if (targetCards == null || originalLocalPositions == null) return;
float spacing = isRevealed ? revealedCardSpacing : blindCardSpacing;
for (int i = 0; i < 3 && i < targetCards.Length && i < originalLocalPositions.Length; i++)
{
if (targetCards[i] != null)
{
Vector3 newLocalPos = originalLocalPositions[i];
newLocalPos.x += (i - 1) * spacing;
StartCoroutine(MoveCardToPosition(targetCards[i].transform, newLocalPos));
}
}
}
/// <summary>
/// 卡牌移动动画
/// </summary>
private IEnumerator MoveCardToPosition(Transform cardTransform, Vector3 targetLocalPosition)
{
Vector3 startPosition = cardTransform.localPosition;
float elapsed = 0f;
while (elapsed < cardMoveDuration)
{
elapsed += Time.deltaTime;
float t = elapsed / cardMoveDuration;
cardTransform.localPosition = Vector3.Lerp(startPosition, targetLocalPosition, t);
yield return null;
}
cardTransform.localPosition = targetLocalPosition;
}
// ==================== 卡牌管理 ====================
/// <summary>
/// 重置所有卡牌显示
/// </summary>
public void ResetAllCards()
{
if (player1Cards == null || player1Cards.Length < 3 || player2Cards == null || player2Cards.Length < 3)
{
Debug.LogWarning("卡牌数组未正确初始化,无法重置卡牌显示");
return;
}
for (int i = 0; i < 3; i++)
{
if (i < player1Cards.Length && player1Cards[i] != null)
{
player1Cards[i].sprite = cardBackSprite;
if (player1OriginalPositions != null && i < player1OriginalPositions.Length)
{
player1Cards[i].transform.position = player1OriginalPositions[i];
player1Cards[i].transform.localPosition = player1OriginalLocalPositions[i];
}
player1Cards[i].color = Color.white;
}
if (i < player2Cards.Length && player2Cards[i] != null)
{
player2Cards[i].sprite = cardBackSprite;
if (player2OriginalPositions != null && i < player2OriginalPositions.Length)
{
player2Cards[i].transform.position = player2OriginalPositions[i];
player2Cards[i].transform.localPosition = player2OriginalLocalPositions[i];
}
player2Cards[i].color = Color.white;
}
}
AdjustCardSpacing(0, false);
AdjustCardSpacing(1, false);
}
// ==================== 游戏状态管理 ====================
/// <summary>
/// 处理回合结束效果
/// </summary>
public void ProcessRoundEndEffects(int winnerIndex)
{
int loserIndex = winnerIndex == 0 ? 1 : 0;
Image[] loserCards = loserIndex == 0 ? player1Cards : player2Cards;
Image[] winnerCards = winnerIndex == 0 ? player1Cards : player2Cards;
foreach (Image card in loserCards)
{
if (card != null)
{
Color color = card.color;
color.a = 0.4f;
card.color = color;
}
}
foreach (Image card in winnerCards)
{
if (card != null)
{
card.transform.position += new Vector3(0, 18, 0);
}
}
if (continueButton != null) continueButton.gameObject.SetActive(true);
SetActionButtonsInteractable(false);
}
/// <summary>
/// 设置动作按钮交互状态
/// </summary>
public void SetActionButtonsInteractable(bool interactable)
{
if (lookButton != null) lookButton.interactable = interactable;
if (compareButton != null) compareButton.interactable = interactable;
if (callButton != null) callButton.interactable = interactable;
if (raiseButton != null) raiseButton.interactable = interactable;
if (foldButton != null) foldButton.interactable = interactable;
}
// ==================== 游戏结束管理 ====================
/// <summary>
/// 显示游戏结束面板
/// </summary>
public void ShowGameOverPanel(int winnerIndex)
{
if (gameOverPanel != null) gameOverPanel.SetActive(true);
if (gameOverText != null) gameOverText.text = $"玩家 {winnerIndex + 1} 获胜!\n游戏结束!";
SetActionButtonsInteractable(false);
if (continueButton != null) continueButton.gameObject.SetActive(false);
}
/// <summary>
/// 隐藏游戏结束面板
/// </summary>
public void HideGameOverPanel()
{
if (gameOverPanel != null) gameOverPanel.SetActive(false);
}
}
using System.Collections.Generic;
using System.Linq;
public static class PokerHandEvaluator
{
public static int CompareHands(List<Card> hand1, List<Card> hand2)
{
hand1 = hand1.OrderByDescending(card => card.rank).ToList();
hand2 = hand2.OrderByDescending(card => card.rank).ToList();
HandRank rank1 = EvaluateHand(hand1);
HandRank rank2 = EvaluateHand(hand2);
if (rank1 > rank2)
return 0; // hand1 胜
if (rank2 > rank1)
return 1; // hand2 胜
return CompareEqualHands(hand1, hand2, rank1);
}
private static int CompareEqualHands(List<Card> hand1, List<Card> hand2, HandRank rank)
{
switch (rank)
{
case HandRank.ThreeOfAKind: return CompareThreeOfAKind(hand1, hand2);
case HandRank.StraightFlush: return CompareStraightFlush(hand1, hand2);
case HandRank.Flush: return CompareFlush(hand1, hand2);
case HandRank.Straight: return CompareStraight(hand1, hand2);
case HandRank.Pair: return ComparePair(hand1, hand2);
case HandRank.HighCard: return CompareHighCard(hand1, hand2);
default: return 0;
}
}
private static HandRank EvaluateHand(List<Card> hand)
{
hand = hand.OrderBy(card => card.rank).ToList();
bool isFlush = IsFlush(hand);
bool isStraight = IsStraight(hand);
bool isThreeOfAKind = IsThreeOfAKind(hand);
// 注意:按你给定的枚举顺序,ThreeOfAKind > StraightFlush
if (isThreeOfAKind)
return HandRank.ThreeOfAKind;
if (isStraight && isFlush)
return HandRank.StraightFlush;
if (isFlush)
return HandRank.Flush;
if (isStraight)
return HandRank.Straight;
if (IsPair(hand))
return HandRank.Pair;
return HandRank.HighCard;
}
/// <summary>
/// 比较三条
/// </summary>
private static int CompareThreeOfAKind(List<Card> hand1, List<Card> hand2)
{
int tripleRank1 = hand1.GroupBy(c => c.rank).First(g => g.Count() == 3).Key;
int tripleRank2 = hand2.GroupBy(c => c.rank).First(g => g.Count() == 3).Key;
return tripleRank1.CompareTo(tripleRank2);
}
/// <summary>
/// 比较顺金(同花顺)
/// </summary>
private static int CompareStraightFlush(List<Card> hand1, List<Card> hand2)
{
// 顺金比较规则:先比较顺子大小,如果相同再比较花色
int straightCompare = CompareStraight(hand1, hand2);
if (straightCompare != 0)
return straightCompare;
// 顺子大小相同,比较最大牌的花色
int maxRank1 = GetStraightMaxRank(hand1);
int maxRank2 = GetStraightMaxRank(hand2);
Card maxCard1 = hand1.First(c => c.rank == maxRank1);
Card maxCard2 = hand2.First(c => c.rank == maxRank2);
// 花色比较:黑桃 > 红心 > 方块 > 梅花
return maxCard1.suit.CompareTo(maxCard2.suit);
}
/// <summary>
/// 比较顺子
/// </summary>
private static int CompareStraight(List<Card> hand1, List<Card> hand2)
{
// 获取顺子的最大牌
int maxRank1 = GetStraightMaxRank(hand1);
int maxRank2 = GetStraightMaxRank(hand2);
return maxRank1.CompareTo(maxRank2);
}
/// <summary>
/// 获取顺子的最大牌面
/// </summary>
private static int GetStraightMaxRank(List<Card> hand)
{
// 先确保手牌按点数排序
hand = hand.OrderBy(card => card.rank).ToList();
// 处理A-2-3的特殊顺子(最小的顺子)
if (hand[0].rank == 0 && hand[1].rank == 1 && hand[2].rank == 12) // 2-3-A
{
return 2; // 3是最大的牌(A作为1使用),但这是最小的顺子
}
// 处理A-K-Q的特殊顺子(最大的顺子)
if (hand[0].rank == 10 && hand[1].rank == 11 && hand[2].rank == 12) // Q-K-A
{
return 12; // A是最大的牌
}
// 正常顺子:返回最大的牌
return hand.Max(card => card.rank);
}
/// <summary>
/// 比较同花
/// </summary>
private static int CompareFlush(List<Card> hand1, List<Card> hand2)
{
// 同花比较:先按高牌规则比较
int highCardCompare = CompareHighCard(hand1, hand2);
if (highCardCompare != 0)
return highCardCompare;
// 如果所有牌点数相同,比较最大牌的花色
Card maxCard1 = hand1.OrderByDescending(c => c.rank).First();
Card maxCard2 = hand2.OrderByDescending(c => c.rank).First();
return maxCard1.suit.CompareTo(maxCard2.suit);
}
/// <summary>
/// 比较对子
/// </summary>
private static int ComparePair(List<Card> hand1, List<Card> hand2)
{
// 获取对子的点数
int pairRank1 = hand1.GroupBy(c => c.rank).First(g => g.Count() == 2).Key;
int pairRank2 = hand2.GroupBy(c => c.rank).First(g => g.Count() == 2).Key;
// 先比较对子大小
if (pairRank1 != pairRank2)
return pairRank1.CompareTo(pairRank2);
// 对子相同,比较单张
int single1 = hand1.First(c => c.rank != pairRank1).rank;
int single2 = hand2.First(c => c.rank != pairRank2).rank;
return single1.CompareTo(single2);
}
/// <summary>
/// 比较高牌
/// </summary>
private static int CompareHighCard(List<Card> hand1, List<Card> hand2)
{
// 逐张比较牌的大小
for (int i = 0; i < 3; i++)
{
if (hand1[i].rank != hand2[i].rank)
return hand1[i].rank.CompareTo(hand2[i].rank);
}
return 0; // 完全相同的牌
}
/// <summary>
/// 判断是否同花
/// </summary>
private static bool IsFlush(List<Card> hand)
{
return hand.All(card => card.suit == hand[0].suit);
}
/// <summary>
/// 判断是否顺子
/// </summary>
private static bool IsStraight(List<Card> hand)
{
// 正常顺子
if (hand[2].rank - hand[0].rank == 2 &&
hand[1].rank == hand[0].rank + 1)
return true;
// 特殊顺子:A-2-3
if (hand[0].rank == 0 && hand[1].rank == 1 && hand[2].rank == 12) // 2-3-A
return true;
return false;
}
/// <summary>
/// 判断是否三条
/// </summary>
private static bool IsThreeOfAKind(List<Card> hand)
{
return hand[0].rank == hand[1].rank && hand[1].rank == hand[2].rank;
}
/// <summary>
/// 判断是否对子
/// </summary>
private static bool IsPair(List<Card> hand)
{
return hand[0].rank == hand[1].rank ||
hand[1].rank == hand[2].rank ||
hand[0].rank == hand[2].rank;
}
}
免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删