def has_flush_draw(self):
"""Verifies if there is a flush draw.
Returns a tuple of booleans, (high, low)
(True, False) means there's a flush draw to the high card.
(False, True) means the same, to the low card.
(True, True) means the hand is suited, and there's a flush draw.
(False, False) means no flush draw.
Should return (True, False) if there's a flush draw with a pair in hand.
Can be used with any() or all()
"""
if self.is_flush():
return (False, False)
high_card = max(self._cards)
hc_suit = Card.get_suit_int(high_card)
low_card = min(self._cards)
lc_suit = Card.get_suit_int(low_card)
suits = list(map(Card.get_suit_int, self._cards + self._board._cards))
high_f_d = len([suit for suit in suits if suit == hc_suit]) == 4
low_f_d = len([suit for suit in suits if suit == lc_suit]) == 4
if any([high_f_d, low_f_d]) and self.pair_in_hand():
return (True, False)
return (high_f_d, low_f_d)
def has_backdoor_flush(self):
"""Verifies if there is a backdoor flush.
Returns a tuple of booleans, (high, low)
(True, False) means there's a backdoor flush to the high card.
(False, True) means the same, to the low card.
(True, True) means the hand is suited, and there's a backdoor flush
with a card on the flop.
(False, False) means no backdoor flush draw.
Can be used with any() or all()
"""
high_card = max(self._cards)
hc_suit = Card.get_suit_int(high_card)
low_card = min(self._cards)
lc_suit = Card.get_suit_int(low_card)
suits = list(map(Card.get_suit_int, self._cards + self._board._cards))
high_bd_f_d = len([suit for suit in suits if suit == hc_suit]) == 3
low_bd_f_d = len([suit for suit in suits if suit == lc_suit]) == 3
if any([high_bd_f_d, low_bd_f_d]) and self.pair_in_hand():
return (True, False)
return (high_bd_f_d, low_bd_f_d)
def make_is_suited(self, hero_player):
if Card.get_suit_int(hero_player.hand[0]) == Card.get_suit_int(
hero_player.hand[1]):
return np.array(1).reshape(1, -1)
else:
return np.array(0).reshape(1, -1)
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 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 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 cards_to_suits(cards):
suit_dummy = np.zeros(4)
suit_binaries = np.array([Card.get_suit_int(x) for x in cards])
suit_dummy[0] = sum(suit_binaries == 1)
suit_dummy[1] = sum(suit_binaries == 2)
suit_dummy[2] = sum(suit_binaries == 4)
suit_dummy[3] = sum(suit_binaries == 8)
suit_dummy_std = (suit_dummy - 1.5) / 2 # Hacky "standardisation"
return suit_dummy_std
def cards_to_suits(cards):
suit_dummy = np.zeros(4)
suit_binaries = np.array([Card.get_suit_int(x) for x in cards])
suit_dummy[0] = sum(suit_binaries == 1)
suit_dummy[1] = sum(suit_binaries == 2)
suit_dummy[2] = sum(suit_binaries == 4)
suit_dummy[3] = sum(suit_binaries == 8)
suit_dummy_std = (suit_dummy - 1.5) / 2 # Hacky "standardisation"
return suit_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_suit_dummies(self, hero_player):
card_dummies = []
for x in hero_player.hand:
suit_int = Card.get_suit_int(x)
suit_int = np.array(suit_int).reshape(-1, 1)
suit_dummies = self.suit_enc.transform(suit_int).toarray()[:, :-1]
card_dummies.append(suit_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 make_board_suit_dummies(self, table):
card_dummies = []
table_card_suits = self.table_card_suits[:]
for idx, x in enumerate(table.board):
suit_int = Card.get_suit_int(x)
table_card_suits[idx] = suit_int
for x in table_card_suits:
x = np.array(x).reshape(-1, 1)
suit_dummies = self.suit_enc.transform(x).toarray()[:, :-1]
card_dummies.append(suit_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 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 get_card_suit(self, card):
return Card.get_suit_int(card)
def suits(self):
"""Return a list of the cards' suits, in order."""
return [Card.INT_SUIT_TO_CHAR_SUIT[Card.get_suit_int(card)] for card in self._cards]
def hand_is_suited(self):
return Card.get_suit_int(self._cards[0]) == Card.get_suit_int(
self._cards[1])
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)
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 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 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_pokers(self):
res = []
for poker in self.pokers:
res.append((Card.get_rank_int(poker), Card.get_suit_int(poker)))
return res
