void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
ISkill skill;
List<Card> cards;
List<Player> players;
List<Card> originalCards = new List<Card>(Game.CurrentGame.Decks[Owner, QiXing.QiXingDeck]);
int qxCount = Game.CurrentGame.Decks[Owner, QiXing.QiXingDeck].Count;
// hack the cards to owner's hand. do not trigger anything
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(Game.CurrentGame.Decks[Owner, QiXing.QiXingDeck]);
move.To = new DeckPlace(Owner, DeckType.Hand);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
if (Game.CurrentGame.UiProxies[Owner].AskForCardUsage(new CardUsagePrompt("KuangFeng"), new KuangFengVerifier(originalCards), out skill, out cards, out players))
{
NotifySkillUse(players);
kuangfengTarget = players[0];
kuangfengTarget[KuangFengMark] = 1;
originalCards.Remove(cards[0]);
Game.CurrentGame.HandleCardDiscard(null, cards);
}
move.Cards = new List<Card>(originalCards);
move.To = new DeckPlace(Owner, QiXing.QiXingDeck);
Game.CurrentGame.MoveCards(move);
}
public BuQu()
{
var trigger = new AutoNotifyPassiveSkillTrigger(
this,
(p, e, a) =>
{
DeckType bq = new PrivateDeckType("BuQu", true);
if (p.Health > 0 && Game.CurrentGame.Decks[Owner, bq].Count > 0)
{
int toDraw = Game.CurrentGame.Decks[Owner, bq].Count - Math.Max(0, -Owner.Health);
while (toDraw-- > 0)
{
Card c1 = Game.CurrentGame.Decks[Owner, bq][Game.CurrentGame.Decks[Owner, bq].Count - 1];
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>() { c1 };
move.To = new DeckPlace(Owner, bq);
Game.CurrentGame.MoveCards(move);
}
}
return p.Health <= 0;
},
Run,
TriggerCondition.OwnerIsTarget
) { Type = TriggerType.Skill };
Triggers.Add(GameEvent.AfterHealthChanged, trigger);
IsAutoInvoked = 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.Heart; });
if (result.Suit != SuitType.Heart)
{
var theTrigger = new LeBuSiShuTrigger() { Priority = int.MaxValue };
theTrigger.Owner = p;
Game.CurrentGame.RegisterTrigger(GameEvent.PhaseOutEvents[TurnPhase.Draw], theTrigger);
}
break;
}
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
move.Cards.Add(c);
move.To = new DeckPlace(null, DeckType.Discard);
Game.CurrentGame.MoveCards(move);
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
var args = eventArgs as DiscardCardEventArgs;
if (args.Source == null || args.Source == Owner || (args.Reason != DiscardReason.Discard && args.Reason != DiscardReason.Judge))
{
return;
}
int answer = 0;
var cardsToProcess = new List<Card>(
from c in eventArgs.Cards
where c.Suit == SuitType.Club
select c);
if (cardsToProcess.Count() > 0)
{
CardsMovement temp = new CardsMovement();
temp.Cards = new List<Card>(cardsToProcess);
temp.To = new DeckPlace(null, DeckType.Discard);
Game.CurrentGame.NotificationProxy.NotifyCardMovement(new List<CardsMovement>() { temp });
foreach (Card cc in cardsToProcess)
{
cc.PlaceOverride = new DeckPlace(null, DeckType.Discard);
}
}
foreach (var c in cardsToProcess)
{
var prompt = new MultipleChoicePrompt("LuoYing", c);
if (Owner.AskForMultipleChoice(prompt, Prompt.YesNoChoices, out answer) && answer == 1)
{
NotifySkillUse();
Game.CurrentGame.HandleCardTransferToHand(null, Owner, new List<Card>() { c });
eventArgs.Cards.Remove(c);
}
}
}
protected void Draw(Player player, GameEvent gameEvent, GameEventArgs eventArgs, List<Card> cards, List<Player> players)
{
Game.CurrentGame.SortByOrderOfComputation(Game.CurrentGame.CurrentPlayer, players);
StagingDeckType QiaoBianDeck = new StagingDeckType("QiaoBian");
CardsMovement move = new CardsMovement();
move.Helper.IsFakedMove = true;
foreach (Player p in players)
{
if (p.HandCards().Count == 0) continue;
List<List<Card>> answer;
var places = new List<DeckPlace>() { new DeckPlace(p, DeckType.Hand) };
if (!Game.CurrentGame.UiProxies[Owner].AskForCardChoice(new CardChoicePrompt("QiaoBian", Owner), places,
new List<string>() { "QiaoBian" }, new List<int>() { 1 }, new RequireOneCardChoiceVerifier(true), out answer))
{
answer = new List<List<Card>>();
answer.Add(Game.CurrentGame.PickDefaultCardsFrom(places));
}
move.Cards = answer[0];
move.To = new DeckPlace(p, QiaoBianDeck);
Game.CurrentGame.MoveCards(move, false, Core.Utils.GameDelayTypes.None);
Game.CurrentGame.PlayerLostCard(p, answer[0]);
}
move.Cards.Clear();
move.Helper.IsFakedMove = false;
move.To = new DeckPlace(Owner, DeckType.Hand);
foreach (Player p in players)
{
move.Cards.AddRange(Game.CurrentGame.Decks[p, QiaoBianDeck]);
}
cards = new List<Card>(move.Cards);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerAcquiredCard(Owner, cards);
Game.CurrentGame.NotificationProxy.NotifyActionComplete();
}
public override void Process(Player source, List<Player> dests, ICard card, ReadOnlyCard readonlyCard)
{
DeckType wuguDeck = new DeckType("WuGu");
DeckType wuguFakeDeck = new DeckType("WuGuFake");
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
for (int i = 0; i < dests.Count; i++)
{
Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.PeekCard(0));
Card c = Game.CurrentGame.DrawCard();
move.Cards.Add(c);
}
move.To = new DeckPlace(null, wuguDeck);
Game.CurrentGame.MoveCards(move);
fakeMapping = new Dictionary<Card, Card>();
Game.CurrentGame.Decks[null, wuguFakeDeck].Clear();
foreach (var c in Game.CurrentGame.Decks[null, wuguDeck])
{
var faked = new Card(c);
faked.Place = new DeckPlace(null, wuguFakeDeck);
Game.CurrentGame.Decks[null, wuguFakeDeck].Add(faked);
fakeMapping.Add(faked, c);
}
Game.CurrentGame.NotificationProxy.NotifyWuGuStart(new DeckPlace(null, wuguFakeDeck));
base.Process(source, dests, card, readonlyCard);
Game.CurrentGame.NotificationProxy.NotifyWuGuEnd();
Game.CurrentGame.Decks[null, wuguFakeDeck].Clear();
if (Game.CurrentGame.Decks[null, wuguDeck].Count > 0)
{
move = new CardsMovement();
move.Cards = new List<Card>(Game.CurrentGame.Decks[null, wuguDeck]);
move.To = new DeckPlace(null, DeckType.Discard);
Game.CurrentGame.MoveCards(move);
}
}
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 Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType HuoShouDeck = DeckType.Register("HuoShou");
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
int toDraw = Owner.LostHealth;
for (int i = 0; i < toDraw; i++)
{
Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.PeekCard(0));
Card c = Game.CurrentGame.DrawCard();
move.Cards.Add(c);
}
move.To = new DeckPlace(null, HuoShouDeck);
Game.CurrentGame.MoveCards(move);
List<Card> toDiscard = new List<Card>();
foreach (var c in move.Cards)
{
if (c.Suit == SuitType.Heart)
{
toDiscard.Add(c);
Game.CurrentGame.RecoverHealth(Owner, Owner, 1);
}
}
Game.CurrentGame.HandleCardDiscard(null, toDiscard);
Game.CurrentGame.HandleCardTransferToHand(null, Owner, Game.CurrentGame.Decks[null, HuoShouDeck]);
Game.CurrentGame.CurrentPhaseEventIndex++;
throw new TriggerResultException(TriggerResult.End);
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
var card = Game.CurrentGame.Judge(Owner, this, null, (judgeResultCard) => { return judgeResultCard.SuitColor == SuitColorType.Black; });
if (card.SuitColor == SuitColorType.Black)
{
ISkill skill;
List<Card> cards;
List<Player> players;
int toDraw = Owner.LostHealth;
List<Card> remainingCards = new List<Card>();
CardsMovement move = new CardsMovement();
for (int i = 0; i < toDraw; i++)
{
Game.CurrentGame.SyncImmutableCard(Owner, Game.CurrentGame.PeekCard(0));
Card c = Game.CurrentGame.DrawCard();
move.Cards.Add(c);
remainingCards.Add(c);
}
move.To = new DeckPlace(Owner, DeckType.Hand);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
if (!Owner.AskForCardUsage(new CardUsagePrompt("MiJi"), new MiJiVerifier(), out skill, out cards, out players))
{
players = new List<Player>() { Owner };
}
Game.CurrentGame.InsertBeforeDeal(null, remainingCards, new MovementHelper() { IsFakedMove = true });
Game.CurrentGame.DrawCards(players[0], toDraw);
}
}
/// <summary>
/// 给某个玩家穿装备
/// </summary>
/// <param name="p"></param>
/// <param name="card"></param>
public void Install(Player p, Card card)
{
ParentCard = card;
CardsMovement attachMove = new CardsMovement();
attachMove.Cards = new List<Card>();
attachMove.Cards.Add(card);
attachMove.To = new DeckPlace(p, DeckType.Equipment);
foreach (Card c in Game.CurrentGame.Decks[p, DeckType.Equipment])
{
if (CardCategoryManager.IsCardCategory(c.Type.Category, this.Category))
{
Equipment e = (Equipment)c.Type;
Trace.Assert(e != null);
Game.CurrentGame.EnterAtomicContext();
Game.CurrentGame.PlayerLostCard(p, new List<Card>() { card });
Game.CurrentGame.HandleCardDiscard(p, new List<Card> () {c});
Game.CurrentGame.MoveCards(attachMove);
Game.CurrentGame.ExitAtomicContext();
return;
}
}
Game.CurrentGame.MoveCards(attachMove);
Game.CurrentGame.PlayerLostCard(p, new List<Card>() {card});
return;
}
public void OnJudgeBegin(Player player, GameEvent gameEvent, GameEventArgs eventArgs)
{
if (player.HandCards().Count == 0 && !player.Equipments().Any(card => card.SuitColor == SuitColorType.Black))
{
return;
}
ISkill skill;
List<Card> cards;
List<Player> players;
Card c = Game.CurrentGame.Decks[eventArgs.Source, DeckType.JudgeResult].Last();
if (Game.CurrentGame.UiProxies[player].AskForCardUsage(new CardUsagePrompt("GuiDao", eventArgs.Source, c.Suit, c.Rank), new GuiDaoVerifier(), out skill, out cards, out players))
{
NotifySkillUse();
Card theCard = cards[0];
theCard.Log = new ActionLog();
theCard.Log.Source = player;
theCard.Log.SkillAction = this;
theCard.Log.GameAction = GameAction.ReplaceJudge;
Game.CurrentGame.EnterAtomicContext();
List<Card> toDiscard = new List<Card>() {Game.CurrentGame.Decks[eventArgs.Source, DeckType.JudgeResult].Last()};
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
move.Cards.AddRange(cards);
move.To = new DeckPlace(eventArgs.Source, DeckType.JudgeResult);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerLostCard(player, cards);
Game.CurrentGame.HandleCardTransferToHand(null, player, toDiscard);
Game.CurrentGame.ExitAtomicContext();
}
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
Owner[FenXinUsed] = 1;
Player target = eventArgs.Targets[0];
Card role1 = Game.CurrentGame.Decks[Owner, RoleGame.RoleDeckType][0];
Card role2 = Game.CurrentGame.Decks[target, RoleGame.RoleDeckType][0];
Game.CurrentGame.SyncCard(target, ref role1);
Game.CurrentGame.SyncCard(Owner, ref role2);
List<CardsMovement> moves = new List<CardsMovement>();
CardsMovement move1 = new CardsMovement();
move1.Cards = new List<Card>() { role1 };
move1.To = new DeckPlace(target, RoleGame.RoleDeckType);
moves.Add(move1);
CardsMovement move2 = new CardsMovement();
move2.Cards = new List<Card>() { role2 };
move2.To = new DeckPlace(Owner, RoleGame.RoleDeckType);
moves.Add(move2);
Game.CurrentGame.MoveCards(moves);
var role = role2.Type as RoleCardHandler;
if (role != null)
{
Owner.Role = role.Role;
}
role = role1.Type as RoleCardHandler;
if (role != null)
{
target.Role = role.Role;
}
GameDelays.Delay(GameDelays.RoleDistribute);
}
public BuQu()
{
var trigger = new AutoNotifyPassiveSkillTrigger(
this,
(p, e, a) =>
{
if (p.Health > 0 && Game.CurrentGame.Decks[Owner, bq].Count > 0)
{
int toDraw = Game.CurrentGame.Decks[Owner, bq].Count;
while (toDraw-- > 0)
{
Card c1 = Game.CurrentGame.Decks[Owner, bq][Game.CurrentGame.Decks[Owner, bq].Count - 1];
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>() { c1 };
move.To = new DeckPlace(null, DeckType.Discard);
Game.CurrentGame.MoveCards(move);
}
}
return p.Health <= 0;
},
Run,
TriggerCondition.OwnerIsTarget
) { Type = TriggerType.Skill };
Triggers.Add(GameEvent.AfterHealthChanged, trigger);
ExtraCardsDeck = bq;
IsAutoInvoked = true;
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
ISkill skill;
List<Card> cards;
List<Player> players;
List<Card> originalCards = new List<Card>(Game.CurrentGame.Decks[Owner, QiXing.QiXingDeck]);
int qxCount = Game.CurrentGame.Decks[Owner, QiXing.QiXingDeck].Count;
// hack the cards to owner's hand. do not trigger anything
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(Game.CurrentGame.Decks[Owner, QiXing.QiXingDeck]);
move.To = new DeckPlace(Owner, DeckType.Hand);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
if (Game.CurrentGame.UiProxies[Owner].AskForCardUsage(new CardUsagePrompt("DaWu"), new DaWuVerifier(originalCards), out skill, out cards, out players))
{
NotifySkillUse(players);
foreach (var mark in players)
{
mark[DaWuMark] = 1;
}
dawuTargets = players;
foreach (Card cc in cards) originalCards.Remove(cc);
Game.CurrentGame.HandleCardDiscard(null, cards);
}
move.Cards = new List<Card>(originalCards);
move.To = new DeckPlace(Owner, QiXing.QiXingDeck);
Game.CurrentGame.MoveCards(move);
}
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);
}
/// <summary>
/// 给某个玩家穿装备
/// </summary>
/// <param name="p"></param>
/// <param name="card"></param>
public void Install(Player p, Card card, Player installedBy)
{
ParentCard = card;
CardsMovement attachMove = new CardsMovement();
attachMove.Cards = new List<Card>();
attachMove.Cards.Add(card);
attachMove.To = new DeckPlace(p, DeckType.Equipment);
foreach (Card c in Game.CurrentGame.Decks[p, DeckType.Equipment])
{
if (CardCategoryManager.IsCardCategory(c.Type.Category, this.Category))
{
Equipment e = (Equipment)c.Type;
Trace.Assert(e != null);
Game.CurrentGame.EnterAtomicContext();
if (installedBy != null) Game.CurrentGame.PlayerLostCard(installedBy, new List<Card>() { card });
if (installedBy != p) Game.CurrentGame.PlayerAcquiredCard(p, new List<Card>() { card });
c.Log.GameAction = GameAction.PlaceIntoDiscard;
c.Log.Source = p;
Game.CurrentGame.PlaceIntoDiscard(p, new List<Card>() { c });
Game.CurrentGame.MoveCards(attachMove);
Game.CurrentGame.ExitAtomicContext();
return;
}
}
Game.CurrentGame.MoveCards(attachMove);
if (installedBy != null) Game.CurrentGame.PlayerLostCard(installedBy, new List<Card>() { card });
if (installedBy != p) Game.CurrentGame.PlayerAcquiredCard(p, new List<Card>() { card });
return;
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType daXiangDeck = DeckType.Register("DaXiang");
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
for (int i = 0; i < 4; i++)
{
Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.PeekCard(0));
Card c = Game.CurrentGame.DrawCard();
move.Cards.Add(c);
}
move.To = new DeckPlace(null, daXiangDeck);
Game.CurrentGame.MoveCards(move);
List<List<Card>> answer;
if (Game.CurrentGame.UiProxies[Owner].AskForCardChoice(new CardChoicePrompt("ChengXiang", Owner),
new List<DeckPlace>() { new DeckPlace(null, daXiangDeck) },
new List<string>() { "AcquiredCards" },
new List<int>() { 4 },
new DaXiangVerifier(Game.CurrentGame.Decks[null, daXiangDeck]),
out answer,
null,
CardChoiceCallback.GenericCardChoiceCallback))
{
Game.CurrentGame.HandleCardTransferToHand(null, Owner, answer[0]);
}
foreach (var c in Game.CurrentGame.Decks[null, daXiangDeck])
{
c.Log.SkillAction = this;
c.Log.GameAction = GameAction.PlaceIntoDiscard;
}
Game.CurrentGame.PlaceIntoDiscard(null, new List<Card>(Game.CurrentGame.Decks[null, daXiangDeck]));
}
void Run(Player owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType FuHunDeck = new DeckType("FuHun");
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
int toDraw = 2;
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);
}
move.To = new DeckPlace(null, FuHunDeck);
var result = from c in move.Cards select c.SuitColor;
bool success = result.Distinct().Count() == toDraw;
if (success) FuHunEffect = 0;
else FuHunEffect = 1;
NotifySkillUse();
Game.CurrentGame.MoveCards(move, false, Core.Utils.GameDelayTypes.Draw);
Game.CurrentGame.HandleCardTransferToHand(null, owner, Game.CurrentGame.Decks[null, FuHunDeck]);
if (success)
{
Trigger tri = new RemoveShengPao(owner, fhWuSheng, fhPaoXiao);
Game.CurrentGame.PlayerAcquireAdditionalSkill(owner, fhWuSheng, HeroTag);
Game.CurrentGame.PlayerAcquireAdditionalSkill(owner, fhPaoXiao, HeroTag);
Game.CurrentGame.RegisterTrigger(GameEvent.PhasePostEnd, tri);
}
Game.CurrentGame.CurrentPhaseEventIndex++;
throw new TriggerResultException(TriggerResult.End);
}
void GetTheirCards(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
ISkill skill;
List<Card> cards;
List<Player> players;
if (Game.CurrentGame.UiProxies[Owner].AskForCardUsage(new CardUsagePrompt("TuXi2"), new TuXiVerifier(), out skill, out cards, out players))
{
Game.CurrentGame.SortByOrderOfComputation(Game.CurrentGame.CurrentPlayer, players);
NotifySkillUse(players);
var p = players[0];
List<List<Card>> answer;
if (!Game.CurrentGame.UiProxies[Owner].AskForCardChoice(new CardChoicePrompt("TuXi"), new List<DeckPlace>() { new DeckPlace(p, DeckType.Hand) },
new List<string>() { "TuXi" }, new List<int>() { 1 }, new RequireOneCardChoiceVerifier(true), out answer))
{
answer = new List<List<Card>>();
answer.Add(Game.CurrentGame.PickDefaultCardsFrom(new List<DeckPlace>() { new DeckPlace(p, DeckType.Hand) }));
}
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(answer[0]);
move.To = new DeckPlace(Owner, DeckType.Hand);
Game.CurrentGame.MoveCards(move);
Owner[Player.DealAdjustment]--;
}
}
protected override void GetJudgeCards(List<Card> list)
{
if (list[0].Suit == SuitType.Heart) return;
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(list);
move.To = new DeckPlace(Owner, TianDeck);
Game.CurrentGame.MoveCards(move);
}
public static void AcquireHeroCard(Player player)
{
Card card = Game.CurrentGame.Decks[DeckType.Heroes][0];
Game.CurrentGame.SyncImmutableCard(player, card);
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>() {card};
move.To = new DeckPlace(player, HuaShenDeck);
Game.CurrentGame.MoveCards(move);
}
protected void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType bq = new PrivateDeckType("BuQu", true);
if (1 - Owner.Health > Game.CurrentGame.Decks[Owner, bq].Count)
{
int toDraw = 1 - Owner.Health - Game.CurrentGame.Decks[Owner, bq].Count;
while (toDraw-- > 0)
{
Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.PeekCard(0));
Card c1 = Game.CurrentGame.DrawCard();
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>() { c1 };
move.To = new DeckPlace(Owner, bq);
Game.CurrentGame.MoveCards(move);
}
}
else if (1 + Math.Max(0, -Owner.Health) < Game.CurrentGame.Decks[Owner, bq].Count)
{
int toDraw = Game.CurrentGame.Decks[Owner, bq].Count - Math.Max(0, -Owner.Health) - 1;
while (toDraw-- > 0)
{
Card c1 = Game.CurrentGame.Decks[Owner, bq][Game.CurrentGame.Decks[Owner, bq].Count - 1];
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>() { c1 };
move.To = new DeckPlace(null, DeckType.Discard);
Game.CurrentGame.MoveCards(move);
}
}
if (Owner.Health > 0) return;
if (Owner.Health <= 0)
{
Dictionary<int, bool> death = new Dictionary<int, bool>();
foreach (Card c in Game.CurrentGame.Decks[Owner, bq])
{
if (death.ContainsKey(c.Rank))
{
return;
}
death.Add(c.Rank, true);
}
if (Game.CurrentGame.IsDying.Contains(Owner))
{
Stack<Player> backup = new Stack<Player>();
while (true)
{
var t = Game.CurrentGame.IsDying.Pop();
if (t == Owner) break;
backup.Push(t);
}
while (backup.Count > 0)
{
Game.CurrentGame.IsDying.Push(backup.Pop());
}
}
throw new TriggerResultException(TriggerResult.End);
}
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
var args = eventArgs as DiscardCardEventArgs;
if (Game.CurrentGame.CurrentPlayer == Owner || args.Source == null || args.Source == Owner || (args.Reason != DiscardReason.Discard))
{
return;
}
var cardsToProcess = new List<Card>(
from c in eventArgs.Cards
where c.Type.BaseCategory() == CardCategory.Equipment && (c.Place.DeckType == DeckType.Hand || c.Place.DeckType == DeckType.Equipment)
select c);
if (cardsToProcess.Count() > 0)
{
CardsMovement temp = new CardsMovement();
temp.Cards = new List<Card>(cardsToProcess);
temp.To = new DeckPlace(null, DeckType.Discard);
foreach (Card cc in cardsToProcess)
{
cc.PlaceOverride = new DeckPlace(null, DeckType.Discard);
}
Game.CurrentGame.NotificationProxy.NotifyCardMovement(new List<CardsMovement>() { temp });
}
else return;
List<OptionPrompt> prompts = new List<OptionPrompt>();
if (cardsToProcess.Count > 1)
{
prompts.Add(OptionPrompt.NoChoice);
prompts.Add(new OptionPrompt("YinLiQuanBu"));
prompts.Add(new OptionPrompt("YinLiBuFen"));
}
else prompts.AddRange(OptionPrompt.YesNoChoices);
int choiceIndex = 0;
Owner.AskForMultipleChoice(new MultipleChoicePrompt(Prompt.SkillUseYewNoPrompt, this), prompts, out choiceIndex);
if (choiceIndex == 0) return;
if (choiceIndex == 1) NotifySkillUse();
foreach (var c in cardsToProcess)
{
var prompt = new MultipleChoicePrompt("YinLi", c);
int answer = 0;
if (choiceIndex == 1 || Owner.AskForMultipleChoice(prompt, Prompt.YesNoChoices, out answer) && answer == 1)
{
if (choiceIndex == 2) NotifySkillUse();
c.Log = new ActionLog();
c.Log.SkillAction = this;
CardsMovement temp = new CardsMovement();
temp.Cards.Add(c);
temp.To = new DeckPlace(null, YinLiDeck);
c.PlaceOverride = new DeckPlace(null, DeckType.Discard);
Game.CurrentGame.NotificationProxy.NotifyCardMovement(new List<CardsMovement>() { temp });
c.Log = new ActionLog();
Game.CurrentGame.HandleCardTransferToHand(c.Owner, Owner, new List<Card>() { c }, new MovementHelper() { IsFakedMove = true, AlwaysShowLog = true });
eventArgs.Cards.Remove(c);
}
}
}
public override bool Commit(GameEventArgs arg)
{
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(arg.Cards);
move.To = new DeckPlace(arg.Targets[0], DeckType.Equipment);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerLostCard(Owner, arg.Cards);
Game.CurrentGame.PlayerAcquiredCard(arg.Targets[0], arg.Cards);
Game.CurrentGame.DrawCards(Owner, 1);
return true;
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs, List<Card> cards, List<Player> players)
{
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(players[0], BiFaDeck);
move.Helper = new MovementHelper();
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerLostCard(Owner, cards);
Game.CurrentGame.RegisterTrigger(GameEvent.PhaseBeginEvents[TurnPhase.Start], new BiFaTrigger(players[0]));
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
if (Game.CurrentGame.Decks[player, JiJiDeck].Count > 0)
{
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(Game.CurrentGame.Decks[player, JiJiDeck]);
move.To = new DeckPlace(player, DeckType.Equipment);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.UnregisterTrigger(GameEvent.HeroDebut, this);
}
}
public void ReplaceJudgementCard(Player player, Player judgePlayer, Card card)
{
Game.CurrentGame.EnterAtomicContext();
List<Card> toDiscard = new List<Card>(Game.CurrentGame.Decks[judgePlayer, DeckType.JudgeResult]);
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>() {card};
move.To = new DeckPlace(judgePlayer, DeckType.JudgeResult);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerLostCard(player, new List<Card>() {card});
Game.CurrentGame.HandleCardDiscard(judgePlayer, toDiscard, DiscardReason.Judge);
Game.CurrentGame.ExitAtomicContext();
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
if (gameEvent == GameEvent.PlayerSkillSetChanged)
{
SkillSetChangedEventArgs args = eventArgs as SkillSetChangedEventArgs;
Trace.Assert(args != null);
if (!args.IsLosingSkill) return;
foreach (var sk in args.Skills)
{
if (deckCleanup.ContainsKey(sk))
{
foreach (var deck in deckCleanup[sk])
{
if (Game.CurrentGame.Decks[args.Source, deck].Count > 0)
{
List<Card> toDiscard = new List<Card>(Game.CurrentGame.Decks[args.Source, deck]);
if (toDiscard.Any(c => c.Type.IsCardCategory(CardCategory.Hero)))
{
//HuaShenDeck
if (Game.CurrentGame.IsClient)
{
foreach (var hc in toDiscard)
{
hc.Id = Card.UnknownHeroId;
hc.Type = new UnknownHeroCardHandler();
}
}
CardsMovement move = new CardsMovement();
move.Cards = toDiscard;
move.To = new DeckPlace(null, DeckType.Heroes);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
}
else
{
Game.CurrentGame.HandleCardDiscard(args.Source, toDiscard);
}
}
}
}
if (markCleanup.ContainsKey(sk))
{
foreach (var player in Game.CurrentGame.Players)
{
foreach (var mark in markCleanup[sk])
{
player[mark] = 0;
}
}
}
}
}
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
var GuZhengDeck = new DeckType("GuZheng");
foreach (Card c in new List<Card>(GuZhengCards))
{
if (c.Place.DeckType != DeckType.Discard)
{
GuZhengCards.Remove(c);
}
}
CardsMovement move = new CardsMovement();
move.Cards = GuZhengCards;
move.To = new DeckPlace(null, GuZhengDeck);
Game.CurrentGame.MoveCards(move);
List<List<Card>> answer;
var options = new AdditionalCardChoiceOptions() { Options = new List<string>() { Prompt.MultipleChoiceOptionPrefix + "GuZhengHuoDe", Prompt.MultipleChoiceOptionPrefix + "GuZhengBuHuoDe" } };
if (!Game.CurrentGame.UiProxies[Owner].AskForCardChoice(
new CardChoicePrompt("GuZheng"),
new List<DeckPlace>() { new DeckPlace(null, GuZhengDeck) },
new List<string>() { "GuZhengFanHui" },
new List<int>() { 1 },
new RequireOneCardChoiceVerifier(),
out answer,
options))
{
Trace.TraceInformation("Invalid answer, choosing for you");
answer = new List<List<Card>>();
answer.Add(new List<Card>());
answer[0].Add(Game.CurrentGame.Decks[null, GuZhengDeck][0]);
}
move = new CardsMovement();
move.Cards = new List<Card>(answer[0]);
move.To = new DeckPlace(Game.CurrentGame.CurrentPlayer, DeckType.Hand);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerAcquiredCard(Game.CurrentGame.CurrentPlayer, answer[0]);
if (options.OptionResult == 1)
{
Game.CurrentGame.PlaceIntoDiscard(null, new List<Card>(Game.CurrentGame.Decks[null, GuZhengDeck]));
}
else
{
var cardsToAcquire = new List<Card>(Game.CurrentGame.Decks[null, GuZhengDeck]);
move = new CardsMovement();
move.Cards = new List<Card>(cardsToAcquire);
move.To = new DeckPlace(Owner, DeckType.Hand);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerAcquiredCard(Owner, cardsToAcquire);
}
GuZhengCards = new List<Card>();
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType mjDeck = DeckType.Register("ManJuan");
List<Card> theCards = new List<Card>(eventArgs.Cards);
CardsMovement move = new CardsMovement();
move.Cards = eventArgs.Cards;
move.To = new DeckPlace(null, DeckType.Discard);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
if (Game.CurrentGame.CurrentPlayer == Owner)
{
foreach (var reclaim in theCards)
{
List<Card> garbageList = new List<Card>();
foreach (var garbage in Game.CurrentGame.Decks[null, DeckType.Discard])
{
if (garbage.Rank == reclaim.Rank)
{
garbageList.Add(garbage);
}
}
move = new CardsMovement();
move.Cards = garbageList;
move.To = new DeckPlace(null, mjDeck);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
IPlayerProxy ui = Game.CurrentGame.UiProxies[Owner];
List<List<Card>> answer;
if (!ui.AskForCardChoice(new CardChoicePrompt("ManJuan", Owner), new List<DeckPlace>() {new DeckPlace(null, mjDeck)}, new List<string>() {"ZuiXiang"}, new List<int>() {1}, new RequireOneCardChoiceVerifier(), out answer))
{
Trace.TraceInformation("Player {0} Invalid answer", Owner);
answer = new List<List<Card>>();
answer.Add(new List<Card>());
answer[0].Add(Game.CurrentGame.Decks[null, mjDeck][0]);
}
Trace.Assert(answer.Count == 1 && answer[0].Count == 1);
move = new CardsMovement();
move.Cards = new List<Card>(answer[0]);
move.To = new DeckPlace(Owner, DeckType.Hand);
Game.CurrentGame.MoveCards(move);
move = new CardsMovement();
move.Cards = new List<Card>(Game.CurrentGame.Decks[null, mjDeck]);
move.To = new DeckPlace(null, DeckType.Discard);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
}
}
}
