许可优化
许可优化
产品
产品
解决方案
解决方案
服务支持
服务支持
关于
关于
软件库
当前位置:服务支持 >  软件文章 >  制作学习扎金花逻辑Unity工程样本,2026年8月版

制作学习扎金花逻辑Unity工程样本,2026年8月版

阅读数 11
点赞 0
article_banner


using UnityEngine;

public class AudioManager : MonoBehaviour

{

 public static AudioManager Instance;

 [Header("音效资源")]

 public AudioClip cardRevealSound;

 public AudioClip chipSound;

 public AudioClip winSound;

 public AudioClip loseSound;

 public AudioClip buttonClickSound;

 private AudioSource audioSource;

 void Awake()

 {

   if (Instance == null)

   {

     Instance = this;

     DontDestroyOnLoad(gameObject);

     audioSource = GetComponent<AudioSource>();

     if (audioSource == null)

     {

       audioSource = gameObject.AddComponent<AudioSource>();

     }

   }

   else

   {

     Destroy(gameObject);

   }

 }

 public void PlaySound(AudioClip clip, float volume = 1.0f)

 {

   if (clip != null && audioSource != null)

   {

     audioSource.PlayOneShot(clip, volume);

   }

 }

 // 特定音效的快捷方法

 public void PlayCardRevealSound() => PlaySound(cardRevealSound, 0.8f);

 public void PlayChipSound() => PlaySound(chipSound, 0.6f);

 public void PlayWinSound() => PlaySound(winSound, 1.0f);

 public void PlayLoseSound() => PlaySound(loseSound, 0.7f);

 public void PlayButtonClickSound() => PlaySound(buttonClickSound, 0.5f);

}

using UnityEngine;

public class Card

{

 public int suit; // 0: spade, 1: heart, 2: diamond, 3: club

 public int rank; // 0: 2, 1: 3, ..., 8: 10, 9: J, 10: Q, 11: K, 12: A

 public Card(int suit, int rank)

 {

   this.suit = suit;

   this.rank = rank;

 }

 public Sprite GetCardSprite()

 {

   string[] suits = { "spade", "heart", "diamond", "club" };

   string[] ranks = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A" };

   string cardName = suits[suit] + "_" + ranks[rank];

   Sprite sprite = Resources.Load<Sprite>("Cards/" + cardName);

   if (sprite == null)

   {

     Debug.LogError("无法加载卡牌图片: Cards/" + cardName);

   }

   return sprite;

 }

}

using System.Collections.Generic;

public class Player

{

 public int id;

 public int money;

 public List<Card> cards;

 public bool hasFolded;

 public Player(int id, int initialMoney)

 {

   this.id = id;

   this.money = initialMoney;

   this.cards = new List<Card>();

   this.hasFolded = false;

 }

 public void AddToPot(int amount)

 {

   money -= amount;

   if (money < 0) money = 0;

 }

}

using System.Collections.Generic;

using System.Linq;

public static class PokerHandEvaluator

{

 /// <summary>

 /// 比较两手牌的大小

 /// </summary>

 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);

   // Debug.Log($"玩家1牌型: {GetHandRankName(rank1)}, 玩家2牌型: {GetHandRankName(rank2)}");

   // 比较牌型等级

   if (rank1 > rank2)

   {

     // Debug.Log("玩家1获胜(牌型更高)");

     return 0;

   }

   if (rank2 > rank1)

   {

     // Debug.Log("玩家2获胜(牌型更高)");

     return 1;

   }

   // 牌型相同,比较具体牌的大小

   int result = CompareEqualHands(hand1, hand2, rank1);

   // Debug.Log($"牌型相同,比较结果: 玩家{(result == 0 ? 1 : 2)}获胜");

   return result;

 }

 /// <summary>

 /// 比较相同牌型的手牌

 /// </summary>

 private static int CompareEqualHands(List<Card> hand1, List<Card> hand2, HandRank rank)

 {

   switch (rank)

   {

     case HandRank.ThreeOfAKind:

       return CompareThreeOfAKind(hand1, hand2);

     case HandRank.StraightFlush:

     case HandRank.Straight:

       return CompareStraight(hand1, hand2);

     case HandRank.Flush:

       return CompareFlush(hand1, hand2);

     case HandRank.Pair:

       return ComparePair(hand1, hand2);

     case HandRank.HighCard:

       return CompareHighCard(hand1, hand2);

     default:

       return 0; // 平局

   }

 }

 /// <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 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)

 {

   // 处理A-2-3的特殊顺子

   if (hand[0].rank == 12 && hand[1].rank == 1 && hand[2].rank == 0) // A-3-2

   {

     return 2; // 3是最大的牌(A作为1使用)

   }

   return hand.Max(card => card.rank);

 }

 /// <summary>

 /// 比较同花

 /// </summary>

 private static int CompareFlush(List<Card> hand1, List<Card> hand2)

 {

   return CompareHighCard(hand1, hand2); // 同花按高牌规则比较

 }

 /// <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 HandRank EvaluateHand(List<Card> hand)

 {

   // 先按点数排序

   hand = hand.OrderBy(card => card.rank).ToList();

   bool isFlush = IsFlush(hand);

   bool isStraight = IsStraight(hand);

   bool isThreeOfAKind = IsThreeOfAKind(hand);

   if (isStraight && isFlush)

     return HandRank.StraightFlush;

   if (isThreeOfAKind)

     return HandRank.ThreeOfAKind;

   if (isFlush)

     return HandRank.Flush;

   if (isStraight)

     return HandRank.Straight;

   if (IsPair(hand))

     return HandRank.Pair;

   return HandRank.HighCard;

 }

 /// <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;

 }

 /// <summary>

 /// 获取牌型名称

 /// </summary>

 private static string GetHandRankName(HandRank rank)

 {

   switch (rank)

   {

     case HandRank.HighCard: return "高牌";

     case HandRank.Pair: return "对子";

     case HandRank.Flush: return "金花";

     case HandRank.Straight: return "顺子";

     case HandRank.ThreeOfAKind: return "三条";

     case HandRank.StraightFlush: return "顺金";

     default: return "未知";

   }

 }

}

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 = 5f;

 public float revealedCardSpacing = 35f;

 public Sprite cardBackSprite;

 [Header("动画设置")]

 public float cardRevealDuration = 0.3f;

 public float cardMoveDuration = 0.2f;

 // 原始位置记录

 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];

   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;

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 = 2,

 Straight = 3,

 ThreeOfAKind = 4,

 StraightFlush = 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();

   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();

   }

 }

 /// <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()

 {

   if (currentRound >= 3)

   {

     CompareCards();

     return true;

   }

   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 UnityEngine;

using UnityEngine.SceneManagement;

using UnityEditor.SceneManagement;

#if UNITY_EDITOR

using UnityEditor;

#endif

public class SceneTemplateManager : MonoBehaviour

{

 public static string TemplateScenePath = "Assets/Scenes/TemplateScene.unity";

 // 运行时加载模板场景

 public static void LoadTemplateScene()

 {

   SceneManager.LoadScene("TemplateScene", LoadSceneMode.Single);

 }

#if UNITY_EDITOR

 // 编辑器菜单快速访问

 [MenuItem("Tools/场景模板/加载模板场景")]

 static void LoadTemplateSceneEditor()

 {

   if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())

   {

     EditorSceneManager.OpenScene(TemplateScenePath);

   }

 }

 [MenuItem("Tools/场景模板/设置为启动场景")]

 static void SetAsStartupScene()

 {

   // 在Build Settings中设置模板场景为第一个场景

   EditorBuildSettingsScene[] scenes = EditorBuildSettings.scenes;

   for (int i = 0; i < scenes.Length; i++)

   {

     if (scenes[i].path == TemplateScenePath)

     {

       // 移动到第一个位置

       EditorBuildSettingsScene temp = scenes[0];

       scenes[0] = scenes[i];

       scenes[i] = temp;

       EditorBuildSettings.scenes = scenes;

       Debug.Log("已将模板场景设置为启动场景");

       return;

     }

   }

   Debug.LogWarning("未找到模板场景,请先保存场景");

 }

#endif

}

// 创建设置脚本 TemplateSceneSetup.cs

using UnityEngine;

using UnityEngine.UI;

public class TemplateSceneSetup : MonoBehaviour

{

 [Header("UI References")]

 public Canvas uiCanvas;

 public Text potText;

 public Text currentBetText;

 public Text playerTurnText;

 public Text player1MoneyText;

 public Text player2MoneyText;

 [Header("Card References")]

 public Image[] player1Cards;

 public Image[] player2Cards;

 [Header("Button References")]

 public Button lookButton;

 public Button compareButton;

 public Button callButton;

 public Button raiseButton;

 public Button foldButton;

 public Button continueButton;

 void Start()

 {

   // 自动设置引用(如果场景中有相应对象)

   SetupReferences();

 }

 void SetupReferences()

 {

   // 自动查找UI元素

   uiCanvas = FindFirstObjectByType<Canvas>();

   // 查找文本组件

   Text[] texts = uiCanvas.GetComponentsInChildren<Text>();

   foreach (Text text in texts)

   {

     if (text.name.Contains("Pot")) potText = text;

     if (text.name.Contains("Bet")) currentBetText = text;

     if (text.name.Contains("Turn")) playerTurnText = text;

     if (text.name.Contains("Player1")) player1MoneyText = text;

     if (text.name.Contains("Player2")) player2MoneyText = text;

   }

   // 查找按钮

   Button[] buttons = uiCanvas.GetComponentsInChildren<Button>();

   foreach (Button button in buttons)

   {

     if (button.name.Contains("Look")) lookButton = button;

     if (button.name.Contains("Compare")) compareButton = button;

     if (button.name.Contains("Call")) callButton = button;

     if (button.name.Contains("Raise")) raiseButton = button;

     if (button.name.Contains("Fold")) foldButton = button;

     if (button.name.Contains("Continue")) continueButton = button;

   }

 }

}


免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删

相关文章
技术文档
QR Code
微信扫一扫,欢迎咨询~
customer

online

联系我们
武汉格发信息技术有限公司
湖北省武汉市经开区科技园西路6号103孵化器
电话:155-2731-8020 座机:027-59821821
邮件:tanzw@gofarlic.com
Copyright © 2023 Gofarsoft Co.,Ltd. 保留所有权利
遇到许可问题?该如何解决!?
评估许可证实际采购量? 
不清楚软件许可证使用数据? 
收到软件厂商律师函!?  
想要少购买点许可证,节省费用? 
收到软件厂商侵权通告!?  
有正版license,但许可证不够用,需要新购? 
联系方式 board-phone 155-2731-8020
close1
预留信息,一起解决您的问题
* 姓名:
* 手机:

* 公司名称:

姓名不为空

姓名不为空

姓名不为空
手机不正确

手机不正确

手机不正确
公司不为空

公司不为空

公司不为空