def encode_state_v1(self, table, hero_player):
state_arrays = []
for x in hero_player.hand:
card_0_rank = Card.get_rank_int(x)
card_0_suit = Card.get_suit_int(x)
state_arrays.append(self.get_card_dummies(card_0_rank,
card_0_suit))
state = np.concatenate([state_arrays], axis=1).reshape(1, 1, -1)
# Put in dummy variables for undealt cards
table_card_ranks = self.table_card_ranks[:]
table_card_suits = self.table_card_suits[:]
for idx, x in enumerate(table.board):
table_card_ranks[idx] = Card.get_rank_int(x)
table_card_suits[idx] = Card.get_suit_int(x)
print(table.board)
print(table_card_ranks)
print(table_card_ranks == self.table_card_ranks)
for card_rank, card_suit in zip(table_card_ranks, table_card_suits):
state_arrays.append(self.get_card_dummies(card_rank, card_suit))
state_arrays = np.concatenate(state_arrays, axis=1)
bet_and_stack = []
bet_and_stack.append(
np.array(hero_player.playing_position).reshape(1, -1))
bet_and_stack.append(
np.array(table.current_pot / table.total_chips).reshape(1, -1))
bet_and_stack.append(
np.array(hero_player.stack / table.total_chips).reshape(1, -1))
bet_and_stack.append(
np.array(table.current_bet / table.total_chips).reshape(1, -1))
bet_and_stack.append(
np.array(hero_player.stack / table.big_blind).reshape(1, -1))
bet_and_stack = np.concatenate(bet_and_stack, axis=1)
state = np.concatenate([state_arrays, bet_and_stack],
axis=1).reshape(1, -1)
fold_state = np.copy(state)
# fold_state = np.zeros(shape=np.shape(state))
return state, fold_state
def revealCards(self, gameObject, cards):
data = {}
data['agenda'] = "cardReveal"
data['data'] = []
for card in cards:
data['data'].append(gameObject.convertNotation(Card.get_rank_int(card), Card.get_suit_int(card)))
comms.broadcastToPlayers(gameObject.players, data);
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 encode_state_simple(self, table, hero_player):
state_arrays = []
for x in hero_player.hand:
card_0_rank = (float(Card.get_rank_int(x)) + 1) / 13
state_arrays.append(card_0_rank)
if Card.get_suit_int(hero_player.hand[0]) == Card.get_suit_int(
hero_player.hand[1]):
is_suited = 1
else:
is_suited = 0
state_arrays.append(is_suited)
card_connectivity = abs(
Card.get_rank_int(hero_player.hand[0]) / 13 -
Card.get_rank_int(hero_player.hand[1]) / 13)**0.25
state_arrays.append(card_connectivity)
# state = np.concatenate([state_arrays], axis=1)
state_arrays = np.array(state_arrays).reshape(1, -1)
# print(state_arrays)
bet_and_stack = []
bet_and_stack.append(
np.array(table.current_pot / hero_player.prev_stack).reshape(
1, -1))
bet_and_stack.append(
np.array(hero_player.stack / hero_player.prev_stack).reshape(
1, -1))
bet_and_stack.append(
np.array(hero_player.playing_position).reshape(1, -1))
bet_and_stack = np.concatenate(bet_and_stack, axis=1)
state = np.concatenate([state_arrays, bet_and_stack],
axis=1).reshape(1, -1)
fold_state = np.copy(state)
fold_state[0][0:6] = 0.0
fold_q_value = hero_player.stack / hero_player.prev_stack
return state, fold_state
def serialize_card(card):
suit_int = Card.get_suit_int(card)
rank_int = Card.get_rank_int(card)
s = Card.INT_SUIT_TO_CHAR_SUIT[suit_int]
r = Card.STR_RANKS[rank_int]
return s + r
def get_rank_of_hand_cards(card1, card2):
rank = 0
features = convert_card_to_feature(card1)
features.update(convert_card_to_feature(card2))
suit_1 = Card.get_suit_int(card1)
suit_2 = Card.get_suit_int(card2)
rank_1 = Card.get_rank_int(card1)
rank_2 = Card.get_rank_int(card2)
features[53] = 1 if suit_1 == suit_2 else 0
features[54] = 1 if rank_1 == rank_2 else 0
features[55] = rank_1 / 13
features[56] = rank_2 / 13
features[57] = abs(rank_1 - rank_2) / 12
if suit_1 == suit_2: # same suit
if rank_1 >= 8 and rank_2 >= 8: # pokers >= 10
rank = 10
elif (rank_1 >= 8 or rank_2 >= 8) and abs(
rank_1 - rank_2) < 5: # |one of poker >= 10| and |gap < 5|
rank = 9
elif abs(rank_1 - rank_2) < 5: # gap < 5
rank = 8
else:
rank = 6
elif rank_1 == rank_2: # same rank
if rank_1 >= 8:
rank = 7
elif rank_1 >= 5:
rank = 5
else:
rank = 3
else:
if rank_1 >= 8 and rank_2 >= 8: # pokers >= 10
rank = 4
elif (rank_1 >= 8 or rank_2 >= 8) and abs(
rank_1 - rank_2) < 5: # |one of poker >= 10| and |gap < 5|
rank = 2
elif rank_1 >= 8 or rank_2 >= 8 or abs(rank_1 - rank_2) < 5: # gap < 5
rank = 1
else:
rank = 0
features[58] = rank / 10
return rank, features
def cards_to_ranks(cards, pad):
rank_dummy = np.zeros(pad)
# Add one to distinguish deuce from missing
cards = sorted([Card.get_rank_int(x) for x in cards])
for i, card in enumerate(cards):
if i >= pad:
continue
rank_dummy[i] = card + 1
rank_dummy_std = (rank_dummy - 8) / 14 # Hacky "standardisation"
return rank_dummy_std
def cards_to_ranks(cards, pad):
rank_dummy = np.zeros(pad)
# Add one to distinguish deuce from missing
cards = sorted([Card.get_rank_int(x) for x in cards])
for i, card in enumerate(cards):
if i >= pad:
continue
rank_dummy[i] = card + 1
rank_dummy_std = (rank_dummy - 8) / 14 # Hacky "standardisation"
return rank_dummy_std
def make_preflop_probability(self, hero_player, table):
if table.stage == "PREFLOP":
card_0_rank = Card.get_rank_int(hero_player.hand[0])
card_0_suit = Card.get_suit_int(hero_player.hand[0])
card_1_rank = Card.get_rank_int(hero_player.hand[1])
card_1_suit = Card.get_suit_int(hero_player.hand[1])
if card_0_suit == card_1_suit:
hero_score = self.preflop_suited_array[card_0_rank,
card_1_rank]
else:
hero_score = self.preflop_unsuited_array[card_0_rank,
card_1_rank]
else:
hero_score = -1
return np.array(hero_score).reshape(1, -1)
def make_hand_rank_dummies(self, hero_player):
card_dummies = []
for x in hero_player.hand:
rank_int = Card.get_rank_int(x)
rank_int = np.array(rank_int).reshape(-1, 1)
rank_dummies = self.rank_enc.transform(rank_int).toarray()[:, :-1]
card_dummies.append(rank_dummies)
card_dummies = np.concatenate(card_dummies, axis=1)
return card_dummies
def get_hole_power(hole):
ha = Card.get_rank_int(hole[0])
hb = Card.get_rank_int(hole[1])
power = ha + hb
if Card.get_suit_int(hole[0]) == Card.get_suit_int(hole[1]):
power += 25
if ha == hb:
power += 50
if ha >= 8:
power += ha * 3
if hb >= 8:
power += hb * 3
if power >= 100:
power = 100
return power
def handle_hold_rank(self, hand):
card_1 = Card.get_rank_int(hand[0]) + 2
card_2 = Card.get_rank_int(hand[1]) + 2
if card_1 > card_2:
fst_card = card_1
sec_card = card_2
else:
fst_card = card_2
sec_card = card_1
card_list = [fst_card, sec_card]
if Card.get_suit_int(hand[0]) == Card.get_suit_int(hand[1]):
card_list.append('s')
rank = 9
for key in TWO_CARD_RANK_EVA.keys():
value = TWO_CARD_RANK_EVA[key]
if card_list in value:
rank = int(key)
break
return rank
def convert_card_to_feature(card):
features = {}
suit = Card.get_suit_int(card)
# print(suit)
rank = Card.get_rank_int(card)
if suit == 1:
index = rank
elif suit == 2:
index = rank + 13
elif suit == 4:
index = rank + 26
elif suit == 8:
index = rank + 39
features[index] = 1
return features
def score_front_royalties(cards):
if len(cards) != 3:
raise ValueError("Incorrect number of cards!")
ranks = [Card.get_rank_int(x) for x in cards]
ctr = collections.Counter(ranks)
rank, count = ctr.most_common()[0]
if count < 2:
return 0
if count == 2:
return max(0, rank - 3)
if count == 3:
return 10 + rank
def score_front_royalties(cards):
if len(cards) != 3:
raise ValueError("Incorrect number of cards!")
ranks = [Card.get_rank_int(x) for x in cards]
ctr = collections.Counter(ranks)
rank, count = ctr.most_common()[0]
if count < 2:
return 0
if count == 2:
return max(0, rank - 3)
if count == 3:
return 10 + rank
def make_board_rank_dummies(self, table):
card_dummies = []
table_card_ranks = self.table_card_ranks[:]
for idx, x in enumerate(table.board):
rank_int = Card.get_rank_int(x)
table_card_ranks[idx] = rank_int
for x in table_card_ranks:
x = np.array(x).reshape(-1, 1)
rank_dummies = self.rank_enc.transform(x).toarray()[:, :-1]
card_dummies.append(rank_dummies)
card_dummies = np.concatenate(card_dummies, axis=1)
return card_dummies
def get_lowest_unpairing_card(hand):
"""Add the worst possible card to an incomplete hand. Something
that cannot pair up or make a flush or make a straight."""
existing_ranks = set([Card.get_rank_int(x) for x in hand])
remaining_ranks = list(set(range(12)) - existing_ranks)
selected_rank = remaining_ranks[0]
would_be_hand = hand + [Card.new(Card.STR_RANKS[selected_rank] + 'h')]
if is_straight(would_be_hand):
selected_rank = remaining_ranks[1] # Don't make a straight
selected_rank_str = Card.STR_RANKS[selected_rank]
last_suit = Card.get_suit_int(hand[-1])
last_suit_index = [1, 2, 4, 8].index(last_suit)
selected_suit = [1, 2, 4, 8][(last_suit_index + 1) % 4]
selected_suit_str = Card.INT_SUIT_TO_CHAR_SUIT[selected_suit]
selected_card_str = selected_rank_str + str(selected_suit_str)
return Card.new(selected_card_str)
def get_lowest_unpairing_card(hand):
"""Add the worst possible card to an incomplete hand. Something
that cannot pair up or make a flush or make a straight."""
existing_ranks = set([Card.get_rank_int(x) for x in hand])
remaining_ranks = list(set(range(12)) - existing_ranks)
selected_rank = remaining_ranks[0]
would_be_hand = hand + [Card.new(Card.STR_RANKS[selected_rank] + 'h')]
if is_straight(would_be_hand):
selected_rank = remaining_ranks[1] # Don't make a straight
selected_rank_str = Card.STR_RANKS[selected_rank]
last_suit = Card.get_suit_int(hand[-1])
last_suit_index = [1, 2, 4, 8].index(last_suit)
selected_suit = [1, 2, 4, 8][(last_suit_index + 1) % 4]
selected_suit_str = Card.INT_SUIT_TO_CHAR_SUIT[selected_suit]
selected_card_str = selected_rank_str + str(selected_suit_str)
return Card.new(selected_card_str)
def get_current_ai_state_id(self):
# current_state_id encodes the current state as follows:
# current_state_id[0]: Indicates whether or not the player's two cards are the same suit
# current_state_id[1]: Value of the player's high card
# current_state_id[2]: Value of the player's low card
# current_state_id[3]: The actions taken, as stored in self.action_round
if Card.get_rank_int(self.player_cards[0]) >= Card.get_rank_int(
self.player_cards[1]):
high_card = Card.get_rank_int(self.player_cards[0])
low_card = Card.get_rank_int(self.player_cards[1])
else:
high_card = Card.get_rank_int(self.player_cards[1])
low_card = Card.get_rank_int(self.player_cards[0])
is_same_suit = Card.get_suit_int(
self.player_cards[0]) == Card.get_suit_int(self.player_cards[1])
current_state_id = (int(is_same_suit), high_card, low_card,
tuple(self.action_round))
return current_state_id
def generate_odds():
card_ints = [i for i in range(13)]
pair_combos = combinations_with_replacement(card_ints, 2)
eval = Evaluator()
pair_scores = np.zeros(shape=(13, 13))
pair_suits = [8, 8]
for x in pair_combos:
deck = Deck()
deck_match_idxs = []
hero_cards = [None, None]
if x[0] == x[1]:
continue
# Find cards in deck
for deck_idx, card in enumerate(deck.cards):
if x[0] == Card.get_rank_int(card) and pair_suits[0] == Card.get_suit_int(card):
hero_cards[0] = card
deck_match_idxs.append(deck_idx)
if x[1] == Card.get_rank_int(card) and pair_suits[1] == Card.get_suit_int(card):
hero_cards[1] = card
deck_match_idxs.append(deck_idx)
# Remove hero cards from deck
deck.cards = [i for idx, i in enumerate(deck.cards) if idx not in deck_match_idxs]
# Repeat x times
num_wins = 0
num_losses = 0
while num_wins + num_losses < 10000:
# Draw villan cards
villan_cards = deck.draw(2)
# Draw five card board
board = deck.draw(5)
# Find winner
hero_rank = eval.evaluate(hero_cards, board)
villan_rank = eval.evaluate(villan_cards, board)
if hero_rank < villan_rank:
num_wins += 1
elif hero_rank > villan_rank:
num_losses += 1
else:
None
# Put villan and board cards back into deck
deck.cards.extend(villan_cards)
deck.cards.extend(board)
# Shuffle deck for next draw
shuffle(deck.cards)
pair_scores[x[0], x[1]] = num_wins / (num_wins + num_losses)
pair_scores[x[1], x[0]] = num_wins / (num_wins + num_losses)
np.savetxt('./suited_pair_scores.csv', pair_scores, delimiter=',', fmt='%5f')
print(pair_scores)
evaluator = Evaluator()
cards = ['Ah', 'Kh', 'Qh', 'Jh', 'Th', '9h', '8h',
'7h', '6h', '5h', '4h', '3h', '2h']
perms = []
for i in xrange(len(cards)):
for j in xrange(i, len(cards)):
for k in xrange(j, len(cards)):
perms.append([Card.new(cards[i]),
Card.new(cards[j]),
Card.new(cards[k])])
front_lookup = {}
for perm in perms:
# Add the two lowest unpairing cards
hand = copy(perm)
hand.append(get_lowest_unpairing_card(hand))
hand.append(get_lowest_unpairing_card(hand))
prime_prod = Card.prime_product_from_hand(perm)
rank = evaluator.evaluate(hand, []) + 1
kicker = Card.get_rank_int(perm[0]) * 0.01 + \
Card.get_rank_int(perm[1]) * 0.0001 + \
Card.get_rank_int(perm[2]) * 0.000001
front_lookup[prime_prod] = rank - kicker
with open('res/front_lookup.p', 'wb') as f:
pickle.dump(front_lookup, f)
def _unique_ranks(self):
"""Return a list of unique card ranks."""
return list(set([Card.get_rank_int(card) for card in self._cards]))
def card_to_ranks_binary(card):
out = np.zeros(13)
rank = Card.get_rank_int(card)
out[rank] = 1
return out
def card_to_ranks_binary(card):
out = np.zeros(13)
rank = Card.get_rank_int(card)
out[rank] = 1
return out
def get_pokers(self):
res = []
for poker in self.pokers:
res.append((Card.get_rank_int(poker), Card.get_suit_int(poker)))
return res
def callAI(self, state, actions):
#CHANGE THIS FUNCTION. NEVER REFERENCE OTHER PLAYER'S CARDS.
#You are not allowed to cheat! (obviously)
#e.g. If we see curState.players[x].curHand, that's unacceptable.
#count turn
self.turns += 1
#reset aggro
self.aggro = 1
#update opponents' aggro ratings based on actions
for action in actions:
#print (action)
if action[0] not in self.opponentAggro:
self.opponentAggro[action[0]] = 0
else:
#if they checked, pass
if (action[1][0] == 'check'):
pass
#otherwise if they raised, increase their aggro factor by 1
else:
self.opponentAggro[
action[0]] = self.opponentAggro[action[0]] + 1
#if there is an aggressive opponent in the hand, be ready to call their bluffs
for player in state.curPlayers:
if player != self:
if (self.opponentAggro[player] / self.turns) > 0.35:
self.aggro *= 1.1
#are you winning or losing?
#based on how many chips you have vs. the field
winning = 0
for player in state.curPlayers:
if player != self:
if self.money < player.money:
winning -= 1
elif self.money > player.money:
winning += 1
winning = (winning > 0)
#if you are winning, play more aggressively
#otherwise, play more conservatively
if (winning):
self.aggro *= 1.1
else:
self.aggro *= 0.9
#action is a string: raise, check,or fold
action = ""
raiseAmount = 1
maxbid = 1
if (state.curStage == "preflop"):
#if you have a pocket pair
if (Card.get_rank_int(self.curHand[0]) == Card.get_rank_int(
self.curHand[1])):
#pair of 10's or higher
if (Card.get_rank_int(self.curHand[0]) >= 8):
#40% chance to raise up to 50, call up to 100
if (random.randint(0, 100) * self.aggro > 60):
raiseAmount = int(random.randint(1, 50) * self.aggro)
maxbid = 100
action = "raise"
else:
maxbid = 100
action = "check"
#pair of 9's or lower
else:
#call up to 30
maxbid = int(30 * self.aggro)
action = "check"
#if you have ace high
elif (Card.get_rank_int(self.curHand[0]) == 12):
#call up to 30
maxbid = int(30 * self.aggro)
action = "check"
else:
#otherwise, call up to 25
maxbid = int(25 * self.aggro)
action = "check"
else: #if flop, turn, or river
#rank percentage of hand (0.0-1.0 where 1.0 is the best hand)
handRank = 1.0 - self.myeval.get_five_card_rank_percentage(
self.myeval.evaluate(self.curHand, state.board))
#adjust hand rank based on aggression (play like you have a better/worse hand)
handRank *= self.aggro
if (handRank < 0.1):
#if hand is in the bottom 10th percentile, fold
action = "fold"
elif (handRank >= 0.1 or handRank <= 0.2):
#if hand is in the 10 - 20th percentile, check with a maxbid of 100
maxbid = 100
action = "check"
elif (handRank >= 0.2):
#if hand rank is greater than the 20th percentile, raise an amount based on the rank
raiseAmount = int(handRank * maxbet)
#keep maxbid at 100 to stay in the hand if possible
maxbid = 100
action = "raise"
#check to make sure you have enough money for maxbid and raiseAmount
if maxbid > self.money: #do not remove
maxbid = self.money
if raiseAmount > self.money: #do not remove
raiseAmount = self.money
#return actions
if (action == "raise"):
return [["raise", raiseAmount], maxbid]
elif (action == "check"):
return ["check", maxbid]
elif (action == "fold"):
#print("Billy folds")
return ["check", 0]
def startRound(self, gameObject):
self.board=[]
self.pot=0
self.sidePot=0
print("MAIN POT: "+ str(self.pot)+ " SIDE POT: "+ str(self.sidePot))
playerCount = len(self.roundPlayers)
if(playerCount <= 1): #check if there are more than 1 players in round
print("ENDING GAME - NOT ENOUGH PLAYERS LEFT")
return False #DONE implementiraj ce ni nobenega ker so leavali
#deal initial hands
for i in range(2):
for player in self.roundPlayers:
player.hand.append(self.deck.draw(1))
#game start & initial cards
for player in self.roundPlayers:
data = {}
data['agenda'] = "roundStart"
data['status'] = "ok"
currentHand = player.hand
data['data'] = [
gameObject.convertNotation(Card.get_rank_int(currentHand[0]), Card.get_suit_int(currentHand[0])),
gameObject.convertNotation(Card.get_rank_int(currentHand[1]), Card.get_suit_int(currentHand[1]))
]
comms.send(player.socket, data);
#Preflop phase
print("--Preflop--")
result = self.preflopPhase(gameObject, (gameObject.roundCounter % len(self.roundPlayers)))
#check if all but 1 folded else go to next phase
if(not result): #only 1 player remains active; end game
lastPlayerIndex=self.getLastPlayer()
if(lastPlayerIndex is not False):
self.endRound(gameObject, [lastPlayerIndex])
return True
else:
return False
#Flop phase
print("--Flop--")
self.board=self.deck.draw(3) #3 cards to board
self.revealCards(gameObject, self.board)
result=self.bettingPhase(gameObject, (gameObject.roundCounter % len(self.roundPlayers)))
#check if all but 1 folded else go to next phase
if(not result): #only 1 player remains active; end game
lastPlayerIndex=self.getLastPlayer()
if(lastPlayerIndex is not False):
self.endRound(gameObject, [lastPlayerIndex])
return True
else:
return False
#Turn phase
print("--Turn--")
drawnCard = self.deck.draw(1)
self.revealCards(gameObject, [drawnCard])
self.board.append(drawnCard)
result=self.bettingPhase(gameObject, (gameObject.roundCounter % len(self.roundPlayers)))
#check if all but 1 folded else go to next phase
if(not result): #only 1 player remains active; end game
lastPlayerIndex=self.getLastPlayer()
if(lastPlayerIndex is not False):
self.endRound(gameObject, [lastPlayerIndex])
return True
else:
return False
#River phase
print("--River--")
drawnCard = self.deck.draw(1)
self.revealCards(gameObject, [drawnCard])
self.board.append(drawnCard)
result=self.bettingPhase(gameObject, (gameObject.roundCounter % len(self.roundPlayers)))
#end hand comparison
if(not result): #only 1 player remains active; end game
lastPlayerIndex=self.getLastPlayer()
if(lastPlayerIndex is not False):
self.endRound(gameObject, [lastPlayerIndex])
return True
else:
return False
# allHands = []
playerCount = len(self.roundPlayers)
for i in range(playerCount):
if(self.playerStatus != None):
self.playerHandScores.append(evaluator.evaluate(self.board, self.roundPlayers[i].hand))
self.playerHandClasses.append(evaluator.get_rank_class(self.playerHandScores[i]))
# allHands.append(self.roundPlayers[i].hand)
else:
self.playerHandScores.append(None)
self.playerHandClasses.append(None)
# allHands.append(self.roundPlayers[i].hand)
#print(str(Card.get_suit_int(self.board[0]))+" "+str(Card.get_rank_int(self.board[0])))
# print("BOARD: ")
# Card.print_pretty_cards(self.board)
# for i in range(playerCount):
# if(self.playerStatus[i]!=None):
# print("Player " + str(i) + ": ")
# Card.print_pretty_cards(self.roundPlayers[i].hand)
# else:
# print("Player " + str(i) + ": FOLDED")
winners=self.getWinnerIndexes()
self.endRound(gameObject, winners)
#DONE(test): ob koncu igre klici removePlayer() nad vsemi igralci ki so ostali zavoljo konsistence
# evaluator.hand_summary(self.board, allHands)
return True
def ranks(self):
"""Return an ordered list of card ranks."""
return [Card.get_rank_int(card) for card in self._cards]
'2h'
]
perms = []
for i in xrange(len(cards)):
for j in xrange(i, len(cards)):
for k in xrange(j, len(cards)):
perms.append(
[Card.new(cards[i]),
Card.new(cards[j]),
Card.new(cards[k])])
front_lookup = {}
for perm in perms:
# Add the two lowest unpairing cards
hand = copy(perm)
hand.append(get_lowest_unpairing_card(hand))
hand.append(get_lowest_unpairing_card(hand))
prime_prod = Card.prime_product_from_hand(perm)
rank = evaluator.evaluate(hand, []) + 1
kicker = Card.get_rank_int(perm[0]) * 0.01 + \
Card.get_rank_int(perm[1]) * 0.0001 + \
Card.get_rank_int(perm[2]) * 0.000001
front_lookup[prime_prod] = rank - kicker
with open('res/front_lookup.p', 'wb') as f:
pickle.dump(front_lookup, f)
def encode_state_by_hand(self, table, hero_player):
state_arrays = []
# Unpack card ranks
for x in hero_player.hand:
# card_0_rank = (float(Card.get_rank_int(x)) + 1) / 13
card_0_rank = Card.get_rank_int(x)
card_0_rank = self.min_max_scaling(-1, 1, 0, 12, card_0_rank)
state_arrays.append(card_0_rank)
c_1_suit = Card.get_suit_int(hero_player.hand[0])
# c_1_suit = self.min_max_scaling(-1, 1, 0, 9, c_1_suit)
c_2_suit = Card.get_suit_int(hero_player.hand[1])
# c_2_suit = self.min_max_scaling(-1, 1, 0, 9, c_2_suit)
# state_arrays.append(c_1_suit)
# state_arrays.append(c_2_suit)
if c_1_suit == c_2_suit:
state_arrays.append(1)
else:
state_arrays.append(-1)
# state = np.concatenate([state_arrays], axis=1).reshape(1, 1, -1)
# is preflop
is_preflop = 0
is_flop = 0
is_turn = 0
is_river = 0
if table.stage == "PREFLOP":
is_preflop = 1
elif table.stage == "FLOP":
is_flop = 1
elif table.stage == "TURN":
is_turn = 1
elif table.stage == "RIVER":
is_river = 1
else:
print("error")
exit()
state_arrays.append(is_preflop)
hero_score = 7462
# evaluate hand if not preflop
if not is_preflop:
board = [x for x in table.board if x != 13]
hero_score = self.evaluator.evaluate(board, hero_player.hand)
hero_score = self.min_max_scaling(0, 1, 0, 7462, hero_score)
else:
card_0_rank = Card.get_rank_int(hero_player.hand[0])
card_1_rank = Card.get_rank_int(hero_player.hand[1])
if c_1_suit == c_2_suit:
hero_score = self.preflop_suited_array[card_0_rank,
card_1_rank]
else:
hero_score = self.preflop_unsuited_array[card_0_rank,
card_1_rank]
# if hero_score == 0:
# print(c_1_suit, c_2_suit)
# print(card_0_rank, card_1_rank)
# print(self.preflop_unsuited_array)
# exit()
state_arrays.append(hero_score)
state_arrays = np.array(state_arrays)
state_arrays = state_arrays.reshape(1, -1)
bet_and_stack = []
bet_and_stack.append(
np.array(hero_player.playing_position).reshape(1, -1))
# pot_total_ratio = table.current_pot/table.total_chips
# stack_total_ratio = hero_player.stack/table.total_chips
bet_total_ratio = table.current_bet / table.total_chips
# stack_bb_ratio = table.big_blind/hero_player.stack
stack_contrib_ratio = hero_player.stack / hero_player.prev_stack
win_stack_ratio = (hero_player.stack +
table.current_pot) / hero_player.prev_stack
# bet_total_ratio = self.min_max_scaling(-1, 1, 0, 1, bet_total_ratio)
# stack_contrib_ratio = self.min_max_scaling(-1, 1, 0, 2, stack_contrib_ratio)
# win_stack_ratio = self.min_max_scaling(-1, 1, 1, 2, win_stack_ratio)
# bet_and_stack.append(np.array(pot_total_ratio).reshape(1, -1))
# bet_and_stack.append(np.array(stack_total_ratio).reshape(1, -1))
bet_and_stack.append(np.array(bet_total_ratio).reshape(1, -1))
# bet_and_stack.append(np.array(stack_bb_ratio).reshape(1, -1))
bet_and_stack.append(np.array(stack_contrib_ratio).reshape(1, -1))
bet_and_stack.append(np.array(win_stack_ratio).reshape(1, -1))
# bet_and_stack.append(np.array(table.current_pot/table.total_chips).reshape(1, -1))
# bet_and_stack.append(np.array(hero_player.stack/table.total_chips).reshape(1, -1))
# bet_and_stack.append(np.array(table.current_bet/table.total_chips).reshape(1, -1))
# bet_and_stack.append(np.array(hero_player.stack/table.big_blind).reshape(1, -1))
# bet_and_stack.append(np.array(hero_player.stack/hero_player.contribution_to_pot).reshape(1, -1))
bet_and_stack = np.concatenate(bet_and_stack, axis=1)
# print(bet_and_stack)
state = np.concatenate([state_arrays, bet_and_stack],
axis=1).reshape(1, -1)
# fold_state = np.copy(state)
fold_state = np.zeros(shape=np.shape(state))
fold_state[-1][-1] = stack_contrib_ratio
# Fold state doesn't matter what the hero cards are, score, position
return state, fold_state
def get_card_rank(self, card):
return Card.get_rank_int(card)
def encode_state_by_table(self, table, hero_player):
state_arrays = []
# Unpack card ranks
for x in hero_player.hand:
# card_0_rank = (float(Card.get_rank_int(x)) + 1) / 13
card_0_rank = Card.get_rank_int(x) + 1
card_0_rank = self.min_max_scaling(-1, 1, 0, 13, card_0_rank)
state_arrays.append(card_0_rank)
c_1_suit = Card.get_suit_int(hero_player.hand[0])
c_1_suit = self.min_max_scaling(-1, 1, 0, 9, c_1_suit)
c_2_suit = Card.get_suit_int(hero_player.hand[1])
c_2_suit = self.min_max_scaling(-1, 1, 0, 9, c_2_suit)
state_arrays.append(c_1_suit)
state_arrays.append(c_2_suit)
# state = np.concatenate([state_arrays], axis=1).reshape(1, 1, -1)
# Put in dummy variables for undealt cards
table_card_ranks = self.table_card_ranks[:]
table_card_suits = self.table_card_suits[:]
for idx, x in enumerate(table.board):
table_card_ranks[idx] = Card.get_rank_int(x) + 1
table_card_ranks[idx] = self.min_max_scaling(
-1, 1, 0, 13, table_card_ranks[idx])
table_card_suits[idx] = Card.get_suit_int(x)
table_card_suits[idx] = self.min_max_scaling(
-1, 1, 0, 9, table_card_suits[idx])
# is preflop
is_preflop = 0
is_flop = 0
is_turn = 0
is_river = 0
if table.stage == "PREFLOP":
is_preflop = 1
elif table.stage == "FLOP":
is_flop = 1
elif table.stage == "TURN":
is_turn = 1
elif table.stage == "RIVER":
is_river = 1
else:
print("error")
exit()
state_arrays.append(is_preflop)
state_arrays.append(is_flop)
state_arrays.append(is_turn)
state_arrays.append(is_river)
hero_score = 7462
# evaluate hand if not preflop
if not is_preflop:
board = [x for x in table.board if x != 13]
hero_score = self.evaluator.evaluate(board, hero_player.hand)
hero_score = self.min_max_scaling(-1, 1, 0, 7462, hero_score)
state_arrays.append(hero_score)
state_arrays = np.array(state_arrays)
state_arrays = state_arrays.reshape(1, -1)
bet_and_stack = []
bet_and_stack.append(
np.array(hero_player.playing_position).reshape(1, -1))
bet_total_ratio = table.current_bet / table.total_chips
stack_contrib_ratio = hero_player.stack / table.total_chips
win_stack_ratio = (hero_player.stack +
table.current_pot) / table.total_chips
bet_total_ratio = self.min_max_scaling(-1, 1, 0, 1, bet_total_ratio)
stack_contrib_ratio = self.min_max_scaling(-1, 1, 0, 2,
stack_contrib_ratio)
win_stack_ratio = self.min_max_scaling(-1, 1, 1, 2, win_stack_ratio)
bet_and_stack.append(np.array(bet_total_ratio).reshape(1, -1))
bet_and_stack.append(np.array(stack_contrib_ratio).reshape(1, -1))
bet_and_stack.append(np.array(win_stack_ratio).reshape(1, -1))
bet_and_stack = np.concatenate(bet_and_stack, axis=1)
state = np.concatenate([state_arrays, bet_and_stack],
axis=1).reshape(1, -1)
# fold_state = np.copy(state)
fold_state = np.zeros(shape=np.shape(state))
fold_state[-1][-1] = stack_contrib_ratio
# Fold state doesn't matter what the hero cards are, score, position
return state, fold_state
def endRound(self, gameObject, winners):
#winners=[0,1]
data = {}
data['agenda'] = "playerWonRound"
data['data'] = {'winnerSid': [], 'earnings': [], 'playerSid':[], 'playerHands':[], 'currentCash':[]}
if(len(winners)==1):
#only 1 winner
gameObject.players[winners[0]].money+=self.pot
print("Player " + str(winners[0]) + " WON")
data['data']['winnerSid'] = gameObject.players[winners[0]].id #front checks len(data['playerSid'])
data['data']['earnings'] = self.pot
else:
#OH LORD HELP US, CE BO TO DELALO
mainPot=0
sidePot=0
leftoverMainPot=0
leftoverSidePot=0
retVal=self.getMinBetAndSecondMinBetAndItsIndexes()
minBetIndex=retVal[0]
minBet=retVal[1]
secondMinIndex=retVal[2]
secondMinBet=retVal[3]
sidePotWinners=[]
for i in range(len(self.roundPlayers)): #get main pot
#calculate mainPot
if(self.playerStatus[i] is not None):
mainPot+=minBet
#advanced black magic sidePot calculations
if(self.playerStatus[i] is not None and self.roundPlayers[i].currentBet > minBet):
sidePot+=(secondMinBet-minBet)
if(self.roundPlayers[i].currentBet>secondMinBet):
self.roundPlayers[i].returnMoney((self.roundPlayers[i].currentBet-secondMinBet))
sidePotWinners.push(i)
self.roundPlayers[i].currentBet=secondMinBet #needed?
if(len(winners)==0):
mainPotSplit=mainPot
else:
mainPotSplit=math.floor(mainPot/len(winners))
leftoverMainPot=mainPot%len(winners)
if(len(sidePotWinners)==0):
sidePotSplit=sidePot
sidePotWinners=winners
else:
sidePotSplit=math.floor(sidePot/len(sidePotWinners))
leftoverSidePot=sidePot%len(sidePotWinners)
for j in range(len(winners)):
if(self.roundPlayers[j].currentBet==minBet):
gameObject.players[winners[j]].money+=mainPotSplit
if(self.roundPlayers[j].currentBet > minBet):
gameObject.players[winners[j]].money+=sidePotSplit
#split leftover earnings amongst players (remainder at pot/ammountOfWinners; example=> 15/2=7=>remainder:1; first winners gets the leftover money)
#requires in-depth testing
mainLeftoverEarnings=[]
for p in winners:
mainLeftoverEarnings.append(0)
mainPotPI=0
while(leftoverMainPot>0):
mainLeftoverEarnings[mainPotPI]+=1
leftoverMainPot-=1
mainPotPI+=1
if(mainPotPI>len(winners)):
mainPotPI=0
sideLeftoverEarnings=[]
for p in sidePotWinners:
sideLeftoverEarnings.addpend(0)
sidePotPI=0
while(leftoverSidePot>0):
sideLeftoverEarnings[sidePotPI]+=1
leftoverSidePot-=1
sidePotPI+=1
if(sidePotPI>len(sidePotWinners)):
sidePotPI=0
mainPotPI2=0
sidePotPI2=0
for p in winners:
earnings=mainPotSplit
if(mainPotPI2<len(winners)):
earnings+=mainLeftoverEarnings[mainPotPI2]
mainPotPI2+=1
data['data']['winnerSid'].append(gameObject.players[p].id)
if(p in sidePotWinners):
earnings+=sidePotSplit
if(sidePotPI2<len(sideLeftoverEarnings)):
earnings+=sideLeftoverEarnings[sidePotPI2]
sidePotPI2+=1
data['data']['earnings'].append(earnings)
#split the pot-DEPRECATED
#potSplit=self.pot / len(winners)
#print("Pot split between: ")
#for p in winners:
# gameObject.players[winnerIndex].money+=potSplit
# print("Player " + str(winners[0]) + " ")
# data['playerSid'].append(gameObject.players[p])
# data['earnings'].append(potSplit)
for player in gameObject.players:
data['data']['playerSid'].append(player.id)
convertedHand = player.hand
convertedHand[0] = gameObject.convertNotation(Card.get_rank_int(convertedHand[0]), Card.get_suit_int(convertedHand[0]))
convertedHand[1] = gameObject.convertNotation(Card.get_rank_int(convertedHand[1]), Card.get_suit_int(convertedHand[1]))
data['data']['playerHands'].append(convertedHand)
data['data']['currentCash'].append(player.money)
print(data)
comms.broadcastToPlayers(gameObject.players, data);
gameObject.roundCounter+=1
print("\r\n\r\n")
def has_under_pair(self):
"""Verify if the hand is an underpair to the board."""
if not self.pair_in_hand():
return False
rank = Card.get_rank_int(self._cards[0])
return all(map(lambda x: rank < x, self._board_ranks))
