public static void GenerateStrategy()
{
List <Card> orderedCards = new List <Card>();
for (int deck = 0; deck < Configuration.NUM_DECKS_IN_SHOE; deck++)
{
orderedCards.AddRange(new FrenchDeck().cards);
}
Queue <Card> shoe = Utilities.ShuffleShoe(orderedCards);
IPlayerStrategy strategy = new RandomPlayerStrategy();
for (int gameIndex = 0; gameIndex < Configuration.STRATEGY_GENERATOR_NUM_GAMES; gameIndex++)
{
BlackjackGame bjgame = new BlackjackGame();
int bet = 10;
BlackjackGameResult result = bjgame.PlayGame(shoe, bet, strategy);
double currentShoePenetration = 1 - (shoe.Count / (double)orderedCards.Count);
if (currentShoePenetration >= Configuration.RESHUFFLE_PENETRATION_PERCENT)
{
Console.WriteLine("Shuffling shoe");
shoe = Utilities.ShuffleShoe(orderedCards);
}
}
}
public void IfPlayerBustsEndGame()
{
var cards = new List <Card>()
{
new Card("QUEENS", "CLUBS"), new Card("KINGS", "HEARTS")
};
var dealerHand = new Hand {
CardsInHand = cards
};
var mock = new Mock <IConsoleReader>();
mock.SetupSequence(reader => reader.GetInput()).Returns("1");
var player = new Player(new Hand(), mock.Object);
var mockRng = new Mock <IRng>();
mockRng.Setup(rng => rng.Next(It.IsAny <int>(), It.IsAny <int>())).Returns(1);
IDealer dealer = new Dealer(dealerHand, mockRng.Object);
var deck = new Deck();
var blackjack = new BlackjackGame(player, dealer, deck);
blackjack.PlayGame();
Assert.True(player.HasBusted());
Assert.False(blackjack.IsPlayingGame);
Assert.False(blackjack.IsPlayerTurn);
}
private void ReconstructRoundPlayerPlayerFields(BlackjackGame game)
{
if (game == null)
{
return;
}
if (!game.IsRoundInProgress)
{
return;
}
var gameDealerField = typeof(BlackjackGame)
.GetField("_dealer", BindingFlags.Instance | BindingFlags.NonPublic);
var gameDealer = (BlackjackGameDealer)gameDealerField.GetValue(game);
var dealerCurrentRound = gameDealer.RoundInProgress;
foreach (var player in dealerCurrentRound.RoundPlayers)
{
var gamePlayer = game.Players.FirstOrDefault(a => a.Id == player.Player.Id);
if (gamePlayer != null)
{
var roundPlayerPlayerField = typeof(BlackjackGameRoundPlayer)
.GetProperty("Player");
roundPlayerPlayerField.SetValue(player, gamePlayer);
}
}
}
public void return_score_of_3_card_hand_with_no_aces()
{
foreach (Rank rank1 in Enum.GetValues(typeof(Rank)))
{
mockCard1.Setup(c => c.rank).Returns(rank1);
foreach (Rank rank2 in Enum.GetValues(typeof(Rank)))
{
mockCard2.Setup(c => c.rank).Returns(rank2);
foreach (Rank rank3 in Enum.GetValues(typeof(Rank)))
{
mockCard3.Setup(c => c.rank).Returns(rank3);
IHand hand = new Hand();
ICard card1 = mockCard1.Object;
ICard card2 = mockCard2.Object;
ICard card3 = mockCard3.Object;
hand.AddCard(card1);
hand.AddCard(card2);
hand.AddCard(card3);
int scoreCard1 = BlackjackGame.GetCardValue(card1);
int scoreCard2 = BlackjackGame.GetCardValue(card2);
int scoreCard3 = BlackjackGame.GetCardValue(card3);
int score = hand.Score(true);
int expectedScore = scoreCard1 + scoreCard2 + scoreCard3;
if (hand.AceCount() == 0)
{
Assert.IsTrue(expectedScore == score);
}
}
}
}
}
public void BlackjackGameFullSimulatedGameTest()
{
// arrange
BlackjackGame game = new BlackjackGame()
{
AnteAmount = 1.00M
};
decimal startingChipsPerPlayer = 100M;
int roundsToDeal = 3;
// act
game.BeginGame();
// assert
Assert.IsTrue(game.State.GetType() == typeof(ReadyToPlayState));
Assert.IsTrue(game.Players.Count > 1); // we have players?
Assert.AreEqual(game.Players.Where(p => p.Bettor.Chips > 0).Count(), game.Players.Count()); // the players all have chips?
// act
game.BeginPlay();
// assert
Assert.IsTrue(game.State.GetType() == typeof(CardsShuffledState));
Assert.IsTrue(IsDeckShuffled(Deck.Instance)); // the deck is shuffled?
// act
game.Ante();
// assert
Assert.IsTrue(game.State.GetType() == typeof(AntePlacedState));
Assert.AreEqual(Pot.Instance.Chips, game.AnteAmount * game.Players.Count); // pot has the correct amount in it?
Assert.IsTrue(game.Players.Where(p => p.Bettor.Chips == startingChipsPerPlayer - game.AnteAmount).Count() == game.Players.Count); // all the players' chips are reduced by the ante amount?
// Deal / bet iterations
for (int i = 1; i <= roundsToDeal; i++)
{
// act
game.DealRound();
// assert
Assert.IsTrue(game.State.GetType() == typeof(CardsDealtState));
Assert.IsTrue(game.Players.Where(p => p.Hand.Size == i).Count() == game.Players.Count()); // all the players have the correct number of cards?
// act
game.AnalyzeHands();
// assert
Assert.IsTrue(game.State.GetType() == typeof(BetsPlacedState));
decimal currentPlayersChipsTotal = game.Players.Select(p => p.Bettor.Chips).Aggregate((ch1, ch2) => ch1 + ch2);
Assert.AreEqual(currentPlayersChipsTotal + Pot.Instance.Chips, startingChipsPerPlayer * game.Players.Count); // pot has the correct amount in it?
}
// act
game.NoMoreRounds();
// assert
Assert.IsTrue(game.State.GetType() == typeof(CardGameFinishedState));
Assert.IsTrue(game.Players.Where(p => p.HandStatus == HandStatus.Winner).Count() > 0); // there was at least one winner?
}
static void Main(string[] args)
{
Console.Write("This programm represents the blackjack game with opportunity to split");
Console.Write(" cards, double wagers and surrender.\n");
Console.WriteLine("You can choose one of 3 strategies to play:");
Console.WriteLine("0 - basic strategy");
Console.WriteLine("1 - cards counting strategy, based on basic strategy and cards count");
Console.WriteLine("2 - simple strategy, based on basic strategy and players score at the moment");
Console.WriteLine("The programm will print the approximate sum of your wagers when the game ends");
Console.WriteLine("Please enter the correct number of strategy you want to play");
int strategy = Convert.ToInt32(Console.ReadLine()); // in ascii table "0" has 48 number
if (strategy < 0 || strategy > 2)
{
Console.WriteLine("You number isn't right.");
return;
}
Bots botsStrategy = (Bots)strategy;
Decks playingDecks = new Decks();
playingDecks.FillCards();
double win = 0;
BlackjackGame game = new BlackjackGame(playingDecks, 1600, botsStrategy); // 1600 is initial players money
for (int i = 0; i < 40; i++)
{
win += game.Game();
}
Console.WriteLine("Approximate sum with 40 played rounds is {0}", win / 40.0);
Console.WriteLine("Press enter button to exit");
Console.ReadLine();
}
private async Task <string> DisplayGameStatus(string channelId, BlackjackGame game)
{
var messageBuilder = new EbmedMessageBuilder()
.AddCustomAuthor("Blackjack");
messageBuilder.AddMessageField(new EmbedField("Prize pool",
string.Format("{0:0.##}", game.MoneyToWin)));
foreach (var member in game.Members)
{
var userCards = string.Empty;
foreach (var card in member.UserCards)
{
userCards += $"``{card.Symbol} {GetCardEmoji(card.Color)}`` ";
}
userCards += $"({string.Format(TextFormat.BoldText, member.CurrentScore)})";
messageBuilder.AddMessageField(new EmbedField(
string.Format(TextFormat.BoldText, member.UserNickname), userCards));
}
var response = await _discordRestClient.PostMessage(channelId,
new Message { Embed = messageBuilder.Build() });
return(response.Data.Id);
}
private async Task ManagePoints(IEnumerable <string> winners, BlackjackGame game)
{
// Add points to winners
if (winners.Count() == 1)
{
await _usersPointsRepository.AddBalanceToUserAccount(winners.First(), game.MoneyToWin);
}
else
{
var splittedAmount = Math.Floor(game.MoneyToWin / winners.Count());
foreach (var winner in winners)
{
await _usersPointsRepository.AddBalanceToUserAccount(winner, (float)splittedAmount);
}
}
// Remove points from loosers
var losers = game.Members.Where(x => !winners.ToList().Contains(x.UserId))
.Select(x => x.UserId);
foreach (var loser in losers)
{
await _usersPointsRepository.SubtractBalanceFromUserAccount(loser, game.BetAmount);
}
}
public void GameTest()
{
Decks playingDecks = new Decks();
playingDecks.FillCards();
byte[] gameCards = new byte[416];
gameCards = playingDecks.Cards;
byte bjFlag;
int testResult;
LibraryLoader libraryLoader = new LibraryLoader("../../../../BotsLibrary/BotsLibrary.dll");
Assembly asm = libraryLoader.LoadLibrary();
PluginHelper pluginHelper = new PluginHelper(asm);
// Dealer has blackjack and player in both hands has blackjack too
gameCards[0] = 10; gameCards[1] = 1; gameCards[2] = 1; gameCards[3] = 10;
gameCards[4] = 10; gameCards[5] = 1; bjFlag = 3; testResult = 32;
SomeGameTest(pluginHelper, playingDecks, gameCards, testResult, bjFlag);
gameCards[0] = 10; gameCards[1] = 10; gameCards[2] = 10; gameCards[3] = 1;
bjFlag = 0; testResult = -16; // Dealer has blackjack, player's score is 20.
SomeGameTest(pluginHelper, playingDecks, gameCards, testResult, bjFlag);
gameCards[0] = 10; gameCards[1] = 10; gameCards[2] = 10; gameCards[3] = 7;
bjFlag = 0; testResult = 32; // Dealer has 17, player's score is 20.
SomeGameTest(pluginHelper, playingDecks, gameCards, testResult, bjFlag);
gameCards[0] = 10; gameCards[1] = 10; gameCards[2] = 5; gameCards[3] = 7;
bjFlag = 0; testResult = 8; // Player surrendered
SomeGameTest(pluginHelper, playingDecks, gameCards, testResult, bjFlag);
gameCards[0] = 9; gameCards[1] = 8; gameCards[2] = 8; gameCards[3] = 9; gameCards[4] = 10;
gameCards[5] = 6; gameCards[6] = 10; bjFlag = 0; testResult = 64; // Player won with both hands
SomeGameTest(pluginHelper, playingDecks, gameCards, testResult, bjFlag);
// Now we test two games successively
playingDecks.FillCards();
gameCards = playingDecks.Cards;
gameCards[0] = 10; gameCards[1] = 10; gameCards[2] = 5; gameCards[3] = 7;
bjFlag = 0; testResult = 8; // Player surrendered
uint initialMoney = 1600;
BlackjackGame testGame = new BlackjackGame(playingDecks, initialMoney);
object[] parameters = new object[] { testGame.PlayingDealer.DealerCards[0], (uint)testGame.InitialMoney, testGame.PlayingCards, (uint)16 };
pluginHelper.CreatePlayer(parameters, 1);
testGame.Player = pluginHelper.players[1];
Assert.AreEqual(testGame.Game(), testResult);
for (int i = 0; i < 416; i++)
{
Assert.AreEqual(testGame.PlayingCards.Cards[i], gameCards[i]);
}
// Second game
gameCards[0] = 9; gameCards[1] = 8; gameCards[2] = 8; gameCards[3] = 9; gameCards[4] = 10;
gameCards[5] = 6; gameCards[6] = 10; bjFlag = 0; testResult = 64; // Player won with both hands
Assert.AreEqual(testGame.Game(), testResult);
for (int i = 0; i < 416; i++)
{
Assert.AreEqual(testGame.PlayingCards.Cards[i], gameCards[i]);
}
}
static void Main(string[] args)
{
Redraw(null, GameEventType.GameUpdated, "App Started");
BlackjackGame blackjackGame = null;
PlayerController playerController = null;
while (true)
{
var cmd = Console.ReadKey();
switch (cmd.Key)
{
case ConsoleKey.UpArrow:
selectedItem = selectedItem > 0 ? selectedItem - 1 : selectedItem;
Redraw(blackjackGame, GameEventType.GameUpdated, "Menu updated");
break;
case ConsoleKey.DownArrow:
selectedItem = selectedItem < menuItems.Length - 1 ? selectedItem + 1 : selectedItem;
Redraw(blackjackGame, GameEventType.GameUpdated, "Menu updated");
break;
case ConsoleKey.Enter:
switch (selectedItem)
{
case 0: // Initialize (New Game)
if (blackjackGame != null)
{
blackjackGame.GameEvent -= Redraw;
}
blackjackGame = new BlackjackGame("Console Dealer");
blackjackGame.GameEvent += Redraw;
playerController = blackjackGame.InitializePlayer("Console Player #1");
break;
case 1: // Ready
try { playerController?.SetReady(); }
catch (OperationCanceledException e) { Console.WriteLine("Exception: " + e.Message); }
break;
case 2: // Hit
try { playerController?.Hit(); }
catch (OperationCanceledException e) { Console.WriteLine("Exception: " + e.Message); }
break;
case 3: // Stand
try { playerController?.Stand(); }
catch (OperationCanceledException e) { Console.WriteLine("Exception: " + e.Message); }
break;
case 4:
return;
}
break;
}
}
}
public void ThreePlayersCanBeAdded()
{
//Arrange
string playerOneFirstName = "testUserOneFirstName";
string playerOneLastName = "testUserOneLastName";
int playerOneIdentifier = 1;
string playerTwoFirstName = "testUserTwoFirstName";
string playerTwoLastName = "testUserTwoLastName";
int playerTwoIdentifier = 10;
string playerThreeFirstName = "testUserThreeFirstName";
string playerThreeLastName = "testUserThreeLastName";
int playerThreeIdentifier = 100;
EPlayers playerOne = EPlayers.Player1;
EPlayers playerTwo = EPlayers.Player2;
EPlayers playerThree = EPlayers.Player3;
BlackjackGame testGame;
//Act
testGame = new BlackjackGame(6);
Player testPlayerOne = new(playerOneFirstName, playerOneLastName, playerOneIdentifier);
Player testPlayerTwo = new(playerTwoFirstName, playerTwoLastName, playerTwoIdentifier);
Player testPlayerThree = new(playerThreeFirstName, playerThreeLastName, playerThreeIdentifier);
testGame.AddNewPlayer(testPlayerOne);
testGame.AddNewPlayer(testPlayerTwo);
testGame.AddNewPlayer(testPlayerThree);
//Assert
if (testGame.Players[playerOne].PlayerIdentifier != playerOneIdentifier || testGame.Players[playerOne].FirstName != playerOneFirstName ||
testGame.Players[playerOne].LastName != playerOneLastName)
{
string errorMessage = $"Added player {playerOne} does not exist in the players list of the game!";
Assert.Fail(errorMessage);
}
//Assert
if (testGame.Players[playerTwo].PlayerIdentifier != playerTwoIdentifier || testGame.Players[playerTwo].FirstName != playerTwoFirstName ||
testGame.Players[playerTwo].LastName != playerTwoLastName)
{
string errorMessage = $"Added player {playerTwo} does not exist in the players list of the game!";
Assert.Fail(errorMessage);
}
//Assert
if (testGame.Players[playerThree].PlayerIdentifier != playerThreeIdentifier || testGame.Players[playerThree].FirstName != playerThreeFirstName ||
testGame.Players[playerThree].LastName != playerThreeLastName)
{
string errorMessage = $"Added player {playerThree} does not exist in the players list of the game!";
Assert.Fail(errorMessage);
}
}
private void SetWagers(BlackjackGame game)
{
var players = game.Players.ToList();
var playersToWager = game.Players.Where(a => a.Position % 2 == 0).ToList();
foreach (var player in playersToWager)
{
player.SetWager(50);
}
}
public void SomeGameTest(Decks playingCards, byte[] gameCards, int result, byte bjFlag, Bots strategy = Bots.BasicStrategy)
{
uint initialMoney = 1600;
BlackjackGame testGame = new BlackjackGame(playingCards, initialMoney, strategy);
Assert.AreEqual(testGame.Game(), result);
for (int i = 0; i < 416; i++)
{
Assert.AreEqual(testGame.PlayingCards.Cards[i], gameCards[i]);
}
}
static void Main()
{
BlackjackGame game = new BlackjackGame(
new System.IO.StreamReader(Console.OpenStandardInput()),
new System.IO.StreamWriter(Console.OpenStandardOutput()),
new ConsoleKeyReader()
);
Console.Title = game.Title;
game.Run();
}
public void return_score_of_one_card_hand()
{
foreach (Rank rank1 in Enum.GetValues(typeof(Rank)))
{
IHand hand = new Hand();
ICard card1 = mockCard1.Object;
mockCard1.Setup(c => c.rank).Returns(rank1);
hand.AddCard(card1);
int expectedScore = BlackjackGame.GetCardValue(card1);
Assert.AreEqual(expectedScore, hand.Score(true));
}
}
public BlackjackGameDealerViewModel(BlackjackGame game)
{
if (game == null)
{
throw new ArgumentNullException("game");
}
Name = "Dealer";
Hand = new BlackjackHandViewModel(game.DealerHand);
CanShowHand = game.Players.All(a => !a.HasAction);
PercentOfCardsRemainingInShoe = game.PercentRemainingInDealerShoe;
}
public async Task Stand()
{
BlackjackGame agame = null;
int listLocation = 0;
foreach (BlackjackGame b in bjg)
{
if (Context.User.Id == b._playerID)
{
agame = b;
break;
}
listLocation++;
}
if (agame == null)
{
await Context.Channel.SendMessageAsync("Silly, you ain't even playing Blackjack! Type !nep play blackjack to start! ~nepu");
return;
}
agame.EndPlayerTurn(true);
GraphicsMethods gm = new GraphicsMethods();
while (true)
{
agame.DrawCard(false);
if (agame.DealerTurnEnd)
{
break;
}
}
await agame.HandMsg.DeleteAsync();
await Context.Channel.SendFileAsync(gm.CardLayout(agame._playerHand, agame._dealerHand, Context.User.Username), string.Concat("[Dealer:] ", agame.DealerTotal, " [Player:] ", agame.PlayerTotal, " [Bet Amt:] ", agame.TotalBet));
if (agame.GameEnd())
{
SocketUser contUser = Context.User;
UserData ud = ExtensionMethods.FindPerson(contUser.Id);
bjg.RemoveAt(listLocation);
if (agame.WhoWon() == 1)
{
EndBlackjack(Context.User.Id, agame.TotalBet, true);
await Context.Channel.SendMessageAsync(string.Concat($"{ExtensionMethods.NeptuneEmojis(false)} You won, congrats and all that stuff, now how 'bout buying me a pudding? ~nepu By the way! You have ", ud.Pudding, " pudding now!"));
}
if (agame.WhoWon() == 2)
{
EndBlackjack(Context.User.Id, agame.TotalBet, false);
await Context.Channel.SendMessageAsync(string.Concat($"{ExtensionMethods.NeptuneEmojis(true)} Yay I won!! Ahem suck to be you! Your {agame.TotalBet} belongs to me now! You have ", ud.Pudding, " pudding left!"));
}
}
}
static void Main(string[] args)
{
//BlackjackSettings settings = SaveDefaultSettings();
BlackjackSettings settings = LoadSettingsFromFile("settings.xml");
BlackjackGame game = new BlackjackGame(settings);
//ConsoleBlackjackPlayer player = new ConsoleBlackjackPlayer() { Game = game };
var handsToPlay = 100000000L;
var player = new BasicStrategyPlayer(handsToPlay);
game.Play(new [] { player });
Console.WriteLine("Profit: {0}%", Math.Round((player.Profit / settings.MinimumBet / (decimal)handsToPlay) * 100m, 2));
}
private void RecontructPlayerGameFields(BlackjackGame game)
{
if (game == null)
{
return;
}
var playerGameField = typeof(BlackjackGamePlayer)
.GetField("_game", BindingFlags.Instance | BindingFlags.NonPublic);
game.Players.ToList()
.ForEach(player => playerGameField.SetValue(player, game));
}
public static void Main(string[] args)
{
var consoleReader = new ConsoleReader();
var deck = new Deck();
var rng = new Rng();
var hand = new Hand();
var playerHand = new Hand();
var dealer = new Dealer(hand, rng);
var player = new Player(playerHand, consoleReader);
var blackjack = new BlackjackGame(player, dealer, deck);
blackjack.PlayGame();
}
public void SomeGameTest(PluginHelper pluginHelper, Decks playingCards, byte[] gameCards, int result, byte bjFlag, Bots strategy = Bots.BasicStrategy)
{
uint initialMoney = 1600;
BlackjackGame testGame = new BlackjackGame(playingCards, initialMoney);
object[] parameters = new object[] { testGame.PlayingDealer.DealerCards[0], (uint)testGame.InitialMoney, testGame.PlayingCards, (uint)16 };
pluginHelper.CreatePlayer(parameters, 1);
testGame.Player = pluginHelper.players[1];
Assert.AreEqual(testGame.Game(), result);
for (int i = 0; i < 416; i++)
{
Assert.AreEqual(testGame.PlayingCards.Cards[i], gameCards[i]);
}
}
private BlackjackGame InitializeGameForTesting()
{
var game = new BlackjackGame(
minWager: 1,
maxWager: 100,
maxPlayers: _numberOfPlayers);
for (int i = 0; i < _numberOfPlayers; i++)
{
var player = new TestPlayer(name: "p" + i);
game.AddPlayer(player.Account, player.Name);
}
return(game);
}
static void Redraw(BlackjackGame blackjackGame, GameEventType gameEventType, String eventMessage)
{
Console.Clear();
// Print Menu
for (int i = 0; i < menuItems.Length - 1; i++)
{
Console.WriteLine(string.Format(" {0}. {1} \t {2}", (i + 1), menuItems[i], selectedItem == i ? "<<<" : ""));
}
Console.WriteLine(string.Format(" 0. {0} \t {1}", menuItems[menuItems.Length - 1], selectedItem == menuItems.Length - 1 ? "<<<" : ""));
Console.WriteLine();
// Game Stuff
Console.WriteLine(blackjackGame?.ToString());
Console.WriteLine("Event> " + eventMessage + "\n");
}
public void IfPlayerHasBlackjackPlayerTurnOver()
{
var deck = new Deck();
var mockDealer = new Mock <IDealer>();
var mockPlayer = new Mock <IPlayer>();
mockPlayer.Setup(player => player.HasBlackJack()).Returns(true);
mockPlayer.Setup(player => player.HasBusted()).Returns(false);
var blackjack = new BlackjackGame(mockPlayer.Object, mockDealer.Object, deck);
blackjack.PlayPlayersTurn();
Assert.False(blackjack.IsPlayerTurn);
Assert.True(blackjack.IsDealerTurn);
}
private void PerformRound(BlackjackGame game)
{
BlackjackGamePlayer player;
while ((player = game.Players.FirstOrDefault(f => f.HasAction)) != null)
{
if (player.Hand.Score < 17)
{
player.Hit();
}
else
{
player.Stand();
}
}
}
/// <summary>
/// reinitialize game to create new one
/// </summary>
/// <returns></returns>
public async Task ReinitGame()
{
_blackjackGame = new BlackjackGame();
_messageBuilder = new BlackjackMessageBuilder(_blackjackGame);
foreach (var entry in Websockets.ToList())
{
var wrapper = entry.Value;
var user = wrapper.BlackjackUser;
if (user == null)
{
continue;
}
user = user.Reinit();
_blackjackGame.AddUser(wrapper.Place, user);
}
await CheckStartGame(false);
}
public IActionResult PlayBlackjack(string bet)
{
/* Get the current logged in user. */
ViewBag.userId = _userManager.GetUserId(HttpContext.User);
ApplicationUser user = _userManager.FindByIdAsync(ViewBag.userId).Result;
ViewBag.User = user;
// set up game + player objects
BlackjackGame blackjack = new BlackjackGame(50, 5000, 6);
BlackjackPlayer player = new BlackjackPlayer(user);
blackjack.AddPlayer(player);
/* Validation */
ViewBag.Errors = new List <string>();
if (!int.TryParse(bet, out int i))
{
ViewBag.Errors.Add("The bet must be an integer."); // checks if bet is an integer
}
/* If any errors got added to error list we'll return the view now */
if (ViewBag.Errors.Count >= 1)
{
return(View("Coinflip"));
}
// take players bet
blackjack.Player.Bet(i); // i == bet after validation.
// display hand values
ViewBag.PlayerHandValue = blackjack.Player.Hand.GetValue();
ViewBag.DealerHandValue = blackjack.Dealer.Hand.GetValue();
// check if player got a blackjack
if (ViewBag.PlayerHand.Blackjack)
{
blackjack.Dealer.Payout(blackjack.Player); // we need an optional blackjack parameter on this method right?
ViewBag.Results = "You got a Blackjack!";
}
else
{
ViewBag.CanHit = ViewBag.PlayerHand.CanHit();
}
return(View("Blackjack"));
}
public void CardsAreCorrectlyShuffled()
{
//Arrange
int numberOfCardDecks = 6;
IBlackjackGame game;
//Act
game = new BlackjackGame(numberOfCardDecks);
game.ShuffleCards();
int numberOfDisplacedCards = CalculateDisplacedNumberOfCards(numberOfCardDecks, game.PlayingCards);
//Assert
if (numberOfDisplacedCards < game.PlayingCards.Count / 2)
{
string errorMessage = $"Minimum accepted number of displaced cards is {game.PlayingCards.Count / 2}. Actual number of displaced cards is {numberOfDisplacedCards}.";
Assert.Fail(errorMessage);
}
}
public void DealerShouldDealCardIfPlayerHits()
{
var playerHand = new Hand();
var mock = new Mock <IConsoleReader>();
mock.SetupSequence(reader => reader.GetInput()).Returns("1").Returns("0");
var player = new Player(playerHand, mock.Object);
var dealerHand = new Hand();
var mockRng = new Mock <IRng>();
mockRng.Setup(rng => rng.Next(It.IsAny <int>(), It.IsAny <int>())).Returns(1);
var dealer = new Dealer(dealerHand, mockRng.Object);
var deck = new Deck();
var blackjack = new BlackjackGame(player, dealer, deck);
blackjack.PlayPlayersTurn();
Assert.Equal(1, player.hand.CardsInHand.Count);
}
/// <summary>
/// constructor
/// </summary>
public Blackjack_Form()
{
InitializeComponent();
//addFonts();
game = new BlackjackGame(this);
// set-up form controls
x_loc = new int[4] {
870, 576, 282, -12
};
y_loc = 644;
button_reset.Enabled = false;
display_playerControls(false, 0);
groupboxes.Add(groupBox_p1);
groupboxes.Add(groupBox_p2);
groupboxes.Add(groupBox_p3);
groupboxes.Add(groupBox_p4);
groupboxes.Add(groupBox_dealer);
labels_hand.Add(label_h1);
labels_hand.Add(label_h2);
labels_hand.Add(label_h3);
labels_hand.Add(label_h4);
labels_hand.Add(label_hd);
labels_balance.Add(label_b1);
labels_balance.Add(label_b2);
labels_balance.Add(label_b3);
labels_balance.Add(label_b4);
panels_bets.Add(flowPanel_1);
panels_bets.Add(flowPanel_2);
panels_bets.Add(flowPanel_3);
panels_bets.Add(flowPanel_4);
playernames.Add(textBox1);
playernames.Add(textBox2);
playernames.Add(textBox3);
playernames.Add(textBox4);
}
public void BlackjackGameFullSimulatedGameTest()
{
// arrange
BlackjackGame game = new BlackjackGame() { AnteAmount = 1.00M };
decimal startingChipsPerPlayer = 100M;
int roundsToDeal = 3;
// act
game.BeginGame();
// assert
Assert.IsTrue(game.State.GetType() == typeof(ReadyToPlayState));
Assert.IsTrue(game.Players.Count > 1); // we have players?
Assert.AreEqual(game.Players.Where(p => p.Bettor.Chips > 0).Count(), game.Players.Count()); // the players all have chips?
// act
game.BeginPlay();
// assert
Assert.IsTrue(game.State.GetType() == typeof(CardsShuffledState));
Assert.IsTrue(IsDeckShuffled(Deck.Instance)); // the deck is shuffled?
// act
game.Ante();
// assert
Assert.IsTrue(game.State.GetType() == typeof(AntePlacedState));
Assert.AreEqual(Pot.Instance.Chips, game.AnteAmount * game.Players.Count); // pot has the correct amount in it?
Assert.IsTrue(game.Players.Where(p => p.Bettor.Chips == startingChipsPerPlayer - game.AnteAmount).Count() == game.Players.Count); // all the players' chips are reduced by the ante amount?
// Deal / bet iterations
for (int i = 1; i <= roundsToDeal; i++)
{
// act
game.DealRound();
// assert
Assert.IsTrue(game.State.GetType() == typeof(CardsDealtState));
Assert.IsTrue(game.Players.Where(p => p.Hand.Size == i).Count() == game.Players.Count()); // all the players have the correct number of cards?
// act
game.AnalyzeHands();
// assert
Assert.IsTrue(game.State.GetType() == typeof(BetsPlacedState));
decimal currentPlayersChipsTotal = game.Players.Select(p => p.Bettor.Chips).Aggregate((ch1, ch2) => ch1 + ch2);
Assert.AreEqual(currentPlayersChipsTotal + Pot.Instance.Chips, startingChipsPerPlayer * game.Players.Count); // pot has the correct amount in it?
}
// act
game.NoMoreRounds();
// assert
Assert.IsTrue(game.State.GetType() == typeof(CardGameFinishedState));
Assert.IsTrue(game.Players.Where(p => p.HandStatus == HandStatus.Winner).Count() > 0); // there was at least one winner?
}