コード例 #1
0
ファイル: CardTable.cs プロジェクト: liycncncn/Relauched
        void JudgeIndividualJade(ICard cardJade, IPlayer playerPlaying, IPlayer playerReceiving)
        {
            // TODO Do we need to do this everywhere for jade, prison and bomb? Seriously?
            ICard cardUsedToJudge = CentralCardDeck.DrawACard();

            Util.PrintPlayerAction(playerReceiving, cardUsedToJudge, PlayerAction.Judge);

            if (CardJudge.CardJudgingResult(cardJade, cardUsedToJudge))
            {
                CardJudge.CardTakeEffect(playerPlaying, playerReceiving, cardJade, null);
                Util.PrintPlayerAction(playerReceiving, cardJade, PlayerAction.JadeTakeEffect);
            }
            else
            {
                CardJudge.CardNotTakeEffect(null, playerPlaying, playerReceiving, cardJade);
                Util.PrintPlayerAction(playerReceiving, cardJade, PlayerAction.JadeNotTakeEffect);
            }
        }
コード例 #2
0
ファイル: CardTable.cs プロジェクト: liycncncn/Relauched
        void JudgeIndividualBomb(List <IPlayer> playerList, IPlayer playerCarrying)
        {
            ICard cardBombCarrying = playerCarrying.CardCarrying.Find(c => c.CardCarryingType == CarriedType.Bomb);

            if (cardBombCarrying == null)
            {
                // Early out if no bomb found
                return;
            }

            ICard cardUsedToJudge = null;

            //IPlayer playerResponding;
            // Raise the ResponseNeeded event
            ICard cardResponded = AllPlayersCanRespond(cardBombCarrying, null);

            if (cardResponded != null)
            {
                Util.PrintPlayerAction(cardResponded.PlayerPlaying, cardResponded, PlayerAction.Counter);
                CardJudge.CardNotTakeEffect(PlayerList, null, playerCarrying, cardBombCarrying);
                Util.PrintPlayerAction(playerCarrying, null, PlayerAction.BombNotTakeEffect);
            }
            else
            {
                Util.PrintPlayerAction(playerCarrying, null, PlayerAction.NoResponseFromAll);
                cardUsedToJudge = CentralCardDeck.DrawACard();
                Util.PrintPlayerAction(playerCarrying, cardUsedToJudge, PlayerAction.Judge);

                if (CardJudge.CardJudgingResult(cardBombCarrying, cardUsedToJudge))
                {
                    CardJudge.CardTakeEffect(null, playerCarrying, cardBombCarrying, null);
                    Util.PrintPlayerAction(playerCarrying, null, PlayerAction.BombTakeEffect);
                    Util.PrintPlayerAction(playerCarrying, null, PlayerAction.TakeDamage);
                }
                else
                {
                    CardJudge.CardNotTakeEffect(PlayerList, null, playerCarrying, cardBombCarrying);
                    Util.PrintPlayerAction(playerCarrying, null, PlayerAction.BombNotTakeEffect);
                }
            }
        }
コード例 #3
0
ファイル: CardTable.cs プロジェクト: liycncncn/Relauched
        bool EnterCardCounteringArena(IPlayer playerPlaying, IPlayer playerReceiving, ICard cardTriggering, ICard cardFirst,
                                      MiniRoundTimingOption timingCountering, MiniRoundTimingOption timingAnnulling)
        {
            ICard cardResponded;
            bool  cardFirstAnnulled = false;
            bool  firstMiniRound    = true;

            do
            {
                cardResponded = null;

                //IPlayer playerResponding;
                if (timingCountering == MiniRoundTimingOption.Always ||
                    timingCountering == MiniRoundTimingOption.FirstMiniRound && firstMiniRound)
                {
                    cardResponded = AllPlayersCanRespond(cardTriggering, cardFirst);
                }

                firstMiniRound = false;

                if (cardResponded == null)
                {
                    // No player has responded with a card as the third party
                    cardResponded = SinglePlayerMustRespond(playerReceiving, cardTriggering, cardFirst);
                }

                if (cardResponded == null)
                {
                    // There is no card played as the response to the card just been played
                    break;
                }

                // TODO What about those equipped cards which do not require a judging card?
                // Certain type of responded cade needs a judging card
                if (CardJudge.CardNeedJudgingCard(cardResponded))
                {
                    ICard cardJudging = CentralCardDeck.DrawACard();
                    if (CardJudge.CardJudgingResult(cardResponded, cardJudging))
                    {
                        CardJudge.CardTakeEffect(playerPlaying, playerReceiving, cardResponded, null);
                        Util.PrintPlayerAction(playerReceiving, null, PlayerAction.TakeDamage);

                        // Replace the responded card with the new card played in TakeEffect(),
                        // e.g. Replace JadeCard with DodgeCard
                        if (CardJudge.CardIsIntermediate(cardResponded))
                        {
                            cardResponded = playerReceiving.CardResponded;
                        }
                    }
                    else
                    {
                        // TODO Consider to move this to NotTakeEffect()
                        if (CardJudge.CardIsIntermediate(cardResponded))
                        {
                            cardResponded = playerPlaying.CardResponded = null;
                        }

                        // No player has responded with a card as the third party
                        cardResponded = SinglePlayerMustRespond(playerReceiving, cardTriggering, cardFirst);

                        if (cardResponded == null)
                        {
                            // There is no card played as the response to the card just been played
                            break;
                        }
                    }
                }

                //Util.PrintPlayerAction(cardResponded.PlayerPlaying, cardResponded, PlayerAction.Counter);
                cardFirstAnnulled = !cardFirstAnnulled;

                // This card just being played is an annulling card and cannot be countered
                if (cardResponded.IsAnnulling)
                {
                    break;
                }

                // Swap players so the player who plays card first in this mini-round needs to respond in the next mini-round
                Util.SwapPlayers(ref playerPlaying, ref playerReceiving);
            }while (cardResponded != null);

            return(cardFirstAnnulled);
        }