def setUp(self):
# get a deck with no cards to test scoring
self.score_deck = Deck()
self.score_deck.cards = []
# get a regular deck
self.deck = Deck()
# get a Hand
self.hand = Hand(self.deck)
def deal_start(self):
"""
deals the cards for the start of the game
@return: tuple( hand:3Card deck table: 4 card Deck)
"""
hand = Deck([])
table = Deck([])
for i in range(0, 3):
hand.cards.append(self.draw_pile.draw())
for i in range(0, 4):
table.cards.append(self.draw_pile.draw())
return (hand, table)
def play(self):
poker_players = []
num_players = input("How many players? ")
for i in range(int(num_players)):
player_name = input("Name of poker player {}? ".format(i + 1))
poker_player = PokerPlayer(player_name)
poker_players.append(poker_player)
print("Dealing cards")
deck = Deck()
deck.shuffle()
for i in range(7):
for poker_player in poker_players:
poker_player.add_card(deck.deal())
print(poker_player)
if (i < 6):
dealmore = input("Deal more card(y or n)? ")
if (dealmore.lower() == 'n'):
return
for poker_player in poker_players:
poker_player.review_all_fiver_hands()
poker_score = poker_player.get_top_poker_score()
print(poker_player.name.center(30, '-'))
print(poker_score)
def __init__(self, num_players=2):
self.deck = Deck()
self.hands = []
self.community_cards = []
self.num_players = num_players
self.pot = 0
self.bet_amt = 0
def __init__(self):
deck = Deck()
deck.shuffle()
deck = deck.get_cards()
piles: List[List[Card]] = []
for i in range(Game.PILES):
piles.append([])
pile_len = i + 1
for j in range(pile_len):
card = deck.pop()
if not j == pile_len - 1:
card.visible = False
piles[i].append(card)
hand: List[Card] = []
self.varInput = VarInput()
self.deck = deck
self.hand = hand
self.piles = piles
self.finished = [0] * len(Card.SUITS)
def __init__(self):
self._deck = Deck()
self._deck.shuffle()
# Pass the player and dealer two cards each
self._player = Player([self._deck.deal(), self._deck.deal()])
self._dealer = Dealer([self._deck.deal(), self._deck.deal()])
def __init__(self, game_type: str) -> None:
self.players: List[Player] = []
self.deck: Deck = Deck()
self.playthrough: int = 0
self.discards: Deck = Deck()
self.current_player_index: int = 0
self.status: str = 'Awaiting' # Awaiting, Running, Completed
self.id: str = str(uuid.uuid4())[:6]
self.stage_index: int = 0
self.market: List[Card] = []
self.trades: List[Trade] = []
self.winner = None
self.game_type: str = game_type
self.last_updates: List[Dict] = []
self.deck.build_deck()
self.deck.shuffle()
def __init__(self, verbose=False):
self.verbose = verbose
if verbose:
deck = Deck()
deck.cards.sort(key=self.undesirability)
self.say('Card undesirability: ')
for card in deck.cards:
self.say('{}: {}', card, self.undesirability(card))
def shuffle_and_deal(self):
self.deck = Deck()
self.deck.shuffle()
for seat in self.seats:
seat.set_card_1(self.deck.deal())
for seat in self.seats:
seat.set_card_2(self.deck.deal())
def draw(
player: 'Player',
deck: Deck,
num: int=1
) -> typing.Tuple['Player', Deck]:
if num not in range(1, len(deck) + 1):
return player, deck
return (
Player(player.name(), hand=player.hand() + Cards(deck[:num])),
Deck(deck[num:]))
def get_remaining_cards(self, hand_cards):
deck = Deck()
remaining_cards = []
for c in deck.cards:
for pc in hand_cards + self.seen_cards:
if c == pc:
break
else:
remaining_cards.append(c)
return remaining_cards
def __init__(self):
self._players_nb = None
self._blend = None
self._max_game = 100000
self._deck = Deck(6)
strat_simple = Simple()
strat_base = Base()
self._dealer = Player(10000, 1, strat_simple, 'dealer')
self._players = []
self._players.append(Player(0, 0, strat_base, 'guest'))
def __init__(self, players, verbose=False):
"""
players is a list of four players
"""
self.verbose = verbose
if len(players) != 4:
raise ValueError('There must be four players.')
self.players = players
# Invariant: the union of these lists makes up exactly one deck of cards
deck = Deck()
self._player_hands = tuple(deck.deal())
self._cards_taken = ([], [], [], [])
def __init__(self):
self.state = None
self.state_history = []
self.width = 1300
self.height = 700
self.window = None
self.clock = None # used for fps
self.game_over = False # true when game is over
self.title_image = None # title image
self.empty_table = None # empty table image
self.cards = Deck()
self.cards.shuffle() # O(n)
self.table = Table()
self.player = Player('p')
self.bot = Bot()
def __init__(self,
gameid,
draw_pile=None,
players=[],
game_board=[],
prev_turn=[]):
if not draw_pile:
self.draw_pile = Deck()
self.draw_pile.shuffle()
else:
self.draw_pile = draw_pile
self.players = players
self.game_board = game_board
self.id = gameid
self.prev_turn = prev_turn
def play_card(self, game, other_info={}, simulation_time_limit=1):
for player_idx, suits in other_info.get("lacking_info", {}).items():
for suit in suits:
game.lacking_cards[player_idx][suit] = True
self.say("Player-{} may lack of {} suit({}, {})", player_idx, suit,
game.lacking_cards[player_idx], other_info)
self.say("Player-{}, the information of lacking_card is {}", \
self.position, [(player_idx, k) for player_idx, info in enumerate(game.lacking_cards) for k, v in info.items() if v])
hand_cards = [[] if player_idx != self.position else
game._player_hands[player_idx]
for player_idx in range(4)]
remaining_cards = Deck().cards
for card in self.seen_cards + hand_cards[self.position]:
remaining_cards.remove(card)
taken_cards = []
for player_idx, cards in enumerate(game._cards_taken):
taken_cards.append(card_to_bitmask(cards))
init_trick = [[None, game.trick]]
void_info = {}
for player_idx, info in enumerate(game.lacking_cards):
if player_idx != self.position:
void_info[player_idx] = info
must_have = self.transfer_cards
selection_func = expert_choose
self.say("proactive_mode: {}, selection_func={}, num_of_cpu={}",
self.proactive_mode, selection_func, self.num_of_cpu)
played_card = run_one_step(
game.trick_nr + 1, self.position, self.num_hand_cards,
copy.deepcopy(init_trick), hand_cards, game.is_heart_broken,
[2 if player.expose else 1
for player in game.players], remaining_cards, taken_cards, None,
selection_func, must_have, void_info)
self.say("pick {} card", played_card)
return played_card
def play():
print('********************')
print('* Blackjack')
dealer = Player(name='Dealer')
guest = Player(name='Guest')
deck = Deck().shuffle().shuffle()
for _ in range(2):
dealer, deck = Player.draw(dealer, deck)
guest, deck = Player.draw(guest, deck)
print('')
print(f"{dealer.name()}'s 1st card: " + str(dealer.hand()[0]))
print('')
print(f"* {guest.name()}'s turn *")
Blackjack._show_hand(guest)
while not BlackjackRule.busts(guest):
decision = GuestDecision.decide()
if decision is GuestDecision.STAND:
break
if decision is GuestDecision.HIT:
guest, deck = Player.draw(guest, deck)
Blackjack._show_hand(guest)
else:
print('Bust!')
Blackjack._result(dealer=dealer, guest=guest)
return
print('')
print(f"* {dealer.name()}'s turn *")
Blackjack._show_hand(dealer)
while not BlackjackRule.busts(dealer):
if BlackjackRule.point(dealer) >= 17:
break
else:
dealer, deck = Player.draw(dealer, deck)
Blackjack._show_hand(dealer)
else:
print('Bust!')
Blackjack._result(dealer=dealer, guest=guest)
return
Blackjack._result(dealer=dealer, guest=guest)
def __init__(self, verbose=False):
self.seen_cards = []
self.freeze_cards = []
self.transfer_cards = {}
self.name = None
self.position = None
self.expose = False
self.proactive_mode = set()
self.void_info = {
0: {
Suit.spades: False,
Suit.hearts: False,
Suit.diamonds: False,
Suit.clubs: False
},
1: {
Suit.spades: False,
Suit.hearts: False,
Suit.diamonds: False,
Suit.clubs: False
},
2: {
Suit.spades: False,
Suit.hearts: False,
Suit.diamonds: False,
Suit.clubs: False
},
3: {
Suit.spades: False,
Suit.hearts: False,
Suit.diamonds: False,
Suit.clubs: False
}
}
self.remaining_cards = set(Deck().cards)
self.num_hand_cards = {0: 13, 1: 13, 2: 13, 3: 13}
self.verbose = verbose
def reset(self):
self.trick_nr = 0
self.current_player_idx = 0
self.trick = []
self.trick_cards = []
for _ in range(13):
self.trick_cards.append([None, None, None, None])
self.player_scores = [0, 0, 0, 0]
self.player_action_pos = [[0] * 13, [0] * 13, [0] * 13, [0] * 13]
self.expose_info = [1, 1, 1, 1]
self.take_pig_card = False
self.is_heart_broken = False
self.is_shootmoon = False
for i in range(4):
self.players[i].set_position(i)
self.players[i].reset()
deck = Deck()
self._player_hands = list(deck.deal())
self._cards_taken = ([], [], [], [])
self._b_cards_taken = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
[0, 0, 0, 0]]
self._temp_score = [0, 0, 0, 0]
self.lacking_cards = []
for _ in range(4):
self.lacking_cards.append({
Suit.spades: False,
Suit.hearts: False,
Suit.diamonds: False,
Suit.clubs: False
})
def __init__(self):
"""Sets up the window and widgets."""
Frame.__init__(self)
self.master.title("Card Demo")
self.grid()
self._deck = Deck()
self._backImage = PhotoImage(file=Card.BACK_NAME)
self._cardImage = None
self._imageLabel = Label(self, image=self._backImage)
self._imageLabel.grid(row=0, column=0, rowspan=3)
self._textLabel = Label(self, text="")
self._textLabel.grid(row=3, column=0)
# DealButton
self._dealButton = Button(self, text="Deal", command=self._deal)
self._dealButton.grid(row=0, column=1)
# ShuffleButton
self._shuffleButton = Button(self,
text="Shuffle",
command=self._shuffle)
self._shuffleButton.grid(row=1, column=1)
# newButton
self._newButton = Button(self, text="New Deck", command=self._new)
self._newButton.grid(row=2, column=1)
def __init__(self):
self.deck = Deck(double=True)
self.player_list = {}
def setUp(self):
self.deck = Deck()
self.deck_multiple = Deck(10)
def __init__(self, document, canv):
'''Store the main window, create the Board and Deck models;
create all the buttons and labels to allow the user to manipulate the game.
'''
self._doc = document
self._canv = canv # fabric Canvas object
self._canv.on("mouse:up", self.onCardClick)
self.loadCardMoveSound()
self.loadCardInPlaceSound()
self.loadEndOfRoundSound()
self.loadFanfareSound()
self._playSounds = True
self._board = Board()
self._deck = Deck()
self._deck.addAllCards()
self._copyOfDeck = self._deck.makeCopy()
# We'll fill this in when we remove the aces from the board.
self._removedAces = []
# keeps track of cards that can be moved: each item is a tuple:
# (card, row, col)
self._moveableCards = []
# A mapping from card object to CardImg object. We do it this way
# so that the card object (in the model) remains agnostic of the view
# being used on it.
self._card2ImgDict = {}
self._score = 0
# a list of templates of high scores we can update when high scores
# change, so the screen changes immediately
self._score_val = []
self._storage = local_storage.storage
self.loadSettingsFromStorage()
# count of cards correctly placed, per round. 1st round is in
# index 0, and initialized to 0 cards placed.
self._cardsPlacedPerRound = [0]
self._roundNum = 1
# 2 rows of info about the game.
self._game_info_elem = html.DIV(Class="game-info")
self._doc <= self._game_info_elem
self._game_info2_elem = html.DIV(Class="game-info")
self._doc <= self._game_info2_elem
self._next_round_btn = html.BUTTON(
"Next Round", Class="button", disabled=True)
self._next_round_btn.bind('click', self.nextRound)
self._game_info_elem <= self._next_round_btn
self._round_info_elem = \
html.SPAN("Round: {roundNum}",
Class="info-text", id="round_num")
self._game_info_elem <= self._round_info_elem
self._round_num_val = template.Template(self._round_info_elem)
self.updateRoundNum()
self._cardsInPlace = self._board.countCardsInPlace()
self._cards_in_place_elem = html.SPAN(
"Cards in place: {cardsInPlace}", Class="info-text")
self._game_info_elem <= self._cards_in_place_elem
self._cardsInPlace_val = template.Template(self._cards_in_place_elem)
self.updateCardsInPlace()
self._score_info_elem = html.SPAN(
"Score: {score}", Class="info-text")
self._game_info_elem <= self._score_info_elem
self._scoreInfo_val = template.Template(self._score_info_elem)
self._pts_per_card_info_elem = html.SPAN(
"Pts per card: {ptsPerCard}", Class="info-text")
self._game_info_elem <= self._pts_per_card_info_elem
self._ptsPerCardInfo_val = template.Template(
self._pts_per_card_info_elem)
self.updateScore()
self._new_game_btn = html.BUTTON(
"New Game", Class="button", disabled=True)
self._new_game_btn.bind('click', self.newGameClickHandler)
self._game_info_elem <= self._new_game_btn
self._repeat_game_btn = html.BUTTON(
"Repeat Game", Class="button")
self._repeat_game_btn.bind('click', self.repeatGameClickHandler)
self._game_info_elem <= self._repeat_game_btn
self._messageDiv = self.createMessageDiv()
switch_button = html.BUTTON ('Switch Deck', Class = 'button')
switch_button.bind ('click', switch_card_sources)
self._game_info_elem <= switch_button
self._status_elem = html.SPAN("{status}")
self._game_info2_elem <= self._status_elem
self._status_val = template.Template(self._status_elem)
self.setStatus("Cards placed this round: 0")
self._playSoundsSpan = html.SPAN()
self._game_info2_elem <= self._playSoundsSpan
self._playSoundsLabel = html.LABEL("Play sounds: ")
self._playSoundsSpan <= self._playSoundsLabel
self._playSoundsCheckBox = html.INPUT(
type="checkbox", checked=self._playSounds)
self._playSoundsCheckBox.bind('click', self.togglePlaySounds)
self._playSoundsSpan <= self._playSoundsCheckBox
# A mapping from Card object to CardImg object. This is needed so
# that we map a card in the board layout to the CardImg, which should
# then be placed at a certain location. (We don't keep a reference to
# the CardImg in Card because it just shouldn't know how it is displayed.)
cards = self._deck.getCards()
for card in cards:
cardimg = CardImg(card, self._canv)
self._card2ImgDict[id(card)] = cardimg
self._boardGui = BoardGui(self._board, self._canv, self._card2ImgDict)
self.loadHighScores()
self.initNewGame()
self.hand.sort(key=partial(card_func_key, valueby='rank'))
def card_count(self):
return len(self.hand)
def has_empty_hand(self):
return not self.hand
if __name__ == '__main__':
from card import Deck
"""Reference: Implementing an Unordered List: Linked Lists
http://interactivepython.org/courselib/static/pythonds/BasicDS/ImplementinganUnorderedListLinkedLists.html
"""
deck = Deck()
deck.shuffle()
john = Player('John')
jane = Player('Jane')
jess = Player('Jess')
june = Player('June')
jack = Player('Jack')
player_list = ActivePlayer(john, jane, jess, june)
# player_list.in_control(june)
# player_list.remove(june)
# print(player_list.next_turn())
# print(player_list.next_turn())
# print(player_list.next_turn())
# print(player_list.next_turn())
def test_initializer(self):
deck = Deck()
self.assertEqual(52, len(deck.get_cards()))
def setUp(self):
self.full_deck = Deck()
self.empty_deck = Deck()
while len(self.empty_deck.get_cards()) > 0:
self.empty_deck.remove_random_card()
def __init__(self, name='dealer', cash_balance=100, number_of_decks=1):
self.name = name
self.cash_balance = cash_balance
self.number_of_decks = number_of_decks
self.deck = Deck(self.number_of_decks)
self.hand = Hand()
def deck():
return Deck(PKCard)
def test_have_all_cards(self):
full_deck = Deck()
self.assertTrue(full_deck.have_all_cards())
full_deck.remove_random_card()
self.assertFalse(full_deck.have_all_cards())
def _new(self):
"""Returns the program to its initial state."""
self._deck = Deck()
self._cardImage = None
self._imageLabel["image"] = self._backImage
self._textLabel["text"] = ""
