private void ToStreet(object obj)
{
if (obj == null)
{
return;
}
StopTimer(null);
if (Enum.TryParse(obj.ToString(), out Street outStreet))
{
var streetState = TableStateList.FirstOrDefault(x => x.CurrentStreet == outStreet);
if (streetState != null)
{
if (outStreet <= Street.Preflop)
{
PlayersCollection.Where(x => x.IsFinished && TableStateList.Any(t => t.ActivePlayer.Name == x.Name)).ForEach(x => x.IsFinished = false);
}
StateIndex = TableStateList.IndexOf(streetState);
UpdatePlayersEquityWin(TableStateList.FirstOrDefault(x => x.CurrentStreet == outStreet)); //update equity win property of all players
}
}
}
private void RefreshBoard(decimal[] equities, Street street)
{
foreach (ReplayerTableState replayerTableState in TableStateList.Where(st => st.CurrentStreet == street))
{
try
{
_playerInState = PlayersCollection.FirstOrDefault(u => u.Name == replayerTableState.CurrentAction.PlayerName);
if (_playerInState != null &&
ActivePlayerHasHoleCard.FirstOrDefault(x => x.PlayerName == replayerTableState.CurrentAction.PlayerName) != null &&
replayerTableState.CurrentAction != null &&
ActivePlayerHasHoleCard.Count > 1)
{
replayerTableState.ActivePlayer.EquityWin = equities[ActivePlayerHasHoleCard.IndexOf(ActivePlayerHasHoleCard.FirstOrDefault(x => x.PlayerName == replayerTableState.CurrentAction.PlayerName))];
}
else
{
replayerTableState.ActivePlayer.EquityWin = -1;
}
ReplayerPlayerViewModel.CopyEquityWin(replayerTableState.ActivePlayer, _playerInState);
}
catch (Exception ex)
{
LogProvider.Log.Error(typeof(Converter), $"Player with name '{replayerTableState.CurrentAction.PlayerName}' has not been found in PlayerCollection in method RefreshBoard in ReplayerViewModel class", ex);
}
}
}
private void ToStart(object obj)
{
StopTimer(null);
PlayersCollection.Where(x => x.IsFinished && TableStateList.Any(t => t.ActivePlayer.Name == x.Name)).ForEach(x => x.IsFinished = false);
StateIndex = 0;
}
public async Task CreatePlayer(Player player)
{
try
{
await PlayersCollection.InsertOneAsync(player);
}
catch (Exception e)
{
logger.Error(e, "Failed to create player {0}.", player.Id);
}
}
private void ToEnd(object obj)
{
StopTimer(null);
ResetPlayersPot(PlayersCollection);
PlayersCollection.Where(x => !x.IsFinished && TableStateList.Any(t => t.ActivePlayer.Name == x.Name && t.ActivePlayer.IsFinished)).ForEach(x => x.IsFinished = true);
StateIndex = TableStateList.Count - 1;
ReplayerTableState replayerTableStateBeforeSummary = TableStateList.FirstOrDefault(x => x.CurrentStreet == Street.Summary);
UpdatePlayersEquityWin(replayerTableStateBeforeSummary); //added in order to update equity state for winning actions when we go to the end of TableStateList
}
public async Task UpdatePlayer(Player player)
{
try
{
var builder = Builders <Player> .Filter;
var filter = builder.Eq(e => e.Id, player.Id);
await PlayersCollection.ReplaceOneAsync(filter, player);
}
catch (Exception e)
{
logger.Error(e, "Failed to save player {0}.", player.Id);
}
}
//public void SelectedPlayers()
//{
// _mvxMessenger.Publish<SelectedPlayersMessage>(new SelectedPlayersMessage(this, PlayersCollection));
//}
void SelectedPlayer(PlayerViewModel player)
{
player.IsSelected = !player.IsSelected;
if (PlayersCollection.Where(p => p.IsSelected).Count() > 0)
{
IsPlayerSelected = true;
Title = string.Format("{0} selected", PlayersCollection.Where(p => p.IsSelected).Count());
}
else
{
IsPlayerSelected = false;
Title = "Players";
}
}
public async Task <Player> GetPlayer(Guid playerId)
{
try
{
var builder = Builders <Player> .Filter;
var filter = builder.Eq(e => e.Id, playerId);
return(await PlayersCollection.Find(filter).FirstOrDefaultAsync());
}
catch (Exception e)
{
logger.Error(e, "Failed to get player {0}.", playerId);
return(null);
}
}
public async Task <List <Player> > GetAccountPlayers(ulong steamId, int worldServerIdentifier = 101)
{
try
{
var builder = Builders <Player> .Filter;
var filter = builder.Eq(e => e.SteamId, steamId) & builder.Eq(e => e.WorldServerIdentifier, worldServerIdentifier);
return(await PlayersCollection.Find(filter).ToListAsync());
}
catch (Exception e)
{
logger.Error(e, "Failed to get account players for {0}:{1}.", steamId, worldServerIdentifier);
return(new List <Player>());
}
}
private ReplayerPlayerViewModel GetActivePlayerForState(ReplayerTableState state)
{
if (state.ActivePlayer == null)
{
return(null);
}
var activePlayer = PlayersCollection.FirstOrDefault(x => x.Name == state.ActivePlayer.Name);
if (activePlayer != null)
{
ReplayerPlayerViewModel.Copy(state.ActivePlayer, activePlayer);
}
return(activePlayer);
}
private void LoadState(int stateIndex)
{
if (stateIndex < 0 || stateIndex >= TableStateList.Count)
{
return;
}
bool isBackward = stateIndex < StateIndex;
bool isRefreshPlayersRequired = Math.Abs(stateIndex - StateIndex) > 1;
ReplayerTableState state = TableStateList[stateIndex];
UpdatePlayersEquityWin(state);
CurrentStreet = state.CurrentStreet;
CurrentPotValue = state.CurrentPotValue;
UpdateTotalPot(state.TotalPotValue);
if (!IsShowHoleCards)
{
ProcessPlayersCards();
}
ResetLastActivePlayer(isBackward);
if (isRefreshPlayersRequired)
{
UpdatePlayersToState(state);
}
if (state.IsStreetChangedAction)
{
ResetPlayersPot(PlayersCollection);
return;
}
var activePlayer = GetActivePlayerForState(state);
if (activePlayer != null)
{
if (activePlayer.IsWin)
{
ResetPlayersPot(PlayersCollection.AsQueryable().Where(x => x != activePlayer));
}
activePlayer.UpdateChips();
}
}
private void ResetLastActivePlayer(bool resetChipsToPreviousState = false)
{
var prevActive = PlayersCollection.FirstOrDefault(x => x.IsActive);
if (prevActive != null)
{
prevActive.IsActive = false;
prevActive.ActionString = string.Empty;
if (resetChipsToPreviousState)
{
prevActive.Bank = prevActive.OldBank;
prevActive.ActiveAmount = prevActive.OldAmount;
prevActive.UpdateChips();
prevActive.IsFinished = false;
}
}
}
private void SetPlayersDefaults()
{
PlayersCollection.ForEach(x => x.Reset());
if (CurrentGame == null)
{
return;
}
var dealer = CurrentGame.Players.FirstOrDefault(x => x.SeatNumber == CurrentGame.DealerButtonPosition);
foreach (Player player in CurrentGame.Players)
{
int i = GetPlayersSeatNumber(player, CurrentGame.Players, CurrentGame.GameDescription.SeatType.MaxPlayers);
PlayersCollection[i].Name = player.PlayerName;
PlayersCollection[i].IsFinished = false;
PlayersCollection[i].Bank = player.StartingStack;
var anteAction = CurrentGame.HandActions.FirstOrDefault(x => x.HandActionType == HandActionType.ANTE && x.PlayerName == player.PlayerName);
if (anteAction != null)
{
PlayersCollection[i].Bank -= Math.Abs(anteAction.Amount);
}
if (dealer == player)
{
PlayersCollection[i].IsDealer = true;
}
if (player.hasHoleCards)
{
bool canHideCards = !IsShowHoleCards && ActivePlayerName != player.PlayerName;
PlayersCollection[i].SetCards(player.HoleCards.Select(x => x.CardIntValue).ToArray(), canHideCards);
PlayersCollection[i].HideCards();
}
}
}
private ReplayerPlayerViewModel GetActivePlayerLastState(HandAction action)
{
ReplayerPlayerViewModel activePlayer;
string activePlayerName = action.PlayerName;
ReplayerTableState activePlayerLastState = TableStateList.LastOrDefault(x => x.ActivePlayer != null && x.ActivePlayer.Name == activePlayerName);
if (activePlayerLastState == null)
{
activePlayer = PlayersCollection.LastOrDefault(x => x.Name == activePlayerName);
}
else
{
activePlayer = activePlayerLastState.ActivePlayer;
}
if (activePlayer == null)
{
throw new ArgumentNullException(nameof(activePlayer), $"Cannot find player with name: {activePlayerName}");
}
return(activePlayer);
}
