public void AddPlayer_WithOutOfRangeSeat_ReturnsFalse()
{
Game game = new Game();
PokerPlayer player = new PokerPlayer("RobA2345");
Assert.IsFalse(game.AddPlayerToGame(player, 0, 10M));
Assert.IsFalse(game.AddPlayerToGame(player, 10, 10M));
}
public void AddPlayer_WithSeatUnavailable_ReturnsFalse()
{
Game game = new Game();
PokerPlayer player = new PokerPlayer("RobA2345");
Assert.IsTrue(game.AddPlayerToGame(player, 9, 1100M));
Assert.IsFalse(game.AddPlayerToGame(player, 9, 1100M));
}
public void Player1WinsWithStraight()
{
game = new PokerGame("name1", "name2");
// Ignore the cards built by constructor for the test
var p1 = new PokerPlayer("p1");
var p2 = new PokerPlayer("p2");
p1.Cards.Clear();
p2.Cards.Clear();
game.Player2.Cards.Clear();
p1.Cards = new List<Card>
{
new Card {Value = CardValue.Four, Suit = Suit.Diamonds},
new Card {Value = CardValue.Five, Suit = Suit.Hearts},
new Card {Value = CardValue.Seven, Suit = Suit.Spades},
new Card {Value = CardValue.Six, Suit = Suit.Clubs},
new Card {Value = CardValue.Three, Suit = Suit.Diamonds}
};
p2.Cards = new List<Card>
{
new Card {Value = CardValue.Four, Suit = Suit.Diamonds},
new Card {Value = CardValue.Ace, Suit = Suit.Hearts},
new Card {Value = CardValue.Ten, Suit = Suit.Spades},
new Card {Value = CardValue.Two, Suit = Suit.Clubs},
new Card {Value = CardValue.King, Suit = Suit.Diamonds}
};
}
public void AddPlayer_WithSeatAvailable_ReturnsTrue()
{
Game game = new Game();
PokerPlayer player = new PokerPlayer("RobA2345");
bool playerAdded = game.AddPlayerToGame(player, 1, 1100M);
Assert.IsTrue(playerAdded);
}
public void BuyInToGame_WithValidAmount_AddsPlayerToGame()
{
Game game = new Game(minmiumBuyIn: 100M, maximumBuyIn: 200M);
PokerPlayer player = new PokerPlayer("RobA2345");
player.BuyInToGame(game, 1, 150M);
Assert.AreEqual(1, game.PlayerCount);
}
public void ReceiveCard_AddsCardToHand()
{
Deck deck = new Deck();
PokerPlayer player = new PokerPlayer("RobA2345");
player.ReceiveCard(deck.Pop());
Assert.AreEqual(1, player.ShowHand().Count());
}
public void Deal_ToPlayer_RemovesCardFromDeck()
{
PokerPlayer player = new PokerPlayer("RobA2345");
Dealer dealer = new Dealer(new Game(), new Deck());
dealer.Deal(player);
Assert.AreEqual(51, dealer.DeckCount);
}
public PokerAI(PokerPlayer player, int peekingSkill, int playingSkill)
{
Debug.Log("PokerAI.PokerAI(peekingSkill = " + peekingSkill + ", playingSkill=" + playingSkill + ")");
this.player = player;
this.peekingSkill = peekingSkill;
this.playingSkill = playingSkill;
}
public BettingRoundStage(Deck deck, Board board, Pot pot, ArrayList players, PokerPlayer dealer)
{
this.deck = deck;
this.board = board;
this.pot = pot;
this.players = players;
currentPlayer = dealer;
}
public void BuyInToGame_WithInvalidAmount_DoesNotAddPlayerToGame()
{
Game game = new Game(minmiumBuyIn: 100M, maximumBuyIn: 200M);
PokerPlayer player = new PokerPlayer("RobA2345");
player.BuyInToGame(game, 1, 250M);
player.BuyInToGame(game, 1, 90M);
Assert.AreEqual(0, game.PlayerCount);
}
public MinimumBetsStage(Pot pot, ArrayList players, PokerPlayer dealer)
{
this.pot = pot;
this.players = players;
this.dealer = dealer;
currentPlayer = dealer;
firstDone = false;
}
public int Call(PokerPlayer player)
{
FModManager.StartEvent(FModLies.EVENTID_LIES_ACTIONS_POKER_DEALING);
int chipsNeeded = GetCallCost(player);
bets[player] = GetHighestBet();
if (previousRaiser == null){
previousRaiser = player;
}
return chipsNeeded;
}
public void Clear(ArrayList players)
{
bets = new Hashtable();
foreach (PokerPlayer player in players){
bets[player] = 0;
}
playersIn = new ArrayList(players);
previousRaiser = null;
displayedPotSize = 0;
}
public void CollectCards_FromPlayer_ReturnsCardsToDeck()
{
PokerPlayer player = new PokerPlayer("RobA2345");
Dealer dealer = new Dealer(new Game(), new Deck());
dealer.Deal(player);
dealer.Deal(player);
dealer.CollectCards(player);
Assert.AreEqual(52, dealer.DeckCount);
}
public void ReturnCards_ReturnsEnumerableOfCardsAndClearsHand()
{
Deck deck = new Deck();
PokerPlayer player = new PokerPlayer("RobA2345");
player.ReceiveCard(deck.Pop());
player.ReceiveCard(deck.Pop());
Assert.AreEqual(2, player.ShowHand().Count());
IEnumerable<Card> cards = player.ReturnCards();
Assert.AreEqual(2, cards.Count());
Assert.AreEqual(0, player.ShowHand().Count());
}
public PokerPlayer GetBestPlayer()
{
PokerPlayer bestPlayer = null;
float bestFitness = 0;
foreach (var player in players)
{
if (bestFitness < player.GetFitness())
{
bestFitness = player.GetFitness();
bestPlayer = player;
}
}
return(bestPlayer);
}
//Returns true if the betting round is over.
private bool NextTurn()
{
int index = players.IndexOf(currentPlayer);
index++;
if (index >= players.Count){
index = 0;
}
currentPlayer = (PokerPlayer)players[index];
if (pot.IsFinished(currentPlayer)){
return true;
}
if (pot.IsIn(currentPlayer)){
currentPlayer.Bet(deck, board, pot, players);
}
return false;
}
public void Pokerplayer_FullHouse_ThreeLow()
{
var player = new PokerPlayer();
player.Hand.Add(new Card(CardFaces.Five.Key, 5, CardSuits.Clubs));
player.Hand.Add(new Card(CardFaces.Two.Key, 2, CardSuits.Hearts));
player.Hand.Add(new Card(CardFaces.Five.Key, 5, CardSuits.Hearts));
player.Hand.Add(new Card(CardFaces.Two.Key, 2, CardSuits.Spades));
player.Hand.Add(new Card(CardFaces.Two.Key, 2, CardSuits.Diamonds));
player.ScoreHand();
Assert.AreEqual(PokerHandValues.FullHouse, player.HandValue);
Assert.AreEqual(5, player.HighSetValue);
Assert.AreEqual(2, player.LowSetValue);
Assert.AreEqual(FullHouseTypes.ThreeLow, player.FullHouseType);
}
public void Pokerplayer_ThreeKind_HighestCards(string highCardFace, int cardValue)
{
var player = new PokerPlayer();
var highCardValue = cardValue == 1 ? 14 : cardValue;
player.Hand.Add(new Card(CardFaces.King.Key, 13, CardSuits.Clubs));
player.Hand.Add(new Card(CardFaces.Two.Key, 2, CardSuits.Hearts));
player.Hand.Add(new Card(CardFaces.King.Key, 13, CardSuits.Hearts));
player.Hand.Add(new Card(CardFaces.King.Key, 13, CardSuits.Spades));
player.Hand.Add(new Card(highCardFace, cardValue, CardSuits.Diamonds));
player.ScoreHand();
Assert.AreEqual(PokerHandValues.ThreeOfAKind, player.HandValue);
Assert.AreEqual(13, player.HighSetValue);
Assert.AreEqual(highCardValue, player.HighCard);
}
public void Pokerplayer_TwoPair_SplitCards()
{
var player = new PokerPlayer();
player.Hand.Add(new Card(CardFaces.Two.Key, 2, CardSuits.Clubs));
player.Hand.Add(new Card(CardFaces.Two.Key, 2, CardSuits.Hearts));
player.Hand.Add(new Card(CardFaces.Five.Key, 5, CardSuits.Clubs));
player.Hand.Add(new Card(CardFaces.King.Key, 13, CardSuits.Spades));
player.Hand.Add(new Card(CardFaces.King.Key, 13, CardSuits.Diamonds));
player.ScoreHand();
Assert.AreEqual(PokerHandValues.TwoPair, player.HandValue);
Assert.AreEqual(5, player.HighCard);
Assert.AreEqual(13, player.HighSetValue);
Assert.AreEqual(2, player.LowSetValue);
}
public void Pokerplayer_Pair_HighestCards(string highCardFace, int cardValue)
{
var player = new PokerPlayer();
var highCardValue = cardValue == 1 ? 14 : cardValue;
player.Hand.Add(new Card(CardFaces.Ten.Key, 10, CardSuits.Clubs));
player.Hand.Add(new Card(CardFaces.King.Key, 13, CardSuits.Hearts));
player.Hand.Add(new Card(highCardFace, cardValue, CardSuits.Clubs));
player.Hand.Add(new Card(CardFaces.King.Key, 13, CardSuits.Clubs));
player.Hand.Add(new Card(CardFaces.Three.Key, 3, CardSuits.Clubs));
player.ScoreHand();
Assert.AreEqual(PokerHandValues.Pair, player.HandValue);
Assert.AreEqual(highCardValue, player.HighCard);
Assert.AreEqual(13, player.HighSetValue);
}
private float[][] PointSpliceCrossover(PokerPlayer dominat, PokerPlayer submissive)
{
float[][] returnList = new float[2][];
float[] dominatGenom = dominat.network.GetNetworkGenom();
float[] submissiveGenom = submissive.network.GetNetworkGenom();
if (spliceCount > 1)
{
//get a random split point
int rand = Random.Range(0, dominatGenom.Length - 1);
for (int i = 0; i < dominatGenom.Length; i++)
{
if (i > rand)
{
//sawp genom values to the rigth of the splitting point
float holder = dominatGenom[i];
dominatGenom[i] = submissiveGenom[i];
submissiveGenom[i] = holder;
}
}
}
else
{
//get 2 split points, one random and the other one based on what is left
int rand = Random.Range(0, dominatGenom.Length - 3);
int rand2 = Random.Range(rand + 2, dominatGenom.Length - 1);
for (int i = 0; i < dominatGenom.Length; i++)
{
if (i > rand && i < rand2)
{
//sawp genom values in between the 2 random generated values
float holder = dominatGenom[i];
dominatGenom[i] = submissiveGenom[i];
submissiveGenom[i] = holder;
}
}
}
returnList[0] = dominatGenom;
returnList[1] = submissiveGenom;
return(returnList);
}
public async Task <WinnerViewModel> GetWinner(PlayersViewModel players)
{
if (players.Players.Count == 0)
{
players.Players.Add(GetMockPlayer("Frankie"));
players.Players.Add(GetMockPlayer("Johnny"));
players.Players.Add(GetMockPlayer("Sammy"));
}
PokerPlayer winner = GetWinner(players.Players);
WinnerViewModel winnerViewModel = new WinnerViewModel()
{
WinnerPlayer = winner, Players = players.Players
};
return(winnerViewModel);
}
public void Check_Player_Has_Cards_After_Dealer_Dealt()
{
//arrange
Deck baraha = new Deck();
Dealer john = new Dealer();
john.Shuffle(baraha.Cards);
PokerPlayer player1 = new PokerPlayer("player1");
PokerPlayer player2 = new PokerPlayer("player2");
Collection <PokerPlayer> players = new Collection <PokerPlayer>();
//act
players = john.Deal(players);
//assert
Assert.AreEqual(5, players[0].Cards.Count);
}
public static void PokerPlayerAction(PokerPlayer player, PlayerAction action, string tablename, bool isDonation)
{
try
{
using (var op = new StreamWriter("Logs/Poker/" + tablename + ".log", true))
{
op.WriteLine(
"Player {0} with account {1} {4} for {2:#,0} {3}.",
player.Mobile.Name,
player.Mobile.Account == null ? "(-null-)" : player.Mobile.Account.Username,
player.Bet,
(isDonation ? "donation coins" : "gold"),
player.Action);
}
}
catch
{ }
}
public static string GenerateNewPlayerName(string startingName, short pokerClientId, bool obfuscate)
{
string newPlayerName = "";
if (DatabaseMode.LOCALMODE.Equals(Mode))
{
List <string> obfuscatedNames = new List <string>()
{
"Bob", "Alice", "Charlene", "Eve", "Tak", "Marc", "Matt", "Ailwyn", "Edmund", "Lucifer", "Denis", "Kent", "Clark", "Bruce", "Peter", "Nike", "Steve", "Rio", "Tony", "Stan"
};
List <string> characters = new List <string>()
{
"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
};
//Check to see if we have created a player with this name before
do
{
string tryName;
if (obfuscate)
{
tryName = ShuffleList.Shuffle(obfuscatedNames)[0] + "-" + String.Join("", ShuffleList.Shuffle(characters).Take(3).ToArray());
}
else
{
tryName = startingName + "-" + String.Join("", ShuffleList.Shuffle(characters).Take(3).ToArray());
}
//Unique name check
PokerPlayer playerDetails = playerDetailsByPlayerName(tryName, pokerClientId);
if (playerDetails == null)
{
newPlayerName = tryName;
break;
}
} while (true);
}
else
{
throw new NotImplementedException();
}
return(newPlayerName);
}
public void Test_Winner_Evaluation_Repeatedly()
{
//run several tests
for (int i = 0; i < 10; i++)
{
//arrange
Deck baraha = new Deck();
Dealer john = new Dealer();
john.Shuffle(baraha.Cards);
PokerPlayer player1 = new PokerPlayer("player1");
PokerPlayer player2 = new PokerPlayer("player2");
PokerPlayer player3 = new PokerPlayer("player3");
PokerPlayer player4 = new PokerPlayer("player4");
PokerPlayer player5 = new PokerPlayer("player5");
Collection <PokerPlayer> players = new Collection <PokerPlayer>();
players.Add(player1);
players.Add(player2);
players.Add(player3);
players.Add(player4);
players.Add(player5);
//act
players = john.Deal(players);
Game game = new Game(players, Round.ShowDown);
var winners = game.Run();
foreach (var player in players)
{
player.ShowCard();
}
Console.WriteLine("we have {0} winner/s", winners.Count);
foreach (var player in winners)
{
Console.WriteLine("player {0} has {1} set of cards has value of {2}", player.name, player.hand, player.CardTotal);
}
}
//assert
Assert.AreEqual(0, 0);
}
public override void Execute(PokerPlayer p)
{
CardPokerFace newCard = null;
Vector3 cardPosition = Vector3.zero;
Sequence seq = DOTween.Sequence();
Layout layout = PokerFaceManager.S.layout;
while (p.selectedCards.Count > 0)
{
cardPosition = p.selectedCards[0].transform.localPosition;
cardPosition.y -= 0.5f;
int layerID = p.selectedCards[0].spriteRenderer.sortingLayerID;
PokerFaceManager.S.MoveToDiscard(p.selectedCards[0]);
// move old card to discard
seq.Append(p.selectedCards[0].transform.DOMove(new Vector3(0f, 4.5f, 0f), 0.5f));
newCard = PokerFaceManager.S.Draw(); // get new card from drawpile
newCard.spriteRenderer.sortingLayerID = layerID;
newCard.spriteRenderer.sortingOrder = 0;
foreach (SpriteRenderer sr in newCard.spriteRenderers)
{
sr.sortingLayerID = newCard.spriteRenderer.sortingLayerID;
if (sr.name == "back")
{
sr.sortingOrder = 2;
}
else
{
sr.sortingOrder = 1;
Vector3 wantedPos = sr.transform.localPosition;
wantedPos.z = -1;
sr.transform.localPosition = wantedPos;
}
}
seq.Append(newCard.transform.DOLocalMove(new Vector3(0f, 4.5f, 0f), 0.01f));
seq.Append(newCard.transform.DOLocalMove(cardPosition, 0.5f).OnStart(() => PokerFaceManager.S.PlaySound(SoundType.CardMoveSlow))); // animate movement
seq.Append(p.selectedCards[0].transform.DOMove(new Vector3(layout.multiplier.x * layout.discardPile.x - 80, layout.multiplier.y * layout.discardPile.y, -layout.discardPile.layerID + 0.5f), 0f));
seq.Play();
newCard.index = p.selectedCards[0].index; // assigning the correct index
p.cards[newCard.index] = newCard; // assign the correct card to player card list
p.DeselectCard(p.selectedCards[0]); // make sure the card is no longer selected
}
PokerFaceManager.S.RemovePokerHand(p);
PokerFaceManager.S.AddPokerHand(p);
}
public void EvaluateHandValue_ReturnsUintValue()
{
Game game = new Game();
Dealer dealer = new Dealer(game, new Deck());
PokerPlayer rob = new PokerPlayer("RobA2345");
dealer.ShuffleDeck();
dealer.Deal(rob);
dealer.Deal(rob);
dealer.DealFlop(game);
dealer.DealTurn(game);
dealer.DealRiver(game);
HandEvaluatorWrapper handEvaluator = new HandEvaluatorWrapper();
uint handValue = handEvaluator.EvaluateHandValue(rob.ShowHand(), game.CommunityCards);
Assert.IsTrue(handValue > 0);
}
public void TestIsDuplicateCard()
{
//Arrange
PlayPokerGame PokerFirstGame = new PlayPokerGame();
PokerPlayer Joe = new PokerPlayer("Joe");
PokerFirstGame.AddPlayer(Joe);
PokerFirstGame.GivePlayingCards(Joe, new PlayingCard {
Rank = RankType.Eight, Suit = SuitType.Clubs
});
PokerFirstGame.GivePlayingCards(Joe, new PlayingCard {
Rank = RankType.Six, Suit = SuitType.Heart
});
PokerFirstGame.GivePlayingCards(Joe, new PlayingCard {
Rank = RankType.Eight, Suit = SuitType.Heart
});
PokerFirstGame.GivePlayingCards(Joe, new PlayingCard {
Rank = RankType.Jack, Suit = SuitType.Heart
});
PokerFirstGame.GivePlayingCards(Joe, new PlayingCard {
Rank = RankType.Eight, Suit = SuitType.Diamond
});
PokerFirstGame.GivePlayingCards(Joe, new PlayingCard {
Rank = RankType.Eight, Suit = SuitType.Diamond
});
//Act
try
{
PokerHand pokerHand = PokerFirstGame.GetWinner();
}
catch (Exception ex)
{
//Assert
StringAssert.Contains(ex.Message.ToString(), "Duplicate card(s) found");
return;
}
Assert.Fail("No exception was thrown.");
}
private void OnApplicationQuit()
{
if (saveBestBrain)
{
float fittnes = 0;
PokerPlayer player = null;
foreach (var game in games)
{
if (fittnes < game.GetBestPlayer().GetFitness())
{
fittnes = game.GetBestPlayer().GetFitness();
player = game.GetBestPlayer();
}
}
player.SaveBrain();
Debug.Log("Best brain saved");
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
var players = new List <PokerPlayer>();
for (int i = 0; i < 4; i++)
{
var cards = new List <PokerCard>();
for (int j = 0; j < 5; j++)
{
cards.Add(GetRandomCard());
}
var player = new PokerPlayer {
Name = Names[i], PokerCards = cards
};
players.Add(player);
}
UpdatePlayers(players);
//get winners
GetWinners(players);
}
private bool NextTurn()
{
int index = players.IndexOf(currentPlayer);
index++;
if (index >= players.Count){
index = 0;
}
currentPlayer = (PokerPlayer)players[index];
if (!firstDone){
currentPlayer.RaiseMinimumBet(pot, MINIMUM_BET);
firstDone = true;
} else {
currentPlayer.CallMinimumBet(pot);
}
if (currentPlayer == dealer){
return true;
} else {
return false;
}
}
private int Partition(List <PokerPlayer> arr, int start, int end)
{
PokerPlayer temp;
PokerPlayer p = arr[end];
int i = start - 1;
for (int j = start; j <= end - 1; j++)
{
if (arr[j].GetFitness() <= p.GetFitness())
{
i++;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
temp = arr[i + 1];
arr[i + 1] = arr[end];
arr[end] = temp;
return(i + 1);
}
public void Can_Play_All_Games()
{
#region Arrange
var player = new PokerPlayer();
#endregion
#region Act
player.PlayGames();
#endregion
#region Assert
Assert.IsTrue(player.Player1Wins > 0);
Assert.IsTrue(player.Player2Wins > 0);
Assert.IsTrue(player.Player1Wins + player.Player2Wins == 1000);
#endregion
}
private float[][] UniformSpliceCrossover(PokerPlayer dominat, PokerPlayer submissive)
{
float[][] returnList = new float[2][];
float[] dominatGenom = dominat.network.GetNetworkGenom();
float[] submisive = submissive.network.GetNetworkGenom();
//do the combination, works for 1 and 2 splits points
for (int i = 0; i < dominatGenom.Length; i++)
{
if (Random.Range(0, 100) >= uniformProbability)
{
//sawp genom values in a given range
float holder = dominatGenom[i];
dominatGenom[i] = submisive[i];
submisive[i] = holder;
}
}
returnList[0] = dominatGenom;
returnList[1] = submisive;
return(returnList);
}
public void Test_Poker_Hand_Reader()
{
//arrange
Deck baraha = new Deck();
Dealer john = new Dealer();
john.Shuffle(baraha.Cards);
PokerPlayer player1 = new PokerPlayer("player1");
PokerPlayer player2 = new PokerPlayer("player2");
Collection <PokerPlayer> players = new Collection <PokerPlayer>();
players.Add(player1);
players.Add(player2);
//act
players = john.Deal(players);
Game game = new Game(players, Round.ShowDown);
var winners = game.Run();
//assert
Assert.AreEqual(0, 0);
}
/// <summary>
/// If the player already exists in the database, pokerPlayer object is populated. If player does not exist, a new player is created and pokerPlayer object is populated.
/// </summary>
/// <param name="playerId"></param>
/// <param name="botConfigId"></param>
/// <param name="playerName"></param>
/// <param name="pokerClientId"></param>
public pokerPlayer(string playerName, short pokerClientId, databaseCache parentCache)
{
this.parentCache = parentCache;
PokerPlayer pokerPlayers = databaseQueries.playerDetailsByPlayerName(playerName, pokerClientId);
if (pokerPlayers != null)
{
//Player already exists, populate pokerPlayer object
this.playerId = pokerPlayers.PlayerId;
this.playerName = pokerPlayers.PlayerName;
this.pokerClientId = pokerPlayers.PokerClientId;
this.isBot = (pokerPlayers.AiType == AIGeneration.NoAi_Human ? false : true);
}
else
{
//Player does not exist, so create new player
this.playerName = playerName;
this.pokerClientId = pokerClientId;
this.isBot = false;
this.playerId = databaseQueries.CreateNewNonBotPlayer(playerName, pokerClientId);
}
}
public void TestIsDuplicatePlayer()
{
//Arrange
PlayPokerGame PokerFirstGame = new PlayPokerGame();
PokerPlayer Batman = new PokerPlayer("Batman");
PokerPlayer Robin = new PokerPlayer("Batman");
//Act
try
{
PokerFirstGame.AddPlayer(Batman);
PokerFirstGame.AddPlayer(Robin);
}
catch (Exception ex)
{
//Assert
StringAssert.Contains(ex.Message.ToString(), "Player name already exists");
return;
}
Assert.Fail("No exception was thrown.");
}
public override void Execute(PokerPlayer p)
{
if (p is AIPokerPlayer)
{
if (PokerFaceManager.S.amountToBet < (p.totalAmount - p.betAmount))
{
p.raiseCashAmount = Random.Range(PokerFaceManager.S.amountToBet + 1, p.totalAmount);
}
else
{
Debug.LogError(p.name + " tried to raise, but doesnt have enough money");
}
p.betAmount += p.raiseCashAmount;
p.totalAmount -= p.raiseCashAmount;
UIManager.S.PlayMovingBetSequence(p);
Debug.Log(p.name + " Raise " + p.raiseCashAmount);
}
else
{
Debug.Log(p.name + " Raise " + p.betAmount);
}
PokerFaceManager.S.SetAmountToBet(p.betAmount);
}
public override void Execute(PokerPlayer p)
{
Debug.Log(p.name + " Check");
PokerFaceManager.S.PlaySound(SoundType.Check);
}
public void AACase()
{
// Arrange
var jsonString = @"{
""tournament_id"": ""604661d35395db00047b2859"",
""game_id"": ""6048bc12c7bae6000442bc0d"",
""round"": 0,
""players"": [
{
""name"": ""Royal Flush"",
""stack"": 1000,
""status"": ""active"",
""bet"": 0,
""hole_cards"": [
{
""rank"": ""7"",
""suit"": ""clubs""
},
{
""rank"": ""K"",
""suit"": ""spades""
}
],
""time_used"": 0,
""version"": ""Default C# folding player"",
""id"": 0
},
{
""name"": ""Oceans 5"",
""stack"": 998,
""status"": ""active"",
""bet"": 2,
""time_used"": 0,
""version"": ""V02"",
""id"": 1
},
{
""name"": ""Stone Cold Nuts"",
""stack"": 996,
""status"": ""active"",
""bet"": 4,
""time_used"": 0,
""version"": ""Stone Cold Nuts"",
""id"": 2
},
{
""name"": ""Heavy Waterfall"",
""stack"": 1000,
""status"": ""folded"",
""bet"": 0,
""time_used"": 21039,
""version"": ""We smarter now."",
""id"": 3
},
{
""name"": ""Lean Stakes"",
""stack"": 1000,
""status"": ""folded"",
""bet"": 0,
""time_used"": 13293,
""version"": ""The lean stakes"",
""id"": 4
},
{
""name"": ""Flop Bot"",
""stack"": 1000,
""status"": ""folded"",
""bet"": 0,
""time_used"": 13996,
""version"": ""TO THE MOON ??? - 13:02"",
""id"": 5
},
{
""name"": ""SalasBot"",
""stack"": 996,
""status"": ""active"",
""bet"": 4,
""time_used"": 851440,
""version"": ""Default C# folding player"",
""id"": 6
},
{
""name"": ""Negreanu 2"",
""stack"": 1000,
""status"": ""folded"",
""bet"": 0,
""time_used"": 64994,
""version"": ""Update"",
""id"": 7
}
],
""small_blind"": 2,
""big_blind"": 4,
""orbits"": 0,
""dealer"": 0,
""community_cards"": [],
""current_buy_in"": 4,
""pot"": 10,
""in_action"": 0,
""minimum_raise"": 2,
""bet_index"": 7
}";
var json = JObject.Parse(jsonString);
// Act
int result = PokerPlayer.BetRequest(json);
// Assert
Assert.Equals(result, 39);
}
public bool IsFinished(PokerPlayer playerInTurn)
{
if (previousRaiser == playerInTurn){
previousRaiser = null;
return true;
} else {
return false;
}
}
public float GetMaximumFairRaise(PokerPlayer currentPlayer)
{
float maximumFairRaise = Mathf.Infinity;
foreach (PokerPlayer player in playersIn){
if (player != currentPlayer){
int stack = player.GetStack();
int callCost = GetCallCost(player);
maximumFairRaise = Mathf.Min(maximumFairRaise, (float)(stack - callCost));
}
}
return maximumFairRaise;
}
public bool IsIn(PokerPlayer player)
{
return playersIn.Contains(player);
}
public void Test_Bob_Wins()
{
//arrange
PokerPlayer Joe = new PokerPlayer("Joe");
PokerPlayer Bob = new PokerPlayer("Bob");
PokerPlayer Sally = new PokerPlayer("Sally");
//Joe
Card sevenD = new Card();
sevenD.Rank = Rank.Seven;
sevenD.Suit = Suit.Diamond;
Card kingD = new Card();
kingD.Rank = Rank.King;
kingD.Suit = Suit.Diamond;
Card queenD = new Card();
queenD.Rank = Rank.Queen;
queenD.Suit = Suit.Diamond;
Card eightD = new Card();
eightD.Rank = Rank.Eight;
eightD.Suit = Suit.Diamond;
Card threeD = new Card();
threeD.Rank = Rank.Three;
threeD.Suit = Suit.Diamond;
//Bob card
Card aceS = new Card();
aceS.Rank = Rank.Ace;
aceS.Suit = Suit.Spade;
Card queenS = new Card();
queenS.Rank = Rank.Queen;
queenS.Suit = Suit.Spade;
Card sixS = new Card();
sixS.Rank = Rank.Six;
sixS.Suit = Suit.Spade;
Card eightS = new Card();
eightS.Rank = Rank.Eight;
eightS.Suit = Suit.Spade;
Card fourS = new Card();
fourS.Rank = Rank.Four;
fourS.Suit = Suit.Spade;
//Sally card
Card threeH = new Card();
threeH.Rank = Rank.Three;
threeH.Suit = Suit.Heart;
Card queenC = new Card();
queenC.Rank = Rank.Queen;
queenC.Suit = Suit.Club;
Card fiveS = new Card();
fiveS.Rank = Rank.Five;
fiveS.Suit = Suit.Spade;
Card eightC = new Card();
eightC.Rank = Rank.Eight;
eightC.Suit = Suit.Club;
Card fourH = new Card();
fourH.Rank = Rank.Four;
fourH.Suit = Suit.Heart;
//Collection<Card> cards = new Collection<Card>();
Joe.ReceiveCard(kingD);
Joe.ReceiveCard(sevenD);
Joe.ReceiveCard(threeD);
Joe.ReceiveCard(eightD);
Joe.ReceiveCard(queenD);
Bob.ReceiveCard(aceS);
Bob.ReceiveCard(eightS);
Bob.ReceiveCard(sixS);
Bob.ReceiveCard(fourS);
Bob.ReceiveCard(queenS);
Sally.ReceiveCard(threeH);
Sally.ReceiveCard(eightC);
Sally.ReceiveCard(queenC);
Sally.ReceiveCard(fourH);
Sally.ReceiveCard(fiveS);
Collection <PokerPlayer> players = new Collection <PokerPlayer>();
players.Add(Bob);
players.Add(Joe);
players.Add(Sally);
//act
Game game = new Game(players, Round.ShowDown);
var winners = game.Run();
foreach (var player in players)
{
player.ShowCard();
}
PokerPlayer winner = new PokerPlayer("winner");
foreach (var player in winners)
{
winner = player;
Console.WriteLine("player {0} has {1} set of cards has value of {2}", player.name, player.hand, player.CardTotal);
}
//assert
Assert.AreEqual(Bob.name, winner.name);
}
public void CollectBet(PokerPlayer p)
{
AddToPot(p.betAmount);
p.betAmount = 0;
}
public void Tests()
{
var player = new PokerPlayer("name");
var hand = player.GenerateNewHand();
Assert.IsTrue(hand.Count > 0);
}
public abstract void Execute(PokerPlayer p);
public void InitPlay()
{
//Debug.Log("InitPlay");
gameState = GameState.Play;
//if this is the first round
if (!dealer)
{
//set dealer
int rand = Random.Range(0, activePlayers.Count);
dealer = activePlayers[rand];
UIManager.S.SetDealerPosition();
finalPlayer = dealer;
lastPlayerToSpeak = dealer;
//set currentPlayer
if (activePlayers.IndexOf(dealer) == activePlayers.Count - 1)
{
currentPlayer = activePlayers[0];
}
else
{
currentPlayer = activePlayers[activePlayers.IndexOf(dealer) + 1];
}
StartCoroutine(PlayGame()); // start the first round
return;
}
//if no player has money left, open cards and declare the winner
int totalSum = 0;
for (int i = 0; i < activePlayers.Count; i++)
{
totalSum += activePlayers[i].totalAmount;
}
if (totalSum == 0)
{
foreach (PokerPlayer p in activePlayers)
{
foreach (CardPokerFace c in p.cards)
{
if (!c.faceUp)
{
c.Flip();
}
}
}
InitDeclareWinner();
return;
}
// if this is NOT the first round
int openCardsCounter = 0;
// count the amount of open cards
for (int i = 0; i < activePlayers[0].cards.Count; i++)
{
if (activePlayers[0].cards[i].faceUp)
{
openCardsCounter++;
}
}
//if there are less than 4 open cards (not last round)
if (openCardsCounter < 4)
{
if (currentPlayer == lastPlayerToSpeak)
{
//if the final player raised, change the final player and resume round
if (lastPlayerToSpeak.command is RaiseCommand)
{
SetLastPlayerToSpeakToPlayerOnHisRight();
//set the new current player
SetCurrentPlayerToPlayerOnHisLeft();
StartCoroutine(PlayGame());
return;
}
//if the final player folded
else if (lastPlayerToSpeak.command is FoldCommand)
{
//SetLastPlayerToSpeakToPlayerOnHisRight();
UIManager.S.PlayCollectBetsAnimation(lastPlayerToSpeak);
if (lastPlayerToSpeak == finalPlayer)
{
SetFinalPlayerToPlayerOnHisRight();
}
lastPlayerToSpeak = finalPlayer;
//remove the old current player from the active list
RemoveFromActivePlayers(currentPlayer);
RemovePokerHand(currentPlayer);
//set the new current player
currentPlayer = GetPlayerLeftOfFinalPlayer();
}
//if the final player didnt raise or fold
else
{
//set the new current player
currentPlayer = GetPlayerLeftOfFinalPlayer();
}
InitReveal1(); //last player to speak finished his turn, time to reveal 1 card
return;
}
else //if the current player is not the last player to speak
{
//if the final player raised, change the final player and resume round
if (currentPlayer.command is RaiseCommand)
{
//set the last player to speak to the player on the right of the currentPlayer... complicated
if (activePlayers.IndexOf(currentPlayer) == 0)
{
lastPlayerToSpeak = activePlayers[activePlayers.Count - 1];
}
else
{
lastPlayerToSpeak = activePlayers[activePlayers.IndexOf(currentPlayer) - 1];
}
//set the new current player
SetCurrentPlayerToPlayerOnHisLeft();
StartCoroutine(PlayGame());
return;
}
//if the final player folded
else if (currentPlayer.command is FoldCommand)
{
PokerPlayer oldPlayer = currentPlayer; // reference to current player (who folded)
if (currentPlayer == finalPlayer)
{
SetFinalPlayerToPlayerOnHisRight();
}
//set the new current player
SetCurrentPlayerToPlayerOnHisLeft();
//remove the old current player from the active list
RemoveFromActivePlayers(oldPlayer);
RemovePokerHand(oldPlayer);
StartCoroutine(PlayGame());
return;
}
//if the current player didnt raise or fold
else
{
//set the new current player
SetCurrentPlayerToPlayerOnHisLeft();
StartCoroutine(PlayGame());
return;
}
}
}
//if this is the last round
else //if there are 4 cards revealed
{
if (currentPlayer == lastPlayerToSpeak)
{
//if the final player raised, change the final player and resume round
if (lastPlayerToSpeak.command is RaiseCommand)
{
SetLastPlayerToSpeakToPlayerOnHisRight();
//set the new current player
SetCurrentPlayerToPlayerOnHisLeft();
StartCoroutine(PlayGame());
return;
}
//if the last player to speak folded
else if (lastPlayerToSpeak.command is FoldCommand)
{
UIManager.S.PlayCollectBetsAnimation(lastPlayerToSpeak);
if (lastPlayerToSpeak == finalPlayer)
{
SetFinalPlayerToPlayerOnHisRight();
}
lastPlayerToSpeak = finalPlayer;
//remove the old current player from the active list
RemoveFromActivePlayers(currentPlayer);
RemovePokerHand(currentPlayer);
//set the new current player
currentPlayer = GetPlayerLeftOfFinalPlayer();
}
foreach (PokerPlayer p in activePlayers)
{
foreach (CardPokerFace c in p.cards)
{
if (!c.faceUp)
{
c.Flip();
}
}
}
InitDeclareWinner();//final player finished his turn, time to see who won
return;
}
else //if the current player is not the last player to speak
{
//if the current player raised, change the final player and resume round
if (currentPlayer.command is RaiseCommand)
{
//set the last player to speak to the player on the right of the currentPlayer... complicated
if (activePlayers.IndexOf(currentPlayer) == 0)
{
lastPlayerToSpeak = activePlayers[activePlayers.Count - 1];
}
else
{
lastPlayerToSpeak = activePlayers[activePlayers.IndexOf(currentPlayer) - 1];
}
//set the new current player
SetCurrentPlayerToPlayerOnHisLeft();
StartCoroutine(PlayGame());
return;
}
else if (currentPlayer.command is FoldCommand)
{
PokerPlayer oldPlayer = currentPlayer; // reference to current player (who folded)
//set the new current player
SetCurrentPlayerToPlayerOnHisLeft();
if (currentPlayer == finalPlayer)
{
SetFinalPlayerToPlayerOnHisRight();
}
//remove the old current player from the active list
RemoveFromActivePlayers(oldPlayer);
RemovePokerHand(oldPlayer);
StartCoroutine(PlayGame());
return;
}
else
{
//set the new current player
SetCurrentPlayerToPlayerOnHisLeft();
StartCoroutine(PlayGame());
return;
}
}
}
}
public void Fold(PokerPlayer player)
{
playersIn.Remove(player);
}
public int Register(PokerPlayer p)
{
AllPlayers.Add(p);
PlayerTabsManager.player_tabs_manager.AssignLocations();
return(AllPlayers.Count - 1);
}
public int Raise(PokerPlayer player, int raiseBy)
{
FModManager.StartEvent(FModLies.EVENTID_LIES_ACTIONS_POKER_DEALING);
int chipsNeeded = GetCallCost(player) + raiseBy;
bets[player] = GetHighestBet() + raiseBy;
previousRaiser = player;
return chipsNeeded;
}
public void Constructor_SetsProperties()
{
PokerPlayer player = new PokerPlayer("RobA2345");
Assert.AreEqual("RobA2345", player.Handle);
Assert.AreEqual("RobA2345", player.ToString());
}
public void Test_Jen_Wins()
{
//arrange
PokerPlayer Joe = new PokerPlayer("Joe");
PokerPlayer Bob = new PokerPlayer("Bob");
PokerPlayer Jen = new PokerPlayer("Jen");
//Joe
Card threeH = new Card();
threeH.Rank = Rank.Three;
threeH.Suit = Suit.Heart;
Card fiveD = new Card();
fiveD.Rank = Rank.Five;
fiveD.Suit = Suit.Diamond;
Card queenH = new Card();
queenH.Rank = Rank.Queen;
queenH.Suit = Suit.Heart;
Card nineC = new Card();
nineC.Rank = Rank.Nine;
nineC.Suit = Suit.Club;
Card nineD = new Card();
nineD.Rank = Rank.Nine;
nineD.Suit = Suit.Diamond;
//Bob card
Card twoH = new Card();
twoH.Rank = Rank.Two;
twoH.Suit = Suit.Heart;
Card twoC = new Card();
twoC.Rank = Rank.Two;
twoC.Suit = Suit.Club;
Card tenC = new Card();
tenC.Rank = Rank.Ten;
tenC.Suit = Suit.Club;
Card aceH = new Card();
aceH.Rank = Rank.Ace;
aceH.Suit = Suit.Heart;
Card fiveS = new Card();
fiveS.Rank = Rank.Five;
fiveS.Suit = Suit.Spade;
//Jen card
Card fiveC = new Card();
fiveC.Rank = Rank.Five;
fiveC.Suit = Suit.Club;
Card sevenD = new Card();
sevenD.Rank = Rank.Seven;
sevenD.Suit = Suit.Diamond;
Card nineH = new Card();
nineH.Rank = Rank.Nine;
nineH.Suit = Suit.Heart;
Card nineS = new Card();
nineS.Rank = Rank.Nine;
nineS.Suit = Suit.Spade;
Card queenS = new Card();
queenS.Rank = Rank.Queen;
queenS.Suit = Suit.Spade;
//Collection<Card> cards = new Collection<Card>();
Joe.ReceiveCard(threeH);
Joe.ReceiveCard(fiveD);
Joe.ReceiveCard(nineC);
Joe.ReceiveCard(nineD);
Joe.ReceiveCard(queenH);
Bob.ReceiveCard(twoH);
Bob.ReceiveCard(twoC);
Bob.ReceiveCard(fiveS);
Bob.ReceiveCard(tenC);
Bob.ReceiveCard(aceH);
Jen.ReceiveCard(fiveC);
Jen.ReceiveCard(sevenD);
Jen.ReceiveCard(nineH);
Jen.ReceiveCard(nineS);
Jen.ReceiveCard(queenS);
Collection <PokerPlayer> players = new Collection <PokerPlayer>();
players.Add(Bob);
players.Add(Joe);
players.Add(Jen);
//act
Game game = new Game(players, Round.ShowDown);
var winners = game.Run();
foreach (var player in players)
{
player.ShowCard();
}
PokerPlayer winner = new PokerPlayer("winner");
foreach (var player in winners)
{
winner = player;
Console.WriteLine("player {0} has {1} set of cards has value of {2}", player.name, player.hand, player.CardTotal);
}
//assert
Assert.AreEqual(Jen.name, winner.name);
}
public void Test_Joe_Wins()
{
//arrange
//Deck baraha = new Deck();
//Dealer john = new Dealer();
//john.Shuffle(baraha.Cards);
PokerPlayer Joe = new PokerPlayer("Joe");
PokerPlayer Bob = new PokerPlayer("Bob");
PokerPlayer Sally = new PokerPlayer("Sally");
//Joe
Card eightS = new Card();
eightS.Rank = Rank.Eight;
eightS.Suit = Suit.Spade;
Card aceD = new Card();
aceD.Rank = Rank.Ace;
aceD.Suit = Suit.Diamond;
Card queenD = new Card();
queenD.Rank = Rank.Queen;
queenD.Suit = Suit.Diamond;
Card eightD = new Card();
eightD.Rank = Rank.Eight;
eightD.Suit = Suit.Diamond;
Card jackH = new Card();
jackH.Rank = Rank.Jack;
jackH.Suit = Suit.Heart;
//Bob card
Card aceS = new Card();
aceS.Rank = Rank.Ace;
aceS.Suit = Suit.Spade;
Card queenS = new Card();
queenS.Rank = Rank.Queen;
queenS.Suit = Suit.Spade;
Card sixS = new Card();
sixS.Rank = Rank.Six;
sixS.Suit = Suit.Spade;
Card eightH = new Card();
eightH.Rank = Rank.Eight;
eightH.Suit = Suit.Heart;
Card fourC = new Card();
fourC.Rank = Rank.Four;
fourC.Suit = Suit.Club;
//Sally card
Card threeH = new Card();
threeH.Rank = Rank.Three;
threeH.Suit = Suit.Heart;
Card queenC = new Card();
queenC.Rank = Rank.Queen;
queenC.Suit = Suit.Club;
Card fourS = new Card();
fourS.Rank = Rank.Four;
fourS.Suit = Suit.Spade;
Card eightC = new Card();
eightC.Rank = Rank.Eight;
eightC.Suit = Suit.Club;
Card fourH = new Card();
fourH.Rank = Rank.Four;
fourH.Suit = Suit.Heart;
//Collection<Card> cards = new Collection<Card>();
Joe.ReceiveCard(aceD);
Joe.ReceiveCard(eightS);
Joe.ReceiveCard(jackH);
Joe.ReceiveCard(eightD);
Joe.ReceiveCard(queenD);
Bob.ReceiveCard(aceS);
Bob.ReceiveCard(eightH);
Bob.ReceiveCard(sixS);
Bob.ReceiveCard(fourC);
Bob.ReceiveCard(queenS);
Sally.ReceiveCard(threeH);
Sally.ReceiveCard(eightC);
Sally.ReceiveCard(queenC);
Sally.ReceiveCard(fourH);
Sally.ReceiveCard(fourS);
Collection <PokerPlayer> players = new Collection <PokerPlayer>();
players.Add(Bob);
players.Add(Joe);
players.Add(Sally);
//act
Game game = new Game(players, Round.ShowDown);
var winners = game.Run();
foreach (var player in players)
{
player.ShowCard();
}
PokerPlayer winner = new PokerPlayer("winner");
Console.WriteLine("we have {0} winner/s", winners.Count);
foreach (var player in winners)
{
winner = player;
Console.WriteLine("player {0} has {1} set of cards has value of {2}", player.name, player.hand, player.CardTotal);
}
//assert
Assert.AreEqual(Joe.name, winner.name);
}
public int GetCallCost(PokerPlayer player)
{
return GetHighestBet() - (int)bets[player];
}
