def __init__(self, limit=1000): """ Here is the algorithm for class construction: 1. Initializes round limit. 2. Creates the Deck and Pile. 3. Creates both Players and places them in a list. 4. Creates the lists holding round and negotiation counts. """ # 1. Initialize round limit self.__limit = limit # 2. Creates the Deck and Pile self.__deck = Deck() self.__pile = Pile() # 3. Creates both Players and places them in a list self.__players = [None, Player(), Player()] # 4. Creates the lists holding round and negotiation counts self.__round_wins = [0, 0, 0]
def __init__(self, deck_size, deck_w_jokers, num_players, start_hand_size, direction): super(SpoonsEnv, self).__init__(deck_size, deck_w_jokers, num_players, start_hand_size, direction) self.trash = Pile() self.pass_pile = Pile() self.end_player = num_players - 1
def setup_game(self): self.pile = Pile() self.board = Board() self.create_players() self.deal() self.set_starting_tile() self.play()
def initGame(mastersound): ''' Initialize a new model of the game: Starts the intro song returns a tuple a deck a list of minidecks a pile a new playscreen ''' deck = Deck() pile = Pile() minidecks = [] mastersound.stop() mastersound.intro() #Initialize a list of slots for i in range(NUMBEROFMINID): minidecks.append(Minideck(deck.draw_cards(CARDSINMINIDECK))) pile.put(deck.draw_card()) return deck, minidecks, pile, PlayScreen()
def testPile(self): ''' Tests the pile class ''' pile = Pile() pile.put('H5') pile.put('H6') self.assertEqual(pile.topCard(), 'H6')
def __init__(self, deck_size, deck_w_jokers, num_players, start_hand_size, direction): super(BartokEnv, self).__init__(deck_size, deck_w_jokers, num_players, start_hand_size, direction) self.center = Pile() self.draw2 = False self.draw2_effect = 0
def __init__(self): """ Constructor: Creates the empty hand """ self.__pile = Pile() self.__hand = Hand()
def __init__(self, game): super(Bartok, self).__init__(game) self.env['center'] = Pile() # Determines if the current player mustDraw2 self.env['mustDraw2'] = False # Keeps track of the number of players who cumulatively Draw 2 self.env['draw2Effect'] = 0
def test(): board = Board.from_config_file('board.cfg') pile = Pile.from_config_file('pile.cfg') players = [ Player('Bot_1', RandomAgent()), Player('Bot_2', RandomAgent()) ] game_count = 10000 starter_winner_count = 0 total_move_count = 0 for i in range(game_count): new_board = copy.deepcopy(board) new_pile = copy.deepcopy(pile) new_players = copy.deepcopy(players) state = State(new_board, new_players, new_pile, False, False) game = Game(state) game.execute_setup() game.play_game() print(f'At game #{i:04}') total_move_count += game.move_count if game.starter == game.winner: starter_winner_count += 1 print(f'Percentage of games won by starter: {starter_winner_count/game_count*100}%') print(f'Average number of total moves in a game: {total_move_count/game_count}')
def __init__(self, players: List[Player], turn=0, trade_pile=None, draw_pile=None, verbose=True, seed=None): self.turn = turn self.players: List[Player] = players if draw_pile is None: draw_pile = DEFAULT_TRADE_PILE.copy() random.shuffle(draw_pile) self.trade_pile: Pile[Card] = Pile('trade_pile', trade_pile or []) self.draw_pile: Pile[Card] = Pile('draw_pile', draw_pile) #self.scrap_pile : Pile[Card] = Pile('scrap', []) if seed: random.seed(seed) self.verbose = verbose
def main(): board = Board.from_config_file('board.cfg') pile = Pile.from_config_file('pile.cfg') players = [ Player('Bot_1', RandomAgent()), Player('Bot_2', RandomAgent()) ] state = State(board, players, pile, True, True) game = Game(state) game.execute_setup() game.play_game()
def new_deck(self): """ Creates and initializes a standard deck of 52 standard playing Cards. """ deck = [] for suit in Suit.SUITS: for rank in range(1,14): deck.append(Card(suit, rank)) self.deck = Pile(deck) self.shuffle_cards() return self.deck
class Destiny: def __init__(self, decks=1, seed=None): self.pile1, self.pile2 = Pile(decks).shuffle(seed).split() def run(self): rounds = 0 while not self.iswon(): self.round([], []) rounds += 1 return rounds def round(self, cards1, cards2): if len(self.pile1) == 0: self.pile1.pushall(cards1 + cards2) return if len(self.pile2) == 0: self.pile2.pushall(cards2 + cards1) return card1, card2 = self.pile1.pop(), self.pile2.pop() cards1.append(card1) cards2.append(card2) if card1 > card2: self.pile1.pushall(cards1 + cards2) return if card2 > card1: self.pile2.pushall(cards2 + cards1) return self.round(cards1, cards2) def iswon(self): return len(self.pile1) == 0 or len(self.pile2) == 0 def __str__(self): return "%s\n\n%s" % (self.pile1, self.pile2)
def __init__(self, limit=1000): """ Initialize round limit Initialize the Deck and Pile Create both Players and place in list Create the lists holding the round and negotiation counts """ # 1. Initialize round limit self.__limit = limit # 2. Initialize the Deck and Pile self.__deck = Deck() self.__pile = Pile() # 3. Create both Players and place in list self.__players = [None, Player(), Player()] # 4. Create the lists holding the round and negotiation counts self.__round_wins = [0, 0, 0]
def __init__(self, name, game, id): self.name = name self.id = id self.actions = 0 self.buys = 0 self.money = 0 self.score = 0 self.potion = 0 self.game = game self.hand = Pile() self.board = Pile() self.deck = Pile() self.durations = Pile() self.drawpile = Pile() self.discardpile = Pile()
def reset(self): self.draw_pile : Pile[Card] = Pile('draw_pile') self.discard_pile : Pile[Card] = Pile('discard_pile', DEFAULT_PLAYER_DRAW) self.health = 50 self.bases : Pile[BaseCard] = Pile('bases', []) self.outposts : Pile[OutpostCard] = Pile('outposts', []) self.need_draw = True # turn data self.hand : Pile[Card] = Pile('hand', []) self.in_play : Pile[Card] = Pile('in_play', []) self.trade = 0 self.discard = 0 self.on_top = 0 self.damage = 0 self.remaining_actions : List[Tuple[Card, Action]] = []
def choose_from_piles(self, action: str, *piles: Pile, min_n=0, max_n=1, ship_only=False, remove_from_pile=True) -> Tuple[Pile, List[Card]]: if ship_only: filtered_piles = [Pile(p.name, filter(lambda c: not isinstance(c, (BaseCard, OutpostCard)), p)) for p in piles] else: filtered_piles = piles filtered_piles = [p for p in filtered_piles if p and len(p) > max(1, min_n)] if not filtered_piles: if min_n > 0: raise UndoMove() return None, None pile, cards = self.do_choose_from_piles(action, filtered_piles, min_n, max_n) actual_pile = None if pile and remove_from_pile: actual_pile = [p for p in piles if p.name == pile.name] assert len(actual_pile) == 1 actual_pile = actual_pile[0] for c in cards: actual_pile.remove(c) return actual_pile, cards
def __init__(self, name, health=50, draw_pile=None, discard_pile=None, bases=None, hand=None, outposts=None, need_draw=True): if draw_pile is None and discard_pile is None: discard_pile = DEFAULT_PLAYER_DRAW self.draw_pile : Pile[Card] = Pile('draw_pile', draw_pile or []) self.discard_pile : Pile[Card] = Pile('discard_pile', discard_pile or []) self.health = health self.name = name self.bases : Pile[BaseCard] = Pile('bases', bases or []) self.outposts : Pile[OutpostCard] = Pile('outposts', outposts or []) self.need_draw = need_draw # turn data self.hand : Pile[Card] = Pile('hand', hand or []) self.in_play : Pile[Card] = Pile('in_play', []) self.trade = 0 self.discard = 0 self.on_top = 0 self.damage = 0 self.remaining_actions : List[Tuple[Card, Action]] = []
def _parse_page(self, page): pile = Pile() pile.parse_layout(page) piles = pile.split_piles() return piles
class Dealer: """ A Dealer shuffles and deals a deck of Cards. He also moves Cards on the Board from Pile to Pile, and draws Cards from the Stock pile to be used in play. """ def __init__(self, draw=3, username='******'): """ Creates a new Dealer by initializing a Board and shuffling and dealing a new deck of Cards. """ self.board = Board() self.deck = self.new_deck() self.player = Player(username) self.num_draw = TYPE_OF_DRAW[self.player.data['draw']] self.history = [] def print_board(self): """ Prints a representation of the Solitaire game in its current state. """ self.board.print_board() def shuffle_cards(self): """Randomly shuffles the deck of Cards.""" random.shuffle(self.deck) def new_deck(self): """ Creates and initializes a standard deck of 52 standard playing Cards. """ deck = [] for suit in Suit.SUITS: for rank in range(1,14): deck.append(Card(suit, rank)) self.deck = Pile(deck) self.shuffle_cards() return self.deck def empty_board(self): """ Collects all the cards on the Board and inserts them into the Dealer's deck. """ waste = self.board.waste stock = self.board.stock while not waste.is_empty(): card = waste.pop() card.flip_down() self.deck.append(card) while not stock.is_empty(): card = stock.pop() card.flip_down() self.deck.append(card) for foundation in self.board.foundations.values(): while not foundation.is_empty(): card = foundation.pop() card.flip_down() self.deck.append(card) for tableau in self.board.tableaux: while not tableau.is_empty(): card = tableau.pop() card.flip_down() self.deck.append(card) self.shuffle_cards() def addHistory(self): """ Adds a copy of the current board state to the history. """ stock, waste, foundations, tableaux = self.board.copy_board() lastBoard = Board() lastBoard.set_piles(stock, waste, foundations, tableaux) historyEntry = {'board': lastBoard, 'score': self.player.current_score} self.history.append(historyEntry) def undo(self): """ Sets the current state of the board to the last entry in the history. Increments the player's number of moves and reverts the player's score. """ if len(self.history) == 0: return False new_state = self.history.pop() self.board = new_state['board'] self.player.current_score = new_state['score'] self.player.current_moves += 1 return True def change_player(self, username): """ Changes this dealer's player. """ self.player.db.unlock_db() self.player = Player(username) self.num_draw = self.player.options['draw'] def player_won(self): """ Checks if the player has won the game, and if they have, returns True. Otherwise, returns False. """ for suit in Suit.SUITS: fpile = self.board.foundations[suit] if not fpile.is_complete(): return False return True def new_game(self, win=False): """ Empties the Cards on the Board and re-deals the Cards for a new game. """ self.empty_board() self.deal() self.player.start_game() self.history = [] self.num_draw = TYPE_OF_DRAW[self.player.data['draw']] def deal(self): """ Deals Cards into the Board's Tableau piles from left to right, and flips the top Card in each pile. The leftmost Tableau pile has one Card, and the number of Cards in the remaining Tableau piles increases from left to right. The remaining 28 Cards are dealt to the Board's Stock pile. """ piles = self.board.tableaux stock = self.board.stock size = len(piles) height = 7 # Push Cards to the Tableau piles for i in range(height): for k in range(i, size): pile = piles[k] c = self.deck.pop() if k == i: c.flip_up() pile.push(c) # Push the remaining Cards to the Stock pile. for card in self.deck: stock.push(card) def handle_move(self, card, srcPile, destPile): """ Handles a move. PROBABLY NOT KEEPING """ if srcPile is None or destPile is None: return if srcPile == self.board.stock: if destPile == self.board.stock: return self.draw() if srcPile == self.board.waste: if destPile == self.board.waste: return destPile.push(card) return destPile.push_card(card) if srcPile in self.board.foundations.values(): if destPile == srcPile or destPile in self.board.tableaux: return destPile.push_card(card) if srcPile in self.board.tableaux: if destPile in self.board.foundations.values(): return destPile.push_card(card) if destPile in self.board.tableaux: pile = Pile([card]) return destPile.push_pile(pile) def update_score(self, srcPile, destPile, flip=False): """ Calculates the score for the move. Standard scoring for Solitaire is as follows: Waste to Tableau: +5 Waste to Foundation: +10 Tableau to Foundation: +10 Turn over Tableau card: +5 Foundation to Tableau: -15 Recycle waste when playing by ones: -100 """ if (srcPile == self.board.waste and destPile in self.board.tableaux): return 5 if ((srcPile == self.board.waste or srcPile in self.board.tableaux) and destPile in self.board.foundations.values()): return 10 if (srcPile in self.board.foundations.values() and destPile in self.board.tableaux): return -15 if (srcPile == self.board.waste and destPile == self.board.waste and self.draw == 1): return -100 return 0 def recycle_waste(self): """ Empties the Waste pile, adding the Cards to the bottom of the Stock pile. Called each time Cards are drawn from Stock. """ waste = self.board.waste stock = self.board.stock self.addHistory() while not waste.is_empty(): self.pop_enqueue_card(waste, stock, True) stock.reverse() waste.squared = 0 def draw(self): """ Draws a certain number of cards from the stock pile, depending on the type of draw. """ waste = self.board.waste stock = self.board.stock self.addHistory() self.player.current_moves += 1 if stock.is_empty(): return self.recycle_waste() for _ in range(self.num_draw): self.pop_push_card(stock, waste, True) waste.squared = max(len(waste) - 3, waste.squared, 0) if len(waste) < 3: waste.squared = 0 def pop_enqueue_card(self, srcPile, destPile, flip=False): """ Pops the topmost Card from srcPile and enqueues it to the bottom of destPile. If flip is True, flips the Card. """ if (srcPile is None or destPile is None or srcPile.is_empty()): return card = srcPile.peek() if card is None: return if srcPile.suitable_card_pop(): srcPile.pop_card() if destPile.suitable_card_enqueue(card): if flip: card.flip() destPile.enqueue_card(card) else: srcPile.push(card) def pop_push(self, card, source, dest): """ Pops a card/pile off the source pile and pushes it onto the destination pile. """ if card == source.peek(): return self.pop_push_card(source, dest) return self.pop_push_pile(card, source, dest) def pop_push_card(self, srcPile, destPile, flip=False): """ Pops the topmost Card from srcPile and pushes it to the top of destPile. If flip is True, flips the Card. """ if (srcPile is None or destPile is None or srcPile.is_empty()): return False card = srcPile.peek() if card is None: return False if srcPile.suitable_card_pop(): srcPile.pop_card() if destPile.suitable_card_push(card): if flip: card.flip() destPile.push_card(card) if srcPile in self.board.tableaux: if (srcPile.peek() is not None and srcPile.peek().is_face_down()): self.player.update_current_score(5) srcPile.flip_top() scoreIncr = self.update_score(srcPile, destPile) self.player.update_current_score(scoreIncr) if srcPile != self.board.stock: self.player.current_moves += 1 return True else: srcPile.push(card) return False return False def pop_push_pile(self, topCard, srcPile, destPile, flip=False): """ Pops a Pile of Cards from srcPile and pushes it to the top of destPile. If flip is True, flips the Card. """ if srcPile is None or destPile is None or topCard is None: return False if srcPile.is_empty(): return False if not srcPile.suitable_pile_pop(topCard): return False if ((srcPile in self.board.tableaux or srcPile == self.board.waste or srcPile == self.board.stock) and srcPile == destPile): return False removed = srcPile.pop_pile(topCard) if removed is None: return False if not destPile.suitable_pile_push(removed): srcPile.extend(removed) return False if flip: removed = [card.flip() for card in removed] if srcPile in self.board.tableaux: if (srcPile.peek() is not None and srcPile.peek().is_face_down()): self.player.update_current_score(5) srcPile.flip_top() destPile.push_pile(removed) scoreIncr = self.update_score(srcPile, destPile) self.player.update_current_score(scoreIncr) if srcPile != self.board.stock: self.player.current_moves += 1 return True def pop_pile(self, bottomCard, srcPile): """ Pops a pile from srcPile beginning with bottomCard. """ if (srcPile is None or bottomCard is None or srcPile.is_empty() or not srcPile.suitable_pile_pop(bottomCard)): return self.addHistory() return srcPile.pop_pile(bottomCard) def undo_pop_pile(self, pile, srcPile): """ Re-pushes the pile popped from srcPile to srcPile if pile couldn't be pushed to destPile during a move. """ if pile is None or srcPile is None: return srcPile.extend(pile) def push_pile(self, pile, srcPile, destPile): """ Pushes pile to destPile if it is legal. Otherwise, undoes the pop and pushes pile back to srcPile. """ if pile is None: return self.undo_pop_pile(pile, srcPile) if pile is not None and srcPile is not None and destPile is None: return self.undo_pop_pile(pile, srcPile) if (srcPile.name == self.board.stock.name and destPile.name == self.board.stock.name): return if ((srcPile in self.board.tableaux or srcPile == self.board.waste) and srcPile.name == destPile.name): return self.undo_pop_pile(pile, srcPile) if not destPile.suitable_pile_push(pile): return self.undo_pop_pile(pile, srcPile) if srcPile in self.board.tableaux: if (srcPile.peek() is not None and srcPile.peek().is_face_down()): self.player.update_current_score(5) srcPile.flip_top() destPile.push_pile(pile) scoreIncr = self.update_score(srcPile, destPile) self.player.update_current_score(scoreIncr) if srcPile != self.board.stock: self.player.current_moves += 1 def to_foundation(self, card, srcPile): """ Sends a card to its appropriate source pile if it's suitable. """ suit = card.suit fpile = self.board.foundations[suit] return self.pop_push_pile(card, srcPile, fpile) def next_move(self): """ Calculates possible moves for the current board configuration. """ vacant_tableau = False king_waiting = False # Check if there are runs starting with a King # in any of the Tableau piles, so that they may be # moved to empty Tableau piles. for tab in self.board.tableaux: if tab.is_empty(): vacant_tableau = True else: for card in tab: if card.is_face_down(): continue if card.rank == Rank.KING: if card == tab.peek(): continue king_waiting = True break # Check if there is a King at the top of the # Waste pile so that it may be moved to an empty # Tableau pile. if not self.board.waste.is_empty(): card = self.board.waste.peek() if card.rank == Rank.KING: king_waiting = True # The next step is to try to move one column to another # column. Non-empty columns (columns which contain face-down # cards) are moved first, because we want to free up # whatever cards may be hidden. for tab in self.board.tableaux: if tab.contains_face_down(): bottom = tab.first_face_up_card() idx = tab.index(bottom) for tab2 in self.board.tableaux: if tab2 == tab: continue if tab2.is_empty(): if bottom.rank == Rank.KING: # Tell the player to move the King in tab # to the empty tab2 print "Move %s from %s to %s" % (str(bottom), tab.name, tab2.name) return else: if tab2.suitable_pile_push(tab[idx:]): print "Move %s from %s to %s" % (str(bottom), tab.name, tab2.name) return # If a Tableau containing face-down cards cannot be moved, try # to move a Tableau pile without face-down cards, but only if # a King is waiting. for tab in self.board.tableaux: if tab.is_empty() or tab.contains_face_down(): continue bottom = tab[0] if bottom.rank == Rank.KING: continue for tab2 in self.board.tableaux: if tab2 == tab or tab2.is_empty(): continue elif tab2.suitable_pile_push(tab): if not vacant_tableau and king_waiting: print "Move %s to %s" % (tab.name, tab2.name) return # If we can't move piles from Tableau to Tableau, # we try moving a card from Waste to a Tableau. if not self.board.waste.is_empty(): top = self.board.waste.peek() # If the top of the Waste pile is a King, move # it to an empty Tableau pile. Otherwise, if it # can go on a nonempty Tableau pile, push it there. for tab in self.board.tableaux: if tab.is_empty(): if top.rank == Rank.KING: print "%i: " % lineno(), "Move %s from %s to %s" % (str(top), self.board.waste.name, tab.name) return else: if tab.suitable_card_push(top): print "Move %s from %s to %s" % (str(top), self.board.waste.name, tab.name) return # If the top of Waste cannot go on any Tableau piles, # try moving it to its Foundation pile. fpile = self.board.foundations[top.suit] if fpile.suitable_card_push(top): print "Move %s from %s to %s" % (str(top), self.board.waste.name, fpile.name) return # Otherwise, try to move the card of the same rank and color # on a Tableau pile to its Foundation pile so the top of Waste # can take its place on the Tableau. for tab in self.board.tableaux: if tab.is_empty(): continue card = tab.peek() fpile2 = self.board.foundations[card.suit] if (card.color == top.color and card.rank == top.rank and fpile2.suitable_card_push(card)): print "Move %s from %s to %s" % (str(card), tab.name, fpile2.name) return # If a Tableau pile contains many cards, try to reduce # its size by moving the top cards to their Foundation # piles. # If a Tableau pile contains only one card, try to move # it to its Foundation pile to free it up for waiting # Kings. If it can't go to a Foundation pile, then try # putting the card of same rank and color on its foundation. for tab in self.board.tableaux: if tab.is_empty(): continue if len(tab) > 1: if king_waiting: card = tab.peek() fpile = self.board.foundations[card.suit] if fpile.suitable_card_push(card): print "Move %s from %s to %s" % (str(card), tab.name, fpile.name) return elif len(tab) == 1: card = tab.peek() fpile = self.board.foundations[card.suit] if fpile.suitable_card_push(card): print "Move %s from %s to %s" % (str(card), tab.name, fpile.name) return else: for tab2 in self.board.tableaux: if tab == tab2 or tab2.is_empty(): continue card2 = tab2.peek() if card.color() == card2.color() and card.rank == card2.rank: fpile2 = self.board.foundations[card2.suit] if fpile2.suitable_card_push(card2): print "Move %s from %s to %s" % (str(card2), tab2.name, fpile2.name) return # Try moving cards in the Tableaux to # their Foundation piles. for tab in self.board.tableaux: if tab.is_empty(): continue card = tab.peek() fpile = self.board.foundations[card.suit] if fpile.suitable_card_push(card): print "Move %s from %s to %s" % (str(card), tab.name, fpile.name) return # Draw from the stock if we couldn't move any cards. if not self.board.stock.is_empty(): print "Draw cards from the Stock pile." return # No moves, give up! print "There are no moves left, try pressing undo or starting a new game!" def can_autocomplete(self): """ Returns true if the Cards in the Piles are ordered such that the game can be auto-completed. """ if not self.board.stock.is_empty(): return False prev_rank = 14 for card in self.board.waste: if card.rank > prev_rank: return False prev_rank = card.rank for tab in self.board.tableaux: if tab.contains_face_down(): return False return True def all_empty(self): """ Returns true if the Waste and Tableaux piles are both empty. """ piles = [] piles.append(self.board.waste) piles.extend(self.board.tableaux) for pile in piles: if not pile.is_empty(): return False return True def autocomplete(self): """ Autocompletes the board as much as possible. """ piles = [] piles.append(self.board.waste) piles.extend(self.board.tableaux) all_empty = self.all_empty() while not all_empty: for pile in piles: if pile.is_empty(): continue card = pile.peek() self.to_foundation(card, pile) all_empty = self.all_empty()
def __init__(self, game): super(Spoons, self).__init__(game) self.initHandCount = 4 self.env['trash'] = Pile()
def __init__(self, deck_size, deck_w_jokers, deck_wo_queens, num_players, start_hand_size, direction): super(OldmaidEnv, self).__init__(deck_size, deck_w_jokers, deck_wo_queens, num_players, start_hand_size, direction) self.trash = Pile() self.pass_pile = Pile()
def __init__(self, deck_size, deck_w_jokers, num_players, start_hand_size, direction): super(SevensEnv, self).__init__(deck_size, deck_w_jokers, num_players, start_hand_size, direction) self.spades_layout = Pile() self.diamonds_layout = Pile() self.clubs_layout = Pile() self.hearts_layout = Pile()
class Game: "The Board State" def start(self): "begin a new game of Dominoes" print("Welcome to Dominoes!", end="\n\n") self.setup_game() def setup_game(self): self.pile = Pile() self.board = Board() self.create_players() self.deal() self.set_starting_tile() self.play() def create_players(self): "creates 2 new players: Athur and Dutch" self.players = [Player('Arthur Morgan'), Player('Dutch')] def deal(self): "deal 7 domninoes to each player, one at a time" for i in range(7): domino_1 = self.pile.take_domino() self.players[0].add_domino(domino_1) domino_2 = self.pile.take_domino() self.players[1].add_domino(domino_2) print('\n') def set_starting_tile(self): "sets the starting tile on the board" domino = self.pile.take_domino() self.board.add_domino(domino) def play(self): "start the game, manages turns and win state" self.game_end = False p = 0 while (not self.game_end): turn_outcome = self.turn(self.players[p]) if turn_outcome == 'next': p = 1 if p == 0 else 0 if turn_outcome == 'blocked': print('Blocked! players cannot continue') dot_count_1 = self.dot_count((self.players[0]).hand) dot_count_2 = self.dot_count((self.players[1]).hand) print((self.players[0]).name + "'s hand count is " + str(dot_count_1)) print((self.players[1]).name + "'s hand count is " + str(dot_count_2)) if (dot_count_1 < dot_count_2): print((self.players[0]).name + ' Wins!') else: print((self.players[1]).name + ' Wins!') self.game_end = True if turn_outcome == 'domino': print('Domino!') print((self.players[p]).name + ' Wins!') self.game_end = True def dot_count(self, hand): "counts the value of a players hand to tally up a score" count = 0 for domino in hand.dominoes.values(): count += domino.value_1 count += domino.value_2 return count def turn(self, player): "a single turn. validates what the turn outcome is " if len(player.hand.dominoes) == 0: return 'domino' if len(self.pile.dominoes) > 0: new_domino = self.pile.take_domino() player.add_domino(new_domino) if self.has_valid_moves(player.hand): domino, position = self.make_move(player) self.place_domino(player, domino, position) else: print(len(self.pile.dominoes), len(player.hand.dominoes)) if len(self.pile.dominoes) == 0: if (not self.has_valid_moves((self.players[0]).hand) and not self.has_valid_moves((self.players[1]).hand)): return 'blocked' else: print("No valid moves, draw again.") self.turn(player) return 'next' def make_move(self, player): "a player move selection pool" valid_moves = self.get_valid_moves(player.hand) move_display = list( map( lambda move: 'PLACE ' + (move["domino"]).show() + ' ' + move["placement"], valid_moves)) move, index = pick(move_display, self.get_selection_heading(player)) player_move = valid_moves[index] return (player_move['domino'], player_move['placement']) def place_domino(self, player, domino, position): "placement of a player's domino onto the board" player.remove_domino(domino.id) self.board.add_domino(domino, position) print(str(player.name) + " places down domino " + str(domino)) def get_selection_heading(self, player): "provide information of the game state while a player makes a move" player_details = str(player.name) + "'s Turn" board = "\nBoard:\n" + str(self.board) hand = "\n\nHand\n" + str(player.hand) title = "\n\nSelect a valid move:\n" return player_details + board + hand + title def has_valid_moves(self, hand): "validates if a player can maka a valid move" return len(self.get_valid_moves(hand)) > 0 def get_valid_moves(self, hand): "returns a players valid moves" first = self.board.dominoes[0] last = self.board.dominoes[-1] moves = [] for domino in hand.dominoes.values(): if (domino.value_1 == first.value_1 or domino.value_2 == first.value_1): moves.append({"domino": domino, "placement": "LEFT"}) if (domino.value_1 == last.value_2 or domino.value_2 == last.value_2): moves.append({"domino": domino, "placement": "RIGHT"}) return moves
def construct_piles_subseqs(self): """ This method handles most of this program's tasks. It creates the Piles of Cards on the table from the Cards dealt from the Deck. It also places the Card in its correct position in the list of SubSequences, linking it to the top Card from the previous Pile. The Algorithm: A. Outer Loop for each Card in the Deck 1. Retrieve the Card from the Deck: card_from_deck 2. Set a flag to indicate if we place the card_from_deck in an existing Pile 3. Inner Loop through each Pile starting from the leftmost Pile - Python list index 0 - to find the correct one on which to place the card_from_deck a. Obtain a reference to the top Card on the current Pile(Stack): See Pile methods b. If there exists a Pile whose top Card is higher than the card_from_deck, then 1. Add the card_from_deck onto the Pile: See Pile methods ii. Set the flag to say we have found a Pile on which to place the card_from_deck iii. Obtain a reference to the top Card on the previous Pile - the one to the left of where you just placed the card_from_deck: (one less index value in Python list): This needs to be a if / else block: if the pile has an index of 0, then prev_card = None else prev_card = top Card on the previous Pile iv. Add the card_from_deck to the list of SubSequences using the add_card_to_subseq method v. Break out of loop 4. Check the flag: If we haven't found a place for the card_from_deck in an existing Pile, then a. Create a new Pile (in Python list of Piles) b. Obtain a reference to the top Card on the previous Pile - the one to the left of where you just placed the card_from_deck: (one less index value in Python list): This needs to be a if / else block: if the pile has an index of 0, then prev_card = None else prev_card = top Card on the previous Pile c. Add the card_from_deck to the list of SubSequences using the add_card_to_subseq method d. Push the card_from_deck onto the Pile e. Add the new pile to the pile list """ for i in range(self.CARDS_IN_DECK): card_from_deck = self.__deck.dequeue() flag = 0 while flag < 5: for t in range(len(self.__piles)): top = self.__piles[t].get_top_card() if top.compare(card_from_deck) == 1: self.__piles[t].add_card(card_from_deck) if len(self.__piles[t - 1]) == 0: prev_card = None else: prev_card = self.__piles[t - 1].get_top_card() self.add_card_to_subseq(card_from_deck, prev_card) flag += 5 break if flag == 0: self.__piles.append(Pile()) if len(self.__piles) <= 1: prev_card = None else: prev_card = self.__piles[len(self.__piles) - 2].get_top_card() self.add_card_to_subseq(card_from_deck, prev_card) self.__piles[len(self.__piles) - 1].push(card_from_deck) flag += 5
def __init__(self, name, id_, max_size=MAX_SIZE): self.name = name self.id = id_ self.hand = Pile() self.knowledge = [] self.points = 0
def _parse_page(self, page): print 'parsing page ' + str(page.pageid) pile = Pile() pile.parse_layout(page) piles = pile.split_piles() return piles
def __init__(self): # create and shuffle deck self.gameDeck = Deck() self.gameDeck.createDeck() self.gameDeck.shuffleDeck() # initialize piles self.handPile = Pile("h", self.gameDeck.cards[:]) self.wastePile = Pile("w", []) self.foundationsPiles = [ Pile("f", []), Pile("f", []), Pile("f", []), Pile("f", []) ] self.tableauPiles = [ Pile("t", []), Pile("t", []), Pile("t", []), Pile("t", []), Pile("t", []), Pile("t", []), Pile("t", []) ]
def _parse_page(self, page): print 'parsing page '+str(page.pageid) pile = Pile() pile.parse_layout(page) piles = pile.split_piles() return piles
def load_piles(self, display_size): display_width, display_height = display_size pile_spacing = 50 start_x = 50 start_y = self.card_size[1] + 100 foundation_x_step = self.card_size[0] + pile_spacing foundation_start_x = display_width - (foundation_x_step * 4) tableau1 = Pile([self.cards[0]], start_x, start_y, self.card_size) tableau2 = Pile(self.cards[1:3], start_x + self.card_size[0] + pile_spacing, start_y, self.card_size) tableau3 = Pile(self.cards[3:6], start_x + self.card_size[0] * 2 + pile_spacing * 2, start_y, self.card_size) tableau4 = Pile(self.cards[6:10], start_x + self.card_size[0] * 3 + pile_spacing * 3, start_y, self.card_size) tableau5 = Pile(self.cards[10:15], start_x + self.card_size[0] * 4 + pile_spacing * 4, start_y, self.card_size) tableau6 = Pile(self.cards[15:21], start_x + self.card_size[0] * 5 + pile_spacing * 5, start_y, self.card_size) tableau7 = Pile(self.cards[21:28], start_x + self.card_size[0] * 6 + pile_spacing * 6, start_y, self.card_size) stock = Pile(self.cards[28:], start_x, pile_spacing, self.card_size, pile_type="stock") waste = Pile([], start_x + self.card_size[0] + pile_spacing, pile_spacing, self.card_size, pile_type="waste") foundation1 = Pile([], foundation_start_x, pile_spacing, self.card_size, pile_type="foundation") foundation2 = Pile([], foundation_start_x + foundation_x_step, pile_spacing, self.card_size, pile_type="foundation") foundation3 = Pile([], foundation_start_x + foundation_x_step * 2, pile_spacing, self.card_size, pile_type="foundation") foundation4 = Pile([], foundation_start_x + foundation_x_step * 3, pile_spacing, self.card_size, pile_type="foundation") self.piles = [ tableau1, tableau2, tableau3, tableau4, tableau5, tableau6, tableau7, stock, waste, foundation1, foundation2, foundation3, foundation4 ]
def __init__(self, decks=1, seed=None): self.pile1, self.pile2 = Pile(decks).shuffle(seed).split()
def construct_piles_subseqs(self): """ This method handles most of this program's tasks. It creates the Piles of Cards on the table from the Cards dealt from the Deck. It also places the Card in its correct position in the list of SubSequences, linking it to the top Card from the previous Pile. The Algorithm: A. Outer Loop for each each Card in the Deck 1. Retrieve the Card from the Deck: card_from_deck 2. Set a flag to indicate if we place the card_from_deck in an existing Pile 3. Inner Loop through each Pile starting from the leftmost Pile - Python list index 0 - to find the correct one on which to place the card_from_deck a. Obtain a reference to the top Card on the current Pile(Stack) using peek b. If there exists a Pile whose top Card is higher than the card_from_deck, then i. Set the flag to say we have found a Pile on which to place the card_from_deck ii. Obtain a reference to the top Card on the previous Pile - the one to the left of where you just placed the card_from_deck: (one less index value in Python list) using peek iii. Add the card_from_deck to the list of SubSequences using the add_card_to_subseq method iv. Push the card_from_deck onto the Pile 4. Check the flag: If we haven't found a place for the card_from_deck in an existing Pile, then a. Create a new Pile (in Python list of Piles (Stacks) b. Obtain a reference to the top Card on the previous Pile - the one to the left of where you just placed the card_from_deck: (one less index value in Python list) using peek - unless this first Card from the Deck, when the number of Piles are zero, using len function. c. Add the card_from_deck to the list of SubSequences using the add_card_to_subseq method d. Push the card_from_deck onto the Pile """ for card in range(self.CARDS_IN_DECK): card_from_deck = self.__deck.deal() flag = False prev_card = None if len(self.__piles) > 0: for i in range(len(self.__piles)): top_card = self.__piles[i].get_top_card() if top_card.compare(card_from_deck) > 0: flag = True if i > 0: prev_card = self.__piles[i - 1].get_top_card() self.add_card_to_subseq(card_from_deck, prev_card) self.__piles[i].add_card(card_from_deck) break if flag is not True: pile = Pile() if len(self.__piles) > 0: prev_card = self.__piles[len(self.__piles) - 1].get_top_card() self.add_card_to_subseq(card_from_deck, prev_card) pile.add_card(card_from_deck) self.__piles.append(pile)
class Game: def __init__(self): # create and shuffle deck self.gameDeck = Deck() self.gameDeck.createDeck() self.gameDeck.shuffleDeck() # initialize piles self.handPile = Pile("h", self.gameDeck.cards[:]) self.wastePile = Pile("w", []) self.foundationsPiles = [ Pile("f", []), Pile("f", []), Pile("f", []), Pile("f", []) ] self.tableauPiles = [ Pile("t", []), Pile("t", []), Pile("t", []), Pile("t", []), Pile("t", []), Pile("t", []), Pile("t", []) ] def displayCards(self): print("=" * 150) print("[h] || " + str(self.handPile)) print("-" * 150) print("[w] || " + str(self.wastePile)) print("-" * 150) for i, foundationsPile in enumerate(self.foundationsPiles): print("[f" + str(i + 1) + "] || ", end="") print(foundationsPile) print("-" * 150) for i, tableauPile in enumerate(self.tableauPiles): print("[t" + str(i + 1) + "] || ", end="") print(tableauPile) print("-" * 150) def gameLoop(self): # insert cards from hand pile into tableau piles for n, tableauPile in enumerate(self.tableauPiles): tableauPile.insertCardFrom(self.handPile, n + 1) keyMap = { "h": self.handPile, "w": self.wastePile, "f1": self.foundationsPiles[0], "f2": self.foundationsPiles[1], "f3": self.foundationsPiles[2], "f4": self.foundationsPiles[3], "t1": self.tableauPiles[0], "t2": self.tableauPiles[1], "t3": self.tableauPiles[2], "t4": self.tableauPiles[3], "t5": self.tableauPiles[4], "t6": self.tableauPiles[5], "t7": self.tableauPiles[6] } while (True): # flip top card in waste pile if (not self.wastePile.isEmpty()): self.wastePile.cards[-1].flip() # flip top card in tableau piles for tableauPile in self.tableauPiles: if (not tableauPile.isEmpty()): tableauPile.cards[-1].flip() self.displayCards() """ # quiting while True: action = input("[continue (c) or quit (q)] || ") if (action == "c" or action == "q"): break """ action = "c" if (action == "c"): # prompt user for input while True: try: fromPile = keyMap[input("[move from] || ")] break except: continue while True: try: toPile = keyMap[input("[move to] || ")] break except: continue if (fromPile.label == "t" and toPile.label == "t"): while True: try: numOfCards = int(input("[# of cards] || ")) break except: continue else: numOfCards = 1 # commit move if (toPile.isValidMove(fromPile, numOfCards)): toPile.insertCardFrom(fromPile, numOfCards) print("--- move executed ---") else: print("--- move failed ---") # if game is won if (len(self.foundationsPiles[0].cards) == 13 and len(self.foundationsPiles[1].cards) == 13 and len(self.foundationsPiles[2].cards) == 13 and len(self.foundationsPiles[3].cards) == 13): self.displayCards() print("--- congratulations, you won! ---") break elif (action == "q"): print("--- exited ---") break
def _init_piles(self) -> [Pile]: ''' Initializes a new list of piles randomly. Used when starting a new game ''' cards = self._generate_random_deck() piles = [] piles.append(Pile('tableau', [cards[0]], number=0)) piles.append(Pile('tableau', cards[1:3], number=1)) piles.append(Pile('tableau', cards[3:6], number=2)) piles.append(Pile('tableau', cards[6:10], number=3)) piles.append(Pile('tableau', cards[10:15], number=4)) piles.append(Pile('tableau', cards[15:21], number=5)) piles.append(Pile('tableau', cards[21:28], number=6)) piles.append(Pile('stock', cards[28:])) piles.append(Pile('waste')) piles.append(Pile('foundation', number=0)) piles.append(Pile('foundation', number=1)) piles.append(Pile('foundation', number=2)) piles.append(Pile('foundation', number=3)) return piles
class Player(object): """This class represents a player that plays the game.""" def __init__(self, name, game, id): self.name = name self.id = id self.actions = 0 self.buys = 0 self.money = 0 self.score = 0 self.potion = 0 self.game = game self.hand = Pile() self.board = Pile() self.deck = Pile() self.durations = Pile() self.drawpile = Pile() self.discardpile = Pile() self.island = Pile() self.nativeVillage = Pile() self.pirateShip = 0 def move_card_to_pile(self, card, target_pile): """Moves a card from the draw pile, the discard pile, or the hand to another target pile""" for p in (self.drawpile, self.discardpile, self.hand): if card in p: p.remove(card) target_pile.add(card) def create_info(self): """Creates an PlayerInfo-Object containing public informations about this player""" return PlayerInfo( self.name, len(self.hand), len(self.drawpile), len(self.discardpile), self.actions, self.buys, self.money, self == self.game.active_player, self.score, self.potion, self.id, ) def can_do_action(self): """Indicates if the player can play an action card""" return self.actions > 0 and len([c for c in self.hand if c.cardtype & ACTION]) > 0 def play_card(self, card_id): """Play the given card""" card = [card for card in self.hand if card.id == card_id] if not card: raise CardNotInHandException("Can't play %s" % card_id) card = card[0] self.hand.remove(card) self.board.add(card) def discard_card(self, card): """Discards the given card from the hand""" if not card in self.hand: raise CardNotInHandException("Can't discard %s" % card) self.hand.remove(card) self.discardpile.add(card) def put_on_drawpile(self, card): if card: self.deck.add(card) self.drawpile.add(card) def trash_card(self, card): """Remove a card from the deck and put it onto the games trashpile""" try: self.game.trash.add(self.deck.remove(card)) except ValueError: pass try: self.game.trash.add(self.board.remove(card)) except ValueError: pass try: self.game.trash.add(self.hand.remove(card)) except ValueError: pass try: self.game.trash.add(self.discardpile.remove(card)) except ValueError: pass try: self.game.trash.add(self.durations.remove(card)) except ValueError: pass def take_card(self, card, to_hand=False, to_deck=False): """Take a card and put in into the discard pile or hand or deck""" self.deck.add(card) if to_hand: self.hand.add(card) elif to_deck: self.drawpile.add(card) else: self.discardpile.add(card) def draw_card(self, just_reveal=False): """Draw a card. If the drawpile is empty, shuffle the discardpile into the drawpile and try again. If the drawpile is still empty, do nothing""" card = None try: card = self.drawpile.take() except PileIsEmptyException: self.discardpile.shuffle_into(self.drawpile) try: card = self.drawpile.take() except PileIsEmptyException: pass if card and not just_reveal: self.hand.add(card) return card
class Broker(): """ This class plays the Buy, Sell, or Negotiate card game. It has a Deck, a Pile and two Players as instance variables. It also contains an instance variable for counting the number of rounds and negotiations and which Player won them. It contains an optional parameter that you can set to stop the play after a certain number of rounds, called limit. """ def __init__(self, limit=1000): """ Here is the algorithm for class construction: 1. Initializes round limit. 2. Creates the Deck and Pile. 3. Creates both Players and places them in a list. 4. Creates the lists holding round and negotiation counts. """ # 1. Initialize round limit self.__limit = limit # 2. Creates the Deck and Pile self.__deck = Deck() self.__pile = Pile() # 3. Creates both Players and places them in a list self.__players = [None, Player(), Player()] # 4. Creates the lists holding round and negotiation counts self.__round_wins = [0, 0, 0] def setup(self): """ Here is the algorithm for game setup: 1. Initializes the Deck. 2. Shuffles the Deck 5 times and displays it. 3. Deals the Cards. 4. Displays the dealt Hands. """ print("=============SETUP===============") # 1. Initializes the Deck print("The new deck:") self.__deck.initialize() # 2. Shuffles the Deck 5 times and displays it for d in range(5): self.__deck.shuffle() print("The shuffled deck:") print(self.__deck) # 3. Deals the cards for c in range(26): for p in range(1, 3): card = self.__deck.deal() player = self.__players[p] player.add_card(card) # 4. Displays the dealt hands print("Original hands:") for p in range(1, 3): player = self.__players[p] print("Player{}:".format(p)) player.display_hand() def play(self): """ Here is the algorithm for playing a game: Loop for each round of play Game ends when someone wins or after round limit 1. Each player plays a Card to the pile Display the first two top Cards on the Pile 2. Call determine_pile_winner to determine the winner Winner is returned as player number (1 or 2) or 0, if cards are equal 3. If Cards are equal, winner is determined through negotiation If Cards are not equal, winner gets pile A. Cards are equal: If both players have at least one Card, Call negotiate to determine winner B. One player does not have enough Cards, use Coin flip to see if he survives 4. Cards are not equal: winning Player adds Pile to Hand 5. Check for game over: meaning a Player has no Cards 6. Increment the number of rounds """ print("=============== PLAY ===============") rounds = 1 game_over = False # Loop for each round of play # Game ends when someone wins or after round limit while not game_over and rounds <= self.__limit: print("\nRound{}: ".format(rounds)) # 1. Each player plays a Card to the pile # Display the first two top Cards on the Pile for p in range(1, 3): player = self.__players[p] player.play_card(self.__pile) p1_card, p2_card = self.__pile.top_two_cards() print("Player1: Card: " + str(p1_card)) print("Player2: Card: " + str(p2_card)) # 2. Call determine_pile_winner to determine the winner # Winner is returned as player number (1 or 2) # or 0, if cards are equal winner = self.determine_pile_winner() print("Winner: Player" + str(winner)) # 3. If Cards are equal, # winner is determined through negotiation # If Cards are not equal, winner gets pile if winner == 0: print("\nLet the NEGOTIATIONs Begin!!!") # A. Cards are equal: # If both players have at least one Card, # Call negotiate to determine winner p1_num_cards = self.__players[1].get_num_cards() p2_num_cards = self.__players[2].get_num_cards() if (p1_num_cards >= 1) and (p2_num_cards >= 1): winner = self.negotiate() print("Winner: Player" + str(winner)) if winner == 0: game_over = self.use_coin_flip_for_neg() else: self.__players[winner].add_pile(self.__pile) # B. One player does not have enough Cards, # use Coin flip to see if he survives else: game_over = self.use_coin_flip_for_neg() # 4. Cards are not equal: winning Player adds Pile to Hand else: self.__players[winner].add_pile(self.__pile) self.__round_wins[0] += 1 self.__round_wins[winner] += 1 # 5. Check for game over: meaning a Player has no Cards if (self.__players[1].get_num_cards() == 0 or self.__players[2].get_num_cards() == 0): game_over = True # 6. Increment the number of rounds rounds += 1 def determine_pile_winner(self): """ Here is the algorithm for determining a pile winner: 1. Retrieve the top two Cards from the Pile 2. Compare the Cards: A. Cards are equal: Return winner = 0 B. Flip Coin to see whether the low Card or the high Card wins the play 1. If the flip is heads, make high card holder the winner 2. If the flip is tails, make low card holder the winner """ # 1. Retrieve the top two Cards from the Pile p1_card, p2_card = self.__pile.top_two_cards() # 2. Compare the Cards: compare_result = p1_card.compare(p2_card) if compare_result == 0: # A. Cards are equal: # Return winner = 0 return 0 else: # B. Flip Coin to see whether the low Card # or the high Card wins the play face = Coin().flip() print("Face: {}".format(face)) # 1. If the flip is heads, make high card holder the winner if face == "Heads": if compare_result > 0: return 1 else: return 2 # 2. If the flip is tails, make low card holder the winner else: if compare_result > 0: return 2 else: return 1 def negotiate(self): """ Here is the algorithm for negotiation: 1. Loop while there is no clear winner (winner == 0) A. Loop for each player to play Cards for the Pile, up to four Cards, as long as both Players have Cards 1. If both Players have Cards: Display the first two top Cards on the Pile 2. Break if a player is out of Cards B. Call determine_pile_winner to find who won the negotiation C. If no clear winner and one player is out of Cards then break 2. Return winner """ # 1. Loop while there is no clear winner (winner == 0) # Clear winner: determine_pile_winner returns 1 or 2 winner = 0 while winner == 0: # A. Loop for each player to play Cards for the Pile, # up to four Cards low_on_cards = False for c in range(4): # 1. If both Players have Cards, # Display the first two top Cards on the Pile if (self.__players[1].get_num_cards() >= 1 and self.__players[2].get_num_cards() >= 1): for p in range(1, 3): player = self.__players[p] player.play_card(self.__pile) p1_card, p2_card = self.__pile.top_two_cards() print("Player1: Card: " + str(p1_card)) print("Player2: Card: " + str(p2_card)) # 2. Break if a player is out of Cards else: low_on_cards = True break # B. Call determine_pile_winner to find who won # the negotiation winner = self.determine_pile_winner() # C. If no clear winner and one player is out of Cards # then break if winner == 0 and low_on_cards: break # 2. Return winner return winner def use_coin_flip_for_neg(self): """ When one of the Players has only one Card and the game is in negotiation: Use a Coin flip to determine who gets the Pile of Cards Here is the algorithm for flipping Coin during negotiation: 1. If the Coin is heads, the Player with the most Cards adds the Pile of Cards to his Hand and wins the game 2. Else the Coin is tails, the Player with the least amount of Cards adds the Pile of Cards to his Hand and the game is continued """ game_over = False print("Using coin flip to settle negotiation") face = Coin().flip() print("Face: " + str(face)) p1_num_cards = self.__players[1].get_num_cards() p2_num_cards = self.__players[2].get_num_cards() # 1. If the Coin is heads, the Player with the most Cards # adds the Pile of Cards to his Hand and wins the game if face == "Heads": game_over = True if p1_num_cards < p2_num_cards: winner = 2 else: winner = 1 self.__players[winner].add_pile(self.__pile) # 2. Else the Coin is tails, the Player with the least # amount of Cards adds the Pile of Cards to his Hand # and the game is continued else: p1_num_cards = self.__players[1].get_num_cards() p2_num_cards = self.__players[2].get_num_cards() if p1_num_cards > p2_num_cards: winner = 2 else: winner = 1 self.__players[winner].add_pile(self.__pile) return game_over def display_results(self): """ Displays the game results, when game is over Here is the algorithm for displaying results at game end 1. The game ends when the round limit is reached, or a player is out of Cards. A. Round limit was reached. The winner is the one with the most Cards. B. A player is out of Cards. The winner is the one with all the Cards. 2. Display Hands, if both players still have Cards. """ print() print("========== Game Over - show results ============") print() print("Number of Rounds:", self.__round_wins[0]) print("Number of Rounds won by Player 1:", self.__round_wins[1]) print("Number of Rounds won by Player 2:", self.__round_wins[2]) # 1. The game ends when the round limit is reached, # or a player is out of Cards p1_num_cards = self.__players[1].get_num_cards() p2_num_cards = self.__players[2].get_num_cards() winner = 0 if self.__round_wins[0] >= self.__limit: # A. Round limit was reached, # The winner is the one with the most Cards print("Round limit of {} rounds reached".format(self.__limit)) if p1_num_cards == p2_num_cards: print("Game is tied") else: if p1_num_cards > p2_num_cards: winner = 1 else: winner = 2 print("Player{} has won the game".format(winner)) else: # B. A player is out of Cards # The winner is the one with all the Cards if p1_num_cards > p2_num_cards: winner = 1 else: winner = 2 print("Player{} has won the game".format(winner)) # 2. Display Hands, if both players still have Cards if winner == 0 or self.__players[winner].get_num_cards() < 52: for p in range(1, 3): print("Player{} Cards:".format(p)) self.__players[p].display_hand() print()
class Player(): """__init__ Default Constructor - Creates a player with the provided name. Also creates the hand and knowledge variables @param name : String - the name of the player @param id : String - a unique player ID in case of overlapping names. In format "name-UNIXtimestamp" """ def __init__(self, name, id_, max_size=MAX_SIZE): self.name = name self.id = id_ self.hand = Pile() self.knowledge = [] self.points = 0 # ------------------------------------------------------------------------------ # Public Methods """ push(card) Push a new card into the player's hand @param card : Card - the card to add to the player's hand @return : boolean - true if push successful, false if max_size """ def push(self, card): if self.getHandSize() < self.max_size: self.hand.push(card) return True else: ERROR.write( "Invalid Push: Inserting into player hand would violate max_size." ) return False """ push_sort(card) Push a new card into the player's hand and sort the hand Postcondition: The player's hand is in sorted order @param card : Card - the card to add to the player's hand @return : boolean - true if successful, false if max_size """ def push_sort(self, card): result = self.push(card) self.hand.sort() return result """ remove(card) Remove the specified card from the player's hand Postcondition: card no longer exists in the player's hand @param card : Card - the card to remove """ def remove(self, card): self.hand.remove(card) """ sort() Sort the player's hand pile """ def sort(self): self.hand.sort() def getID(self): return self.id def getName(self): return self.name def getPoints(self): return self.points def getHandSize(self): return len(self.hand) def getKnowledge(self): return self.knowledge def hand_tostr(self): return str(self.hand) # ------------------------------------------------------------------------------ # Python Methods def __len__(self): return len(self.hand) def __str__(self): return self.name def __repr__(self): return self.id """ __contains__(other) Checks if other (a card Object...) is contained within the pile Precondition: type(other) == Card @param other : Card - the card to check the presence of. """ def __contains__(self, other): if type(other) != type(Card(2, 0)): # confirm other is a Card return False elif other in self.hand: #Check if the card is contained return True else: return False def __iter__(self): return self.hand.__iter__() def __next__(self): return self.hand.__next__() def __eq__(self, other): return self.getID() == other.getID()