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