def pick_card(self, data):
self.is_first_play = True
candidate_cards = []
for card in data['self']['candidateCards']:
candidate_cards.append(transform(card[0], card[1]))
self.my_hand_cards = []
for card_str in data['self']['cards']:
card = transform(card_str[0], card_str[1])
self.my_hand_cards.append(card)
self.game.current_player_idx = self.player.position
self.game._player_hands[self.player.position] = self.my_hand_cards
played_card = self.game.players[self.player.position].play_card(
self.game, self.other_info)
message = "Pick Card:{}, Candicated Card: {}, Hand Card: {}".format(
played_card, candidate_cards,
self.game._player_hands[self.player.position])
self.say(message)
system_log.show_message(message)
system_log.save_logs(message)
return str(played_card)
def receive_opponent_cards(self, data):
self.my_hand_cards = self.get_cards(data)
self.given_cards = []
self.received_cards = []
players = data['players']
for player in players:
player_name = player['playerName']
if player_name == self.player_name:
picked_cards = player['pickedCards']
for card_str in picked_cards:
card = transform(card_str[0], card_str[1])
self.given_cards.append(card)
receive_cards = player['receivedCards']
for card_str in receive_cards:
card = transform(card_str[0], card_str[1])
self.received_cards.append(card)
message = "User Name:{}, Given Cards:{}, Receive Cards:{}".format(
player_name, self.given_cards, receive_cards)
self.say(message)
system_log.show_message(message)
system_log.save_logs(message)
break
def turn_end(self,data):
turnCard = data['turnCard']
turnCard = transform(turnCard[0], turnCard[1])
turnPlayer = data['turnPlayer']
players = data['players']
is_timeout = data['serverRandom']
for player in players:
player_name = player['playerName']
if player_name == self.player_name:
current_cards = player['cards']
for card in current_cards:
self.players_current_picked_cards.append(transform(card[0], card[1]))
break
self.round_cards[turnPlayer] = turnCard
opp_pick = {}
opp_pick[turnPlayer] = turnCard
if (self.pick_his.get(turnPlayer)) is not None:
pick_card_list=self.pick_his.get(turnPlayer)
pick_card_list.append(turnCard)
self.pick_his[turnPlayer]=pick_card_list
else:
pick_card_list = []
pick_card_list.append(turnCard)
self.pick_his[turnPlayer] = pick_card_list
self.round_cards_history.append((turnPlayer, turnCard))
self.pick_history(data, is_timeout, opp_pick)
def run_one_step(current_round_idx, position, num_hand_cards, init_trick, hand_cards, is_hearts_broken, expose_info, cards,
score_cards=None, played_card=None, selection_func=random_choose, must_have={}, void_info={}):
for trick_idx, (winner_index, trick) in enumerate(init_trick):
for card_idx, card in enumerate(trick):
for suit, rank in str_to_bitmask([card]).items():
trick[card_idx] = [suit, rank]
if played_card is not None:
played_card = [SUIT_TO_INDEX[played_card.suit.__repr__()], NUM_TO_INDEX[played_card.rank.__repr__()]]
simulations_cards = None
if cards:
simulation_cards = redistribute_cards(1, position, hand_cards, num_hand_cards, init_trick[-1][1], cards, must_have, void_info)
else:
simulation_cards = [hand_cards]
for simulation_card in simulation_cards:
card = one_step_simulation(current_round_idx,
position,
simulation_card,
copy.deepcopy(init_trick),
void_info,
copy.deepcopy(score_cards),
is_hearts_broken,
expose_info,
played_card,
selection_func)
#print("----->", card)
return transform(INDEX_TO_NUM[card[1]], INDEX_TO_SUIT[card[0]])
def translate_hand_cards(self, hand_cards):
cards = []
for suit, ranks in hand_cards.items():
bit_mask = NUM_TO_INDEX["2"]
while bit_mask <= NUM_TO_INDEX["A"]:
if hand_cards[suit] & bit_mask:
cards.append(transform(INDEX_TO_NUM[bit_mask], INDEX_TO_SUIT[suit]))
bit_mask <<= 1
return cards
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(transform(card[0], card[1]))
break
return receive_cards
except Exception as e:
system_log.show_message(e)
return None
def translate_taken_cards(self, hand_cards):
cards = []
bit_mask = NUM_TO_INDEX["2"]
while bit_mask <= NUM_TO_INDEX["A"]:
if hand_cards[SUIT_TO_INDEX["H"]] & bit_mask:
cards.append(transform(INDEX_TO_NUM[bit_mask], "H"))
bit_mask <<= 1
if hand_cards[SUIT_TO_INDEX["S"]] & NUM_TO_INDEX["Q"]:
cards.append(Card(Suit.spades, Rank.queen))
if hand_cards[SUIT_TO_INDEX["C"]] & NUM_TO_INDEX["T"]:
cards.append(Card(Suit.clubs, Rank.ten))
return cards
def expose_my_cards(self, data):
self.my_hand_cards = []
for card in data["self"]["cards"]:
self.my_hand_cards.append(transform(card[0], card[1]))
is_exposed = self.player.expose_hearts_ace(self.my_hand_cards)
expose_card = []
if is_exposed:
expose_card.append(str(Card(Suit.hearts, Rank.ace)))
# for card in self.my_hand_cards:
# if card == Card(Suit.hearts, Rank.ace):
# expose_card.append(str(card))
# break
message = "Expose Cards:{}".format(expose_card)
system_log.show_message(message)
system_log.save_logs(message)
return expose_card
def pass_cards(self, data):
cards = data['self']['cards']
self.my_hand_cards = []
for card_str in cards:
card = transform(card_str[0], card_str[1])
self.my_hand_cards.append(card)
pass_cards = self.player.pass_cards(self.my_hand_cards,
data["dealNumber"])
self.proactive_mode = self.player.proactive_mode
return_values = []
for card in pass_cards:
return_values.append(str(card))
message = "Pass Cards:{}".format(return_values)
system_log.show_message(message)
system_log.save_logs(message)
self.my_pass_card = return_values
return return_values
def run_simulation(seed,
current_round_idx,
position,
init_trick,
hand_cards,
is_hearts_broken,
expose_info,
cards,
score_cards=None,
played_card=None,
selection_func=random_choose,
must_have={},
void_info={},
proactive_mode=None,
simulation_time=0.93):
simulation_time = max(simulation_time, 0.1)
stime = time.time()
for trick_idx, (winner_index, trick) in enumerate(init_trick):
for card_idx, card in enumerate(trick):
for suit, rank in str_to_bitmask([card]).items():
trick[card_idx] = [suit, rank]
if played_card is not None:
played_card = [
SUIT_TO_INDEX[played_card.suit.__repr__()],
NUM_TO_INDEX[played_card.rank.__repr__()]
]
simulations_cards = None
if cards:
simulation_cards = redistribute_cards(seed, position, hand_cards,
init_trick[-1][1], cards,
must_have, void_info)
else:
simulation_cards = [hand_cards]
results, num_of_shoot_the_moon = defaultdict(list), defaultdict(int)
for simulation_card in simulation_cards:
card, scores, _, self_shoot_the_moon = simulation(
current_round_idx, position, simulation_card,
copy.deepcopy(init_trick), void_info, copy.deepcopy(score_cards),
is_hearts_broken, expose_info, played_card, selection_func,
proactive_mode)
if card is None:
continue
card = tuple(card)
sum_score = sum(scores)
results[card].append(
[scores[position] / sum_score, self_shoot_the_moon])
if time.time() - stime > simulation_time or IS_DEBUG:
break
return dict([(transform(INDEX_TO_NUM[card[1]],
INDEX_TO_SUIT[card[0]]), info)
for card, info in results.items()])
hand_3 = "AH, 9D, 7C, 7D, 6S, 4H, 5D, 4C, 3D, 2D, AD, QH, KD".replace(
" ", "")
hand_4 = "JC, JS, TD, TS, 9C, 8D, 7S, 6D, 3C, 2C, KS, KH, AC".replace(
" ", "")
init_trick = [[None, []]]
hand_1 = "6C, 7C, JC, QC, 2S, 5S, 6S, 9S, QS, AS, 6H, 7H, KH".replace(
" ", "")
hand_2 = "8C, AC, 3D, 4D, 7D, 8S, TS, JS, KS, 2H, 4H, 5H, QH".replace(
" ", "")
hand_3 = "4C, 2D, 5D, 8D, 9D, TD, JD, KD, 4S, 7S, 3H, 8H, AH".replace(
" ", "")
hand_4 = "2C, 3C, 5C, 9C, TC, KC, 6D, QD, AD, 3S, 9H, TH, JH".replace(
" ", "")
hand_cards = [[transform(card[0], card[1]) for card in hand_1.split(",")],
[transform(card[0], card[1]) for card in hand_2.split(",")],
[transform(card[0], card[1]) for card in hand_3.split(",")],
[transform(card[0], card[1]) for card in hand_4.split(",")]]
myself_hand_cards = hand_cards
cards = []
played_card = None
score_cards = None
must_have = {}
void_info = {}
proactive_mode = None
IS_DEBUG = True
def run_simulation(seed, current_round_idx, position, num_hand_cards, init_trick, hand_cards, is_hearts_broken, expose_hearts_ace, cards,
score_cards=None, played_card=None, selection_func=random_choose, must_have={}, void_info={},
proactive_mode=None, simulation_time=0.93):
simulation_time = max(simulation_time, 0.1)
stime = time.time()
for trick_idx, (winner_index, trick) in enumerate(init_trick):
for card_idx, card in enumerate(trick):
for suit, rank in str_to_bitmask([card]).items():
trick[card_idx] = [suit, rank]
if played_card is not None:
played_card = [SUIT_TO_INDEX[played_card.suit.__repr__()], NUM_TO_INDEX[played_card.rank.__repr__()]]
simulations_cards = None
if cards:
simulation_cards = redistribute_cards(seed, position, hand_cards, num_hand_cards, init_trick[-1][1], cards, must_have, void_info)
else:
simulation_cards = [hand_cards]
results, num_of_shoot_the_moon = defaultdict(list), defaultdict(int)
for simulation_card in simulation_cards:
card, scores, _, self_shoot_the_moon = simulation(current_round_idx,
position,
simulation_card,
copy.deepcopy(init_trick),
void_info,
copy.deepcopy(score_cards),
is_hearts_broken,
expose_hearts_ace,
played_card,
selection_func,
proactive_mode)
if card is None:
continue
card = tuple(card)
rating = [0, 0, 0, 0]
info = zip(range(4), scores)
total_score = sum(scores)
pre_score, pre_rating, sum_score = None, None, [score/total_score for score in scores]
for rating_idx, (player_idx, score) in enumerate(sorted(info, key=lambda x: -x[1])):
tmp_rating = rating_idx
if pre_score is not None:
if score == pre_score:
tmp_rating = pre_rating
rating[player_idx] = (4-tmp_rating)/4 + sum_score[player_idx]
pre_score = score
pre_rating = tmp_rating
#print(card, scores, rating, sum_score)
results[card].append([rating[position], self_shoot_the_moon])
if time.time()-stime > simulation_time or IS_DEBUG:
break
return dict([(transform(INDEX_TO_NUM[card[1]], INDEX_TO_SUIT[card[0]]), info) for card, info in results.items()])
def expose_cards_end(self, data):
expose_player, expose_card = None, None
self.player_names, current_player_idx, players = [], None, []
for player_idx, player in enumerate(data['players']):
try:
self.player_names.append(player["playerName"])
p = None
if self.player_names[-1] == self.player_name:
p = copy.deepcopy(self.pure_player)
current_player_idx = player_idx
else:
p = SimplePlayer(verbose=False)
p.name = self.player_names[-1]
players.append(p)
except Exception as e:
system_log.show_message(e)
system_log.save_logs(e)
self.game = Game(players, verbose=False)
self.player = self.game.players[current_player_idx]
if self.proactive_mode:
self.player.proactive_mode = self.proactive_mode
else:
self.player.evaluate_proactive_mode(self.game)
idx = None
deal_number = data["dealNumber"]
if deal_number % 4 == 1:
idx = (self.player.position + 1) % 4
self.player.set_transfer_card(idx, self.given_cards)
elif deal_number % 4 == 2:
idx = (self.player.position + 3) % 4
self.player.set_transfer_card(idx, self.given_cards)
elif deal_number % 4 == 3:
idx = (self.player.position + 2) % 4
self.player.set_transfer_card(idx, self.given_cards)
if idx is not None:
self.say("pass card to {}, {}, {}", idx,
self.player.transfer_cards, self.given_cards)
else:
self.say("not passing card")
if expose_player is not None and expose_card is not None:
message = "Player:{}, Expose card:{}".format(
expose_player, expose_card)
self.game.expose_heart_ace = True
self.player.set_transfer_card([
idx for idx in range(4)
if self.player_names[idx] == expose_player
][0], transform(expose_card[0], expose_card[1]))
#print("expose", message, self.player.transfer_cards)
system_log.show_message(message)
system_log.save_logs(message)
self.expose_card = True
else:
message = "No player expose card!"
system_log.show_message(message)
system_log.save_logs(message)
self.expose_card = False
