protected void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
NotifySkillUse(new List <Player>());
int answer;
if (Game.CurrentGame.UiProxies[Owner].AskForMultipleChoice(
new MultipleChoicePrompt(Prompt.SkillUseYewNoPrompt, new BaGuaZhen.BaGuaZhenSkill()), Prompt.YesNoChoices, out answer) &&
answer == 1)
{
ReadOnlyCard c = Game.CurrentGame.Judge(Owner, null, new Card()
{
Type = new BaGuaZhen()
}, (judgeResultCard) => { return(judgeResultCard.SuitColor == SuitColorType.Red); });
if (c.SuitColor == SuitColorType.Red)
{
eventArgs.Cards = new List <Card>();
eventArgs.Skill = new CardWrapper(Owner, new Shan(), false);
ActionLog log = new ActionLog();
log.Source = Owner;
log.SkillAction = new BaGuaZhen().EquipmentSkill;
log.GameAction = GameAction.None;
Game.CurrentGame.NotificationProxy.NotifySkillUse(log);
throw new TriggerResultException(TriggerResult.Success);
}
}
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs eventArgs)
{
if (eventArgs != null)
{
eventArgs.ReadonlyCard[ShaCancelling.ShaCancellationCount]--;
}
}
public void OnAfterDamageInflicted(Player owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
ReadOnlyCard c = Game.CurrentGame.Judge(owner, this, null, (judgeResultCard) => { return(judgeResultCard.Suit != SuitType.Heart); });
if (c.Suit != SuitType.Heart)
{
NotifySkillUse(new List <Player>()
{
eventArgs.Source
});
List <DeckPlace> deck = new List <DeckPlace>();
GangLieVerifier ver = new GangLieVerifier();
ISkill skill;
List <Card> cards;
List <Player> players;
if (!Game.CurrentGame.UiProxies[eventArgs.Source].AskForCardUsage(new CardUsagePrompt("GangLie", Owner), ver, out skill, out cards, out players))
{
Game.CurrentGame.DoDamage(owner, eventArgs.Source, 1, DamageElement.None, null, null);
}
else
{
Game.CurrentGame.HandleCardDiscard(eventArgs.Source, cards);
}
}
else
{
Trace.TraceInformation("Judgement fail");
}
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
if (dest.Health >= dest.MaxHealth)
{
return;
}
Game.CurrentGame.RecoverHealth(source, dest, 1);
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
if (readonlyCard[EatOneGetAnotherFreeCoupon] == 1)
{
Game.CurrentGame.RecoverHealth(source, dest, 2);
}
else
{
Game.CurrentGame.RecoverHealth(source, dest, 1);
}
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
if (Game.CurrentGame.DyingPlayers.Count > 0)
{
Game.CurrentGame.RecoverHealth(source, dest, 1);
}
else
{
dest[JiuUsed] = 1;
dest[Drank] = 1;
}
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
DeckType wuguDeck = DeckType.Register("WuGu");
DeckType wuguFakeDeck = DeckType.Register("WuGuFake");
List <List <Card> > answer;
if (!Game.CurrentGame.UiProxies[dest].AskForCardChoice(new CardChoicePrompt("WuGuFengDeng"),
new List <DeckPlace>()
{
new DeckPlace(null, wuguFakeDeck)
},
new List <string>()
{
"WuGu"
},
new List <int>()
{
1
},
new WuGuCardChoiceVerifier(FakeMapping),
out answer,
new AdditionalCardChoiceOptions()
{
IsWuGu = true
}))
{
Trace.TraceInformation("Invalid answer for WuGu, choosing for you");
answer = new List <List <Card> >();
answer.Add(new List <Card>());
answer[0].Add(Game.CurrentGame.Decks[null, wuguDeck][0]);
}
else
{
if (!FakeMapping.ContainsKey(answer[0][0]) || FakeMapping[answer[0][0]] == null)
{
answer[0] = new List <Card>()
{
Game.CurrentGame.Decks[null, wuguDeck][0]
};
}
var theCard = answer[0][0];
answer[0] = new List <Card>()
{
FakeMapping[theCard]
};
FakeMapping[theCard] = null;
}
Game.CurrentGame.HandleCardTransferToHand(null, dest, answer[0], new MovementHelper()
{
IsWuGu = true
});
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
SingleCardUsageVerifier v1 = new SingleCardUsageVerifier((c) => { return(RequiredCard.GetType().IsAssignableFrom(c.Type.GetType())); }, false, RequiredCard);
List <Player> sourceList = new List <Player>();
sourceList.Add(source);
GameEventArgs args = new GameEventArgs();
args.Source = dest;
args.Targets = sourceList;
args.Card = new CompositeCard();
args.Card.Type = RequiredCard;
args.ReadonlyCard = readonlyCard;
try
{
Game.CurrentGame.Emit(GameEvent.PlayerRequireCard, args);
}
catch (TriggerResultException e)
{
if (e.Status == TriggerResult.Success)
{
Game.CurrentGame.HandleCardPlay(dest, args.Skill, args.Cards, sourceList);
return;
}
}
while (true)
{
IPlayerProxy ui = Game.CurrentGame.UiProxies[dest];
ISkill skill;
List <Player> p;
List <Card> cards;
Game.CurrentGame.Emit(GameEvent.PlayerIsAboutToPlayCard, new PlayerIsAboutToUseOrPlayCardEventArgs()
{
Source = dest, Verifier = v1
});
if (!ui.AskForCardUsage(new CardUsagePrompt(UsagePromptString, source),
v1, out skill, out cards, out p))
{
Trace.TraceInformation("Player {0} Invalid answer", dest);
Game.CurrentGame.DoDamage(source.IsDead ? null : source, dest, 1, DamageElement.None, card, readonlyCard);
}
else
{
if (!Game.CurrentGame.HandleCardPlay(dest, skill, cards, sourceList))
{
continue;
}
Trace.TraceInformation("Player {0} Responded. ", dest.Id);
}
break;
}
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
if (!eventArgs.Targets.Contains(Owner))
{
return;
}
DamageEventArgs damageArgs = eventArgs as DamageEventArgs;
ReadOnlyCard rCard = new ReadOnlyCard(damageArgs.ReadonlyCard);
rCard[ShiChouDamage] = 1;
target[ShiChouTarget[Owner]]++;
Game.CurrentGame.DoDamage(damageArgs.Source, target, Owner, damageArgs.Magnitude, damageArgs.Element, damageArgs.Card, rCard);
throw new TriggerResultException(TriggerResult.End);
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
IPlayerProxy ui = Game.CurrentGame.UiProxies[source];
if (source.IsDead)
{
return;
}
if (dest.HandCards().Count + dest.Equipments().Count + dest.DelayedTools().Count == 0)
{
return; // ShunChai -> WuXie(from target) -> WuXie(soemone else) -> target has no card
}
List <DeckPlace> places = new List <DeckPlace>();
places.Add(new DeckPlace(dest, DeckType.Hand));
places.Add(new DeckPlace(dest, DeckType.Equipment));
places.Add(new DeckPlace(dest, DeckType.DelayedTools));
List <string> resultDeckPlace = new List <string>();
resultDeckPlace.Add(ResultDeckName);
List <int> resultDeckMax = new List <int>();
resultDeckMax.Add(1);
List <List <Card> > answer;
if (!ui.AskForCardChoice(new CardChoicePrompt(ChoicePrompt), places, resultDeckPlace, resultDeckMax, new RequireOneCardChoiceVerifier(true), out answer))
{
Trace.TraceInformation("Player {0} Invalid answer", source.Id);
answer = new List <List <Card> >();
answer.Add(Game.CurrentGame.PickDefaultCardsFrom(places));
}
Card theCard = answer[0][0];
if (ShunChaiDest(source, dest).DeckType == DeckType.Discard)
{
Game.CurrentGame.HandleCardDiscard(dest, new List <Card>()
{
theCard
});
}
else
{
Game.CurrentGame.HandleCardTransferToHand(dest, source, new List <Card>()
{
theCard
});
}
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
IPlayerProxy ui = Game.CurrentGame.UiProxies[dest];
HuoGongCardChoiceVerifier v1 = new HuoGongCardChoiceVerifier();
ISkill s;
List <Player> p;
List <Card> cards;
if (dest.IsDead)
{
return;
}
if (!ui.AskForCardUsage(new CardUsagePrompt("HuoGong", source), v1, out s, out cards, out p))
{
Trace.TraceInformation("Player {0} Invalid answer", dest);
cards = new List <Card>();
if (Game.CurrentGame.Decks[dest, DeckType.Hand].Count == 0)
{
Trace.TraceError("HuoGong Cannot Show Card! This should NOT have happened!");
return;
}
cards.Add(Game.CurrentGame.Decks[dest, DeckType.Hand][0]);
}
var theCard = cards[0];
Game.CurrentGame.SyncCardAll(ref theCard);
Trace.TraceInformation("Player {0} HuoGong showed {1}, ", dest.Id, theCard);
Game.CurrentGame.NotificationProxy.NotifyShowCard(dest, theCard);
if (source.IsDead)
{
return;
}
ui = Game.CurrentGame.UiProxies[source];
HuoGongCardMatchVerifier v2 = new HuoGongCardMatchVerifier(theCard.Suit);
Game.CurrentGame.HideHandCard(theCard);
v2.Owner = source;
if (ui.AskForCardUsage(new CardUsagePrompt("HuoGong2", dest, theCard.Suit), v2, out s, out cards, out p))
{
Game.CurrentGame.HandleCardDiscard(source, cards);
Game.CurrentGame.DoDamage(source, dest, 1, DamageElement.Fire, card, readonlyCard);
}
else
{
Trace.TraceInformation("HuoGong aborted, failed to provide card");
}
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
ISkill skill;
List<Card> cards;
List<Player> players;
DamageEventArgs args = eventArgs as DamageEventArgs;
if (Game.CurrentGame.UiProxies[Owner].AskForCardUsage(new CardUsagePrompt("TianXiang"), new TianXiangVerifier(),
out skill, out cards, out players))
{
NotifySkillUse(players);
Game.CurrentGame.HandleCardDiscard(Owner, cards);
ReadOnlyCard ncard = new ReadOnlyCard(args.ReadonlyCard);
ncard[TianXiangDamage] = 1;
players[0][TianXiangTarget]++;
Game.CurrentGame.DoDamage(args.Source, players[0], Owner, args.Magnitude, args.Element, args.Card, ncard);
throw new TriggerResultException(TriggerResult.End);
}
}
protected void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
ParentEquipment.InUse = true;
ReadOnlyCard c = Game.CurrentGame.Judge(Owner, null, new Card()
{
Type = new BaGuaZhen()
}, (judgeResultCard) => { return(judgeResultCard.SuitColor == SuitColorType.Red); });
ParentEquipment.InUse = false;
if (c.SuitColor == SuitColorType.Red)
{
eventArgs.Cards = new List <Card>();
eventArgs.Skill = new CardWrapper(Owner, new Shan(), false);
ActionLog log = new ActionLog();
log.Source = Owner;
log.SkillAction = this;
log.GameAction = GameAction.None;
Game.CurrentGame.NotificationProxy.NotifySkillUse(log);
throw new TriggerResultException(TriggerResult.Success);
}
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
if (source.IsDead)
{
return;
}
if (dest.Equipments().Count == 0)
{
Game.CurrentGame.DoDamage(source, dest, 1, DamageElement.None, null, null);
return;
}
int answer;
if (dest.AskForMultipleChoice(new MultipleChoicePrompt("ShuiYanQiJun"), OptionPrompt.YesNoChoices, out answer) && answer == 1)
{
Game.CurrentGame.HandleCardDiscard(dest, new List <Card>(dest.Equipments()));
}
else
{
Game.CurrentGame.DoDamage(source, dest, 1, DamageElement.None, null, null);
}
}
public override void Activate(Player p, Card c)
{
while (true)
{
GameEventArgs args = new GameEventArgs();
args.Source = null;
args.Targets = new List <Player>()
{
p
};
args.Card = c;
args.ReadonlyCard = new ReadOnlyCard(c);
try
{
Game.CurrentGame.Emit(GameEvent.CardUsageBeforeEffected, args);
}
catch (TriggerResultException e)
{
Trace.Assert(e.Status == TriggerResult.End);
break;
}
ReadOnlyCard result = Game.CurrentGame.Judge(p, null, c, (judgeResultCard) => { return(judgeResultCard.Suit == SuitType.Spade && judgeResultCard.Rank >= 2 && judgeResultCard.Rank <= 9); });
if (result.Suit == SuitType.Spade && result.Rank >= 2 && result.Rank <= 9)
{
var roc = new ReadOnlyCard(c);
CardsMovement move = new CardsMovement();
move.Cards = new List <Card>();
move.Cards.Add(c);
move.To = new DeckPlace(null, DeckType.Discard);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.DoDamage(null, p, 3, DamageElement.Lightning, c, roc);
return;
}
break;
}
RecursiveShanDianDriver(p, p, c);
}
public override void Activate(Player p, Card c)
{
while (true)
{
GameEventArgs args = new GameEventArgs();
args.Source = null;
args.Targets = new List <Player>()
{
p
};
args.Card = c;
args.ReadonlyCard = new ReadOnlyCard(c);
try
{
Game.CurrentGame.Emit(GameEvent.CardUsageBeforeEffected, args);
}
catch (TriggerResultException e)
{
Trace.Assert(e.Status == TriggerResult.End);
break;
}
ReadOnlyCard result = Game.CurrentGame.Judge(p, null, c, (judgeResultCard) => { return(judgeResultCard.Suit != SuitType.Heart); });
if (result.Suit != SuitType.Heart)
{
Game.CurrentGame.PhasesSkipped.Add(TurnPhase.Play);
}
break;
}
CardsMovement move = new CardsMovement();
move.Cards = new List <Card>();
move.Cards.Add(c);
move.To = new DeckPlace(null, DeckType.Discard);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move, false, Core.Utils.GameDelays.None);
}
void ZhaoLieProcess(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
ZhaoLieUsed = false;
basicCards.Clear();
notBasicCards.Clear();
List <Card> tao = new List <Card>();
DeckType ZhaoLieDeck = DeckType.Register("ZhaoLie");
CardsMovement move = new CardsMovement();
move.Cards = new List <Card>();
int toDraw = 3;
for (int i = 0; i < toDraw; i++)
{
Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.PeekCard(0));
Card c = Game.CurrentGame.DrawCard();
c.Log.SkillAction = this;
c.Log.Source = Owner;
move.Cards.Add(c);
Game.CurrentGame.NotificationProxy.NotifyShowCard(null, c);
if (c.Type is Tao)
{
tao.Add(c);
}
else if (c.Type.IsCardCategory(CardCategory.Basic))
{
basicCards.Add(c);
}
else
{
notBasicCards.Add(c);
}
}
move.To = new DeckPlace(null, ZhaoLieDeck);
Game.CurrentGame.MoveCards(move);
int answer = 0;
List <OptionPrompt> prompts = new List <OptionPrompt>();
prompts.Add(new OptionPrompt("ZhaoLieShangHai", notBasicCards.Count, basicCards.Count));
prompts.Add(new OptionPrompt("ZhaoLieQiPai", notBasicCards.Count, basicCards.Count));
while (true)
{
if (ZhaoLieTarget.HandCards().Count + ZhaoLieTarget.Equipments().Count < notBasicCards.Count)
{
break;
}
ZhaoLieTarget.AskForMultipleChoice(new MultipleChoicePrompt("ZhaoLie"), prompts, out answer);
break;
}
List <Card> toDiscard = new List <Card>();
toDiscard.AddRange(notBasicCards);
toDiscard.AddRange(tao);
foreach (Card c in toDiscard)
{
c.Log = new ActionLog();
c.Log.SkillAction = this;
c.Log.GameAction = GameAction.PlaceIntoDiscard;
}
Game.CurrentGame.PlaceIntoDiscard(null, toDiscard);
if (answer == 0)
{
if (notBasicCards.Count == 0)
{
Game.CurrentGame.HandleCardTransferToHand(null, ZhaoLieTarget, basicCards);
}
else
{
ReadOnlyCard rCard = new ReadOnlyCard(new Card()
{
Place = new DeckPlace(null, null)
});
rCard[ZhaoLieDamage] = 1;
Game.CurrentGame.DoDamage(Owner, ZhaoLieTarget, notBasicCards.Count, DamageElement.None, null, rCard);
}
}
else
{
for (int i = 0; i < notBasicCards.Count; i++)
{
Game.CurrentGame.ForcePlayerDiscard(ZhaoLieTarget, (pl, d) => { return(1 - d); }, true);
}
Game.CurrentGame.HandleCardTransferToHand(null, Owner, basicCards);
}
ZhaoLieTarget = null;
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
Game.CurrentGame.DoDamage(source, dest, 1, ShaDamageElement, card, readonlyCard);
}
public void DoDamage(Player source, Player dest, int magnitude, DamageElement elemental, ICard card, ReadOnlyCard readonlyCard)
{
DoDamage(source, dest, dest, magnitude, elemental, card, readonlyCard);
}
/// <summary>
/// 造成伤害
/// </summary>
/// <param name="source">伤害来源</param>
/// <param name="dest">伤害目标</param>
/// <param name="originalTarget">最初的伤害目标</param>
/// <param name="magnitude">伤害点数</param>
/// <param name="elemental">伤害属性</param>
/// <param name="cards">造成伤害的牌</param>
public void DoDamage(Player source, Player dest, Player originalTarget, int magnitude, DamageElement elemental, ICard card, ReadOnlyCard readonlyCard)
{
if (dest.IsDead)
{
return;
}
var damageArgs = new DamageEventArgs()
{
Source = source, OriginalTarget = originalTarget, Targets = new List <Player>(), Magnitude = magnitude, Element = elemental
};
HealthChangedEventArgs healthChangedArgs;
int ironShackledDamage = 0;
DamageElement ironShackledDamageElement = DamageElement.None;
if (readonlyCard == null)
{
readonlyCard = new ReadOnlyCard(new Card()
{
Place = new DeckPlace(null, null)
});
}
damageArgs.ReadonlyCard = readonlyCard;
if (card is CompositeCard)
{
if ((card as CompositeCard).Subcards != null)
{
damageArgs.Cards = new List <Card>((card as CompositeCard).Subcards);
}
}
else if (card is Card)
{
damageArgs.Cards = new List <Card>()
{
card as Card
};
}
else
{
damageArgs.Cards = new List <Card>();
}
damageArgs.Targets.Add(dest);
damageArgs.Card = card;
try
{
//伤害来源与基数、属性的确定发生在伤害结算前，连环，以及转移的伤害不会重新确定来源与基数，所以不会多次触发【裸衣】，以及【酒】
while (damageArgs.ReadonlyCard[SourceAndElementIsConfirmed] == 0)
{
Emit(GameEvent.DamageSourceConfirmed, damageArgs);
Emit(GameEvent.DamageElementConfirmed, damageArgs);
damageArgs.ReadonlyCard[SourceAndElementIsConfirmed] = 1;
break;
}
Emit(GameEvent.BeforeDamageComputing, damageArgs);
Emit(GameEvent.DamageComputingStarted, damageArgs);
Emit(GameEvent.DamageCaused, damageArgs);
Emit(GameEvent.DamageInflicted, damageArgs);
if (damageArgs.Magnitude == 0)
{
Trace.TraceInformation("Damage is 0, aborting");
return;
}
if (damageArgs.Targets[0].IsIronShackled && damageArgs.Element != DamageElement.None)
{
ironShackledDamage = damageArgs.Magnitude;
Trace.TraceInformation("IronShackled damage {0}", ironShackledDamage);
ironShackledDamageElement = damageArgs.Element;
damageArgs.Targets[0].IsIronShackled = false;
// if this is TieSuo damage already, prevent itself from spreading...
if (readonlyCard[IsIronShackleDamage] == 1)
{
ironShackledDamage = 0;
}
}
healthChangedArgs = new HealthChangedEventArgs(damageArgs);
Emit(GameEvent.BeforeHealthChanged, healthChangedArgs);
damageArgs.Magnitude = -healthChangedArgs.Delta;
}
catch (TriggerResultException e)
{
if (e.Status == TriggerResult.End)
{
//伤害结算完毕事件应该总是被触发
//受到伤害的角色如果存活能发动的技能/会执行的技能效果：【酒诗②】、执行【天香】摸牌的效果。
Emit(GameEvent.DamageComputingFinished, damageArgs);
Trace.TraceInformation("Damage Aborted");
return;
}
Trace.Assert(false);
return;
}
Trace.Assert(damageArgs.Targets.Count == 1);
damageArgs.Targets[0].Health -= damageArgs.Magnitude;
Trace.TraceInformation("Player {0} Lose {1} hp, @ {2} hp", damageArgs.Targets[0].Id, damageArgs.Magnitude, damageArgs.Targets[0].Health);
NotificationProxy.NotifyDamage(damageArgs.Source, damageArgs.Targets[0], damageArgs.Magnitude, damageArgs.Element);
GameDelays.Delay(GameDelays.Damage);
try
{
Emit(GameEvent.AfterHealthChanged, healthChangedArgs);
}
catch (TriggerResultException)
{
}
Emit(GameEvent.AfterDamageCaused, damageArgs);
Emit(GameEvent.AfterDamageInflicted, damageArgs);
Emit(GameEvent.DamageComputingFinished, damageArgs);
if (ironShackledDamage != 0)
{
List <Player> toProcess = new List <Player>(AlivePlayers);
SortByOrderOfComputation(CurrentPlayer, toProcess);
foreach (Player p in toProcess)
{
if (p.IsIronShackled)
{
readonlyCard[IsIronShackleDamage] = 1;
DoDamage(damageArgs.Source, p, originalTarget, ironShackledDamage, ironShackledDamageElement, card, readonlyCard);
}
}
}
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
ReadOnlyCard card = eventArgs.ReadonlyCard;
SingleCardUsageVerifier v1 = new SingleCardUsageVerifier((c) => { return(c.Type is WuXieKeJi); }, true, new WuXieKeJi());
v1.Helper.ExtraTimeOutSeconds = -9;
List <Card> cards;
List <Player> players;
ISkill skill;
Player responder;
bool WuXieSuccess = false;
Trace.Assert(eventArgs.Targets.Count == 1);
Player promptPlayer = eventArgs.Targets[0];
ICard promptCard = eventArgs.ReadonlyCard;
if (card != null && CardCategoryManager.IsCardCategory(card.Type.Category, CardCategory.Tool) &&
card[WuXieKeJi.CannotBeCountered] == 0 && card[WuXieKeJi.CannotBeCountered[promptPlayer]] == 0)
{
bool askWuXie = false;
foreach (var p in Game.CurrentGame.AlivePlayers)
{
foreach (var c in Game.CurrentGame.Decks[p, DeckType.Hand])
{
if (c.Type is WuXieKeJi)
{
askWuXie = true;
break;
}
}
foreach (var sk in p.ActionableSkills)
{
CardTransformSkill cts = sk as CardTransformSkill;
if (cts != null)
{
if (cts.PossibleResults == null)
{
askWuXie = true;
break;
}
foreach (var pr in cts.PossibleResults)
{
if (pr is WuXieKeJi)
{
askWuXie = true;
break;
}
}
}
}
if (askWuXie)
{
break;
}
}
Game.CurrentGame.SyncConfirmationStatus(ref askWuXie);
if (!askWuXie)
{
return;
}
foreach (var p in Game.CurrentGame.AlivePlayers)
{
Game.CurrentGame.Emit(GameEvent.PlayerIsAboutToPlayCard, new PlayerIsAboutToUseOrPlayCardEventArgs()
{
Source = p, Verifier = v1
});
}
while (true)
{
Prompt prompt = new CardUsagePrompt("WuXieKeJi", promptPlayer, promptCard);
if (Game.CurrentGame.GlobalProxy.AskForCardUsage(
prompt, v1, out skill, out cards, out players, out responder))
{
try
{
GameEventArgs args = new GameEventArgs();
args.Source = responder;
args.Targets = players;
args.Skill = skill;
args.Cards = cards;
Game.CurrentGame.Emit(GameEvent.CommitActionToTargets, args);
}
catch (TriggerResultException e)
{
Trace.Assert(e.Status == TriggerResult.Retry);
continue;
}
promptPlayer = responder;
promptCard = new CompositeCard();
promptCard.Type = new WuXieKeJi();
(promptCard as CompositeCard).Subcards = null;
WuXieSuccess = !WuXieSuccess;
}
else
{
break;
}
}
}
if (WuXieSuccess)
{
throw new TriggerResultException(TriggerResult.End);
}
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
Player current = dest;
bool firstTime = true;
while (true)
{
List <Player> sourceList = new List <Player>();
if (current == dest)
{
sourceList.Add(source);
}
else
{
sourceList.Add(dest);
}
IPlayerProxy ui = Game.CurrentGame.UiProxies[current];
SingleCardUsageVerifier v1 = new SingleCardUsageVerifier((c) => { return(c.Type is Sha); }, false, new Sha());
ISkill skill;
List <Player> p;
List <Card> cards;
CardUsagePrompt prompt;
if (current.IsDead)
{
return;
}
if (firstTime)
{
prompt = new CardUsagePrompt("JueDou", source);;
}
else
{
prompt = new CardUsagePrompt("JueDou2", current == dest ? source : dest);
firstTime = false;
}
int numberOfShaRequired = current == dest ? readonlyCard[CardAttribute.TargetRequireTwoResponses[dest]] + 1 : readonlyCard[CardAttribute.SourceRequireTwoResponses] + 1;
bool cannotProvideSha = false;
while (numberOfShaRequired > 0)
{
Game.CurrentGame.Emit(GameEvent.PlayerIsAboutToPlayCard, new PlayerIsAboutToUseOrPlayCardEventArgs()
{
Source = current, Verifier = v1
});
if (!ui.AskForCardUsage(prompt, v1, out skill, out cards, out p))
{
Trace.TraceInformation("Player {0} Invalid answer", current);
cannotProvideSha = true;
break;
}
if (!Game.CurrentGame.HandleCardPlay(current, skill, cards, sourceList))
{
continue;
}
numberOfShaRequired--;
}
if (cannotProvideSha)
{
break;
}
Trace.TraceInformation("Player {0} SHA, ", current.Id);
if (current == dest)
{
current = source;
}
else
{
current = dest;
}
}
Player won = current == dest ? source : dest;
Game.CurrentGame.DoDamage(won, current, 1, DamageElement.None, card, readonlyCard);
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
Game.CurrentGame.DrawCards(dest, 2);
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
if (source.IsDead)
{
return;
}
if (dest.HandCards().Count + dest.Equipments().Count == 0)
{
return; // ShunChai -> WuXie(from target) -> WuXie(soemone else) -> target has no card
}
List <string> resultDeckPlace = new List <string>();
resultDeckPlace.Add("GuoHeChaiQiao");
List <int> resultDeckMax = new List <int>();
resultDeckMax.Add(1);
List <List <Card> > answer;
bool doHandCard = true;
if (dest.Equipments().Count != 0)
{
int result = 0;
source.AskForMultipleChoice(new MultipleChoicePrompt("GuoHeChaiQiao2"), new List <OptionPrompt>()
{
new OptionPrompt("ShouPai"), new OptionPrompt("ZhuangBeiPai")
}, out result);
if (result == 1)
{
doHandCard = false;
}
}
if (doHandCard)
{
Game.CurrentGame.SyncImmutableCards(source, Game.CurrentGame.Decks[dest, DeckType.Hand]);
Game.CurrentGame.HandCardVisibility[source].Add(dest);
var places = new List <DeckPlace>()
{
new DeckPlace(dest, DeckType.Hand)
};
if (!source.AskForCardChoice(new CardChoicePrompt("GuoHeChaiQiao2"), places, resultDeckPlace, resultDeckMax, new RequireOneCardChoiceVerifier(true), out answer))
{
Trace.TraceInformation("Player {0} Invalid answer", source.Id);
answer = new List <List <Card> >();
answer.Add(Game.CurrentGame.PickDefaultCardsFrom(places));
}
foreach (Card c in dest.HandCards())
{
Game.CurrentGame.HideHandCard(c);
}
Game.CurrentGame.HandCardVisibility[source].Remove(dest);
Game.CurrentGame.HandleCardDiscard(dest, answer[0]);
}
else
{
var places = new List <DeckPlace>()
{
new DeckPlace(dest, DeckType.Equipment)
};
if (!source.AskForCardChoice(new CardChoicePrompt("GuoHeChaiQiao2"), places, resultDeckPlace, resultDeckMax, new RequireOneCardChoiceVerifier(true), out answer))
{
Trace.TraceInformation("Player {0} Invalid answer", source.Id);
answer = new List <List <Card> >();
answer.Add(Game.CurrentGame.PickDefaultCardsFrom(places));
}
Game.CurrentGame.HandleCardDiscard(dest, answer[0]);
}
}
protected override void Process(Players.Player source, Players.Player dest, ICard card, ReadOnlyCard cardr, GameEventArgs inResponseTo)
{
throw new NotImplementedException();
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard cardr, GameEventArgs inResponseTo)
{
dest.IsIronShackled = !dest.IsIronShackled;
Game.CurrentGame.NotificationProxy.NotifyIronShackled(dest);
}
