def test_choose_random_move_doubles(example_doubles_request):
logger = MagicMock()
battle = DoubleBattle("tag", "username", logger)
battle._parse_request(example_doubles_request)
battle._switch("p2a: Tyranitar", "Tyranitar, L50, M", "48/48")
player = RandomPlayer()
active_pokemon_1, active_pokemon_2 = battle.active_pokemon
choice_1 = player.choose_random_move(battle)
assert (any([move in choice_1 for move in active_pokemon_1.moves])
or "/choose switch" in choice_1)
assert (any([move in choice_1 for move in active_pokemon_2.moves])
or ",switch" in choice_1)
choices_100 = [player.choose_random_move(battle) for _ in range(100)]
assert not any([" 2" in choice for choice in choices_100])
assert any(["1" in choice for choice in choices_100])
assert any(["-1" in choice for choice in choices_100])
assert any(["-2" in choice for choice in choices_100])
assert any(["dynamax" in choice for choice in choices_100])
assert not any([choice.count("dynamax") == 2 for choice in choices_100])
assert any([choice.count("switch") == 2 for choice in choices_100])
battle._switch("p2b: Charizard", "Charizard, L50, M", "48/48")
choices_100 = [player.choose_random_move(battle) for _ in range(100)]
assert any([" 2" in choice for choice in choices_100])
async def main():
# We create two players
player_1 = RandomPlayer(battle_format="gen8ou",
team=custom_builder,
max_concurrent_battles=10)
player_2 = RandomPlayer(battle_format="gen8ou",
team=custom_builder,
max_concurrent_battles=10)
await player_1.battle_against(player_2, n_battles=5)
async def simple_ladderring(n_battles, max_concurrent_battles):
players = [
RandomPlayer(max_concurrent_battles=max_concurrent_battles),
RandomPlayer(max_concurrent_battles=max_concurrent_battles),
]
await asyncio.gather(players[0].ladder(n_battles),
players[1].ladder(n_battles))
for player in players:
await player.stop_listening()
async def main():
p1 = RandomPlayer(
max_concurrent_battles=int(sys.argv[3]), log_level=int(sys.argv[2])
)
p2 = RandomPlayer(
max_concurrent_battles=int(sys.argv[3]), log_level=int(sys.argv[2])
)
await p1.battle_against(p2, n_battles=int(sys.argv[1]) % int(sys.argv[3]))
for _ in tqdm(range(int(sys.argv[1]) // int(sys.argv[3]))):
await p1.battle_against(p2, n_battles=int(sys.argv[3]))
def test_choose_random_move_doubles(pseudo_random, example_doubles_request):
logger = MagicMock()
battle = DoubleBattle("tag", "username", logger)
player = RandomPlayer()
battle._parse_request(example_doubles_request)
battle._switch("p2a: Tyranitar", "Tyranitar, L50, M", "48/48")
pseudo_random.side_effect = lambda: 0
choice = player.choose_random_move(battle)
assert choice.message == "/choose move psychic -2, move geargrind -1"
pseudo_random.side_effect = lambda: 0.5
choice = player.choose_random_move(battle)
assert (choice.message ==
"/choose switch zamazentacrowned, move geargrind dynamax -1")
pseudo_random.side_effect = lambda: 0.999
choice = player.choose_random_move(battle)
assert choice.message == "/choose move slackoff dynamax, switch thundurus"
battle._switch("p2b: Excadrill", "Excadrill, L50, M", "48/48")
pseudo_random.side_effect = lambda: 0
choice = player.choose_random_move(battle)
assert choice.message == "/choose move psychic -2, move geargrind -1"
pseudo_random.side_effect = lambda: 0.5
choice = player.choose_random_move(battle)
assert choice.message == "/choose move slackoff, move wildcharge dynamax 2"
pseudo_random.side_effect = lambda: 0.999
choice = player.choose_random_move(battle)
assert choice.message == "/choose move slackoff dynamax, switch thundurus"
async def main():
# Configs for random agents, one from class defined above, one from library.
player1 = PlayerConfiguration("Manual Random", None)
player2 = PlayerConfiguration("Library Random", None)
# Create the players from configs.
players = [
RandomAgent(
player_configuration=player1,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
),
RandomPlayer(
player_configuration=player2,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
)
]
# Get results from 10 games
cross_evaluation = await cross_evaluate(players, n_challenges=10)
# Display results in a nice format
table = [["-"] + [p.username for p in players]]
for p_1, results in cross_evaluation.items():
table.append([p_1] + [cross_evaluation[p_1][p_2] for p_2 in results])
print(tabulate(table))
async def main():
start = time.time()
# We define two player configurations.
player_1_configuration = PlayerConfiguration("Random player", None)
player_2_configuration = PlayerConfiguration("Max damage player", None)
# We create the corresponding players.
random_player = RandomPlayer(
player_configuration=player_1_configuration,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
)
max_damage_player = MaxDamagePlayer(
player_configuration=player_2_configuration,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
)
# Now, let's evaluate our player
cross_evaluation = await cross_evaluate([random_player, max_damage_player],
n_challenges=100)
print("Max damage player won %d / 100 battles [this took %f seconds]" % (
cross_evaluation[max_damage_player.username][random_player.username] *
100,
time.time() - start,
))
async def main():
# First, we define three player configurations.
player_1_configuration = PlayerConfiguration("Player 1", None)
player_2_configuration = PlayerConfiguration("Player 2", None)
player_3_configuration = PlayerConfiguration("Player 3", None)
# Then, we create the corresponding players.
players = [
RandomPlayer(
player_configuration=player_config,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
max_concurrent_battles=10,
)
for player_config in [
player_1_configuration,
player_2_configuration,
player_3_configuration,
]
]
# Now, we can cross evaluate them: every player will player 20 games against every
# other player.
cross_evaluation = await cross_evaluate(players, n_challenges=20)
# Defines a header for displaying results
table = [["-"] + [p.username for p in players]]
# Adds one line per player with corresponding results
for p_1, results in cross_evaluation.items():
table.append([p_1] + [cross_evaluation[p_1][p_2] for p_2 in results])
# Displays results in a nicely formatted table.
print(tabulate(table))
async def test_laddering_parallel():
async def send_message(self, *args, **kwargs):
interactions.append("Search start")
asyncio.ensure_future(start_battle())
async def start_battle():
interactions.append(f"Battle {player.count} start")
await player._handle_message(
f">battle-gen8randombattle-{player.count}\n|init|battle")
asyncio.ensure_future(end_battle(player.count))
player.count += 1
async def end_battle(count):
await asyncio.sleep(0.01)
interactions.append(f"Battle {count} end")
await player._handle_message(
f">battle-gen8randombattle-{count}\n|win|{player.username}")
player = RandomPlayer(start_listening=False, max_concurrent_battles=3)
player.count = 0
type(player)._send_message = send_message
player.logged_in.set()
interactions = []
await asyncio.wait_for(asyncio.gather(player.ladder(5)), timeout=1)
assert set(interactions) == set([
"Search start",
"Battle 0 start",
"Search start",
"Battle 1 start",
"Search start",
"Battle 2 start",
"Battle 0 end",
"Battle 1 end",
"Battle 2 end",
"Search start",
"Battle 3 start",
"Search start",
"Battle 4 start",
"Battle 3 end",
"Battle 4 end",
])
for i in range(3):
assert interactions[2 * i] == "Search start"
assert interactions[2 * i + 1] == "Battle %d start" % i
async def test_player_evaluation_assertions():
p = RandomPlayer(battle_format="gen8ou", start_listening=False)
with pytest.raises(AssertionError):
await evaluate_player(p)
p = RandomPlayer(start_listening=False)
with pytest.raises(AssertionError):
await evaluate_player(p, n_battles=0)
with pytest.raises(AssertionError):
await evaluate_player(p, n_battles=-10)
with pytest.raises(AssertionError):
await evaluate_player(p, n_placement_battles=0)
with pytest.raises(AssertionError):
await evaluate_player(p, n_placement_battles=-10)
async def main():
# First, we define three player configurations.
player_1_configuration = PlayerConfiguration("Player 1", None)
player_2_configuration = PlayerConfiguration("Player 2", None)
player_3_configuration = PlayerConfiguration("Max Damage Player", None)
player_4_configuration = PlayerConfiguration("Type Damage Player", None)
cheater_player_config = PlayerConfiguration("Cheater Player", None)
#player_custom_configuration = PlayerConfiguration("Custom Player", None)
#player_test_configuration = PlayerConfiguration("Test Player", None)
# # Then, we create the corresponding players.
players = []
players.extend([
RandomPlayer(
player_configuration=player_config,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
max_concurrent_battles=max_concurrent_battles,
) for player_config in [
player_4_configuration
# player_2_configuration,
]
])
# players.extend(
# CheaterPlayer(
# player_configuration=player_config,
# battle_format="gen7randombattle",
# server_configuration=LocalhostServerConfiguration,
# max_concurrent_battles=max_concurrent_battles,
# )
# for player_config in [
# player_custom_configuration,
# ]
# )
players.extend([
CheaterPlayer(
player_configuration=player_config,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
max_concurrent_battles=max_concurrent_battles,
) for player_config in [cheater_player_config]
])
# Now, we can cross evaluate them: every player will player 20 games against every
# other player.
cross_evaluation = await cross_evaluate(players, n_challenges=20)
# Defines a header for displaying results
table = [["-"] + [p.username for p in players]]
# Adds one line per player with corresponding results
for p_1, results in cross_evaluation.items():
table.append([p_1] + [cross_evaluation[p_1][p_2] for p_2 in results])
# Displays results in a nicely formatted table.
print(tabulate(table))
def test_random_gym_players_gen7():
env_player = RandomGen7EnvPlayer(log_level=20)
random_player = RandomPlayer(battle_format="gen7randombattle",
log_level=20)
env_player.play_against(
env_algorithm=play_function,
opponent=random_player,
env_algorithm_kwargs={"n_battles": 3},
)
async def main():
# We create a random player
player = RandomPlayer(
player_configuration=PlayerConfiguration("bot_username", "bot_password"),
server_configuration=ShowdownServerConfiguration,
)
# Sending challenges to 'your_username'
await player.send_challenges("your_username", n_challenges=1)
async def main():
start = time.time()
# We create two players.
random_player = RandomPlayer(battle_format="gen8randombattle")
max_damage_player = MaxDamagePlayer(battle_format="gen8randombattle")
# Now, let's evaluate our player
await max_damage_player.battle_against(random_player, n_battles=100)
print("Max damage player won %d / 100 battles [this took %f seconds]" %
(max_damage_player.n_won_battles, time.time() - start))
def __init__(self,
player,
model,
policy_dict,
agent_dict,
opponent=RandomPlayer(battle_format="gen8randombattle"),
nbsteps=100000,
**kwargs):
super().__init__(player, model, policy_dict, agent_dict, **kwargs)
self.opponent = opponent if isinstance(
opponent, Player) else PlayerFactory.get_player(**opponent)
self.nbsteps = nbsteps
def test_choose_random_move_doubles(pseudo_random, example_doubles_request):
# possible_choices_memo = (
# []
# ) # this needs to be reset at each start of Player.choose_random_move
# def count_substrings(substring: str, in_: List[str]) -> int:
# return sum(map(lambda el: substring in el, in_))
# def choose_non_dynamax(first_orders,) -> str:
# joined = DoubleBattleOrder.join_orders(possible_choices)
# possible_choices_memo.append(possible_choices.copy())
# for possible_choice in possible_choices:
# if " dynamax" not in possible_choice:
# return possible_choice
# raise ValueError(f"Only max moves are available in {possible_choices}")
logger = MagicMock()
battle = DoubleBattle("tag", "username", logger)
player = RandomPlayer()
battle._parse_request(example_doubles_request)
battle._switch("p2a: Tyranitar", "Tyranitar, L50, M", "48/48")
pseudo_random.side_effect = lambda: 0
choice = player.choose_random_move(battle)
assert choice.message == "/choose move psychic -2, move geargrind -1"
pseudo_random.side_effect = lambda: 0.5
choice = player.choose_random_move(battle)
assert (choice.message ==
"/choose switch zamazentacrowned, move geargrind dynamax -1")
pseudo_random.side_effect = lambda: 0.999
choice = player.choose_random_move(battle)
assert choice.message == "/choose move slackoff dynamax, switch thundurus"
battle._switch("p2b: Excadrill", "Excadrill, L50, M", "48/48")
pseudo_random.side_effect = lambda: 0
choice = player.choose_random_move(battle)
assert choice.message == "/choose move psychic -2, move geargrind -1"
pseudo_random.side_effect = lambda: 0.5
choice = player.choose_random_move(battle)
assert choice.message == "/choose move slackoff, move wildcharge dynamax 2"
pseudo_random.side_effect = lambda: 0.999
choice = player.choose_random_move(battle)
assert choice.message == "/choose move slackoff dynamax, switch thundurus"
async def cross_evaluation(n_battles, format_, teams):
players = [
RandomPlayer(
player_configuration=PlayerConfiguration("Player %d" % i, None),
battle_format=format_,
server_configuration=LocalhostServerConfiguration,
max_concurrent_battles=n_battles,
team=team,
) for i, team in enumerate(teams)
]
await cross_evaluate(players, n_challenges=n_battles)
for player in players:
await player.stop_listening()
async def simple_cross_evaluation(n_battles, format_):
players = [
RandomPlayer(
battle_format=format_,
server_configuration=LocalhostServerConfiguration,
max_concurrent_battles=n_battles,
log_level=20,
)
for _ in range(3)
]
await cross_evaluate(players, n_challenges=n_battles)
for player in players:
await player.stop_listening()
async def main():
start = time.time()
# We define two player configurations.
player_1_configuration = PlayerConfiguration("Random Player", None)
player_2_configuration = PlayerConfiguration("Tabular Q Player", None)
# We create the corresponding players.
random_player = RandomPlayer(
player_configuration=player_1_configuration,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
)
tabular_q_player = TabularQPlayer(
player_configuration=player_2_configuration,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
)
#defines training protocols
spars = 10
battles = 100
n_challenges = 1
q_wins = []
game_count = []
for s in range(spars):
print('spar ' + str(s))
battle_wins = 0
for b in range(battles):
cross_evaluation = await cross_evaluate(
[random_player, tabular_q_player], n_challenges)
battle_win_rate = cross_evaluation[tabular_q_player.username][
random_player.username]
battle_wins = battle_wins + battle_win_rate
#information for matplotlib graphing on jupyter
q_wins.append(((battle_wins) / (battles)) * 100.0)
game_count.append((s + 1) * battles)
print('done')
print(q_wins)
print(game_count)
print(time.time() - start)
def test_two_successive_calls_gen8():
env_player = RandomGen8EnvPlayer(battle_format="gen8randombattle",
log_level=20)
random_player = RandomPlayer(battle_format="gen8randombattle",
log_level=20)
env_player.play_against(
env_algorithm=play_function,
opponent=random_player,
env_algorithm_kwargs={"n_battles": 2},
)
env_player.play_against(
env_algorithm=play_function,
opponent=random_player,
env_algorithm_kwargs={"n_battles": 2},
)
async def main():
diagnostics = []
team_1 = """
Lucario (M) @ Assault Vest
Ability: Justified
EVs: 4 HP / 252 SpA / 252 Spe
Modest Nature
- Focus Blast
- Aura Sphere
"""
team_2 = """
Bisharp (M) @ Life Orb
Ability: Defiant
EVs: 4 HP / 252 Atk / 252 Spe
Adamant Nature
- Brick Break"""
diagnostics.append([team_1, team_2])
team_1 = """
Lucario (M) @ Choice Specs
Ability: Justified
EVs: 4 HP / 252 SpA / 252 Spe
Modest Nature
- Aura Sphere
"""
team_2 = """
Lapras (M) @ Leftovers
Level: 100
Ability: Shell Armor
EVs: 4 HP / 252 SpA / 252 Spe
Modest Nature
- Water Gun"""
diagnostics.append([team_1, team_2])
# We create two players.
for team_1, team_2 in diagnostics:
random_player = RandomPlayer(battle_format="gen8ou",
team=team_2,
max_concurrent_battles=10)
max_damage_player = MaxDamagePlayer(battle_format="gen8ou",
team=team_1,
max_concurrent_battles=10)
# Now, let's evaluate our player
cross_evaluation = await cross_evaluate(
[random_player, max_damage_player], n_challenges=50)
print("Max damage player won %d / 100 battles" % (cross_evaluation[
max_damage_player.username][random_player.username] * 100))
async def main():
player_1_configuration = PlayerConfiguration("Player 1", None)
player_2_configuration = PlayerConfiguration("Player 2", None)
p1 = RandomPlayer(
player_configuration=player_1_configuration,
battle_format="gen8nationaldexag",
server_configuration=LocalhostServerConfiguration,
team=RandomTeambuilder(),
max_concurrent_battles=int(sys.argv[3]),
log_level=int(sys.argv[2]),
)
p2 = RandomPlayer(
player_configuration=player_2_configuration,
battle_format="gen8nationaldexag",
server_configuration=LocalhostServerConfiguration,
team=RandomTeambuilder(),
max_concurrent_battles=int(sys.argv[3]),
log_level=int(sys.argv[2]),
)
await asyncio.gather(
p1.send_challenges(
opponent=to_id_str(p2.username),
n_challenges=int(sys.argv[1]) % int(sys.argv[3]),
to_wait=p2.logged_in,
),
p2.accept_challenges(
opponent=to_id_str(p1.username),
n_challenges=int(sys.argv[1]) % int(sys.argv[3]),
),
)
for _ in tqdm(range(int(sys.argv[1]) // int(sys.argv[3]))):
await asyncio.gather(
p1.send_challenges(
opponent=to_id_str(p2.username),
n_challenges=int(sys.argv[3]),
to_wait=p2.logged_in,
),
p2.accept_challenges(
opponent=to_id_str(p1.username), n_challenges=int(sys.argv[3])
),
)
def test_random_gym_player_gen8():
env_player = RandomEnvPlayer(
player_configuration=PlayerConfiguration("EnvPlayerGen8", None),
battle_format="gen8randombattle",
server_configuration=LocalhostServerConfiguration,
)
random_player = RandomPlayer(
player_configuration=PlayerConfiguration("RandomPlayerGen8", None),
battle_format="gen8randombattle",
server_configuration=LocalhostServerConfiguration,
)
env_player.play_against(
env_algorithm=play_function,
opponent=random_player,
env_algorithm_kwargs={"n_battles": 5},
)
async def main():
# We create three random players
players = [RandomPlayer(max_concurrent_battles=10) for _ in range(3)]
# Now, we can cross evaluate them: every player will player 20 games against every
# other player.
cross_evaluation = await cross_evaluate(players, n_challenges=20)
# Defines a header for displaying results
table = [["-"] + [p.username for p in players]]
# Adds one line per player with corresponding results
for p_1, results in cross_evaluation.items():
table.append([p_1] + [cross_evaluation[p_1][p_2] for p_2 in results])
# Displays results in a nicely formatted table.
print(tabulate(table))
async def evaluate_max_damage():
"""
Evaluate performance of max damage player against regular player
:return:
None
"""
start = time.time()
# We create two players.
random_player = RandomPlayer(battle_format="gen8randombattle", )
max_damage_player = MaxDamagePlayer(battle_format="gen8randombattle", )
# Now, let's evaluate our player
await max_damage_player.battle_against(random_player, n_battles=100)
print("Max damage player won %d / 100 battles [this took %f seconds]" %
(max_damage_player.n_won_battles, time.time() - start))
async def simple_cross_evaluation(n_battles, finished):
player_1_configuration = PlayerConfiguration("Player 1", None)
player_2_configuration = PlayerConfiguration("Player 2", None)
player_3_configuration = PlayerConfiguration("Player 3", None)
players = [
RandomPlayer(
player_configuration=player_config,
battle_format="gen7randombattle",
server_configuration=LocalhostServerConfiguration,
max_concurrent_battles=n_battles,
) for player_config in [
player_1_configuration,
player_2_configuration,
player_3_configuration,
]
]
await cross_evaluate(players, n_challenges=n_battles)
for player in players:
await player.stop_listening()
async def simple_cross_evaluation(n_battles, format_, i=0):
player_1_configuration = PlayerConfiguration("Player %d" % (i + 1), None)
player_2_configuration = PlayerConfiguration("Player %d" % (i + 2), None)
player_3_configuration = PlayerConfiguration("Player %d" % (i + 3), None)
players = [
RandomPlayer(
player_configuration=player_config,
battle_format=format_,
server_configuration=LocalhostServerConfiguration,
max_concurrent_battles=n_battles,
) for player_config in [
player_1_configuration,
player_2_configuration,
player_3_configuration,
]
]
await cross_evaluate(players, n_challenges=n_battles)
for player in players:
await player.stop_listening()
async def training(future, child, opponent):
# We define two player configurations.
player_1_configuration = PlayerConfiguration("Agent player", None)
player_2_configuration = PlayerConfiguration("Enemy player", None)
# We create the corresponding players.
agent_player = PokeAgent(
player_configuration=player_1_configuration,
battle_format="gen7letsgorandombattle",
server_configuration=LocalhostServerConfiguration,
conn=child
)
if opponent == "random":
enemy_player = RandomPlayer(
player_configuration=player_2_configuration,
battle_format="gen7letsgorandombattle",
server_configuration=LocalhostServerConfiguration,
)
else:
enemy_player = AggressivePlayer(
player_configuration=player_2_configuration,
battle_format="gen7letsgorandombattle",
server_configuration=LocalhostServerConfiguration,
)
episodes = 800
while episodes > 0:
await agent_player.train_against(enemy_player, 1)
episodes -=1
if agent_player.epsilon > agent_player.min_epsilon:
agent_player.epsilon = max(agent_player.epsilon * agent_player.epsilon_decay, agent_player.min_epsilon)
if (800 - episodes == 1 or 800 - episodes == 100 or 800 - episodes == 200
or 800 - episodes == 300 or 800 - episodes == 400 or 800 - episodes == 500
or 800 - episodes == 600 or 800 - episodes == 700 or 800 - episodes == 800):
print("Fiz " + str(800 - episodes) + " batalhas - SAVING MODEL")
agent_player.conn.send([-3, 800 - episodes])
print("Terminei")
future.set_result("I'm done!")
agent_player.conn.send([-1])
async def main():
# We create a random player
player = RandomPlayer(
player_configuration=PlayerConfiguration("bot_username", "bot_password")
server_configuration=ShowdownServerConfiguration,
)
# Sending challenges to 'your_username'
await player.send_challenges("your_username", n_challenges=1)
# Accepting one challenge from any user
await player.accept_challenges(None, 1)
# Accepting three challenges from 'your_username'
await player.accept_challenges('your_username', 3)
# Playing 5 games on the ladder
await player.ladder(5)
# Print the rating of the player and its opponent after each battle
for battle in player.battles.values():
print(battle.rating, battle.opponent_rating)
async def evaluating(future, child, opponent):
# We define two player configurations.
player_1_configuration = PlayerConfiguration("Agent player", None)
player_2_configuration = PlayerConfiguration("Enemy player", None)
# We create the corresponding players.
agent_player = PokeAgent(
player_configuration=player_1_configuration,
battle_format="gen7letsgorandombattle",
server_configuration=LocalhostServerConfiguration,
conn=child,
train=False
)
if opponent == "random":
enemy_player = RandomPlayer(
player_configuration=player_2_configuration,
battle_format="gen7letsgorandombattle",
server_configuration=LocalhostServerConfiguration,
)
else:
enemy_player = AggressivePlayer(
player_configuration=player_2_configuration,
battle_format="gen7letsgorandombattle",
server_configuration=LocalhostServerConfiguration,
)
n_battles = 100
won_battles = 0
while n_battles > 0:
cross_evaluation = await cross_evaluate(
[agent_player, enemy_player], n_challenges=1
)
n_battles -= 1
won_battles += cross_evaluation[agent_player.username][enemy_player.username]
print("Agent won {} / 100 battles".format(won_battles))
future.set_result("I'm done!")
agent_player.conn.send([-1])