/// <summary>
/// Returns an AI decision where the gameCache is already populated.
/// </summary>
/// <param name="handId">Current Hand Id</param>
/// <param name="playerId">Player for which decision is required.</param>
/// <param name="gameCache">The current gamecache</param>
/// <returns></returns>
protected override Play GetDecision()
{
//Initialise playDecision as fold which is returned if it is not modified anywhere
botAction = PokerAction.Fold;
betAmount = 0;
decisionTime = 0;
botPlayWRThreshold = getPlayWR(currentDecision.AiConfigStr);
botRaiseWRThreshold = getRaiseWR(currentDecision.AiConfigStr);
botAlwaysPlayLB = true;
winRatioDifference = (botPlayWRThreshold / 2);
bettingRound = currentDecision.Cache.getBettingRound();
currentRoundMinimumPlayAmount = currentDecision.Cache.getMinimumPlayAmount();
currentRoundLastRaiseAmount = currentDecision.Cache.getCurrentRoundLastRaiseAmount();
currentRoundPlayerBetAmount = currentDecision.Cache.getPlayerCurrentRoundBetAmount(currentDecision.PlayerId);
currentWinPercentage = infoStore.GetInfoValue(InfoType.WR_CardsOnlyWinPercentage);
currentWinRatio = infoStore.GetInfoValue(InfoType.WR_CardsOnlyWinRatio);
GetAIDecision();
return(new Play(botAction, betAmount, decisionTime, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, currentWinRatio.ToString(), 2));
}
public PlayerActionPrediction(double probFoldCheck, double probCall, double probRaise, decimal accuracy)
{
this.probFoldCheck = probFoldCheck;
this.probCall = probCall;
this.probRaise = probRaise;
double[] probabilities = new double[] { probFoldCheck, probCall, probRaise };
probabilities = (from
predictions in probabilities
orderby predictions descending
select predictions).ToArray();
this.accuracy = accuracy;
double maxProbability = probFoldCheck;
predictedAction = PokerAction.Check;
if (probCall > maxProbability)
{
maxProbability = probCall;
predictedAction = PokerAction.Call;
}
if (probRaise > maxProbability)
{
predictedAction = PokerAction.Raise;
}
}
public void Test_GameString_FromGameDef_Over()
{
GameDefinition gameDef = LoadGameDef();
GameState gs = new GameState(gameDef, 2);
VerifyGameState(gs, "", false, -1, 1.5, 1, 1, GameState.InvalidPosition, true, 0, 0, 0, false, 2);
VerifyGameStateMethods(gs, gameDef, new Ak[] { Ak.d });
VerifyPlayerState(gs.Players[0], "", -0.5, "", 0.5, 0.5, 0, false, false, false, true);
VerifyPlayerState(gs.Players[1], "", -1, "", 1, 1, 0, false, false, false, true);
gs.UpdateByAction(PokerAction.d(0, "Ac Ad"), gameDef);
gs.UpdateByAction(PokerAction.d(1, "2c 3d"), gameDef);
VerifyPlayerState(gs.Players[0], "", -0.5, "Ac Ad", 0.5, 0.5, 0, false, false, true, true);
VerifyPlayerState(gs.Players[1], "", -1, "2c 3d", 1, 1, 0, false, false, true, true);
gs.UpdateByAction(PokerAction.c(0), gameDef);
gs.UpdateByAction(PokerAction.c(1), gameDef);
gs.UpdateByAction(PokerAction.d("Ah As Qc"), gameDef);
gs.UpdateByAction(PokerAction.c(1), gameDef);
gs.UpdateByAction(PokerAction.c(0), gameDef);
gs.UpdateByAction(PokerAction.d("Jh"), gameDef);
gs.UpdateByAction(PokerAction.c(1), gameDef);
gs.UpdateByAction(PokerAction.c(0), gameDef);
gs.UpdateByAction(PokerAction.d("Ts"), gameDef);
gs.UpdateByAction(PokerAction.c(1), gameDef);
gs.UpdateByAction(PokerAction.c(0), gameDef);
UInt32[] ranks = new UInt32[] { 2, 1 };
gs.UpdateByShowdown(ranks, gameDef);
VerifyGameState(gs, "", true, 3, 2, 0, 0, 0, false, GameState.InvalidPosition, 0, 0, true, 2);
VerifyGameStateMethods(gs, gameDef, new Ak[] { });
VerifyPlayerState(gs.Players[0], "", 1, "Ac Ad Ah As Qc Jh Ts", 1, 0, 1, false, false, false, true);
VerifyPlayerState(gs.Players[1], "", -1, "2c 3d Ah As Qc Jh Ts", 1, 0, -1, false, false, false, true);
}
public void SetPlayerAction(PokerAction action, float amount)
{
remainingChipsValue += this.amount - amount;
this.action = action;
this.amount = amount;
actionEntered = true;
}
public void Test_IsDealerAction_Static()
{
Assert.IsFalse(PokerAction.IsDealerAction(Ak.b));
Assert.IsFalse(PokerAction.IsDealerAction(Ak.f));
Assert.IsFalse(PokerAction.IsDealerAction(Ak.c));
Assert.IsFalse(PokerAction.IsDealerAction(Ak.r));
Assert.IsTrue(PokerAction.IsDealerAction(Ak.d));
}
protected override Definitions.Play GetDecision()
{
PokerAction action = (PokerAction)(infoStore.GetInfoValue(InfoProviders.InfoType.WR_ModelAction));
decimal amount = (decimal)infoStore.GetInfoValue(InfoProviders.InfoType.WR_ModelActionAmount);
float decisionTime = 0;
return(new Play(action, amount, decisionTime, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId));
}
public Play(long handId, long playerId)
{
this.action = PokerAction.CatastrophicError;
this.amount = 0;
this.decisionTime = 0;
this.handId = handId;
this.playerId = playerId;
}
/// <summary>
/// Contructor for Play struct
/// </summary>
/// <param name="action">The action to be performed</param>
/// <param name="amount">The amount to raise by if that is the desired action</param>
/// <param name="decisionTime">The elapsed time to allow before implementing the decision</param>
/// <param name="handId">The handId for which this decision applies</param>
/// <param name="playerId">The playerId for which this decision applies</param>
public Play(PokerAction action, decimal amount, float decisionTime, long handId, long playerId)
{
this.action = action;
this.amount = amount;
this.decisionTime = decisionTime;
this.handId = handId;
this.playerId = playerId;
}
public virtual PokerAction OnActionRequired(string gameString)
{
log.InfoFormat("{0} OnActionRequired", _name);
_gameRecord = new GameRecord(gameString);
ProcessActions();
int chBegin, movesCount;
_strIndexes[_pos].GetChildrenBeginIdxAndCount(_curStrNodeIdx, out chBegin, out movesCount);
double[] probabs = new double[movesCount];
double sumProbab = 0;
for (int c = 0; c < movesCount; ++c)
{
int stNodeIdx = _strIndexes[_pos].GetChildIdx(chBegin + c);
StrategyTreeNode stNode = new StrategyTreeNode();
_strategies[_pos].GetNode(stNodeIdx, &stNode);
// Verify we are in the correct position.
// This is proven to be very helpful in testing.
if (!stNode.IsPlayerAction(_pos))
{
throw new ApplicationException(String.Format("{0}: expected strategy child: player action for pos {1}, but was: '{2}'",
GetBotStateDiagText(),
_pos,
stNode.ToStrategicString(null)));
}
probabs[c] = stNode.Probab;
sumProbab += probabs[c];
}
try
{
// Convert to relative probability and ignore if necessary
for (int c = 0; c < probabs.Length; ++c)
{
probabs[c] /= sumProbab;
if (probabs[c] < _relProbabIgnoreLevel)
{
probabs[c] = 0;
}
}
_moveSelector.SetWeights(probabs);
}
catch (Exception e)
{
// If there are problems with 0-probablities, add more info to it.
throw new ApplicationException(String.Format("{0} : see inner exception", GetBotStateDiagText()), e);
}
int moveIdx = _moveSelector.Next();
Debug.Assert(probabs[moveIdx] > 0, "0-probabs must not occur");
int nextStrNode = _strIndexes[_pos].GetChildIdx(chBegin + moveIdx);
PokerAction move = ConvertStrActionToPokerAction(nextStrNode);
log.InfoFormat("{0} OnActionRequired() returns {1}", _name, move);
return(move);
}
public void Test_RemoteClient()
{
SocketServer socketServer = new SocketServer("127.0.0.1", 9001);
Console.WriteLine("Waiting for client to connect");
SocketServerPlayer socketPlayer = socketServer.Listen(60000);
Assert.IsNotNull(socketPlayer);
Console.WriteLine("Socket client connected");
PlayerInfo pi = socketPlayer.OnServerConnect();
Console.WriteLine("Player connected");
Assert.AreEqual("SocketClientTest", pi.Name);
GameDefinition gameDef = new GameDefinition();
gameDef.Name = "Test game";
string[] cardNames1 = new string[] { "Q", "K", "A" };
CardSet[] cardSets1 = new CardSet[]
{
new CardSet {
bits = 0x01
},
new CardSet {
bits = 0x02
},
new CardSet {
bits = 0x10
}
};
gameDef.DeckDescr = new metagame.DeckDescriptor("TestDeck", cardNames1, cardSets1);
socketPlayer.OnSessionBegin("Test session", gameDef, new Dictionary <string, string> {
{ "p1", "v1" },
{ "p2", "v2" }
});
socketPlayer.OnGameBegin("gamestring OnGameBegin");
socketPlayer.OnGameUpdate("gamestring OnGameUpdate");
PokerAction action = socketPlayer.OnActionRequired("gamestring OnActionRequired");
Assert.AreEqual(Ak.r, action.Kind);
Assert.AreEqual(100, action.Amount);
Console.WriteLine("Action received");
socketPlayer.OnGameEnd("gamestring OnGameEnd");
socketPlayer.OnSessionEnd();
socketPlayer.OnServerDisconnect("End of test");
socketPlayer.Disconnect();
}
public string OnServerMessage(string textMessage)
{
if (textMessage.StartsWith("#") || textMessage.StartsWith(";"))
{
// Ignore comments
return(null);
}
ServerMessage msg = new ServerMessage(textMessage);
int ourPosition = 1 - msg.AcpcPosition;
int nextActor = (msg.Betting[msg.Round].Length) % 2;
if (msg.Round > 0)
{
// reversed blinds
nextActor = 1 - nextActor;
}
GameRecord gr = new GameRecord();
// For now fill only fields that are necessary for Patience.
gr.Id = msg.HandNumber;
for (int p = 0; p < 2; ++p)
{
gr.Players.Add(new GameRecord.Player(OPPONENT_NAME, 0, p == 0 ? 0.5 : 1.0, 0));
}
gr.Players[ourPosition].Name = PlayerName;
if (msg.Betting[0].Length == 0)
{
// Empty action string for round 0 - game started.
GameCount++;
Player.OnGameBegin(gr.ToGameString());
}
// Add actions to the game record after the call to OnGameBegin().
ParseActionsForHe(msg, gr);
if (nextActor != ourPosition)
{
// If we are not acting, do not update the bot.
return(null);
}
if (msg.IsGameOver())
{
return(null);
}
PokerAction response = Player.OnActionRequired(gr.ToGameString());
string responseText = textMessage + ":" + response.Kind.ToString();
return(responseText);
}
private static void ProcessGameContext(GameContext context)
{
int nodeId = context.Global.NodeId++;
GameDefinition gd = context.Global.GameDef;
ActionTree tree = context.Global.Tree;
// Store it before we possible change the state to skip dealer actions.
int lastActor = context.GameState.LastActor;
int round = context.GameState.Round;
while (!context.GameState.IsGameOver && context.GameState.IsDealerActing)
{
List <Ak> kinds = context.GameState.GetAllowedActions(gd);
foreach (Ak kind in kinds)
{
PokerAction action = new PokerAction
{
Kind = kind,
Position = context.GameState.CurrentActor
};
context.GameState.UpdateByAction(action, gd);
}
}
if (tree != null)
{
tree.SetDepth(nodeId, (byte)context.Depth);
tree.Nodes[nodeId].Position = lastActor;
tree.Nodes[nodeId].Amount = context.Amount;
tree.Nodes[nodeId].ActivePlayers = context.GameState.GetActivePlayers();
tree.Nodes[nodeId].Round = round;
}
if (context.GameState.IsGameOver)
{
return;
}
// Deal next cards.
List <Ak> actions = context.GameState.GetAllowedActions(gd);
foreach (Ak actionKind in actions)
{
GameContext childContext = new GameContext(context);
childContext.Depth++;
int position = context.GameState.CurrentActor;
PokerAction a = new PokerAction(actionKind, position, 0, "");
if (a.Kind == Ak.r)
{
a.Amount = gd.BetStructure[context.GameState.Round];
}
childContext.GameState.UpdateByAction(a, gd);
childContext.Amount = childContext.GameState.Players[position].InPot -
context.GameState.Players[position].InPot;
ProcessGameContext(childContext);
context.ChildCount += childContext.ChildCount + 1;
}
}
public override PokerAction OnActionRequired(string gameString)
{
base.OnActionRequired(gameString);
if (CurGameState.BetCount < GameDefinition.BetsCountLimits[CurGameState.Round])
{
return(PokerAction.r(0, 0));
}
return(PokerAction.c(0));
}
public override PokerAction OnActionRequired(string gameString)
{
base.OnActionRequired(gameString);
List <Ak> possibleActions = CurGameState.GetAllowedActions(GameDefinition);
int i = _rng.Next(possibleActions.Count);
PokerAction action = new PokerAction(possibleActions[i], 0, 0, "");
return(action);
}
static IConvertedPokerAction ConvertedActionFrom(string sqlAction)
{
ActionTypes theWhat = PokerAction.GetActionWhatFromSql(sqlAction.Substring(0, 1));
double parsedRatio;
double theRatio = double.TryParse(sqlAction.Substring(1), out parsedRatio) ? parsedRatio : 1.0;
return(new ConvertedPokerAction(theWhat, theRatio));
}
public Play(PokerAction action, decimal amount, float decisionTime, long handId, long playerId, string aiDecisionStr, short aiDecisionStrType)
{
this.action = action;
this.amount = amount;
this.decisionTime = decisionTime;
this.handId = handId;
this.playerId = playerId;
this.aiDecisionStrType = aiDecisionStrType;
this.aiDecisionStr = aiDecisionStr;
}
void CalculateGameResult()
{
if (_state.IsShowdownRequired)
{
UInt32[] ranks = new UInt32[_state.Players.Length];
int [][] hands = new int[_state.Players.Length][];
for (int p = 0; p < _state.Players.Length; ++p)
{
if (!_state.Players[p].IsFolded)
{
hands[p] = _gameDef.DeckDescr.GetIndexes(_state.Players[p].Hand);
}
}
_gameDef.GameRules.Showdown(_gameDef, hands, ranks);
long ranksSum = 0;
for (int p = 0; p < ranks.Length; ++p)
{
if (ranks[p] < 0)
{
throw new ApplicationException(String.Format("Negative rank {0} for player # {1}", ranks[p], p));
}
ranksSum += ranks[p];
}
if (ranksSum == 0)
{
throw new ApplicationException("At least one rank must be non-negative");
}
_state.UpdateByShowdown(ranks, _gameDef);
}
// Update the main game record and players' game records.
// Make private cards of non-folders visible for other players.
// Update stacks.
for (int p = 0; p < _players.Count; ++p)
{
_gameRecord.Players[p].Result = _state.Players[p].Result;
_gameRecord.IsGameOver = _state.IsGameOver;
_players[p].gameRecord.IsGameOver = _state.IsGameOver;
_players[p].stack = _state.Players[p].Stack;
for (int p1 = 0; p1 < _players.Count; ++p1)
{
_players[p].gameRecord.Players[p1].Result = _state.Players[p1].Result;
}
for (int a = 0; a < _players[p].gameRecord.Actions.Count; ++a)
{
PokerAction action = _players[p].gameRecord.Actions[a];
if (action.Kind == Ak.d &&
(action.Position == -1 || !_state.Players[action.Position].IsFolded))
{
action.Cards = _gameRecord.Actions[a].Cards;
}
}
}
}
/// <summary>
/// Deals cards for the next game. Is used if not replaying from game log.
/// </summary>
GameRecord DealCards()
{
GameRecord dealRecord = new GameRecord();
int cardsToDealCount = 0;
for (int r = 0; r < _gameDef.RoundsCount; ++r)
{
cardsToDealCount +=
(_gameDef.PrivateCardsCount[r] + _gameDef.PublicCardsCount[r]) * _sessionPlayers.Count
+ _gameDef.SharedCardsCount[r];
}
if (cardsToDealCount > 0)
{
_dealer.Shuffle(cardsToDealCount);
int dealt = 0;
for (int r = 0; r < _gameDef.RoundsCount; ++r)
{
if (_gameDef.PrivateCardsCount[r] > 0)
{
for (int p = 0; p < _sessionPlayers.Count; ++p)
{
dealRecord.Actions.Add(PokerAction.d(p, _gameDef.DeckDescr.GetCardNames(
_dealer.Sequence, dealt,
_gameDef.PrivateCardsCount[r])));
dealt += _gameDef.PrivateCardsCount[r];
}
}
if (_gameDef.PublicCardsCount[r] > 0)
{
for (int p = 0; p < _sessionPlayers.Count; ++p)
{
dealRecord.Actions.Add(PokerAction.d(p, _gameDef.DeckDescr.GetCardNames(
_dealer.Sequence, dealt,
_gameDef.PublicCardsCount[r])));
dealt += _gameDef.PublicCardsCount[r];
}
}
if (_gameDef.SharedCardsCount[r] > 0)
{
dealRecord.Actions.Add(PokerAction.d(_gameDef.DeckDescr.GetCardNames(
_dealer.Sequence, dealt, _gameDef.SharedCardsCount[r])));
dealt += _gameDef.SharedCardsCount[r];
}
}
}
return(dealRecord);
}
public DealRecord(GameRecord cfg, DeckDescriptor deckDescr, SequenceRng randomDealer)
{
_cfg = cfg;
_deckDescr = deckDescr;
_randomDealer = randomDealer;
// Loop through actions and
// - find the fixed cards
// - count random cards
// - count enumerated cards
for (int a = 0; a < _cfg.Actions.Count; ++a)
{
PokerAction action = _cfg.Actions[a];
if (!action.IsDealerAction())
{
continue;
}
string[] cards = action.Cards.Split(_separator, StringSplitOptions.RemoveEmptyEntries);
foreach (string card in cards)
{
if (card == "?")
{
_randomCount++;
}
else if (card.Length > 0 && card.Substring(0, 1) == "#")
{
int idx = int.Parse(card.Substring(1));
while (_enumCounts.Count <= idx)
{
_enumCounts.Add(0);
_enumCombosCounts.Add(0);
_enumCombos.Add(new List <CardSet>());
}
_enumCounts[idx]++;
}
else
{
_fixedCards.UnionWith(_deckDescr.GetCardSet(card));
}
}
}
// Count enumerated combinations.
int deadCards = _fixedCards.CountCards();
for (int i = 0; i < _enumCounts.Count; ++i)
{
_enumCombosCounts[i] = EnumAlgos.CountCombin(_deckDescr.Size - deadCards, _enumCounts[i]);
deadCards += _enumCounts[i];
}
}
private static string ActionToClearText(PokerAction response)
{
switch (response.Kind)
{
case Ak.f:
return "F";
case Ak.c:
return "C";
case Ak.r:
return "R";
}
return "";
}
/// <summary>
/// Contructor for Player
/// </summary>
/// <param name="action">The type of action that the player performed</param>
/// <param name="amount">The amount the player bet</param>
/// <param name="decisionTime">The time it took for the player to make their decision</param>
/// <param name="remainingChipsValue">The remaining value of the player's chips</param>
public Player(string name, float remainingChipsValue)
{
this.name = name;
this.remainingChipsValue = remainingChipsValue;
actionEntered = false;
action = PokerAction.Check;
amount = 0;
sittingOut = false;
holeCard1 = Card.NoCard;
holeCard2 = Card.NoCard;
playerID = 0;
}
private void ProcessPlayerActions()
{
for (int a = _strategyPath.Count - 1; a < _gameRecord.Actions.Count; ++a)
{
PokerAction pa = _gameRecord.Actions[a];
log.InfoFormat("{0} process {1} of pos {2}", _name, pa.Kind, pa.Position);
ActionTreeNode nextNode = CurStrategyNode.FindChildByAction(pa.Kind);
Debug.Assert(nextNode.State.LastActor == pa.Position);
_strategyPath.Add(nextNode);
if (pa.Kind == Ak.d && pa.Position == _pos)
{
OnDeal(pa.Cards);
}
}
}
public void Test_IsDealerAction()
{
PokerAction action = new PokerAction();
action.Kind = Ak.b;
Assert.IsFalse(action.IsDealerAction());
action.Kind = Ak.f;
Assert.IsFalse(action.IsDealerAction());
action.Kind = Ak.c;
Assert.IsFalse(action.IsDealerAction());
action.Kind = Ak.r;
Assert.IsFalse(action.IsDealerAction());
action.Kind = Ak.d;
Assert.IsTrue(action.IsDealerAction());
}
/// <summary>
/// Process new poker actions received from the server.
/// </summary>
private void ProcessActions()
{
for (int a = _processedActionsCount; a < _gameRecord.Actions.Count; ++a, _processedActionsCount++)
{
PokerAction pa = _gameRecord.Actions[a];
log.InfoFormat("{0} process {1} of pos {2}", _name, pa.Kind, pa.Position);
ProcessAction(pa);
StrategyTreeNode stNode = new StrategyTreeNode();
_strategies[_pos].GetNode(_curStrNodeIdx, &stNode);
if (stNode.IsPlayerAction(_pos))
{
_lastAbsStrProbab = stNode.Probab;
}
}
}
void ParseActionsForHe(ServerMessage msg, GameRecord gr)
{
string[] privateCards = msg.GetPrivateCards();
// Reverse positions for our format
for (int p = 1; p >= 0; --p)
{
string cards = privateCards[p];
if (cards == "")
{
cards = "? ?";
}
else
{
cards = CardsFromAcpc(cards);
}
PokerAction a = PokerAction.d(1 - p, cards);
gr.Actions.Add(a);
}
for (int r = 0; r <= msg.Round; ++r)
{
if (r > 0)
{
PokerAction a = PokerAction.d(CardsFromAcpc(msg.Cards[r]));
gr.Actions.Add(a);
}
for (int move = 0; move < msg.Betting[r].Length; ++move)
{
PokerAction a = null;
int position = r == 0 ? move % 2 : 1 - (move % 2);
switch (msg.Betting[r][move])
{
case 'r':
a = PokerAction.r(position, r < 2 ? 1 : 2);
break;
case 'c':
a = PokerAction.c(position);
break;
case 'f':
a = PokerAction.f(position);
break;
}
gr.Actions.Add(a);
}
}
}
private void UpdateProbability(PokerAction[] actions, double probab)
{
StringBuilder strategicString = new StringBuilder();
GameState gs = new GameState(GameDef);
int raiseCount = 0;
for (int a = 1; a < actions.Length; ++a)
{
PokerAction pa = actions[a];
if (pa.Kind == Ak.d)
{
// Skip private deals to opponents
if (pa.Position > 0)
{
continue;
}
gs.UpdateByAction(pa, GameDef);
strategicString.Append('0');
strategicString.Append('d');
strategicString.Append(pa.Cards);
raiseCount = 0;
}
else
{
double curInPot = gs.Players[pa.Position].InPot;
gs.UpdateByAction(pa, GameDef);
strategicString.Append(pa.Position.ToString());
if (pa.Kind == Ak.r)
{
raiseCount++;
}
strategicString.Append('p');
double newInPot = gs.Players[pa.Position].InPot;
double amount = newInPot - curInPot;
strategicString.Append(amount.ToString());
}
strategicString.Append(' ');
}
int node = (int)Strategy.FindNode(strategicString.ToString(), null);
// Just set the value.
// It is obviously correct for non-abstract games.
// For abstract games the cards corresponding to the same abstract cards will have the same
// probability anyway provided that the OCFR strategy uses the same abstraction.
Strategy.Nodes[node].Probab = probab;
}
void AdjustAction(ref PokerAction action)
{
if (action == null || !action.IsPlayerAction())
{
log.WarnFormat("Player returned null action, Action replaced by fold.");
action = new PokerAction {
Kind = Ak.f
};
}
if (!action.IsPlayerAction())
{
log.WarnFormat("Player returned a non-player action: {0}. Action replaced by fold.", action);
action = new PokerAction {
Kind = Ak.f
};
}
action.Position = _state.CurrentActor;
if (action.Kind == Ak.r)
{
if (_state.BetCount >= _gameDef.BetsCountLimits[_state.Round])
{
// No more raises allowed.
action.Kind = Ak.c;
}
}
if (action.Kind != Ak.r)
{
action.Amount = 0;
}
else
{
double minBet = _state.GetMinBet(_gameDef);
double maxBet = _state.GetMaxBet(_gameDef);
if (action.Amount < minBet)
{
action.Amount = minBet;
}
if (action.Amount > maxBet)
{
action.Amount = maxBet;
}
}
}
private void SetOptions(Stage gameStage)
{
int c = 0;
foreach (var button in Buttons)
{
button.GetComponentInChildren <Text>().text = gameStage.Actions[c].Name;
int thisC = c;
button.onClick.AddListener(() =>
{
option = gameStage.Actions[thisC];
isClicked = true;
});
c++;
}
}
private PokerAction GetAgentResponse()
{
// Check first if we have to call OnGameBegin().
// We do it as late as possible to enable undo.
// Only OnGameBegin() and OnActionRequired() are used
// to interact with the bot during the game,
// all interaction is currently done from this function.
Cursor.Current = Cursors.WaitCursor;
if (!HaveAgentActed())
{
GameRecord startGameRecord = new GameRecord(_gameRecord.ToGameString());
startGameRecord.Actions.Clear();
Player.OnGameBegin(startGameRecord.ToGameString());
}
PokerAction response = Player.OnActionRequired(_gameRecord.ToGameString());
Cursor.Current = Cursors.Default;
return response;
}
public void Test_GameString_GameDef_NotOver()
{
GameDefinition gameDef = LoadGameDef();
string gameString = "14; P1{100 .5 0} P2{200 1 0}; 0d{Ac Ad} 1d{Kc Kd};";
GameState gs = new GameState(gameString, gameDef);
VerifyGameState(gs, "14", false, 0, 1.5, 1, 1, 1, false, 0, 2, 0, false, 2);
VerifyGameStateMethods(gs, gameDef, new Ak[] { Ak.f, Ak.c, Ak.r });
VerifyPlayerState(gs.Players[0], "P1", 99.5, "Ac Ad", 0.5, 0.5, 0, false, false, true, true);
VerifyPlayerState(gs.Players[1], "P2", 199, "Kc Kd", 1, 1, 0, false, false, true, true);
gs.UpdateByAction(PokerAction.c(0), gameDef);
VerifyGameState(gs, "14", false, 0, 2, 1, 1, 0, false, 1, 0, 0, false, 2);
VerifyGameStateMethods(gs, gameDef, new Ak[] { Ak.c, Ak.r });
VerifyPlayerState(gs.Players[0], "P1", 99, "Ac Ad", 1, 1, 0, false, false, false, true);
VerifyPlayerState(gs.Players[1], "P2", 199, "Kc Kd", 1, 1, 0, false, false, true, true);
gs.UpdateByAction(PokerAction.c(1), gameDef);
VerifyGameState(gs, "14", false, 0, 2, 1, 1, 1, true, GameState.DealerPosition, 0, 0, false, 2);
VerifyGameStateMethods(gs, gameDef, new Ak[] { Ak.d });
VerifyPlayerState(gs.Players[0], "P1", 99, "Ac Ad", 1, 1, 0, false, false, false, true);
VerifyPlayerState(gs.Players[1], "P2", 199, "Kc Kd", 1, 1, 0, false, false, false, true);
gs.UpdateByAction(PokerAction.d("As 2d 4d"), gameDef);
VerifyGameState(gs, "14", false, 1, 2, 0, 0, GameState.DealerPosition, false, 1, 1, 0, false, 2);
VerifyGameStateMethods(gs, gameDef, new Ak[] { Ak.c, Ak.r });
VerifyPlayerState(gs.Players[0], "P1", 99, "Ac Ad As 2d 4d", 1, 0, 0, false, false, true, true);
VerifyPlayerState(gs.Players[1], "P2", 199, "Kc Kd As 2d 4d", 1, 0, 0, false, false, true, true);
gs.UpdateByAction(PokerAction.r(1, gameDef.BetStructure[1]), gameDef);
VerifyGameState(gs, "14", false, 1, 3, 1, 1, 1, false, 0, 0, 0, false, 2);
VerifyGameStateMethods(gs, gameDef, new Ak[] { Ak.f, Ak.c, Ak.r });
VerifyPlayerState(gs.Players[0], "P1", 99, "Ac Ad As 2d 4d", 1, 0, 0, false, false, true, true);
VerifyPlayerState(gs.Players[1], "P2", 198, "Kc Kd As 2d 4d", 2, 1, 0, false, false, false, true);
gs.UpdateByAction(PokerAction.f(0), gameDef);
VerifyGameState(gs, "14", true, 1, 3, 1, 1, 0, false, GameState.InvalidPosition, 0, 1, false, 2);
VerifyGameStateMethods(gs, gameDef, new Ak[] {});
VerifyPlayerState(gs.Players[0], "P1", 99, "Ac Ad As 2d 4d", 1, 0, -1, true, false, false, false);
VerifyPlayerState(gs.Players[1], "P2", 201, "Kc Kd As 2d 4d", 2, 1, 1, false, false, false, true);
}
public void ActionTaken(PokerPlayer player, PokerAction action)
{
ActionTaken(player, action, 0);
}
public void ActionTaken(PokerPlayer player, PokerAction action, bool forced)
{
ActionTaken(player, action, 0, forced);
}
public void ActionTaken(PokerPlayer player, PokerAction action, int val)
{
ActionTaken(player, action, val, false);
}
private void InstanceStartPoker(PCPokerAction pcAction, GameObject npc, bool withMoney)
{
this.withMoney = withMoney;
players = new ArrayList();
this.pcAction = pcAction;
players.Add(pcAction);
npcAction = new PokerAction(npc, "Poker Chair: Ed", withMoney);
ActionRunner npcActionRunner = (ActionRunner)npc.GetComponent("ActionRunner");
npcActionRunner.ResetRoutine(npcAction, false);
players.Add(npcAction);
deck = new Deck();
pot = new Pot(players, table.GetPotHook());
board = new Board(table.GetBoardHooks());
InitStages();
running = true;
playAgain = false;
enabled=true;
}
public void ActionTaken(PokerPlayer player, PokerAction action, int val, bool forced)
{
if (!forced)
player.EndAction();
if (GameProgress == PokerProgress.None || GameProgress == PokerProgress.End || Players[m_PlayerTurn] != player && !forced)
return;
bool done = false;
switch (action)
{
case PokerAction.Check:
{
done = Check(player);
break;
}
case PokerAction.Fold:
{
done = Fold(player);
break;
}
case PokerAction.Raise:
{
done = Raise(player, val);
break;
}
case PokerAction.Call:
{
done = Call(player);
break;
}
default:
{
player.Mobile.SendMessage(33, "Invalid action.");
SendBettingGump(Players[m_PlayerTurn], false);
return;
}
}
if (done)
CalculateAction();
}
