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