void Run(Player owner, GameEvent gameEvent, GameEventArgs args)
{
while (owner.HandCards().Count > 0 && owner.DelayedTools().Count > 0)
{
List <List <Card> > answer;
List <DeckPlace> sourceDeck = new List <DeckPlace>();
sourceDeck.Add(new DeckPlace(owner, DeckType.DelayedTools));
sourceDeck.Add(new DeckPlace(owner, DeckType.Hand));
AdditionalCardChoiceOptions options = new AdditionalCardChoiceOptions();
options.IsCancellable = true;
if (owner.AskForCardChoice(new CardChoicePrompt("XiuLuo", owner),
sourceDeck,
new List <string>()
{
"XLJinNang", "XLShouPai"
},
new List <int>()
{
1, 1
},
new XiuLuoVerifier(),
out answer,
options))
{
NotifySkillUse();
Game.CurrentGame.HandleCardDiscard(owner, answer[1]);
Game.CurrentGame.HandleCardDiscard(owner, answer[0]);
}
else
{
break;
}
}
}
public void AskForCardChoice(Prompt prompt, List <Cards.DeckPlace> sourceDecks, List <string> resultDeckNames, List <int> resultDeckMaximums, ICardChoiceVerifier verifier, int timeOutSeconds, AdditionalCardChoiceOptions options, CardChoiceRearrangeCallback callback)
{
currentChoiceOptions = options;
CurrentQuestionState = QuestionState.AskForCardChoice;
Gamer.ReceiveAsync();
if (Gamer.OnlineStatus != OnlineStatus.Online)
{
AnswerCardChoice(null);
}
}
/// <summary>
/// 询问用户从若干牌堆中选择卡牌，例如顺手牵羊，观星等等。
/// </summary>
/// <param name="prompt"></param>
/// <param name="sourceDecks"></param>
/// <param name="resultDeckNames"></param>
/// <param name="resultDeckMaximums"></param>
/// <param name="verifier"></param>
/// <param name="answer">用户选择结果。对应resultDeckNames，每个选出的牌堆占用一个list。</param>
/// <returns>False if user cannot provide an answer.</returns>
public static bool AskForCardChoice(this Player p, Prompt prompt,
List <DeckPlace> sourceDecks,
List <string> resultDeckNames,
List <int> resultDeckMaximums,
ICardChoiceVerifier verifier,
out List <List <Card> > answer,
AdditionalCardChoiceOptions helper = null,
CardChoiceRearrangeCallback callback = null)
{
return(Game.CurrentGame.UiProxies[p].AskForCardChoice(prompt, sourceDecks, resultDeckNames, resultDeckMaximums, verifier, out answer, helper, callback));
}
public override bool Commit(GameEventArgs arg)
{
Owner[XinZhanUsed] = 1;
DeckType XinZhanDeck = DeckType.Register("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, false, GameDelays.None);
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 LogEvent("XinZhan", Owner, Game.CurrentGame.Decks[null, XinZhanDeck].Count), new List <Player>()
{
Owner
}, false);
Game.CurrentGame.InsertBeforeDeal(null, Game.CurrentGame.Decks[null, XinZhanDeck], new MovementHelper()
{
IsFakedMove = true
});
}
else
{
Game.CurrentGame.NotificationProxy.NotifyLogEvent(new LogEvent("XinZhan", Owner, answer[0].Count), new List <Player>()
{
Owner
}, false);
Game.CurrentGame.InsertBeforeDeal(null, answer[0], new MovementHelper()
{
IsFakedMove = true
});
Game.CurrentGame.HandleCardTransferToHand(null, Owner, answer[1]);
}
return(true);
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
Pk1v1Game game = Game.CurrentGame as Pk1v1Game;
foreach (Player pp in game.Players)
{
game.HandCardVisibility.Add(pp, new List <Player>()
{
pp
});
}
// Put the whole deck in the dealing deck
foreach (Card card in game.CardSet)
{
// We don't want hero cards
if (card.Type is HeroCardHandler)
{
game.Decks[DeckType.Heroes].Add(card);
card.Place = new DeckPlace(null, DeckType.Heroes);
}
else if (card.Type is RoleCardHandler)
{
card.Place = new DeckPlace(null, RoleDeckType);
}
else
{
game.Decks[DeckType.Dealing].Add(card);
card.Place = new DeckPlace(null, DeckType.Dealing);
}
}
if (game.Players.Count == 0)
{
return;
}
// Await role decision
int seed = DateTime.Now.Millisecond;
game.Seed = seed;
Trace.TraceError("Seed is {0}", seed);
if (game.RandomGenerator == null)
{
game.RandomGenerator = new Random(seed);
Random random = game.RandomGenerator;
}
int selectorId = game.RandomGenerator.Next(2);
int rulerId = 0;
bool selectorIs0 = selectorId == 0;
game.SyncConfirmationStatus(ref selectorIs0);
if (selectorIs0)
{
selectorId = 0;
}
else
{
selectorId = 1;
}
int wantToBeRuler = 0;
game.Players[selectorId].AskForMultipleChoice(new MultipleChoicePrompt("BeRuler"), OptionPrompt.YesNoChoices, out wantToBeRuler);
rulerId = 1 - (wantToBeRuler ^ selectorId);
Trace.Assert(rulerId >= 0 && rulerId <= 1);
Trace.Assert(game.Players.Count == 2);
if (rulerId == 0)
{
game.AvailableRoles.Add(Role.Ruler);
game.AvailableRoles.Add(Role.Defector);
game.Decks[null, RoleDeckType].Add(_FindARoleCard(Role.Ruler));
game.Decks[null, RoleDeckType].Add(_FindARoleCard(Role.Defector));
}
else
{
game.AvailableRoles.Add(Role.Defector);
game.AvailableRoles.Add(Role.Ruler);
game.Decks[null, RoleDeckType].Add(_FindARoleCard(Role.Defector));
game.Decks[null, RoleDeckType].Add(_FindARoleCard(Role.Ruler));
}
List <CardsMovement> moves = new List <CardsMovement>();
int 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, GameDelays.GameStart);
GameDelays.Delay(GameDelays.RoleDistribute);
//hero allocation
game.Shuffle(game.Decks[DeckType.Heroes]);
List <Card> heroPool = new List <Card>();
int toDraw = 12;
for (int rc = 0; rc < toDraw; rc++)
{
game.SyncImmutableCardAll(game.Decks[DeckType.Heroes][rc]);
heroPool.Add(game.Decks[DeckType.Heroes][rc]);
}
game.SyncImmutableCards(game.Players[rulerId], heroPool);
DeckType tempHero = DeckType.Register("TempHero");
game.Decks[null, tempHero].AddRange(heroPool);
Trace.TraceInformation("Ruler is {0}", rulerId);
game.Players[rulerId].Role = Role.Ruler;
game.Players[1 - rulerId].Role = Role.Defector;
List <int> heroSelectCount = new List <int>()
{
1, 2, 2, 2, 2, 2, 1
};
int seq = 0;
int turn = rulerId;
Dictionary <int, int> map = new Dictionary <int, int>();
map.Add(0, 0);
map.Add(1, 1);
var deckPlace = new DeckPlace(null, tempHero);
game.NotificationProxy.NotifyTwoSidesCardPickStart(new CardChoicePrompt("Pk1v1.InitHeroPick.Init"), deckPlace, map, 6, 6);
while (heroSelectCount.Count > seq)
{
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>();
int numHeroes = heroSelectCount[seq];
resultDeckMaximums.Add(numHeroes);
List <List <Card> > answer;
var newVer = new Pk1v1HeroChoiceVerifier(1, seq + 1 == heroSelectCount.Count ? -(Game.CurrentGame.Settings.TimeOutSeconds - 2) : 0);
for (int j = 0; j < numHeroes; j++)
{
var option = new AdditionalCardChoiceOptions();
option.IsTwoSidesCardChoice = true;
if (!game.UiProxies[game.Players[turn]].AskForCardChoice(new CardChoicePrompt("Pk1v1.InitHeroPick", numHeroes), sourceDecks, resultDeckNames, resultDeckMaximums, newVer, out answer, option))
{
answer = new List <List <Card> >();
answer.Add(new List <Card>());
answer[0].Add(game.Decks[null, tempHero].First(h => !answer[0].Contains(h) && !game.Decks[game.Players[turn], SelectedHero].Contains(h) && !game.Decks[game.Players[1 - turn], SelectedHero].Contains(h)));
}
game.Decks[game.Players[turn], SelectedHero].AddRange(answer[0]);
game.NotificationProxy.NotifyTwoSidesCardPicked(turn == 0, game.Decks[deckPlace].IndexOf(answer[0][0]));
}
seq++;
turn = 1 - turn;
}
GameDelays.Delay(GameDelays.Pk1v1EndOfSelection);
game.NotificationProxy.NotifyTwoSidesCardPickEnd();
game.Shuffle(game.Decks[null, DeckType.Dealing]);
Player current = game.CurrentPlayer = game.Players[1 - rulerId];
Dictionary <Player, List <Card> > restDraw = new Dictionary <Player, List <Card> >();
List <Player> players = new List <Player>(game.Players);
foreach (Player p in players)
{
restDraw.Add(p, new List <Card>(game.Decks[p, SelectedHero]));
}
var heroSelection = new Dictionary <Player, List <Card> >();
int numberOfHeroes = Game.CurrentGame.Settings.DualHeroMode ? 2 : 1;
game.GlobalProxy.AskForHeroChoice(restDraw, heroSelection, numberOfHeroes, new RequireCardsChoiceVerifier(numberOfHeroes, false, true));
bool notUsed = true;
game.SyncConfirmationStatus(ref notUsed);
foreach (var pxy in game.UiProxies)
{
pxy.Value.Freeze();
}
for (int repeat = 0; repeat < numberOfHeroes; repeat++)
{
foreach (Player p in players)
{
Card c;
int idx;
//only server has the result
if (!game.IsClient)
{
idx = repeat;
if (heroSelection.ContainsKey(p))
{
c = heroSelection[p][repeat];
idx = restDraw[p].IndexOf(c);
}
else
{
c = restDraw[p][idx];
}
if (game.GameServer != null)
{
foreach (Player player in game.Players)
{
game.GameServer.SendPacket(player.Id, new StatusSync()
{
Status = idx
});
}
game.GameServer.SendPacket(game.Players.Count, new StatusSync()
{
Status = idx
});
}
}
// you are client
else
{
idx = (int)game.GameClient.Receive();
c = restDraw[p][idx];
}
game.Decks[p, SelectedHero].Remove(c);
var 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);
}
}
if (repeat == 0)
{
p.Hero = hero;
p.Allegiance = hero.Allegiance;
p.IsMale = hero.IsMale;
p.IsFemale = !hero.IsMale;
if (numberOfHeroes == 1)
{
p.MaxHealth = hero.MaxHealth;
p.Health = hero.MaxHealth;
}
}
else if (repeat == 1)
{
p.Hero2 = hero;
int aveHp = (p.Hero2.MaxHealth + p.Hero.MaxHealth) / 2;
p.MaxHealth = aveHp;
p.Health = aveHp;
}
}
}
foreach (var rm in heroPool)
{
game.Decks[DeckType.Heroes].Remove(rm);
}
foreach (var st in game.Decks[game.Players[0], SelectedHero])
{
st.Place = new DeckPlace(game.Players[0], SelectedHero);
}
foreach (var st in game.Decks[game.Players[1], SelectedHero])
{
st.Place = new DeckPlace(game.Players[1], SelectedHero);
}
game.Shuffle(game.Decks[DeckType.Heroes]);
if (game.IsClient)
{
foreach (var card in game.Decks[DeckType.Heroes])
{
card.Type = new UnknownHeroCardHandler();
card.Id = Card.UnknownHeroId;
}
}
GameDelays.Delay(GameDelays.GameBeforeStart);
Game.CurrentGame.NotificationProxy.NotifyGameStart();
GameDelays.Delay(GameDelays.GameStart);
GameDelays.Delay(GameDelays.GameStart);
foreach (var pl in game.Players)
{
StartGameDeal(game, pl);
}
foreach (var pl in game.Players)
{
try
{
game.Emit(GameEvent.HeroDebut, new GameEventArgs()
{
Source = pl
});
}
catch (EndOfTurnException)
{
game.CurrentPlayer = game.Players[1 - game.CurrentPlayer.Id];
}
}
foreach (var act in game.AlivePlayers)
{
game.Emit(GameEvent.PlayerGameStartAction, new GameEventArgs()
{
Source = act
});
}
//redo this: current player might change
current = game.CurrentPlayer;
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);
}
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
var GuZhengDeck = DeckType.Register("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();
foreach (var c in GuZhengCards)
{
c.Log.SkillAction = this;
}
CardsMovement move = new CardsMovement();
move.Cards = GuZhengCards;
move.To = new DeckPlace(null, GuZhengDeck);
Game.CurrentGame.MoveCards(move, false, Core.Utils.GameDelays.None);
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", Game.CurrentGame.CurrentPlayer),
new List <DeckPlace>()
{
new DeckPlace(null, GuZhengDeck)
},
new List <string>()
{
"GuZhengFanHui"
},
new List <int>()
{
1
},
new GuZhengVerifier(belongToCurrent),
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 void SendCardChoice(ICardChoiceVerifier verifier, List <List <Card> > answer, AdditionalCardChoiceOptions options)
{
for (int i = 0; i < server.MaxClients; i++)
{
int j = 0;
if (answer != null)
{
foreach (var cards in answer)
{
foreach (Card c in cards)
{
if (verifier.Helper != null && (verifier.Helper.RevealCards || (verifier.Helper.AdditionalFineGrainedCardChoiceRevealPolicy != null && verifier.Helper.AdditionalFineGrainedCardChoiceRevealPolicy[j])))
{
if (c.Place.DeckType != DeckType.Equipment && c.Place.DeckType != DeckType.DelayedTools)
{
c.RevealOnce = true;
}
}
}
j++;
}
}
server.SendPacket(i, AskForCardChoiceResponse.Parse(proxy.QuestionId, answer, options == null? 0 : options.OptionResult, i));
}
}
public bool AskForCardChoice(Prompt prompt, List <DeckPlace> sourceDecks, List <string> resultDeckNames, List <int> resultDeckMaximums, ICardChoiceVerifier verifier, out List <List <Card> > answer, AdditionalCardChoiceOptions options, CardChoiceRearrangeCallback callback)
{
answer = null;
bool ret = true;
if (!TryAskForCardChoice(sourceDecks, resultDeckMaximums, verifier, out answer, options, callback))
{
SendCardChoice(null, null, null);
ret = false;
}
else
{
SendCardChoice(verifier, answer, options);
}
NextQuestion();
if (answer == null)
{
answer = new List <List <Card> >();
foreach (var v in resultDeckMaximums)
{
answer.Add(new List <Card>());
}
}
return(ret);
}
public bool TryAskForCardChoice(List <DeckPlace> sourceDecks, List <int> resultDeckMaximums, ICardChoiceVerifier verifier, out List <List <Card> > answer, AdditionalCardChoiceOptions options, CardChoiceRearrangeCallback callback)
{
answer = null;
int timeOut = TimeOutSeconds + (verifier.Helper != null ? verifier.Helper.ExtraTimeOutSeconds : 0);
Trace.TraceInformation("Asking Card Choice to {0}, timeout {1}.", HostPlayer.Id, timeOut);
var answerReady = new Semaphore(0, Int16.MaxValue);
CardChoiceAnsweredEventHandler handler = (c) =>
{
choiceAnswer = c;
answerReady.Release(1);
};
proxy.CardChoiceAnsweredEvent += handler;
proxy.AskForCardChoice(new Prompt(), sourceDecks, new List <string>(), resultDeckMaximums, verifier, timeOut, options, callback);
bool noAnswer = false;
if (!answerReady.WaitOne(timeOut * 1000))
{
noAnswer = true;
}
proxy.CardChoiceAnsweredEvent -= handler;
proxy.Freeze();
if (noAnswer)
{
return(false);
}
answer = choiceAnswer;
if (answer != null)
{
foreach (var list in answer)
{
foreach (var item in list)
{
if (item == null)
{
return(false);
}
bool exist = false;
foreach (var v in sourceDecks)
{
if (Game.CurrentGame.Decks[v].Contains(item))
{
exist = true;
break;
}
}
if (options != null && options.DefaultResult != null)
{
foreach (var dk in options.DefaultResult)
{
if (dk.Contains(item))
{
exist = true;
break;
}
}
}
if (!exist)
{
Trace.TraceWarning("Client DDOS!");
return(false);
}
}
}
}
else
{
answer = new List <List <Card> >();
}
while (answer.Count < resultDeckMaximums.Count)
{
answer.Add(new List <Card>());
}
if (verifier.Verify(answer) != VerifierResult.Success)
{
Trace.TraceWarning("Client seems to be sending invalid answers at us. DDOS?");
answer = null;
return(false);
}
return(true);
}
public bool TryAnswerForCardChoice(Prompt prompt, ICardChoiceVerifier verifier, out List <List <Card> > answer, AdditionalCardChoiceOptions options, CardChoiceRearrangeCallback callback)
{
object o = client.Receive();
int opt;
answer = (o as AskForCardChoiceResponse).ToAnswer(client.SelfId, out opt);
if (options != null)
{
options.OptionResult = opt;
}
return(true);
}
public void TryAskForCardChoice(Prompt prompt, List <DeckPlace> sourceDecks, List <string> resultDeckNames, List <int> resultDeckMaximums, ICardChoiceVerifier verifier, AdditionalCardChoiceOptions options, CardChoiceRearrangeCallback callback)
{
List <List <Card> > answer;
if (!IsPlayable)
{
if (IsUiDetached)
{
return;
}
uiProxy.AskForCardChoice(prompt, sourceDecks, resultDeckNames, resultDeckMaximums, verifier, out answer, options, callback);
return;
}
if (IsUiDetached || !uiProxy.AskForCardChoice(prompt, sourceDecks, resultDeckNames, resultDeckMaximums, verifier, out answer, options, callback) ||
answer == null)
{
Trace.TraceInformation("Invalid answer");
client.Send(AskForCardChoiceResponse.Parse(numQuestionsAsked, null, 0, client.SelfId));
}
else
{
client.Send(AskForCardChoiceResponse.Parse(numQuestionsAsked, answer, options == null ? 0 : options.OptionResult, client.SelfId));
}
}
public bool AskForCardChoice(Prompt prompt, List <DeckPlace> sourceDecks, List <string> resultDeckNames, List <int> resultDeckMaximums, ICardChoiceVerifier verifier, out List <List <Card> > answer, AdditionalCardChoiceOptions options = null, CardChoiceRearrangeCallback callback = null)
{
Trace.TraceInformation("Asking Card Choice to {0}.", HostPlayer.Id);
TryAskForCardChoice(prompt, sourceDecks, resultDeckNames, resultDeckMaximums, verifier, options, callback);
SimulateReplayDelay();
NextQuestion();
if (TryAnswerForCardChoice(prompt, verifier, out answer, options, callback))
{
uiProxy.Freeze();
if (answer == null || answer.Count == 0)
{
return(false);
}
#if DEBUG
Trace.Assert(verifier.Verify(answer) == VerifierResult.Success);
#endif
return(true);
}
uiProxy.Freeze();
return(false);
}
void Run(Player Owner, GameEvent gameEvent, GameEventArgs eventArgs)
{
DeckType GuanXingDeck = DeckType.Register("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.GameDelays.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
});
}
}
