private void DataGridKeyPoints_OnSelectedCellsChanged(object sender, SelectedCellsChangedEventArgs e)
{
var selected = ((DataGrid)sender).SelectedItem as TurnViewItem;
if (selected == null || selected.KeyPoint == null)
{
return;
}
_currentGameState = selected.KeyPoint;
Update();
}
private void TreeViewKeyPoints_OnSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
var selected = ((TreeView)sender).SelectedItem as ReplayKeyPoint;
if (selected == null)
{
return;
}
_currentGameState = selected;
Update();
}
public void Load(List <ReplayKeyPoint> replay)
{
if (replay == null || replay.Count == 0)
{
return;
}
Replay = replay;
_currentGameState = Replay[0];
_playerController = PlayerEntity.GetTag(GAME_TAG.CONTROLLER);
_opponentController = OpponentEntity.GetTag(GAME_TAG.CONTROLLER);
_treeViewTurnItems = new List <TreeViewItem>();
foreach (var kp in Replay)
{
var tvItem = _treeViewTurnItems.FirstOrDefault(x => (string)x.Header == "Turn " + kp.Turn);
if (tvItem == null)
{
tvItem = new TreeViewItem {
Header = "Turn " + kp.Turn, IsExpanded = true
};
_treeViewTurnItems.Add(tvItem);
}
var entity = kp.Data.FirstOrDefault(x => x.Id == kp.Id);
if (entity == null || string.IsNullOrEmpty(entity.CardId))
{
continue;
}
if (kp.Type == KeyPointType.Summon && entity.GetTag(GAME_TAG.CARDTYPE) == (int)TAG_CARDTYPE.ENCHANTMENT)
{
continue;
}
tvItem.Items.Add(kp);
}
foreach (var tvi in _treeViewTurnItems)
{
TreeViewKeyPoints.Items.Add(tvi);
}
DataContext = this;
}
public void Load(List <ReplayKeyPoint> replay)
{
if (replay == null || replay.Count == 0)
{
return;
}
var selectedKeypoint = DataGridKeyPoints.SelectedItem as TurnViewItem;
DataGridKeyPoints.Items.Clear();
Replay = replay;
_currentGameState = Replay.FirstOrDefault(r => r.Data.Any(x => x.HasTag(GAME_TAG.PLAYER_ID)));
if (_currentGameState == null)
{
Logger.WriteLine("Error loading replay. No player entity found.");
return;
}
_playerController = PlayerEntity.GetTag(GAME_TAG.CONTROLLER);
_opponentController = OpponentEntity.GetTag(GAME_TAG.CONTROLLER);
var currentTurn = -1;
TurnViewItem tvi = null;
foreach (var kp in Replay)
{
var entity = kp.Data.FirstOrDefault(x => x.Id == kp.Id);
if (entity == null || (string.IsNullOrEmpty(entity.CardId) && kp.Type != KeyPointType.Victory && kp.Type != KeyPointType.Defeat))
{
continue;
}
if (kp.Type == KeyPointType.Summon && entity.GetTag(GAME_TAG.CARDTYPE) == (int)TAG_CARDTYPE.ENCHANTMENT)
{
continue;
}
var turn = (kp.Turn + 1) / 2;
if (turn == 1)
{
if (!kp.Data.Any(x => x.HasTag(GAME_TAG.PLAYER_ID) && x.GetTag(GAME_TAG.RESOURCES) == 1))
{
turn = 0;
}
}
if (turn > currentTurn)
{
currentTurn = turn;
if (tvi != null && tvi.IsTurnRow && tvi.Turn.HasValue && !_collapsedTurns.Contains(tvi.Turn.Value))
{
DataGridKeyPoints.Items.Remove(tvi); //remove empty turns
}
tvi = new TurnViewItem {
Turn = turn, IsCollapsed = _collapsedTurns.Contains(turn), ShowAll = _showAllTurns.Contains(turn)
};
DataGridKeyPoints.Items.Add(tvi);
}
if (!_showAllTurns.Contains(turn))
{
switch (kp.Type)
{
case KeyPointType.Attack:
if (!Config.Instance.ReplayViewerShowAttack)
{
continue;
}
break;
case KeyPointType.Death:
if (!Config.Instance.ReplayViewerShowDeath)
{
continue;
}
break;
case KeyPointType.Mulligan:
case KeyPointType.DeckDiscard:
case KeyPointType.HandDiscard:
if (!Config.Instance.ReplayViewerShowDiscard)
{
continue;
}
break;
case KeyPointType.Draw:
case KeyPointType.Obtain:
case KeyPointType.PlayToDeck:
case KeyPointType.PlayToHand:
if (!Config.Instance.ReplayViewerShowDraw)
{
continue;
}
break;
case KeyPointType.HeroPower:
if (!Config.Instance.ReplayViewerShowHeroPower)
{
continue;
}
break;
case KeyPointType.SecretStolen:
case KeyPointType.SecretTriggered:
if (!Config.Instance.ReplayViewerShowSecret)
{
continue;
}
break;
case KeyPointType.Play:
case KeyPointType.PlaySpell:
case KeyPointType.SecretPlayed:
if (!Config.Instance.ReplayViewerShowPlay)
{
continue;
}
break;
case KeyPointType.Summon:
if (!Config.Instance.ReplayViewerShowSummon)
{
continue;
}
break;
}
}
if (_collapsedTurns.Contains(turn))
{
continue;
}
tvi = new TurnViewItem();
if (kp.Player == ActivePlayer.Player)
{
tvi.PlayerAction = kp.Type.ToString();
tvi.AdditionalInfoPlayer = kp.GetAdditionalInfo();
}
else
{
tvi.OpponentAction = kp.Type.ToString();
tvi.AdditionalInfoOpponent = kp.GetAdditionalInfo();
}
tvi.KeyPoint = kp;
DataGridKeyPoints.Items.Add(tvi);
}
if (selectedKeypoint != null)
{
var newSelection = selectedKeypoint.Turn.HasValue
? DataGridKeyPoints.Items.Cast <TurnViewItem>()
.FirstOrDefault(x => x.Turn.HasValue && x.Turn.Value == selectedKeypoint.Turn.Value)
: DataGridKeyPoints.Items.Cast <TurnViewItem>().FirstOrDefault(x => x.KeyPoint == selectedKeypoint.KeyPoint);
if (newSelection != null)
{
DataGridKeyPoints.SelectedItem = newSelection;
DataGridKeyPoints.ScrollIntoView(newSelection);
var index = DataGridKeyPoints.Items.IndexOf(newSelection);
DataGridRow dgrow = (DataGridRow)DataGridKeyPoints.ItemContainerGenerator.ContainerFromItem(DataGridKeyPoints.Items[index]);
dgrow.MoveFocus(new TraversalRequest(FocusNavigationDirection.Up));
}
}
DataContext = this;
}
public void ProposeKeyPoint(KeyPointType type, int id, ActivePlayer player)
{
if (ProposedKeyPoint != null)
ReplayMaker.Generate(ProposedKeyPoint.Type, ProposedKeyPoint.Id, ProposedKeyPoint.Player, _game);
ProposedKeyPoint = new ReplayKeyPoint(null, type, id, player);
}
private void TagChange(string rawTag, int id, string rawValue, bool isRecursive = false)
{
if(_lastId != id)
{
Game.SecondToLastUsedId = _lastId;
if(_proposedKeyPoint != null)
{
ReplayMaker.Generate(_proposedKeyPoint.Type, _proposedKeyPoint.Id, _proposedKeyPoint.Player);
_proposedKeyPoint = null;
}
}
_lastId = id;
if(!Game.Entities.ContainsKey(id))
Game.Entities.Add(id, new Entity(id));
GAME_TAG tag;
if(!Enum.TryParse(rawTag, out tag))
{
int tmp;
if(int.TryParse(rawTag, out tmp) && Enum.IsDefined(typeof(GAME_TAG), tmp))
tag = (GAME_TAG)tmp;
}
var value = ParseTagValue(tag, rawValue);
var prevZone = Game.Entities[id].GetTag(GAME_TAG.ZONE);
Game.Entities[id].SetTag(tag, value);
if(tag == GAME_TAG.CONTROLLER && _waitForController != null && Game.PlayerId == -1)
{
var p1 = Game.Entities.FirstOrDefault(e => e.Value.GetTag(GAME_TAG.PLAYER_ID) == 1).Value;
var p2 = Game.Entities.FirstOrDefault(e => e.Value.GetTag(GAME_TAG.PLAYER_ID) == 2).Value;
if(_currentEntityHasCardId)
{
if(p1 != null)
p1.IsPlayer = value == 1;
if(p2 != null)
p2.IsPlayer = value != 1;
Game.PlayerId = value;
Game.OpponentId = value == 1 ? 2 : 1;
}
else
{
if(p1 != null)
p1.IsPlayer = value != 1;
if(p2 != null)
p2.IsPlayer = value == 1;
Game.PlayerId = value == 1 ? 2 : 1;
Game.OpponentId = value;
}
}
var controller = Game.Entities[id].GetTag(GAME_TAG.CONTROLLER);
var player = Game.Entities[id].HasTag(GAME_TAG.CONTROLLER) ? (controller == Game.PlayerId ? "FRIENDLY" : "OPPOSING") : "";
var cardId = Game.Entities[id].CardId;
if(tag == GAME_TAG.ZONE)
{
//Logger.WriteLine("--------" + player + " " + Game.Entities[id].CardId + " " + (TAG_ZONE)prevZone + " -> " +
// (TAG_ZONE)value);
if(((TAG_ZONE)value == TAG_ZONE.HAND || ((TAG_ZONE)value == TAG_ZONE.PLAY) && Game.IsMulliganDone) && _waitForController == null)
{
if(!Game.IsMulliganDone)
prevZone = (int)TAG_ZONE.DECK;
if(controller == 0)
{
Game.Entities[id].SetTag(GAME_TAG.ZONE, prevZone);
_waitForController = new {Tag = rawTag, Id = id, Value = rawValue};
//Logger.WriteLine("CURRENTLY NO CONTROLLER SET FOR CARD, WAITING...");
return;
}
}
switch((TAG_ZONE)prevZone)
{
case TAG_ZONE.DECK:
switch((TAG_ZONE)value)
{
case TAG_ZONE.HAND:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerDraw(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.Draw, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentDraw(GetTurnNumber());
ProposeKeyPoint(KeyPointType.Draw, id, ActivePlayer.Opponent);
}
break;
case TAG_ZONE.REMOVEDFROMGAME:
case TAG_ZONE.GRAVEYARD:
case TAG_ZONE.SETASIDE:
case TAG_ZONE.PLAY:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerDeckDiscard(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.DeckDiscard, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentDeckDiscard(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.DeckDiscard, id, ActivePlayer.Opponent);
}
break;
case TAG_ZONE.SECRET:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerSecretPlayed(cardId, GetTurnNumber(), true);
ProposeKeyPoint(KeyPointType.SecretPlayed, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentSecretPlayed(cardId, -1, GetTurnNumber(), true, id);
ProposeKeyPoint(KeyPointType.SecretPlayed, id, ActivePlayer.Player);
}
break;
}
break;
case TAG_ZONE.HAND:
switch((TAG_ZONE)value)
{
case TAG_ZONE.PLAY:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerPlay(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.Play, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentPlay(cardId, Game.Entities[id].GetTag(GAME_TAG.ZONE_POSITION), GetTurnNumber());
ProposeKeyPoint(KeyPointType.Play, id, ActivePlayer.Opponent);
}
break;
case TAG_ZONE.REMOVEDFROMGAME:
case TAG_ZONE.GRAVEYARD:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerHandDiscard(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.HandDiscard, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentHandDiscard(cardId, Game.Entities[id].GetTag(GAME_TAG.ZONE_POSITION), GetTurnNumber());
ProposeKeyPoint(KeyPointType.HandDiscard, id, ActivePlayer.Opponent);
}
break;
case TAG_ZONE.SECRET:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerSecretPlayed(cardId, GetTurnNumber(), false);
ProposeKeyPoint(KeyPointType.SecretPlayed, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentSecretPlayed(cardId, Game.Entities[id].GetTag(GAME_TAG.ZONE_POSITION), GetTurnNumber(), false, id);
ProposeKeyPoint(KeyPointType.SecretPlayed, id, ActivePlayer.Opponent);
}
break;
case TAG_ZONE.DECK:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerMulligan(cardId);
ProposeKeyPoint(KeyPointType.Mulligan, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentMulligan(Game.Entities[id].GetTag(GAME_TAG.ZONE_POSITION));
ProposeKeyPoint(KeyPointType.Mulligan, id, ActivePlayer.Opponent);
}
break;
}
break;
case TAG_ZONE.PLAY:
switch((TAG_ZONE)value)
{
case TAG_ZONE.HAND:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerBackToHand(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.PlayToHand, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentPlayToHand(cardId, GetTurnNumber(), id);
ProposeKeyPoint(KeyPointType.PlayToHand, id, ActivePlayer.Opponent);
}
break;
case TAG_ZONE.DECK:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerPlayToDeck(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.PlayToDeck, id, ActivePlayer.Player);
}
else if (controller == Game.OpponentId)
{
_gameHandler.HandleOpponentPlayToDeck(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.PlayToDeck, id, ActivePlayer.Opponent);
}
break;
case TAG_ZONE.GRAVEYARD:
if(Game.Entities[id].HasTag(GAME_TAG.HEALTH))
{
if(controller == Game.PlayerId)
ProposeKeyPoint(KeyPointType.Death, id, ActivePlayer.Player);
else if(controller == Game.OpponentId)
ProposeKeyPoint(KeyPointType.Death, id, ActivePlayer.Opponent);
}
break;
}
break;
case TAG_ZONE.SECRET:
switch((TAG_ZONE)value)
{
case TAG_ZONE.SECRET:
case TAG_ZONE.GRAVEYARD:
if(controller == Game.PlayerId)
ProposeKeyPoint(KeyPointType.SecretTriggered, id, ActivePlayer.Player);
if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentSecretTrigger(cardId, GetTurnNumber(), id);
ProposeKeyPoint(KeyPointType.SecretTriggered, id, ActivePlayer.Opponent);
}
break;
}
break;
case TAG_ZONE.GRAVEYARD:
case TAG_ZONE.SETASIDE:
case TAG_ZONE.CREATED:
case TAG_ZONE.INVALID:
case TAG_ZONE.REMOVEDFROMGAME:
switch((TAG_ZONE)value)
{
case TAG_ZONE.PLAY:
if(controller == Game.PlayerId)
ProposeKeyPoint(KeyPointType.Summon, id, ActivePlayer.Player);
if(controller == Game.OpponentId)
ProposeKeyPoint(KeyPointType.Summon, id, ActivePlayer.Opponent);
break;
case TAG_ZONE.HAND:
if(controller == Game.PlayerId)
{
_gameHandler.HandlePlayerGet(cardId, GetTurnNumber());
ProposeKeyPoint(KeyPointType.Obtain, id, ActivePlayer.Player);
}
else if(controller == Game.OpponentId)
{
_gameHandler.HandleOpponentGet(GetTurnNumber(), id);
ProposeKeyPoint(KeyPointType.Obtain, id, ActivePlayer.Opponent);
}
break;
}
break;
}
}
else if(tag == GAME_TAG.PLAYSTATE)
{
if(value == (int)TAG_PLAYSTATE.QUIT)
_gameHandler.HandleConcede();
if(!_gameEnded)
{
if(Game.Entities[id].IsPlayer)
{
if(value == (int)TAG_PLAYSTATE.WON)
{
GameEndKeyPoint(true, id);
_gameHandler.HandleWin();
_gameHandler.HandleGameEnd();
_gameEnded = true;
}
else if(value == (int)TAG_PLAYSTATE.LOST)
{
GameEndKeyPoint(false, id);
_gameHandler.HandleLoss();
_gameHandler.HandleGameEnd();
_gameEnded = true;
}
else if(value == (int)TAG_PLAYSTATE.TIED)
{
GameEndKeyPoint(false, id);
_gameHandler.HandleTied();
_gameHandler.HandleGameEnd();
}
}
}
}
else if(tag == GAME_TAG.CURRENT_PLAYER && value == 1)
{
var activePlayer = Game.Entities[id].IsPlayer ? ActivePlayer.Player : ActivePlayer.Opponent;
_gameHandler.TurnStart(activePlayer, GetTurnNumber());
if(activePlayer == ActivePlayer.Player)
_playerUsedHeroPower = false;
else
_opponentUsedHeroPower = false;
}
else if(tag == GAME_TAG.NUM_ATTACKS_THIS_TURN && value > 0)
{
if(controller == Game.PlayerId)
ProposeKeyPoint(KeyPointType.Attack, id, ActivePlayer.Player);
else if(controller == Game.OpponentId)
ProposeKeyPoint(KeyPointType.Attack, id, ActivePlayer.Opponent);
}
else if(tag == GAME_TAG.ZONE_POSITION)
{
var zone = Game.Entities[id].GetTag(GAME_TAG.ZONE);
if(zone == (int)TAG_ZONE.HAND)
{
if(controller == Game.PlayerId)
ReplayMaker.Generate(KeyPointType.HandPos, id, ActivePlayer.Player);
else if(controller == Game.OpponentId)
ReplayMaker.Generate(KeyPointType.HandPos, id, ActivePlayer.Opponent);
}
else if(zone == (int)TAG_ZONE.PLAY)
{
if(controller == Game.PlayerId)
ReplayMaker.Generate(KeyPointType.BoardPos, id, ActivePlayer.Player);
else if(controller == Game.OpponentId)
ReplayMaker.Generate(KeyPointType.BoardPos, id, ActivePlayer.Opponent);
}
}
else if(tag == GAME_TAG.CARD_TARGET && value > 0)
{
if(controller == Game.PlayerId)
ProposeKeyPoint(KeyPointType.PlaySpell, id, ActivePlayer.Player);
else if(controller == Game.OpponentId)
ProposeKeyPoint(KeyPointType.PlaySpell, id, ActivePlayer.Opponent);
}
else if(tag == GAME_TAG.EQUIPPED_WEAPON && value == 0)
{
if(controller == Game.PlayerId)
ProposeKeyPoint(KeyPointType.WeaponDestroyed, id, ActivePlayer.Player);
else if(controller == Game.OpponentId)
ProposeKeyPoint(KeyPointType.WeaponDestroyed, id, ActivePlayer.Opponent);
}
else if(tag == GAME_TAG.EXHAUSTED && value > 0)
{
if(Game.Entities[id].GetTag(GAME_TAG.CARDTYPE) == (int)TAG_CARDTYPE.HERO_POWER)
{
if(controller == Game.PlayerId)
ProposeKeyPoint(KeyPointType.HeroPower, id, ActivePlayer.Player);
else if(controller == Game.OpponentId)
ProposeKeyPoint(KeyPointType.HeroPower, id, ActivePlayer.Opponent);
}
}
else if(tag == GAME_TAG.CONTROLLER && Game.Entities[id].IsInZone(TAG_ZONE.SECRET))
{
if(value == Game.PlayerId)
{
_gameHandler.HandleOpponentSecretTrigger(cardId, GetTurnNumber(), id);
ProposeKeyPoint(KeyPointType.SecretStolen, id, ActivePlayer.Player);
}
else if(value == Game.OpponentId)
ProposeKeyPoint(KeyPointType.SecretStolen, id, ActivePlayer.Player);
}
else if(tag == GAME_TAG.FATIGUE)
{
if(controller == Game.PlayerId)
_gameHandler.HandlePlayerFatigue(Convert.ToInt32(rawValue));
else if(controller == Game.OpponentId)
_gameHandler.HandleOpponentFatigue(Convert.ToInt32(rawValue));
}
if(_waitForController != null)
{
if(!isRecursive)
{
TagChange((string)_waitForController.Tag, (int)_waitForController.Id, (string)_waitForController.Value, true);
_waitForController = null;
}
}
}
private void ProposeKeyPoint(KeyPointType type, int id, ActivePlayer player)
{
if(_proposedKeyPoint != null)
ReplayMaker.Generate(_proposedKeyPoint.Type, _proposedKeyPoint.Id, _proposedKeyPoint.Player);
_proposedKeyPoint = new ReplayKeyPoint(null, type, id, player);
}
private void GameEndKeyPoint(bool victory, int id)
{
if(_proposedKeyPoint != null)
{
ReplayMaker.Generate(_proposedKeyPoint.Type, _proposedKeyPoint.Id, _proposedKeyPoint.Player);
_proposedKeyPoint = null;
}
ReplayMaker.Generate(victory ? KeyPointType.Victory : KeyPointType.Defeat, id, ActivePlayer.Player);
}
private void DataGridKeyPoints_OnSelectedCellsChanged(object sender, SelectedCellsChangedEventArgs e)
{
var selected = ((DataGrid)sender).SelectedItem as TurnViewItem;
if(selected == null || selected.KeyPoint == null)
return;
_currentGameState = selected.KeyPoint;
Update();
}
public void Load(List<ReplayKeyPoint> replay)
{
if(replay == null || replay.Count == 0)
return;
var selectedKeypoint = DataGridKeyPoints.SelectedItem as TurnViewItem;
DataGridKeyPoints.Items.Clear();
Replay = replay;
_currentGameState = Replay.FirstOrDefault(r => r.Data.Any(x => x.HasTag(GAME_TAG.PLAYER_ID)));
if(_currentGameState == null)
{
Logger.WriteLine("Error loading replay. No player entity found.");
return;
}
_playerController = PlayerEntity.GetTag(GAME_TAG.CONTROLLER);
_opponentController = OpponentEntity.GetTag(GAME_TAG.CONTROLLER);
var currentTurn = -1;
TurnViewItem tvi = null;
foreach(var kp in Replay)
{
var entity = kp.Data.FirstOrDefault(x => x.Id == kp.Id);
if(entity == null || (string.IsNullOrEmpty(entity.CardId) && kp.Type != KeyPointType.Victory && kp.Type != KeyPointType.Defeat))
continue;
if(kp.Type == KeyPointType.Summon && entity.GetTag(GAME_TAG.CARDTYPE) == (int)TAG_CARDTYPE.ENCHANTMENT)
continue;
var turn = (kp.Turn + 1) / 2;
if(turn == 1)
{
if(!kp.Data.Any(x => x.HasTag(GAME_TAG.PLAYER_ID) && x.GetTag(GAME_TAG.RESOURCES) == 1))
turn = 0;
}
if(turn > currentTurn)
{
currentTurn = turn;
if(tvi != null && tvi.IsTurnRow && tvi.Turn.HasValue && !_collapsedTurns.Contains(tvi.Turn.Value))
DataGridKeyPoints.Items.Remove(tvi); //remove empty turns
tvi = new TurnViewItem {Turn = turn, IsCollapsed = _collapsedTurns.Contains(turn), ShowAll = _showAllTurns.Contains(turn)};
DataGridKeyPoints.Items.Add(tvi);
}
if(!_showAllTurns.Contains(turn))
{
switch(kp.Type)
{
case KeyPointType.Attack:
if(!Config.Instance.ReplayViewerShowAttack)
continue;
break;
case KeyPointType.Death:
if(!Config.Instance.ReplayViewerShowDeath)
continue;
break;
case KeyPointType.Mulligan:
case KeyPointType.DeckDiscard:
case KeyPointType.HandDiscard:
if(!Config.Instance.ReplayViewerShowDiscard)
continue;
break;
case KeyPointType.Draw:
case KeyPointType.Obtain:
case KeyPointType.PlayToDeck:
case KeyPointType.PlayToHand:
if(!Config.Instance.ReplayViewerShowDraw)
continue;
break;
case KeyPointType.HeroPower:
if(!Config.Instance.ReplayViewerShowHeroPower)
continue;
break;
case KeyPointType.SecretStolen:
case KeyPointType.SecretTriggered:
if(!Config.Instance.ReplayViewerShowSecret)
continue;
break;
case KeyPointType.Play:
case KeyPointType.PlaySpell:
case KeyPointType.SecretPlayed:
if(!Config.Instance.ReplayViewerShowPlay)
continue;
break;
case KeyPointType.Summon:
if(!Config.Instance.ReplayViewerShowSummon)
continue;
break;
}
}
if(_collapsedTurns.Contains(turn))
continue;
tvi = new TurnViewItem();
if(kp.Player == ActivePlayer.Player)
{
tvi.PlayerAction = kp.Type.ToString();
tvi.AdditionalInfoPlayer = kp.GetAdditionalInfo();
}
else
{
tvi.OpponentAction = kp.Type.ToString();
tvi.AdditionalInfoOpponent = kp.GetAdditionalInfo();
}
tvi.KeyPoint = kp;
DataGridKeyPoints.Items.Add(tvi);
}
if(selectedKeypoint != null)
{
var newSelection = selectedKeypoint.Turn.HasValue
? DataGridKeyPoints.Items.Cast<TurnViewItem>()
.FirstOrDefault(x => x.Turn.HasValue && x.Turn.Value == selectedKeypoint.Turn.Value)
: DataGridKeyPoints.Items.Cast<TurnViewItem>().FirstOrDefault(x => x.KeyPoint == selectedKeypoint.KeyPoint);
if(newSelection != null)
{
DataGridKeyPoints.SelectedItem = newSelection;
DataGridKeyPoints.ScrollIntoView(newSelection);
var index = DataGridKeyPoints.Items.IndexOf(newSelection);
DataGridRow dgrow = (DataGridRow)DataGridKeyPoints.ItemContainerGenerator.ContainerFromItem(DataGridKeyPoints.Items[index]);
dgrow.MoveFocus(new TraversalRequest(FocusNavigationDirection.Up));
}
}
DataContext = this;
}
public void LoadNoUI(List<ReplayKeyPoint> replay)
{
if (replay == null || replay.Count == 0)
return;
Replay = replay;
_currentGameState = Replay.FirstOrDefault(r => r.Data.Any(x => x.HasTag(PLAYER_ID)));
if (_currentGameState == null)
{
Log.Error("No player entity found.");
return;
}
_playerController = PlayerEntity.GetTag(CONTROLLER);
_opponentController = OpponentEntity.GetTag(CONTROLLER);
}
