def handOutCards(self): temp_players = [] for player in self.players: if player["id"] is not self.dealer_id: if self.deck.size is 0: self.rebuild() hand = pydealer.Stack() card = self.deck.deal() hand.add(card) temp_players.append(pydash.assign({}, player, {"hand": hand})) for player in self.players: if player["id"] is self.dealer_id: if self.deck.size is 0: self.rebuild() hand = pydealer.Stack() card = self.deck.deal() hand.add(card) temp_players.append(pydash.assign({}, player, {"hand": hand})) self.players = temp_players
def main(): # Construct Deck instance, with 52 cards. deck = new_deck() hand = pydealer.Stack() hand.add(deck.deal(2)) hand.sort() table = pydealer.Stack() table.add(deck.deal(3)) table.sort() cards = hand+table print('Hand: \n{}'.format(hand)) print('Table: \n{}'.format(table)) print(count_suits(cards)) print('Flush: {}'.format(flush(cards))) print('Flush Draw: {}'.format(flush_draw(cards))) print('Straight: {}'.format(straight(cards))) print('Straight Flush: {}'.format(straight_flush(cards))) print('Open-Ended Straight Draw: {}'.format(oesd(cards))) print('Gut-Shot Hole Draw: {}'.format(hole_draw(cards))) print('Pairs: {}'.format(pairs(cards))) print('Sets: {}'.format(sets(cards))) print('Fours: {}'.format(fours(cards))) print('Full House: {}'.format(full_house(cards))) print('High Card: {}'.format(high_card(cards))) print('Rank: {}'.format(rank_hand(cards)))
def two_player_setup(self): player_1 = pydealer.Stack() player_1.add(self.deck.deal(26)) player_2 = pydealer.Stack() player_2.add(self.deck.deal(26)) player_list = [player_1, player_2] player_names_list = ['Player 1', 'Player 2'] return player_list, player_names_list
def __init__(self, name, color): self.name = name self.hand = pydealer.Stack() self.color = color self.victory_cards = pydealer.Stack() self.down_cards = pydealer.Stack() self.formatted_name = f"{self.color}{self.name}{BColors.END_COLOR}" self.down = False
def __init__(self, player_id, initial_cards=None): self.hand = pydealer.Stack() self.pile = pydealer.Stack() self.card_count = CardCount() if initial_cards: self.hand += initial_cards for card in initial_cards: self.card_count.add_card(card) self.name = "player{}".format(player_id)
def __init__(self, squares=[]): if len(squares) == 0: self.squares = [None for i in range(50)] else: self.squares = squares self.player = 'B' self.deck = pydealer.Deck() self.deck.shuffle() self.p1_hand = pydealer.Stack() self.p2_hand = pydealer.Stack() self.deal_cards()
def four_player_setup(self): player_1 = pydealer.Stack() player_1.add(self.deck.deal(13)) player_2 = pydealer.Stack() player_2.add(self.deck.deal(13)) player_3 = pydealer.Stack() player_3.add(self.deck.deal(13)) player_4 = pydealer.Stack() player_4.add(self.deck.deal(13)) player_list = [player_1, player_2, player_3, player_4] player_names_list = ['Player 1', 'Player 2', 'Player 3', 'Player 4'] return player_list, player_names_list
def return_cards_to_deck(group_tele_id): session = scoped_session(session_factory) s = session() game, player = s.query(Game, Player). \ filter(Game.group_tele_id == group_tele_id, Player.group_tele_id == group_tele_id, Player.player_id == Game.curr_player).first() curr_cards = game.curr_cards player_cards = pydealer.Stack(cards=player.cards) player_cards.add(curr_cards) game.curr_cards = pydealer.Stack() player.cards = player_cards s.commit() session.remove()
def meld(self, player_i, sets=[], runs=[]): """Place down the cards for this round Player at index player_i places down the cards, if meld is correct for the current round Args: player_i (int): the index of the player sets (list<list<int>>): list of sets, each set containing the card indices for the set runs (list<list<int>>): list of runs, each run containing the card indices for the run Prerequisites: - Must be this players turn - Must have proper number of sets and runs for round - All cards must be valid and not duplicates - Each set and each run must be correct """ self.raise_if_out_of_turn(player_i) # Flatten sets and runs to get one list of all card indices all_sets = [item for sublist in sets for item in sublist] all_runs = [item for sublist in runs for item in sublist] all_cards = all_sets + all_runs self.raise_if_duplicates(all_cards) spec = self.ROUNDS[self.round] cur_hand = self.players[player_i].hand self.raise_if_bad_sets(cur_hand, sets, spec['sets']) self.raise_if_bad_runs(cur_hand, runs, spec['runs']) # Assumes correct sets and runs # Add sets to meld set_meld = self.players[player_i].set_meld for s in sets: cards = pydealer.Stack() for i in s: cards.add(cur_hand.get(i)) set_meld.append(cards) # Add runs to meld run_meld = self.players[player_i].run_meld for r in runs: cards = pydealer.Stack() for i in r: cards.add(cur_hand.get(i)) run_meld.append(cards)
def get_all_cards_as_stack(self): stack = pydealer.Stack() for x in self.cards.values(): stack += [x] for x in self.bonus_cards: stack += [x] return stack
def test_eq(self): """""" other_stack = pydealer.Stack(cards=pydealer.tools.build_cards()) result = self.full_stack == other_stack self.assertTrue(result)
def run_game(): deck = pydealer.Deck() hand = pydealer.Stack() cards = deck.get_list([ '10 of Spades', 'Jack of Spades', 'Queen of Spades', 'King of Spades' ]) players = create_player_set(3) game = KuhnGame(players, cards, 1) root = game.create_root_node() #random.seed(1) #chance_sampling_cfr = ChanceSamplingCFR(root, players) #chance_sampling_cfr.run(iterations=1000) #chance_sampling_cfr.compute_nash_equilibrium() # read Nash-Equilibrum via chance_sampling_cfr.nash_equilibrium member # try chance_sampling_cfr.value_of_the_game() function to get value of the game (-1/18) #print(chance_sampling_cfr.value_of_the_game()) # vanilla cfr vanilla_cfr = VanillaCFR(root, players) for i in tqdm(range(10)): vanilla_cfr.run(iterations=100) vanilla_cfr.compute_nash_equilibrium()
def setUp(self): """""" self.ace_spades = pydealer.Card("Ace", "Spades") self.two_diamonds = pydealer.Card("2", "Diamonds") self.queen_hearts = pydealer.Card("Queen", "Hearts") self.seven_clubs = pydealer.Card("7", "Clubs") self.cards = [ self.ace_spades, self.two_diamonds, self.queen_hearts, self.seven_clubs ] self.names = [ "Ace of Spades", "2 of Diamonds", "Queen of Hearts", "7 of Clubs" ] self.stack = pydealer.Stack() self.full_stack = pydealer.Stack(cards=pydealer.tools.build_cards()) self.small_stack = pydealer.Stack(cards=self.cards)
def __init__(self, name): self.hand = pydealer.Stack() self.set_meld = [] self.run_meld = [] self.name = name self.beg_count = 0 self.score = 0
def getPlayers(self, number_of_players): player = {"hand": pydealer.Stack(), "chips": self.initial_chips} for id in range(1, number_of_players + 1): self.players.append(pydash.assign({}, player, {"id": id})) self.stats[id] = {"dealer_wins": 0, "dealer_losses": 0}
def __init__(self, players): # Number of Players: at least three and up to six if len(players) not in range(3, 7): raise ValueError( 'Game must be played with 3 to 6 players, not {}'.format( len(players))) # Initalize the state self.players = players # Zero based round number self.round = 0 # Create an empty discard pile self.discard_pile = pydealer.Stack() # Choose a random dealer self.dealer = random.randrange(len(players)) # Set the current player to the left of the dealer self.current_player = self.dealer self.increment_player() # Index of the begging player (-1 is none) self.beggar = -1 # Initialize the deck with the proper number of decks self.deck = self.get_new_deck(self.get_num_decks())
class CardDeck: deck = pd.Deck(rebuild=True, re_shuffle=True) deck.shuffle() # Define a new rank dictionary new_ranks = { "values": { "Ace": 1, "King": 10, "Queen": 10, "Jack": 10, "10": 10, "9": 9, "8": 8, "7": 7, "6": 6, "5": 5, "4": 4, "3": 3, "2": 2, } } # Create a discard pile discardPile = pd.Stack() # Add cards to discard pile def addToDiscard(self, cards): self.discardPile.add(cards)
def roll_new_round(player_hand, player_charactersheet, posse_deck, posse_discard, message_log): quickness_roll = skill_roll(player_charactersheet.quickness.traitDie, player_charactersheet.quickness.levelDice) message_log.add_message(Message('Beginning of new round. Rolling quickness...')) bust = quickness_roll.get('bust') failure = quickness_roll.get('failure') success = quickness_roll.get('success') if not bust: handsize = 1 if success: message_log.add_message(Message("You succeeded in quickly getting multiple action cards this round!", tcod.green)) handsize += success if handsize > 5: handsize = 5 else: message_log.add_message(Message("You failed to get more than the default single action card this round.")) newhand = pydealer.Stack() for i in range(handsize): if posse_deck.size == 0: message_log.add_message(Message("Reshuffling!", tcod.gray)) posse_deck.add(posse_discard.deal(posse_discard.size)) posse_deck.shuffle() newcard = posse_deck.deal(1) newhand.add(newcard) player_hand.add(newhand) player_hand.sort() else: message_log.add_message(Message("You went bust, no new cards this round!", tcod.red))
def __createNewTreeNode(self, parent, play, playerMove=False, playerHand=None): # copy current gamestate gameBoard = copy.deepcopy(parent.gameBoard) hand = playerHand if not playerMove: hand = copy.deepcopy(parent.aiHand) cardsPlayed = copy.deepcopy(parent.cardsPlayed) # Change gamestate to reflect the play stack = pydealer.Stack() self.playCard(play, gameBoard, hand, cardsPlayed, stack, playerMove=playerMove) if playerMove: hand = copy.deepcopy(parent.aiHand) # create new node for this play return TreeNode(gameBoard, hand, cardsPlayed, play, parent)
def setup_game(group_tele_id): session = scoped_session(session_factory) s = session() player_tele_ids = s.query(Player.player_tele_id).filter(Player.group_tele_id == group_tele_id).all() random.shuffle(player_tele_ids) # Creates a deck of cards in random order deck = pydealer.Deck(ranks=pydealer.BIG2_RANKS) deck.shuffle() # Sets up players curr_player = -1 for i, player_tele_id in enumerate(player_tele_ids): player_cards = pydealer.Stack(cards=deck.deal(13)) player_cards.sort(ranks=pydealer.BIG2_RANKS) # Player with ♦3 starts first if player_cards.find("3D"): curr_player = i player = s.query(Player).filter(Player.player_tele_id == player_tele_id).first() player.player_id = i player.cards = player_cards s.commit() game = s.query(Game).filter(Game.group_tele_id == group_tele_id).first() game.curr_player = game.biggest_player = curr_player s.commit() session.remove()
def __init__(self, card_map=None, handPL=None, handAI=None, pastcard=None, roundwaste=None, winner=None, adaptor=None, scorePL=None, scoreAI=None, pastwin=None): ''' Initial the class ''' self.card_map = card_map self.handPL = handPL self.handAI = handAI self.pastcard = pastcard if roundwaste is None: self.roundwaste = pdl.Stack() self.winner = winner self.adaptor = adaptor self.scorePL = scorePL self.scoreAI = scoreAI self.pastwin = pastwin
def pass_round(bot, job): group_tele_id, player_tele_id, message_id = map(int, job.context.split(",")) install_lang(player_tele_id) try: bot.editMessageText(text=_("You Passed"), chat_id=player_tele_id, message_id=message_id) except: return session = scoped_session(session_factory) s = session() game = s.query(Game).filter(Game.group_tele_id == group_tele_id).first() if game.count_pass + 1 > 4: session.remove() stop_idle_game(bot, group_tele_id) return return_cards_to_deck(group_tele_id) game = s.query(Game).filter(Game.group_tele_id == group_tele_id).first() game.game_round += 1 game.curr_player = (game.curr_player + 1) % 4 game.count_pass += 1 if game.game_round > 1 and game.curr_player == game.biggest_player: game.prev_cards = pydealer.Stack() s.commit() session.remove() game_message(bot, group_tele_id) player_message(bot, group_tele_id, job.job_queue)
def retrace(): global data_comp data_comp = rd.random deck2 = pydealer.Deck() #picks random deck start point and begins comparison of secondary data print("deck made") deck2.shuffle() print("shuffled") play12 = pydealer.Stack() play22 = pydealer.Stack() comp12 = pydealer.Stack() comp22 = pydealer.Stack() hold2 = pydealer.Stack() #buffer hold states for transfer initialized and stored here play12 = deck.deal(26) play22 = deck.deal(26) #end buffer operations and return cards that were not compared to each hand return data_comp
def new_deck(self): shoe = pydealer.Stack() for i in range(self.shoe_size): shoe.add(pydealer.Deck()) shoe.shuffle() return shoe
def main(): bj = game.Game(dev_mode=True) # output file sys.stdout = open("game_test.txt", "w") # initial betting amount bet_amount = 1 # traverse card values for making the player's first card for i in card_values: # traverse card values for making the player's second card for j in card_values: # traverse card values for dealer upcard for k in card_values: # deck used during gameplay deck = pydealer.Deck() deck.shuffle() # assemble player hand hand = pydealer.Stack(cards=[ deck.get(i + " of Hearts")[0], deck.get(j + " of Spades")[0] ]) dealer_hand = pydealer.Stack( cards=[deck.get(k + " of Diamonds")[0]]) print("\n\n-----------[ New Game ]-----------\n\n") # play game with the hand game_dict = bj.game_result(bet=bet_amount, player_hand=hand, dealer_hand=dealer_hand, deck=deck) print("\nPlayer Result After ${} Initial Bet: ${}\n".format( bet_amount, game_dict["result"])) print(game_dict) sys.stdout.close()
def pregame_setup(self): self.deck.shuffle() self.player_list = self.deal_cards() self.winner_stack = pydealer.Stack() self.player_list = self.assign_ai(self.player_list, self.number_of_players, self.number_of_humans) self.dealer = self.pick_random_dealer() self.state_dict = self.update_dealer(self.state_dict, self.dealer) self.create_dealer_list()
def add_use_card(bot, group_tele_id, message_id, card_abbrev, job_queue): session = scoped_session(session_factory) s = session() game, player = s.query(Game, Player). \ filter(Game.group_tele_id == group_tele_id, Player.group_tele_id == group_tele_id, Player.player_id == Game.curr_player).first() curr_cards = pydealer.Stack(cards=game.curr_cards) player_cards = pydealer.Stack(cards=player.cards) cards = player_cards.get(card_abbrev) if cards: curr_cards.add(cards[0]) game.curr_cards, player.cards = curr_cards, player_cards s.commit() session.remove() player_message(bot, group_tele_id, job_queue, is_edit=True, message_id=message_id) else: session.remove()
def DealCards(self,deck,numOfPlayers): # Just splits deck to deal, as cards are shuffled. Visual can deal one at a time. if numOfPlayers not in (2,4): raise Exception('numOfPlayers must be 2 or 4') if numOfPlayers == 2: Player1 = pydealer.Stack() Player1.add(deck.deal(26)) Player2 = pydealer.Stack() Player2.add(deck.deal(26)) playerList = [Player1,Player2] playerNamesList = ['Player 1','Player 2'] playerNum = 0 for player,nameString in zip(playerList,playerNamesList): player.name = nameString player.eliminated = False player.index = playerNum playerNum += 1 elif numOfPlayers == 4: Player1 = pydealer.Stack() Player1.add(deck.deal(13)) Player2 = pydealer.Stack() Player2.add(deck.deal(13)) Player3 = pydealer.Stack() Player3.add(deck.deal(13)) Player4 = pydealer.Stack() Player4.add(deck.deal(13)) playerList = [Player1,Player2,Player3,Player4] playerNames = ['Player 1','Player 2','Player 3','Player 4'] playerNum = 0 for player,nameString in zip(playerList,playerNames): player.name = nameString player.eliminated = False player.index = playerNum playerNum += 1 return playerList
def start_game(bot, update, job_queue): group_tele_id = update.message.chat.id player_name = update.message.from_user.first_name install_lang(update.message.from_user.id) if update.message.chat.type not in (Chat.GROUP, Chat.SUPERGROUP): bot.send_message(group_tele_id, _("You can only use this command in a group")) return if not can_msg_player(bot, update): return session = scoped_session(session_factory) s = session() if s.query(Game).filter(Game.group_tele_id == group_tele_id).first(): session.remove() bot.send_message(update.message.from_user.id, _("A game has already been started")) return try: game = Game(group_tele_id=group_tele_id, game_round=1, curr_player=-1, biggest_player=-1, count_pass=0, curr_cards=pydealer.Stack(), prev_cards=pydealer.Stack()) s.add(game) s.commit() session.remove() except: s.rollback() session.remove() return install_lang(group_tele_id) text = _("[%s] has started Big Two. Type /join to join the game\n\n") % player_name bot.send_message(chat_id=group_tele_id, text=text, disable_notification=True) make_group_setting(group_tele_id) join(bot, update, job_queue)
def Round(deck, handPL, handAI, scorePL, scoreAI, pastwin, waste): ''' Round function is used to operate one round of game. It includes deciding card playing order, score calculation, winner decision, card supply and waste stack collection. ''' pastcard = 0 score = 0 roundwaste = pdl.Stack() winner = 0 adaptor = 0 if pastwin == "PL": handPL, pastcard, roundwaste, winner, adaptor = Human( handPL, pastcard, roundwaste, winner, adaptor) else: handAI, pastcard, roundwaste, winner, adaptor = GreedyAI( handAI, pastcard, roundwaste, winner, adaptor) while winner == 0: if adaptor == "PL": handPL, pastcard, roundwaste, winner, adaptor = Human( handPL, pastcard, roundwaste, winner, adaptor) else: handAI, pastcard, roundwaste, winner, adaptor = GreedyAI( handAI, pastcard, roundwaste, winner, adaptor) print('Winner of this turn is:', winner) pastwin = winner for i in roundwaste: if i.value == '5': score += 5 elif i.value == '10' or i.value == 'King': score += 10 if winner == 'PL': scorePL += score else: scoreAI += score waste += roundwaste PLneed = 5 - len(handPL) AIneed = 5 - len(handAI) if pastwin == 'PL': handPL += deck.deal(PLneed) handPL.sort() else: handAI += deck.deal(AIneed) handAI.sort() print('This turn score is:', score) print('Current score of player is:', scorePL) print('Current score of AI is:', scoreAI) return deck, handPL, handAI, scorePL, scoreAI, pastwin, waste