class Dealer:
def __init__(self):
self.money = 1E999
self.name = "Dealer"
self.hand = Hand()
def print_hand(self, hand_idx=0):
print(self.hand.cards[0], end=" ")
for _ in self.hand.cards[1:]:
print("xx", end=" ")
print()
def print_all(self, hand_idx=0):
for card in self.hand:
print(card, end=" ")
print()
def add(self, card):
self.hand.append(card)
def can_buy_insurance(self):
return self.hand.cards[0] == 'A'
def get_max_points(self):
return self.hand.get_max_points()
def test_card(self):
# Empty hand
test_hand = Hand()
self.assertEqual(0, test_hand.__len__())
# Add a 2 of Clubs
test_hand.append(Card(2, "C"))
self.assertEqual(1, test_hand.__len__())
# Add an Ace of Spades
test_hand.append(Card("A", "S"))
self.assertEqual(2, test_hand.__len__())
# Check for an Ace of Spades
self.assertTrue(test_hand.has_card(Card("A", "S")))
# Check for a Jack of Diamonds
self.assertFalse(test_hand.has_card(Card("J", "D")))
# Remove an Ace of Spades
test_hand.remove_card(Card("A", "S"))
self.assertEqual(1, test_hand.__len__())
# Remove a card that isn't in the hand
removed_card = test_hand.remove_card(Card("J", "D"))
self.assertEqual(None, removed_card)
self.assertEqual(1, test_hand.__len__())
class Player:
def __init__(self, name, cash):
self.name = name
self.hand = Hand([])
self.cash = cash
self.is_folded = False
self.is_all_in = False
self.is_out = False
def bet(self, amount):
if amount <= self.cash:
self.update_cash(-1 * amount)
else:
raise Error("Could not make the bet.")
if self.cash == 0:
self.is_all_in = True
return amount
def call(self, amount):
self.bet(amount)
return amount
def raise_bet(self, starting_amount, ending_amount):
self.bet(ending_amount)
return ending_amount - starting_amount
def check(self):
return 0
def fold(self):
self.is_folded = True
return 0
def deal_card(self, card):
self.hand.append(card)
def deal_cards(self, cards):
self.hand.extend(cards)
def update_cash(self, amount):
if self.is_all_in and amount == 0:
self.is_out = True
self.cash += amount
if self.cash == 0:
self.all_in = True
def reset(self):
self.cards = []
self.is_folded = False
class Round():
def __init__(self, game, playerDeals):
self.playerDeals = playerDeals
self.deck = Deck()
self.playerHand = Hand()
self.computerHand = Hand()
self.crib = Hand(True)
self.playedCardsPlayer = []
self.playedCardsComputer = []
self.cardsInPlay = []
def deal(self):
this.deck.reset()
this.deck.shuffle()
for x in range(6):
this.playerHand.append(deck.pop())
this.computerHand.append(deck.pop())
this.playerHand.sort()
this.computerHand.sort()
def playhand(self):
crib = Hand(True)
# Computer deposit cards to crib
self.depositToCrib(computerHand,
AI.getDepositCards(computerHand, playerDeals))
# Player deposit cards to crib
self.depositToCrib(playerHand,
Player.getDepositCards(playerHand, playerDeals))
getUpcard()
while len(playerHand) + len(computerHand) > 0:
if playerTurn:
self.playerHand.
else
def depositToCrib(hand, cards):
for c in cards:
self.crib.append(c)
hand.remove(c)
def getUpcard(self):
upcard = self.deck.pop()
if upcard.rankInt == 10:
self.game.awardPoints(self.playerdeals, 2)
if self.game.playerPoints >= 121 or self.game.computerPoints >= 121:
self.game.gameover()
return
def playCard(self, card):
count = 0
for c in self.cardsInPlay:
count += c.rankInt
count += card.rankInt
if count > 31:
return False
class Game:
def __init__(self):
self.players = [Human('Player'), CPU('CPU')]
self.dealToCrib = False
if (len(self.players) == 2):
self.dealCardNumber = 6
elif (len(self.players) == 3 or len(self.players) == 4):
self.dealCardNumber = 5
self.dealToCrib = True
else:
raise ValueError('Number of players not supported')
self.gameWinningScore = 121
self.cutCard = None
self.currentDealer = None
self.deck = Deck()
self.crib = Hand()
def determineDealer(self):
randomIndex = random.randrange(len(self.players))
self.currentDealer = self.players[randomIndex]
def switchDealer(self):
dealerIndex = self.players.index(self.currentDealer)
if (dealerIndex < 0 or dealerIndex >= len(self.players)):
self.determineDealer()
elif ((dealerIndex + 1) % len(self.players) == 0):
self.currentDealer = self.players[0]
else:
self.currentDealer = self.players[dealerIndex + 1]
def dealCards(self):
self.deck.shuffle()
for i in range(self.dealCardNumber):
for player in self.players:
player.hand.append(self.deck.deal())
if (self.dealToCrib):
self.crib.append(self.deck.deal())
self.cutCard = self.deck.cut()
def discard(self):
# Player discard
# First
for player in self.players:
self.crib.append(player.discard())
self.crib.append(player.discard())
def playRound(self):
currentPlay = Play()
currentPlayerIndex = self.players.index(self.currentDealer)
currentPlayer = self.players[currentPlayerIndex]
for player in self.players:
player.createPlayHand()
lastPlayerToPlay = None
while True:
# Determine is anyone has cards left
someoneHasCards = False
for player in self.players:
if (len(player.playHand) > 0):
someoneHasCards = True
if (not someoneHasCards):
break
# Get the next player
if ((currentPlayerIndex + 1) % len(self.players) == 0):
currentPlayerIndex = 0
currentPlayer = self.players[0]
else:
currentPlayerIndex += 1
currentPlayer = self.players[currentPlayerIndex]
# If player can play, play
if (currentPlayer.canPlay(currentPlay.pointLimit)):
cardPlayed = currentPlayer.play(currentPlay.pointLimit)
currentPlay.append(cardPlayed)
print('{0} plays {1}'.format(currentPlayer.name, cardPlayed))
currentPlayer.score += currentPlay.calculateExtraPoints()
lastPlayerToPlay = currentPlayer
print(currentPlay.points)
else:
if (currentPlayer == lastPlayerToPlay):
currentPlayer.score += 1
print('{0}: One for last'.format(currentPlayer.name))
currentPlay.reset()
else:
print('{0} GO'.format(currentPlayer.name))
currentPlayer.score += 1
print('{0}: One for last'.format(currentPlayer.name))
currentPlay.reset()
def show(self):
print('Cut Card: {0}'.format(self.cutCard))
for player in self.players:
print(player.name, player.hand)
player.show(self.cutCard)
print('The Crib: {0}'.format(self.crib))
self.currentDealer.score += self.crib.getPoints(self.cutCard)
def endRound(self):
self.crib.clear()
self.cutCard = None
for player in self.players:
player.hand.clear()
def isComplete(self):
for player in self.players:
if (player.score >= self.gameWinningScore):
return True
return False
def getScoreBoardString(self):
scoreBoardString = ''
for player in self.players:
scoreBoardString += '{0:16s}: {1:3d}\n'.format(
player.name, player.score)
return scoreBoardString
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)
