class Player(object):
def __init__(self, chips=100):
self.chips = chips
self.hand = Hand()
def _subtract_chips(self, amt):
if self.chips >= amt:
self.chips -= amt
else:
raise StandardError("Not enough chips")
def clear_hand(self):
self.hand.clear()
def bet(self, amt):
self._subtract_chips(amt)
def add_card(self, card):
self.hand.add_card(card)
class Game:
def __init__(self):
self.deck = Deck()
self.dealer_hand = Hand()
self.player_hand = Hand()
self.deck.shuffle()
def reset(self):
self.deck.reset()
self.dealer_hand.clear()
self.player_hand.clear()
self.deck.shuffle()
def ask_user(self, prompt, valid_inputs):
"""
Prompt the user with a question, and repeat until they give a valid answer
For example, `self.ask_user('Choose:', ['hit', 'stay'])` will display:
Choose: (hit/stay)
and loop until the user types either hit or stay
:param prompt: The question to display
:param valid_inputs: the valid answers
:return: one of the valid answers given
"""
joined_inputs = '/'.join(valid_inputs)
prompt_string = f'{prompt} ({joined_inputs}) '
result = input(prompt_string)
while result not in valid_inputs:
print('Invalid input, please try again')
result = input(prompt_string)
return result
def play_hand(self):
# First, make sure everything is cleared out to play the hand
self.reset()
# Setup and deal two cards to each player
self.player_hand.add_card(self.deck.draw())
self.dealer_hand.add_card(self.deck.draw())
self.player_hand.add_card(self.deck.draw())
self.dealer_hand.add_card(self.deck.draw())
# Print the game state out to the user
self.display_game()
# Checks for natural 21
if self.player_hand.score() == 21:
print('You Win!')
return
# Start by asking the user if they want to hit or stay
user_input = self.ask_user('Choose:', ['hit', 'stay'])
# Loop so long as the user is not busted and they have not entered "stay"
while user_input != 'stay' and not self.player_hand.is_bust():
# Deal the player another card
self.player_hand.add_card(self.deck.draw())
# Print out the game state again
self.display_game()
# Check if the user is busted and if so, return because the hand is done
if self.player_hand.is_bust():
print('Bust! You Lose!')
return
# Ask the user again if they'd like to hit, which determines if the loop will run again
user_input = self.ask_user('Choose:', ['hit', 'stay'])
# If the player hasn't busted, dealer plays
# From here on out we don't mask the dealer's cards beyond the first
self.display_game(dealer_hidden=False)
# Dealers hit on 16 and stay on 17, so that's the condition for our loop
while self.dealer_hand.score() < 17:
print('Dealer hits')
# Dealer draws a card
self.dealer_hand.add_card(self.deck.draw())
# Print out the game state again
self.display_game(dealer_hidden=False)
# Check if the dealer has busted and if so, return out of this function
if self.dealer_hand.is_bust():
print('Dealer busted! You Win!')
return
# Neither player has busted, who wins?
if self.player_hand.score() > self.dealer_hand.score():
print('You Win!')
else:
# Dealer wins in case of a tie
print('You Lose!')
def display_game(self, dealer_hidden=True):
"""
Print out the game state to the console
:param dealer_hidden: If cards in the dealers hand beyond the first should be "face down"
:return: None
"""
print('Your hand:')
print(self.player_hand.display())
print(f'Score: {self.player_hand.score()}')
print('Dealer\'s hand:')
print(self.dealer_hand.display(dealer_hidden))
print()
def run(self):
"""
Main entry point to the game. Plays hands in a loop until the user chooses to exit
:return: None
"""
play_again = None
while play_again != 'n':
self.play_hand()
play_again = self.ask_user('Play again?', ['y', 'n'])
class BlackJack:
def __init__(self, shoe_size=6):
self.deck = Deck(shoe_size)
self.players = self.setup_players()
self.dealer = Hand('Dealer')
def setup_players(self):
plrs = []
while True:
try:
q = int(input('How many players are going to play?: '))
break
except ValueError:
print('Please enter a base 10 number.')
for i in range(q):
player_name = input('What is the name of player {}?: '.format(i + 1))
plrs.append(Hand(player_name))
return plrs
def deal_round(self):
for i in range(2):
for p in self.players:
p.take(self.deck.deal_card())
self.dealer.take(self.deck.deal_card())
def play_round(self):
self.deal_round()
for p in self.players:
while p.score() <= 21:
p.display_hand()
q = input('Would you like to (H)it or (S)tay?: ').lower()
if q == 'h':
p.take(self.deck.deal_card())
elif q == 's':
break
else:
if p.score() > 21:
p.display_hand()
else:
self.dealer.display_hand()
d_score = self.dealer.score()
while d_score < 17:
self.dealer.take(self.deck.deal_card())
self.dealer.display_hand()
d_score = self.dealer.score()
time.sleep(1)
def clear_hands(self):
for p in self.players:
p.clear()
self.dealer.clear()
def score_game(self):
winner = self.dealer
score = self.dealer.score() if self.dealer.score() <= 21 else 0
for p in self.players:
if 22 > p.score() > score:
score = p.score()
winner = p
return winner
def game(self):
while True:
self.play_round()
print('{} wins!'.format(self.score_game().name))
self.clear_hands()
q = input("Would you like to play again?: ").lower()
if 'n' in q:
quit()
import sys import os sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from hand import Hand testHand = Hand() ## Royal Flush testHand.add_card(14,0) testHand.add_card(10,0) testHand.add_card(12,0) testHand.add_card(11,0) testHand.add_card(13,0) testHand.clear() ## Straight Flush testHand.add_card(9,3) testHand.add_card(10,3) testHand.add_card(12,3) testHand.add_card(11,3) testHand.add_card(13,3) testHand.clear() ## Straight testHand.add_card(9,1) testHand.add_card(10,2) testHand.add_card(12,0) testHand.add_card(11,3) testHand.add_card(13,2) testHand.clear()
class GameController:
CONST_ISLAND_MASK = 0b10000
CONST_FOREST_MASK = 0b01000
CONST_PLAIN_MASK = 0b00100
CONST_MOUNTAIN_MASK = 0b00010
CONST_SWAMP_MASK = 0b00001
def __init__(self, deck_wanted_size, hand_init_size, enable_mulligan=True):
assert deck_wanted_size >= hand_init_size
assert deck_wanted_size >= self.get_land_quantity()
self.deck = Deck()
self.hand = Hand()
self.board = Board()
self.deck_wanted_size = deck_wanted_size
self.hand_init_size = hand_init_size
self.enable_mulligan = enable_mulligan
self.decision_tree = {}
self.compute_tree = []
def init(self):
self.deck.clear()
self.hand.clear()
self.board.clear()
def insert_lands_in_deck(self):
for land, quantity in binary_lands.items():
card = Card(
'terrain',
land & self.CONST_ISLAND_MASK,
land & self.CONST_FOREST_MASK,
land & self.CONST_PLAIN_MASK,
land & self.CONST_MOUNTAIN_MASK,
land & self.CONST_SWAMP_MASK,
)
self.deck.add_card(card)
def fill_deck(self):
for i in range(self.deck_wanted_size - self.get_land_quantity()):
self.deck.add_card(Card('useless'))
def game_set_up(self):
self.insert_lands_in_deck()
self.fill_deck()
self.deck.shuffle()
# If we enable mulligans
def mulligan_phase(self, hand_size):
cards_drawn = self.deck.draw(hand_size)
self.hand.clear()
self.hand.add_cards(cards_drawn)
if not self.enable_mulligan or \
self.deck.get_size() == 0 or \
hand_size == 0 or \
not self.hand.is_improvable(self.get_land_quantity(), self.deck.get_size()):
return
# Put card back into the deck and redraw
self.deck.add_cards(self.hand.get_cards())
self.deck.shuffle()
self.hand.clear()
self.mulligan_phase(hand_size - 1)
def run(self):
self.init()
self.game_set_up()
self.mulligan_phase(self.hand_init_size)
print(self.hand)
ret = self.game()
# game_result(ret)
def check_succeed(self, binary_hand_matrix, chain=0b00000):
for binary_card in binary_hand_matrix:
binary_substract = [
x for x in binary_hand_matrix if x != binary_card
]
chain = 0b00000
for elem in binary_card:
chain = chain | elem
print(chain)
if chain == 0b11111:
print("Returning True")
return True
print("Returning False")
return False
# def place_element_tree(self, tree, elem):
# if not tree:
# if type(elem) != tuple:
# elem = tuple(elem)
# for e in elem:
# tree[e] = {}
# return
# for key, val in tree.items():
# self.place_element_tree(val, elem)
#
# def construct_decision_tree(self):
# for card in self.board.get_cards():
# if card.name == 'cavern':
# continue
# self.place_element_tree(self.decision_tree, card)
#
# def do_compute_tree(self, next_elem, path=''):
# if not next_elem:
# return self.compute_tree.append(path)
# for key, val in next_elem.items():
# if key in path:
# self.do_compute_tree(val, path)
# else:
# self.do_compute_tree(val, path + key)
#
# def check_succeed(self):
# if self.board.get_size() > 5 and self.board.has_cavern():
# return True
# self.construct_decision_tree()
# # print(json.dumps(decision_tree, indent=1))
# self.do_compute_tree(self.decision_tree)
# # print(json.dumps(compute_tree, indent=1))
#
# for elem in self.compute_tree:
# if len(elem) == 5:#nb_diff_land_to_collect:
# return True
# return False
def place_land_board(self):
weight_matrix = {}
for key, card in enumerate(self.hand.get_cards()):
if card.name == 'useless':
continue
if card.name == 'cavern':
if len(self.board.get_size()) == 5:
weight_matrix[key] = 100
else:
weight_matrix[key] = 0.5
if card in self.board.get_cards():
weight_matrix[key] = 1
weight_matrix[key] = len(card.get_mana_colors())
if not weight_matrix:
return
key = max(weight_matrix, key=weight_matrix.get)
card_to_add = self.hand.remove(key)
self.board.add_card(card_to_add)
# print('%s added to the board...' % (card_to_add))
# print(self.board)
def game(self):
while self.deck.get_size() > 0:
self.decision_tree = {}
self.compute_tree = []
card_drawn = self.deck.draw(1)
# print("Draw %s" % (card_drawn,))
self.hand.add_cards(card_drawn)
self.place_land_board()
print(self.board)
if self.check_succeed(self.board.get_cards_binary_color_matrix()):
return 1
return 0
@staticmethod
def get_land_quantity():
return len(binary_lands)
card7 = Card(rank="7", suit="c") card8 = Card(rank="8", suit="c") card9 = Card(rank="9", suit="c") card10 = Card(rank="10", suit="c") card11 = Card(rank="11", suit="c") card12 = Card(rank="12", suit="c") card13 = Card(rank="13", suit="c") print(card1) # Ac print(card2) # 2c print(card3) # 3c print(card4) # 4c print(card5) # 5c my_hand = Hand() print(my_hand) # <empty> my_hand.add(card1) my_hand.add(card2) my_hand.add(card3) my_hand.add(card4) my_hand.add(card5) print(my_hand) # Ac 2c 3c 4c 5c your_hand = Hand() my_hand.give(card1, your_hand) my_hand.give(card2, your_hand) print(your_hand) # Ac 2c print(my_hand) # 3c 4c 5c my_hand.clear() print(my_hand) # <empty>
dealer_bust = True
for i in range(len(player)):
if (player[i].value > dealer.value and not player_bust[i]) or (dealer_bust and not player_bust[i]):
if len(player) > 1:
print('You win on hand ' + str(i + 1) + '!')
else:
print('You win!')
elif player[i].value == dealer.value and not player_bust[i]:
if len(player) > 1:
print('You tie the dealer on hand ' + str(i + 1) + '.')
else:
print('You tie the dealer.')
else:
if len(player) > 1:
print('You lose on hand ' + str(i + 1) + '!')
else:
print('You lose!')
play_again = True if input('\nPlay again? (y/n) ').lower() == 'y' else False
if play_again:
player = []
player_bust = []
player.append(Hand())
player_bust.append(False)
dealer.clear()
print('\n\nThanks for playing Blackjack!\n\n')
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)
