public BlackjackResponse Chat(
BlackjackTable table,
BlackjackPlayer player,
string message)
{
return(send(new BlackjackRequest(player, BlackjackAction.Chat, table, message)));
}
/// <summary>
/// Load Player Profiles in Players Panel
/// </summary>
private void LoadPlayers()
{
players = new BlackjackPlayer[nPlayers];
otherPlayers = new List <int>();
for (int i = 0; i < nPlayers; i++)
{
players[i] = new BlackjackPlayer("player" + (i).ToString());
otherPlayers.Add(i);
players[i].giveHand(new List <Card>());
}
otherPlayers.RemoveAt(myindex);
if (nPlayers >= 2)
{
lblPlayerXname.Text = "Player" + otherPlayers[0].ToString();
pnlPlayerX.Show();
}
if (nPlayers >= 3)
{
lblPlayerYname.Text = "Player" + otherPlayers[1].ToString();
pnlPlayerY.Show();
}
if (nPlayers == 4)
{
lblPlayerZname.Text = "Player" + otherPlayers[2].ToString();
pnlPlayerZ.Show();
}
flowPnlPlayers.Show();
}
public static int PayoutForBankOnAPlayer(string playerName)
{
BlackjackPlayer player = blackjack.GetPlayer(playerName);
if (!IsBusted(playerName, false) && player.Hand.Count >= 5)//5 card charlie
{
player.Bank += player.FirstBet * 4;
}
else if (CheckNatural(playerName) && !CheckNatural("", true))//blackjack for player and not dealer
{
player.Bank += player.FirstBet * 3;
}
else if (!IsBusted(playerName, false) && IsBusted("", false, true))//dealer busts and player does not
{
player.Bank += player.FirstBet * 2;
}
else if (IsBusted(playerName, false) && IsBusted("", false, true))//both dealer and player bust
{
player.Bank += player.FirstBet;
}
else if (IsBusted(playerName, false) && !IsBusted("", false, true))//player busts and dealer does not
{
//nothing happens but needed to be checked
}
else if (GetTotal(playerName, false) > GetTotal("", false, true))//player gets a higher score than dealer
{
player.Bank += player.FirstBet * 2;
}
else if (GetTotal(playerName, false) == GetTotal("", false, true))//player and dealer get the same score
{
player.Bank += player.FirstBet;
}
return(player.Bank);
}
public static bool CanDoubleDown(string name)
{
bool possible = false;
BlackjackPlayer player = blackjack.GetPlayer(name);
if (round == 1 && player.Hand.Count == 2)
{
int total = 0;
foreach (var card in player.Hand)
{
if (card.Value == 'A')
{
total += 1;
}
else
{
total += ConvertValue(card);
}
}
if (total >= 9 && total <= 11)
{
possible = true;
}
}
return(possible);
}
private void DealCard(BlackjackPlayer _blackjackPlayer, bool faceUp)
{
Card drawnCard = Deck.GetRandomCard();
_blackjackPlayer.AddCardToHand(drawnCard);
GameObject drawnCardObject = new GameObject("CardObject");
drawnCardObject.transform.parent = _blackjackPlayer.isDealer ? dealerCardContainer.transform : playerCardContainer.transform;
drawnCardObject.AddComponent <Image>().sprite = faceUp ? drawnCard.sprite : Deck.cardbackSprite;
// Don't show the dealer's total
if (!_blackjackPlayer.isDealer)
{
playerTotal.text = $"Your total: {blackjackPlayer.handTotal}";
}
// Automatically stand the player if they get blackjack
if (_blackjackPlayer.handTotal == 21)
{
StandPlayer();
}
// Check if bust
if (_blackjackPlayer.handTotal > 21)
{
_blackjackPlayer.isBust = true;
PostGame();
}
}
public static int GetTotal(string playerName, bool secondHandCheck, bool isHouse = false)
{
BlackjackPlayer player = isHouse ? house : blackjack.GetPlayer(playerName);
int total = 0;
bool hasAce = false;
foreach (Card card in secondHandCheck ? player.SecondHand : player.Hand)
{
if (card.Value == 'A')
{
hasAce = true;
}
total += ConvertValue(card);
}
if (total > 21 && hasAce)
{
total -= 10;
}
return(total);
}
public ulong Join(PlayerIdType playerId, PlayerPointManager pointManager, ulong bet)
{
if (!base.Contains(playerId))
{
var player = new BlackjackPlayer <PlayerIdType>(this, pointManager, playerId);
if (base.Join(player))
{
if (player.PlaceBet(bet, false) > 0)
{
Log.info(playerId.ToString() + " joined Blackjack!");
return(player.bet);
}
}
}
else
{
var player = GetPlayer(playerId);
player.CancelBet();
if (player.PlaceBet(bet, false) > 0)
{
Log.info(playerId.ToString() + " changed their Blackjack bet.");
return(player.bet);
}
}
return(0);
}
public static int PlayerBet(string playerName, int amount)
{
BlackjackPlayer player = blackjack.GetPlayer(playerName);
player.FirstBet = amount;
player.Bank -= amount;
return(player.Bank);
}
public void calling_get_initial_hand_before_placing_ante_throws_exception()
{
// Arrange
var player = new BlackjackPlayer();
// Act
player.GetInitialHand();
}
public void Surrender(BlackjackPlayer <PlayerIdType> player)
{
if (player.canSurrender)
{
player.Award((long)(player.bet * -0.5));
player.isWinner = false;
LeaveGame(player.idObject);
}
}
public static bool CanSplitPairs(string player)
{
BlackjackPlayer p = blackjack.GetPlayer(player);
bool splitting = (p.Hand.Count == 2 &&
p.Hand.ToArray()[0].Value == p.Hand.ToArray()[1].Value);
return(splitting);
}
void Hit(TwitchUser speaker, string message, bool doubleDown = false)
{
BlackjackPlayer <TwitchUser> player = GetPlayer(speaker);
if (player != null)
{
string chatMessage = "";
if (!player.CurrentHandEvaluator.isDone)
{
if (doubleDown)
{
if (player.DoubleDown())
{
chatMessage += "Doubled down! ";
}
else
{
chatMessage += "Can't afford a double, so you hit instead. ";
doubleDown = false;
player.Hit();
}
}
else
{
player.Hit();
}
chatMessage += "Dealt a " + player.hand.Last.ToString();
if (player.CurrentHandEvaluator.isBust)
{
chatMessage += " and BUSTED with " + player.CurrentHandEvaluator.cards.ToString() + " (" + player.CurrentHandEvaluator.HandValueString() + ")!";
}
else if (player.CurrentHandEvaluator.handValue == 21 && player.Stand())
{
chatMessage += " and you stood with " + player.CurrentHandEvaluator.cards.ToString() + " (" + player.CurrentHandEvaluator.HandValueString() + ")!";
}
else
{
chatMessage += ", you have " + player.CurrentHandEvaluator.cards.ToString() + ".";
}
chatMessage += AnnounceSplitHand(player);
controller.room.SendWhisper(speaker, chatMessage);
if (controller.game.ReadyToEnd())
{
controller.SetState(this, typeof(BJStateDealerPlaying));
}
}
else
{
controller.room.SendWhisper(speaker, "Too late, you are standing with " + player.CurrentHandEvaluator.HandValueString());
}
}
}
private void FrmNewGame_Load(object sender, EventArgs e)
{
deck = new Deck(FindBitmap);
player1 = new BlackjackPlayer();
// add listener
player1.scoreUpdated += p_ScoreUpdated;
// add betting money
player1.giveMoney(1000);
updateGUI();
startBetting();
}
static void Main(string[] args)
{
IBlackjackTable table = new BlackjackTable();
IBlackjackPlayer player1 = new BlackjackPlayer {Balance = 2000, Ante = 20};
IBlackjackPlayer player2 = new BlackjackPlayer {Balance = 3000, Ante = 30};
table.AddPlayer(player1);
table.AddPlayer(player2);
table.ShuffleShoe();
PerformOneGame(table);
}
public static Text InitialiseGameInfo(GameObject parentObject, BlackjackPlayer blackjackPlayer)
{
GameObject gameInfoObject = new GameObject(BlackjackConstants.gameInfoName);
gameInfoObject.transform.parent = parentObject.transform;
Text gameInfoText = gameInfoObject.AddComponent <Text>();
gameInfoText.color = Color.black;
SetFont(gameInfoText);
gameInfoText.text = $"You have {blackjackPlayer.chips} chips. Place a bet to begin the game!";
return(gameInfoText);
}
private bool CanSplit(BlackjackPlayer bp)
{
var cardArr = bp.ReturnCards().ToArray();
if (cardArr[0].Number == cardArr[1].Number)
{
return(true);
}
else
{
return(false);
}
}
public static void HitMe(string playerName, bool secondHand)
{
BlackjackPlayer player = blackjack.GetPlayer(playerName);
if (secondHand)
{
player.SecondHand.Add(blackjack.Deck.GetCard());
}
else
{
player.Hand.Add(blackjack.Deck.GetCard());
}
}
public static bool DoublingDown(string name)
{
bool successful = CanDoubleDown(name);
if (successful)
{
BlackjackPlayer player = blackjack.GetPlayer(name);
player.Bank -= player.FirstBet;
player.FirstBet *= 2;
player.DoubledDown = true;
player.Hand.Add(blackjack.Deck.GetCard());
}
return(successful);
}
public void default_player_rejects_hit_above_16()
{
// Arrange
IBlackjackPlayer player = new BlackjackPlayer();
var dealerFaceUpCard = Substitute.For<IBlackjackCard>();
var hand = Substitute.For<IPlayerHand>();
hand.Value().Returns(17);
// Act
var acceptHit = player.Hit(hand, dealerFaceUpCard);
// Assert
acceptHit.Should().Be.False();
}
private void HumanPlay(BlackjackPlayer player)
{
bool awaitResp = true;
LogLine("h to hit | s to stay | split to split | q to quit");
PrintCards(player);
while (awaitResp)
{
LogLine("Card value : " + player.CardsValue);
if (player.CardsValue > 21)
{
awaitResp = false;
LogLine("Card value : " + player.CardsValue);
LogLine("Bust!");
break;
}
var action = WaitForCommand();
switch (action)
{
case "h":
Hit(player);
break;
case "s":
awaitResp = false;
break;
case "split":
break;
case "exit":
awaitResp = false;
commands.Enqueue("exit");
break;
case "money":
Log(player.Money);
break;
default:
LogLine("Enter a value");
break;
}
}
}
string AnnounceSplitHand(BlackjackPlayer <TwitchUser> player)
{
if (player.ReadyToSwitchHands())
{
string chatMessage = "";
if (!player.CurrentHandEvaluator.isStanding)
{
chatMessage += " Next hand: " + player.CurrentHandEvaluator.cards.ToString();
}
return(chatMessage);
}
return("");
}
public static BlackjackPlayer[] ConvertPlayerToBlackjackPlayer(string[] playerNames)
{
BlackjackPlayer[] players = new BlackjackPlayer[playerNames.Length];
for (int i = 0; i < players.Length; i++)
{
players[i] = new BlackjackPlayer()
{
Name = playerNames[i],
Bank = 20,
BoughtIn = false,
DoubledDown = false,
SecondHandInitiated = false
};
}
return(players);
}
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 static bool CheckNatural(string player, bool isHouse = false)
{
BlackjackPlayer p = isHouse ? house : blackjack.GetPlayer(player);
List <Card> hand = p.Hand;
bool isNatural = false;
int total = 0;
foreach (Card c in hand)
{
total += ConvertValue(c);
}
isNatural = (total == 21 && hand.Count == 2);
return(isNatural);
}
public void default_player_accepts_hit_below_17()
{
// Arrange
IBlackjackPlayer player = new BlackjackPlayer();
var dealerFaceUpCard = Substitute.For<IBlackjackCard>();
var hand = Substitute.For<IPlayerHand>();
var bet = Substitute.For<AnteBet>(0.0);
hand.Value().Returns(16);
hand.Bet.Returns(bet);
// Act
var acceptHit = player.Hit(hand, dealerFaceUpCard);
// Assert
acceptHit.Should().Be.True();
}
public void calling_get_initial_hand_returns_first_hand()
{
// Arrange
var player = new BlackjackPlayer();
player.PlaceBet();
player.PlaceBet();
var hands = (List<IPlayerHand>)player.Hands;
hands.Count.Should().Equal(2);
var hand1 = hands[0];
// Act
var hand = player.GetInitialHand();
// Assert
hand.Should().Not.Be.Null();
hand.Should().Be.SameAs(hand1);
}
public static void SplitPairs(string player)
{
BlackjackPlayer p = blackjack.GetPlayer(player);
bool aces = (p.Hand.ToArray()[0].Value == 'A' && p.Hand.ToArray()[1].Value == 'A');
if (aces)
{
p.HitLimit = 1;
}
p.SecondHand.Add(p.Hand.Last <Card>());
p.Hand.Remove(p.Hand.Last <Card>());
p.Hand.Add(blackjack.Deck.GetCard());
p.SecondHand.Add(blackjack.Deck.GetCard());
p.SecondBet = p.FirstBet;
}
public void TestGameEngine_Leave()
{
BlackjackEngine engine =
new BlackjackEngine();
BlackjackPlayer player =
new BlackjackPlayer("Cory");
BlackjackPlayer player2 =
new BlackjackPlayer("Bob");
BlackjackTable table =
new BlackjackTable(
"1",
"Yes",
null,
null);
BlackjackResponse response1 = engine.Process(
new BlackjackRequest(
player,
BlackjackAction.JoinTable,
table));
BlackjackResponse response2 = engine.Process(
new BlackjackRequest(
player2,
BlackjackAction.JoinTable,
table));
BlackjackResponse response3 = engine.Process(
new BlackjackRequest(
player,
BlackjackAction.LeaveTable,
table));
BlackjackResponse response4 = engine.Process(
new BlackjackRequest(
player2,
BlackjackAction.LeaveTable,
table));
}
private bool DecideOutcome(BlackjackPlayer bp)
{
if (bp.CardsValue > 21)
{
return(false);
}
if (dealer.CardsValue > 21)
{
return(true);
}
if (bp.CardsValue > dealer.CardsValue)
{
return(true);
}
else
{
return(false);
}
}
static void Main(string[] args)
{
BlackjackHand Hand = new BlackjackHand();
BlackjackDealer Dealer = new BlackjackDealer();
BlackjackPlayer Player = new BlackjackPlayer(Hand, 500, "Player 1");
BlackjackModel Model = new BlackjackModel(Dealer, Player);
BlackjackController Controller = new BlackjackController(Model);
// >>>>>[ To use the straight Console/CLI View
// -----
// BlackjackConsoleView View = new BlackjackConsoleView(Model, Controller);
// >>>>>[ To use the "Fake-Curses" View
// -----
BlackjackCursesView View = new BlackjackCursesView(Model, Controller);
Model.LinkView(View);
View.ModelChanged();
}
private void PlayerAI(BlackjackPlayer bp)
{
int cardValue = 0;
if (CanSplit(bp))
{
Logs.LogTrace("Found split", logID);
List <Card> deck1 = new List <Card> {
bp.ReturnCards()[0]
};
List <Card> deck2 = new List <Card> {
bp.ReturnCards()[1]
};
var deck1Val = BasicPlayerAI(deck1);
var deck2Val = BasicPlayerAI(deck2);
if (deck1Val <= 21 && deck1Val < deck2Val)
{
bp.CardsValue = deck1Val;
}
else
{
bp.CardsValue = deck2Val;
}
List <Card> returnCardList = new List <Card>();
returnCardList.AddRange(deck1);
returnCardList.AddRange(deck2);
bp.SetCardList(returnCardList);
}
else
{
cardValue = CalcCards(bp.ReturnCards());
while (cardValue <= 17)
{
Hit(bp);
cardValue = CalcCards(bp.ReturnCards());
}
bp.CardsValue = cardValue;
}
}
public BlackjackModel(BlackjackDealer Dealer, BlackjackPlayer Player)
{
// >>>>>[ For now keeping it simple: One player, one view.
// - jds | 2019.01.30
// -----
this.Dealer = Dealer;
this.Player = Player;
Dealer.NewHand();
Player.NewHand();
// >>>>>[ Populate the command list. Initially, the only available
// command will be "Bet".
// -jds | 2019.01.31
// -----
this.Commands.Add("bet", true);
this.Commands.Add("hit", false);
this.Commands.Add("stand", false);
this.Commands.Add("double down", false);
this.Commands.Add("restart", true);
this.Commands.Add("surrender", false);
this.Commands.Add("split", false);
this.Commands.Add("quit", true);
}
public void settle_bet_when_only_dealer_busted_returns_negative_win_amount()
{
// Arrange
IBlackjackPlayer player = new BlackjackPlayer();
IBlackjackBet bet = new AnteBet(100);
var dealerHand = Substitute.For<IDealerHand>();
var playerHand = Substitute.For<IPlayerHand>();
playerHand.Busted.Returns(false);
dealerHand.Busted.Returns(true);
playerHand.Bet.Returns(bet);
// Act
var amount = player.SettleBet(playerHand, dealerHand);
// Assert
amount.Should().Equal(-100.0);
}
public BlackjackResponse Evaluate(BlackjackTable table,
BlackjackPlayer player)
{
return(send(new BlackjackRequest(player, BlackjackAction.Evaluate, table)));
}
public void settle_bet_with_equal_hands_returns_zero()
{
// Arrange
IBlackjackBet bet = new AnteBet(100);
IBlackjackPlayer player = new BlackjackPlayer { Balance = 900 };
var dealerHand = Substitute.For<IDealerHand>();
var playerHand = Substitute.For<IPlayerHand>();
playerHand.Busted.Returns(false);
dealerHand.Busted.Returns(false);
playerHand.Value().Returns(20);
dealerHand.Value().Returns(20);
playerHand.Bet.Returns(bet);
// Act
var amount = player.SettleBet(playerHand, dealerHand);
// Assert
amount.Should().Equal(0.0);
}
public void settle_bet_with_equal_hands_changes_bet_to_push_bet()
{
// Arrange
IBlackjackBet bet = new AnteBet(100);
IBlackjackPlayer player = new BlackjackPlayer { Balance = 900 };
var dealerHand = Substitute.For<IDealerHand>();
var playerHand = Substitute.For<IPlayerHand>();
playerHand.Busted.Returns(false);
dealerHand.Busted.Returns(false);
playerHand.Value().Returns(20);
dealerHand.Value().Returns(20);
playerHand.Bet.Returns(bet);
// Act
player.SettleBet(playerHand, dealerHand);
// Assert
playerHand.Bet.Should().Be.OfType<PushBet>();
}
public void offer_to_double_down_on_eligible_hand_doubles_amount_of_bet()
{
// Arrange
var player = new BlackjackPlayer { Balance = 100.0 };
var bet = new AnteBet(20.0);
var dealerFaceUpCard = Substitute.For<IBlackjackCard>();
var hand1 = Substitute.For<IPlayerHand>();
hand1.EligibleForDoubleDown.Returns(true);
hand1.Bet = bet;
// Act
player.OfferDoubleDown(hand1, dealerFaceUpCard);
// Assert
hand1.Bet.Amount.Should().Equal(40.0);
hand1.Bet.Should().Be.OfType<DoubleDownBet>();
}
public void start_new_game_resets_hands_to_empty()
{
// Arrange
IBlackjackPlayer player = new BlackjackPlayer();
player.PlaceBet();
player.Hands.Count().Should().Equal(1);
// Act
player.StartNewGame();
// Assert
player.Hands.Count().Should().Equal(0);
}
public void offer_to_split_on_ineligible_hand_returns_false()
{
// Arrange
var player = new BlackjackPlayer();
var dealerFaceUpCard = Substitute.For<IBlackjackCard>();
var card1 = Substitute.For<IBlackjackCard>();
var card2 = Substitute.For<IBlackjackCard>();
var cards = new List<IBlackjackCard> { card1, card2 };
var hand1 = Substitute.For<IPlayerHand>();
hand1.EligibleForSplit.Returns(false);
var playerHands = (List<IPlayerHand>)player.Hands;
playerHands.Add(hand1);
// Act
var response = player.OfferSplit(dealerFaceUpCard);
// Assert
response.Should().Be.False();
}
public void offer_to_double_down_on_eligible_hand_decreases_players_balance()
{
// Arrange
var player = new BlackjackPlayer {Balance = 100.0};
var bet = new AnteBet(20.0);
var dealerFaceUpCard = Substitute.For<IBlackjackCard>();
var hand1 = Substitute.For<IPlayerHand>();
hand1.EligibleForDoubleDown.Returns(true);
hand1.Bet = bet;
// Act
player.OfferDoubleDown(hand1, dealerFaceUpCard);
// Assert
player.Balance.Should().Equal(80.0);
}
public void offer_to_double_down_on_eligible_hand_returns_true()
{
// Arrange
var player = new BlackjackPlayer();
var dealerFaceUpCard = Substitute.For<IBlackjackCard>();
var hand1 = Substitute.For<IPlayerHand>();
hand1.EligibleForDoubleDown.Returns(true);
// Act
var response = player.OfferDoubleDown(hand1, dealerFaceUpCard);
// Assert
response.Should().Be.True();
}
public void offer_to_split_on_eligible_hand_results_in_two_hands()
{
// Arrange
var player = new BlackjackPlayer();
var dealerFaceUpCard = Substitute.For<IBlackjackCard>();
var card1 = Substitute.For<IBlackjackCard>();
var card2 = Substitute.For<IBlackjackCard>();
var cards = new List<IBlackjackCard> {card1, card2};
var hand1 = Substitute.For<IPlayerHand>();
hand1.EligibleForSplit.Returns(true);
hand1.GetCards().Returns(cards);
var playerHands = (List<IPlayerHand>) player.Hands;
playerHands.Add(hand1);
// Act
player.OfferSplit(dealerFaceUpCard);
// Assert
var actualHands = player.Hands.ToList();
actualHands.Should().Not.Be.Null();
actualHands.Count.Should().Equal(2);
hand1.ReceivedWithAnyArgs().SplitInto(hand1);
}
public void offer_to_double_down_on_ineligible_hand_returns_false()
{
// Arrange
var player = new BlackjackPlayer();
var dealerFaceUpCard = Substitute.For<IBlackjackCard>();
var hand1 = Substitute.For<IPlayerHand>();
hand1.EligibleForDoubleDown.Returns(false);
var playerHands = (List<IPlayerHand>)player.Hands;
playerHands.Add(hand1);
// Act
var response = player.OfferDoubleDown(hand1, dealerFaceUpCard);
// Assert
response.Should().Be.False();
}
private void PrintCards(BlackjackPlayer player)
{
player.ReturnCards().ForEach(a => { Console.Write(a.ToString()); });
Console.WriteLine("");
}
public void settle_bet_when_only_dealer_busted_credits_players_balance()
{
// Arrange
IBlackjackBet bet = new AnteBet(100);
IBlackjackPlayer player = new BlackjackPlayer {Balance = 900};
var dealerHand = Substitute.For<IDealerHand>();
var playerHand = Substitute.For<IPlayerHand>();
playerHand.Busted.Returns(false);
dealerHand.Busted.Returns(true);
playerHand.Bet.Returns(bet);
// Act
player.SettleBet(playerHand, dealerHand);
// Assert
player.Balance.Should().Equal(1100.0);
}
private void Hit(BlackjackPlayer bp)
{
bp.AddCards((Card)st.Dequeue());
bp.CardsValue = CalcCards(bp.ReturnCards());
}
public void place_bet_reduces_balance_by_ante()
{
// Arrange
IBlackjackPlayer player = new BlackjackPlayer {Balance = 1000, Ante = 50};
// Act
player.PlaceBet();
// Assert
player.Balance.Should().Equal(950.0);
}
