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 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 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_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 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))