def createFourCard20PointHand(self):
hand = Hand(1)
hand.addCard(Card(1, 1))
hand.addCard(Card(1, 2))
hand.addCard(Card(1, 3))
hand.addCard(Card(1, 4))
return hand
def playHand(self, hand, dealercards):
stand = False
while not stand and hand.getSum() <= 21:
action = self.getAction(hand, dealercards[0].bjValue())
# print(hand)
if action == "hit":
# print("hit")
hand.addCard(self.takeCard())
elif action == "stand":
# print("stand")
return [hand]
elif action == "double":
# print("double")
hand.addCard(self.takeCard())
hand.setDouble()
self.bankroll -= self.bet
return [hand]
elif action == "split":
hand2 = Hand([hand.takeCard()], self.bet)
self.bankroll -= self.bet
hand.addCard(self.takeCard())
hand2.addCard(self.takeCard())
# print("pair split into %s and %s" % (hand, hand2))
# print("play first pair")
a = self.playHand(hand, dealercards)
# print("play second pair")
b = self.playHand(hand2, dealercards)
a.extend(b)
return a
elif action == "surrender":
hand.setSurrender()
return [hand]
return [hand]
def test_bustedHandWithAce(self):
hand = Hand(1)
hand.addCard(Card(1, 0))
hand.addCard(Card(1, 6))
hand.addCard(Card(1, 6))
hand.addCard(Card(1, 9))
self.assertTrue(hand.isBust())
def test_stand(self):
hand = Hand(1)
hand.addCard(Card(0, 1))
hand.addCard(Card(1, 1))
deck = HandTest.FakeDeck()
self.assertTrue(hand.canStand())
hand.stand(deck)
def test_4CardHand(self):
hand = Hand(0)
hand.addCard(Card(1, 6))
hand.addCard(Card(1, 4))
hand.addCard(Card(1, 2))
hand.addCard(Card(1, 0))
dealer = DealerAgent()
self.assertEqual(Actions.HIT, dealer.getNextAction(None, hand))
def test_hit(self):
hand = Hand(1)
hand.addCard(Card(0, 1))
hand.addCard(Card(1, 1))
deck = HandTest.FakeDeck()
self.assertTrue(hand.canHit())
hand.hit(deck)
self.assertTrue(hand.canHit())
hand.hit(deck)
class Player:
def __init__(self, player_id, name):#, deck):
self._id = player_id
self.name = name
self.hand = Hand() # need to discuss, we may need to pass the deck back and forth via JSON
#self.book = []
#self.deck = deck
#self.score = 0
def draw(self):
cardDrawn = self.deck.pop_card()
self.hand.addCard(cardDrawn)
print('%s drew %s.' % (self.name, cardDrawn))
def numCards(self):
return self.hand.numCards()
def printHand(self):
return self.hand.printHand()
def checkHand(self, card):
return self.hand.checkCards(card)
def toString(self):
return self.name, self._id
def matchCheck(self):
return self.hand.bookCheck()
def removeMatch(self, card):
return self.hand.removeCards(card)
# true/false check for four of a kind
def fourKind(self):
ranks = []
rtnMsg = {0:False, 1:0}
lark = self.hand.hand
for i in lark:
if i not in ranks:
ranks.append(i)
if lark.count(i) == 4:
print(True)
rtnMsg = {0:True, 1:i}
#else:
# rtnMsg = False
return rtnMsg
def testEntireDeckNoCountMultiRound(self):
# The entire deck should be neutral
deck = Deck(1, 4, 13)
dealerHand = Hand(1)
for _ in range(6):
dealerHand.addCard(deck.take())
playerHandMap = {}
for i in range(3):
hand = Hand(1)
for _ in range(6):
hand.addCard(deck.take())
playerHandMap[hand] = i
self.assertEqual(52 - 6 * 4, deck.numActiveCards())
gameState = GameState(playerHandMap, dealerHand, deck)
self.agent.gameOver(gameState, playerHandMap.keys()[0], 1)
dealerHand = Hand(1)
for _ in range(7):
dealerHand.addCard(deck.take())
playerHandMap = {}
for i in range(3):
hand = Hand(1)
for _ in range(7):
hand.addCard(deck.take())
playerHandMap[hand] = i
self.assertEqual(0, deck.numActiveCards())
gameState = GameState(playerHandMap, dealerHand, deck)
self.agent.gameOver(gameState, playerHandMap.keys()[0], 1)
self.assertEqual(0, self.agent.count)
def testEntireDeckNoCountMultiRound(self):
# The entire deck should be neutral
deck = Deck(1, 4, 13)
dealerHand = Hand(1)
for _ in range(6):
dealerHand.addCard(deck.take())
playerHandMap = {}
for i in range(3):
hand = Hand(1)
for _ in range(6):
hand.addCard(deck.take())
playerHandMap[hand] = i
self.assertEqual(52-6*4, deck.numActiveCards())
gameState = GameState(playerHandMap, dealerHand, deck)
self.agent.gameOver(gameState, playerHandMap.keys()[0], 1)
dealerHand = Hand(1)
for _ in range(7):
dealerHand.addCard(deck.take())
playerHandMap = {}
for i in range(3):
hand = Hand(1)
for _ in range(7):
hand.addCard(deck.take())
playerHandMap[hand] = i
self.assertEqual(0, deck.numActiveCards())
gameState = GameState(playerHandMap, dealerHand, deck)
self.agent.gameOver(gameState, playerHandMap.keys()[0], 1)
self.assertEqual(0, self.agent.count)
def play(self, deck, dealer_hand=None):
# play all hands once
i = 0
while i < len(self._chairs):
chair = self._chairs[i]
i += 1
while not chair['hand'].isOver():
action = self._strategy.chooseAction(chair['hand'],
dealer_hand)
if action == 'P':
chair['hand'].addCard(deck.pick())
if action == 'L':
break
if action == 'D':
self._pot -= chair['bet']
chair['bet'] *= 2
chair['hand'].addCard(deck.pick())
break
if action == 'A':
chair['hand']._is_abandonned = True
break
if action == 'S':
# append 2 new hands
for l in [0, 1]:
# take one of the 2 cards
hand = Hand()
hand.addCard(chair['hand']._cards[l])
hand.addCard(deck.pick())
# bet
bet = chair['bet']
self._pot -= bet
# will be played later
new_chair = {'hand': hand, 'bet': bet}
self._chairs.append(new_chair)
# remove splited hand
self._pot += chair['bet']
self._chairs.remove(chair)
i -= 1
break
def printAcePolicy(agent):
printPolicyHeader("aces")
for nonAceCard in range(10,1,-1):
printString = "{0}\t".format(nonAceCard)
for dealerSoftCard in range(2,12):
dummyHand = Hand(1)
dummyHand.addCard(Card(1, 0))
dummyHand.addCard(Card(1, nonAceCard-1))
# Construct features for this cell
features = (nonAceCard+1, True, dealerSoftCard)
# print the action for that features
action = agent.getPolicy(features, dummyHand)[0]
color = getColor(action)
printString += '{0}{1}\t'.format(color, action)
# key = (features, action)
# if key in agent.q_values:
# str += "%0.2f\t" % agent.q_values[key]
# else:
# str += '\t'
print printString + "\033[1;37m"
def play(self, deck, dealer_hand = None):
# play all hands once
i = 0
while i < len(self._chairs):
chair = self._chairs[i]
i+=1
while not chair['hand'].isOver():
action = self._strategy.chooseAction(chair['hand'], dealer_hand)
if action == 'P':
chair['hand'].addCard(deck.pick())
if action == 'L':
break;
if action == 'D':
self._pot -= chair['bet']
chair['bet'] *= 2
chair['hand'].addCard(deck.pick())
break;
if action == 'A':
chair['hand']._is_abandonned = True
break;
if action == 'S':
# append 2 new hands
for l in [0, 1]:
# take one of the 2 cards
hand = Hand()
hand.addCard(chair['hand']._cards[l])
hand.addCard(deck.pick())
# bet
bet = chair['bet']
self._pot -= bet
# will be played later
new_chair = { 'hand': hand, 'bet': bet }
self._chairs.append(new_chair)
# remove splited hand
self._pot += chair['bet']
self._chairs.remove(chair)
i-=1
break;
def getReward(self, state, action, transitionState):
isDone, isFirst, isDoubleDown, hasAce, hardCount, dealerSoftCount = transitionState
multiplier = 2 if isDoubleDown else 1
if hardCount > 21:
return -2 * multiplier
softCount = hardCount + 10 if hasAce and hardCount <= 11 else hardCount
if isDone:
if isFirst and softCount == 21:
return multiplier
# Simulate the dealer's actions
dealerAgent = DealerAgent()
dealerCardValue = dealerSoftCount - 1 if dealerSoftCount != 11 else 0
card = Card(0, dealerCardValue)
dealerHand = Hand(1)
dealerHand.addCard(card)
deck = Deck(1, 4, 13)
dealerHand.addCard(deck.take())
while dealerAgent.getNextAction(None, dealerHand) == Actions.HIT:
dealerHand.addCard(deck.take())
return (
multiplier
if softCount > dealerHand.getSoftCount()
else (0 if softCount == dealerHand.getSoftCount() else -multiplier)
)
else:
return 0
def test_str(self):
hand = Hand(1)
hand.addCard(Card(0, 6))
hand.addCard(Card(2, 4))
self.assertEqual("[7 of Clubs, 5 of Spades] with soft " \
"count 12 and hard count 12", str(hand))
hand.addCard(Card(3, 10))
self.assertEqual("[7 of Clubs, 5 of Spades, Jack of " \
"Hearts] with soft count 22 and " \
"hard count 22 (Bust)", str(hand))
hand = Hand(1)
hand.addCard(Card(0, 0))
hand.addCard(Card(0, 12))
self.assertEqual("[Ace of Clubs, King of Clubs] with " \
"soft count 21 and hard count 11 " \
"(BlackJack)", str(hand))
def test_doubleDown(self):
hand = Hand(1)
hand.addCard(Card(0, 1))
hand.addCard(Card(1, 1))
deck = HandTest.FakeDeck()
self.assertTrue(hand.canDoubleDown())
hand.doubleDown(deck)
self.assertEqual(2, hand.getBet())
self.assertEqual(3, len(hand.getCards()))
self.assertEqual(Card(3, 0), hand.getCards()[2])
hand = Hand(1)
hand.addCard(Card(0, 1))
hand.addCard(Card(1, 1))
hand.addCard(Card(2, 1))
self.assertFalse(hand.canDoubleDown())
def test_split(self):
hand = Hand(1)
hand.addCard(Card(0, 1))
hand.addCard(Card(1, 1))
deck = HandTest.FakeDeck()
self.assertTrue(hand.canSplit())
self.assertFalse(hand.isSplit())
splitHands = hand.split(deck)
self.assertEqual(1, splitHands[0].getBet())
self.assertEqual(1, splitHands[1].getBet())
self.assertTrue(splitHands[0].isSplit())
self.assertTrue(splitHands[1].isSplit())
self.assertFalse(splitHands[0].canSplit())
self.assertFalse(splitHands[1].canSplit())
self.assertEqual(hand.getCards()[0], splitHands[0].getCards()[0])
self.assertEqual(Card(3, 0), splitHands[0].getCards()[1])
self.assertEqual(hand.getCards()[1], splitHands[1].getCards()[0])
self.assertEqual(Card(3, 1), splitHands[1].getCards()[1])
hand = Hand(1)
hand.addCard(Card(0, 1))
hand.addCard(Card(1, 1))
hand.addCard(Card(2, 1))
self.assertFalse(hand.canSplit())
def getReward(self, state, action, transitionState):
isDone, isFirst, isDoubleDown, hasAce, hardCount, dealerSoftCount = transitionState
multiplier = 2 if isDoubleDown else 1
if hardCount > 21:
return -2 * multiplier
softCount = hardCount + 10 if hasAce and hardCount <= 11 else hardCount
if isDone:
if isFirst and softCount == 21:
return multiplier
# Simulate the dealer's actions
dealerAgent = DealerAgent()
dealerCardValue = dealerSoftCount - 1 if dealerSoftCount != 11 else 0
card = Card(0, dealerCardValue)
dealerHand = Hand(1)
dealerHand.addCard(card)
deck = Deck(1, 4, 13)
dealerHand.addCard(deck.take())
while dealerAgent.getNextAction(None, dealerHand) == Actions.HIT:
dealerHand.addCard(deck.take())
return multiplier if softCount > dealerHand.getSoftCount() else (
0 if softCount == dealerHand.getSoftCount() else -multiplier)
else:
return 0
def test_blackJack(self):
hand = Hand(1)
hand.addCard(Card(1, 0))
hand.addCard(Card(1, 10))
self.assertTrue(hand.isBlackJack())
def deal():
""" Returns void
Deals cards, and checks for splitting
"""
while True:
try:
wager = int(input("Place wager: "))
if 1 <= wager <= balance:
break
else:
print(
"!! Invalid Choice!! Please pick a number between 1 and %d"
% balance)
except ValueError:
print("!! Invalid Choice!! Please pick a number between 1 and %d" %
balance)
deck = Deck()
player = Hand()
dealer = Hand()
# deal two cards each for player and dealer
for i in range(2):
player.addCard(deck.dealCard())
dealer.addCard(deck.dealCard())
card_1 = player.getCard(0)
card_2 = player.getCard(1)
upcard = dealer.getCard(0)
utils.printStatus(upcard, player)
# check for splitting
if player.canSplit():
while True:
choice = input("Would you like to Split (Y / N): ").upper()
if choice == "Y":
if balance < wager * 2:
print("Inadequate balance :(")
else:
print("Splitting into two hands. \nHand #1")
player = Hand()
player.addCard(card_1)
player.addCard(deck.dealCard())
utils.printStatus(upcard, player)
engine(player, dealer, deck, wager)
# checks for adequate balance
if balance >= wager:
print("Hand #2")
player = Hand()
dealer = Hand()
player.addCard(card_2)
player.addCard(deck.dealCard())
for i in range(2):
dealer.addCard(deck.dealCard())
upcard = dealer.getCard(0)
utils.printStatus(upcard, player)
engine(player, dealer, deck, wager)
else:
print("Inadequate balance. Unable to play Hand #2 :(")
break
elif choice == "N":
engine(player, dealer, deck, wager)
break
else:
print("!! Invalid Choice !! Please choose one of (Y / N)")
else:
engine(player, dealer, deck, wager)
class GameLogicTest(unittest.TestCase):
def setUp(self):
dealerAgent = None
playerAgents = []
self.game = Game(dealerAgent, playerAgents)
self.playaHand = Hand(1)
self.dealerHand = Hand(0)
# Ensure that player blackjack beats dealer non-blackjack
def testPlayaBlackjackBeatsDealerNonBlackJack(self):
self.playaHand.addCard(Card(1, 0))
self.playaHand.addCard(Card(1, 10))
self.dealerHand.addCard(Card(1, 4))
self.dealerHand.addCard(Card(1, 5))
self.dealerHand.addCard(Card(1, 10))
self.assertGreater(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
# Ensure that player blackjack beats dealer non-blackjack
def testPlaya17LosesDealer21(self):
self.playaHand.addCard(Card(1, 0))
self.playaHand.addCard(Card(1, 6))
self.dealerHand.addCard(Card(1, 4))
self.dealerHand.addCard(Card(1, 5))
self.dealerHand.addCard(Card(1, 10))
self.assertLess(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
# Ensure that player blackjack beats dealer blackjack
def testPlayaBlackJackLosesDealerBlackjack(self):
self.playaHand.addCard(Card(1, 0))
self.playaHand.addCard(Card(1, 10))
self.dealerHand.addCard(Card(1, 0))
self.dealerHand.addCard(Card(1, 10))
self.assertGreater(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
# Ensure that player blackjack beats dealer blackjack
def testPlaya21LosesDealerBlackjack(self):
self.playaHand.addCard(Card(1, 4))
self.playaHand.addCard(Card(1, 5))
self.playaHand.addCard(Card(1, 10))
self.dealerHand.addCard(Card(1, 0))
self.dealerHand.addCard(Card(1, 10))
self.assertLess(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
# Ensure that player bust loses to dealer bust
def testPlayaBustLosesDealerBust(self):
self.playaHand.addCard(Card(1, 5))
self.playaHand.addCard(Card(1, 6))
self.playaHand.addCard(Card(1, 10))
self.dealerHand.addCard(Card(1, 5))
self.dealerHand.addCard(Card(1, 5))
self.dealerHand.addCard(Card(1, 10))
self.assertLess(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
class GameLogicTest(unittest.TestCase):
def setUp(self):
dealerAgent = None
playerAgents = []
self.game = Game(dealerAgent, playerAgents)
self.playaHand = Hand(1)
self.dealerHand = Hand(0)
# Ensure that player blackjack beats dealer non-blackjack
def testPlayaBlackjackBeatsDealerNonBlackJack(self):
self.playaHand.addCard(Card(1, 0))
self.playaHand.addCard(Card(1, 10))
self.dealerHand.addCard(Card(1, 4))
self.dealerHand.addCard(Card(1, 5))
self.dealerHand.addCard(Card(1, 10))
self.assertGreater(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
# Ensure that player blackjack beats dealer non-blackjack
def testPlaya17LosesDealer21(self):
self.playaHand.addCard(Card(1, 0))
self.playaHand.addCard(Card(1, 6))
self.dealerHand.addCard(Card(1, 4))
self.dealerHand.addCard(Card(1, 5))
self.dealerHand.addCard(Card(1, 10))
self.assertLess(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
# Ensure that player blackjack beats dealer blackjack
def testPlayaBlackJackLosesDealerBlackjack(self):
self.playaHand.addCard(Card(1, 0))
self.playaHand.addCard(Card(1, 10))
self.dealerHand.addCard(Card(1, 0))
self.dealerHand.addCard(Card(1, 10))
self.assertGreater(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
# Ensure that player blackjack beats dealer blackjack
def testPlaya21LosesDealerBlackjack(self):
self.playaHand.addCard(Card(1, 4))
self.playaHand.addCard(Card(1, 5))
self.playaHand.addCard(Card(1, 10))
self.dealerHand.addCard(Card(1, 0))
self.dealerHand.addCard(Card(1, 10))
self.assertLess(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
# Ensure that player bust loses to dealer bust
def testPlayaBustLosesDealerBust(self):
self.playaHand.addCard(Card(1, 5))
self.playaHand.addCard(Card(1, 6))
self.playaHand.addCard(Card(1, 10))
self.dealerHand.addCard(Card(1, 5))
self.dealerHand.addCard(Card(1, 5))
self.dealerHand.addCard(Card(1, 10))
self.assertLess(self.game.determineWinner(self.playaHand, self.dealerHand), 0)
def executeRound(self):
# A map of hands to the players who control them.
handPlayerMap = {}
inactiveHandPlayerMap = {}
deck = Deck(1, 4, 13)
# Deal cards to the dealer. The dealer has a bet of 0.
dealerHand = Hand(0)
dealerHand.addCard(deck.take())
dealerHand.addCard(deck.take())
for playerAgent in self.playerAgents:
# TODO(snowden): Allow players to choose how much
# they bet each time.
playerHand = Hand(1)
playerHand.addCard(deck.take())
playerHand.addCard(deck.take())
handPlayerMap[playerHand] = playerAgent
# While there are still hands in play, ask the
# agent controlling the hand for the next action.
while handPlayerMap:
# It isn't possible to modify the keys of the existing
# map, so we have to create a new one each iteration.
newHandPlayerMap = {}
remainingHandPlayerMap = handPlayerMap
for (hand, playerAgent) in handPlayerMap.items():
currentHandPlayerMap = dict(newHandPlayerMap.items() +
remainingHandPlayerMap.items())
del remainingHandPlayerMap[hand]
action = playerAgent.getNextAction(
GameState(currentHandPlayerMap,
dealerHand, deck), hand)
if action == Actions.HIT:
hand.hit(deck)
if hand.isBust():
inactiveHandPlayerMap[hand] = playerAgent
else:
newHandPlayerMap[hand] = playerAgent
elif action == Actions.STAND:
hand.stand(deck)
# If the action is to stand, remove the hand from
# the map of active hands and add it to the map
# of inactive hands.
inactiveHandPlayerMap[hand] = playerAgent
elif action == Actions.SPLIT:
splitHands = hand.split(deck)
newHandPlayerMap[splitHands[0]] = playerAgent
newHandPlayerMap[splitHands[1]] = playerAgent
elif action == Actions.DOUBLE_DOWN:
hand.doubleDown(deck)
# After doubling down, the player may take no
# further actions.
inactiveHandPlayerMap[hand] = playerAgent
else:
raise ValueError("Not yet implemented.")
handPlayerMap = newHandPlayerMap
# All agents have either indicated that they want to
# stand or else have busted, so it is the dealer's
# turn to act.
while True:
# The dealer is not permitted to act on the cards
# that players have been dealt and can only hit
# or stand with each card received.
dealerAction = self.dealerAgent.getNextAction(None, dealerHand)
if dealerAction == Actions.STAND:
break
elif dealerAction == Actions.HIT:
dealerHand.hit(deck)
if dealerHand.isBust():
break
# print
# print "Dealer has: %s" % dealerHand.getValidCount()
# print "Player has: %s" % map(Hand.getValidCount, inactiveHandPlayerMap.keys())
# The dealer has finished executing its actions. Compare
# the dealer's hands with those of the players to determine
# winners and losers.
endingState = GameState(inactiveHandPlayerMap, dealerHand, deck)
for (hand, playerAgent) in inactiveHandPlayerMap.items():
result = self.determineWinner(hand, dealerHand)
# print result
if result < 0:
playerAgent.lose(endingState, hand)
self.losses[playerAgent] += 1
self.balances[playerAgent] -= hand.getBet()
elif result > 0:
playerAgent.win(endingState, hand)
self.wins[playerAgent] += 1
self.balances[playerAgent] += hand.getBet() * 1.5 if hand.isBlackJack() else 1
else: # result == 0
playerAgent.tie(endingState, hand)
self.ties[playerAgent] += 1
# Return the cards in the hand to the deck.
for card in hand.getCards():
deck.give(card)
# Return the dealer's cards to the deck.
for card in dealerHand.getCards():
deck.give(card)
# The deck should have all of the cards back.
deck.verifyFull()
def test_compare(self):
hand1 = Hand(1)
hand1.addCard(Card(0, 6))
hand1.addCard(Card(0, 7))
hand2 = Hand(1)
hand2.addCard(Card(0, 9))
hand2.addCard(Card(0, 3))
self.assertGreater(hand1.compare(hand2), 0)
self.assertLess(hand2.compare(hand1), 0)
self.assertEqual(hand1.compare(hand1), 0)
# BlackJack should beat a normal 21 hand.
hand1 = Hand(1)
hand1.addCard(Card(0, 0))
hand1.addCard(Card(0, 11))
self.assertTrue(hand1.isBlackJack())
hand2 = Hand(1)
hand2.addCard(Card(0, 3))
hand2.addCard(Card(0, 9))
hand2.addCard(Card(0, 6))
self.assertEqual(21, hand2.getValidCount())
self.assertFalse(hand2.isBlackJack())
self.assertGreater(hand1.compare(hand2), 0)
self.assertLess(hand2.compare(hand1), 0)
self.assertEqual(hand1.compare(hand1), 0)
def playRound(self):
#Acionar os booleanos e iniciar o jogo
game_on = True
firstTime = True
#Jogo começa
while game_on:
if firstTime:
print("Welcome to BlackJack Game, let's play!")
#Embaralhar e dar as cartas
deck = Deck()
deck.shuffleDeck()
dealerhand = Hand([deck.drawCard(),deck.drawCard()])
playerhand = Hand([deck.drawCard(),deck.drawCard()])
#Instanciar as classes
dealer = Dealer(dealerhand.cards)
player = Player(200,'Gabriel',playerhand.cards)
#Escolher aposta
bet = int(input("Choose your bet: "))
print(dealer)
print(player)
if playerhand.totalHandValue() == 21:
print("BlackJack! You win!")
break
if dealerhand.totalHandValue() == 21:
print("Dealer got a BlackJack! You lose :(")
break
choice = input('Hit[H], Stand[S], or Double[D]: ')
firstTime = False
else:
choice = input('Hit[H], Stand[S]: ')
if choice == 'H':
playerhand.addCard(deck.drawCard())
print(dealer)
print(player)
elif choice == 'D' or choice == 'S':
if choice == 'D':
player.wager(bet)
playerhand.addCard(deck.drawCard())
if dealerhand.totalHandValue() < 17:
while dealerhand.totalHandValue() < 17:
dealerhand.addCard(deck.drawCard())
print(dealer)
print(player)
if dealerhand.totalHandValue() <= 21:
if dealerhand.totalHandValue() > playerhand.totalHandValue():
print("You lose!")
break
elif playerhand.totalHandValue() <= 21:
print("You beat the dealer! You win!")
break
else:
if playerhand.totalHandValue() > 21:
print("You busted, dealer wins!")
break
else:
print("Dealer Busted! You win!")
break
if playerhand.totalHandValue() == dealerhand.totalHandValue():
print("It's a draw!")
break
print(dealer)
print(player)
class Player:
def __init__(self, id, deck, name=""):
self.name = name
self.id = id
self.hand = Hand(
deck) #Every player has a hand of cards drawn from deck
def setName(self, name):
self.name = name
def getName(self):
return self.name
def getId(self):
return self.id
def getHand(self):
return self.hand
def noOfCardsInHand(self):
return self.hand.noOfCardsInHand()
def askForCardToPlay(self):
"""Input 0 to draw a card."""
playCardWithIndex = None
while playCardWithIndex == None:
try:
playCardWithIndex = int(
input("Play Card: "
)) - 1 #-1 because we want index starting with 0
if playCardWithIndex >= self.noOfCardsInHand(
) or playCardWithIndex < -1:
print("Wrong number of card!")
playCardWithIndex = None
except ValueError:
print('Wrong number of card!')
return playCardWithIndex
def playCard(self, onOtherCard, deck):
index = self.askForCardToPlay()
if index == -1:
self.drawCards(deck, 1)
return None
else:
cardToPlay = self.hand.playCard(index, keepInHand=True)
while not cardToPlay.allowedOn(onOtherCard):
print('Card not allowed')
index = self.askForCardToPlay()
if index == -1:
self.drawCards(deck, 1)
return None
cardToPlay = self.hand.playCard(index, keepInHand=True)
return self.hand.playCard(index)
def drawCards(self, deck, amount):
for card in deck.drawCard(amount):
self.hand.addCard(card)
def takeTurn(self, deck, topCard, noOfPlayers):
if topCard.isSpecial():
if not topCard.didActionHappen(
): #Did action already act on a player
topCard.actionHappens() #Let action happen
if topCard.isSkip():
return 'skip'
elif topCard.isDraw2():
self.drawCards(deck, 2)
elif topCard.isDraw4():
self.drawCards(deck, 4)
return 'skip'
elif topCard.isReverse():
if noOfPlayers == 2: #Skip next player if 2 players and reverse card is played
return 'skip'
print(self) #Show the current player's hand
cardToPlay = self.playCard(topCard,
deck) #Play a card that's allowed on
#discard pile or draw a card
return cardToPlay #Play a card
def isWinner(self):
if self.hand.noOfCardsInHand() == 0:
return True
else:
return False
def isKi(self):
return False
def __str__(self):
return '%s\n%s' % (self.getName(), self.getHand())
def testNoValCardsNoCount(self):
hand = Hand(1)
hand.addCard(Card(1, 6))
hand.addCard(Card(1, 6))
self.agent.updateCount(hand)
self.assertEqual(0, self.agent.count)
def test_Soft17(self):
hand = Hand(0)
hand.addCard(Card(1, 6))
hand.addCard(Card(1, 0))
dealer = DealerAgent()
self.assertEqual(Actions.STAND, dealer.getNextAction(None, hand))
def testOffsettingCardsNoCount(self):
hand = Hand(1)
hand.addCard(Card(1, 0))
hand.addCard(Card(1, 2))
self.agent.updateCount(hand)
self.assertEqual(0, self.agent.count)
def testNoValCardsNoCount(self):
hand = Hand(1)
hand.addCard(Card(1, 6))
hand.addCard(Card(1, 6))
self.agent.updateCount(hand)
self.assertEqual(0, self.agent.count)
# testAce = Card('Diamond',1)
# testKing = Card('Spade',13)
# testCard = Card('Club',2)
# testInvalid = Card('Hearts',32)
# print(testQueen)
# print(testJack)
# print(testAce)
# print(testKing)
# print(testCard)
# print(testInvalid)
import sys
sys.path.append('../testers')
from deck import Deck
from hand import Hand
max_hand_size = 2
h1 = Hand(max_hand_size)
h2 = Hand(max_hand_size)
board = []
deck = Deck()
x = 0
while x < max_hand_size:
h1.addCard(deck.deal())
h2.addCard(deck.deal())
x += 1
for card in h1.getHeldCards():
print(card, end='')
def testOffsettingCardsNoCount(self):
hand = Hand(1)
hand.addCard(Card(1, 0))
hand.addCard(Card(1, 2))
self.agent.updateCount(hand)
self.assertEqual(0, self.agent.count)
from player import Player
pu = PokerUtil()
nothin = Hand(5)
pair = Hand(5)
two_pair = Hand(5)
trips = Hand(5)
straight = Hand(5)
flush = Hand(5)
fullhouse = Hand(5)
quads = Hand(5)
straight_flush = Hand(5)
# load a nothing hand (Darn :/, time to fold)
nothin.addCard(Card('Club', 6))
nothin.addCard(Card('Heart', 10))
nothin.addCard(Card('Spade', 11))
nothin.addCard(Card('Diamond', 1))
nothin.addCard(Card('Club', 12))
# load a pair hand (Aces, baby!)
pair.addCard(Card('Heart', 1))
pair.addCard(Card('Club', 1))
pair.addCard(Card('Diamond', 12))
pair.addCard(Card('Club', 7))
pair.addCard(Card('Heart', 8))
# Top TWO
two_pair.addCard(Card('Heart', 1))
two_pair.addCard(Card('Club', 1))
class Player():
def __init__(self, name):
self.id = None
self.name = name
self.type = 'Human'
self.hand = Hand()
self.legalCards = []
self.wildCards = []
self.valueChangeCards = []
self.zeroCards = []
self.canSkip = False
self.canReverse = False
self.canDrawTwo = False
self.canDrawFour = False
self.canValueChange = False
self.drew = False
self.points = 0
self.forceDraw = 0
def addCard(self, card):
self.drew = True
if self.forceDraw > 0:
self.forceDraw -= 1
self.drew = False
self.hand.addCard(card)
def beginTurn(self):
self.drew = False
def didDraw(self):
return self.drew
def getLegalCards(self, color, value, zeroChange=False):
self.canSkip = False
self.canReverse = False
self.canDrawTwo = False
self.canDrawFour = False
self.canValueChange = False
self.canZeroChange = False
self.legalCards = []
self.wildCards = []
self.valueChangeCards = []
self.zeroCards = []
plusFours = []
for card in self.hand:
if card.isWild():
if card.getValue() == '+4':
plusFours.append(card)
else:
self.wildCards.append(card)
elif zeroChange and card.isZero():
self.canZero = True
self.zeroCards.append(card)
elif card.getColor() == color or card.getValue() == value:
if card.getColor() != color:
self.canValueChange = True
self.valueChangeCards.append(card)
if card.getValue() == "+2":
self.canDrawTwo = True
elif card.getValue() == 'R':
self.canReverse = True
elif card.getValue() == 'X':
self.canSkip = True
self.legalCards.append(card)
if len(self.legalCards) == 0 and len(plusFours) > 0:
self.canDrawFour = True
self.wildCards += plusFours
def getValidCards(self):
return self.legalCards
def getAllValidCards(self):
return self.legalCards + self.wildCards + self.zeroCards
def hasLegalCard(self):
return len(self.legalCards) > 0
def addPoints(self, amount):
if (self.points + amount) <= 999999999999999999999:
self.points += amount
def removeCard(self, index):
return self.hand.removeCard(index)
def assignID(self, identity):
self.id = identity
def getName(self):
return self.name
def getID(self):
return self.id
def getPoints(self):
return self.points
def getType(self):
return self.type
def getCardNum(self):
return len(self.hand)
def getHand(self, scrollNum=0, hide=False):
return self.hand.show(scrollNum, hide)
def getForceDraws(self):
return self.forceDraw
def addForceDraw(self, num):
self.forceDraw += num
def decreaseForceDraw(self):
self.forceDraw -= 1
def removeForceDraw(self):
self.forceDraw = 0
def checkCard(self, index):
return self.hand.getCard(int(index))
def discardHand(self):
self.hand.discard()
def __str__(self):
return self.name
def __repr__(self):
return '({},{})'.format(self.name, self.points)
class Game:
def __init__(self):
self.deck = []
self.pit = []
# initialize the deck
self.resetDeck()
self.dealerHand = Hand()
self.playerHand = Hand()
self.scores = getScoresFromFile()
def resetDeck(self):
for figure in cardFigure:
for rank in range(1, len(cardRank) + 1):
self.deck.append(Card(rank, figure))
shuffle(self.deck)
def resetHands(self):
self.dealerHand = Hand()
self.playerHand = Hand()
def initializeGameScore(self):
self.scores['player'] = 0
self.scores['dealer'] = 0
def getScores(self):
return sortScores(self.scores)
def updateScoreDealer(self):
self.scores['dealer'] += 1
def updateScorePlayer(self):
self.scores['player'] += 1
def dealerTurn(self):
if (len(self.deck) == 0):
self.resetDeck()
card = self.deck.pop(0)
self.dealerHand.addCard(card)
def playerTurn(self):
if (len(self.deck) == 0):
self.resetDeck()
card = self.deck.pop(0)
self.playerHand.addCard(card)
def saveGameScore(self):
saveScores(self.scores)
def encodeDeck(self):
code = [0] * 52
for card in self.deck:
if card.figure == "p":
fig = 0
elif card.figure == "t":
fig = 1
elif card.figure == "c":
fig = 2
else:
fig = 3
code[4 * (card.rank-1) + fig] = 1
return code
class Player:
def __init__(self, id, deck, name = ""):
self.name = name
self.id = id
self.hand = Hand(deck) #Every player has a hand of cards drawn from deck
def setName(self, name):
self.name = name
def getName(self):
return self.name
def getId(self):
return self.id
def getHand(self):
return self.hand
def noOfCardsInHand(self):
return self.hand.noOfCardsInHand()
def askForCardToPlay(self):
"""Input 0 to draw a card."""
playCardWithIndex = None
while playCardWithIndex == None:
try:
playCardWithIndex = int(input("Play Card: ")) - 1 #-1 because we want index starting with 0
if playCardWithIndex >= self.noOfCardsInHand() or playCardWithIndex < -1:
print("Wrong number of card!")
playCardWithIndex = None
except ValueError:
print('Wrong number of card!')
return playCardWithIndex
def playCard(self, onOtherCard, deck):
index = self.askForCardToPlay()
if index == -1:
self.drawCards(deck, 1)
return None
else:
cardToPlay = self.hand.playCard(index, keepInHand = True)
while not cardToPlay.allowedOn(onOtherCard):
print('Card not allowed')
index = self.askForCardToPlay()
if index == -1:
self.drawCards(deck, 1)
return None
cardToPlay = self.hand.playCard(index, keepInHand = True)
return self.hand.playCard(index)
def drawCards(self, deck, amount):
for card in deck.drawCard(amount):
self.hand.addCard(card)
def takeTurn(self, deck, topCard, noOfPlayers):
if topCard.isSpecial():
if not topCard.didActionHappen(): #Did action already act on a player
topCard.actionHappens() #Let action happen
if topCard.isSkip():
return 'skip'
elif topCard.isDraw2():
self.drawCards(deck, 2)
elif topCard.isDraw4():
self.drawCards(deck, 4)
return 'skip'
elif topCard.isReverse():
if noOfPlayers == 2: #Skip next player if 2 players and reverse card is played
return 'skip'
print(self) #Show the current player's hand
cardToPlay = self.playCard(topCard, deck) #Play a card that's allowed on
#discard pile or draw a card
return cardToPlay #Play a card
def isWinner(self):
if self.hand.noOfCardsInHand() == 0:
return True
else:
return False
def isKi(self):
return False
def __str__(self):
return '%s\n%s' % (self.getName(), self.getHand())
from hand import Hand
from cards import Card
h = Hand(5)
h.addCard(Card('Heart',13))
h.addCard(Card('Club',13))
h.addCard(Card('Diamond',2))
h.addCard(Card('Club',7))
h.addCard(Card('Heart',8))
for rank in h.getHandRanks():
print(rank)
def createHandWithAceFive(self):
hand = Hand(1)
hand.addCard(Card(1, 0))
hand.addCard(Card(1, 6))
hand.addCard(Card(1, 4))
return hand
class Player(object):
HUMAN = 1
COMPUTER = 0
def __init__(self,name,tyyppi):
self.__name=name
self.__cottages=0
self.__points=0
self.__hand = Hand()
self.__type = tyyppi
self.__stack = Hand()
'''
name methods
'''
def getName(self):
return self.__name
'''
point methods
'''
def updatePoints(self,amount):
self.__points += amount
def setPoints(self,amount):
self.__points = amount
def getPoints(self):
return self.__points
'''
cottage methods
'''
def getCottages(self):
return self.__cottages
def raiseCottages(self,amount):
self.__cottages+=amount
def setCottages(self,amount):
self.__cottages=amount
def clearCottages(self):
self.__cottages=0
'''
hand methods
'''
def getHand(self):
return self.__hand
def addCardsToHand(self,cards):
self.__hand.addCards(cards)
def addCardToHand(self,card):
self.__hand.append(cards)
def setHand(self,cards):
self.__hand.clear()
self.__hand.addCards(cards)
def hasCards(self):
return len(self.__hand.getCards())>0
'''
stack methods
'''
def getStack(self):
return self.__stack
def clearStack(self):
self.__stack=Hand()
def addCardsToStack(self,cards):
for card in cards:
self.addCardToStack(card)
def addCardToStack(self,card):
self.__stack.addCard(card)
def setStack(self,cards):
self.__stack.clear()
self.__stack.addCards(cards)
'''
type methods
'''
def getType(self):
return self.__type
'''
other methods
'''
def getScoreFromStack(self):
points = self.__cottages
points += self.__stack.getSureValue()
return points
def __str__(self):
return self.__name+"-"+str(self.__points)
