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);
}
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);
}
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType HuoShouDeck = new DeckType("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)
{
Owner[FenXinUsed] = 1;
Player target = eventArgs.Targets[0];
DeckType RoleDeck = new DeckType("Role");
Card role1 = Game.CurrentGame.Decks[Owner, RoleDeck][0];
Card role2 = Game.CurrentGame.Decks[target, RoleDeck][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, RoleDeck);
moves.Add(move1);
CardsMovement move2 = new CardsMovement();
move2.Cards = new List<Card>() { role2 };
move2.To = new DeckPlace(Owner, RoleDeck);
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(GameDelayTypes.RoleDistribute);
}
public List<Card> this[Player player, DeckType type]
{
get
{
if (player == null)
{
player = GameAsPlayer.Instance;
}
if (!gameDecks.ContainsKey(player))
{
gameDecks[player] = new Dictionary<DeckType, List<Card>>();
}
if (!gameDecks[player].ContainsKey(type))
{
gameDecks[player][type] = new List<Card>();
}
return gameDecks[player][type];
}
set
{
if (player == null)
{
player = GameAsPlayer.Instance;
}
if (!gameDecks.ContainsKey(player))
{
gameDecks[player] = new Dictionary<DeckType, List<Card>>();
}
if (!gameDecks[player].ContainsKey(type))
{
gameDecks[player][type] = value;
}
}
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
{
DeckType wuguDeck = new DeckType("WuGu");
DeckType wuguFakeDeck = new DeckType("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 });
}
public void AddCards(DeckType deck, IList<CardView> cards, bool isFaked, bool updateFootnote)
{
if (isFaked)
{
foreach (var card in cards)
{
card.Disappear(0d);
}
return;
}
if (cards.Count == 0) return;
int numAdded = cards.Count;
int numRemoved = Cards.Count - Math.Max(_MaxVisibleCards, numAdded + 1);
DeckType from = cards[0].Card.Place.DeckType;
Canvas canvas = cards[0].Parent as Canvas;
// canvas can only be null on reconnection.
// @todo: Probably fix canvas on its source rather than here.
if (canvas == null) return;
if (updateFootnote)
{
foreach (var card in cards)
{
card.CardModel.UpdateFootnote();
}
}
// Do not show cards that move from compute area to discard area
// or from judge result area to discard aresa
if (from != DeckType.Compute && (from != DeckType.JudgeResult || from == DeckType.JudgeResult && deck != DeckType.Discard) && from != DeckType.Dealing)
{
AddCards(cards);
// Card just entered compute area should hold until they enter discard area.
}
else if (from == DeckType.Dealing && deck == DeckType.JudgeResult)
{
foreach (var card in Cards) MarkClearance(card);
AppendCards(cards);
}
else
{
foreach (var card in cards)
{
canvas.Children.Remove(card);
}
}
// When a card enters discard area, every thing in the deck should fade out (but
// not disappear).
// When there are too many cards in the deck, remove the dated ones.
for (int i = 0; i < numRemoved; i++)
{
MarkClearance(Cards[i]);
}
}
public void AddCards(DeckType deck, IList<CardView> cards, bool isFaked)
{
if (isFaked)
{
foreach (var card in cards)
{
card.Disappear(0d);
}
return;
}
if (cards.Count == 0) return;
int numAdded = cards.Count;
int numRemoved = Cards.Count - Math.Max(_MaxVisibleCards, numAdded + 1);
DeckType from = cards[0].Card.Place.DeckType;
Canvas canvas = cards[0].Parent as Canvas;
Trace.Assert(canvas != null);
foreach (var card in cards)
{
card.CardModel.UpdateFootnote();
card.CardModel.IsFootnoteVisible = true;
}
// Do not show cards that move from compute area to discard area
// or from judge result area to discard aresa
if (from != DeckType.Compute && from != DeckType.JudgeResult && from != DeckType.Dealing)
{
AddCards(cards, 0.3d);
}
else if (from == DeckType.Dealing && deck == DeckType.JudgeResult)
{
foreach (var card in Cards) MarkClearance(card);
AppendCards(cards);
}
else
{
foreach (var card in cards)
{
canvas.Children.Remove(card);
}
}
// Card just entered compute area should hold until they enter discard area.
foreach (var card in cards)
{
card.DiscardDeckClearTimeStamp = int.MaxValue;
}
// When a card enters discard area, every thing in the deck should fade out (but
// not disappear).
// When there are too many cards in the deck, remove the dated ones.
for (int i = 0; i < numRemoved; i++)
{
MarkClearance(Cards[i]);
}
}
static DeckType()
{
Dealing = new DeckType("Dealing");
Discard = new DeckType("Discard");
Compute = new DeckType("Compute");
Hand = new DeckType("Hand");
Equipment = new DeckType("Equipment");
DelayedTools = new DeckType("DelayedTools");
JudgeResult = new DeckType("JudgeResult");
GuHuo = new DeckType("GuHuo");
None = new DeckType("None");
Heroes = new DeckType("Heroes");
}
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 = new DeckType("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);
IUiProxy 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);
}
}
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType shelieDeck = new DeckType("SheLie");
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
for (int i = 0; i < 5; i++)
{
Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.PeekCard(0));
Card c = Game.CurrentGame.DrawCard();
move.Cards.Add(c);
}
move.To = new DeckPlace(null, shelieDeck);
Game.CurrentGame.MoveCards(move);
List<List<Card>> answer;
if (!Game.CurrentGame.UiProxies[Owner].AskForCardChoice(new CardChoicePrompt("SheLie", Owner),
new List<DeckPlace>() { new DeckPlace(null, shelieDeck) },
new List<string>() { "SheLie" },
new List<int>() { 4 },
new SheLieVerifier(Game.CurrentGame.Decks[null, shelieDeck]),
out answer,
null,
CardChoiceCallback.GenericCardChoiceCallback))
{
Trace.TraceInformation("Invalid answer for SheLie, choosing for you");
answer = new List<List<Card>>();
answer.Add(new List<Card>());
HashSet<SuitType> choice = new HashSet<SuitType>();
foreach (Card c in Game.CurrentGame.Decks[null, shelieDeck])
{
if (!choice.Contains(c.Suit))
{
answer[0].Add(c);
choice.Add(c.Suit);
}
}
}
Game.CurrentGame.HandleCardTransferToHand(null, Owner, answer[0]);
foreach (var c in Game.CurrentGame.Decks[null, shelieDeck])
{
c.Log.SkillAction = this;
c.Log.GameAction = GameAction.PlaceIntoDiscard;
}
Game.CurrentGame.PlaceIntoDiscard(null, new List<Card>(Game.CurrentGame.Decks[null, shelieDeck]));
Game.CurrentGame.CurrentPhaseEventIndex++;
throw new TriggerResultException(TriggerResult.End);
}
public override void Process(GameEventArgs handlerArgs)
{
base.Process(handlerArgs);
DeckType wuguDeck = new DeckType("WuGu");
DeckType wuguFakeDeck = new DeckType("WuGuFake");
CardsMovement move = new CardsMovement();
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, false, Core.Utils.GameDelayTypes.Draw);
}
}
public override bool Commit(GameEventArgs arg)
{
Owner[DiMengUsed] = 1;
List<Card> cards = arg.Cards;
if (cards.Count > 0)
{
Game.CurrentGame.HandleCardDiscard(Owner, cards);
}
Player src1 = arg.Targets[0];
Player src2 = arg.Targets[1];
DeckType DiMengDeck1 = new DeckType("DiMeng1");
DeckType DiMengDeck2 = new DeckType("DiMeng2");
Game.CurrentGame.EnterAtomicContext();
CardsMovement move = new CardsMovement();
cards = new List<Card>(Game.CurrentGame.Decks[src1, DeckType.Hand]);
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(null, DiMengDeck1);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerLostCard(src1, cards);
cards = new List<Card>(Game.CurrentGame.Decks[src2, DeckType.Hand]);
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(null, DiMengDeck2);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerLostCard(src2, cards);
Game.CurrentGame.ExitAtomicContext();
Game.CurrentGame.SyncImmutableCards(src1, Game.CurrentGame.Decks[null, DiMengDeck2]);
Game.CurrentGame.EnterAtomicContext();
cards = new List<Card>(Game.CurrentGame.Decks[null, DiMengDeck2]);
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(src1, DeckType.Hand);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerAcquiredCard(src1, cards);
Game.CurrentGame.SyncImmutableCards(src2, Game.CurrentGame.Decks[null, DiMengDeck1]);
cards = new List<Card>(Game.CurrentGame.Decks[null, DiMengDeck1]);
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(src2, DeckType.Hand);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerAcquiredCard(src2, cards);
Game.CurrentGame.ExitAtomicContext();
return true;
}
protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard)
{
DeckType wuguDeck = new DeckType("WuGu");
List<List<Card>> answer;
if (!Game.CurrentGame.UiProxies[dest].AskForCardChoice(new CardChoicePrompt("WuGuFengDeng"),
new List<DeckPlace>() { new DeckPlace(null, wuguDeck) },
new List<string>() { "WuGu" },
new List<int>() { 1 },
new RequireOneCardChoiceVerifier(),
out answer))
{
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]);
}
Game.CurrentGame.HandleCardTransferToHand(null, dest, answer[0]);
}
public override bool Commit(GameEventArgs arg)
{
GameDelays.Delay(GameDelayTypes.Awaken);
Owner[XinZhanUsed] = 1;
DeckType XinZhanDeck = new DeckType("XinZhan");
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
for (int i = 0; i < choiceCount; i++)
{
Game.CurrentGame.SyncImmutableCard(Owner, Game.CurrentGame.PeekCard(0));
Card c = Game.CurrentGame.DrawCard();
move.Cards.Add(c);
}
move.To = new DeckPlace(null, XinZhanDeck);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move);
List<List<Card>> answer;
AdditionalCardChoiceOptions options = new AdditionalCardChoiceOptions();
options.Rearrangeable = new List<bool>() { true, false };
options.DefaultResult = new List<List<Card>>() { new List<Card>(Game.CurrentGame.Decks[null, XinZhanDeck]), new List<Card>() };
if (!Game.CurrentGame.UiProxies[Owner].AskForCardChoice(new CardChoicePrompt("XinZhan", Owner),
new List<DeckPlace>() {},
new List<string>() { "PaiDuiDing", "HuoDe" },
new List<int>() {choiceCount, choiceCount},
new XinZhanVerifier(),
out answer,
options,
CardChoiceCallback.GenericCardChoiceCallback))
{
Game.CurrentGame.NotificationProxy.NotifyLogEvent(new Prompt(Prompt.LogEventPrefix + "XinZhan", Owner, Game.CurrentGame.Decks[null, XinZhanDeck].Count));
Game.CurrentGame.InsertBeforeDeal(null, Game.CurrentGame.Decks[null, XinZhanDeck], new MovementHelper() { IsFakedMove = true });
}
else
{
Game.CurrentGame.NotificationProxy.NotifyLogEvent(new Prompt(Prompt.LogEventPrefix + "XinZhan", Owner, answer[0].Count));
Game.CurrentGame.InsertBeforeDeal(null, answer[0], new MovementHelper() { IsFakedMove = true });
Game.CurrentGame.HandleCardTransferToHand(null, Owner, answer[1]);
}
return true;
}
public override void Process(GameEventArgs handlerArgs)
{
var source = handlerArgs.Source;
var dests = handlerArgs.Targets;
var readonlyCard = handlerArgs.ReadonlyCard;
var inResponseTo = handlerArgs.InResponseTo;
var card = handlerArgs.Card;
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 CardChoicePrompt("WuGuFengDeng.Init"), new DeckPlace(null, wuguFakeDeck));
base.Process(handlerArgs);
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 Process(Player source, List<Player> dests, ICard card, ReadOnlyCard readonlyCard)
{
DeckType wuguDeck = new DeckType("WuGu");
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);
base.Process(source, dests, card, readonlyCard);
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);
}
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType GuanXingDeck = new DeckType("GuanXing");
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
int toDraw = Math.Min(5, Game.CurrentGame.AlivePlayers.Count);
for (int i = 0; i < toDraw; i++)
{
Game.CurrentGame.SyncImmutableCard(Owner, Game.CurrentGame.PeekCard(0));
Card c = Game.CurrentGame.DrawCard();
move.Cards.Add(c);
}
move.To = new DeckPlace(null, GuanXingDeck);
move.Helper.IsFakedMove = true;
Game.CurrentGame.MoveCards(move, false, Core.Utils.GameDelayTypes.None);
List<List<Card>> answer;
AdditionalCardChoiceOptions options = new AdditionalCardChoiceOptions();
options.Rearrangeable = new List<bool>() { true, true };
options.DefaultResult = new List<List<Card>>() { new List<Card>(Game.CurrentGame.Decks[null, GuanXingDeck]), new List<Card>() };
if (!Game.CurrentGame.UiProxies[Owner].AskForCardChoice(new CardChoicePrompt("GuanXing"),
new List<DeckPlace>() { },
new List<string>() { "PaiDuiDing", "PaiDuiDi" },
new List<int>() { toDraw, toDraw },
new GuanXingVerifier(Game.CurrentGame.Decks[null, GuanXingDeck]),
out answer,
options,
CardChoiceCallback.GenericCardChoiceCallback))
{
Game.CurrentGame.NotificationProxy.NotifyLogEvent(new LogEvent("GuanXing", Owner, Game.CurrentGame.Decks[null, GuanXingDeck].Count, 0), new List<Player>() { Owner }, false);
Game.CurrentGame.InsertBeforeDeal(null, Game.CurrentGame.Decks[null, GuanXingDeck], new MovementHelper() { IsFakedMove = true });
}
else
{
Game.CurrentGame.NotificationProxy.NotifyLogEvent(new LogEvent("GuanXing", Owner, answer[0].Count, answer[1].Count), new List<Player>() { Owner }, false);
Game.CurrentGame.InsertBeforeDeal(null, answer[0], new MovementHelper() { IsFakedMove = true });
Game.CurrentGame.InsertAfterDeal(null, answer[1], new MovementHelper() { IsFakedMove = true });
}
}
public override bool Commit(GameEventArgs arg)
{
Owner[GanLuUsed] = 1;
List<Card> cards;
Player src1 = arg.Targets[0];
Player src2 = arg.Targets[1];
DeckType GanLuDeck1 = new DeckType("GanLu1");
DeckType GanLuDeck2 = new DeckType("GanLu2");
Game.CurrentGame.EnterAtomicContext();
CardsMovement move = new CardsMovement();
cards = new List<Card>(src1.Equipments());
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(null, GanLuDeck1);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerLostCard(src1, cards);
cards = new List<Card>(src2.Equipments());
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(null, GanLuDeck2);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerLostCard(src2, cards);
Game.CurrentGame.ExitAtomicContext();
Game.CurrentGame.EnterAtomicContext();
cards = new List<Card>(Game.CurrentGame.Decks[null, GanLuDeck2]);
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(src1, DeckType.Equipment);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerAcquiredCard(src1, cards);
cards = new List<Card>(Game.CurrentGame.Decks[null, GanLuDeck1]);
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(src2, DeckType.Equipment);
Game.CurrentGame.MoveCards(move);
Game.CurrentGame.PlayerAcquiredCard(src2, cards);
Game.CurrentGame.ExitAtomicContext();
return true;
}
public List<Card> this[DeckType type]
{
get { return this[null, type]; }
set { this[null, type] = value; }
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
Player p = eventArgs.Targets[0];
Player source = eventArgs.Source;
if (source == null)
{
Trace.TraceInformation("Player {0} killed", p.Id);
}
else
{
Trace.TraceInformation("Player {0} killed by Player {1}", p.Id, source.Id);
}
DeckType role = new DeckType("Role");
Trace.Assert(Game.CurrentGame.Decks[p, role].Count == 1);
Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.Decks[p, role][0]);
Trace.TraceInformation("Player {0} is {1}", p.Id, (Game.CurrentGame.Decks[p, role][0].Type as RoleCardHandler).Role);
p.Role = (Game.CurrentGame.Decks[p, role][0].Type as RoleCardHandler).Role;
Game.CurrentGame.NotificationProxy.NotifyDeath(p, source);
if (p.Role == Role.Ruler)
{
Trace.TraceInformation("Ruler dead. Game over");
if (Game.CurrentGame.AlivePlayers.Count == 2)
{
var winners = from pl in Game.CurrentGame.Players where pl.Role == Role.Defector select pl;
Game.CurrentGame.NotificationProxy.NotifyGameOver(false, winners.ToList());
}
else
{
var winners = from pl in Game.CurrentGame.Players where pl.Role == Role.Rebel select pl;
Game.CurrentGame.NotificationProxy.NotifyGameOver(false, winners.ToList());
}
throw new GameOverException();
}
if (p.Role == Role.Rebel || p.Role == Role.Defector)
{
int deadRebel = 0;
int deadDefector = 0;
foreach (Player z in Game.CurrentGame.Players)
{
if (z.Role == Role.Rebel && (z.IsDead || z == p))
{
deadRebel++;
}
if (z.Role == Role.Defector && (z.IsDead || z == p))
{
deadDefector++;
}
}
Trace.TraceInformation("Deathtoll: Rebel {0}/{1}, Defector {2}/{3}", deadRebel, (Game.CurrentGame as RoleGame).NumberOfRebels, deadDefector, (Game.CurrentGame as RoleGame).NumberOfDefectors);
if (deadRebel == (Game.CurrentGame as RoleGame).NumberOfRebels && deadDefector == (Game.CurrentGame as RoleGame).NumberOfDefectors)
{
Trace.TraceInformation("Ruler wins.");
var winners = from pl in Game.CurrentGame.Players where pl.Role == Role.Ruler || pl.Role == Role.Loyalist select pl;
Game.CurrentGame.NotificationProxy.NotifyGameOver(false, winners.ToList());
throw new GameOverException();
}
}
Game.CurrentGame.Emit(GameEvent.PlayerIsDead, eventArgs);
p.IsDead = true;
if (p.Hero != null)
{
foreach (ISkill s in p.Hero.Skills)
{
if (s is TriggerSkill)
{
(s as TriggerSkill).Owner = null;
}
}
}
if (p.Hero2 != null)
{
foreach (ISkill s in p.Hero2.Skills)
{
if (s is TriggerSkill)
{
(s as TriggerSkill).Owner = null;
}
}
}
if (p.Role == Role.Rebel || p.Role == Role.Defector)
{
if (source != null && !source.IsDead && p.Role == Role.Rebel)
{
Trace.TraceInformation("Killed rebel. GIVING YOU THREE CARDS OMG WIN GAME RIGHT THERE!!!");
Game.CurrentGame.DrawCards(source, 3);
}
}
if (p.Role == Role.Loyalist && source.Role == Role.Ruler)
{
Trace.TraceInformation("Loyalist killl by ruler. GG");
Game.CurrentGame.SyncCardsAll(Game.CurrentGame.Decks[source, DeckType.Hand]);
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>();
foreach (Card c in Game.CurrentGame.Decks[source, DeckType.Hand])
{
if (Game.CurrentGame.PlayerCanDiscardCard(source, c))
{
move.Cards.Add(c);
}
}
move.Cards.AddRange(Game.CurrentGame.Decks[source, DeckType.Equipment]);
move.Cards.AddRange(Game.CurrentGame.Decks[source, DeckType.DelayedTools]);
move.To = new DeckPlace(null, DeckType.Discard);
move.Helper = new MovementHelper();
Game.CurrentGame.MoveCards(move);
}
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
Game game = Game.CurrentGame;
foreach (Player pp in game.Players)
{
game.HandCardVisibility.Add(pp, new List<Player>() { pp });
}
int numberOfDefectors = 1;
// Put the whole deck in the dealing deck
game.Decks[DeckType.Dealing] = game.CardSet.GetRange(0, game.CardSet.Count);
var dealdeck = new List<Card>(game.Decks[DeckType.Dealing]);
foreach (Card card in dealdeck)
{
// We don't want hero cards
if (card.Type is HeroCardHandler)
{
game.Decks[DeckType.Dealing].Remove(card);
game.Decks[DeckType.Heroes].Add(card);
card.Place = new DeckPlace(null, DeckType.Heroes);
}
else if (card.Type is RoleCardHandler)
{
game.Decks[DeckType.Dealing].Remove(card);
card.Place = new DeckPlace(null, RoleDeckType);
}
else
{
card.Place = new DeckPlace(null, DeckType.Dealing);
}
}
if (game.Players.Count == 0)
{
return;
}
// Await role decision
int seed = DateTime.Now.Millisecond;
Trace.TraceError("Seed is {0}", seed);
Random random = new Random(seed);
int rulerId = 0;
game.Decks[null, RoleDeckType].Add(_FindARoleCard(Role.Ruler));
Trace.Assert(game.Players.Count > 1);
Trace.Assert(numberOfDefectors + 1 <= game.Players.Count);
int t = numberOfDefectors;
while (t-- > 0)
{
game.Decks[null, RoleDeckType].Add(_FindARoleCard(Role.Defector));
}
int remaining = game.Players.Count - numberOfDefectors;
int rebel;
int loyalist;
if (remaining <= 1)
{
rebel = 0;
loyalist = 0;
}
else
{
rebel = (int)Math.Ceiling(((double)remaining) / 2);
loyalist = remaining - rebel - 1;
}
Trace.Assert(rebel + loyalist + numberOfDefectors + 1 == game.Players.Count);
(game as RoleGame).NumberOfDefectors = numberOfDefectors;
(game as RoleGame).NumberOfRebels = rebel;
while (rebel-- > 0)
{
game.Decks[null, RoleDeckType].Add(_FindARoleCard(Role.Rebel));
}
while (loyalist-- > 0)
{
game.Decks[null, RoleDeckType].Add(_FindARoleCard(Role.Loyalist));
}
Shuffle(game.Decks[null, RoleDeckType]);
if (game.IsClient)
{
int count = game.Decks[null, RoleDeckType].Count;
game.Decks[null, RoleDeckType].Clear();
while (count-- > 0)
{
Card c = new Card(SuitType.None, 0, new UnknownRoleCardHandler());
c.Id = Card.UnknownRoleId;
c.Place = new DeckPlace(null, RoleDeckType);
game.Decks[null, RoleDeckType].Add(c);
}
game.SyncImmutableCardAll(game.Decks[null, RoleDeckType][0]);
}
else
{
foreach (Card c in game.Decks[null, RoleDeckType])
{
if ((c.Type as RoleCardHandler).Role == Role.Ruler)
{
game.SyncImmutableCardAll(c);
}
}
}
int i = 0;
for (i = 0; i < game.Players.Count; i++)
{
game.SyncImmutableCard(game.Players[i], game.Decks[null, RoleDeckType][i]);
}
List<CardsMovement> moves = new List<CardsMovement>();
i = 0;
foreach (Player p in game.Players)
{
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>() { game.Decks[null, RoleDeckType][i] };
move.To = new DeckPlace(p, RoleDeckType);
moves.Add(move);
i++;
}
game.MoveCards(moves, null);
Thread.Sleep(1200);
i = 0;
foreach (Player player in game.Players)
{
Card card = game.Decks[player, RoleDeckType][0];
var role = card.Type as RoleCardHandler;
if (role != null)
{
if (role.Role == Role.Ruler)
{
rulerId = i;
}
player.Role = role.Role;
}
i++;
}
Thread.Sleep(400);
//hero allocation
Shuffle(game.Decks[DeckType.Heroes]);
if (!game.IsClient)
{
foreach (var hero in new List<Card>(game.Decks[DeckType.Heroes]))
{
foreach (var s in (hero.Type as HeroCardHandler).Hero.Skills)
{
if (s.IsRulerOnly)
{
game.Decks[DeckType.Heroes].Remove(hero);
game.Decks[DeckType.Heroes].Insert(0, hero);
}
}
}
}
List<Card> rulerDraw = new List<Card>();
for (int rc = 0; rc < 12; rc++)
{
game.SyncImmutableCardAll(game.Decks[DeckType.Heroes][rc]);
rulerDraw.Add(game.Decks[DeckType.Heroes][rc]);
}
game.SyncCards(game.Players[rulerId], rulerDraw);
DeckType tempHero = new DeckType("TempHero");
game.Decks[null, tempHero].AddRange(rulerDraw);
Trace.TraceInformation("Ruler is {0}", rulerId);
game.Players[rulerId].Role = Role.Ruler;
List<DeckPlace> sourceDecks = new List<DeckPlace>();
sourceDecks.Add(new DeckPlace(null, tempHero));
List<string> resultDeckNames = new List<string>();
resultDeckNames.Add("HeroChoice");
List<int> resultDeckMaximums = new List<int>();
resultDeckMaximums.Add(1);
List<List<Card>> answer;
if (!game.UiProxies[game.Players[rulerId]].AskForCardChoice(new CardChoicePrompt("RulerHeroChoice"), sourceDecks, resultDeckNames, resultDeckMaximums, new AlwaysTrueChoiceVerifier(), out answer))
{
answer = new List<List<Card>>();
answer.Add(new List<Card>());
answer[0].Add(game.Decks[DeckType.Heroes][0]);
}
game.SyncImmutableCardAll(answer[0][0]);
game.Decks[DeckType.Heroes].Remove(answer[0][0]);
HeroCardHandler h = (HeroCardHandler)answer[0][0].Type;
Trace.TraceInformation("Assign {0} to player {1}", h.Hero.Name, rulerId);
Game.CurrentGame.Players[rulerId].Hero = h.Hero;
Game.CurrentGame.Players[rulerId].Allegiance = h.Hero.Allegiance;
Game.CurrentGame.Players[rulerId].MaxHealth = Game.CurrentGame.Players[rulerId].Health = ((game.Players.Count > 4) ? h.Hero.MaxHealth + 1 : h.Hero.MaxHealth);
Game.CurrentGame.Players[rulerId].IsMale = h.Hero.IsMale ? true : false;
Game.CurrentGame.Players[rulerId].IsFemale = h.Hero.IsMale ? false : true;
Shuffle(game.Decks[DeckType.Heroes]);
Dictionary<Player, List<Card>> restDraw = new Dictionary<Player, List<Card>>();
List<Player> players = new List<Player>(game.Players);
players.Remove(game.Players[rulerId]);
int idx = 0;
foreach (Player p in players)
{
restDraw.Add(p, new List<Card>());
for (int n = 0; n < 3; n++)
{
game.SyncImmutableCard(p, game.Decks[DeckType.Heroes][idx]);
restDraw[p].Add(game.Decks[DeckType.Heroes][idx]);
idx++;
}
}
var heroSelection = new Dictionary<Player, Card>();
game.GlobalProxy.AskForHeroChoice(restDraw, heroSelection);
bool notUsed = true;
game.SyncConfirmationStatus(ref notUsed);
List<Card> toRemove = new List<Card>();
foreach (Player p in players)
{
Card c;
//only server has the result
if (!game.IsClient)
{
idx = 0;
if (heroSelection.ContainsKey(p))
{
c = heroSelection[p];
idx = restDraw[p].IndexOf(c);
}
else
{
c = restDraw[p][0];
}
foreach (Player player in game.Players)
{
game.GameServer.SendObject(player.Id, idx);
}
}
// you are client
else
{
idx = (int)game.GameClient.Receive();
c = restDraw[p][idx];
}
game.SyncImmutableCardAll(c);
toRemove.Add(c);
h = (HeroCardHandler)c.Type;
Trace.TraceInformation("Assign {0} to player {1}", h.Hero.Name, p.Id);
var hero = h.Hero.Clone() as Hero;
foreach (var skill in new List<ISkill>(hero.Skills))
{
if (skill.IsRulerOnly)
{
hero.Skills.Remove(skill);
}
}
p.Hero = hero;
p.Allegiance = hero.Allegiance;
p.MaxHealth = p.Health = hero.MaxHealth;
p.IsMale = hero.IsMale ? true : false;
p.IsFemale = hero.IsMale ? false : true;
}
foreach (var card in toRemove)
{
game.Decks[DeckType.Heroes].Remove(card);
}
if (game.IsClient)
{
foreach (var card in game.Decks[DeckType.Heroes])
{
card.Type = new UnknownHeroCardHandler();
card.Id = Card.UnknownHeroId;
}
}
Shuffle(game.Decks[DeckType.Heroes]);
foreach (var pxy in game.UiProxies)
{
pxy.Value.Freeze();
}
var toCheck = game.AlivePlayers;
game.SortByOrderOfComputation(game.Players[rulerId], toCheck);
foreach (var p in toCheck)
{
Game.CurrentGame.HandleGodHero(p);
}
Shuffle(game.Decks[null, DeckType.Dealing]);
Player current = game.CurrentPlayer = game.Players[rulerId];
StartGameDeal(game);
foreach (var act in game.AlivePlayers)
{
game.Emit(GameEvent.PlayerGameStartAction, new GameEventArgs() { Source = act });
}
while (true)
{
GameEventArgs args = new GameEventArgs();
args.Source = current;
game.CurrentPhaseEventIndex = 0;
game.CurrentPhase = TurnPhase.BeforeStart;
game.CurrentPlayer = current;
game.Emit(GameEvent.DoPlayer, args);
current = game.NextAlivePlayer(current);
}
}
public void HandleCardTransfer(Player from, Player to, DeckType target, List<Card> cards)
{
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(to, target);
move.Helper = new MovementHelper();
MoveCards(move);
PlayerLostCard(from, cards);
PlayerAcquiredCard(to, cards);
}
public List <Card> this[DeckType type]
{
get { return(this[null, type]); }
set { this[null, type] = value; }
}
public void HandleCardTransfer(Player from, Player to, DeckType target, List<Card> cards)
{
if (to.IsDead)
{
if (cards.Any(cd => cd.Place.DeckType != DeckType.Hand && cd.Place.DeckType != DeckType.Equipment && cd.Place.DeckType != DeckType.DelayedTools))
{
CardsMovement move1 = new CardsMovement();
move1.Cards = new List<Card>(cards);
move1.To = new DeckPlace(null, DeckType.Discard);
MoveCards(move1);
PlayerLostCard(from, cards);
}
return;
}
CardsMovement move = new CardsMovement();
move.Cards = new List<Card>(cards);
move.To = new DeckPlace(to, target);
move.Helper = new MovementHelper();
MoveCards(move);
GameDelays.Delay(GameDelayTypes.CardTransfer);
EnterAtomicContext();
PlayerLostCard(from, cards);
PlayerAcquiredCard(to, cards);
ExitAtomicContext();
}
public DeckPlace(Player player, DeckType deckType)
{
this.player = player;
this.deckType = deckType;
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
var GuZhengDeck = new DeckType("GuZheng");
belongToCurrent = new List<Card>();
foreach (Card c in new List<Card>(GuZhengCards))
{
if (c.Place.DeckType != DeckType.Discard)
{
GuZhengCards.Remove(c);
}
else if (c.HistoryPlace1.Player == Game.CurrentGame.CurrentPlayer)
{
belongToCurrent.Add(c);
}
}
if (belongToCurrent.Count == 0 || !AskForSkillUse())
{
GuZhengCards = new List<Card>();
belongToCurrent = new List<Card>();
return;
}
NotifySkillUse();
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<OptionPrompt>() { new OptionPrompt("GuZhengHuoDe"), new OptionPrompt("GuZhengBuHuoDe") } };
if (!Game.CurrentGame.UiProxies[Owner].AskForCardChoice(
new CardChoicePrompt("GuZheng", Owner, Game.CurrentGame.CurrentPlayer),
new List<DeckPlace>() { new DeckPlace(null, GuZhengDeck) },
new List<string>() { "GuZhengFanHui" },
new List<int>() { 1 },
new GuZhengVerifier(),
out answer,
options))
{
Trace.TraceInformation("Invalid answer, choosing for you");
answer = new List<List<Card>>();
answer.Add(new List<Card>());
answer[0].Add(belongToCurrent[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>();
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
var card = eventArgs.Card;
if (!(card.Type is WuGuFengDeng)) return;
var wugu = card.Type as WuGuFengDeng;
var dests = eventArgs.Targets;
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, false, Core.Utils.GameDelayTypes.None);
wugu.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);
wugu.FakeMapping.Add(faked, c);
}
Game.CurrentGame.NotificationProxy.NotifyWuGuStart(new CardChoicePrompt("WuGuFengDeng.Init"), new DeckPlace(null, wuguFakeDeck));
}
public DeckPlace(Player player, DeckType deckType)
{
this.player = player;
this.deckType = deckType;
}
void ZhaoLieProcess(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
ZhaoLieUsed = false;
basicCards.Clear();
notBasicCards.Clear();
List<Card> tao = new List<Card>();
DeckType ZhaoLieDeck = new DeckType("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;
}
public void AskForHeroChoice(Dictionary<Player, List<Card>> restDraw, Dictionary<Player, Card> heroSelection)
{
DeckType temp = new DeckType("Temp");
if (!restDraw.ContainsKey(proxy.HostPlayer))
{
return;
}
Game.CurrentGame.Decks[proxy.HostPlayer, temp].AddRange(restDraw[proxy.HostPlayer]);
List<DeckPlace> sourceDecks = new List<DeckPlace>();
sourceDecks.Add(new DeckPlace(proxy.HostPlayer, temp));
List<string> resultDeckNames = new List<string>() { "HeroChoice" };
List<int> resultDeckMaximums = new List<int>() { 1 };
int windowId = 0;
proxy.TryAskForCardChoice(new CardChoicePrompt("HeroChoice"), sourceDecks, resultDeckNames, resultDeckMaximums, new AlwaysTrueChoiceVerifier(), new List<bool>() {false}, ref windowId, null);
}
