// the final result which we use when testing public ActionToTake GetActionForHand(Hand hand, Card dealerUpcard) { if (hand.HandValue() >= 21) { return(ActionToTake.Stand); } var upcardIndex = IndexFromRank(dealerUpcard.Rank); if (hand.IsPair()) { var pairIndex = IndexFromRank(hand.Cards[0].Rank); return(pairsStrategy[upcardIndex, pairIndex]); } if (hand.HasSoftAce()) { // we want the total other than the high ace int howManyAces = hand.Cards.Count(c => c.Rank == Card.Ranks.Ace); int total = hand.Cards .Where(c => c.Rank != Card.Ranks.Ace) .Sum(c => c.RankValueHigh) + (howManyAces - 1); return(softStrategy[upcardIndex, total]); } return(hardStrategy[upcardIndex, hand.HandValue()]); }
public int GetStrategyScore(int numHandsToPlay) { int playerChips = 0; var deck = new Deck(testConditions.NumDecks); var randomizer = new Randomizer(); Hand dealerHand = new Hand(); Hand playerHand = new Hand(); List <Hand> playerHands = new List <Hand>(); List <int> betAmountPerHand = new List <int>(); for (int handNum = 0; handNum < numHandsToPlay; handNum++) { dealerHand.Cards.Clear(); playerHand.Cards.Clear(); dealerHand.AddCard(deck.DealCard()); dealerHand.AddCard(deck.DealCard()); playerHand.AddCard(deck.DealCard()); if (StackTheDeck) { // even out the hands dealt to the player so it's proportionate to the // number of cells in the three grids var rand = randomizer.GetFloatFromZeroToOne(); if (rand < 0.33F) { // deal a pair deck.ForceNextCardToBe(playerHand.Cards[0].Rank); } if (rand >= 0.33F && rand < 0.66F) { // deal a soft hand if (playerHand.Cards[0].Rank != Card.Ranks.Ace) { deck.ForceNextCardToBe(Card.Ranks.Ace); } else { deck.EnsureNextCardIsnt(Card.Ranks.Ace); // avoid a pair of Aces } } // yes, our normal deal for hard hands may result in a pair or a hard hand, but // we don't care since we're just trying to even out the proportion of those type of hands } playerHand.AddCard(deck.DealCard()); playerHands.Clear(); playerHands.Add(playerHand); // we need to track how much bet per hand, since you can double down after a split. betAmountPerHand.Clear(); betAmountPerHand.Add(testConditions.BetSize); playerChips -= testConditions.BetSize; // 1. check for player Blackjack if (playerHand.HandValue() == 21) { // if the dealer also has 21, then it's a tie if (dealerHand.HandValue() == 21) // ##!! THIS WAS EDITED FROM != TO == ##!! { playerChips += betAmountPerHand[0]; // return the bet } else { // Blackjack typically pays 3:2, although some casinos do 5:4 playerChips += testConditions.BlackjackPayoffSize + betAmountPerHand[0]; //+betSize was EDITED IN } betAmountPerHand[0] = 0; continue; // go to next hand } // 2. if the dealer has blackjack, then simply move to the next hand, since playerChips was already decremented if (dealerHand.HandValue() == 21) { continue; } // 3. If the player has a playable hand, get a decision and play until standing or busting // If split is selected, a new hand is added to playerHands, which is why we loop like this: for (var handIndex = 0; handIndex < playerHands.Count; handIndex++) { playerHand = playerHands[handIndex]; var gameState = GameState.PlayerDrawing; while (gameState == GameState.PlayerDrawing) { // if the hand was split and resulted in Blackjack, pay off and more to the next hand if (playerHand.HandValue() == 21) { if (playerHand.Cards.Count == 2) // Blackjack { int blackjackPayoff = (testConditions.BlackjackPayoffSize + betAmountPerHand[handIndex]) / testConditions.BetSize; //testConditions.BlackjackPayoffSize * betAmountPerHand[handIndex] / testConditions.BetSize; playerChips += blackjackPayoff; betAmountPerHand[handIndex] = 0; } gameState = GameState.DealerDrawing; break; } var action = strategy.GetActionForHand(playerHand, dealerHand.Cards[0]); // if there's an attempt to double-down with more than 2 cards, turn into a hit if (action == ActionToTake.Double && playerHand.Cards.Count > 2) { action = ActionToTake.Hit; } switch (action) { case ActionToTake.Hit: playerHand.AddCard(deck.DealCard()); // if we're at 21, we automatically stand if (playerHand.HandValue() == 21) { gameState = GameState.DealerDrawing; } // did we bust? if (playerHand.HandValue() > 21) { betAmountPerHand[handIndex] = 0; gameState = GameState.PlayerBusted; } break; case ActionToTake.Stand: gameState = GameState.DealerDrawing; break; case ActionToTake.Double: // double down means bet another chip, and get one and only card card playerChips -= testConditions.BetSize; betAmountPerHand[handIndex] += testConditions.BetSize; playerHand.AddCard(deck.DealCard()); if (playerHand.HandValue() > 21) { betAmountPerHand[handIndex] = 0; gameState = GameState.PlayerBusted; } else { gameState = GameState.DealerDrawing; } break; case ActionToTake.Split: // add the new hand to our collection var newHand = new Hand(); newHand.AddCard(playerHand.Cards[1]); playerHand.Cards[1] = deck.DealCard(); newHand.AddCard(deck.DealCard()); playerHands.Add(newHand); // our extra bet playerChips -= testConditions.BetSize; betAmountPerHand.Add(testConditions.BetSize); break; } } } // 4. if there are playable hands for the player, get the dealer decisions bool playerHandsAvailable = betAmountPerHand.Sum() > 0; if (playerHandsAvailable) { var gameState = GameState.DealerDrawing; // draw until holding 17 or busting while (dealerHand.HandValue() < 17) { dealerHand.AddCard(deck.DealCard()); if (dealerHand.HandValue() > 21) { // payoff each hand that is still valid - busts and blackjacks have 0 for betAmountPerHand for (int handIndex = 0; handIndex < playerHands.Count; handIndex++) { playerChips += betAmountPerHand[handIndex] * 2; // the original bet and a matching amount } gameState = GameState.DealerBusted; break; } } // 5. and then compare the dealer hand to each player hand if (gameState != GameState.DealerBusted) { int dealerHandValue = dealerHand.HandValue(); for (int handIndex = 0; handIndex < playerHands.Count; handIndex++) { var playerHandValue = playerHands[handIndex].HandValue(); // if it's a tie, give the player his bet back if (playerHandValue == dealerHandValue) { playerChips += betAmountPerHand[handIndex]; } else { if (playerHandValue > dealerHandValue) { // player won playerChips += betAmountPerHand[handIndex] * 2; // the original bet and a matching amount } else { // player lost, nothing to do since the chips have already been decremented } } } } } } return(playerChips); }
//------------------------------------------------------------------------- // each candidate gets evaluated here //------------------------------------------------------------------------- private float EvaluateCandidate(CandidateSolution <bool, ProblemState> candidate) { int playerChips = 0; for (int handNum = 0; handNum < TestConditions.NumHandsToPlay; handNum++) { // for each hand, we generate a random deck. Blackjack is often played with multiple decks to improve the house edge MultiDeck deck = new MultiDeck(TestConditions.NumDecks); // always use the designated dealer upcard (of hearts), so we need to remove from the deck so it doesn't get used twice deck.RemoveCard(dealerUpcardRank, "H"); Hand dealerHand = new Hand(); Hand playerHand = new Hand(); playerHand.AddCard(deck.DealCard()); dealerHand.AddCard(new Card(dealerUpcardRank, "H")); playerHand.AddCard(deck.DealCard()); dealerHand.AddCard(deck.DealCard()); // save the cards in state, and reset the votes for this hand candidate.StateData.PlayerHands.Clear(); candidate.StateData.PlayerHands.Add(playerHand); // do the intial wager int totalBetAmount = TestConditions.BetSize; playerChips -= TestConditions.BetSize; // outer loop is for each hand the player holds. Obviously this only happens when they've split a hand for (int handIndex = 0; handIndex < candidate.StateData.PlayerHands.Count; handIndex++) { candidate.StateData.HandIndex = handIndex; playerHand = candidate.StateData.PlayerHand; // gets the current hand, based on index // loop until the hand is done var currentHandState = TestConditions.GameState.PlayerDrawing; // check for player having a blackjack, which is an instant win if (playerHand.HandValue() == 21) { // if the dealer also has 21, then it's a tie if (dealerHand.HandValue() != 21) { currentHandState = TestConditions.GameState.PlayerBlackjack; playerChips += TestConditions.BlackjackPayoffSize; } else { // a tie means we just ignore it and drop through currentHandState = TestConditions.GameState.HandComparison; } } // check for dealer having blackjack, which is either instant loss or tie if (dealerHand.HandValue() == 21) { currentHandState = TestConditions.GameState.HandComparison; } // player draws while (currentHandState == TestConditions.GameState.PlayerDrawing) { // get the decision candidate.StateData.VotesForDoubleDown = 0; candidate.StateData.VotesForHit = 0; candidate.StateData.VotesForStand = 0; candidate.StateData.VotesForSplit = 0; candidate.Evaluate(); // throw away the result, because it's meaningless // look at the votes to see what to do var action = GetAction(candidate.StateData); // if there's an attempt to double-down with more than 2 cards, turn into a hit if (action == ActionToTake.Double && playerHand.Cards.Count > 2) { action = ActionToTake.Hit; } // if we're trying to split, but don't have a pair, turn that into a stand? if (action == ActionToTake.Split && !playerHand.IsPair()) { Debug.Assert(false, "Vote for split without a pair"); } switch (action) { case ActionToTake.Hit: // hit me playerHand.AddCard(deck.DealCard()); // if we're at 21, we're done if (playerHand.HandValue() == 21) { currentHandState = TestConditions.GameState.DealerDrawing; } // did we bust? if (playerHand.HandValue() > 21) { currentHandState = TestConditions.GameState.PlayerBusted; } break; case ActionToTake.Stand: // if player stands, it's the dealer's turn to draw currentHandState = TestConditions.GameState.DealerDrawing; break; case ActionToTake.Double: // double down means bet another chip, and get one and only card card playerChips -= TestConditions.BetSize; totalBetAmount += TestConditions.BetSize; playerHand.AddCard(deck.DealCard()); if (playerHand.HandValue() > 21) { currentHandState = TestConditions.GameState.PlayerBusted; } else { currentHandState = TestConditions.GameState.DealerDrawing; } break; case ActionToTake.Split: // do the split and add the hand to our collection var newHand = new Hand(); newHand.AddCard(playerHand.Cards[1]); playerHand.Cards[1] = deck.DealCard(); newHand.AddCard(deck.DealCard()); candidate.StateData.PlayerHands.Add(newHand); //Debug.WriteLine("TID " + AppDomain.GetCurrentThreadId() + " " + // "is splitting and has " + candidate.StateData.PlayerHands.Count + " hands"); Debug.Assert(candidate.StateData.PlayerHands.Count < 5, "Too many hands for player"); // our extra bet playerChips -= TestConditions.BetSize; // we don't adjust totalBetAmount because each bet pays off individually, so the total is right //totalBetAmount += TestConditions.BetSize; break; } } // if the player busted, nothing to do, since chips have already been consumed. Just go on to the next hand // on the other hand, if the player hasn't busted, then we need to play the hand for the dealer while (currentHandState == TestConditions.GameState.DealerDrawing) { // if player didn't bust or blackjack, dealer hits until they have 17+ (hits on soft 17) if (dealerHand.HandValue() < 17) { dealerHand.AddCard(deck.DealCard()); if (dealerHand.HandValue() > 21) { currentHandState = TestConditions.GameState.DealerBusted; playerChips += totalBetAmount * 2; // the original bet and a matching amount } } else { // dealer hand is 17+, so we're done currentHandState = TestConditions.GameState.HandComparison; } } if (currentHandState == TestConditions.GameState.HandComparison) { int playerHandValue = playerHand.HandValue(); int dealerHandValue = dealerHand.HandValue(); // if it's a tie, give the player his bet back if (playerHandValue == dealerHandValue) { playerChips += totalBetAmount; } else { if (playerHandValue > dealerHandValue) { // player won playerChips += totalBetAmount * 2; // the original bet and a matching amount } else { // player lost, nothing to do since the chips have already been decremented } } } } } return(playerChips); }