private static async Task<Deck> ImportHearthNewsFr(string url)
{
try
{
var doc = await GetHtmlDoc(url);
var deck = new Deck();
var deckName = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//span[contains(@class, 'deckName')]").InnerText).Trim();
deck.Name = deckName;
var cardNodes = doc.DocumentNode.SelectNodes("//table[@class='deck_card_list']/tbody/tr/td/a[@class='real_id']");
foreach(var cardNode in cardNodes)
{
var id = cardNode.Attributes["real_id"].Value;
var count = int.Parse(cardNode.Attributes["nb_card"].Value);
var card = GameV2.GetCardFromId(id);
card.Count = count;
deck.Cards.Add(card);
if(string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
deck.Class = card.PlayerClass;
}
return deck;
}
catch(Exception e)
{
Logger.WriteLine(e.ToString(), "DeckImporter");
return null;
}
}
private static async Task<Deck> ImportHearthstoneDecks(string url)
{
try
{
var doc = await GetHtmlDoc(url);
var deck = new Deck
{
Name =
HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//*[@id='content']/div[contains(@class, 'deck')]/h1").InnerText).Trim()
};
var nodes = doc.DocumentNode.SelectNodes("//a[@real_id]");
foreach(var cardNode in nodes)
{
var id = cardNode.Attributes["real_id"].Value;
var count = int.Parse(cardNode.Attributes["nb_card"].Value);
var card = GameV2.GetCardFromId(id);
card.Count = count;
deck.Cards.Add(card);
if(string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
deck.Class = card.PlayerClass;
}
return deck;
}
catch(Exception e)
{
Logger.WriteLine(e.ToString(), "DeckImporter");
return null;
}
}
public async void HandlePlayerDraw(string cardId, int turn)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
if (cardId == "GAME_005")
{
HandlePlayerGet(cardId, turn);
}
else
{
if (_game.SetAsideCards.Contains(cardId))
{
_game.SetAsideCards.Remove(cardId);
}
LogEvent("PlayerDraw", cardId);
var correctDeck = _game.PlayerDraw(cardId);
if (!(await correctDeck) && Config.Instance.AutoDeckDetection && !Helper.MainWindow.NeedToIncorrectDeckMessage &&
!Helper.MainWindow.IsShowingIncorrectDeckMessage && _game.IsUsingPremade && _game.CurrentGameMode != GameMode.Spectator)
{
Helper.MainWindow.NeedToIncorrectDeckMessage = true;
Logger.WriteLine("Found incorrect deck on PlayerDraw", "GameEventHandler");
}
Helper.MainWindow.Overlay.ListViewPlayer.Items.Refresh();
Helper.MainWindow.PlayerWindow.ListViewPlayer.Items.Refresh();
_game.AddPlayToCurrentGame(PlayType.PlayerDraw, turn, cardId);
}
GameEvents.OnPlayerDraw.Execute(GameV2.GetCardFromId(cardId));
}
private void FilterEntities()
{
List <object> list = new List <object>();
foreach (var entity in _game.Entities)
{
var tags = entity.Value.Tags.Select(GetTagKeyValue).Aggregate((c, n) => c + " | " + n);
var card = GameV2.GetCardFromId(entity.Value.CardId);
var cardName = card != null ? card.Name : "";
var name = string.IsNullOrEmpty(entity.Value.Name) ? cardName : entity.Value.Name;
list.Add(new { Name = name, entity.Value.CardId, Tags = tags });
}
var firstNotSecond = list.Except(_previous).ToList();
var secondNotFirst = _previous.Except(list).ToList();
if (firstNotSecond.Any() || secondNotFirst.Any())
{
DataGridProperties.ItemsSource = list;
DataGridProperties.UpdateLayout();
foreach (var item in firstNotSecond)
{
var row = DataGridProperties.ItemContainerGenerator.ContainerFromItem(item) as DataGridRow;
if (row != null)
{
row.Background = new SolidColorBrush(Color.FromArgb(50, 0, 205, 0));
}
}
_previous = list;
}
}
public void HandleOpponentPlayToDeck(string cardId, int turn)
{
LogEvent("OpponentPlayToDeck", cardId, turn);
_game.OpponentPlayToDeck(cardId, turn);
_game.AddPlayToCurrentGame(PlayType.OpponentPlayToDeck, turn, cardId);
Helper.MainWindow.Overlay.ListViewOpponent.Items.Refresh();
Helper.MainWindow.OpponentWindow.ListViewOpponent.Items.Refresh();
GameEvents.OnOpponentPlayToDeck.Execute(GameV2.GetCardFromId(cardId));
}
private async void BtnIdString_Click(object sender, RoutedEventArgs e)
{
try
{
var settings = new MetroDialogSettings();
var clipboard = Clipboard.ContainsText() ? Clipboard.GetText() : "";
if (clipboard.Count(c => c == ':') > 0 && clipboard.Count(c => c == ';') > 0)
{
settings.DefaultText = clipboard;
}
//import dialog
var idString =
await
this.ShowInputAsync("Import deck",
"id:count;id2:count2;... (e.g. EX1_050:2;EX1_556:1;)\nObtained from: \nEXPORT > COPY IDS TO CLIPBOARD",
settings);
if (string.IsNullOrEmpty(idString))
{
return;
}
var deck = new Deck();
foreach (var entry in idString.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
var splitEntry = entry.Split(':');
if (splitEntry.Length != 2)
{
continue;
}
var card = GameV2.GetCardFromId(splitEntry[0]);
if (card.Id == "UNKNOWN")
{
continue;
}
int count;
int.TryParse(splitEntry[1], out count);
card.Count = count;
if (string.IsNullOrEmpty(deck.Class) && card.GetPlayerClass != "Neutral")
{
deck.Class = card.GetPlayerClass;
}
deck.Cards.Add(card);
}
SetNewDeck(deck);
if (Config.Instance.AutoSaveOnImport)
{
SaveDeckWithOverwriteCheck();
}
}
catch (Exception ex)
{
Logger.WriteLine("Error importing deck from clipboard(id string): " + ex, "Import");
}
}
public void TestHeroSkins()
{
var Alleria = GameV2.GetHeroNameFromId("HERO_05a");
Assert.AreEqual("Hunter", Alleria);
var AlleriaPower = GameV2.GetCardFromId("DS1h_292_H1");
Assert.AreEqual("Steady Shot", AlleriaPower.Name);
}
public string GetAdditionalInfo()
{
if (Type == KeyPointType.Victory || Type == KeyPointType.Defeat)
{
return(Type.ToString());
}
var cardId = GetCardId();
return(string.IsNullOrEmpty(cardId) ? "Entity " + Id : GameV2.GetCardFromId(GetCardId()).LocalizedName);
}
public void TestBrawlCards()
{
var Rotten = GameV2.GetCardFromId("TB_008");
Assert.AreEqual("Rotten Banana", Rotten.Name);
var Moira = GameV2.GetCardFromId("BRMC_87");
Assert.AreEqual("Moira Bronzebeard", Moira.Name);
}
public void HandlePlayerBackToHand(string cardId, int turn)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
LogEvent("PlayerBackToHand", cardId);
_game.PlayerGet(cardId, true, turn);
_game.AddPlayToCurrentGame(PlayType.PlayerBackToHand, turn, cardId);
GameEvents.OnPlayerPlayToHand.Execute(GameV2.GetCardFromId(cardId));
}
public void HandleOpponentDeckDiscard(string cardId, int turn)
{
LogEvent("OpponentDeckDiscard", cardId);
_game.OpponentDeckDiscard(cardId);
//there seems to be an issue with the overlay not updating here.
//possibly a problem with order of logs?
Helper.MainWindow.Overlay.ListViewOpponent.Items.Refresh();
Helper.MainWindow.OpponentWindow.ListViewOpponent.Items.Refresh();
_game.AddPlayToCurrentGame(PlayType.OpponentDeckDiscard, turn, cardId);
GameEvents.OnOpponentDeckDiscard.Execute(GameV2.GetCardFromId(cardId));
}
public override string ToString()
{
var additionalInfo = "";
if (Type == KeyPointType.Attack)
{
var attackerId = Data[0].GetTag(GAME_TAG.PROPOSED_ATTACKER);
var attackerCardId = Data.First(x => x.Id == attackerId).CardId;
if (!string.IsNullOrEmpty(attackerCardId))
{
additionalInfo += GameV2.GetCardFromId(attackerCardId).LocalizedName;
}
additionalInfo += " -> ";
var defenderId = Data[0].GetTag(GAME_TAG.PROPOSED_DEFENDER);
var defenderCardId = Data.First(x => x.Id == defenderId).CardId;
if (!string.IsNullOrEmpty(defenderCardId))
{
additionalInfo += GameV2.GetCardFromId(defenderCardId).LocalizedName;
}
}
else if (Type == KeyPointType.PlaySpell)
{
var entity = Data.First(x => x.Id == Id);
if (!string.IsNullOrEmpty(entity.CardId))
{
additionalInfo += GameV2.GetCardFromId(entity.CardId).LocalizedName;
}
additionalInfo += " -> ";
var targetId = entity.GetTag(GAME_TAG.CARD_TARGET);
var targetCardId = Data.First(x => x.Id == targetId).CardId;
if (!string.IsNullOrEmpty(targetCardId))
{
additionalInfo += GameV2.GetCardFromId(targetCardId).LocalizedName;
}
}
else
{
var entityCardId = Data.First(x => x.Id == Id).CardId;
if (!string.IsNullOrEmpty(entityCardId))
{
additionalInfo = GameV2.GetCardFromId(entityCardId).LocalizedName;
}
else
{
additionalInfo = "Entity " + Id;
}
}
return(string.Format("{1} {2}", Player, Type, additionalInfo));
}
public GameDetailItem(TurnStats.Play play, int turn)
{
Turn = turn.ToString();
Player = play.Type.ToString().StartsWith("Player") ? "Player" : "Opponent";
Action = play.Type.ToString().Replace("Player", string.Empty).Replace("Opponent", string.Empty);
Card = GameV2.GetCardFromId(play.CardId);
if (play.Type == PlayType.PlayerHandDiscard || play.Type == PlayType.OpponentHandDiscard && (Card != null && Card.Type == "Spell"))
{
Action = "Play/Discard";
}
}
public void HandlePossibleArenaCard(string id)
{
var card = GameV2.GetCardFromId(id);
if (!GameV2.IsActualCard(card))
{
return;
}
if (!_game.PossibleArenaCards.Contains(card))
{
_game.PossibleArenaCards.Add(card);
}
}
public void HandlePlayerPlay(string cardId, int turn)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
LogEvent("PlayerPlay", cardId);
_game.PlayerPlayed(cardId);
Helper.MainWindow.Overlay.ListViewPlayer.Items.Refresh();
Helper.MainWindow.PlayerWindow.ListViewPlayer.Items.Refresh();
_game.AddPlayToCurrentGame(PlayType.PlayerPlay, turn, cardId);
GameEvents.OnPlayerPlay.Execute(GameV2.GetCardFromId(cardId));
}
public void HandlePossibleConstructedCard(string id, bool canBeDoneImporting)
{
if (_doneImportingConstructed)
{
return;
}
var card = GameV2.GetCardFromId(id);
if (card == null || !GameV2.IsActualCard(card))
{
return;
}
if (canBeDoneImporting)
{
_unloadedCardCount++;
var containsOtherThanDruid =
_game.PossibleConstructedCards.Any(c => !string.IsNullOrEmpty(c.PlayerClass) && c.PlayerClass != "Druid");
var cardCount =
_game.PossibleConstructedCards.Where(c => !Config.Instance.ConstructedImportingIgnoreCachedIds.Contains(c.Id))
.Count(c => (!containsOtherThanDruid || c.PlayerClass != "Druid"));
if (_unloadedCardCount > MaxCardsOnCollectionPage && card.Cost < _lastManaCost && cardCount > 10)
{
_doneImportingConstructed = true;
return;
}
_lastManaCost = card.Cost;
}
else
{
if (Helper.SettingUpConstructedImporting)
{
if (!_game.PossibleConstructedCards.Contains(card))
{
_game.PossibleConstructedCards.Add(card);
}
return;
}
if (_ignoreCachedIds.Contains(card.Id))
{
_ignoreCachedIds.Remove(card.Id);
return;
}
}
if (!_game.PossibleConstructedCards.Contains(card))
{
_game.PossibleConstructedCards.Add(card);
}
}
private void BtnImportDeck_Click(object sender, RoutedEventArgs e)
{
var ignoreCards = new List <Card>();
var deck = new Deck {
Class = _gameStats.OpponentHero
};
foreach (var turn in _gameStats.TurnStats)
{
foreach (var play in turn.Plays)
{
if (play.Type == PlayType.OpponentPlay || play.Type == PlayType.OpponentDeckDiscard || play.Type == PlayType.OpponentHandDiscard ||
play.Type == PlayType.OpponentSecretTriggered)
{
var card = GameV2.GetCardFromId(play.CardId);
if (GameV2.IsActualCard(card))
{
if (ignoreCards.Contains(card))
{
ignoreCards.Remove(card);
continue;
}
var deckCard = deck.Cards.FirstOrDefault(c => c.Id == card.Id);
if (deckCard != null)
{
deckCard.Count++;
}
else
{
deck.Cards.Add(card);
}
}
}
else if (play.Type == PlayType.OpponentBackToHand)
{
var card = GameV2.GetCardFromId(play.CardId);
if (GameV2.IsActualCard(card))
{
ignoreCards.Add(card);
}
}
}
}
Helper.MainWindow.SetNewDeck(deck);
//Helper.MainWindow.TabControlTracker.SelectedIndex = 1;
Helper.MainWindow.FlyoutGameDetails.IsOpen = false;
Helper.MainWindow.FlyoutDeckStats.IsOpen = false;
}
public void HandleOpponentHandDiscard(string cardId, int from, int turn)
{
LogEvent("OpponentHandDiscard", cardId, turn, from);
try
{
_game.OpponentPlay(cardId, from, turn);
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString(), "OpponentHandDiscard");
}
Helper.MainWindow.Overlay.ListViewOpponent.Items.Refresh();
Helper.MainWindow.OpponentWindow.ListViewOpponent.Items.Refresh();
_game.AddPlayToCurrentGame(PlayType.OpponentHandDiscard, turn, cardId);
GameEvents.OnOpponentHandDiscard.Execute(GameV2.GetCardFromId(cardId));
}
public void HandlePlayerPlayToDeck(string cardId, int turn)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
LogEvent("PlayerPlayToDeck", cardId);
_game.PlayerPlayToDeck(cardId);
//without this update call the overlay deck does not update properly after having Card implement INotifyPropertyChanged
Helper.MainWindow.Overlay.ListViewPlayer.Items.Refresh();
Helper.MainWindow.PlayerWindow.ListViewPlayer.Items.Refresh();
_game.AddPlayToCurrentGame(PlayType.PlayerPlayToDeck, turn, cardId);
GameEvents.OnPlayerPlayToDeck.Execute(GameV2.GetCardFromId(cardId));
}
public void HandlePlayerMulligan(string cardId)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
LogEvent("PlayerMulligan", cardId);
TurnTimer.Instance.MulliganDone(ActivePlayer.Player);
_game.PlayerMulligan(cardId);
//without this update call the overlay deck does not update properly after having Card implement INotifyPropertyChanged
Helper.MainWindow.Overlay.ListViewPlayer.Items.Refresh();
Helper.MainWindow.PlayerWindow.ListViewPlayer.Items.Refresh();
_game.AddPlayToCurrentGame(PlayType.PlayerMulligan, 0, cardId);
GameEvents.OnPlayerMulligan.Execute(GameV2.GetCardFromId(cardId));
}
public void HandlePlayerDeckDiscard(string cardId, int turn)
{
LogEvent("PlayerDeckDiscard", cardId);
var correctDeck = _game.PlayerDeckDiscard(cardId);
if (!correctDeck && Config.Instance.AutoDeckDetection && !Helper.MainWindow.NeedToIncorrectDeckMessage &&
!Helper.MainWindow.IsShowingIncorrectDeckMessage && _game.IsUsingPremade && _game.CurrentGameMode != GameMode.Spectator)
{
Helper.MainWindow.NeedToIncorrectDeckMessage = true;
Logger.WriteLine("Found incorrect deck on PlayerDeckDiscard", "GameEventHandler");
}
_game.AddPlayToCurrentGame(PlayType.PlayerDeckDiscard, turn, cardId);
Helper.MainWindow.Overlay.ListViewPlayer.Items.Refresh();
Helper.MainWindow.PlayerWindow.ListViewPlayer.Items.Refresh();
GameEvents.OnPlayerDeckDiscard.Execute(GameV2.GetCardFromId(cardId));
}
public void HandlePlayerHandDiscard(string cardId, int turn)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
LogEvent("PlayerHandDiscard", cardId);
if (_game.SetAsideCards.Contains(cardId))
{
_game.SetAsideCards.Remove(cardId);
}
_game.PlayerHandDiscard(cardId);
Helper.MainWindow.Overlay.ListViewPlayer.Items.Refresh();
Helper.MainWindow.PlayerWindow.ListViewPlayer.Items.Refresh();
_game.AddPlayToCurrentGame(PlayType.PlayerHandDiscard, turn, cardId);
GameEvents.OnPlayerHandDiscard.Execute(GameV2.GetCardFromId(cardId));
}
public Deck GetOpponentDeck()
{
var ignoreCards = new List <Card>();
var deck = new Deck {
Class = OpponentHero
};
foreach (var turn in TurnStats)
{
foreach (var play in turn.Plays)
{
if (play.Type == PlayType.OpponentPlay || play.Type == PlayType.OpponentDeckDiscard || play.Type == PlayType.OpponentHandDiscard ||
play.Type == PlayType.OpponentSecretTriggered)
{
var card = GameV2.GetCardFromId(play.CardId);
if (GameV2.IsActualCard(card) && (card.PlayerClass == null || card.PlayerClass == OpponentHero))
{
if (ignoreCards.Contains(card))
{
ignoreCards.Remove(card);
continue;
}
var deckCard = deck.Cards.FirstOrDefault(c => c.Id == card.Id);
if (deckCard != null)
{
deckCard.Count++;
}
else
{
deck.Cards.Add(card);
}
}
}
else if (play.Type == PlayType.OpponentBackToHand)
{
var card = GameV2.GetCardFromId(play.CardId);
if (GameV2.IsActualCard(card))
{
ignoreCards.Add(card);
}
}
}
}
return(deck);
}
public Card ToCard(bool localizedName)
{
Card card = null;
if (!string.IsNullOrEmpty(Id))
{
card = GameV2.GetCardFromId(Id);
}
else if (!string.IsNullOrEmpty(Name))
{
card = GameV2.GetCardFromName(Name, localizedName);
}
if (card != null)
{
card.Count = Count;
}
return(card);
}
public void HandlePlayerGet(string cardId, int turn)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
LogEvent("PlayerGet", cardId);
_game.PlayerGet(cardId, false, turn);
if (cardId == "GAME_005" && _game.CurrentGameStats != null)
{
_game.CurrentGameStats.Coin = true;
Logger.WriteLine("Got coin", "GameStats");
}
_game.AddPlayToCurrentGame(PlayType.PlayerGet, turn, cardId);
GameEvents.OnPlayerGet.Execute(GameV2.GetCardFromId(cardId));
}
public void HandlePlayerSecretPlayed(string cardId, int turn, bool fromDeck)
{
if (string.IsNullOrEmpty(cardId))
{
return;
}
LogEvent("PlayerSecretPlayed", cardId);
if (fromDeck)
{
_game.PlayerDeckDiscard(cardId);
}
else
{
_game.PlayerHandDiscard(cardId);
}
Helper.MainWindow.Overlay.ListViewPlayer.Items.Refresh();
Helper.MainWindow.PlayerWindow.ListViewPlayer.Items.Refresh();
_game.AddPlayToCurrentGame(PlayType.PlayerSecretPlayed, turn, cardId);
GameEvents.OnPlayerPlay.Execute(GameV2.GetCardFromId(cardId));
}
public void HandleOpponentSecretTrigger(string cardId, int turn, int otherId)
{
LogEvent("OpponentSecretTrigger", cardId);
_game.OpponentSecretTriggered(cardId);
_game.OpponentSecretCount--;
_game.OpponentSecrets.SecretRemoved(otherId);
if (_game.OpponentSecretCount <= 0)
{
Helper.MainWindow.Overlay.HideSecrets();
}
else
{
if (Config.Instance.AutoGrayoutSecrets)
{
_game.OpponentSecrets.SetZero(cardId);
}
Helper.MainWindow.Overlay.ShowSecrets();
}
_game.AddPlayToCurrentGame(PlayType.OpponentSecretTriggered, turn, cardId);
GameEvents.OnOpponentSecretTriggered.Execute(GameV2.GetCardFromId(cardId));
}
public void HandleOpponentSecretPlayed(string cardId, int from, int turn, bool fromDeck, int otherId)
{
LogEvent("OpponentSecretPlayed");
_game.OpponentSecretCount++;
if (fromDeck)
{
_game.OpponentDeckDiscard(cardId);
}
else
{
_game.OpponentPlay(cardId, from, turn);
}
_game.AddPlayToCurrentGame(PlayType.OpponentSecretPlayed, turn, cardId);
var isStolenCard = from > 0 && _game.OpponentHandMarks[from - 1] == CardMark.Stolen;
_game.OpponentSecrets.NewSecretPlayed(otherId, isStolenCard);
Helper.MainWindow.Overlay.ShowSecrets();
GameEvents.OnOpponentPlay.Execute(GameV2.GetCardFromId(cardId));
}
public Card ToCard()
{
try
{
if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(count))
{
return(null);
}
var card = GameV2.GetCardFromId(id);
card.Count = int.Parse(count);
if (card.Count == 0)
{
card.Count = 1;
}
return(card);
}
catch (Exception e)
{
Logger.WriteLine("error converting CardObject: " + e, "HearthStatsAPI");
return(null);
}
}
public void Handle(string logLine, IHsGameState gameState, IGame game)
{
if (logLine.Contains("CREATE_GAME"))
{
gameState.GameHandler.HandleGameStart();
gameState.GameEnded = false;
gameState.AddToTurn = -1;
gameState.GameLoaded = true;
gameState.LastGameStart = DateTime.Now;
}
else if (HsLogReaderConstants.GameEntityRegex.IsMatch(logLine))
{
gameState.GameHandler.HandleGameStart();
gameState.GameEnded = false;
gameState.AddToTurn = -1;
var match = HsLogReaderConstants.GameEntityRegex.Match(logLine);
var id = int.Parse(match.Groups["id"].Value);
if (!game.Entities.ContainsKey(id))
{
game.Entities.Add(id, new Entity(id));
}
gameState.CurrentEntityId = id;
}
else if (HsLogReaderConstants.PlayerEntityRegex.IsMatch(logLine))
{
var match = HsLogReaderConstants.PlayerEntityRegex.Match(logLine);
var id = int.Parse(match.Groups["id"].Value);
if (!game.Entities.ContainsKey(id))
{
game.Entities.Add(id, new Entity(id));
}
gameState.CurrentEntityId = id;
}
else if (HsLogReaderConstants.TagChangeRegex.IsMatch(logLine))
{
var match = HsLogReaderConstants.TagChangeRegex.Match(logLine);
var rawEntity = match.Groups["entity"].Value.Replace("UNKNOWN ENTITY ", "");
int entityId;
if (rawEntity.StartsWith("[") && HsLogReaderConstants.EntityRegex.IsMatch(rawEntity))
{
var entity = HsLogReaderConstants.EntityRegex.Match(rawEntity);
var id = int.Parse(entity.Groups["id"].Value);
_tagChangeHandler.TagChange(gameState, match.Groups["tag"].Value, id, match.Groups["value"].Value, game);
}
else if (int.TryParse(rawEntity, out entityId))
{
_tagChangeHandler.TagChange(gameState, match.Groups["tag"].Value, entityId, match.Groups["value"].Value, game);
}
else
{
var entity = game.Entities.FirstOrDefault(x => x.Value.Name == rawEntity);
if (entity.Value == null)
{
//while the id is unknown, store in tmp entities
var tmpEntity = _tmpEntities.FirstOrDefault(x => x.Name == rawEntity);
if (tmpEntity == null)
{
tmpEntity = new Entity(_tmpEntities.Count + 1);
tmpEntity.Name = rawEntity;
_tmpEntities.Add(tmpEntity);
}
GAME_TAG tag;
Enum.TryParse(match.Groups["tag"].Value, out tag);
var value = HsLogReaderV2.ParseTagValue(tag, match.Groups["value"].Value);
tmpEntity.SetTag(tag, value);
if (tmpEntity.HasTag(GAME_TAG.ENTITY_ID))
{
var id = tmpEntity.GetTag(GAME_TAG.ENTITY_ID);
if (game.Entities.ContainsKey(id))
{
game.Entities[id].Name = tmpEntity.Name;
foreach (var t in tmpEntity.Tags)
{
game.Entities[id].SetTag(t.Key, t.Value);
}
_tmpEntities.Remove(tmpEntity);
//Logger.WriteLine("COPIED TMP ENTITY (" + rawEntity + ")");
}
else
{
Logger.WriteLine(
"TMP ENTITY (" + rawEntity + ") NOW HAS A KEY, BUT GAME.ENTITIES DOES NOT CONTAIN THIS KEY",
"LogReader");
}
}
}
else
{
_tagChangeHandler.TagChange(gameState, match.Groups["tag"].Value, entity.Key, match.Groups["value"].Value, game);
}
}
if (HsLogReaderConstants.EntityNameRegex.IsMatch(logLine))
{
match = HsLogReaderConstants.EntityNameRegex.Match(logLine);
var name = match.Groups["name"].Value;
var player = int.Parse(match.Groups["value"].Value);
if (player == 1)
{
gameState.GameHandler.HandlePlayerName(name);
}
else if (player == 2)
{
gameState.GameHandler.HandleOpponentName(name);
}
}
}
else if (HsLogReaderConstants.CreationRegex.IsMatch(logLine))
{
var match = HsLogReaderConstants.CreationRegex.Match(logLine);
var id = int.Parse(match.Groups["id"].Value);
var cardId = match.Groups["cardId"].Value;
if (!game.Entities.ContainsKey(id))
{
game.Entities.Add(id, new Entity(id)
{
CardId = cardId
});
}
gameState.CurrentEntityId = id;
gameState.CurrentEntityHasCardId = !string.IsNullOrEmpty(cardId);
}
else if (HsLogReaderConstants.UpdatingEntityRegex.IsMatch(logLine))
{
var match = HsLogReaderConstants.UpdatingEntityRegex.Match(logLine);
var cardId = match.Groups["cardId"].Value;
var rawEntity = match.Groups["entity"].Value;
int entityId;
if (rawEntity.StartsWith("[") && HsLogReaderConstants.EntityRegex.IsMatch(rawEntity))
{
var entity = HsLogReaderConstants.EntityRegex.Match(rawEntity);
entityId = int.Parse(entity.Groups["id"].Value);
if (gameState.NextUpdatedEntityIsJoust)
{
Entity currentEntity;
if (game.Entities.TryGetValue(entityId, out currentEntity) &&
currentEntity.IsControlledBy(game.OpponentId))
{
gameState.GameHandler.HandleOpponentJoust(cardId);
gameState.NextUpdatedEntityIsJoust = false;
}
}
}
else if (!int.TryParse(rawEntity, out entityId))
{
entityId = -1;
}
if (entityId != -1)
{
gameState.CurrentEntityId = entityId;
if (!game.Entities.ContainsKey(entityId))
{
game.Entities.Add(entityId, new Entity(entityId));
}
game.Entities[entityId].CardId = cardId;
}
}
else if (HsLogReaderConstants.CreationTagRegex.IsMatch(logLine) && !logLine.Contains("HIDE_ENTITY"))
{
var match = HsLogReaderConstants.CreationTagRegex.Match(logLine);
_tagChangeHandler.TagChange(gameState, match.Groups["tag"].Value, gameState.CurrentEntityId, match.Groups["value"].Value, game);
}
else if ((logLine.Contains("Begin Spectating") || logLine.Contains("Start Spectator")) && game.IsInMenu)
{
gameState.GameHandler.SetGameMode(GameMode.Spectator);
}
else if (logLine.Contains("End Spectator"))
{
gameState.GameHandler.SetGameMode(GameMode.Spectator);
gameState.GameHandler.HandleGameEnd();
}
else if (HsLogReaderConstants.ActionStartRegex.IsMatch(logLine))
{
var playerEntity =
game.Entities.FirstOrDefault(
e => e.Value.HasTag(GAME_TAG.PLAYER_ID) && e.Value.GetTag(GAME_TAG.PLAYER_ID) == game.PlayerId);
var opponentEntity =
game.Entities.FirstOrDefault(
e => e.Value.HasTag(GAME_TAG.PLAYER_ID) && e.Value.GetTag(GAME_TAG.PLAYER_ID) == game.OpponentId);
var match = HsLogReaderConstants.ActionStartRegex.Match(logLine);
var actionStartingCardId = match.Groups["cardId"].Value.Trim();
var actionStartingEntityId = int.Parse(match.Groups["id"].Value);
if (string.IsNullOrEmpty(actionStartingCardId))
{
Entity tmpEntity;
if (game.Entities.TryGetValue(actionStartingEntityId, out tmpEntity))
{
actionStartingCardId = tmpEntity.CardId;
}
}
if (!string.IsNullOrEmpty(actionStartingCardId))
{
if (actionStartingCardId == "BRM_007") //Gang Up
{
int id = game.Entities.Count + 1;
if (playerEntity.Value != null && playerEntity.Value.GetTag(GAME_TAG.CURRENT_PLAYER) == 1)
{
var target = match.Groups["target"].Value.Trim();
if (target.StartsWith("[") && HsLogReaderConstants.EntityRegex.IsMatch(target))
{
var cardIdMatch = HsLogReaderConstants.CardIdRegex.Match(target);
if (cardIdMatch.Success)
{
var targetCardId = cardIdMatch.Groups["cardId"].Value.Trim();
for (int i = 0; i < 3; i++)
{
gameState.ProposeKeyPoint(KeyPointType.CreateToDeck, id, ActivePlayer.Player);
gameState.GameHandler.HandlePlayerGetToDeck(targetCardId, gameState.GetTurnNumber());
}
}
}
}
else
{
//if I pass the entity id here I could know if a drawn card is one of the copies.
// (should probably not be implemented :))
for (int i = 0; i < 3; i++)
{
gameState.ProposeKeyPoint(KeyPointType.CreateToDeck, id, ActivePlayer.Opponent);
gameState.GameHandler.HandleOpponentGetToDeck(gameState.GetTurnNumber());
}
}
}
else if (actionStartingCardId == "GVG_056") //Iron Juggernaut
{
// burrowing mine will be the entity created next
int id = game.Entities.Count + 1;
if (playerEntity.Value != null && playerEntity.Value.GetTag(GAME_TAG.CURRENT_PLAYER) == 1)
{
gameState.ProposeKeyPoint(KeyPointType.CreateToDeck, id, ActivePlayer.Opponent);
gameState.GameHandler.HandleOpponentGetToDeck(gameState.GetTurnNumber());
}
else
{
gameState.ProposeKeyPoint(KeyPointType.CreateToDeck, id, ActivePlayer.Player);
gameState.GameHandler.HandlePlayerGetToDeck("GVG_056t", gameState.GetTurnNumber());
}
}
else if (actionStartingCardId == "GVG_031") //Recycle
{
// Recycled card will be the entity created next
int id = game.Entities.Count + 1;
if (playerEntity.Value != null && playerEntity.Value.GetTag(GAME_TAG.CURRENT_PLAYER) == 1)
{
gameState.ProposeKeyPoint(KeyPointType.CreateToDeck, id, ActivePlayer.Opponent);
gameState.GameHandler.HandleOpponentGetToDeck(gameState.GetTurnNumber());
}
else
{
gameState.ProposeKeyPoint(KeyPointType.CreateToDeck, id, ActivePlayer.Player);
var target = match.Groups["target"].Value.Trim();
if (target.StartsWith("[") && HsLogReaderConstants.EntityRegex.IsMatch(target))
{
var cardIdMatch = HsLogReaderConstants.CardIdRegex.Match(target);
if (cardIdMatch.Success)
{
var targetCardId = cardIdMatch.Groups["cardId"].Value.Trim();
for (int i = 0; i < 3; i++)
{
gameState.GameHandler.HandlePlayerGetToDeck(targetCardId, gameState.GetTurnNumber());
}
}
}
}
}
else if (actionStartingCardId == "GVG_035") //Malorne
{
// Malorne will be the entity created next
int id = game.Entities.Count + 1;
if (playerEntity.Value != null && playerEntity.Value.GetTag(GAME_TAG.CURRENT_PLAYER) == 1)
{
gameState.ProposeKeyPoint(KeyPointType.CreateToDeck, id, ActivePlayer.Opponent);
gameState.GameHandler.HandleOpponentGetToDeck(gameState.GetTurnNumber());
}
else
{
gameState.ProposeKeyPoint(KeyPointType.CreateToDeck, id, ActivePlayer.Player);
gameState.GameHandler.HandlePlayerGetToDeck("GVG_035", gameState.GetTurnNumber());
}
}
else
{
if (playerEntity.Value != null && playerEntity.Value.GetTag(GAME_TAG.CURRENT_PLAYER) == 1 &&
!gameState.PlayerUsedHeroPower ||
opponentEntity.Value != null && opponentEntity.Value.GetTag(GAME_TAG.CURRENT_PLAYER) == 1 &&
!gameState.OpponentUsedHeroPower)
{
var card = GameV2.GetCardFromId(actionStartingCardId);
if (card.Type == "Hero Power")
{
if (playerEntity.Value != null && playerEntity.Value.GetTag(GAME_TAG.CURRENT_PLAYER) == 1)
{
gameState.GameHandler.HandlePlayerHeroPower(actionStartingCardId, gameState.GetTurnNumber());
gameState.PlayerUsedHeroPower = true;
}
else if (opponentEntity.Value != null)
{
gameState.GameHandler.HandleOpponentHeroPower(actionStartingCardId, gameState.GetTurnNumber());
gameState.OpponentUsedHeroPower = true;
}
}
}
}
}
}
else if (logLine.Contains("BlockType=JOUST"))
{
gameState.NextUpdatedEntityIsJoust = true;
}
}
