def test_prefix_handling():
"""Test prefix validation for LogWriter."""
# Invalid tab character
catch_err_1 = False
try:
_ = LogWriter(header=["test"], prefix="\test")
except AttributeError:
catch_err_1 = True
assert catch_err_1
# Invalid backslash
catch_err_2 = False
try:
_ = LogWriter(header=["test"], prefix="/test")
except AttributeError:
catch_err_2 = True
assert catch_err_2
# Invalid dot character
catch_err_3 = False
try:
_ = LogWriter(header=["test"], prefix=".test")
except AttributeError:
catch_err_3 = True
assert catch_err_3
def init_type_log_writer(self):
"""Initialize Type Average Elo LogWriter."""
header = []
for conf in self.config:
header.append(conf["agent_type"])
self.type_log_writer = LogWriter(header, prefix="PKMNTypes")
def test_writer_basic():
"""Basic test for LogWriter class."""
lw1 = LogWriter(header=HEADER, prefix=TEST_ID)
dict_to_write = {}
dict_to_write["X"] = 10
dict_to_write["pew"] = "pew"
dict_to_write["Y"] = 20
lw1.write_line(dict_to_write)
lw1.write_line(dict_to_write)
def create_invalid_file():
"""
Create invalid file to test reader logic.
This file will have different headers, so it should
cause LogReader to generate a warning message.
"""
sleep(0.001)
lw_invalid = LogWriter(header=HEADER + ["pew2"], prefix=TEST_ID)
dict_to_write = {}
dict_to_write["X"] = 10
dict_to_write["pew"] = "pew"
dict_to_write["pew2"] = "pew2"
dict_to_write["Y"] = 20
lw_invalid.write_line(dict_to_write)
lw_invalid.write_line(dict_to_write)
def test_header_validation():
"""Test logic for checking header."""
catch_err = False
try:
_ = LogWriter(header=[])
except AttributeError:
catch_err = True
assert catch_err
def init_player_log_writer(self):
"""
Initialize player data LogWriter.
This LogWriter generates a record of the two players
who play a game (player-type and elo) and the outcome.
"""
header = []
header.append("player1.type")
header.append("player1.elo")
header.append("player2.type")
header.append("player2.elo")
header.append("outcome")
log_prefix = "{}Players".format(self.prefix)
self.player_log_writer = LogWriter(header, prefix=log_prefix)
def init_player_logwriter(player1, player2):
"""
Initialize the log writer to write the turns of this game.
Args:
player1 (PokemonAgent): The object that is Player 1.
player2 (PokemonAgent): The object that is Player 2.
Returns:
The log writer for a battle between player1 and player2.
"""
header = ["turn_num", "player_id", "active", "target", "move", "damage"]
turn_logwriter = LogWriter(header,
prefix="PKMNGame_{}_{}_{}".format(
player1.type, player2.type, uuid4()))
return turn_logwriter
def init_type_log_writer(self):
"""Initialize Type Average Elo LogWriter."""
header = []
if self.config:
temp_header = set()
for conf in self.config:
temp_header.add(conf["agent_type"])
header = sorted(list(temp_header))
else:
if self.proportions[0] != 0:
header.append("rock")
if self.proportions[1] != 0:
header.append("paper")
if self.proportions[2] != 0:
header.append("scissors")
if self.proportions[3] != 0:
header.append("uniform")
if self.proportions[4] != 0:
header.append("counter")
self.type_log_writer = LogWriter(header, prefix="RPSTypes")
class PokemonSimulation(BaseLoggingSimulation):
"""Class for Pokemon Simulation."""
def __init__(self, **kwargs):
"""
Initialize this simulation.
Args:
config (str): Filename for the population configs.
data_delay (int): Number of matches between gathering type data.
multithread (bool): Whether or not to run this simulation multithreaded.
"""
pkmn_kwargs = kwargs
pkmn_kwargs["game"] = PokemonEngine()
pkmn_kwargs["prefix"] = "PKMN"
self.config = load_config(kwargs["config"])
self.type_log_writer = None
self.data_delay = kwargs["data_delay"]
self.multithread = kwargs.get("multithread", False)
super().__init__(pkmn_kwargs)
def add_agents(self):
"""Add the agents to this model."""
for conf in self.config:
conf_tr = TeamReader(prefix=conf["team_file"])
conf_tr.process_files()
conf_team = conf_tr.teams[0]
for _ in range(int(self.num_players * conf["proportion"])):
pkmn_agent = None
if conf["agent_class"] == "basic":
pkmn_agent = PokemonAgent(team=conf_team)
pkmn_agent.type = conf["agent_type"]
elif conf["agent_class"] == "basicplanning":
pkmn_agent = BasicPlanningPokemonAgent(
tier=conf["agent_tier"], team=conf_team)
pkmn_agent.type = conf["agent_type"]
else:
raise RuntimeError("Invalid agent_class: {}".format(
conf["agent_class"]))
self.ladder.add_player(pkmn_agent)
def init_type_log_writer(self):
"""Initialize Type Average Elo LogWriter."""
header = []
for conf in self.config:
header.append(conf["agent_type"])
self.type_log_writer = LogWriter(header, prefix="PKMNTypes")
def run(self):
"""Run this simulation."""
if not self.multithread:
super().run()
return
battle_queue = Queue()
battle_results_queue = Queue()
type_results_queue = Queue()
for num in range(self.num_games):
battle_queue.put(num)
start_time = time()
# Threads to run the battles
for _ in range(4):
battle_thread = Thread(target=battle,
args=(self, battle_queue,
battle_results_queue,
type_results_queue, start_time))
battle_thread.start()
battle_queue.join()
while not battle_results_queue.empty():
output, player1, player2 = battle_results_queue.get()
self.write_player_log(output, player1, player2)
battle_results_queue.task_done()
while not type_results_queue.empty():
data_line = type_results_queue.get()
self.type_log_writer.write_line(data_line)
type_results_queue.task_done()
