Example #1
0
        ICard DecideWhatCardToPlayOutOfYourTurn(SinglePlayerResponseArgs e)
        {
            ICard        cardTriggering = e.CardTriggering;
            List <ICard> miniCardList   = e.MiniCardList;
            ICard        cardFirst      = e.CardFirst;

            List <Func> funcsCanCounter;
            List <Func> funcsCanAnnul;
            ICard       cardResponded = null;

            if (CardJudge.CardCanBeCounteredByAnyPlayer(null, cardFirst, cardTriggering, out funcsCanCounter) != MiniRoundTimingOption.None)
            {
                cardResponded = PlayACard(this.FindASpecificCard(funcsCanCounter), PlayerToKill, false);
            }

            if (cardResponded != null)
            {
                return(cardResponded);
            }

            if (CardJudge.CardCanBeAnnulled(null, cardFirst, cardTriggering, out funcsCanAnnul) != MiniRoundTimingOption.None)
            {
                cardResponded = PlayACard(this.FindASpecificCard(funcsCanAnnul), PlayerToKill, true);
            }

            if (cardResponded != null)
            {
                return(cardResponded);
            }

            return(null); // Make no response
        }
Example #2
0
        void StartACardLifeCycle(IPlayer playerPlaying, IPlayer playerReceiving)
        {
            if (playerPlaying.CardPlayed != null)
            {
                Util.PrintPlayerAction(playerPlaying, playerPlaying.CardNeedResponse, PlayerAction.Play);
            }

            ICard cardTriggering;
            ICard cardFirst;

            cardFirst = cardTriggering = playerPlaying.CardNeedResponse;

            if (!CardJudge.CardHasImmediateEffect(cardFirst))
            {
                // The card played has no immediate effect
                CardJudge.CardGetDeployed(playerReceiving, cardFirst);
                Util.PrintPlayerAction(playerReceiving, cardFirst, PlayerAction.Deployed);
                return;
            }

            List <Func> funcsCanCounter;
            List <Func> funcsCanAnnul;
            bool        cardFirstAnnulled = false;

            MiniRoundTimingOption timingCountering = CardJudge.CardCanBeCounteredByAnyPlayer(playerPlaying, cardFirst, cardTriggering, out funcsCanCounter);
            MiniRoundTimingOption timingAnnulling  = CardJudge.CardCanBeAnnulled(playerPlaying, cardFirst, cardTriggering, out funcsCanAnnul);

            // TODO This last option varies from card to card
            if (timingCountering != MiniRoundTimingOption.None || timingAnnulling != MiniRoundTimingOption.None)
            {
                cardFirstAnnulled = EnterCardCounteringArena(playerPlaying, playerReceiving, cardTriggering, cardFirst,
                                                             timingCountering, timingAnnulling);
            }

            if (cardFirstAnnulled)
            {
                Util.PrintPlayerAction(playerReceiving, cardFirst, PlayerAction.Annulled);
                return;
            }

            // The card requires drawing more cards from the central card deck
            List <ICard> cardsExtraDrawn = null;

            if (CardJudge.CardNeedExtraCard(cardFirst))
            {
                cardsExtraDrawn = CentralCardDeck.DrawCards(CardJudge.CardNeedNumOfExtraCards(cardFirst, cardFirst));
                Util.PrintPlayerAction(playerReceiving, cardFirst, cardsExtraDrawn, PlayerAction.Drawn);
            }

            CardJudge.CardTakeEffect(playerPlaying, playerReceiving, cardFirst, cardsExtraDrawn);
            Util.PrintPlayerAction(playerReceiving, null, PlayerAction.TakeDamage);
        }
Example #3
0
        ICard DecideWhatCardToPlayOutOfYourTurn(SinglePlayerResponseArgs e)
        {
            ICard        cardTriggering = e.CardTriggering;
            List <ICard> miniCardList   = e.MiniCardList;
            ICard        cardFirst      = e.CardFirst;

            List <Func> funcsCanCounter;
            List <Func> funcsCanAnnul;
            ICard       cardResponded = null;

            //if (CardJudge.CardCanBeAnnulledByEquippable(null, cardFirst, cardTriggering, out funcsCanAnnul) != MiniRoundTimingOption.None)
            //  cardResponded = PlayACard(this.FindASpecificCard(funcsCanAnnul), PlayerToKill, true);

            // TODO Make the function parameters correct
            if (CardJudge.CanBePossiblyAnnulledByEquippable(cardFirst.PlayerPlaying, cardFirst, out funcsCanAnnul) != MiniRoundTimingOption.None)
            {
                cardResponded = PlayACard(this.FindASpecificCardInEquippable(funcsCanAnnul), PlayerToKill, true, true);
            }

            if (cardResponded != null)
            {
                return(cardResponded);
            }

            // TODO Add the logic about whether I want to intervene
            if (CardJudge.CardCanBeCounteredByAnyPlayer(null, cardFirst, cardTriggering, out funcsCanCounter) != MiniRoundTimingOption.None)
            {
                cardResponded = PlayACard(this.FindASpecificCard(funcsCanCounter), PlayerToKill, false, false);
            }

            if (cardResponded != null)
            {
                return(cardResponded);
            }

            if (CardJudge.CardCanBeAnnulled(null, cardFirst, cardTriggering, out funcsCanAnnul) != MiniRoundTimingOption.None)
            {
                cardResponded = PlayACard(this.FindASpecificCard(funcsCanAnnul), PlayerToKill, true, false);
            }

            if (cardResponded != null)
            {
                return(cardResponded);
            }

            return(null); // Make no response
        }