protected int PayOut(CardPlayerData playerData, int maxAmount)
{
int num = 0;
StorageContainer storage = playerData.GetStorage();
StorageContainer pot = Owner.GetPot();
if (storage != null && pot != null)
{
List <Item> obj = Pool.GetList <Item>();
num = pot.inventory.Take(obj, ScrapItemID, maxAmount);
if (num > 0)
{
foreach (Item item in obj)
{
item.MoveToContainer(storage.inventory, -1, true, true);
}
}
Pool.FreeList(ref obj);
}
else
{
Debug.LogError(GetType().Name + ": PayOut: Null storage.");
}
return(num);
}
public Playability GetPlayabilityStatus(CardPlayerData cpd)
{
if (!cpd.HasUser)
{
return(Playability.NoPlayer);
}
int scrapAmount = cpd.GetScrapAmount();
if (cpd.HasUserInGame)
{
if (scrapAmount <= 0)
{
return(Playability.RanOutOfScrap);
}
}
else
{
if (scrapAmount < MinBuyIn)
{
return(Playability.NotEnoughBuyIn);
}
if (scrapAmount > MaxBuyIn)
{
return(Playability.TooMuchBuyIn);
}
}
return(Playability.OK);
}
public bool TryGetCardPlayerData(int index, out CardPlayerData cardPlayer)
{
if (index >= 0 && index < playerData.Length)
{
cardPlayer = playerData[index];
return(true);
}
cardPlayer = null;
return(false);
}
private bool ToCardPlayerData(int relIndex, bool includeFolded, out CardPlayerData result)
{
if (!base.HasRoundInProgress)
{
Debug.LogWarning(GetType().Name + ": Tried to call ToCardPlayerData while no round was in progress. Returning null.");
result = null;
return(false);
}
int num = (includeFolded ? NumPlayersInGame() : NumPlayersInCurrentRound());
int index = RelToAbsIndex(relIndex % num, includeFolded);
return(TryGetCardPlayerData(index, out result));
}
public bool TryGetCardPlayerData(BasePlayer forPlayer, out CardPlayerData cardPlayer)
{
for (int i = 0; i < playerData.Length; i++)
{
if (playerData[i].UserID == forPlayer.userID)
{
cardPlayer = playerData[i];
return(true);
}
}
cardPlayer = null;
return(false);
}
protected void ReceivedInputFromPlayer(CardPlayerData pData, int input, bool countAsAction, int value = 0, bool playerInitiated = true)
{
if (HasGameInProgress && pData != null)
{
if (playerInitiated)
{
pData.lastActionTime = Time.unscaledTime;
}
SubReceivedInputFromPlayer(pData, input, value, countAsAction);
UpdateAllAvailableInputs();
Owner.SendNetworkUpdate();
}
}
public bool TryGetCardPlayerData(ulong forPlayer, out CardPlayerData cardPlayer)
{
CardPlayerData[] array = playerData;
foreach (CardPlayerData cardPlayerData in array)
{
if (cardPlayerData.UserID == forPlayer)
{
cardPlayer = cardPlayerData;
return(true);
}
}
cardPlayer = null;
return(false);
}
public int NumPlayersAllowedToPlay(CardPlayerData ignore = null)
{
int num = 0;
CardPlayerData[] array = playerData;
foreach (CardPlayerData cardPlayerData in array)
{
if (cardPlayerData != ignore && IsAllowedToPlay(cardPlayerData))
{
num++;
}
}
return(num);
}
protected override void SubOnPlayerLeaving(CardPlayerData playerData)
{
CardPlayerData activePlayer;
if (base.HasRoundInProgress && TryGetActivePlayer(out activePlayer))
{
if (playerData == activePlayer)
{
ReceivedInputFromPlayer(activePlayer, 1, true, 0, false);
}
else if (playerData.HasUserInCurrentRound && playerData.mountIndex < activePlayer.mountIndex && activePlayerIndex > 0)
{
activePlayerIndex--;
}
}
}
public CardGameController(CardTable owner)
{
Owner = owner;
playerData = new CardPlayerData[MaxPlayersAtTable()];
winnerInfo = Pool.Get <ProtoBuf.CardTable.WinnerBreakdown>();
winnerInfo.winners = Pool.GetList <ProtoBuf.CardTable.WinnerBreakdown.Winner>();
winnerInfo.winningScore = 0;
localPlayerCards = Pool.Get <ProtoBuf.CardTable.CardList>();
localPlayerCards.cards = Pool.GetList <int>();
if (IsServer)
{
for (int i = 0; i < playerData.Length; i++)
{
playerData[i] = new CardPlayerData(ScrapItemID, owner.GetPlayerStorage, i, IsServer);
}
}
}
protected override int GetAvailableInputsForPlayer(CardPlayerData playerData)
{
PokerInputOption pokerInputOption = PokerInputOption.None;
if (playerData == null || isWaitingBetweenTurns)
{
return((int)pokerInputOption);
}
if (!base.HasRoundInProgress)
{
if (!playerData.LeftRoundEarly && playerData.Cards.Count > 0 && !playerData.SendCardDetails)
{
pokerInputOption |= PokerInputOption.RevealHand;
}
return((int)pokerInputOption);
}
CardPlayerData activePlayer;
if (!TryGetActivePlayer(out activePlayer) || playerData != activePlayer)
{
return((int)pokerInputOption);
}
int scrapAmount = playerData.GetScrapAmount();
if (scrapAmount > 0)
{
pokerInputOption |= PokerInputOption.AllIn;
pokerInputOption |= PokerInputOption.Fold;
int currentBet = GetCurrentBet();
if (playerData.betThisTurn >= currentBet)
{
pokerInputOption |= PokerInputOption.Check;
}
if (currentBet > playerData.betThisTurn && scrapAmount >= currentBet - playerData.betThisTurn)
{
pokerInputOption |= PokerInputOption.Call;
}
if (scrapAmount >= GetCurrentMinRaise(playerData))
{
pokerInputOption = ((BiggestRaiseThisTurn != 0) ? (pokerInputOption | PokerInputOption.Raise) : (pokerInputOption | PokerInputOption.Bet));
}
}
return((int)pokerInputOption);
}
protected int RemoveScrapFromStorage(CardPlayerData data)
{
StorageContainer storage = data.GetStorage();
BasePlayer basePlayer = BasePlayer.FindByID(data.UserID);
int num = 0;
if (basePlayer != null)
{
List <Item> obj = Pool.GetList <Item>();
num = storage.inventory.Take(obj, ScrapItemID, int.MaxValue);
if (num > 0)
{
foreach (Item item in obj)
{
item.MoveToContainer(basePlayer.inventory.containerMain, -1, true, true);
}
}
Pool.FreeList(ref obj);
}
return(num);
}
public bool TryGetDealer(out CardPlayerData dealer)
{
return(ToCardPlayerData(dealerIndex, true, out dealer));
}
protected abstract void SubOnPlayerLeaving(CardPlayerData playerData);
protected abstract int GetAvailableInputsForPlayer(CardPlayerData playerData);
protected abstract void SubReceivedInputFromPlayer(CardPlayerData playerData, int input, int value, bool countAsAction);
protected int PayOutAll(CardPlayerData playerData)
{
return(PayOut(playerData, int.MaxValue));
}
protected override void SubReceivedInputFromPlayer(CardPlayerData playerData, int input, int value, bool countAsAction)
{
if (!Enum.IsDefined(typeof(PokerInputOption), input))
{
return;
}
if (!base.HasRoundInProgress)
{
if (input == 64)
{
playerData.EnableSendingCards();
}
LastActionTarget = playerData.UserID;
LastAction = (PokerInputOption)input;
LastActionValue = 0;
}
else
{
CardPlayerData activePlayer;
if (!TryGetActivePlayer(out activePlayer) || activePlayer != playerData)
{
return;
}
bool flag = false;
if ((playerData.availableInputs & input) != input)
{
return;
}
switch (input)
{
case 1:
playerData.LeaveCurrentRound(false, true);
flag = true;
LastActionValue = 0;
break;
case 2:
{
int currentBet = GetCurrentBet();
int num = (LastActionValue = AddToPot(playerData, currentBet - playerData.betThisTurn));
break;
}
case 16:
case 32:
{
int currentBet = GetCurrentBet();
int biggestRaiseThisTurn = BiggestRaiseThisTurn;
if (playerData.betThisTurn + value < currentBet + biggestRaiseThisTurn)
{
value = currentBet + biggestRaiseThisTurn - playerData.betThisTurn;
}
int num = AddToPot(playerData, value);
BiggestRaiseThisTurn = Mathf.Max(BiggestRaiseThisTurn, num - currentBet);
LastActionValue = num;
break;
}
case 4:
{
int currentBet = GetCurrentBet();
int num = AddAllToPot(playerData);
BiggestRaiseThisTurn = Mathf.Max(BiggestRaiseThisTurn, num - currentBet);
LastActionValue = num;
break;
}
case 8:
LastActionValue = 0;
break;
}
if (countAsAction && input != 0)
{
playerData.SetHasActedThisTurn(true);
}
LastActionTarget = playerData.UserID;
LastAction = (PokerInputOption)input;
if (flag && NumPlayersInCurrentRound() == 1)
{
EndRound();
return;
}
int startIndex = activePlayerIndex;
if (flag)
{
if (activePlayerIndex > NumPlayersInCurrentRound() - 1)
{
startIndex = 0;
}
}
else
{
startIndex = (activePlayerIndex + 1) % NumPlayersInCurrentRound();
}
if (ShouldEndTurn())
{
EndTurn();
return;
}
MoveToNextPlayerWithInputs(startIndex);
StartTurnTimer(MaxTurnTime);
base.Owner.SendNetworkUpdate();
}
}
protected int AddAllToPot(CardPlayerData playerData)
{
return(AddToPot(playerData, int.MaxValue));
}
public abstract bool IsAllowedToPlay(CardPlayerData cpd);
public bool TryGetBigBlind(out CardPlayerData bigBlind)
{
int relIndex = ((NumPlayersInGame() < 3) ? (dealerIndex + 1) : (dealerIndex + 2));
return(ToCardPlayerData(relIndex, true, out bigBlind));
}
public bool TryGetActivePlayer(out CardPlayerData activePlayer)
{
return(ToCardPlayerData(activePlayerIndex, false, out activePlayer));
}
public int GetCurrentMinRaise(CardPlayerData playerData)
{
return(Mathf.Max(10, GetCurrentBet() - playerData.betThisTurn + BiggestRaiseThisTurn));
}
public override bool IsAllowedToPlay(CardPlayerData cpd)
{
return(GetPlayabilityStatus(cpd) == Playability.OK);
}
public bool TryGetSmallBlind(out CardPlayerData smallBlind)
{
int relIndex = ((NumPlayersInGame() < 3) ? dealerIndex : (dealerIndex + 1));
return(ToCardPlayerData(relIndex, true, out smallBlind));
}
