def test_seed_different(self):
s = State.generate()
s1 = State.generate()
if s.get_deck().get_card_states() == s1.get_deck().get_card_states():
raise RuntimeError("The decks are shuffled in the same way.")
print s.get_deck().get_card_states()
print s1.get_deck().get_card_states()
def heuristic_1a(self, player: int, depth: int,
curr_state: State) -> float:
if (curr_state.get_points(util.other(player)) +
curr_state.get_points(player)) == 0:
return 0
return curr_state.get_points(
util.other(player)) / (curr_state.get_points(util.other(player)) +
curr_state.get_points(player))
def test_seed_same(self):
for i in range(1,1000):
id = i
s = State.generate(id)
s1 = State.generate(id)
if s.get_deck().get_card_states() != s1.get_deck().get_card_states() or s.whose_turn() != s.whose_turn():
raise RuntimeError("The decks are not shuffled in the same way.")
print s.get_deck().get_card_states()
print s1.get_deck().get_card_states()
def heuristic_3c(self, player: int, depth: int,
curr_state: State) -> float:
trumprange = range(15, 20)
trumpamount = 0
if curr_state.get_trump_suit == "C":
trumprange = range(0, 5)
elif curr_state.get_trump_suit == "D":
trumprange = range(5, 10)
elif curr_state.get_trump_suit == 'H':
trumprange = range(10, 15)
for move in curr_state.moves():
if move[0] in trumprange:
trumpamount += 1
return trumpamount / len(curr_state.moves())
def test_trump_jack_non_leading(self):
state = State.generate(6)
me = state.whose_turn()
s1 = state.clone(signature=me)
trump_suit = state.get_trump_suit()
jacks = [
move for move in s1.moves()
if (move[0] == 4 or move[0] == 9 or move[0] == 14 or move[0] == 19)
]
trump_jacks = [
move for move in jacks if util.get_suit(move[0]) == trump_suit
]
self.assertEqual(len(s1.moves()), 5 + len(trump_jacks))
state = state.next(random.choice(state.moves()))
s1 = state.clone(me)
jacks = [
move for move in state.moves()
if (move[0] == 4 or move[0] == 9 or move[0] == 14 or move[0] == 19)
]
trump_jacks = [
move for move in jacks if util.get_suit(move[0]) == trump_suit
]
self.assertGreater(len(trump_jacks), 0)
self.assertEqual(len(state.moves()), 5)
def create_dataset(path, player=ml_ml_rdeep.Bot(), games=2000, phase=1):
data = []
target = []
# For progress bar
bar_length = 30
start = time.time()
for g in range(games - 1):
# For progress bar
if g % 10 == 0:
percent = 100.0 * g / games
sys.stdout.write('\r')
sys.stdout.write("Generating dataset: [{:{}}] {:>3}%".format(
'=' * int(percent / (100.0 / bar_length)), bar_length,
int(percent)))
sys.stdout.flush()
# Randomly generate a state object starting in specified phase.
state = State.generate(phase=phase)
state_vectors = []
while not state.finished():
# Give the state a signature if in phase 1, obscuring information that a player shouldn't see.
given_state = state.clone(signature=state.whose_turn()
) if state.get_phase() == 1 else state
# Add the features representation of a state to the state_vectors array
state_vectors.append(features(given_state))
# Advance to the next state
move = player.get_move(given_state)
state = state.next(move)
winner, score = state.winner()
for state_vector in state_vectors:
data.append(state_vector)
if winner == 1:
result = 'won'
elif winner == 2:
result = 'lost'
target.append(result)
with open(path, 'wb') as output:
pickle.dump((data, target), output, pickle.HIGHEST_PROTOCOL)
# For printing newline after progress bar
print(
"\nDone. Time to generate dataset: {:.2f} seconds".format(time.time() -
start))
return data, target
def test_game10(self): state = State.generate(0) for i in range(10): if not state.finished(): moves = state.moves() state = state.next(moves[0])
def test_game15(self): state = State.generate(0) for i in range(15): if not state.finished(): # print state moves = state.moves() state = state.next(moves[0])
def run_tournament(options):
botnames = options.players.split(",")
bots = []
for botname in botnames:
bots.append(util.load_player(botname))
n = len(bots)
wins = [0] * len(bots)
matches = [(p1, p2) for p1 in range(n) for p2 in range(n) if p1 < p2]
totalgames = (n * n - n) / 2 * options.repeats
playedgames = 0
wins_player1 = 0
wins_player2 = 0
seed = 7453876
print('Playing {} games:'.format(int(totalgames)))
for a, b in matches:
for r in range(options.repeats):
if random.choice([True, False]):
p = [a, b]
else:
p = [b, a]
# Generate a state with a random seed
state = State.generate(id=seed, phase=int(options.phase))
winner, score = engine.play(bots[p[0]],
bots[p[1]],
state,
options.max_time * 1000,
verbose=options.verbose,
fast=options.fast)
if winner is not None:
winner = p[winner - 1]
wins[winner] += score
if winner == 0:
wins_player1 += 1
elif winner == 1:
wins_player2 += 1
seed += 1
playedgames += 1
print('Played {} out of {:.0f} games ({:.0f}%): {} \r'.format(
playedgames, totalgames, playedgames / float(totalgames) * 100,
wins))
print('Results:')
for i in range(len(bots)):
print(' bot {}: {} points'.format(bots[i], wins[i]))
print('Player 1 won %d games. Player 2 won %d games.' %
(wins_player1, wins_player2))
def execute(params):
ids, (player1, player2), (map_size, seed) = params
start, _ = State.generate(map_size, seed, symmetric=not args.asym)
winner = engine.play(player1[1], player2[1], start, verbose=(args.verbose > 2), outfile=None,
max_time=args.max_time * 1000, max_turns=args.max_turns)
if winner is not None:
winner = (player1[0], player2[0])[winner-1]
return ids, winner, (player1[0], player2[0]), (map_size, seed)
def test_mariage_visible(self): # for i in range(1,200): # s = State.generate(i) # moves = s.moves() # # if # print moves s = State.generate(2) moves = s.moves() # if print moves
def kb_consistent_trumpmarriage(self, state, move):
# type: (State, move) -> bool
# each time we check for consistency we initialise a new knowledge-base
kb = KB()
# Add general information about the game
suit = State.get_trump_suit(state)
if suit == "C":
card1 = 2
card2 = 3
variable_string = "m" + str(card1) + str(card2)
strategy_variable = Boolean(variable_string)
kb.add_clause(strategy_variable)
elif suit == "D":
card1 = 7
card2 = 8
variable_string = "m" + str(card1) + str(card2)
strategy_variable = Boolean(variable_string)
kb.add_clause(strategy_variable)
elif suit == "H":
card1 = 12
card2 = 13
variable_string = "m" + str(card1) + str(card2)
strategy_variable = Boolean(variable_string)
kb.add_clause(strategy_variable)
elif suit == "S":
card1 = 17
card2 = 18
variable_string = "m" + str(card1) + str(card2)
strategy_variable = Boolean(variable_string)
kb.add_clause(strategy_variable)
load.general_information(kb)
# Add the necessary knowledge about the strategy
load.strategy_knowledge(kb)
# This line stores the index of the card in the deck.
# If this doesn't make sense, refer to _deck.py for the card index mapping
index = move[0]
variable_string = "pm" + str(index)
strategy_variable = Boolean(variable_string)
# Add the relevant clause to the loaded knowledge base
kb.add_clause(~strategy_variable)
# If the knowledge base is not satisfiable, the strategy variable is
# entailed (proof by refutation)
return kb.satisfiable()
def test_few_moves(self):
state = State.generate(50)
self.assertEqual(state.get_perspective(), [
'P1H', 'P1H', 'S', 'S', 'P2H', 'P2H', 'S', 'P2H', 'P1H', 'P2H',
'S', 'P2H', 'S', 'S', 'P1H', 'S', 'P1H', 'S', 'S', 'S'
])
s1 = state.clone(1)
self.assertEqual(s1.get_perspective(), [
'P1H', 'P1H', 'U', 'U', 'U', 'U', 'U', 'U', 'P1H', 'U', 'S', 'U',
'U', 'U', 'P1H', 'U', 'P1H', 'U', 'U', 'U'
])
def run_tournament(options):
botnames = options.players.split(",")
bots = []
for botname in botnames:
bots.append(util.load_player(botname))
n = len(bots)
wins = [0] * len(bots)
ranks = [0] * len(bots)
matches = [(p1, p2) for p1 in range(n) for p2 in range(n) if p1 < p2]
totalgames = (n * n - n) / 2 * options.repeats
playedgames = 0
totalpoints = 0
print('Playing {} games:'.format(int(totalgames)))
for a, b in matches:
for r in range(options.repeats):
p = [a, b] if random.choice([True, False]) else [
b, a
] # randomly chooses who starting_state applies to
#p = [a, b] # starting state applied to second player
#p = [b, a] # starting state applied to first player
# add starting_state argument here, most of them apply to second player
starting_state = None # None, one_marriage, two marriage, all_jacks, all_aces, same_suit, all_ace_jack
state = State.generate(phase=int(options.phase),
starting_state=starting_state)
winner, score = engine.play(bots[p[0]],
bots[p[1]],
state,
options.max_time * 1000,
verbose=False,
fast=options.fast)
if winner is not None:
winner = p[winner - 1]
wins[winner] += score
ranks[winner] += 1
totalpoints += score
playedgames += 1
#print('Played {} out of {:.0f} games ({:.0f}%): {} \r'.format(playedgames, totalgames, playedgames/float(totalgames) * 100, wins))
for i in range(len(bots)):
ranks[i] = wins[i] / (totalpoints)
#ranks[i] = ranks[i]/(totalgames) # i think points are more important than just games won
print(' bot {}: {} points, {:04.2f} rank'.format(
bots[i], wins[i], ranks[i]))
def test_exchange_move(self):
s = State.generate(11)
moves = s.moves()
s1 = s.next(moves[5])
if s.moves() == s1.moves():
raise RuntimeError("The available moves should have changed.")
if s.whose_turn() is not s1.whose_turn():
raise RuntimeError("The turns shifted. This should not be the case.")
if len(s.moves()) <= len(s1.moves()):
raise RuntimeError("The number of available moves should have decreased.")
def test_marriage_deterministic(self):
state = State.generate(38)
self.assertEqual(state.get_deck().get_card_states(), [
'S', 'P2H', 'P1H', 'S', 'P1H', 'P1H', 'S', 'S', 'P2H', 'S', 'S',
'P2H', 'P2H', 'P2H', 'S', 'S', 'S', 'S', 'P1H', 'P1H'
])
self.assertEqual(state.get_perspective(1), [
'U', 'U', 'P1H', 'U', 'P1H', 'P1H', 'U', 'U', 'U', 'U', 'U', 'U',
'U', 'U', 'S', 'U', 'U', 'U', 'P1H', 'P1H'
])
self.assertEqual(state.get_perspective(2), [
'U', 'P2H', 'U', 'U', 'U', 'U', 'U', 'U', 'P2H', 'U', 'U', 'P2H',
'P2H', 'P2H', 'S', 'U', 'U', 'U', 'U', 'U'
])
def test_trump_jack_non_leading(self): state = State.generate(6) trump_suit = state.get_trump_suit() jacks = [move for move in state.moves() if (move[0] == 4 or move[0] == 9 or move[0] == 14 or move[0] == 19)] trump_jacks = [move for move in jacks if util.get_suit(move[0]) == trump_suit] self.assertEqual(len(state.moves()), 5 + len(trump_jacks)) self.assertEqual(len(jacks), 0) state = state.next(random.choice(state.moves())) jacks = [move for move in state.moves() if (move[0] == 4 or move[0] == 9 or move[0] == 14 or move[0] == 19)] trump_jacks = [move for move in jacks if util.get_suit(move[0]) == trump_suit]
def test_game_full(self):
wins = 0
for i in range(10000):
state = State.generate()
while not state.finished():
moves = state.moves()
# print state.get_deck().get_card_states()
# print "p1 score: {}".format(state.get_points(1))
# print "p2 score: {}".format(state.get_points(2))
# print moves
state = state.next(moves[0])
winner, points = state.winner()
if winner == 1:
wins +=1
print wins
def execute(params):
ids, bot, (map_size, seed, max_turns, asym) = params
state, _ = State.generate(map_size, seed, symmetric=not asym)
state_vectors = []
i = 0
while not state.finished() and i <= max_turns:
state_vectors.append(features(state))
move = bot.get_move(state)
state = state.next(move)
i += 1
winner = state.winner()
return ids, winner, state_vectors, (map_size, seed)
def run_tournament(options):
botnames = options.players.split(",")
bots = []
for botname in botnames:
bots.append(util.load_player(botname))
n = len(bots)
wins = [0] * len(bots)
points = [0] * len(bots)
matches = [(p1, p2) for p1 in range(n) for p2 in range(n) if p1 < p2]
totalgames = (n * n - n) / 2 * options.repeats
playedgames = 0
print('Playing {} games:'.format(totalgames))
for a, b in matches:
for r in range(options.repeats):
if random.choice([True, False]):
p = [a, b]
else:
p = [b, a]
# Generate a state with a random seed
start = State.generate(phase=int(options.phase))
winner = engine.play(bots[p[0]], bots[p[1]], start, verbose=False)
#TODO: ALSO IMPLEMENT POINTS FOR WINNING
if winner is not None:
_, temp_points = winner
winner = p[winner[0] - 1]
wins[winner] += 1
points[winner] += temp_points
playedgames += 1
print('Played {} out of {:.0f} games ({:.0f}%): {} \r'.format(
playedgames, totalgames, playedgames / float(totalgames) * 100,
wins))
print('Results:')
for i in range(len(bots)):
print(' bot {}: {} wins, {} points'.format(bots[i], wins[i],
points[i]))
def heuristic_3a(self, player: int, depth: int,
curr_state: State) -> float:
trumprange = range(15, 20)
trumpamount = 0
handstrength = 0
if curr_state.get_trump_suit == "C":
trumprange = range(0, 5)
elif curr_state.get_trump_suit == "D":
trumprange = range(5, 10)
elif curr_state.get_trump_suit == 'H':
trumprange = range(10, 15)
for move in curr_state.moves():
handstrength = 3 - ((move[0] % 5) - 2)
if move[0] in trumprange:
trumpamount += 1
handstrength += 5 * trumpamount
return handstrength
def test_clone(self): deck = Deck.generate(0) state = State(deck,True) clone = state.clone() self.assertEqual(state.finished(), clone.finished()) self.assertEqual(state.revoked(), clone.revoked()) self.assertEqual(state.winner(), clone.winner()) current_deck = state.get_deck() clone_deck = clone.get_deck() self.assertEqual(current_deck.get_card_states(), clone_deck.get_card_states()) pass
def heuristic_2a(self, player: int, depth: int,
curr_state: State) -> float:
MAX_POSSIBLE_POTENTIAL_POINTS = 11
potential_points = 0
played_card = curr_state.get_opponents_played_card()
if played_card is not None:
played_card = util.get_rank(played_card)
if played_card == 'J':
potential_points -= 2
elif played_card == 'Q':
potential_points -= 3
elif played_card == 'K':
potential_points -= 4
elif played_card == '10':
potential_points -= 10
elif played_card == 'A':
potential_points -= 11
return potential_points / MAX_POSSIBLE_POTENTIAL_POINTS
def test_marriage_deterministic(self): state = State.generate(38) self.assertEqual(state.get_deck().get_card_states(), ['S', 'P2H', 'P1H', 'S', 'P1H', 'P1H', 'S', 'S', 'P2H', 'S', 'S', 'P2H', 'P2H', 'P2H', 'S', 'S', 'S', 'S', 'P1H', 'P1H']) self.assertEqual(state.get_perspective(1), ['U', 'U', 'P1H', 'U', 'P1H', 'P1H', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'S', 'U', 'U', 'U', 'P1H', 'P1H']) self.assertEqual(state.get_perspective(2), ['U', 'P2H', 'U', 'U', 'U', 'U', 'U', 'U', 'P2H', 'U', 'U', 'P2H', 'P2H', 'P2H', 'S', 'U', 'U', 'U', 'U', 'U']) state = state.next((12, 13)) self.assertEqual(state.get_deck().get_card_states(), ['S', 'P2H', 'P1H', 'S', 'P1H', 'P1H', 'S', 'S', 'P2H', 'S', 'S', 'P2H', 'P2H', 'P2H', 'S', 'S', 'S', 'S', 'P1H', 'P1H']) self.assertEqual(state.get_perspective(1), ['U', 'U', 'P1H', 'U', 'P1H', 'P1H', 'U', 'U', 'U', 'U', 'U', 'U', 'P2H', 'P2H', 'S', 'U', 'U', 'U', 'P1H', 'P1H']) self.assertEqual(state.get_perspective(2), ['U', 'P2H', 'U', 'U', 'U', 'U', 'U', 'U', 'P2H', 'U', 'U', 'P2H', 'P2H', 'P2H', 'S', 'U', 'U', 'U', 'U', 'U']) move = random.choice(state.moves()) index = move[0] scores = [11, 10, 4, 3, 2] score = 40 + scores[12%5] + scores[index%5] st = state.get_deck().get_stock() state = state.next(move) card_states = ['S', 'P2H', 'P1H', 'S', 'P1H', 'P1H', 'S', 'S', 'P2H', 'S', 'S', 'P2H', 'P2W', 'P2H', 'S', 'S', 'S', 'S', 'P1H', 'P1H'] st1 = st.pop() st2 = st.pop() card_states[index] = "P2W" card_states[st1] = "P2H" card_states[st2] = "P1H" p1 = ['U', 'U', 'P1H', 'U', 'P1H', 'P1H', 'U', 'U', 'U', 'U', 'U', 'U', 'P2W', 'P2H', 'S', 'U', 'U', 'U', 'P1H', 'P1H'] p1[st2] = "P1H" p1[index] = "P2W" p2 = ['U', 'P2H', 'U', 'U', 'U', 'U', 'U', 'U', 'P2H', 'U', 'U', 'P2H', 'P2W', 'P2H', 'S', 'U', 'U', 'U', 'U', 'U'] p2[index] = "P2W" p2[st1] = "P2H" self.assertEqual(state.get_deck().get_card_states(), card_states) self.assertEqual(state.get_perspective(1), p1) self.assertEqual(state.get_perspective(2), p2) self.assertEqual(state.get_points(1), 0) self.assertEqual(state.get_points(2), score)
def test_trump_jack_exchange_deterministic(self):
state = State.generate(50)
self.assertEqual(state.get_deck().get_card_states(), [
'P1H', 'P1H', 'S', 'S', 'P2H', 'P2H', 'S', 'P2H', 'P1H', 'P2H',
'S', 'P2H', 'S', 'S', 'P1H', 'S', 'P1H', 'S', 'S', 'S'
])
self.assertEqual(state.get_perspective(1), [
'P1H', 'P1H', 'U', 'U', 'U', 'U', 'U', 'U', 'P1H', 'U', 'S', 'U',
'U', 'U', 'P1H', 'U', 'P1H', 'U', 'U', 'U'
])
self.assertEqual(state.get_perspective(2), [
'U', 'U', 'U', 'U', 'P2H', 'P2H', 'U', 'P2H', 'U', 'P2H', 'S',
'P2H', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U'
])
#Test trump jack exchange
#Maybe needs to change if order of moves is altered
self.assertEqual(state.whose_turn(), 1)
self.assertEqual(state.get_points(1), 0)
self.assertEqual(state.get_points(2), 0)
self.assertEqual(state.get_pending_points(1), 0)
self.assertEqual(state.get_pending_points(2), 0)
state = state.next(state.moves().pop())
self.assertEqual(state.whose_turn(), 1)
self.assertEqual(state.get_deck().get_card_states(), [
'P1H', 'P1H', 'S', 'S', 'P2H', 'P2H', 'S', 'P2H', 'P1H', 'P2H',
'P1H', 'P2H', 'S', 'S', 'S', 'S', 'P1H', 'S', 'S', 'S'
])
self.assertEqual(state.get_perspective(1), [
'P1H', 'P1H', 'U', 'U', 'U', 'U', 'U', 'U', 'P1H', 'U', 'P1H', 'U',
'U', 'U', 'S', 'U', 'P1H', 'U', 'U', 'U'
])
self.assertEqual(state.get_perspective(2), [
'U', 'U', 'U', 'U', 'P2H', 'P2H', 'U', 'P2H', 'U', 'P2H', 'P1H',
'P2H', 'U', 'U', 'S', 'U', 'U', 'U', 'U', 'U'
])
self.assertEqual(state.get_points(1), 0)
self.assertEqual(state.get_points(2), 0)
self.assertEqual(state.get_pending_points(1), 0)
self.assertEqual(state.get_pending_points(2), 0)
def train_bot(player):
for g in range(GAMES):
# Randomly generate a state object starting in specified phase.
state = State.generate(phase=PHASE)
state_vectors = []
while not state.finished():
# Give the state a signature if in phase 1, obscuring information that a player shouldn't see.
given_state = state.clone(signature=state.whose_turn()
) if state.get_phase() == 1 else state
# Add the features representation of a state to the state_vectors array
state_vectors.append(features(given_state))
# Advance to the next state
move = player.get_move(given_state)
state = state.next(move)
winner, score = state.winner()
for state_vector in state_vectors:
data.append(state_vector)
if winner == 1:
result = 'won'
elif winner == 2:
result = 'lost'
target.append(result)
sys.stdout.write(".")
sys.stdout.flush()
if g % (GAMES / 10) == 0:
print("")
print('game {} finished ({}%)'.format(g, (g / float(GAMES) * 100)))
def call_engine(options):
# Create player 1
player1 = util.load_player(options.player1)
# Create player 2
player2 = util.load_player(options.player2)
# Generate or load the map
state, id = State.generate(int(options.num_planets), symmetric=not options.asym)
if not options.quiet:
print('-- Using map with id {} '.format(id))
print(' Start state: ' + str(state))
# Play the game
viz = (options.outputfile.lower() == 'none')
outfile = options.outputfile # type: str
if not outfile.endswith('.pdf'):
outfile += '.pdf'
engine.play(player1, player2, state=state, max_time=options.max_time*1000, verbose=(not options.quiet), outfile=outfile)
def call_engine(options):
# Create player 1
player1 = util.load_player(options.player1)
# Create player 2
player2 = util.load_player(options.player2)
# Generate or load the map
state = State.generate(phase=int(options.phase))
if not options.quiet:
# print('-- Using map with id {} '.format(id))
print(' Start state: ' + str(state))
# Play the game
engine.play(player1,
player2,
state=state,
max_time=options.max_time * 1000,
verbose=(not options.quiet))
def run_tournament(options):
botnames = options.players.split(",")
bots = []
for botname in botnames:
bots.append(util.load_player(botname))
n = len(bots)
wins = [0] * len(bots)
matches = [(p1, p2) for p1 in range(n) for p2 in range(n) if p1 < p2]
totalgames = (n*n - n)/2 * options.repeats
playedgames = 0
print('Playing {} games:'.format(totalgames))
for a, b in matches:
for r in range(options.repeats):
if random.choice([True, False]):
p = [a, b]
else:
p = [b, a]
start, _ = State.generate(int(options.num_planets), symmetric=not options.asym)
winner = engine.play(bots[p[0]], bots[p[1]], start, verbose=False, outfile=None)
if winner is not None:
winner = p[winner - 1]
wins[winner] += 1
playedgames += 1
print('Played {} out of {:.0f} games ({:.0f}%): {} \r'.format(playedgames, totalgames, playedgames/float(totalgames) * 100, wins))
print('Results:')
for i in range(len(bots)):
print(' bot {}: {} wins'.format(bots[i], wins[i]))
def features(state):
# type: (State) -> tuple[float, ...]
"""
Extract features from this state. Remember that every feature vector returned should have the same length.
:param state: A state to be converted to a feature vector
:return: A tuple of floats: a feature vector representing this state.
"""
feature_set = []
# Add player 1's points to feature set
p1_points = State.get_points(state, 1)
# Add player 2's points to feature set
p2_points = State.get_points(state, 2)
# Add player 1's pending points to feature set
p1_pending_points = State.get_pending_points(state, 1)
# Add plauer 2's pending points to feature set
p2_pending_points = State.get_pending_points(state, 2)
# Get trump suit
trump_suit = State.get_trump_suit(state)
# Add phase to feature set
phase = State.get_phase(state)
# Add stock size to feature set
stock_size = State.get_stock_size(state)
# Add leader to feature set
leader = State.leader(state)
# Add whose turn it is to feature set
whose_turn = State.whose_turn(state)
# Add opponent's played card to feature set
opponents_played_card = State.get_opponents_played_card(state)
################## You do not need to do anything below this line ########################
perspective = state.get_perspective()
# Perform one-hot encoding on the perspective.
# Learn more about one-hot here: https://machinelearningmastery.com/how-to-one-hot-encode-sequence-data-in-python/
perspective = [
card if card != 'U' else [1, 0, 0, 0, 0, 0] for card in perspective
]
perspective = [
card if card != 'S' else [0, 1, 0, 0, 0, 0] for card in perspective
]
perspective = [
card if card != 'P1H' else [0, 0, 1, 0, 0, 0] for card in perspective
]
perspective = [
card if card != 'P2H' else [0, 0, 0, 1, 0, 0] for card in perspective
]
perspective = [
card if card != 'P1W' else [0, 0, 0, 0, 1, 0] for card in perspective
]
perspective = [
card if card != 'P2W' else [0, 0, 0, 0, 0, 1] for card in perspective
]
# Append one-hot encoded perspective to feature_set
feature_set += list(chain(*perspective))
# Append normalized points to feature_set
total_points = p1_points + p2_points
feature_set.append(p1_points / total_points if total_points > 0 else 0.)
feature_set.append(p2_points / total_points if total_points > 0 else 0.)
# Append normalized pending points to feature_set
total_pending_points = p1_pending_points + p2_pending_points
feature_set.append(
p1_pending_points /
total_pending_points if total_pending_points > 0 else 0.)
feature_set.append(
p2_pending_points /
total_pending_points if total_pending_points > 0 else 0.)
# Convert trump suit to id and add to feature set
# You don't need to add anything to this part
suits = ["C", "D", "H", "S"]
trump_suit_onehot = [0, 0, 0, 0]
trump_suit_onehot[suits.index(trump_suit)] = 1
feature_set += trump_suit_onehot
# Append one-hot encoded phase to feature set
feature_set += [1, 0] if phase == 1 else [0, 1]
# Append normalized stock size to feature set
feature_set.append(stock_size / 10)
# Append one-hot encoded leader to feature set
feature_set += [1, 0] if leader == 1 else [0, 1]
# Append one-hot encoded whose_turn to feature set
feature_set += [1, 0] if whose_turn == 1 else [0, 1]
# Append one-hot encoded opponent's card to feature set
opponents_played_card_onehot = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
opponents_played_card_onehot[
opponents_played_card if opponents_played_card is not None else 20] = 1
feature_set += opponents_played_card_onehot
for index, element in enumerate(feature_set):
if element == None:
feature_set[index] = 0
# Return feature set
return feature_set
