def declare_action(self, valid_actions, hole_card, round_state):
choice = self.__choice_action(valid_actions)
action = choice["action"]
amount = choice["amount"]
if action == "raise":
amountToRaise = 40
amount = amountToRaise #rand.randrange(amount["min"], max(amount["min"], amount["max"]) + 1)
opponentAgressivnessScore = opponentAgressivness(self)
opponentAgressivnessScoreLast7Round = opponentAgressivness(self, 2)
card1InString, card2InString = hole_card[0], hole_card[1]
cardObject1 = cardToCardObject(card1InString)
cardObject2 = cardToCardObject(card2InString)
pot, levelOfBetting, cardsOnBoard, roundCount, isOnSmallblind, isOnBigBlind, smallBlindAmount, bigBlindAmount, stackOfPlayer, stackOfOpponent = extractInfoFromState(self.uuid, round_state)
cardsOnBoardObjects = getBoardToCardsObject(cardsOnBoard)
allCardsObjectOnBoard = cardsOnBoardObjects[:2 + levelOfBetting - 1]
evaluator = Evaluator()
if len(cardsOnBoardObjects) > 0: # if there is any card on board - so after flop every case
handStrengthLibrary = evaluate(evaluator, allCardsObjectOnBoard, cardObject1, cardObject2)
else: # preFLop
handStrengthLibrary = 0
sklanskyClass = getSklanskyClass(card1InString, card2InString)
cards = getAllCards()
cards.remove(cardObject1)
cards.remove(cardObject2)
for boardCard in cardsOnBoardObjects:
cards.remove(boardCard)
evaluator = Evaluator()
if len(cardsOnBoardObjects) > 0:
HS = handStrength(cardsOnBoardObjects, cardObject1, cardObject2, cards, evaluator)
else:
HS = 0
EHS, PPOT, NPOT = 0,0,0
# if len(cardsOnBoardObjects) > 0: # if there is any card on board - so after flop every case
# EHS, HS, PPOT, NPOT = effectiveHandStrength(cardsOnBoardObjects, handStrength, cardObject1, cardObject2)
# else:
# EHS, HS, PPOT, NPOT = 0, 0, 0, 0
# handle -BigBlind and smallBlind
if levelOfBetting == 1 and action != "fold":
if isOnSmallblind:
realAmountToPlay = amount - smallBlindAmount
elif isOnBigBlind:
realAmountToPlay = amount - bigBlindAmount
else: # no blind
realAmountToPlay = amount
else:
realAmountToPlay = amount
addRowToHistory(self.historyDF,
[self.hashOfGame, self.uuid, hole_card[0], hole_card[1], action, realAmountToPlay, pot,
levelOfBetting, cardsOnBoard, roundCount, isOnSmallblind, isOnBigBlind
, smallBlindAmount, bigBlindAmount, stackOfPlayer, stackOfOpponent,
sklanskyClass, EHS, HS, PPOT, NPOT, handStrengthLibrary, opponentAgressivnessScore,
opponentAgressivnessScoreLast7Round])
return action, amount
def is_winner(self):
# This function return 1 if the player wins, 0 if it is a draw, and -1 if the opponent wins.
try:
player_hand_str = Evaluator().evaluate(self.flop_cards,
self.player_cards)
opponent_hand_str = Evaluator().evaluate(self.flop_cards,
self.opponent_cards)
except TypeError, e:
print(
'ERROR: Something went wrong. Make sure that all required cards are defined.'
)
def run(number):
"""
This function generates a population sample with size sample.
It also computes probabilities for each hand, considering a
frequentist approach.
Arguments:
- number (int): run ID
Returns:
- stats (str): returns a JSON formatted string containing
probabilities for each poker hand
"""
print 'starting run #{0}'.format(number)
evaluator = Evaluator()
poker_hands = defaultdict(int)
for _ in range(SAMPLE_SIZE):
deck = Deck()
p1_hand = deck.draw(5)
p1_score = evaluator.evaluate(p1_hand, [])
if p1_score == 1: # just a little hack
poker_hands['Royal Flush'] += 1
else:
p1_class = evaluator.get_rank_class(p1_score)
poker_hands[evaluator.class_to_string(p1_class)] += 1
stats = dict((k, round(float(v)/SAMPLE_SIZE, 7))
for k, v in poker_hands.items())
return json.dumps(stats)
def estimate_proba(hand, board, n_player, n_simul=1000):
evaluator = Evaluator()
to_draw = 5 - len(board)
deck = set_deck(hand, board)
winnings = []
for _ in range(n_simul):
deck2 = deepcopy(deck)
shuffle(deck2.cards)
if to_draw == 1:
board2 = board + [deck2.draw(to_draw)]
else:
board2 = board + deck2.draw(to_draw)
if n_player > 2:
other_hands = list(
zip(deck2.draw(n_player - 1), deck2.draw(n_player - 1)))
score_others = min([
evaluator.evaluate(list(hand2), board2)
for hand2 in other_hands
])
elif n_player == 2:
other_hand = deck2.draw(2)
score_others = evaluator.evaluate(other_hand, board2)
score_player = evaluator.evaluate(hand, board2)
winnings += [score_player < score_others]
return mean(winnings)
def is_good(board_cards=[], hand_cards=['AH', 'KD']):
if (len(board_cards) + len(hand_cards) == 0):
return False
board = []
for x in board_cards:
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
board.append(c)
hand = []
for x in hand_cards:
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
hand.append(c)
evaluator = Evaluator()
deck = Deck()
random_cards = deck.draw(5 - len(board) - len(hand))
score = evaluator.evaluate(board + random_cards, hand)
rank_class = evaluator.get_rank_class(score)
print_cards(board + random_cards + hand, rank_class)
if (rank_class < 9):
return True
return False
def __finalize_game(self):
"""
Giving all the money to the player with the best hand
(Nothing to adapt here)
:return:
"""
evaluator = Evaluator()
hand_strength = np.array(
[evaluator.evaluate(hand, self.board) for hand in self.hands])
if any(~(self.all_ins | self.ins)):
hand_strength[~(self.all_ins | self.ins)] = np.nan
if any(self.all_ins | self.ins):
winner = np.nanargmin(hand_strength)
# computing how much money the winner is getting from the others
money_transfer = np.min(
[self.bets, [self.bets[winner]] * self.n_players], axis=0)
self.money[winner] += np.sum(money_transfer)
self.bets = self.bets - money_transfer
# redistributing what hasn't been won to the players
self.money += self.bets
self.bets *= 0
def __init__(self):
self.emulateCount = 1000
self.maxRank = 7462
self.evaluator = Evaluator()
self.color = {'SPADES': 0, 'HEARTS': 1, 'CLUBS': 2, 'DIAMONDS': 3}
self.rColor = ['♠', '♥', '♣', '♦']
self.eColor = ['s', 'h', 'c', 'd']
self.rPoint = [
'2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A'
]
self.ePoint = self.rPoint
self.type = {
'HIGH_CARD': 0,
'ONE_PAIR': 1,
'TWO_PAIR': 2,
'THREE_OF_A_KIND': 3,
'STRAIGHT': 4,
'FLUSH': 5,
'FULL_HOUSE': 6,
'FOUR_OF_A_KIND': 7,
'STRAIGHT_FLUSH': 8
}
self.entries = {
'HIGH_CARD': self.__is_high_card,
'ONE_PAIR': self.__is_one_pair,
'TWO_PAIR': self.__is_two_pair,
'THREE_OF_A_KIND': self.__is_three_of_a_kind,
'STRAIGHT': self.__is_straight,
'FLUSH': self.__is_flush,
'FULL_HOUSE': self.__is_full_house,
'FOUR_OF_A_KIND': self.__is_four_of_a_kind,
'STRAIGHT_FLUSH': self.__is_straight_flush
}
def __init__(self,
bots,
initial_credits=2000,
num_decks=1,
small_blind_amount=1,
seed=None):
self.players = []
self.credits = {}
self.id = {}
self.deck = Deck()
self.evaluator = Evaluator()
# big blind amount is 2x small_blind_amount
self.small_blind_amount = small_blind_amount
# initialize randomness
if seed is None:
random.seed() # seed with, hopefully, /dev/urandom
seed = random.randint(0, 2**32)
self.output("random seed: %d" % seed)
random.seed(seed)
for id, bot in enumerate(bots):
bot_instance = bot(id=id,
credits=initial_credits,
small_blind_amount=self.small_blind_amount,
big_blind_amount=self.big_blind_amount)
self.players.append(bot_instance)
self.id[bot_instance] = id
self.credits[bot_instance] = initial_credits
bot_instance.credits_table = self.credits
self.active_players = copy.copy(self.players)
def build_dataframe(nb_hands=100, nb_players=2):
decks = [Deck() for _ in range(nb_hands)]
df_board = pd.DataFrame({'board': [deck.draw(5) for deck in decks]})
df_players = pd.concat([
pd.DataFrame({'player': [deck.draw(2) for deck in decks]})
for _ in range(nb_players)
],
axis=1,
keys=range(nb_players))
df_players = df_players.swaplevel(0, 1, axis=1)
evaluator = Evaluator()
df_scores = pd.concat([
df_board.join(df_players.xs(i, level=1, axis=1)).apply(
lambda x: evaluator.evaluate(x['board'], x['player']),
axis=1).to_frame('score')
for i in df_players.columns.get_level_values(1)
],
axis=1,
keys=df_players.columns.get_level_values(1))
df_scores = df_scores.swaplevel(0, 1, axis=1)
return df_board, df_players, df_scores
def __init__(self):
# All possible card ranks (0-12 inclusive)
# + 13 - used for board cards when they have not been dealt
# all_card_rank_values = np.array([x for x in range(14)]).reshape(14, 1)
# All possible suit values (0 - 4 inclusive)
# + 9 - used for board cards when they have not been dealt
all_card_suit_values = np.array([1, 2, 4, 8, 9]).reshape(5, 1)
self.rank_enc = OneHotEncoder(handle_unknown='error',
categories='auto')
self.rank_enc.fit(all_card_rank_values)
self.suit_enc = OneHotEncoder(handle_unknown='error',
categories='auto')
self.suit_enc.fit(all_card_suit_values)
# Put in dummy variables for undealt cards
self.table_card_ranks = [0 for x in range(5)]
self.table_card_suits = [0 for x in range(5)]
self.evaluator = Evaluator()
self.min_max_scaling = lambda a, b, min_x, max_x, x: a + (
(x - min_x) * (b - a)) / (max_x - min_x)
self.preflop_suited_array = np.loadtxt(
"./preflop_odds/suited_pair_scores.csv", delimiter=',')
self.preflop_unsuited_array = np.loadtxt(
"./preflop_odds/unsuited_pair_scores.csv", delimiter=',')
self.normalise_preflop_arrays()
def get_score(hand_cards, board_cards):
board = []
for x in board_cards:
x = x.encode('ascii', 'ignore')
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
board.append(c)
hand = []
for x in hand_cards:
x = x.encode('ascii', 'ignore')
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
hand.append(c)
score_min = 9999999
if (len(hand) + len(board) <= 5):
return score_min
else:
for board_five_match in combinations(board, 5 - len(hand)):
evaluator = Evaluator()
score = evaluator.evaluate(tuple(board_five_match), tuple(hand))
if (score < score_min):
score_min = score
return score_min
def __init__(self, preflop_tight_loose_threshold, aggresive_passive_threshold, bet_tolerance): self.preflop_tight_loose_threshold = preflop_tight_loose_threshold self.aggresive_passive_threshold = aggresive_passive_threshold self.bet_tolerance = bet_tolerance # deuces self.evaluator = Evaluator() self.deck = Deck()
def __init__(self, cards, board, evaluator=None):
"""Initialize new poker hand from a card array and an evaluator."""
assert len(cards) == 2
assert len(board) in [3, 4, 5]
# checking there are 5, 6 or 7 unique cards
cardset = set(list(cards) + list(board))
assert len(cardset) == len(cards) + len(board)
if isinstance(cards[0], str):
self._cards = [Card.new(card_str) for card_str in cards]
else:
self._cards = list(cards)
self._cards = sorted(self._cards)
#TODO allow for Flop object to be passed
self._board = Flop(board)
if evaluator:
self.ev = evaluator
else:
ev = Evaluator()
self.ev = ev
self.rank = self.ev.evaluate(self._cards, self._board._cards)
self.rank_class = self.ev.get_rank_class(self.rank)
self._hand_ranks = sorted(
[Card.get_rank_int(card) for card in self._cards])
self._board_ranks = self._board.ranks
def test_create_single_df_of_scores(self):
evaluator = Evaluator()
df = self.df_board.join(self.df_players.xs(0, level=1, axis=1)).apply(
lambda x: evaluator.evaluate(x['board'], x['player']),
axis=1).to_frame('score')
expected = [[310], [2415], [5362], [4014], [2991]]
self.assertEqual(df.values.tolist(), expected)
self.assertEqual(df.columns, ['score'])
def test_valuation(self):
player0 = self.df_players.xs(0, level=1, axis=1)
df = self.df_board.join(player0)
evaluator = Evaluator()
valuations = df.apply(
lambda x: evaluator.evaluate(x['board'], x['player']), axis=1)
expected = [310, 2415, 5362, 4014, 2991]
self.assertEqual(valuations.values.tolist(), expected)
def build(self, testMode=True):
"""
Initiate objects and views.
"""
''' init game objects '''
self.deck = Deck()
self.evaluator = Evaluator()
self.player = []
self.player.append(Player(0))
self.player.append(Player(1))
# board stands for public cards on board
self.board = Board()
# In test mode, both player select right-most cards for the turn automatically
self.testMode = testMode
''' create view objects '''
# Scatter that can be rotated to display players
scatter_bot = ScatterLayout(do_rotation=False,
do_translation=False,
do_scale=False,
size_hint=(1, 1),
pos_hint={
'x': 0,
'y': 0
},
rotation=0)
# For player on top, the widget rotates 180 degree
scatter_top = ScatterLayout(do_rotation=False,
do_translation=False,
do_scale=False,
size_hint=(1, 1),
pos_hint={
'x': 0,
'y': 0
},
rotation=180)
box = PlayerDeck()
box2 = PlayerDeck()
publicArea = PublicArea()
box.build(self, "player1", 0, self.testMode)
box2.build(self, "player2", 1, self.testMode)
publicArea.build()
scatter_bot.add_widget(box)
scatter_top.add_widget(box2)
self.add_widget(scatter_bot)
self.add_widget(scatter_top)
self.add_widget(publicArea)
# register id of view objects
self.ids[box.id] = box
self.ids[box2.id] = box2
self.ids[publicArea.id] = publicArea
def get_score_by_simulate(board_cards, hand_cards, iteration=5):
try:
score_min = 10000 # deuces evaluate score, the small, the better
board = []
for x in board_cards:
x = x.encode('ascii', 'ignore')
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
board.append(c)
hand = []
for x in hand_cards:
x = x.encode('ascii', 'ignore')
c = Card.new('{0}{1}'.format(x[0], x[1].lower()))
hand.append(c)
if (len(hand) + len(board) < 5):
score_list = []
for i in range(iteration):
evaluator = Evaluator()
deck = Deck()
random_cards = deck.draw(5 - len(board) - len(hand))
if (isinstance(random_cards, int)):
random_cards = [random_cards]
score = evaluator.evaluate(board + random_cards, hand)
score_list.append(score)
score_list.remove(max(score_list))
score_list.remove(min(score_list))
return sum(score_list) / float(len(score_list))
else:
for board_five_match in combinations(board, 5 - len(hand)):
evaluator = Evaluator()
score = evaluator.evaluate(tuple(board_five_match),
tuple(hand))
if (score < score_min):
score_min = score
return score_min
except Exception as e:
traceback.print_exc()
printtolog('EXCEPTION={0}'.format(e))
return score_min
def declare_action(self, valid_actions, hole_card, round_state):
# valid_actions format => [raise_action_info, call_action_info, fold_action_info]
# print valid_actions
opponentAgressivnessScore = opponentAgressivness(self)
opponentAgressivnessScoreLast7Round = opponentAgressivness(self, 7)
card1InString, card2InString = hole_card[0], hole_card[1]
cardObject1 = cardToCardObject(card1InString)
cardObject2 = cardToCardObject(card2InString)
call_action_info = valid_actions[1]
action = call_action_info["action"]
amount = call_action_info["amount"]
pot, levelOfBetting, cardsOnBoard, roundCount, isOnSmallblind, isOnBigBlind, smallBlindAmount, bigBlindAmount, stackOfPlayer, stackOfOpponent = extractInfoFromState(
self.uuid, round_state)
cardsOnBoardObjects = getBoardToCardsObject(cardsOnBoard)
allCardsObjectOnBoard = cardsOnBoardObjects[:2 + levelOfBetting - 1]
evaluator = Evaluator()
print cardsOnBoardObjects
if len(
cardsOnBoardObjects
) > 0: # if there is any card on board - so after flop every case
handStrength = evaluate(evaluator, allCardsObjectOnBoard,
cardObject1, cardObject2)
else: # preFLop
handStrength = 0
sklanskyClass = getSklanskyClass(card1InString, card2InString)
if len(
cardsOnBoardObjects
) > 0: # if there is any card on board - so after flop every case
EHS, HS, PPOT, NPOT = effectiveHandStrength(
cardsOnBoardObjects, handStrength, cardObject1, cardObject2)
else:
EHS, HS, PPOT, NPOT = 0, 0, 0, 0
#handle -BigBlind and smallBlind
if levelOfBetting == 1:
if isOnSmallblind:
realAmountToPlay = amount - smallBlindAmount
elif isOnBigBlind:
realAmountToPlay = amount - bigBlindAmount
else: #no blind
realAmountToPlay = amount
else:
realAmountToPlay = amount
addRowToHistory(self.historyDF, [
self.hashOfGame, self.uuid, hole_card[0], hole_card[1], action,
realAmountToPlay, pot, levelOfBetting, cardsOnBoard, roundCount,
isOnSmallblind, isOnBigBlind, smallBlindAmount, bigBlindAmount,
stackOfPlayer, stackOfOpponent, sklanskyClass, EHS, HS, PPOT, NPOT,
handStrength, opponentAgressivnessScore,
opponentAgressivnessScoreLast7Round
])
# print(self.historyDF)
return action, amount # action returned here is sent to the poker engine
def ai_action(data, debug=False):
rank, s_player, round_count = get_player(data)
table_card, self_card = get_card(data)
betCount = get_betCount(data)
min_bet = get_minBet(data)
print "Survive player : {n}".format(n=s_player)
print "Sparrow ranking: {n}".format(n=rank)
print "Total BetCount : {n}".format(n=betCount)
print "min_bet : {n}".format(n=min_bet)
gamma = 0
beta = 0
alpha = 0
if rank < 3:
alpha = -1200
gamma = -1000
'''
if round_count > 5 and rank > 5:
gamma += 1000
beta += 1000
if rank > 7:
beta += 500
'''
if min_bet > 200:
gamma += -500
beta += -500
if min_bet > 400:
gamma += -1000
beta += -500
if len(table_card + self_card) >= 5:
evaluator = Evaluator()
pscore = evaluator.evaluate(table_card, self_card)
pclass = evaluator.get_rank_class(pscore)
print "Sparrow hand rank = %d (%s)\n" % (
pscore, evaluator.class_to_string(pclass))
if pscore > 6000 + beta:
return "fold"
elif pscore > 4000 + gamma:
return "call"
elif pscore > 2000 + alpha:
return "raise"
else:
return "allin"
elif round_count < 10 and min_bet > 300:
return "fold"
else:
return "call"
def compareRank(self):
HighRank = 8000
HingRankIndex = -1
board = []
evalulator = Evaluator()
sh1 = self.convertHand(self.object1.student_Hand)
HighRank = evalulator.evaluate(board, sh1)
HighRankIndex = 0
print "\n"
print "Player 1: " + self.object1.student_Name + "\t Cards: " + self.printHand(
self.object1.student_Hand) + "\t Card-rank: " + str(HighRank)
sh2 = self.convertHand(self.object2.student_Hand)
rank = evalulator.evaluate(board, sh2)
print "\n"
print "Player 2: " + self.object2.student_Name + "\t Cards: " + self.printHand(
self.object2.student_Hand) + "\t Card-rank: " + str(rank)
if (rank < HighRank):
HighRank = rank
HighRankIndex = 1
if (self.object3 is None):
print "\n"
print "Player " + str(HighRankIndex +
1) + " is winner with rank " + str(HighRank)
return
else:
sh3 = self.convertHand(self.object3.student_Hand)
rank = evalulator.evaluate(board, sh3)
print "\n"
print "Player 3: " + self.object3.student_Name + "\t Cards: " + self.printHand(
self.object3.student_Hand) + "\t Card-rank: " + str(rank)
if (rank < HighRank):
HighRank = rank
HighRankIndex = 2
if (self.object4 is None):
print "\n"
print "Player " + str(HighRankIndex +
1) + " is winner with rank " + str(HighRank)
return
else:
sh4 = self.convertHand(self.object4.student_Hand)
rank = evalulator.evaluate(board, sh4)
print "\n"
print "Player 4: " + self.object1.student_Name + "\t Cards: " + self.printHand(
self.object4.student_Hand) + "\t Card-rank: " + str(rank)
if (rank < HighRank):
HighRank = rank
HighRankIndex = 3
def getHandStrength(self):
evaluator = Evaluator()
score = evaluator.evaluate(
[Card.new(str(self.hand[0])),
Card.new(str(self.hand[1]))],
[Card.new('Td'), Card.new('4c'),
Card.new('9s')])
rank = evaluator.get_rank_class(score)
print "Score:", score, "Percentile:", round(
1 - float(score) / float(7254),
2), "Class:", evaluator.class_to_string(rank)
def build_dataframe(nb_hands=1000):
decks = [Deck() for _ in range(nb_hands)]
boards = [deck.draw(5) for deck in decks]
player1 = [deck.draw(2) for deck in decks]
player2 = [deck.draw(2) for deck in decks]
e = Evaluator()
score1 = [e.evaluate(b, h) for (b, h) in zip(boards, player1)]
score2 = [e.evaluate(b, h) for (b, h) in zip(boards, player2)]
return pd.DataFrame({'score1': score1, 'score2': score2})
def getRank3(card):
hand = [Card.new(card[0]), Card.new(card[1])]
evaluator = Evaluator()
board = [
Card.new(card[2]),
Card.new(card[3]),
Card.new(card[4]),
Card.new(card[5])
]
rank3 = evaluator.evaluate(board, hand)
return rank3
def get_hand_strength(hole_cards, board_cards):
"""
Takes in hole cards and board cards and returns the hand strength.
"""
evaluator=Evaluator()
hole=[Card.new(hole_cards[0]), Card.new(hole_cards[1])]
board=[]
for card in board_cards:
board.append(Card.new(card))
strength=(7643-evaluator.evaluate(hole, board))/float(7642)
return strength
def getFeatures(self, state, action):
features = defaultdict(float)
# Get the chip ratio.
features['C-RATIO'] = util.chipRatio(self.chipsIn, state[2])
# Get the agents hand strength.
features['STRENGTH'] = util.strength(Evaluator(), self.getCards(),
state[0])
# Get the agents aggression.
features['AGGRESSION'] = state[4]
return features
def get_deuces_hand_strength(self, cards, board_cards):
"""
Gets the effective hand strength of your cards at any stage of the game using the deuces library.
"""
evaluator = Evaluator()
hole = [Card.new(cards[0]), Card.new(cards[1])
] #Turns cards and board cards into deuces.Card objects
board = []
for card in board_cards:
board.append(Card.new(card))
return (7643 - evaluator.evaluate(hole, board)) / float(
7642) #Turns the hand strength into a decimal in the range of 0-1
def get_score_by_simulate(hand, board, iteration=100):
if(len(hand)+len(board)<=5):
score_list = []
for i in range(iteration):
evaluator = Evaluator()
deck = Deck()
random_cards = deck.draw(5-len(board)-len(hand))
score = evaluator.evaluate(board+random_cards, hand)
score_list.append(score)
score_list.remove(max(score_list))
score_list.remove(min(score_list))
return sum(score_list)/float(len(score_list))
else:
score_min = 9999999
for board_five_match in combinations(board,5-len(hand)):
evaluator = Evaluator()
score = evaluator.evaluate(tuple(board_five_match), tuple(hand))
if(score<score_min):
score_min=score
return score_min
def __init__(self, player_list, chips, blinds):
self.player_list = player_list
self.player_num = len(player_list)
#self.hands = [[] for i in range(len(player_list))]
self.deck = Deck()
self.evaluator = Evaluator()
self.blinds = blinds
self.chips = chips
self.pot = [0 for x in range(0,self.player_num)]
self.table_chips = 0
self.raise_counter = 0
self.table = []
self.strengths =[[], []]
def test_create_df_of_scores(self):
evaluator = Evaluator()
scores = pd.concat([
self.df_board.join(self.df_players.xs(i, level=1, axis=1)).apply(
lambda x: evaluator.evaluate(x['board'], x['player']),
axis=1).to_frame('score')
for i in self.df_players.columns.get_level_values(1)
],
axis=1,
keys=range(2))
scores = scores.swaplevel(0, 1, axis=1)
self.assertEqual(len(scores), 5)
expected = [('score', 0), ('score', 1)]
self.assertEqual(scores.columns.tolist(), expected)
def get_strength_difference(hole_cards_1, hole_cards_2, board_cards):
"""
Takes in the hole cards and the board cards and returns the difference in hand strength between player one and
player two.
"""
evaluator=Evaluator()
hole_1=[Card.new(hole_cards_1[0]), Card.new(hole_cards_1[1])]
hole_2=[Card.new(hole_cards_2[0]), Card.new(hole_cards_2[1])]
board=[]
for card in board_cards:
board.append(Card.new(card))
strength_1=(7643-evaluator.evaluate(hole_1, board))/float(7642)
strength_2=(7643-evaluator.evaluate(hole_2, board))/float(7642)
return strength_1-strength_2
