def hint_first_free_card(self, round_info, player_number):
original_player_number = player_number
player_number = utils.next_player_number(round_info,
original_player_number)
while player_number is not original_player_number:
if player_number is round_info.player_turn:
player_hand = round_info.true_hand_info()
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
for card in player_hand:
if card.revealed_rank is None:
return ChoiceDetails(
Choice.HINT, HintDetails(player_number,
card.real_rank))
elif card.revealed_suit is None:
return ChoiceDetails(
Choice.HINT, HintDetails(player_number,
card.real_suit))
player_number = utils.next_player_number(round_info, player_number)
player_number = utils.next_player_number(round_info,
original_player_number)
player_hand = utils.get_player_hand_by_number(round_info,
player_number)
for card in player_hand:
return ChoiceDetails(Choice.HINT,
HintDetails(player_number, card.real_rank))
def check_for_hint(self, round_info, player_number):
if round_info.hints <= 1:
return False
original_player_number = player_number
player_number = utils.next_player_number(round_info,
original_player_number)
hinted_plays = {}
while player_number is not original_player_number:
hinted_plays[player_number] = {}
for suit in utils.Suit:
hinted_plays[player_number][suit] = {}
for rank in utils.Rank:
hinted_plays[player_number][suit][rank] = 0
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
for card in player_hand:
if round_info.board_state[card.real_suit] < card.real_rank.value and \
(card.revealed_rank is not None or card.revealed_suit is not None):
hinted_plays[player_number][card.real_suit][
card.real_rank] += 1
player_number = utils.next_player_number(round_info, player_number)
player_number = utils.next_player_number(round_info,
original_player_number)
best_hint_player = None
best_hint_rank = 6
best_hint_type = None
while player_number is not original_player_number:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
for card in player_hand:
already_hinted = False
for player in hinted_plays:
if player is not player_number and hinted_plays[player][
card.real_suit][card.real_rank] is not 0:
already_hinted = True
if round_info.board_state[card.real_suit] < card.real_rank.value < best_hint_rank and \
not already_hinted:
if card.revealed_rank is None:
best_hint_player = player_number
best_hint_rank = card.real_rank.value
best_hint_type = card.real_rank
elif card.revealed_suit is None:
best_hint_player = player_number
best_hint_rank = card.real_rank.value
best_hint_type = card.real_suit
player_number = utils.next_player_number(round_info, player_number)
if best_hint_player is not None:
return ChoiceDetails(Choice.HINT,
HintDetails(best_hint_player, best_hint_type))
return False
def initialize_variables(self, round_info):
self.remaining = utils.list_remaining_playable_cards(round_info)
self.point_of_uselessness = {}
for suit in utils.Suit:
self.point_of_uselessness[suit] = None
for rank in utils.Rank:
if round_info.board_state[suit] < rank.value:
if self.point_of_uselessness[suit] is None and self.remaining[suit][rank] == 0:
self.point_of_uselessness[suit] = rank
original_player_number = round_info.player_turn
player_number = utils.next_player_number(round_info, original_player_number)
oldest_age = -1
for card in round_info.player_hand:
card_age = round_info.current_turn - card.drawn_on_turn
if card_age > oldest_age:
oldest_age = card_age
self.oldest_card[original_player_number] = card.hand_position
while player_number is not original_player_number:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
oldest_age = -1
for card in player_hand:
card_age = round_info.current_turn - card.drawn_on_turn
if card_age > oldest_age:
oldest_age = card_age
self.oldest_card[player_number] = card.hand_position
player_number = utils.next_player_number(round_info, player_number)
def check_for_obvious_play(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
board_state_stars_align = round_info.board_state[utils.Suit.BLUE] + 1
prev = False
for suit in round_info.board_state:
if prev is not False and round_info.board_state[suit] is not prev:
board_state_stars_align = -1
prev = round_info.board_state[suit]
best_card = -1
best_card_rank = 6
for card in player_hand:
if (card.is_playable(round_info) or
(card.revealed_rank is not None and card.revealed_rank.value is board_state_stars_align)) and \
card.revealed_rank.value < best_card_rank:
best_card = card.hand_position
best_card_rank = card.revealed_rank.value
if best_card >= 0:
return ChoiceDetails(
Choice.PLAY,
best_card
)
return False
def check_for_play(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.true_hand_info()
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
known = self.list_all_known_cards(round_info, player_number)
best_card = -1
chain_bonus = False
best_card_rank = 6
for card in player_hand:
if round_info.board_state[
card.real_suit] + 1 is card.real_rank.value:
new_chain = False
if card.real_rank.value <= 4 and known[card.real_suit][
utils.Rank(card.real_rank.value + 1)] > 0:
new_chain = True
if (chain_bonus and new_chain and card.real_rank.value < best_card_rank) or \
(not chain_bonus and (new_chain or card.real_rank.value < best_card_rank)):
best_card = card.hand_position
best_card_rank = card.real_rank.value
chain_bonus = new_chain
if best_card >= 0:
return ChoiceDetails(Choice.PLAY, best_card)
return False
def check_for_discard_tip(self, round_info, player_number, hint_pass_score=2.5, distance_to_player_multiplier=0.99):
original_player_number = player_number
player_number = utils.next_player_number(round_info, original_player_number)
potential_discardable_ranks = {}
potential_discardable_suits = {}
while player_number is not original_player_number:
potential_discardable_ranks[player_number] = {}
potential_discardable_suits[player_number] = {}
for rank in utils.Rank:
potential_discardable_ranks[player_number][rank] = []
for suit in utils.Suit:
potential_discardable_suits[player_number][suit] = []
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
if round_info.board_state[card.real_suit] >= card.real_rank.value:
if card.revealed_suit is None:
potential_discardable_suits[player_number][card.real_suit].append(card)
if card.revealed_rank is None:
potential_discardable_ranks[player_number][card.real_rank].append(card)
player_number = utils.next_player_number(round_info, player_number)
max_player_number = 0
max_potential = 0
max_hint = 0
def check_card_potential(card, player):
player_distance = player - original_player_number - 1
if player_distance < 0:
player_distance += round_info.number_of_players
card_potential = pow(distance_to_player_multiplier, player_distance)
return card_potential
for player in potential_discardable_ranks:
for rank in potential_discardable_ranks[player]:
potential = 0
for card in potential_discardable_ranks[player][rank]:
potential += check_card_potential(card, player)
if potential > max_potential:
max_player_number = player
max_potential = potential
max_hint = rank
for suit in potential_discardable_suits[player]:
potential = 0
for card in potential_discardable_suits[player][suit]:
potential += check_card_potential(card, player)
if potential > max_potential:
max_player_number = player
max_potential = potential
max_hint = suit
if max_potential >= hint_pass_score:
return ChoiceDetails(
Choice.HINT,
HintDetails(max_player_number, max_hint)
)
return False
def check_for_forced_discard(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.true_hand_info()
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
known = self.list_all_known_cards(round_info, player_number)
remaining = utils.list_remaining_playable_cards(round_info)
for card in player_hand:
if known[card.real_suit][card.real_rank] > 1:
return ChoiceDetails(Choice.DISCARD, card.hand_position)
for card in player_hand:
if remaining[card.real_suit][card.real_rank] > 1:
return ChoiceDetails(Choice.DISCARD, card.hand_position)
best_card_rank = -1
best_card = None
for card in player_hand:
if card.real_rank.value > best_card_rank:
best_card = card.hand_position
best_card_rank = card.real_rank.value
return ChoiceDetails(Choice.DISCARD, best_card)
def check_for_discard(self, round_info, player_number):
if round_info.hints is utils.MAX_HINTS:
return False
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
unmarked = []
for card in player_hand:
if card.revealed_rank is None and card.revealed_suit is None:
unmarked.append(card)
if len(unmarked) is 0:
for card in player_hand:
if card.revealed_rank is None or card.revealed_suit is None:
unmarked.append(card)
if len(unmarked) is 0:
unmarked = player_hand
return ChoiceDetails(Choice.DISCARD,
random.choice(unmarked).hand_position)
def check_for_discard(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
return ChoiceDetails(Choice.DISCARD,
random.choice(player_hand).hand_position)
def check_for_obvious_discard(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
answer = self.check_card_usefulness(round_info, card)
if answer is not False:
return answer
return False
def check_for_play(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
for card in player_hand:
if card.revealed_rank is not None and card.revealed_suit is not None and \
round_info.board_state[card.revealed_suit] + 1 is card.revealed_rank.value:
return ChoiceDetails(Choice.PLAY, card.hand_position)
return False
def check_for_hint(self, round_info, player_number):
if round_info.hints is 0:
return False
players = list(range(0, round_info.number_of_players))
random.shuffle(players)
for player in players:
if player is not player_number:
hand = deepcopy(
utils.get_player_hand_by_number(round_info, player))
hand.shuffle()
for card in hand:
if random.randint(0, 1) is 0:
if card.revealed_rank is None:
return ChoiceDetails(
Choice.HINT,
HintDetails(player, card.real_rank))
elif card.revealed_suit is None:
return ChoiceDetails(
Choice.HINT,
HintDetails(player, card.real_suit))
else:
if card.revealed_suit is None:
return ChoiceDetails(
Choice.HINT,
HintDetails(player, card.real_suit))
elif card.revealed_rank is None:
return ChoiceDetails(
Choice.HINT,
HintDetails(player, card.real_rank))
for player in players:
if player is not player_number:
hand = utils.get_player_hand_by_number(round_info, player)
for card in hand:
return ChoiceDetails(Choice.HINT,
HintDetails(player, card.real_suit))
def check_for_guess_discard(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
unmarked = []
for card in player_hand:
if card.revealed_rank is None and card.revealed_suit is None:
unmarked.append(card)
if len(unmarked) == 0:
known = utils.list_all_known_cards(round_info, player_number)[0]
remaining = utils.list_remaining_playable_cards(round_info)
discarded = utils.list_discarded_cards(round_info)
for card in player_hand:
if card.revealed_rank is None:
add = True
for rank in utils.Rank:
if round_info.board_state[card.revealed_suit] < rank.value and \
remaining[card.revealed_suit][rank] == 1 and \
known[card.revealed_suit][rank] - discarded[card.revealed_suit][rank] == 0:
add = False
if add:
unmarked.append(card)
elif card.revealed_suit is None:
add = True
for suit in remaining:
if round_info.board_state[suit] < card.revealed_rank.value and \
remaining[suit][card.revealed_rank] == 1 and \
known[suit][card.revealed_rank] - discarded[suit][card.revealed_rank] == 0:
add = False
if add:
unmarked.append(card)
if len(unmarked) == 0:
unmarked = player_hand
oldest = unmarked[0]
for card in unmarked:
if card.drawn_on_turn < oldest.drawn_on_turn:
oldest = card
return ChoiceDetails(
Choice.DISCARD,
oldest.hand_position
)
def extrapolate_board_state(self, round_info, target_player):
player_number = utils.next_player_number(round_info, round_info.player_turn)
predicted_board_state = deepcopy(round_info.board_state)
while player_number is not target_player:
play = self.check_for_obvious_play(round_info, player_number)
if play is False:
play = self.check_for_hinted_play(round_info, player_number)
if play is not False:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
suit = player_hand[play[1]].real_suit
rank = player_hand[play[1]].real_rank
self.info("{0} {1}".format(suit, rank))
if suit is None or rank is None or predicted_board_state[suit] is rank.value - 1:
predicted_board_state[suit] += 1
player_number = utils.next_player_number(round_info, player_number)
return predicted_board_state
def check_for_obvious_discard(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
known = utils.list_all_known_cards(round_info)[0]
discarded = utils.list_discarded_cards(round_info)
remaining = utils.list_remaining_playable_cards(round_info)
for card in player_hand:
useless = False
if card.revealed_suit is not None:
useless = True
future_ranks_useless = False
for rank in utils.Rank:
if round_info.board_state[card.revealed_suit] < rank.value:
if not future_ranks_useless and remaining[card.revealed_suit][rank] - \
known[card.revealed_suit][rank] + discarded[card.revealed_suit][rank] > 0:
useless = False
else:
future_ranks_useless = True
if card.revealed_rank is not None:
useless = True
for suit in utils.Suit:
if round_info.board_state[suit] < card.revealed_rank.value:
if remaining[suit][card.revealed_rank] - known[suit][card.revealed_rank] + \
discarded[suit][card.revealed_rank] > 0:
useless = False
if card.revealed_suit is not None and card.revealed_rank is not None:
if round_info.board_state[card.revealed_suit] >= card.revealed_rank.value:
useless = True
if useless:
return ChoiceDetails(
Choice.DISCARD,
card.hand_position
)
return False
def list_all_known_cards(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.true_hand_info()
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
known = {}
for suit in utils.Suit:
known[suit] = {}
for rank in utils.Rank:
known[suit][rank] = 0
for card in player_hand:
if card.real_rank is not None and card.real_suit is not None:
known[card.real_suit][card.real_rank] += 1
for hand in round_info.other_players_hands:
if player_number is not hand.player_number:
for card in hand:
known[card.real_suit][card.real_rank] += 1
return known
def check_for_play_tip(self, round_info, player_number, hint_pass_score=0.9, double_hint_multiplier=0.3,
false_tip_penalty=-2.5, distance_to_player_multiplier=1.01, lower_rank_multiplier=1.07,
information_tip_value=0.2, already_has_play_multiplier=0.5, chain_bonus_multiplier=1.3,
only_next_player=False):
if round_info.hints <= 1:
return False
original_player_number = player_number
if player_number is round_info.player_turn:
original_player_hand = round_info.player_hand
else:
original_player_hand = utils.get_player_hand_by_number(round_info, player_number)
player_number = utils.next_player_number(round_info, original_player_number)
worth_hinting = {}
predicted_board_state = {original_player_number: deepcopy(round_info.board_state)}
while player_number is not original_player_number:
predicted_board_state[player_number] = deepcopy(
predicted_board_state[utils.prev_player_number(round_info, player_number)])
worth_hinting[player_number] = False
play = self.check_for_obvious_play(round_info, player_number)
if play is False:
play = self.check_for_hinted_play(round_info, player_number)
if play is False:
worth_hinting[player_number] = True
if play is not False:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
suit = player_hand[play[1]].real_suit
rank = player_hand[play[1]].real_rank
if predicted_board_state[player_number][suit] is rank.value - 1:
predicted_board_state[player_number][suit] += 1
player_number = utils.next_player_number(round_info, player_number)
player_number = original_player_number
hinted_plays = {}
first_time = True
while player_number is not original_player_number or first_time:
first_time = False
hinted_plays[player_number] = {}
for suit in utils.Suit:
hinted_plays[player_number][suit] = {}
for rank in utils.Rank:
hinted_plays[player_number][suit][rank] = 0
player_number = utils.next_player_number(round_info, player_number)
player_number = utils.next_player_number(round_info, original_player_number)
for card in original_player_hand:
if card.revealed_rank is not None and card.revealed_suit is not None and \
round_info.board_state[card.real_suit] < card.real_rank.value:
hinted_plays[original_player_number][card.real_suit][card.real_rank] += 1
while player_number is not original_player_number:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
if round_info.board_state[card.real_suit] < card.real_rank.value and \
(card.revealed_rank is not None or card.revealed_suit is not None):
hinted_plays[player_number][card.real_suit][card.real_rank] += 1
player_number = utils.next_player_number(round_info, player_number)
player_number = utils.next_player_number(round_info, original_player_number)
potential_playable_ranks = {}
potential_playable_suits = {}
while player_number is not original_player_number:
potential_playable_ranks[player_number] = {}
potential_playable_suits[player_number] = {}
for rank in utils.Rank:
potential_playable_ranks[player_number][rank] = []
for suit in utils.Suit:
potential_playable_suits[player_number][suit] = []
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
if card.revealed_suit is None:
potential_playable_suits[player_number][card.real_suit].append(card)
if card.revealed_rank is None:
potential_playable_ranks[player_number][card.real_rank].append(card)
player_number = utils.next_player_number(round_info, player_number)
max_player_number = 0
max_potential = -5
max_hint = 0
known = {}
for suit in utils.Suit:
known[suit] = {}
for rank in utils.Rank:
known[suit][rank] = 0
for card in original_player_hand:
if card.revealed_rank is not None and card.revealed_suit is not None:
known[card.revealed_suit][card.revealed_rank] += 1
for hand in round_info.other_players_hands:
if original_player_number is not hand.player_number:
for card in hand:
known[card.real_suit][card.real_rank] += 1
def check_card_potential(card, player, board_state, current_rank=None, pure_info=False):
player_distance = player - original_player_number - 1
if player_distance < 0:
player_distance += round_info.number_of_players
already_hinted = False
if card.revealed_suit is None and card.revealed_rank is None:
for players in hinted_plays:
if hinted_plays[players][card.real_suit][card.real_rank] != 0:
already_hinted = True
card_potential = pow(distance_to_player_multiplier, player_distance) *\
pow(lower_rank_multiplier, 5 - card.real_rank.value)
if (card.revealed_suit is not None or card.revealed_rank is not None) and \
card.real_rank.value - board_state[card.real_suit] <= 1 and \
self.card_hint_type[player][card.hand_position] == "Play":
card_potential *= double_hint_multiplier
if card.real_rank.value <= 4 and card.real_rank.value - board_state[card.real_suit] == 1 and \
known[card.real_suit][utils.Rank(card.real_rank.value + 1)] > 0:
card_potential *= chain_bonus_multiplier
if already_hinted:
card_potential += false_tip_penalty
if pure_info \
or (max(round_info.board_state.values()) < card.real_rank.value - 1 and current_rank is None) \
or (self.card_hint_type[player][card.hand_position] == "Information"):
card_potential = information_tip_value * pow(distance_to_player_multiplier, player_distance) * \
pow(lower_rank_multiplier, card.real_rank.value - 1)
if not already_hinted and \
card.real_rank.value - board_state[card.real_suit] == 1 and \
self.card_hint_type[player][card.hand_position] == "Information":
card_potential = pow(distance_to_player_multiplier, player_distance) * \
pow(lower_rank_multiplier, 5 - card.real_rank.value)
if card.real_rank.value <= 4 and card.real_rank.value - board_state[card.real_suit] == 1 and \
known[card.real_suit][utils.Rank(card.real_rank.value + 1)] > 0:
card_potential *= chain_bonus_multiplier
elif (card.revealed_suit is None and card.revealed_rank is None) and \
((current_rank is None and board_state[card.real_suit] is not card.real_rank.value - 1) or
(current_rank is not None and card.real_rank.value is not current_rank)):
card_potential += false_tip_penalty
if current_rank is not None and card.real_rank.value is current_rank:
current_rank += 1
return card_potential, current_rank
for player in potential_playable_ranks:
if debug and round_info.log:
self.info('{0}'.format(player))
info_rank = None
info_suit = None
player_distance = player - original_player_number - 1
if player_distance < 0:
player_distance += round_info.number_of_players
if player_distance == 0 or not only_next_player:
if player_distance == 0:
play = self.check_for_hinted_play(round_info, player)
target_hand = utils.get_player_hand_by_number(round_info, player)
if play is not False:
if target_hand[play[1]].revealed_rank is None:
info_rank = target_hand[play[1]].real_rank
if target_hand[play[1]].revealed_suit is None:
info_suit = target_hand[play[1]].real_suit
else:
play = self.check_for_guess_discard(round_info, player)
if target_hand[play[1]].revealed_rank is None:
info_rank = target_hand[play[1]].real_rank
if target_hand[play[1]].revealed_suit is None:
info_suit = target_hand[play[1]].real_suit
for rank in potential_playable_ranks[player]:
board_state = deepcopy(predicted_board_state[utils.prev_player_number(round_info, player)])
potential = 0
for card in potential_playable_ranks[player][rank]:
if rank is not info_rank:
answer = check_card_potential(card, player, board_state)[0]
else:
answer = check_card_potential(card, player, board_state, pure_info=True)[0]
if answer >= pow(distance_to_player_multiplier, player_distance) * \
pow(lower_rank_multiplier, 5 - card.real_rank.value):
board_state[card.real_suit] += 1
potential += answer
if not worth_hinting[player] and rank is not info_rank:
potential *= already_has_play_multiplier
if debug and round_info.log:
self.info('{0} {1}'.format(rank, potential))
if potential > max_potential:
max_player_number = player
max_potential = potential
max_hint = rank
board_state = deepcopy(predicted_board_state[utils.prev_player_number(round_info, player)])
for suit in potential_playable_suits[player]:
potential = 0
current_rank = board_state[suit] + 1
for card in potential_playable_suits[player][suit]:
if suit is not info_suit:
answer = check_card_potential(card, player, board_state, current_rank)
else:
answer = check_card_potential(card, player, board_state, current_rank, pure_info=True)
potential += answer[0]
current_rank = answer[1]
if not worth_hinting[player] and suit is not info_suit:
potential *= already_has_play_multiplier
if debug and round_info.log:
self.info('{0} {1}'.format(suit, potential))
if potential > max_potential:
max_player_number = player
max_potential = potential
max_hint = suit
if max_potential >= hint_pass_score:
return ChoiceDetails(
Choice.HINT,
HintDetails(max_player_number, max_hint)
)
return False
def check_for_play_tip(self, round_info, player_number, hint_pass_score=2, double_hint_multiplier=2.3,
distance_to_playable_multiplier=0.5, distance_to_player_multiplier=0.99,
lower_rank_multiplier=1.1):
if round_info.hints <= 1:
return False
original_player_number = player_number
player_number = utils.next_player_number(round_info, original_player_number)
hinted_plays = {}
while player_number is not original_player_number:
hinted_plays[player_number] = {}
for suit in utils.Suit:
hinted_plays[player_number][suit] = {}
for rank in utils.Rank:
hinted_plays[player_number][suit][rank] = 0
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
if round_info.board_state[card.real_suit] < card.real_rank.value and \
(card.revealed_rank is not None or card.revealed_suit is not None):
hinted_plays[player_number][card.real_suit][card.real_rank] += 1
player_number = utils.next_player_number(round_info, player_number)
player_number = utils.next_player_number(round_info, original_player_number)
potential_playable_ranks = {}
potential_playable_suits = {}
while player_number is not original_player_number:
potential_playable_ranks[player_number] = {}
potential_playable_suits[player_number] = {}
for rank in utils.Rank:
potential_playable_ranks[player_number][rank] = []
for suit in utils.Suit:
potential_playable_suits[player_number][suit] = []
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
already_hinted = False
for player in hinted_plays:
if player is not player_number and hinted_plays[player][card.real_suit][card.real_rank] != 0:
already_hinted = True
if round_info.board_state[card.real_suit] < card.real_rank.value and not already_hinted:
if card.revealed_suit is None:
potential_playable_suits[player_number][card.real_suit].append(card)
if card.revealed_rank is None:
potential_playable_ranks[player_number][card.real_rank].append(card)
player_number = utils.next_player_number(round_info, player_number)
max_player_number = 0
max_potential = 0
max_hint = 0
def check_card_potential(card, player):
player_distance = player - original_player_number - 1
if player_distance < 0:
player_distance += round_info.number_of_players
card_potential = \
pow(distance_to_playable_multiplier,
card.real_rank.value - round_info.board_state[card.real_suit] - 1) * \
pow(distance_to_player_multiplier, player_distance) * \
pow(lower_rank_multiplier, 5-card.real_rank.value)
if (card.revealed_suit is not None or card.revealed_rank is not None) and \
card.real_rank.value - round_info.board_state[card.real_suit] == 1:
card_potential *= double_hint_multiplier
return card_potential
for player in potential_playable_ranks:
if debug:
self.info('{0}'.format(player))
for rank in potential_playable_ranks[player]:
potential = 0
for card in potential_playable_ranks[player][rank]:
potential += check_card_potential(card, player)
if debug:
self.info('{0} {1}'.format(rank, potential))
if potential > max_potential:
max_player_number = player
max_potential = potential
max_hint = rank
for suit in potential_playable_suits[player]:
potential = 0
for card in potential_playable_suits[player][suit]:
potential += check_card_potential(card, player)
if debug:
self.info('{0} {1}'.format(suit, potential))
if potential > max_potential:
max_player_number = player
max_potential = potential
max_hint = suit
if max_potential >= hint_pass_score:
return ChoiceDetails(
Choice.HINT,
HintDetails(max_player_number, max_hint)
)
return False
def check_for_hinted_play(self, round_info, player_number):
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
alignment_delta = 2
max_hint_size = 10
if round_info.lives == 1:
alignment_delta = 0
max_hint_size = 1
hinted_ranks = {}
hinted_suits = {}
for suit in utils.Suit:
hinted_suits[suit] = 0
for rank in utils.Rank:
hinted_ranks[rank] = 0
for x in range(0, len(player_hand)):
if player_hand[x].revealed_suit is not None and player_hand[x].revealed_rank is None and \
self.card_hint_type[player_number][x] == "Play":
hinted_suits[player_hand[x].revealed_suit] += 1
if player_hand[x].revealed_rank is not None and player_hand[x].revealed_suit is None and \
self.card_hint_type[player_number][x] == "Play":
hinted_ranks[player_hand[x].revealed_rank] += 1
known = utils.list_all_known_cards(round_info, player_number)[0]
remaining = utils.list_remaining_playable_cards(round_info)
discarded = utils.list_discarded_cards(round_info)
best_hint = -1
best_hint_size = max_hint_size
best_alignment = 0
hint_type = None
for suit in hinted_suits:
if 0 < hinted_suits[suit] <= best_hint_size:
rank = round_info.board_state[suit] + 1
if rank <= 5:
rank_rank = utils.Rank(rank)
if remaining[suit][rank_rank] - known[suit][rank_rank] + discarded[suit][rank_rank] > 0:
best_hint = suit
best_hint_size = hinted_suits[suit]
best_alignment = 1
hint_type = 'suit'
board_alignment = {}
for rank in utils.Rank:
board_alignment[rank] = 0
for suit in round_info.board_state:
rank = round_info.board_state[suit] + 1
if rank <= 5:
rank_rank = utils.Rank(rank)
if remaining[suit][rank_rank] - known[suit][rank_rank] + discarded[suit][rank_rank] > 0:
board_alignment[rank_rank] += 1
for rank in hinted_ranks:
if 0 < board_alignment[rank] and ((0 < hinted_ranks[rank] < best_hint_size) or
(0 < hinted_ranks[rank] <= best_hint_size and best_alignment <
board_alignment[rank])):
best_hint = rank
best_hint_size = hinted_ranks[rank]
best_alignment = board_alignment[rank]
hint_type = 'rank'
if best_hint != -1 and best_hint_size <= best_alignment + alignment_delta:
for x in range(0, len(player_hand)):
if hint_type == 'rank':
if player_hand[x].revealed_rank is not None and player_hand[x].revealed_suit is None and \
player_hand[x].revealed_rank is best_hint and \
self.card_hint_type[player_number][x] == "Play":
return ChoiceDetails(
Choice.PLAY,
x
)
else:
if player_hand[x].revealed_suit is not None and player_hand[x].revealed_rank is None and \
player_hand[x].revealed_suit is best_hint and \
self.card_hint_type[player_number][x] == "Play":
return ChoiceDetails(
Choice.PLAY,
x
)
return False
def check_for_necessary_tip(self, round_info, player_number):
if round_info.hints == 0 or round_info.hints == utils.MAX_HINTS:
return False
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
remaining = utils.list_remaining_playable_cards(round_info)
next_player_hand = utils.next_player_hand(round_info, player_number)
next_player_number = utils.next_player_number(round_info, player_number)
if self.check_for_obvious_play(round_info, next_player_number) is not False:
return False
distrust = False
play = self.check_for_hinted_play(round_info, next_player_number)
if play is not False:
play_position = play[1]
played_card = next_player_hand[play_position]
if round_info.board_state[played_card.real_suit] is not played_card.real_rank.value - 1:
distrust = True
own_play = None
if self.check_for_obvious_play(round_info, player_number) is not False:
own_play = self.check_for_obvious_play(round_info, player_number)[1]
if own_play is None and self.check_for_hinted_play(round_info, player_number) is not False:
own_play = self.check_for_hinted_play(round_info, player_number)[1]
if own_play is not None and \
round_info.board_state[played_card.real_suit] is played_card.real_rank.value - 2:
own_card = player_hand[own_play]
if (own_card.revealed_rank is not None and
own_card.revealed_rank.value is played_card.real_rank.value - 1) or \
(own_card.revealed_suit is not None and
own_card.revealed_suit is played_card.real_suit):
distrust = False
else:
if self.check_for_obvious_discard(round_info, next_player_number) is False:
played_position = self.check_for_guess_discard(round_info, next_player_number)[1]
played_card = next_player_hand[played_position]
if round_info.board_state[played_card.real_suit] < played_card.real_rank.value and \
remaining[played_card.real_suit][played_card.real_rank] == 1 and \
self.check_card_usefulness(round_info, played_card) is False:
distrust = True
if distrust:
if debug and round_info.log:
self.info("good_tip:")
answer = self.check_for_good_tip(round_info, player_number, only_next_player=True)
if answer is False:
if debug and round_info.log:
self.info("risky_tip:")
answer = self.check_for_risky_tip(round_info, player_number, only_next_player=True)
if answer is not False:
return answer
if played_card.revealed_rank is None:
return ChoiceDetails(
Choice.HINT,
HintDetails(utils.next_player_number(round_info, player_number), played_card.real_rank)
)
else:
return ChoiceDetails(
Choice.HINT,
HintDetails(utils.next_player_number(round_info, player_number), played_card.real_suit)
)
return False
def read_board(self, round_info, player_number):
self.known = utils.list_others_cards(round_info, player_number)
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
play_actions = []
for card in player_hand:
play_actions.append(self.read_own_card(round_info, card))
hint_actions = []
if round_info.hints > 0:
hint_actions = self.read_others_hands(round_info, player_number)
used_actions = []
used_hints = []
max_of_weights = -1
used_play = None
for play in play_actions:
if round_info.log and debug:
self.info("{0} {1} {2} {3}".format(play[0], play[1][0][0],
self.get_chance(play[1][0]), play[2]))
sum_of_weights = self.get_chance(play[1][0])
if sum_of_weights > max_of_weights:
max_of_weights = sum_of_weights
used_play = play
used_actions.append(used_play)
max_of_weights = -1
used_play = None
for play in play_actions:
if round_info.log and debug:
self.info("{0} {1} {2} {3}".format(play[0], play[1][1][0],
self.get_chance(play[1][1]), play[2]))
sum_of_weights = self.get_chance(play[1][1])
if sum_of_weights >= max_of_weights:
max_of_weights = sum_of_weights
used_play = play
used_actions.append(used_play)
if round_info.hints > 0:
max_of_weights = -1
used_hint = None
for hint in hint_actions:
if round_info.log and debug:
self.info("{0} {1} {2} {3} {4}".format(hint[0], hint[1][0][0],
self.get_chance(hint[1][0]),
hint[2], hint[3]))
sum_of_weights = self.get_chance(hint[1][0])
if sum_of_weights > max_of_weights:
max_of_weights = sum_of_weights
used_hint = hint
used_hints.append(used_hint)
if len(used_hints) > 0 and used_hints[0] is None:
used_hints = []
macro_weights = self.decide_macro_action(round_info, used_actions, used_hints)
macro_max = 0
macro_action = "Discard"
sum_of_weights = self.get_chance(macro_weights[1][0])
if macro_max < sum_of_weights:
macro_max = sum_of_weights
macro_action = "Play"
sum_of_weights = self.get_chance(macro_weights[1][1])
if macro_max < sum_of_weights:
macro_max = sum_of_weights
macro_action = "Discard"
sum_of_weights = self.get_chance(macro_weights[1][2])
if macro_max < sum_of_weights and round_info.hints > 0 and len(used_hints) > 0:
macro_action = "Hint"
used_state = None
action = None
if macro_action == "Play":
used_state = used_actions[0]
action = ChoiceDetails(
Choice.PLAY,
used_actions[0][2]
)
if macro_action == "Discard":
used_state = used_actions[1]
action = ChoiceDetails(
Choice.DISCARD,
used_actions[1][2]
)
if macro_action == "Hint":
used_state = used_hints[0]
action = ChoiceDetails(
Choice.HINT,
HintDetails(used_hints[0][2], used_hints[0][3])
)
if round_info.log and debug:
self.info("{0}".format(macro_action))
self.info("{0} {1} {2}".format(used_state[0], used_state[1][0][0],
self.get_chance(used_state[1][0])))
self.info("{0} {1} {2}".format(macro_weights[0], macro_weights[1][0][0],
self.get_chance(macro_weights[1][0])))
return action
def read_others_hands(self, round_info, player_number):
original_player_number = player_number
hints = round_info.hints
if 2 <= hints <= 7:
hints = 2
actions = []
hinted_plays = {}
player_hand = round_info.player_hand
first_time = True
while player_number is not original_player_number or first_time:
first_time = False
hinted_plays[player_number] = {}
for suit in utils.Suit:
hinted_plays[player_number][suit] = {}
for rank in utils.Rank:
hinted_plays[player_number][suit][rank] = 0
player_number = utils.next_player_number(round_info, player_number)
for card in player_hand:
if card.revealed_rank is not None and card.revealed_suit is not None and \
round_info.board_state[card.real_suit] < card.real_rank.value:
hinted_plays[original_player_number][card.real_suit][card.real_rank] += 1
player_number = utils.next_player_number(round_info, original_player_number)
while player_number is not original_player_number:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
if round_info.board_state[card.real_suit] < card.real_rank.value and \
(card.revealed_rank is not None or card.revealed_suit is not None):
hinted_plays[player_number][card.real_suit][card.real_rank] += 1
player_number = utils.next_player_number(round_info, player_number)
player_number = utils.next_player_number(round_info, original_player_number)
while player_number is not original_player_number:
if player_number is not round_info.player_turn:
player_distance = player_number - original_player_number - 1
if player_distance < 0:
player_distance += round_info.number_of_players
if player_distance > 2:
player_distance = 2
targets = {}
for rank in utils.Rank:
targets[rank] = []
for suit in utils.Suit:
targets[suit] = []
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
if card.revealed_rank is None:
targets[card.real_rank].append(card)
if card.revealed_suit is None:
targets[card.real_suit].append(card)
def basic_check(targets, hint, rank=False):
current_alignment = 0
future_alignment = 0
corrected = 0
obviously_useless = 0
falsely_hinted = 0
chain_bonus = 0
card_age = 0
oldest_card = False
last_remaining = 0
for card in targets:
already_hinted = False
if card.revealed_suit is None and card.revealed_rank is None:
for players in hinted_plays:
if players is not player_number and \
hinted_plays[players][card.real_suit][card.real_rank] != 0:
already_hinted = True
card_with_hint = deepcopy(card)
if rank:
card_with_hint.revealed_rank = hint
else:
card_with_hint.revealed_suit = hint
if self.check_card_usefulness(round_info, card_with_hint) is not False \
and self.check_card_usefulness(round_info, card) is False:
obviously_useless += 1
if rank:
card_with_hint.revealed_suit = card.real_suit
else:
card_with_hint.revealed_rank = card.real_rank
if round_info.board_state[card.real_suit] is card.real_rank.value - 1:
if self.remaining[card.real_suit][card.real_rank] == 1 \
and ((rank and card.revealed_suit is None)
or (not rank and card.revealed_rank is None)):
last_remaining += 1
if card.revealed_rank is not None or card.revealed_suit is not None and \
round_info.current_turn - card.drawn_on_turn > 2:
corrected += 1
if already_hinted:
falsely_hinted += 1
else:
current_alignment += 1
chain = 1
if card.real_rank.value + chain <= 5 and \
self.known[card.real_suit][utils.Rank(card.real_rank.value + chain)] > 0:
chain += 1
chain_bonus += 1
elif self.check_card_usefulness(round_info, card_with_hint) is False:
if self.remaining[card.real_suit][card.real_rank] == 1 \
and ((rank and card.revealed_suit is None)
or (not rank and card.revealed_rank is None)):
last_remaining += 1
if card.revealed_rank is not None or card.revealed_suit is not None:
corrected += 1
future_alignment += 1
if round_info.board_state[card.real_suit] is not card.real_rank.value - 1 \
and ((rank and card.revealed_suit is None)
or (not rank and card.revealed_rank is None)):
falsely_hinted += 1
if round_info.current_turn - card.drawn_on_turn > card_age:
card_age = round_info.current_turn - card.drawn_on_turn
if card.hand_position is self.oldest_card[card.player_number]:
oldest_card = True
if card_age > 3:
card_age = 3
if current_alignment > 2:
current_alignment = 2
if future_alignment > 2:
future_alignment = 2
if obviously_useless > 2:
obviously_useless = 2
if corrected > 2:
corrected = 2
if falsely_hinted > 2:
falsely_hinted = 2
chain_bonus = math.ceil(chain_bonus / 2)
if chain_bonus > 2:
chain_bonus = 2
if last_remaining > 1:
last_remaining = 1
state = (rank, current_alignment, future_alignment, obviously_useless, corrected, falsely_hinted,
chain_bonus, last_remaining, card_age, oldest_card, player_distance)
weights = self.get_hint_weights(state)
return state, weights, player_number, hint
for rank in utils.Rank:
if len(targets[rank]) > 0:
actions.append(basic_check(targets[rank], rank, True))
for suit in utils.Suit:
if len(targets[suit]) > 0:
actions.append(basic_check(targets[suit], suit, False))
player_number = utils.next_player_number(round_info, player_number)
return actions
def check_for_save_tip(self, round_info, player_number):
best_player_number = -1
best_play_priority = False
best_hint_type = None
best_hint_rank = 6
remaining = utils.list_remaining_playable_cards(round_info)
original_player_number = player_number
player_number = utils.next_player_number(round_info, utils.next_player_number(round_info, player_number))
while player_number is not original_player_number and not best_play_priority:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
play_priority = False
prev_player = utils.prev_player_number(round_info, player_number)
play = self.check_for_obvious_play(round_info, prev_player)
if play is False:
play = self.check_for_hinted_play(round_info, prev_player)
if play is not False:
play_priority = True
discarded_position = self.check_for_guess_discard(round_info, player_number)[1]
discarded_card = player_hand[discarded_position]
if remaining[discarded_card.real_suit][discarded_card.real_rank] == 1 and \
max(round_info.board_state.values()) < discarded_card.real_rank.value - 1 and \
discarded_card.revealed_rank is None and discarded_card.revealed_suit is None:
best_player_number = player_number
best_play_priority = play_priority
best_hint_type = discarded_card.real_rank
player_number = utils.next_player_number(round_info, player_number)
if best_hint_type is None:
player_number = utils.next_player_number(round_info, utils.next_player_number(round_info, player_number))
while player_number is not original_player_number and not best_play_priority:
player_hand = utils.get_player_hand_by_number(round_info, player_number)
play_priority = False
prev_player = utils.prev_player_number(round_info, player_number)
if prev_player is not original_player_number:
play = self.check_for_obvious_play(round_info, prev_player)
if play is False:
play = self.check_for_hinted_play(round_info, prev_player)
if play is not False:
play_priority = True
for card in player_hand:
if remaining[card.real_suit][card.real_rank] == 1 and \
max(round_info.board_state.values()) < card.real_rank.value - 1 and \
card.revealed_rank is None and card.revealed_suit is None and \
best_hint_rank > card.real_rank.value:
best_player_number = player_number
best_play_priority = play_priority
best_hint_type = card.real_rank
best_hint_rank = card.real_rank.value
player_number = utils.next_player_number(round_info, player_number)
if best_hint_type is not None:
return ChoiceDetails(
Choice.HINT,
HintDetails(best_player_number, best_hint_type)
)
return False
def analyze_game(self, round_info, score):
scores = self.learning_state.score_history
#prog = 16
prog = statistics.median_low(scores) - 2
amount = abs(score - prog)
amount = math.ceil(amount)
original_player_number = round_info.player_turn
player_number = original_player_number
first = True
while player_number != original_player_number or first:
first = False
if player_number == original_player_number:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
for card in player_hand:
for state in card.hint_states:
self.penalize_hint(state[0], round_info, 0.05078125)
player_number = utils.next_player_number(round_info, player_number)
if score > prog:
for i in range(-1, -len(self.learning_state.states_history) - 1,
-1):
action = self.learning_state.states_history[i][1][0]
state = self.learning_state.states_history[i][2][0]
macro_state = self.learning_state.states_history[i][5][0]
if round_info.log and debug:
self.info("{0} {1}".format(action, state))
if action is Choice.PLAY:
self.reward_own_play(state, round_info, amount / 16)
self.reward_macro(macro_state, 0, round_info, amount)
if action is Choice.DISCARD:
self.reward_own_discard(state, round_info, amount / 8)
self.reward_macro(macro_state, 1, round_info, amount)
if action is Choice.HINT:
self.reward_hint(state, round_info, amount / 8)
self.reward_macro(macro_state, 2, round_info, amount)
elif score < prog:
for i in range(-1, -len(self.learning_state.states_history) - 1,
-1):
action = self.learning_state.states_history[i][1][0]
state = self.learning_state.states_history[i][2][0]
macro_state = self.learning_state.states_history[i][5][0]
if round_info.log and debug:
self.info("{0} {1}".format(action, state))
if action is Choice.PLAY:
self.penalize_own_play(state, round_info, amount / 16)
self.penalize_macro(macro_state, 0, round_info, amount)
if action is Choice.DISCARD:
self.penalize_own_discard(state, round_info, amount / 8)
self.penalize_macro(macro_state, 1, round_info, amount)
if action is Choice.HINT:
self.penalize_hint(state, round_info, amount / 8)
self.penalize_macro(macro_state, 2, round_info, amount)
scores[0] = ((len(scores) - 1) * scores[0] + score) / len(scores)
scores.append(score)
while len(scores) > 1001:
scores[0] = (
(len(scores) - 1) * scores[0] - scores[1]) / (len(scores) - 2)
scores.pop(1)
self.learning_state.score_history = scores
self.learning_state.states_history = []
def check_for_discard_tip(self, round_info, player_number, hint_pass_score=1.8, false_tip_penalty=-10.0,
distance_to_player_multiplier=1.01, only_next_player=False):
original_player_number = player_number
player_number = utils.next_player_number(round_info, original_player_number)
potential_discardable_ranks = {}
potential_discardable_suits = {}
while player_number is not original_player_number:
potential_discardable_ranks[player_number] = {}
potential_discardable_suits[player_number] = {}
for rank in utils.Rank:
potential_discardable_ranks[player_number][rank] = []
for suit in utils.Suit:
potential_discardable_suits[player_number][suit] = []
player_hand = utils.get_player_hand_by_number(round_info, player_number)
for card in player_hand:
if card.revealed_suit is None:
potential_discardable_suits[player_number][card.real_suit].append(card)
if card.revealed_rank is None:
potential_discardable_ranks[player_number][card.real_rank].append(card)
player_number = utils.next_player_number(round_info, player_number)
max_player_number = 0
max_potential = 0
max_hint = 0
def check_card_potential(card, player, hint_type, hint):
player_distance = player - original_player_number - 1
if player_distance < 0:
player_distance += round_info.number_of_players
card_potential = pow(distance_to_player_multiplier, player_distance)
card_with_hint = deepcopy(card)
if hint_type == 'rank':
card_with_hint.revealed_rank = hint
else:
card_with_hint.revealed_suit = hint
if self.check_card_usefulness(round_info, card_with_hint) is False:
card_potential += false_tip_penalty
return card_potential
for player in potential_discardable_ranks:
player_distance = player - original_player_number - 1
if player_distance < 0:
player_distance += round_info.number_of_players
if player_distance == 0 or not only_next_player:
for rank in potential_discardable_ranks[player]:
potential = 0
for card in potential_discardable_ranks[player][rank]:
potential += check_card_potential(card, player, 'rank', rank)
if potential > max_potential:
max_player_number = player
max_potential = potential
max_hint = rank
for suit in potential_discardable_suits[player]:
potential = 0
for card in potential_discardable_suits[player][suit]:
potential += check_card_potential(card, player, 'suit', suit)
if potential > max_potential:
max_player_number = player
max_potential = potential
max_hint = suit
if max_potential >= hint_pass_score:
return ChoiceDetails(
Choice.HINT,
HintDetails(max_player_number, max_hint)
)
return False
def read_board(self, round_info, player_number):
self.known = utils.list_others_cards(round_info, player_number)
if player_number is round_info.player_turn:
player_hand = round_info.player_hand
else:
player_hand = utils.get_player_hand_by_number(
round_info, player_number)
play_actions = []
for card in player_hand:
play_actions.append(self.read_own_card(round_info, card))
hint_actions = []
if round_info.hints > 0:
hint_actions = self.read_others_hands(round_info, player_number)
use_random = False
if random.random() <= random_action:
use_random = True
used_actions = []
used_hints = []
if use_random:
micro_decision = random.random()
sum_of_weights = 0
for play in play_actions:
sum_of_weights += 1 / len(play_actions)
if sum_of_weights - 1 / len(
play_actions) <= micro_decision <= sum_of_weights:
used_actions.append(play)
else:
max_of_weights = 0
used_play = None
total_count = 1
for play in play_actions:
total_count += play[1][0][0]
total_count = math.log(total_count)
for play in play_actions:
if round_info.log and debug:
self.info("{0} {1} {2} {3}".format(
play[0], play[1][0][0],
self.learning_state.get_chance(play[1][0]), play[2]))
sum_of_weights = self.learning_state.get_chance(play[1][0]) \
+ exploration_param * math.sqrt(total_count / play[1][0][0])
if sum_of_weights > max_of_weights:
max_of_weights = sum_of_weights
used_play = play
used_actions.append(used_play)
if use_random:
micro_decision = random.random()
sum_of_weights = 0
for play in play_actions:
sum_of_weights += 1 / len(play_actions)
if sum_of_weights - 1 / len(
play_actions) <= micro_decision <= sum_of_weights:
used_actions.append(play)
else:
max_of_weights = 0
used_play = None
total_count = 1
for play in play_actions:
total_count += play[1][1][0]
total_count = math.log(total_count)
for play in play_actions:
if round_info.log and debug:
self.info("{0} {1} {2} {3}".format(
play[0], play[1][1][0],
self.learning_state.get_chance(play[1][1]), play[2]))
sum_of_weights = self.learning_state.get_chance(play[1][1]) \
+ exploration_param * math.sqrt(total_count / play[1][1][0])
if sum_of_weights > max_of_weights:
max_of_weights = sum_of_weights
used_play = play
used_actions.append(used_play)
if round_info.hints > 0:
if use_random:
micro_decision = random.random()
sum_of_weights = 0
for hint in hint_actions:
sum_of_weights += 1 / len(hint_actions)
if sum_of_weights - 1 / len(
hint_actions) <= micro_decision <= sum_of_weights:
used_hints.append(hint)
else:
max_of_weights = 0
used_hint = None
total_count = 1
for hint in hint_actions:
total_count += hint[1][0][0]
total_count = math.log(total_count)
for hint in hint_actions:
if round_info.log and debug:
self.info("{0} {1} {2} {3} {4}".format(
hint[0], hint[1][0][0],
self.learning_state.get_chance(hint[1][0]),
hint[2], hint[3]))
sum_of_weights = self.learning_state.get_chance(hint[1][0]) \
+ exploration_param * math.sqrt(total_count / hint[1][0][0])
if sum_of_weights > max_of_weights:
max_of_weights = sum_of_weights
used_hint = hint
used_hints.append(used_hint)
if len(used_hints) > 0 and used_hints[0] is None:
used_hints = []
macro_weights = self.decide_macro_action(round_info, used_actions,
used_hints)
macro_max = 0
macro_action = "Discard"
total_count = 0
for weight in macro_weights[1]:
total_count += len(weight) - 1
total_count = math.log(total_count)
sum_of_weights = self.learning_state.get_chance(macro_weights[1][0]) \
+ exploration_param * math.sqrt(total_count / (len(macro_weights[1][0]) - 1))
if macro_max < sum_of_weights:
macro_max = sum_of_weights
macro_action = "Play"
sum_of_weights = self.learning_state.get_chance(macro_weights[1][1]) \
+ exploration_param * math.sqrt(total_count / (len(macro_weights[1][1]) - 1))
if macro_max < sum_of_weights:
macro_max = sum_of_weights
macro_action = "Discard"
sum_of_weights = self.learning_state.get_chance(macro_weights[1][2]) \
+ exploration_param * math.sqrt(total_count / (len(macro_weights[1][2]) - 1))
if macro_max < sum_of_weights and round_info.hints > 0 and len(
used_hints) > 0:
macro_action = "Hint"
if use_random:
stop = 1
if round_info.hints == 0:
stop -= 0.33
macro_decision = random.uniform(0, stop)
if macro_decision <= 0.34:
macro_action = "Play"
elif macro_decision <= 0.67:
macro_action = "Discard"
else:
macro_action = "Hint"
used_state = None
action = None
if macro_action == "Play":
used_state = used_actions[0]
action = ChoiceDetails(Choice.PLAY, used_actions[0][2])
if macro_action == "Discard":
used_state = used_actions[1]
action = ChoiceDetails(Choice.DISCARD, used_actions[1][2])
if macro_action == "Hint":
used_state = used_hints[0]
action = ChoiceDetails(
Choice.HINT, HintDetails(used_hints[0][2], used_hints[0][3]))
if round_info.log and debug:
self.info("{0}".format(macro_action))
self.info("{0} {1} {2}".format(
used_state[0], used_state[1][0][0],
self.learning_state.get_chance(used_state[1][0])))
self.info("{0} {1} {2}".format(
macro_weights[0], macro_weights[1][0][0],
self.learning_state.get_chance(macro_weights[1][0])))
self.learning_state.append_to_history(
(round_info.player_turn, action, used_state, play_actions,
hint_actions, macro_weights))
return action
