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
