def has_suited_pockets(self, player_index):
if Card.get_suit_int(
self.pocket_cards[player_index][0]) == Card.get_suit_int(
self.pocket_cards[player_index][1]):
return True
else:
return False
def _get_observation(self, player):
keys = ['position', 'state', 'stack', 'money_in_pot', 'bet_this_street', 'all_in']
values = [
[other.position, other.state, other.stack, other.money_in_pot, other.bet_this_street, other.all_in]
for other in self.players if other is not player
]
return {
'self': {
'position': player.position,
'cards': [[Card.get_suit_int(card), Card.get_rank_int(card)] for card in player.cards],
'stack': player.stack,
'money_in_pot': player.money_in_pot,
'bet_this_street': player.bet_this_street,
},
'table': {
'street': int(self.street),
'cards': [[Card.get_suit_int(card), Card.get_rank_int(card)] for card in self.cards],
'pot': self.pot,
'bet_to_match': self.bet_to_match,
'minimum_raise': self.minimum_raise,
},
'others': [
{
key: val
for key, val in zip(keys, value)
}
for value in values
]
}
def eval_trick_winner(self):
trumps = []
for card in self.playedCards:
if Card.get_suit_int(card) == self.trumps:
trumps.append(card)
trumps.sort(reverse=True)
if len(trumps) > 0:
bestCard = trumps[0]
else:
leadSuits = []
for card in self.playedCards:
if Card.get_suit_int(card) == self.leadSuit:
leadSuits.append(card)
leadSuits.sort(reverse=True)
bestCard = leadSuits[0]
winnerIndex = self.playedCards.index(bestCard)
winner = self.playerOrder[winnerIndex]
winner.trickCount += 1
print('\n', winner.name, ' wins the trick with ',
Card.print_pretty_card(bestCard))
self.leadPlayer = winner
self.playedCards = []
def find_swap(hand):
s1 = Card.get_suit_int(hand[0])
s2 = Card.get_suit_int(hand[1])
if (s1 == s2):
if (s1 == 1):
return 0 #both are spades, do nothing
else:
return [int_to_char[s1] + 's'] #swap with spades
elif (s1 == 1 or s2 == 1):
if (s1 == 1):
if (s2 != 2):
return [int_to_char[s2] + 'h']
else:
return 0
else:
#some suit with spade
if (s1 != 2):
return [int_to_char[s1] + 'h', 'hs']
else:
#heart and spade
return ['hs']
elif (s1 == 2 or s2 == 2): #no spades, hearts and something else
if (s1 == 2):
return [int_to_char[s2] + 's', 'sh']
else:
return [int_to_char[s1] + 's']
else:
return [int_to_char[s1] + 's', int_to_char[s2] + 'h']
def split_by_suit(cards):
spades = []
hearts = []
diamonds = []
clubs = []
for card in cards:
if Card.get_suit_int(card)==1:
spades.append(card)
elif Card.get_suit_int(card)==2:
hearts.append(card)
elif Card.get_suit_int(card)==4:
diamonds.append(card)
elif Card.get_suit_int(card)==8:
clubs.append(card)
else:
return 'Card suit ERROR'
all_suits = [spades,hearts,diamonds,clubs]
suit_split = []
for suit in all_suits:
if len(suit)>0:
suit_split.append(suit)
suit_split.sort(key=len, reverse=True)
return suit_split
def is_flush(cards):
suit = Card.get_suit_int(cards[0])
is_flush = True
for card in cards:
if Card.get_suit_int(card) != suit:
is_flush = False
break
return is_flush
def __construct_preflop_key(self, card_strs):
cards = sorted(Card.hand_to_binary(card_strs), reverse=True)
#print Card.print_pretty_cards(cards)
key = ''.join([Card.int_to_str(card)[0] for card in cards])
if Card.get_suit_int(cards[0]) == Card.get_suit_int(cards[1]):
key = key + "s"
else:
key = key + "o"
return key
def _get_valid_hand_cards(self, playing_cards, hand_cards):
valid_hand_cards = hand_cards
if len(playing_cards) > 0:
trick_suit = Card.get_suit_int(playing_cards[0])
valid_hand_cards = [
c for c in hand_cards if Card.get_suit_int(c) == trick_suit
]
if len(valid_hand_cards) == 0:
valid_hand_cards = hand_cards
return valid_hand_cards
def do_swap(card, swap):
char_one = swap[0]
char_two = swap[1]
if (Card.get_suit_int(card) == char_to_int[char_one]):
return Card.new(rank_int_to_char[Card.get_rank_int(card)] + char_two)
else:
return card
def get_card_real_suit_int(self, card):
suit = Card.get_suit_int(card)
if suit == 1:
return 1
elif suit == 2:
return 2
elif suit == 4:
return 3
elif suit == 8:
return 4
def move(self, observation):
# for Lookaheadplaystrategy
if self._first_action_card is not None:
first_action_card = self._first_action_card
self._first_action_card = None
return first_action_card
number_of_playing_ids = len(observation['playing_ids'])
valid_hand_cards = observation['valid_hand_cards']
playing_cards = observation['playing_cards']
valid_hand_ranks = [Card.get_rank_int(c) for c in valid_hand_cards]
min_card_id = valid_hand_ranks.index(min(valid_hand_ranks))
max_card_id = valid_hand_ranks.index(max(valid_hand_ranks))
# if i am last player in this trick
if number_of_playing_ids == observation['number_of_players'] - 1:
first_suit = Card.get_suit_int(playing_cards[0])
competitor_ranks = [
Card.get_rank_int(c) for c in playing_cards
if Card.get_suit_int(c) == first_suit
]
max_suit = Card.get_suit_int(valid_hand_cards[max_card_id])
punish_score = self._evaluator.calculate_score(playing_cards)
# we do not have same suit card, so just drop max card. it does not get punish score
if (max_suit != first_suit) or (punish_score == 0):
return valid_hand_cards[max_card_id]
# we will be the looser in this round, so just drop max card.
elif valid_hand_ranks[min_card_id] > max(competitor_ranks):
return valid_hand_cards[max_card_id]
# drop the card which is not larger then biggest playing card.
else:
max_safe_card_id = min_card_id
max_safe_rank = valid_hand_ranks[min_card_id]
max_competitor_ranks = max(competitor_ranks)
for tmp_card_id, r in enumerate(valid_hand_ranks):
if (r < max_competitor_ranks) and (r > max_safe_rank):
max_safe_rank = r
max_safe_card_id = tmp_card_id
return valid_hand_cards[max_safe_card_id]
# otherwise
else:
return valid_hand_cards[min_card_id]
def card_to_total_index(c):
suit = Card.get_suit_int(c)
# keeping 1 as is
if suit == 2:
suit = 0
elif suit == 4:
suit = 2
elif suit == 8:
suit = 3
return Card.get_rank_int(c)*(suit+1)
def move(self, observation):
number_of_playing_ids = len(observation['playing_ids'])
valid_hand_cards = observation['valid_hand_cards']
playing_cards = observation['playing_cards']
valid_hand_ranks = [Card.get_rank_int(c) for c in valid_hand_cards]
min_card_id = valid_hand_ranks.index(min(valid_hand_ranks))
max_card_id = valid_hand_ranks.index(max(valid_hand_ranks))
# if i am last player in this trick
if number_of_playing_ids == observation['number_of_players'] - 1:
first_suit = Card.get_suit_int(playing_cards[0])
competitor_ranks = [
Card.get_rank_int(c) for c in playing_cards
if Card.get_suit_int(c) == first_suit
]
max_suit = Card.get_suit_int(valid_hand_cards[max_card_id])
punish_score = self._evaluator.calculate_score(playing_cards)
# we do not have same suit card, so just drop max card. it does not get punish score
if (max_suit != first_suit) or (punish_score == 0):
return valid_hand_cards[max_card_id]
# we will be the looser in this round, so just drop max card.
elif valid_hand_ranks[min_card_id] > max(competitor_ranks):
return valid_hand_cards[max_card_id]
# drop the card which is not larger then biggest playing card.
else:
max_safe_card_id = min_card_id
max_safe_rank = valid_hand_ranks[min_card_id]
max_competitor_ranks = max(competitor_ranks)
for tmp_card_id, r in enumerate(valid_hand_ranks):
if (r < max_competitor_ranks) and (r > max_safe_rank):
max_safe_rank = r
max_safe_card_id = tmp_card_id
return valid_hand_cards[max_safe_card_id]
# apply monte carlo sampling to estimate win rate of valid hand cards
else:
simulated_scores = [
self._simulate(card, observation) for card in valid_hand_cards
]
best_card_id = simulated_scores.index(min(simulated_scores))
return valid_hand_cards[best_card_id]
def preflop(self):
score = 0
highest_card = max(Card.get_rank_int(self.hand[0]),
Card.get_rank_int(self.hand[1]))
if highest_card == 12:
score += 10
elif highest_card == 11:
score += 8
elif highest_card == 10:
score += 7
elif highest_card == 9:
score += 6
elif highest_card <= 8:
score += highest_card / 2 + 1
if Card.get_rank_int(self.hand[0]) == Card.get_rank_int(self.hand[1]):
score = score * 2
if score < 5:
score = 5
if Card.get_suit_int(self.hand[0]) == Card.get_suit_int(self.hand[1]):
score += 2
if abs(
Card.get_rank_int(self.hand[0]) -
Card.get_rank_int(self.hand[1])) == 2:
score -= 1
elif abs(
Card.get_rank_int(self.hand[0]) -
Card.get_rank_int(self.hand[1])) == 3:
score -= 2
elif abs(
Card.get_rank_int(self.hand[0]) -
Card.get_rank_int(self.hand[1])) == 4:
score -= 4
elif abs(
Card.get_rank_int(self.hand[0]) -
Card.get_rank_int(self.hand[1])) >= 5:
score -= 5
if abs(Card.get_rank_int(self.hand[0]) - Card.get_rank_int(self.hand[1])) <= 2 \
and highest_card < 10:
score += 1
return math.ceil(score)
def available_moves(self, player):
if self.leadPlayer == player:
return player.cards
else:
lsCards = []
for card in player.cards:
if Card.get_suit_int(card) == self.leadSuit:
lsCards.append(card)
if lsCards == []:
return player.cards
else:
return lsCards
def transferCard(cards):
try:
result = []
for i in cards:
rank = Card.get_rank_int(i)
suit = Card.get_suit_int(i)
suit = int(math.log2(suit))
result.append(suit * 13 + rank)
print('cards = ', result)
one_hot_encoding = np.zeros(52)
one_hot_encoding[result] += 1
except Exception as e:
print(cards)
one_hot_encoding = np.zeros(52)
return one_hot_encoding
def convertCardToString(card):
intSuit = Card.get_suit_int(
card) # Spade = 1, heart = 2, diamond = 4, club = 8
intRank = Card.get_rank_int(
card
) # 2 = 0, 3 = 1, 4 = 2, 5 = 3, 6 = 4, 7 = 5, 8 = 6,... J = 9, ... A = 12
cardString = ""
if (intRank < 8):
cardString = str(intRank + 2)
elif (intRank == 8):
cardString = "T"
elif (intRank == 9):
cardString = "J"
elif (intRank == 10):
cardString = "Q"
elif (intRank == 11):
cardString = "K"
elif (intRank == 12):
cardString = "A"
else:
raise Exception(
'intRank should not exceed 12. The value of intRank was: {}'.
format(intRank))
if (intSuit == 1):
cardString = cardString + "s"
elif (intSuit == 2):
cardString = cardString + "h"
elif (intSuit == 4):
cardString = cardString + "d"
elif (intSuit == 8):
cardString = cardString + "c"
else:
raise Exception(
'intSuit bad. The value of intSuit was: {}'.format(intSuit))
return cardString
def update_trumps(self):
self.trumps = Card.get_suit_int(self.trumpCard)
def suit(self):
suit_int = Card.get_suit_int(self._card)
return Card.INT_SUIT_TO_CHAR_SUIT[suit_int]
def purge_offsuits(item):
a, b = item
return Card.get_suit_int(a) == Card.get_suit_int(b)
def GetCardInt(self, card):
card_suit = Card.get_suit_int(card) - 1
if card_suit == 7: #Treys Clubs suit == 8-> From line above, if clubs, card_suit == 7 (Club_Suit-1 --> 8 - 1 == 7)
card_suit = 2 #Correct the fact clubs suit should == 3, from first line (clubs_int - 1 == 2)
return str((13 * card_suit) + Card.get_rank_int(card))
def pretty_print_hand(hand_cards, hand_type, table_cards, kicker):
combined = []
combined.extend(hand_cards)
combined.extend(table_cards)
values = [Card.get_rank_int(c) for c in combined]
suits = [Card.get_suit_int(c) for c in combined]
suit_ints = [1, 2, 4, 8]
if hand_type == 'High Card':
return 'High card %s' % singulars[max(values)]
if hand_type == 'Pair':
doubles = []
for k, v in Counter(values).items():
doubles.extend([k] * (v // 2))
return 'a pair of %s' % plurals[max(doubles)]
if hand_type == 'Two Pair':
doubles = []
for k, v in Counter(values).items():
doubles.extend([k] * (v // 2))
first = max(doubles)
doubles.remove(first)
second = max(doubles)
return 'two pair, %s and %s' % (plurals[first], plurals[second])
if hand_type == 'Three of a Kind':
triples = []
for k, v in Counter(values).items():
triples.extend([k] * (v // 3))
return 'three of a kind, %s' % plurals[max(triples)]
if hand_type == 'Straight':
# TODO: Fix this mess
previous_value = None
high = None
low = None
sequence = 1
for value in reversed(sorted(set(values))):
if previous_value is None:
previous_value = value
high = value
continue
elif value == previous_value - 1:
sequence += 1
if sequence == 4 and value == 0:
if 12 in values:
low = value
break
else:
sequence = 1
high = value
if sequence == 5:
low = value
break
previous_value = value
return 'a straight, %s to %s' % (singulars[low], singulars[high])
if hand_type == 'Flush':
# TODO: Fix this mess
counts = np.array(
[len([suit for suit in suits if suit == i]) for i in suit_ints])
suit_i = int(np.argmax(counts))
high = max([
values[i] for i in range(len(values))
if suits[i] == suit_ints[suit_i]
])
return 'a flush, %s high' % singulars[high]
if hand_type == 'Full House':
triples = []
for k, v in Counter(values).items():
triples.extend([k] * (v // 3))
doubles = []
for k, v in Counter(values).items():
doubles.extend([k] * (v // 2))
return 'a full house, %s full of %s' % (plurals[max(triples)],
plurals[max(doubles)])
if hand_type == 'Four of a Kind':
quads = []
for k, v in Counter(values).items():
quads.extend([k] * (v // 4))
return 'four of a kind, %s' % plurals[max(quads)]
if hand_type == 'Straight Flush':
# TODO: Fix this mess
counts = np.array(
[len([suit for suit in suits if suit == i]) for i in suit_ints])
suit_i = int(np.argmax(counts))
correct_suit = [
values[i] for i in range(len(values))
if suits[i] == suit_ints[suit_i]
]
previous_value = None
high = None
low = None
sequence = 1
for value in reversed(sorted(set(correct_suit))):
if previous_value is None:
previous_value = value
high = value
continue
elif value == previous_value - 1:
sequence += 1
if sequence == 4 and value == 0:
if 12 in correct_suit:
low = value
break
else:
sequence = 1
high = value
if sequence == 5:
low = value
break
previous_value = value
return 'royal flush, %s to %s' % (singulars[low], singulars[high])
raise Exception("Incorrect hand/table passed to pretty_print_hand")
def update_lead_suit(self):
if self.playedCards == []:
pass
else:
self.leadSuit = Card.get_suit_int(self.playedCards[0])
