private void CreatePlayersLayout(RadDiagram diagram, HudDragCanvas dgCanvas, ReplayerViewModel viewModel)
{
var seats = (int)CurrentCapacity;
var positionProvider = ServiceLocator.Current.GetInstance <IPositionProvider>(ReplayerPokerSite.ToString());
var labelPositions = positionProvider.Positions[seats];
var hasHoleCards = viewModel.CurrentGame.Players.Any(x => x.hasHoleCards);
var cardsCount = hasHoleCards ? viewModel.CurrentGame.Players.Where(x => x.hasHoleCards).Max(x => x.HoleCards.Count) : 2;
for (var i = 0; i < seats; i++)
{
var player = viewModel.PlayersCollection[i];
var label = CreatePlayerLabel(player);
label.X = labelPositions[i, 0];
label.Y = labelPositions[i, 1];
PlaceCardLabels(diagram, label, cardsCount);
player.ChipsContainer.ChipsShape.X = predefinedChipsPositions[seats][i, 0];
player.ChipsContainer.ChipsShape.Y = predefinedChipsPositions[seats][i, 1];
AddPotPlayerLabel(diagram, viewModel.PlayersCollection[i], predefinedChipsPositions[seats][i, 0], predefinedChipsPositions[seats][i, 1]);
diagram.AddShape(label);
diagram.AddShape(player.ChipsContainer.ChipsShape);
}
}
private ReplayerHudPanel CreateHudPanel(ReplayerViewModel viewModel, int zeroBasedSeatNumber)
{
var player = viewModel.PlayersCollection[zeroBasedSeatNumber];
player.Parent = new HudElementViewModel {
Seat = zeroBasedSeatNumber
};
var panel = new ReplayerHudPanel
{
DataContext = player
};
panel.Height = double.NaN;
panel.Width = double.NaN;
var playerNotes = dataService.GetPlayerNotes(player.Name, viewModel.CurrentHand.PokersiteId);
player.NoteToolTip = NoteBuilder.BuildNote(playerNotes);
player.Parent.IsXRayNoteVisible = playerNotes.Any(x => x.IsAutoNote);
var contextMenu = CreateContextMenu(viewModel.CurrentHand.PokersiteId, player.Name, player);
contextMenu.EventName = "MouseRightButtonUp";
RadContextMenu.SetContextMenu(panel, contextMenu);
return(panel);
}
private void LoadPlayerHudStats(ReplayerPlayerViewModel replayerPlayer, ReplayerViewModel replayerViewModel, IList <StatInfo> statInfoCollection)
{
replayerPlayer.StatInfoCollection.Clear();
HudLightIndicators hudIndicators;
if (storageModel.PlayerSelectedItem.Name == replayerPlayer.Name &&
(short?)storageModel.PlayerSelectedItem.PokerSite == replayerViewModel.CurrentHand.PokersiteId)
{
hudIndicators = new HudLightIndicators(storageModel.GetStatisticCollection());
}
else
{
hudIndicators = new HudLightIndicators();
playerStatisticRepository
.GetPlayerStatistic(replayerPlayer.Name, replayerViewModel.CurrentHand.PokersiteId)
.ForEach(stat => hudIndicators.AddStatistic(stat));
}
if (hudIndicators != null)
{
var statList = new List <StatInfo>();
var counter = 0;
foreach (var selectedStatInfo in statInfoCollection)
{
if (selectedStatInfo is StatInfoBreak)
{
continue;
}
var statInfo = selectedStatInfo.Clone();
var propertyName = StatsProvider.GetStatProperyName(statInfo.Stat);
if (!string.IsNullOrWhiteSpace(propertyName))
{
statInfo.AssignStatInfoValues(hudIndicators, propertyName);
}
replayerPlayer.StatInfoCollection.Add(statInfo);
if ((counter + 1) % 4 == 0)
{
replayerPlayer.StatInfoCollection.Add(new StatInfoBreak());
}
counter++;
}
}
}
private void SaveHUDPositions(HudDragCanvas dgCanvas, ReplayerViewModel viewModel)
{
var layout = hudLayoutsService.GetLayout(viewModel.LayoutName);
if (layout == null)
{
LogProvider.Log.Warn($"Failed to save HUD positions. Could not find layout '{viewModel.LayoutName}'");
return;
}
try
{
var hudLayoutContract = new HudLayoutContract
{
LayoutName = viewModel.LayoutName,
GameType = EnumGameType.CashHoldem,
PokerSite = ReplayerPokerSite,
TableType = layout.TableType,
HudPositions = new List <HudPositionContract>()
};
// clone is needed
var toolViewModels = dgCanvas.Children.OfType <FrameworkElement>()
.Where(x => x != null && (x.DataContext is IHudNonPopupToolViewModel))
.Select(x => x.DataContext as HudBaseToolViewModel)
.Concat(EmptySeats
.SelectMany(x => x.Tools)
.OfType <IHudNonPopupToolViewModel>()
.Cast <HudBaseToolViewModel>());
foreach (var toolViewModel in toolViewModels)
{
var seatNumber = toolViewModel.Parent != null ? toolViewModel.Parent.Seat : 1;
var xPos = toolViewModel.OffsetX ?? toolViewModel.Position.X;
var yPos = toolViewModel.OffsetY ?? toolViewModel.Position.Y;
hudLayoutContract.HudPositions.Add(new HudPositionContract
{
Id = toolViewModel.Id,
Position = new Point(xPos, yPos),
SeatNumber = seatNumber
});
}
hudLayoutsService.Save(hudLayoutContract);
}
catch (Exception e)
{
LogProvider.Log.Error(this, "Failed to save HUD positions in replayer.", e);
}
}
private void LoadIndicators(int seats, ReplayerViewModel viewModel, IEnumerable <Stat> heatMapStats)
{
var tasksToLoad = new List <Task>();
var selectedPlayer = storageModel.PlayerSelectedItem;
var players = viewModel.PlayersCollection.Select(x => x.Name).ToArray();
for (var i = 0; i < seats; i++)
{
var player = players[i];
if (playerIndicators.ContainsKey(player))
{
continue;
}
var playerData = new HudIndicators(heatMapStats);
// read data from statistic
var taskToReadPlayerStats = Task.Run(() =>
{
if (selectedPlayer != null &&
player == selectedPlayer.Name &&
(short?)selectedPlayer.PokerSite == viewModel.CurrentHand.PokersiteId)
{
storageModel
.GetStatisticCollection()
.Where(stat => (stat.PokersiteId == (short)viewModel.CurrentGame.GameDescription.Site) &&
stat.IsTourney == viewModel.CurrentGame.GameDescription.IsTournament &&
GameTypeUtils.CompareGameType((GameType)stat.PokergametypeId, viewModel.CurrentGame.GameDescription.GameType))
.ForEach(stat => playerData.AddStatistic(stat));
playerIndicators.AddOrUpdate(player, playerData, (key, old) => playerData);
return;
}
playerStatisticRepository
.GetPlayerStatistic(player, (short)viewModel.CurrentGame.GameDescription.Site)
.Where(stat => (stat.PokersiteId == (short)viewModel.CurrentGame.GameDescription.Site) &&
stat.IsTourney == viewModel.CurrentGame.GameDescription.IsTournament &&
GameTypeUtils.CompareGameType((GameType)stat.PokergametypeId, viewModel.CurrentGame.GameDescription.GameType))
.ForEach(stat => playerData.AddStatistic(stat));
playerIndicators.AddOrUpdate(player, playerData, (key, old) => playerData);
});
tasksToLoad.Add(taskToReadPlayerStats);
}
Task.WhenAll(tasksToLoad).Wait();
}
private EnumReplayerTableType GetTableSize(ReplayerViewModel viewModel)
{
SeatType seatType = SeatType.FromMaxPlayers(viewModel.CurrentGame.GameDescription.SeatType.MaxPlayers, true);
if (seatType.MaxPlayers <= 6)
{
return(EnumReplayerTableType.Six);
}
if (seatType.MaxPlayers <= 9)
{
return(EnumReplayerTableType.Nine);
}
return(EnumReplayerTableType.Ten);
}
private void CreateCurrentPotValueLabel(RadDiagram diagram, ReplayerViewModel viewModel)
{
System.Windows.Controls.Label lbl = new System.Windows.Controls.Label();
Binding myBinding = new Binding(nameof(ReplayerViewModel.CurrentPotValue))
{
Source = viewModel, Mode = BindingMode.TwoWay, Converter = new DecimalToPotConverter(), ConverterParameter = "Pot {0:C2}"
};
lbl.SetBinding(ContentControl.ContentProperty, myBinding);
lbl.Background = Brushes.LightGray;
lbl.Foreground = Brushes.Black;
lbl.BorderBrush = Brushes.Black;
lbl.BorderThickness = new Thickness(1);
lbl.Padding = new Thickness(3, 3, 3, 3);
lbl.Margin = new Thickness(480, 315, 100, 100);
diagram.AddShape(lbl);
}
private void CreateTotalPotValueLabel(RadDiagram diagram, ReplayerViewModel viewModel)
{
System.Windows.Controls.Label lbl = new System.Windows.Controls.Label();
Binding myBinding = new Binding(nameof(ReplayerViewModel.TotalPotValue))
{
Source = viewModel, Mode = BindingMode.TwoWay, Converter = new DecimalToPotConverter(), ConverterParameter = "{0:C2}"
};
lbl.SetBinding(ContentControl.ContentProperty, myBinding);
lbl.Foreground = Brushes.White;
lbl.Margin = new Thickness(480, 100, 100, 100);
diagram.AddShape(lbl);
viewModel.TotalPotChipsContainer.ChipsShape.X = TotalPotChipsPosition.X;
viewModel.TotalPotChipsContainer.ChipsShape.Y = TotalPotChipsPosition.Y;
diagram.AddShape(viewModel.TotalPotChipsContainer.ChipsShape);
}
private void PlaceTableCardPanels(RadDiagram diagram, ReplayerViewModel viewModel)
{
double y = table.Y + table.Height / 2 - CARD_HEIGHT / 2.0 - 20;
double x = table.X + table.Width / 2 - CARD_WIDTH / 2.0 - 2 * CARD_WIDTH - 10;
for (int i = 0; i < viewModel.CommunityCards.Count; i++)
{
var card = CreateCardLabel(diagram, viewModel.CommunityCards[i]);
Street cardStreet = i < 3 ? Street.Flop : i < 4 ? Street.Turn : Street.River;
Binding myBinding = new Binding(ReflectionHelper.GetPath <ViewModels.Replayer.ReplayerViewModel>(o => o.CurrentStreet))
{
Source = viewModel, Mode = BindingMode.TwoWay, Converter = new StreetToVisibilityConverter(), ConverterParameter = cardStreet
};
card.SetBinding(UIElement.VisibilityProperty, myBinding);
card.X = x;
card.Y = y;
diagram.AddShape(card);
x = card.X + CARD_WIDTH + 5;
}
}
public void ConfigureTable(RadDiagram diagram, HudDragCanvas dgCanvas, ReplayerViewModel viewModel)
{
try
{
if (viewModel == null || viewModel.CurrentGame == null)
{
LogProvider.Log.Info("Cannot find handHistory");
return;
}
CurrentCapacity = GetTableSize(viewModel);
CreateTable(diagram);
CreatePlayersLayout(diagram, dgCanvas, viewModel);
CreateCurrentPotValueLabel(diagram, viewModel);
CreateTotalPotValueLabel(diagram, viewModel);
PlaceTableCardPanels(diagram, viewModel);
InitializeHUD(dgCanvas, viewModel);
}
catch (Exception e)
{
LogProvider.Log.Error(this, "ReplayerTable: Cannot configure table", e);
}
}
private void LoadHUD(HudDragCanvas dgCanvas, ReplayerViewModel viewModel, HudLayoutInfoV2 activeLayout)
{
var seats = (int)CurrentCapacity;
var hudPanelService = ServiceLocator.Current.GetInstance <IHudPanelService>(ReplayerPokerSite.ToString());
var nonToolLayoutStats = activeLayout
.HudPlayerTypes
.SelectMany(x => x.Stats)
.Select(x => x.Stat)
.Concat(activeLayout
.HudBumperStickerTypes
.SelectMany(x => x.Stats)
.Select(x => x.Stat))
.Concat(new[] { Stat.TotalHands })
.Distinct()
.ToArray();
var hudElements = new List <HudElementViewModel>();
var hudElementCreator = ServiceLocator.Current.GetInstance <IHudElementViewModelCreator>();
var hudElementCreationInfo = new HudElementViewModelCreationInfo
{
GameType = EnumGameType.CashHoldem,
HudLayoutInfo = activeLayout,
PokerSite = ReplayerPokerSite
};
for (var i = 0; i < seats; i++)
{
var replayerPlayer = viewModel.PlayersCollection[i];
hudElementCreationInfo.SeatNumber = i + 1;
if ((int)activeLayout.TableType < hudElementCreationInfo.SeatNumber)
{
continue;
}
var hudElement = hudElementCreator.Create(hudElementCreationInfo);
if (string.IsNullOrEmpty(replayerPlayer.Name))
{
if (hudElement != null)
{
EmptySeats.Add(hudElement);
}
continue;
}
var player = dataService.GetPlayer(replayerPlayer.Name, viewModel.CurrentHand.PokersiteId);
if (player == null)
{
if (hudElement != null)
{
EmptySeats.Add(hudElement);
}
continue;
}
if (hudElement == null ||
!playerIndicators.TryGetValue(replayerPlayer.Name, out HudIndicators playerData))
{
continue;
}
hudElement.PlayerId = player.PlayerId;
hudElement.PlayerName = replayerPlayer.Name;
hudElement.TotalHands = playerData.TotalHands;
var playerNotes = dataService.GetPlayerNotes(player.PlayerId);
hudElement.NoteToolTip = NoteBuilder.BuildNote(playerNotes);
hudElement.IsXRayNoteVisible = playerNotes.Any(x => x.IsAutoNote);
var graphTools = hudElement.Tools.OfType <HudGraphViewModel>().ToArray();
foreach (var graphTool in graphTools)
{
graphTool.StatSessionCollection = new ReactiveList <decimal>();
}
var heatMapTools = hudElement.Tools.OfType <HudHeatMapViewModel>()
.Concat(hudElement.Tools.OfType <HudGaugeIndicatorViewModel>()
.SelectMany(x => x.GroupedStats)
.SelectMany(x => x.Stats)
.Where(x => x.HeatMapViewModel != null)
.Select(x => x.HeatMapViewModel))
.ToArray();
heatMapTools.ForEach(x =>
{
var heatMapKey = playerData.HeatMaps.Keys
.ToArray()
.FirstOrDefault(p => p.Stat == x.BaseStat.Stat);
if (heatMapKey != null)
{
x.HeatMap = playerData.HeatMaps[heatMapKey];
}
});
var gaugeIndicatorTools = hudElement.Tools.OfType <HudGaugeIndicatorViewModel>().ToArray();
hudElement.SessionMoneyWonCollection = new ObservableCollection <decimal>();
var activeLayoutHudStats = hudElement.ToolsStatInfoCollection
.Concat(heatMapTools.Select(x => x.BaseStat))
.Concat(gaugeIndicatorTools.Select(x => x.BaseStat))
.ToList();
var extraStats = (from nonToolLayoutStat in nonToolLayoutStats
join activateLayoutHudStat in activeLayoutHudStats on nonToolLayoutStat equals activateLayoutHudStat.Stat into grouped
from extraStat in grouped.DefaultIfEmpty()
where extraStat == null
select new StatInfo
{
Stat = nonToolLayoutStat
}).ToArray();
activeLayoutHudStats.AddRange(extraStats);
StatsProvider.UpdateStats(activeLayoutHudStats);
foreach (var statInfo in activeLayoutHudStats)
{
var propertyName = StatsProvider.GetStatProperyName(statInfo.Stat);
if (!string.IsNullOrEmpty(propertyName))
{
if (playerData.TotalHands < statInfo.MinSample)
{
statInfo.IsNotVisible = true;
}
statInfo.AssignStatInfoValues(playerData, propertyName);
}
else if (!(statInfo is StatInfoBreak) && statInfo.Stat != Stat.PlayerInfoIcon)
{
continue;
}
}
hudElement.StatInfoCollection = activeLayoutHudStats;
var isNoteIconSet = false;
foreach (var toolViewModel in hudElement.Tools.Where(x => x is IHudNonPopupToolViewModel).ToArray())
{
if (!isNoteIconSet && toolViewModel is HudPlainStatBoxViewModel && !(toolViewModel is HudFourStatsBoxViewModel))
{
(toolViewModel as HudPlainStatBoxViewModel).IsNoteIconEnabled = true;
isNoteIconSet = true;
}
var panel = hudPanelService.Create(toolViewModel);
if (panel != null)
{
dgCanvas.Children.Add(panel);
Canvas.SetLeft(panel, toolViewModel.Position.X);
Canvas.SetTop(panel, toolViewModel.Position.Y);
}
}
hudElements.Add(hudElement);
}
hudLayoutsService.SetPlayerTypeIcon(hudElements, activeLayout);
}
private async void InitializeHUD(HudDragCanvas dgCanvas, ReplayerViewModel viewModel)
{
var gameNumber = viewModel.CurrentHand.GameNumber;
var pokerSite = viewModel.CurrentHand.PokersiteId;
ClearHUD(dgCanvas);
viewModel.IsLoadingHUD = true;
var seats = (int)CurrentCapacity;
var tableType = (EnumTableType)viewModel.CurrentGame.GameDescription.SeatType.MaxPlayers;
// need to add DriveHUDReplayer to sites, add provider, panel service etc.
var activeLayout = hudLayoutsService.GetActiveLayout(ReplayerPokerSite,
tableType,
EnumGameType.CashHoldem);
viewModel.LayoutName = activeLayout.Name;
viewModel.LayoutsCollection = new ObservableCollection <string>(hudLayoutsService.GetAvailableLayouts(tableType));
viewModel.LoadLayoutCommand = new RelayCommand(obj =>
{
try
{
var layoutName = obj?.ToString();
if (string.IsNullOrWhiteSpace(layoutName))
{
return;
}
viewModel.LayoutName = layoutName;
var layout = hudLayoutsService.GetLayout(layoutName);
var layoutHeatMapStats = new HashSet <Stat>(layout.GetHeatMapStats());
// there are no loaded heat map stats
if (layoutHeatMapStats.Count > 0 &&
layoutHeatMapStats.Any(x => !heatMapStats.Contains(x)))
{
viewModel.IsLoadingHUD = true;
playerIndicators.Clear();
LoadIndicators(seats, viewModel, layoutHeatMapStats);
heatMapStats = layoutHeatMapStats;
viewModel.IsLoadingHUD = false;
}
ClearHUD(dgCanvas);
LoadHUD(dgCanvas, viewModel, layout);
hudLayoutsService.SetActiveLayout(layout, ReplayerPokerSite, EnumGameType.CashHoldem, tableType);
}
catch (Exception e)
{
LogProvider.Log.Error(this, "Failed to load layout", e);
}
});
viewModel.SaveHUDPositionsCommand = new RelayCommand(obj => SaveHUDPositions(dgCanvas, viewModel));
viewModel.RotateHUDToLeftCommand = new RelayCommand(() => RotateHUD(false, tableType, dgCanvas));
viewModel.RotateHUDToRightCommand = new RelayCommand(() => RotateHUD(true, tableType, dgCanvas));
heatMapStats = new HashSet <Stat>(activeLayout.GetHeatMapStats());
await Task.Run(() => LoadIndicators(seats, viewModel, heatMapStats));
if (gameNumber != viewModel.CurrentHand.GameNumber ||
pokerSite != viewModel.CurrentHand.PokersiteId)
{
return;
}
LoadHUD(dgCanvas, viewModel, activeLayout);
viewModel.IsLoadingHUD = false;
}
