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])