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)
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)
# 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='')
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)