public void HandlePlayerDeckDiscard(Entity entity, string cardId, int turn)
{
_game.Player.DeckDiscard(entity, turn);
DeckManager.DetectCurrentDeck().Forget();
Core.UpdatePlayerCards();
GameEvents.OnPlayerDeckDiscard.Execute(Database.GetCardFromId(cardId));
}
public void HandlePlayerSecretPlayed(Entity entity, string cardId, int turn, Zone fromZone)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
if (!entity.IsSecret)
{
if (entity.IsQuest)
{
_game.Player.QuestPlayedFromHand(entity, turn);
GameEvents.OnPlayerPlay.Execute(Database.GetCardFromId(cardId));
}
return;
}
switch (fromZone)
{
case Zone.DECK:
_game.Player.SecretPlayedFromDeck(entity, turn);
DeckManager.DetectCurrentDeck().Forget();
break;
case Zone.HAND:
_game.Player.SecretPlayedFromHand(entity, turn);
_game.SecretsManager.HandleCardPlayed(entity);
break;
default:
_game.Player.CreateInSecret(entity, turn);
return;
}
Core.UpdatePlayerCards();
GameEvents.OnPlayerPlay.Execute(Database.GetCardFromId(cardId));
}
public void HandleInMenu()
{
if (_game.IsInMenu)
{
return;
}
Log.Info("Game is now in menu.");
_game.IsInMenu = true;
TurnTimer.Instance.Stop();
Core.Overlay.HideTimers();
Core.Overlay.HideSecrets();
Core.Overlay.Update(true);
DeckManager.ResetIgnoredDeckId();
Core.Windows.CapturableOverlay?.UpdateContentVisibility();
SaveAndUpdateStats();
if (Config.Instance.AutoArchiveArenaDecks && (DeckList.Instance.ActiveDeck?.IsArenaRunCompleted ?? false))
{
Core.MainWindow.ArchiveDeck(DeckList.Instance.ActiveDeck, true);
}
_game.ResetStoredGameState();
if (_arenaRewardDialog != null)
{
_arenaRewardDialog.Show();
_arenaRewardDialog.Activate();
}
if (_game.CurrentGameStats != null && _game.CurrentGameStats.GameMode == Arena)
{
ArenaStats.Instance.UpdateArenaRuns();
ArenaStats.Instance.UpdateArenaStats();
ArenaStats.Instance.UpdateArenaStatsHighlights();
}
if (!_game.IsUsingPremade)
{
_game.DrawnLastGame =
new List <Card>(_game.Player.RevealedEntities.Where(x => !x.Info.Created && !x.Info.Stolen && x.Card.Collectible &&
x.IsPlayableCard).GroupBy(x => x.CardId).Select(x =>
{
var card = Database.GetCardFromId(x.Key);
card.Count = x.Count();
return(card);
}));
}
if (!Config.Instance.KeepDecksVisible)
{
Core.Reset().Forget();
}
GameEvents.OnInMenu.Execute();
}
public void HandlePlayerDraw(Entity entity, string cardId, int turn)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
if (cardId == "GAME_005")
{
HandlePlayerGet(entity, cardId, turn);
}
else
{
_game.Player.Draw(entity, turn);
Core.UpdatePlayerCards();
DeckManager.DetectCurrentDeck().Forget();
}
GameEvents.OnPlayerDraw.Execute(Database.GetCardFromId(cardId));
}
#pragma warning disable 4014
public async void HandleGameEnd()
{
try
{
if (_game.CurrentGameStats == null || _handledGameEnd)
{
Log.Warn("HandleGameEnd was already called.");
return;
}
_handledGameEnd = true;
TurnTimer.Instance.Stop();
Core.Overlay.HideTimers();
DeckManager.ResetAutoSelectCount();
LiveDataManager.Stop();
Log.Info("Game ended...");
_game.InvalidateMatchInfoCache();
if (_game.CurrentGameMode == Spectator && _game.CurrentGameStats.Result == GameResult.None)
{
Log.Info("Game was spectator mode without a game result. Probably exited spectator mode early.");
return;
}
var player = _game.Entities.FirstOrDefault(e => e.Value?.IsPlayer ?? false).Value;
var opponent = _game.Entities.FirstOrDefault(e => e.Value != null && e.Value.HasTag(PLAYER_ID) && !e.Value.IsPlayer).Value;
if (player != null)
{
_game.CurrentGameStats.PlayerName = player.Name;
_game.CurrentGameStats.Coin = !player.HasTag(FIRST_PLAYER);
}
if (opponent != null && CardIds.HeroIdDict.ContainsValue(_game.CurrentGameStats.OpponentHero))
{
_game.CurrentGameStats.OpponentName = opponent.Name;
}
else
{
_game.CurrentGameStats.OpponentName = _game.CurrentGameStats.OpponentHero;
}
_game.CurrentGameStats.Turns = _game.GetTurnNumber();
if (Config.Instance.DiscardZeroTurnGame && _game.CurrentGameStats.Turns < 1)
{
Log.Info("Game has 0 turns, discarded. (DiscardZeroTurnGame)");
_assignedDeck = null;
GameEvents.OnGameEnd.Execute();
return;
}
_game.CurrentGameStats.GameMode = _game.CurrentGameMode;
_game.CurrentGameStats.Format = _game.CurrentFormat;
Log.Info("Format: " + _game.CurrentGameStats.Format);
if (_game.CurrentGameMode == Ranked && _game.MatchInfo != null)
{
var wild = _game.CurrentFormat == Format.Wild;
_game.CurrentGameStats.Rank = wild ? _game.MatchInfo.LocalPlayer.WildRank : _game.MatchInfo.LocalPlayer.StandardRank;
_game.CurrentGameStats.OpponentRank = wild ? _game.MatchInfo.OpposingPlayer.WildRank : _game.MatchInfo.OpposingPlayer.StandardRank;
_game.CurrentGameStats.LegendRank = wild ? _game.MatchInfo.LocalPlayer.WildLegendRank : _game.MatchInfo.LocalPlayer.StandardLegendRank;
_game.CurrentGameStats.OpponentLegendRank = wild ? _game.MatchInfo.OpposingPlayer.WildLegendRank : _game.MatchInfo.OpposingPlayer.StandardLegendRank;
_game.CurrentGameStats.Stars = wild ? _game.MatchInfo.LocalPlayer.WildStars : _game.MatchInfo.LocalPlayer.StandardStars;
}
else if (_game.CurrentGameMode == Arena)
{
_game.CurrentGameStats.ArenaWins = DeckImporter.ArenaInfoCache?.Wins ?? 0;
_game.CurrentGameStats.ArenaLosses = DeckImporter.ArenaInfoCache?.Losses ?? 0;
}
else if (_game.CurrentGameMode == Brawl && _game.BrawlInfo != null)
{
_game.CurrentGameStats.BrawlWins = _game.BrawlInfo.Wins;
_game.CurrentGameStats.BrawlLosses = _game.BrawlInfo.Losses;
}
_game.CurrentGameStats.GameType = _game.CurrentGameType;
_game.CurrentGameStats.ServerInfo = _game.MetaData.ServerInfo;
_game.CurrentGameStats.PlayerCardbackId = _game.MatchInfo?.LocalPlayer.CardBackId ?? 0;
_game.CurrentGameStats.OpponentCardbackId = _game.MatchInfo?.OpposingPlayer.CardBackId ?? 0;
_game.CurrentGameStats.FriendlyPlayerId = _game.MatchInfo?.LocalPlayer.Id ?? 0;
_game.CurrentGameStats.ScenarioId = _game.MatchInfo?.MissionId ?? 0;
_game.CurrentGameStats.BrawlSeasonId = _game.MatchInfo?.BrawlSeasonId ?? 0;
_game.CurrentGameStats.RankedSeasonId = _game.MatchInfo?.RankedSeasonId ?? 0;
var confirmedCards = _game.Player.RevealedCards.Where(x => x.Collectible)
.Concat(_game.Player.KnownCardsInDeck.Where(x => x.Collectible && !x.IsCreated))
.ToList();
if (_game.CurrentSelectedDeck != null && _game.CurrentSelectedDeck.Id > 0)
{
_game.CurrentGameStats.HsDeckId = _game.CurrentSelectedDeck.Id;
_game.CurrentGameStats.SetPlayerCards(_game.CurrentSelectedDeck, confirmedCards);
}
else
{
_game.CurrentGameStats.HsDeckId = DeckList.Instance.ActiveDeckVersion?.HsId ?? 0;
_game.CurrentGameStats.SetPlayerCards(DeckList.Instance.ActiveDeckVersion, confirmedCards);
}
_game.CurrentGameStats.SetOpponentCards(_game.Opponent.OpponentCardList.Where(x => !x.IsCreated).ToList());
_game.CurrentGameStats.GameEnd();
GameEvents.OnGameEnd.Execute();
_game.CurrentSelectedDeck = null;
var selectedDeck = DeckList.Instance.ActiveDeck;
if (selectedDeck != null)
{
var revealed = _game.Player.RevealedEntities.Where(x => x != null).ToList();
if (Config.Instance.DiscardGameIfIncorrectDeck &&
!revealed.Where(x => x.IsPlayableCard && !x.Info.Created && !x.Info.Stolen && x.Card.Collectible)
.GroupBy(x => x.CardId).All(x => selectedDeck.GetSelectedDeckVersion().Cards.Any(c2 => x.Key == c2.Id && x.Count() <= c2.Count)))
{
if (Config.Instance.AskBeforeDiscardingGame)
{
var discardDialog = new DiscardGameDialog(_game.CurrentGameStats)
{
Topmost = true
};
discardDialog.ShowDialog();
if (discardDialog.Result == DiscardGameDialogResult.Discard)
{
Log.Info("Assigned current game to NO deck - selected deck does not match cards played (dialogresult: discard)");
_assignedDeck = null;
return;
}
if (discardDialog.Result == DiscardGameDialogResult.MoveToOther)
{
var moveDialog = new MoveGameDialog(DeckList.Instance.Decks.Where(d => d.Class == _game.CurrentGameStats.PlayerHero))
{
Topmost = true
};
moveDialog.ShowDialog();
var targetDeck = moveDialog.SelectedDeck;
if (targetDeck != null)
{
selectedDeck = targetDeck;
_game.CurrentGameStats.PlayerDeckVersion = moveDialog.SelectedVersion;
//...continue as normal
}
else
{
Log.Info("No deck selected in move game dialog after discard dialog, discarding game");
_assignedDeck = null;
return;
}
}
}
else
{
Log.Info("Assigned current game to NO deck - selected deck does not match cards played (no dialog)");
_assignedDeck = null;
return;
}
}
else
{
_game.CurrentGameStats.PlayerDeckVersion = selectedDeck.GetSelectedDeckVersion().Version;
}
_lastGame = _game.CurrentGameStats;
selectedDeck.DeckStats.AddGameResult(_lastGame);
if (Config.Instance.ArenaRewardDialog && (selectedDeck.IsArenaRunCompleted ?? false))
{
if (selectedDeck.ArenaReward.Packs[0] == ArenaRewardPacks.None)
{
selectedDeck.ArenaReward.Packs[0] = Enum.GetValues(typeof(ArenaRewardPacks)).OfType <ArenaRewardPacks>().Max();
}
_arenaRewardDialog = new ArenaRewardDialog(selectedDeck);
}
if (Config.Instance.ShowNoteDialogAfterGame && !Config.Instance.NoteDialogDelayed && !_showedNoteDialog)
{
_showedNoteDialog = true;
new NoteDialog(_game.CurrentGameStats);
}
Log.Info("Assigned current game to deck: " + selectedDeck.Name);
_assignedDeck = selectedDeck;
// Unarchive the active deck after we have played a game with it
if (_assignedDeck.Archived)
{
Log.Info("Automatically unarchiving deck " + selectedDeck.Name + " after assigning current game");
Core.MainWindow.ArchiveDeck(_assignedDeck, false);
}
_lastGame = null;
}
else
{
try
{
DefaultDeckStats.Instance.GetDeckStats(_game.Player.Class).AddGameResult(_game.CurrentGameStats);
Log.Info($"Assigned current deck to default {_game.Player.Class} deck.");
}
catch (Exception ex)
{
Log.Error("Error saving to DefaultDeckStats: " + ex);
}
_assignedDeck = null;
}
if (_game.StoredGameStats != null)
{
_game.CurrentGameStats.StartTime = _game.StoredGameStats.StartTime;
}
await SaveReplays();
if (Config.Instance.ShowGameResultNotifications && RecordCurrentGameMode)
{
var deckName = _assignedDeck == null ? "No deck - " + _game.CurrentGameStats.PlayerHero : _assignedDeck.NameAndVersion;
ToastManager.ShowGameResultToast(deckName, _game.CurrentGameStats);
}
}
catch (Exception ex)
{
Log.Error(ex);
}
}
public void HandlePlayerRemoveFromDeck(Entity entity, int turn)
{
_game.Player.RemoveFromDeck(entity, turn);
DeckManager.DetectCurrentDeck().Forget();
Core.UpdatePlayerCards();
}
