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

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

阅读数 15
点赞 0
article_banner

Cards.cs

---------------------------------begin

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;

 }

}

-------------------------------------------------------end

Player.cs

---------------------------------begin

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;

 }

}

-------------------------------------------------------end

PokerHandEvaluator.cs

---------------------------------begin

using System.Collections.Generic;

using System.Linq;

public static class PokerHandEvaluator

{

 public static int CompareHands(List<Card> hand1, List<Card> hand2)

 {

   HandRank rank1 = EvaluateHand(hand1);

   HandRank rank2 = EvaluateHand(hand2);

   if (rank1 > rank2) return 0;

   if (rank2 > rank1) return 1;

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

   return CompareEqualHands(hand1, hand2, rank1);

 }

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

 {

   // 简化处理,实际游戏需要更详细的比较逻辑

   // 这里只是比较三张牌的总和

   int sum1 = hand1.Sum(card => card.rank);

   int sum2 = hand2.Sum(card => card.rank);

   return sum1 >= sum2 ? 0 : 1;

 }

 private static HandRank EvaluateHand(List<Card> hand)

 {

   // 排序手牌

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

   bool isFlush = hand.All(card => card.suit == hand[0].suit);

   bool isStraight = (hand[2].rank - hand[0].rank == 2) &&

            (hand[1].rank == hand[0].rank + 1);

   // 三条

   if (hand[0].rank == hand[1].rank && hand[1].rank == hand[2].rank)

     return HandRank.ThreeOfAKind;

   // 顺金

   if (isStraight && isFlush)

     return HandRank.StraightFlush;

   // 金花

   if (isFlush)

     return HandRank.Flush;

   // 顺子

   if (isStraight)

     return HandRank.Straight;

   // 对子

   if (hand[0].rank == hand[1].rank || hand[1].rank == hand[2].rank)

     return HandRank.Pair;

   // 单张

   return HandRank.HighCard;

 }

}

-------------------------------------------------------end

PokerUIManager.cs

---------------------------------begin

using UnityEngine;

using UnityEngine.UI;

using System.Collections.Generic;

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

 public float revealedCardSpacing = 18f;

 public Sprite cardBackSprite;

 // 原始位置记录

 private Vector3[] player1OriginalPositions;

 private Vector3[] player2OriginalPositions;

 private Vector3[] player1OriginalLocalPositions;

 private Vector3[] player2OriginalLocalPositions;

 private void Awake()

 {

   // 先检查并查找卡牌引用

   CheckAndFindCardReferences();

   // 保存原始位置

   SaveOriginalPositions();

 }

 private void Start()

 {

   InitializeUI();

   HideGameOverPanel();

 }

 private void SaveOriginalPositions()

 {

   // 重新检查数组是否有效

   if (player1Cards == null || player1Cards.Length < 3)

   {

     Debug.LogWarning("Player1卡牌数组未正确初始化,尝试重新查找...");

     FindPlayerCardImages(0);

   }

   if (player2Cards == null || player2Cards.Length < 3)

   {

     Debug.LogWarning("Player2卡牌数组未正确初始化,尝试重新查找...");

     FindPlayerCardImages(1);

   }

   // 再次检查

   if (player1Cards == null || player1Cards.Length < 3 ||

     player2Cards == null || player2Cards.Length < 3)

   {

     Debug.LogError("卡牌数组未正确初始化!请确保玩家区域中有3个Image组件作为卡牌");

     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;

     }

   }

 }

 private void InitializeUI()

 {

   Debug.Log("初始化UI...");

   // 检查并自动查找卡牌引用

   CheckAndFindCardReferences();

   // 设置按钮文本

   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 = "继续";

   // 绑定按钮事件

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

   // 初始状态

   SetActionButtonsInteractable(false);

   if (continueButton != null) continueButton.gameObject.SetActive(false);

   // 加载卡牌背面

   if (cardBackSprite == null)

   {

     cardBackSprite = Resources.Load<Sprite>("Cards/CardBack");

     if (cardBackSprite == null)

     {

       Debug.LogError("无法加载卡牌背面图片!");

     }

   }

   // 初始显示卡牌背面

   ResetAllCards();

   Debug.Log("UI初始化完成");

 }

 private void CheckAndFindCardReferences()

 {

   // 如果player1Cards未设置或长度不对,尝试自动查找

   if (player1Cards == null || player1Cards.Length != 3)

   {

     FindPlayerCardImages(0);

   }

   // 如果player2Cards未设置或长度不对,尝试自动查找

   if (player2Cards == null || player2Cards.Length != 3)

   {

     FindPlayerCardImages(1);

   }

 }

 private void FindPlayerCardImages(int playerIndex)

 {

   GameObject playerArea = playerIndex == 0 ? player1Area : player2Area;

   if (playerArea != null)

   {

     // 查找所有子物体中的Image组件

     Image[] allImages = playerArea.GetComponentsInChildren<Image>(true);

     List<Image> cardImages = new List<Image>();

     // 筛选出可能是卡牌的Image(可以根据需要添加更多筛选条件)

     foreach (Image image in allImages)

     {

       // 排除按钮等其他UI元素的Image

       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}区域未设置!");

   }

 }

 private void OnActionButtonClick(int actionIndex)

 {

   if (GameManager.Instance != null)

   {

     GameManager.Instance.OnPlayerAction(actionIndex);

   }

 }

 // 更新游戏信息

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

 }

 // 显示玩家卡牌

 public void RevealPlayerCards(int playerIndex, List<Card> cards)

 {

   if (cards == null || cards.Count < 3)

   {

     Debug.LogError("卡牌数据不完整!");

     return;

   }

   Image[] targetCards = playerIndex == 0 ? player1Cards : player2Cards;

   if (targetCards == null || targetCards.Length < 3)

   {

     Debug.LogError("目标卡牌数组未正确设置!");

     return;

   }

   for (int i = 0; i < 3 && i < targetCards.Length && i < cards.Count; i++)

   {

     if (targetCards[i] != null)

     {

       targetCards[i].sprite = cards[i].GetCardSprite();

     }

   }

   AdjustCardSpacing(playerIndex, true);

 }

 // 调整卡牌间距

 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;

       targetCards[i].transform.localPosition = newLocalPos;

     }

   }

 }

 // 重置所有卡牌显示

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

 }

 // 处理回合结束效果

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

 }

 // 设置动作按钮交互状态

 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;

 }

 // 继续按钮点击事件

 private void OnContinueButtonClicked()

 {

   if (continueButton != null) continueButton.gameObject.SetActive(false);

   if (GameManager.Instance != null) GameManager.Instance.ContinueToNextRound();

 }

 // 显示游戏结束面板

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

 }

 // 隐藏游戏结束面板

 public void HideGameOverPanel()

 {

   if (gameOverPanel != null) gameOverPanel.SetActive(false);

 }

}

-------------------------------------------------------end

GameManager.cs

---------------------------------begin

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;

 // 引用PokerUIManager

 public PokerUIManager uiManager;

 // 玩家相关

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

 private void Awake()

 {

   if (Instance == null)

   {

     Instance = this;

   }

   else

   {

     Destroy(gameObject);

   }

 }

 private IEnumerator Start()

 {

   Debug.Log("GameManager启动");

   // 等待一帧确保所有组件初始化完成

   yield return null;

   // 自动查找UI管理器(如果未手动赋值)

   if (uiManager == null)

   {

     uiManager = FindObjectOfType<PokerUIManager>();

     if (uiManager == null)

     {

       Debug.LogError("找不到PokerUIManager!");

       yield break;

     }

     else

     {

       Debug.Log("自动找到PokerUIManager: " + uiManager.gameObject.name);

     }

   }

   InitializeGame();

 }

 void InitializeGame()

 {

   // 初始化玩家

   players = new Player[2];

   players[0] = new Player(0, 2000);

   players[1] = new Player(1, 2000);

   // 开始新的一轮

   StartNewRound();

 }

 void StartNewRound()

 {

   // 重置变量

   currentRound = 1;

   pot = 0;

   currentBet = 10;

   isBlindBetting = true;

   // 重置玩家状态

   foreach (Player player in players)

   {

     player.hasFolded = false;

     player.cards.Clear();

   }

   // 洗牌和发牌

   ShuffleDeck();

   DealCards();

   // 玩家下底注

   foreach (Player player in players)

   {

     player.AddToPot(10);

     pot += 10;

   }

   // 更新UI

   UpdateUI();

   // 设置当前玩家

   currentPlayerIndex = startingPlayerIndex;

   // 调用UI管理器更新回合显示

   if (uiManager != null)

   {

     uiManager.UpdateGameInfo(pot, currentBet, isBlindBetting, currentPlayerIndex,

                 new int[] { players[0].money, players[1].money });

   }

   // 启用动作按钮

   SetActionButtonsInteractable(true);

   // 切换起始玩家

   startingPlayerIndex = (startingPlayerIndex + 1) % 2;

 }

 // 洗牌

 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;

   }

 }

 // 发牌

 void DealCards()

 {

   Debug.Log("开始发牌,牌堆数量: " + deck.Count);

   // 给每个玩家发3张牌

   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张牌");

   }

 }

 // 更新UI信息

 void UpdateUI()

 {

   if (uiManager != null)

   {

     uiManager.UpdateGameInfo(pot, currentBet, isBlindBetting, currentPlayerIndex,

                 new int[] { players[0].money, players[1].money });

   }

 }

 // 设置动作按钮交互状态

 void SetActionButtonsInteractable(bool interactable)

 {

   if (uiManager != null)

   {

     uiManager.SetActionButtonsInteractable(interactable);

   }

 }

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

   // 更新UI

   UpdateUI();

   // 检查游戏是否结束

   CheckGameEnd();

   // 切换到下一个玩家

   if (!CheckRoundEnd())

   {

     currentPlayerIndex = (currentPlayerIndex + 1) % 2;

     // 更新UI显示当前玩家

     if (uiManager != null)

     {

       uiManager.UpdateGameInfo(pot, currentBet, isBlindBetting, currentPlayerIndex,

                   new int[] { players[0].money, players[1].money });

     }

     // 启用动作按钮

     SetActionButtonsInteractable(true);

   }

 }

 void LookCards(Player player)

 {

   // 调用UI管理器显示卡牌

   if (uiManager != null)

   {

     uiManager.RevealPlayerCards(player.id, player.cards);

   }

   // 看牌后下注金额翻倍

   isBlindBetting = false;

   // 更新UI

   UpdateUI();

 }

 // 检查回合是否结束

 bool CheckRoundEnd()

 {

   // 简化版:第三轮后强制比牌

   if (currentRound >= 3)

   {

     CompareCards();

     return true;

   }

   currentRound++;

   return false;

 }

 // 比较牌型

 void CompareCards()

 {

   // 简化比较逻辑:比较三张牌的总点数

   int player1Score = CalculateHandScore(players[0].cards);

   int player2Score = CalculateHandScore(players[1].cards);

   int winnerIndex = player1Score >= player2Score ? 0 : 1;

   EndRound(winnerIndex);

 }

 // 计算手牌分数(简化版)

 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;

 }

 // 跟注

 void Call(Player player)

 {

   int callAmount = isBlindBetting ? currentBet : currentBet * 2;

   if (player.money >= callAmount)

   {

     player.AddToPot(callAmount);

     pot += callAmount;

   }

   else

   {

     // 钱不够,全下

     player.AddToPot(player.money);

     pot += player.money;

   }

 }

 // 加注

 void Raise(Player player)

 {

   int raiseAmount = isBlindBetting ? currentBet * 2 : currentBet * 4;

   if (player.money >= raiseAmount)

   {

     player.AddToPot(raiseAmount);

     pot += raiseAmount;

     currentBet = isBlindBetting ? currentBet * 2 : currentBet * 2;

   }

   else

   {

     // 钱不够,全下

     player.AddToPot(player.money);

     pot += player.money;

   }

   // 如果加注超过1000,立即比牌

   if (raiseAmount > 1000)

   {

     CompareCards();

   }

 }

 // 弃牌

 void Fold(Player player)

 {

   player.hasFolded = true;

   int winnerIndex = (player.id + 1) % 2;

   EndRound(winnerIndex);

 }

 void EndRound(int winnerIndex)

 {

   // 赢家获得底池

   players[winnerIndex].money += pot;

   pot = 0;

   // 调用UI管理器处理回合结束效果

   if (uiManager != null)

   {

     uiManager.ProcessRoundEndEffects(winnerIndex);

   }

   // 更新UI

   UpdateUI();

   // 禁用动作按钮

   SetActionButtonsInteractable(false);

 }

 void CheckGameEnd()

 {

   for (int i = 0; i < 2; i++)

   {

     if (players[i].money <= 0)

     {

       int winnerIndex = (i + 1) % 2;

       // 调用UI管理器显示游戏结束

       if (uiManager != null)

       {

         uiManager.ShowGameOverPanel(winnerIndex);

       }

       SetActionButtonsInteractable(false);

       return;

     }

   }

 }

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

   }

 }

}

-------------------------------------------------------end


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

相关文章
技术文档
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
预留信息,一起解决您的问题
* 姓名:
* 手机:

* 公司名称:

姓名不为空

姓名不为空

姓名不为空
手机不正确

手机不正确

手机不正确
公司不为空

公司不为空

公司不为空