def _conservative_pass(self, suit_dict):
return_values = []
asc_suit_amount = sorted(
suit_dict.items(),
key=lambda d: d[1]) #asc :[('S', 0), ('D', 1), ('C', 5), ('H', 7)]
min_suit = asc_suit_amount[0][0]
count = 0
for card in self.my_hand_cards: # already order in desc
if card == Card("QS"): # -13
return_values.append(card.toString())
count += 1
elif card == Card("TC"): # double your score in this deal
return_values.append(card.toString())
count += 1
elif card.suit == min_suit: # pass if it's min suit
return_values.append(card.toString())
count += 1
elif card.suit_index == 2: # pick Heart
return_values.append(card.toString())
count += 1
if count == 3:
break
if count < 3:
second_min_suit = asc_suit_amount[1][0]
for card in self.my_hand_cards:
if card.suit == second_min_suit:
return_values.append(card.toString())
count += 1
if count == 3:
break
self.my_pass_card = return_values
return return_values
def get_round_scores(self, is_expose_card=False, data=None):
player_shoot_moon = collections.defaultdict(bool)
if data != None:
for player in data["players"]:
player_shoot_moon[
player["playerName"]] = player["shootingTheMoon"]
players = data['roundPlayers']
picked_user = players[0] #init
round_card = self.round_cards.get(picked_user)
score_cards = []
for i in range(len(players)):
card = self.round_cards.get(players[i])
if card in self.game_score_cards:
score_cards.append(card)
if round_card.suit_index == card.suit_index:
if round_card.value < card.value:
picked_user = players[i] #next
round_card = card
if (self.score_cards.get(picked_user) != None):
current_score_cards = self.score_cards.get(picked_user)
score_cards += current_score_cards
self.score_cards[picked_user] = score_cards
self.round_cards = {}
receive_cards = {}
for key in self.pick_his.keys():
picked_score_cards = self.score_cards.get(key)
round_score = 0
round_heart_score = 0
is_double = False
if picked_score_cards != None:
for card in picked_score_cards:
if card in self.game_score_cards:
if card == Card("QS"):
round_score += -13
elif card == Card("TC"):
is_double = True
else:
round_heart_score += -1
if is_expose_card:
round_heart_score *= 2
round_score += round_heart_score
if player_shoot_moon[key]:
round_score *= 4
round_score = abs(round_score)
if is_double:
round_score *= 2
receive_cards[key] = round_score
return receive_cards
def pass_cards(self, data):
cards = data['self']['cards']
self.my_hand_cards = []
suit_dict = collections.defaultdict(int)
large_cards = 0
for card_str in cards:
card = Card(card_str)
self.my_hand_cards.append(card)
suit_dict[
card.suit] += 1 # [('S', 5), ('D', 2), ('C', 4), ('H', 2)]
if card.value > 10:
large_cards += 1
# aggressive
if large_cards > 5:
message = "Pass card with _shooting_the_moon_pass"
self.system_log.show_message(message)
self.system_log.save_logs(message)
return self._shooting_the_moon_pass(suit_dict)
# conservative
else:
message = "Pass card with _conservative_pass"
self.system_log.show_message(message)
self.system_log.save_logs(message)
return self._conservative_pass(suit_dict)
def pick_card(self, data):
me = data['self']['playerName']
cadidate_cards = data['self']['candidateCards']
# set strategy candidate cards
self.strategy.set_candidates(cadidate_cards)
out_round = []
for player_name, out_turn_card in self.round_cards.items():
out_round.append(out_turn_card)
# set strategy round cards
self.strategy.set_roundcards(out_round)
message = "Me:{}, Candidates:{}, Roundcards:{}".format(
me, cadidate_cards, out_round)
self.system_log.show_message(message)
self.system_log.save_logs(message)
if self.player_dict[me]:
predict_action = self.global_agent.predict_action(
self.player_dict[me].state)
message = "Me:{}, Predict Strategy No.{}".format(
me, predict_action)
# set action with predict action
self.player_dict[me].set_action(predict_action)
self.system_log.show_message(message)
self.system_log.save_logs(message)
predict_card, actual_action = self.strategy.dispatcher(
predict_action)
card_string = predict_card.toString()
# set action with fallback(action) action could make model forever not know what a strategy affects to a state
# self.player_dict[me].set_action(actual_action)
message = "Me:{}, Strategy Fallback to No.{}".format(
me, actual_action)
self.system_log.show_message(message)
self.system_log.save_logs(message)
message = "Me:{}, Action Set: {}".format(
me, self.player_dict[me].action)
self.system_log.show_message(message)
self.system_log.save_logs(message)
message = "Me:{}, Predict Card:{}".format(me, card_string)
self.system_log.show_message(message)
self.system_log.save_logs(message)
return card_string
else:
cards = data['self']['cards']
self.my_hand_cards = []
for card_str in cards:
card = Card(card_str)
self.my_hand_cards.append(card)
message = "My Cards:{}".format(self.my_hand_cards)
self.system_log.show_message(message)
card_index = len(cadidate_cards) - 1 # pick smallest
message = "Pick Card Event Content:{}".format(data)
self.system_log.show_message(message)
message = "Candidate Cards:{}".format(cadidate_cards)
self.system_log.show_message(message)
self.system_log.save_logs(message)
message = "Pick Card:{}".format(cadidate_cards[card_index])
self.system_log.show_message(message)
self.system_log.save_logs(message)
return cadidate_cards[card_index]
def expose_my_cards(self, yourcards):
expose_card = []
for card in self.my_hand_cards:
if card == Card("AH"):
expose_card.append(card.toString())
message = "Expose Cards:{}".format(expose_card)
self.system_log.show_message(message)
self.system_log.save_logs(message)
return expose_card
def _is_uni_suit(self, cards):
suit = collections.defaultdict(list)
if cards:
for card in cards:
c = Card(card)
suit[c.suit] += 1
if len(suit.keys()) == 1:
return True
return False
def get_cards(self, data):
try:
receive_cards = []
players = data['players']
for player in players:
if player['playerName'] == self.player_name:
cards = player['cards']
for card in cards:
receive_cards.append(Card(card))
break
return receive_cards
except Exception as e:
self.system_log.show_message(e)
self.system_log.save_errors(e)
return None
def turn_end(self, data):
turnCard = data['turnCard']
turnPlayer = data['turnPlayer']
players = data['players']
is_timeout = data['serverRandom']
player_sample = self.player_dict[self.player_name]
for player in players:
if player['playerName'] == self.player_name:
current_cards = player['cards']
for card in current_cards:
self.players_current_picked_cards.append(
Card(card)) # self left hand cards
self.round_cards[turnPlayer] = Card(
turnCard
) # turnPlayer hand out turnCard. keep round_cards here {'P1':'3C', 'P2':'8C'}
# if self.player_name == turnPlayer:
# player_sample.set_turn_card(Card(turnCard))
# message = "My Turn:{}. Pick {} State: {}".format(turnPlayer, turnCard, player_sample.state)
# self.system_log.show_message(message)
# self.system_log.save_logs(message)
# else:
player_sample.set_others_turn_card(Card(turnCard))
message = "{}'s Turn:. Pick {} Mark it used".format(
turnPlayer, turnCard)
self.system_log.show_message(message)
self.system_log.save_logs(message)
opp_pick = {}
opp_pick[turnPlayer] = Card(turnCard)
if (self.pick_his.get(turnPlayer)) != None:
pick_card_list = self.pick_his.get(turnPlayer)
pick_card_list.append(Card(turnCard))
self.pick_his[turnPlayer] = pick_card_list
else:
pick_card_list = []
pick_card_list.append(Card(turnCard))
self.pick_his[turnPlayer] = pick_card_list
self.round_cards_history.append(Card(turnCard))
def set_others_score_cards(self, oppo_label, scores): # list
for s in scores:
s_card = Card(s)
self.state[13 * s_card.suit_index + s_card.value -
2] = oppo_label # 4 / 5 / 6
def set_score_cards(self, scores): # list
for s in scores:
s_card = Card(s)
self.state[13 * s_card.suit_index + s_card.value - 2] = 3
def set_hand_cards(self, hands): # list
for h in hands:
h_card = Card(h)
self.state[13 * h_card.suit_index + h_card.value - 2] = 1
def __init__(self, player_name, system_log):
self.game_count = 0
self.round_cards_history = []
self.pick_his = {}
self.round_cards = {}
self.score_cards = {}
self.player_name = player_name
self.players_current_picked_cards = []
self.game_score_cards = {
Card("QS"),
Card("TC"),
Card("2H"),
Card("3H"),
Card("4H"),
Card("5H"),
Card("6H"),
Card("7H"),
Card("8H"),
Card("9H"),
Card("TH"),
Card("JH"),
Card("QH"),
Card("KH"),
Card("AH")
}
self.system_log = system_log
self.state_size = 54
self.action_size = 12 # strategy amount
self.player_dict = collections.defaultdict(list)
self.global_agent = A3CAgent(self.state_size, self.action_size)
self.player_episodes = []
self.strategy = None
def set_roundcards(self, round_cards):
for r in round_cards:
if isinstance (r, Card):
self.round_cards.append(r)
else:
self.round_cards.append(Card(r))
def set_candidates(self, candi):
for c in candi:
self.candidates.append(Card(c))