private void ReinitializeDictionaries()
{
ActivePlayers.Clear();
Teams.Clear();
Teams[ETeamID.TEAM_1] = new List <EPlayerID>();
Teams[ETeamID.TEAM_2] = new List <EPlayerID>();
Teams[ETeamID.TEAM_3] = new List <EPlayerID>();
Teams[ETeamID.TEAM_4] = new List <EPlayerID>();
partyStatusMap.Clear();
PlayersTeam.Clear();
PlayersDeathPositions.Clear();
PlayersDeathRotations.Clear();
// Adding all players (Besides Spectator and None)
foreach (EPlayerID playerID in Enum.GetValues(typeof(EPlayerID)))
{
if ((playerID != EPlayerID.NONE) &&
(playerID != EPlayerID.SPECTATOR))
{
PlayersTeam.Add(playerID, ETeamID.NONE);
PlayersDeathPositions.Add(playerID, Vector3.zero);
PlayersDeathRotations.Add(playerID, Quaternion.identity);
partyStatusMap.Add(playerID, new PlayerJoinStatus(EControllerID.NONE));
}
}
}
private void On_INPUT_ControllerDisconnected(BEHandle <EControllerID> eventHandle)
{
EControllerID controllerID = eventHandle.Arg1;
if (IS_KEY_CONTAINED(ControllersMap, controllerID))
{
EPlayerID playerID = ControllersMap[controllerID];
// Was a joined controller?
if (playerID != EPlayerID.SPECTATOR &&
IS_KEY_CONTAINED(partyStatusMap, playerID))
{
partyStatusMap[playerID].Flush();
}
// Destroy Player
if (ActivePlayers.ContainsKey(playerID))
{
DestroyPlayer(playerID);
}
ControllersMap.Remove(controllerID);
BEventsCollection.PLAYERS_PlayerLeft.Invoke(new BEHandle <EPlayerID, EControllerID>(playerID, controllerID));
}
}
private void CompareNodes(ChanceTreeNode *pNode0, ChanceTreeNode *pNode1)
{
double probab0 = pNode0->Probab;
double probab1 = pNode1->Probab;
double probabDiff = Math.Abs(probab0 - probab1);
SumProbabDiff += probabDiff;
MaxProbabDiff = Math.Max(MaxProbabDiff, probabDiff);
double relProbabDiff = (probab0 + probab1) != 0 ? probabDiff / (probab0 + probab1) / 2 : 0;
SumRelProbabDiff += relProbabDiff;
MaxRelProbabDiff = Math.Max(MaxRelProbabDiff, relProbabDiff);
UInt16[] activePlayers;
activePlayers = ActivePlayers.Get(_playersCount, 2, _playersCount);
double[] potShares0 = new double[_playersCount];
double[] potShares1 = new double[_playersCount];
foreach (UInt16 ap in activePlayers)
{
pNode0->GetPotShare(ap, potShares0);
pNode1->GetPotShare(ap, potShares1);
for (int p = 0; p < _playersCount; ++p)
{
double potShareDiff = Math.Abs(potShares0[p] - potShares1[p]);
SumPotShareDiff[p] += potShareDiff;
MaxPotShareDiff[p] = Math.Max(MaxPotShareDiff[p], potShareDiff);
}
}
}
public void Despawn(PlayerIndex index, bool removeActivePlayer)
{
PlayerInput player = _players.FirstOrDefault(p => p.Index == index);
if (player)
{
Transform playerTransform = player.transform;
Destroy(player.gameObject);
ParticleSystem particleEmitter = Instantiate(_despawnParticleEffect, playerTransform.position, Quaternion.identity);
particleEmitter.transform.parent = gameObject.transform;
Material material = player.GetComponentInChildren <SkinnedMeshRenderer>().material;
particleEmitter.GetComponent <Renderer>().material = material;
int removedPlayers = _players.RemoveAll(p => p.Index == index);
_colorController.ReturnMaterialToPool(material);
if (removedPlayers > 0)
{
AudioManager.Instance.PlayOneShot("Character Death");
if (removeActivePlayer)
{
ActivePlayers.RemovePlayer(new Player((int)index, material));
}
}
}
}
public void Spawn(PlayerIndex index, bool addActivePlayer)
{
if (LobbyStateManager.Instance.State == LobbyStateManager.LobbyState.TitleScreen || !LobbyStateManager.Instance.CameraAtDestination)
{
return;
}
if (!_players.FirstOrDefault(p => p.Index == index))
{
Vector3 position = _spawnLocations[(int)index - 1];
GameObject player = Instantiate(_playerPrefab, position, Quaternion.identity);
player.GetComponent <PlayerInput>().Index = index;
player.transform.parent = gameObject.transform;
Material material = _colorController.AssignRandomPlayerMaterial(player);
_players.Add(player.GetComponent <PlayerInput>());
AudioManager.Instance.PlayOneShot("Player Jump");
if (PlayerSelectUIManager.Instance.PlayerIsReady(index))
{
_colorController.ShowIcon(index);
}
else
{
_colorController.HideIcon(index);
}
if (addActivePlayer)
{
ActivePlayers.AddPlayer(new Player((int)index, material));
}
}
}
public void LeavePlayer(EPlayerID playerID)
{
if ((IS_KEY_CONTAINED(partyStatusMap, playerID)) &&
(IS_TRUE(partyStatusMap[playerID].HasJoined)))
{
// Destroy Player
if (ActivePlayers.ContainsKey(playerID))
{
DestroyPlayer(playerID);
}
// Reset controller to Spectator
EControllerID controllerID = partyStatusMap[playerID].ControllerID;
if (IS_KEY_CONTAINED(ControllersMap, controllerID))
{
ControllersMap[controllerID] = EPlayerID.SPECTATOR;
}
// Reset entry of playerID in party status
partyStatusMap[playerID] = new PlayerJoinStatus(EControllerID.NONE);
// Trigger global event
BEventsCollection.PLAYERS_PlayerLeft.Invoke(new BEHandle <EPlayerID, EControllerID>(playerID, controllerID));
// Are the rest of the joined players ready?
CheckIfAllPlayersAreReady();
}
}
public void Test_GetActivePlayers()
{
UInt16[] ap;
// Total: 0
ap = ActivePlayers.Get(0, 0, 0);
Assert.AreEqual(1, ap.Length);
Array.Sort(ap);
Assert.AreEqual(0, ap[0]);
// Total: 1
ap = ActivePlayers.Get(1, 0, 0);
Assert.AreEqual(1, ap.Length);
Array.Sort(ap);
Assert.AreEqual(0, ap[0]);
ap = ActivePlayers.Get(1, 0, 1);
Assert.AreEqual(2, ap.Length);
Array.Sort(ap);
Assert.AreEqual(0, ap[0]);
Assert.AreEqual(1, ap[1]);
// Total: 2
ap = ActivePlayers.Get(2, 0, 0);
Assert.AreEqual(1, ap.Length);
Array.Sort(ap);
Assert.AreEqual(0, ap[0]);
ap = ActivePlayers.Get(2, 0, 1);
Assert.AreEqual(3, ap.Length);
Array.Sort(ap);
Assert.AreEqual(0, ap[0]);
Assert.AreEqual(1, ap[1]);
Assert.AreEqual(2, ap[2]);
ap = ActivePlayers.Get(2, 1, 1);
Assert.AreEqual(2, ap.Length);
Array.Sort(ap);
Assert.AreEqual(1, ap[0]);
Assert.AreEqual(2, ap[1]);
ap = ActivePlayers.Get(2, 0, 2);
Assert.AreEqual(4, ap.Length);
Array.Sort(ap);
Assert.AreEqual(0, ap[0]);
Assert.AreEqual(1, ap[1]);
Assert.AreEqual(2, ap[2]);
Assert.AreEqual(3, ap[3]);
// Total: 3
ap = ActivePlayers.Get(3, 2, 2);
Assert.AreEqual(3, ap.Length);
Array.Sort(ap);
Assert.AreEqual(3, ap[0]);
Assert.AreEqual(5, ap[1]);
Assert.AreEqual(6, ap[2]);
ap = ActivePlayers.Get(3, 3, 3);
Assert.AreEqual(1, ap.Length);
Array.Sort(ap);
Assert.AreEqual(7, ap[0]);
}
void IStarcraftBot.onPlayerLeft(SWIG.BWAPI.Player player)
{
if (ActivePlayers.ContainsKey(player.getName()))
{
ActivePlayers.Remove(player.getName());
}
}
/// <summary>
/// Remove player from the game
/// </summary>
public void RemovePlayer(PokerPlayer player)
{
if (player != null)
{
//null these here so we know that one of the key players for the next game has left
if (DealerButton == player)
{
DealerButton = null;
}
if (SmallBlind == player)
{
SmallBlind = null;
}
if (BigBlind == player)
{
BigBlind = null;
}
//Move to view list so that they can continue viewing the game
if (ActivePlayers.Contains(player))
{
Viewers.Add(player.Owner);
}
Players.Remove(player);
player.LeaveGame(this);
}
}
/// <summary>
/// Initializes Players arrays and Input array depending on the number of players in the game.
/// First player always gets WSADE keymap and red color indication, whereas second gets Arrow-0 keymap and green color indication.
/// Both players instantiate in their own predefined locations.
/// </summary>
/// <param name="_numberOfPlayers"></param>
private void InitializePlayers(ActivePlayers _numberOfPlayers)
{
int numOfPlayers = _numberOfPlayers == ActivePlayers.OnePlayer ? 1 : 2;
_playerModels = new PlayerModel[numOfPlayers];
_playerControllers = new PlayerController[numOfPlayers];
_playerViews = new PlayerView[numOfPlayers];
_playerInputControls = new InputControl [numOfPlayers];
for (int i = 0; i < numOfPlayers; i++)
{
_playerViews [i] = GameObject.Instantiate <PlayerView> (_playerPrefab);
_playerInputControls [i] = _playerViews [i].gameObject.AddComponent <InputControl> ( );
_playerModels [i] = new PlayerModel(_playerStartTimeInSeconds);
if (i == 0)
{
_playerViews [i].transform.localPosition = MoveableAreaConstants._firstPlayerSpawnPoint;
_playerViews [i].AssignPlayerViewDetails(Color.red, "Player1", _scoreTextPlayer01, _timeTextPlayer01);
_playerInputControls [i].AssignInputs(KeyCode.W, KeyCode.S, KeyCode.D, KeyCode.A, KeyCode.E);
_playerModels [i]._playerID = PlayerID.Player01;
}
else
{
_playerViews [i].transform.localPosition = MoveableAreaConstants._secondPlayerSpawnPoint;
_playerViews [i].AssignPlayerViewDetails(Color.green, "Player2", _scoreTextPlayer02, _timeTextPlayer02);
_playerInputControls [i].AssignInputs(KeyCode.UpArrow, KeyCode.DownArrow, KeyCode.RightArrow, KeyCode.LeftArrow, KeyCode.Keypad0);
_playerModels [i]._playerID = PlayerID.Player02;
}
_playerControllers [i] = _playerViews [i].gameObject.AddComponent <PlayerController> ( );
_playerControllers [i].Init(_playerModels [i], _playerViews [i], _playerInputControls [i]);
}
}
public void ResetGame()
{
CloseGumps();
State = PokerGameState.Inactive;
RoundActions = new List <PlayerAction>();
CommunityCards.Clear();
//create and shuffle a new deck
Deck = new Deck();
PokerPots.Clear();
ActivePlayers.Clear();
foreach (var player in Players.ToArray())
{
player.ClearGame();
}
ActivePlayers.AddRange(Players.Where(x => x.Currency > 0));
if (GetActiveElliblePlayersCount() > 1)
{
BeginGame();
}
else
{
StopIntermission();
ActivePlayers.Clear();
}
}
public void RankHands()
{
foreach (var player in ActivePlayers.Where(x => !x.HasFolded))
{
player.RankHand(CommunityCards);
}
}
/// <summary>
/// UC014 Start (Deal) a New Hand
/// </summary>
/// <see cref="https://docs.google.com/document/d/1OTee6BGDWK2usL53jdoeBOI-1Jh8wyNejbQ0ZroUhcA/edit#heading=h.3z6a7b6nlnjj"/>
public void StartNewHand()
{
while (true)
{
Monitor.Enter(_lock);
while (ActivePlayers.Count < Preferences.MinNumberOfPlayers)
{
Monitor.Wait(_lock);
//throw new NotEnoughPlayersException("Its should be at least 2 active players to start new hand!");
}
Monitor.Exit(_lock);
if (this.CurrentHand != null && this.CurrentHand.Active)
{
throw new NotEnoughPlayersException("The previous hand hasnt ended");
}
Player dealer = ActivePlayers.ElementAt(dealerIndex);
CurrentHand = new Hand(dealer, ActivePlayers, Preferences);
CurrentHand.PlayHand(_lock);
EndCurrentHand();
/* Note: only the first player joining the room start
* the new thread of the hand
*/
}
}
/// <summary>
/// Remove the player from the Active Players list for the Mission.
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public bool RemoveActivePlayer(Client client)
{
if (!ActivePlayers.Contains(client))
{
return(false);
}
ActivePlayers.Remove(client);
client.ResetData(EntityData.ActiveMission);
NAPI.ClientEvent.TriggerClientEvent(client, "MissionInfo", "Mission_Active_Players", "");
NAPI.ClientEvent.TriggerClientEvent(client, "MissionInfo", "Mission_Active_Objectives", "");
string activePlayers = JsonConvert.SerializeObject(GetActivePlayers());
for (int i = 0; i < ActivePlayers.Count; i++)
{
NAPI.ClientEvent.TriggerClientEvent(NAPI.Player.GetPlayerFromHandle(ActivePlayers[i]), "MissionInfo", "Mission_Active_Players", activePlayers);
}
if (ActivePlayers.Count <= 0)
{
CleanupMission();
}
return(true);
}
private void RoboPlayerCallback(RoboPlayerPlugin plugin, RoboCard[] chosenCards, Exception ex)
{
RoboPlayer player = plugin.Player;
if (player == null || !ActivePlayers.Contains(plugin))
{
return;
}
if (player.PlayerState != RoboPlayerState.Thinking || ex != null)
{
player.PlayerState = RoboPlayerState.Error;
}
else
{
if (player.EndRound(chosenCards))
{
player.PlayerState = RoboPlayerState.Decided;
}
else
{
player.PlayerState = RoboPlayerState.Error;
}
}
Action playingCards = DoPlayingCards;
playingCards.BeginInvoke(null, playingCards);
}
/// <summary>
/// Check if only one player is left that isn't allin.
/// </summary>
private void CheckAllins()
{
if (ActivePlayers.Count(x => x.Allin) == ActivePlayers.Length - 1 && ActivePlayers.First(x => !x.Allin).Checked)
{
foreach (var player2 in ActivePlayers)
{
player2.Allin = true;
}
}
else
{
CurrentPlayerIndex = NextActivePlayerIndex(CurrentPlayerIndex);
}
// If only one player isn't allin, check everyone as allin. No further actions can be taken.
//if (ActivePlayers.Where(x => !x.Allin && x.Checked).Count() <= 1)
//{
// foreach (var player2 in ActivePlayers)
// {
// player2.Allin = true;
// }
//}
//else
//{
// CurrentPlayerIndex = NextActivePlayerIndex(CurrentPlayerIndex);
//}
}
public bool Fold(Msg message)
{
if (ValidPlayer(message.From))
{
var player = Players.FirstOrDefault(x => x.UserId == message.From.UserId);
if (player.Active && !player.Allin && !player.Checked)
{
player.Active = false;
Bot.Say(player.Username, "Foldaat.");
if (ActivePlayers.Count(x => x.Allin) == ActivePlayers.Length - 1 && ActivePlayers.First(x => !x.Allin).Checked)
{
foreach (var player2 in ActivePlayers)
{
player2.Allin = true;
}
}
}
if (!CheckStatuses())
{
CurrentPlayerIndex = NextActivePlayerIndex(CurrentPlayerIndex);
}
return(true);
}
else
{
NotAPlayer(message.From.Username);
}
return(false);
}
/// <summary>
/// Get the index of the next active player after the given index.
/// </summary>
private int NextActivePlayerIndex(int currentIndex, bool informOfTurn = true)
{
currentIndex++;
if (currentIndex >= Players.Count)
{
currentIndex = 0;
}
int loopCount = 0;
while (loopCount < 100 && (!Players[currentIndex].Active || Players[currentIndex].Allin))
{
currentIndex++;
if (currentIndex >= Players.Count)
{
currentIndex = 0;
}
loopCount++;
}
if (informOfTurn && ActivePlayers.Where(x => x.Checked).Count() != ActivePlayers.Length)
{
InformOfPlayerTurn(currentIndex);
}
return(currentIndex);
}
/// <summary>
/// Add the player to the Active Players list for the Mission.
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public bool AddActivePlayer(Client client)
{
if (client.HasData(EntityData.ActiveMission))
{
client.SendChatMessage("You must leave your current mission to join a new one. /leavemission");
return(false);
}
if (ActivePlayers.Contains(client))
{
return(false);
}
ActivePlayers.Add(client);
client.SetData(EntityData.ActiveMission, this);
string activePlayers = JsonConvert.SerializeObject(GetActivePlayers());
string activeObjectives = JsonConvert.SerializeObject(GetObjectives());
for (int i = 0; i < ActivePlayers.Count; i++)
{
NAPI.ClientEvent.TriggerClientEvent(NAPI.Player.GetPlayerFromHandle(ActivePlayers[i]), "MissionInfo", "Mission_Active_Players", activePlayers);
NAPI.ClientEvent.TriggerClientEvent(NAPI.Player.GetPlayerFromHandle(ActivePlayers[i]), "MissionInfo", "Mission_Active_Objectives", activeObjectives);
}
return(true);
}
private void GameEnded()
{
gameEnded = true;
List <Player> Results = new List <Player>();
for (int i = 0; i < ActivePlayers.Count; i++)
{
Results = ActivePlayers.ToList <Player>();
//Results.OrderBy(ActivePlayer => ActivePlayer.TotalScore).ToList();
}
var orderByResult = from r in Results
orderby r.TotalScore descending
select r;
PlayVictorySound();
MessageBox.Show(orderByResult.First().Firstname.ToString() + " vann med " + orderByResult.First().TotalScore.ToString() + " poäng");
dbOps.SaveGameTransaction(ActivePlayers);
if (MessageBox.Show("Spelet är s**t, vill du avsluta?", "Avsluta spel", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
{
//rutan stängs ned här
}
else
{
gameEngine.NullProps();
playerEngine.NullProps();
SelectedViewModel = new MainMenuViewModel();
}
}
private void Start()
{
if (!AudioManager.Instance.IsPlaying("Menu Theme"))
{
AudioManager.Instance.FadeInSound("Menu Theme", 1f);
}
ActivePlayers.Reset();
}
public void Reset()
{
List <GameObject> players = GetComponentsInChildren <PlayerInput>().Select(p => p.gameObject).ToList();
players.ForEach(p => DestroyPlayer(p));
ActivePlayers.Reset();
_players.Clear();
_playersToRespawn.Clear();
}
public void SetPlayerColor(GameObject player, Material material)
{
PlayerInput input = player.GetComponent <PlayerInput>();
player.GetComponentInChildren <SkinnedMeshRenderer>().material = material;
ActivePlayers.UpdateMaterial((int)player.GetComponent <PlayerInput>().Index, material);
PlayerSelectUIManager.Instance.UpdateColor(input.Index, material);
_playerMaterials[input.Index] = material;
}
public Game(
Dictionary <string, string> userProfileMap,
Dictionary <string, List <string> > roleToUsers,
List <string> activePlayers,
string mafiaTarget,
string doctorTarget,
string voteTarget,
GameState currentState
)
{
CurrentState = currentState;
List <string> mafiaIdList; // all mafias
List <string> doctorIdList;
roleToUsers.TryGetValue(Role.Mafia.ToString(), out mafiaIdList);
roleToUsers.TryGetValue(Role.Doctor.ToString(), out doctorIdList);
foreach (KeyValuePair <string, string> idWithName in userProfileMap)
{
Player newPlayer = new Player(idWithName.Key, idWithName.Value);
AddPlayer(newPlayer);
newPlayer.Vote = voteTarget;
newPlayer.Active = true;
if (activePlayers.Contains(newPlayer.Id))
{
// TODO: Sheriff
if (mafiaIdList != null && mafiaIdList.Contains(newPlayer.Id))
{
var mafia = new Mafia(newPlayer);
mafia.Target = mafiaTarget;
Mafias.Add(mafia);
PlayerMapping[newPlayer.Id] = mafia;
ActivePlayers.Add(mafia);
}
else if (doctorIdList != null && doctorIdList.Contains(newPlayer.Id))
{
var doctor = new Doctor(newPlayer);
doctor.Target = doctorTarget;
Doctors.Add(doctor);
PlayerMapping[newPlayer.Id] = doctor;
ActivePlayers.Add(doctor);
}
else
{
var village = new Villager(newPlayer);
PlayerMapping[newPlayer.Id] = village;
ActivePlayers.Add(village);
}
}
else
{
newPlayer.Active = false;
PlayerMapping[newPlayer.Id] = newPlayer;
}
}
}
public void InitPlayers()
{
ActivePlayers.Clear();
BettingPlayers = 0;
for (int i = 0; i < Config.MaxPlayers; i++)
{
if (i < Config.Players)
{
ActivePlayers.Add(players[i]);
//turn on active players game objects
players[i].gameObject.SetActive(true);
}
else
{
//turn off inactive players gameobjects
players[i].gameObject.SetActive(false);
//players[i].Role = Role.Defeated;
}
}
for (int i = 0; i < ActivePlayers.Count; i++)
{
//if player has been initialized, reset player.
if (!ActivePlayers[i].Initialized)
{
ActivePlayers[i].Init(i, turnSequencer, this, Config.placingBetDelay, Config.takeDelay, options.CardBackground);
}
ActivePlayers[i].ResetPlayer();
if (!Config.specialCards)
{
ActivePlayers[i].Cards = deck.GetCardsFromLiveDeckTasselated(i); //give activePlayers random cards
}
else
{
ActivePlayers[i].Cards = deck.GetSpecialCards(i);
}
ActivePlayers[i].StartReceivingCards();
}
//Recalculate turning order after live players list has been created.
turnSequencer.RecalculateTurningOrder(ActivePlayers);
PlayDealingSound();
//test
//activePlayers[0].MakeAllCardsHighestRank();
//activePlayers[1].MakeAllCardsHighestRank();
//activePlayers[2].MakeAllCardsHighestRank();
}
public void AssignVoteToPlayers(string voteId)
{
// If the vote is not within active players, assign null to the Vote property
if (!ActivePlayers.Select(p => p.Id).Contains(voteId))
{
voteId = null;
}
foreach (Player player in ActivePlayers)
{
player.Vote = voteId;
}
}
public void SetPlayers(ActivePlayers players)
{
_players = players;
_lastPlayerChange = DateTime.Now;
System.IO.File.WriteAllText("players/playerLeft_name.txt", _players.playerLeft.name);
System.IO.File.WriteAllText("players/playerLeft_deck.txt", _players.playerLeft.deck);
System.IO.File.WriteAllText("players/playerLeft_score.txt", _players.playerLeft.score);
System.IO.File.WriteAllText("players/playerLeft_lpoints.txt", _players.playerLeft.lifePoints);
System.IO.File.WriteAllText("players/playerRight_name.txt", _players.playerRight.name);
System.IO.File.WriteAllText("players/playerRight_deck.txt", _players.playerRight.deck);
System.IO.File.WriteAllText("players/playerRight_score.txt", _players.playerRight.score);
System.IO.File.WriteAllText("players/playerRight_lpoints.txt", _players.playerRight.lifePoints);
}
private void VoteOutPlayer()
{
// All players have the same vote
string playerVote = ActivePlayers.FirstOrDefault()?.Vote;
if (string.IsNullOrEmpty(playerVote))
{
return;
}
Player playerToEliminate = PlayerMapping[playerVote];
EliminatePlayer(playerToEliminate);
}
public void AddActivePlayer(Player player, int index)
{
player.Team = this;
ActivePlayers.Insert(index, player);
if (metadata.NumActivePlayers.HasValue)
{
if (ActivePlayers.Count > metadata.NumActivePlayers.Value)
{
Player end = ActivePlayers[ActivePlayers.Count - 1];
ActivePlayers.RemoveAt(ActivePlayers.Count - 1);
BenchPlayers.Insert(0, end);
}
}
}
/// <summary>
/// Creates a list of active players and grabs the next active player that can act. If play doesn't exist, grab the
/// first player in the list
/// <returns>next active player</returns>
/// </summary>
public PokerPlayer GetNextActivePlayer(PokerPlayer current)
{
var index = ActivePlayers.IndexOf(current);
PokerPlayer activeplayer;
do
{
activeplayer = ActivePlayers[index == -1 ? 0 : (index + 1 >= ActivePlayers.Count ? 0 : (index + 1))];
index = ActivePlayers.IndexOf(activeplayer);
}while (activeplayer.Currency == 0 || activeplayer.HasFolded);
return(activeplayer == current ? null : activeplayer);
}
