Пример #1
0
        private void LayingCardsDone()
        {
            // With only one card left, just end the game
            if (HandCardCount == 1)
            {
                DiscardCard();
                return;
            }

            // Check if there are any (more) single cards to lay down
            singleLayDownCards = PlayerUtil.UpdateSingleLaydownCards(HandCardSpot.Objects, laydownCards);
            PossibleSinglesChanged.Invoke(singleLayDownCards);

            if (singleLayDownCards.Count == HandCardCount)
            {
                KeepOneSingleCard();
            }

            if (singleLayDownCards.Count > 0)
            {
                currentCardIdx = 0;
                layStage       = LayStage.SINGLES;
            }
            else
            {
                DiscardCard();
            }
        }
Пример #2
0
        private void LayDownCardMoveFinished(Card card)
        {
            card.MoveFinished.RemoveAllListeners();
            isCardBeingLaidDown = false;
            currentCardSpot.AddCard(card);

            int cardCount, cardPackCount;

            switch (layStage)
            {
            case LayStage.SETS:
                cardCount     = laydownCards.Sets[currentCardPackIdx].Count;
                cardPackCount = laydownCards.Sets.Count;
                break;

            case LayStage.RUNS:
                cardCount     = laydownCards.Runs[currentCardPackIdx].Count;
                cardPackCount = laydownCards.Runs.Count;
                break;

            default:     // LayStage.SINGLES
                cardCount     = singleLayDownCards.Count;
                cardPackCount = 1;

                if (!card.IsJoker())
                {
                    returningJoker = singleLayDownCards[currentCardIdx].Joker;
                    if (returningJoker != null)
                    {
                        State = PlayerState.RETURNING_JOKER;
                        return;
                    }
                }
                break;
            }

            if (currentCardIdx < cardCount - 1)
            {
                currentCardIdx++;
                return;
            }

            // All cards of the current pack have been laid down
            currentCardIdx = 0;
            currentCardPackIdx++;
            currentCardSpot = null;  // Find a new spot for the next pack

            if (currentCardPackIdx < cardPackCount)
            {
                return;
            }

            // All packs or singles have been laid down
            if (layStage == LayStage.RUNS || layStage == LayStage.SINGLES ||
                (layStage == LayStage.SETS && laydownCards.Runs.Count == 0))
            {
                LayingCardsDone();
            }
            else // LayStage.SETS -> Start laying runs
            {
                currentCardPackIdx = 0;
                layStage           = LayStage.RUNS;
            }
        }
Пример #3
0
        private void Update()
        {
            if (State == PlayerState.WAITING && Time.time - waitStartTime > Tb.I.GameMaster.PlayWaitDuration)
            {
                State = PlayerState.PLAYING;
                if (!Tb.I.GameMaster.LayingAllowed() || !HasLaidDown)
                {
                    DiscardCard();
                }
                else
                {
                    State = PlayerState.LAYING;
                    isCardBeingLaidDown = false;
                    currentCardPackIdx  = 0;
                    currentCardIdx      = 0;
                    currentCardSpot     = null;
                    layStage            = LayStage.SETS;

                    if (laydownCards.Sets.Count == 0)
                    {
                        layStage = LayStage.RUNS;
                        if (laydownCards.Runs.Count == 0)
                        {
                            LayingCardsDone();
                        }
                    }
                }
            }

            if (State == PlayerState.LAYING)
            {
                if (isCardBeingLaidDown)
                {
                    return;
                }
                isCardBeingLaidDown = true;

                if (layStage == LayStage.SINGLES)
                {
                    currentCardSpot = singleLayDownCards[currentCardIdx].CardSpot;
                }
                else if (currentCardSpot == null)
                {
                    currentCardSpot      = PlayerCardSpotsNode.AddCardSpot();
                    currentCardSpot.Type = (layStage == LayStage.RUNS) ? CardSpot.SpotType.RUN : CardSpot.SpotType.SET;
                }

                Card card;
                switch (layStage)
                {
                case LayStage.SETS:
                    card = laydownCards.Sets[currentCardPackIdx].Cards[currentCardIdx];
                    break;

                case LayStage.RUNS:
                    card = laydownCards.Runs[currentCardPackIdx].Cards[currentCardIdx];
                    break;

                default:     // LayStage.SINGLES:
                    card = singleLayDownCards[currentCardIdx].Card;
                    break;
                }

                HandCardSpot.RemoveCard(card);
                card.MoveFinished.AddListener(LayDownCardMoveFinished);
                card.MoveCard(currentCardSpot.transform.position, Tb.I.GameMaster.AnimateCardMovement);
            }

            if (State == PlayerState.RETURNING_JOKER)
            {
                if (isJokerBeingReturned)
                {
                    return;
                }
                isJokerBeingReturned = true;
                currentCardSpot.RemoveCard(returningJoker);
                returningJoker.MoveFinished.AddListener(ReturnJokerMoveFinished);
                returningJoker.MoveCard(HandCardSpot.transform.position, Tb.I.GameMaster.AnimateCardMovement);
            }
        }