def main(unused_argv): agent1 = myAgent() try: with sc2_env.SC2Env( map_name="Flat96", players=[ sc2_env.Agent(sc2_env.Race.terran), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=config.MAP_SIZE, minimap=config.MAP_SIZE), camera_width_world_units=config.MAP_SIZE * 1, action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=config.MAP_SIZE, use_unit_counts=True), score_index=-1, step_mul=32, disable_fog=False, visualize=True, realtime=False) as env: run_loop.run_loop([agent1], env) except KeyboardInterrupt: pass
def main(unused_argv): agent = ArcaneSwarm() try: while True: with sc2_env.SC2Env( map_name="AbyssalReef", players=[sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=84),use_feature_units=True), # Size of screen and minimap that the agent see visualize=True ) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def sc2_thread(*args): FLAGS(args) sc2env = sc2_env.SC2Env( map_name="MoveToBeacon", # players=[sc2_env.Agent(sc2_env.Race.terran), # sc2_env.Bot(sc2_env.Race.random, # sc2_env.Difficulty.very_easy)], players=[sc2_env.Agent(sc2_env.Race.terran)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True), step_mul=1, game_steps_per_episode=0, #screen_size_px=(128, 128), visualize=True) #visualize=False) sc2agent.setup(sc2env.observation_spec(), sc2env.action_spec()) timesteps = sc2env.reset() sc2agent.reset() # actrAgent.run() while True: step_actions = [sc2agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = sc2env.step(step_actions)
def run_thread(map_name, visualize): with sc2_env.SC2Env(map_name=map_name, players=[ sc2_env.Agent(sc2_env.Race.protoss), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy) ], step_mul=FLAGS.step_mul, game_steps_per_episode=FLAGS.game_steps_per_episode, agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=FLAGS.screen_resolution, minimap=FLAGS.minimap_resolution)), visualize=visualize) as env: env = available_actions_printer.AvailableActionsPrinter(env) agent = Agent( save_name= f'./data/{FLAGS.map}/{FLAGS.max_episodes}eps_{FLAGS.screen_resolution}res' ) # run_loop([agent], env, FLAGS.max_agent_steps) # agent.train(env, FLAGS.train) # agent.train(env, FLAGS.train, max_episodes=FLAGS.max_episodes) agent.evaluate(env) if FLAGS.save_replay: env.save_replay(Agent.__name__)
def setup_envs(num_of_envs, map_name, dimensions, game_steps, step_mul, to_visualize): """ setup pysc2 envs :param num_of_envs: number of envs to setup :param map_name: map to launch :param dimensions: feature layer dimensions :param game_steps: number of game steps to run for each episode :param step_mul: number of game steps run for each observation :param to_visualize: boolean to render visualise :return: list of pysc2 envs """ print("Setting up envs") environments = [] for _ in range(0, num_of_envs): try: env = sc2_env.SC2Env( map_name=map_name, players=[sc2_env.Agent(sc2_env.Race.terran)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=dimensions, minimap=dimensions), use_feature_units=True), step_mul=step_mul, game_steps_per_episode=game_steps, visualize=to_visualize, random_seed=1) environments.append(env) except Exception as e: print(e) print("Envs set up") return environments
def main(unused_argv): agent = ProtossAgentQLearning() try: while True: with sc2_env.SC2Env( map_name="Catalyst", players=[ sc2_env.Agent(sc2_env.Race.protoss), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True), step_mul=16, game_steps_per_episode=0, visualize=True, save_replay_episodes=0, replay_dir='E:\Program Files (x86)\StarCraft II\Replays' ) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(): agent = BayesAgent() try: while True: with sc2_env.SC2Env( map_name="Simple64", players=[ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.protoss, sc2_env.Difficulty.very_easy, sc2_env.BotBuild.power) ], agent_interface_format=features.AgentInterfaceFormat( action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=64, ), step_mul=16, disable_fog=True, game_steps_per_episode=15000, ) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(unused_argv): agent1 = myAgent() try: with sc2_env.SC2Env( map_name="3m_vs_3m", players=[sc2_env.Agent(sc2_env.Race.terran), ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=config.MAP_SIZE, minimap=config.MAP_SIZE), camera_width_world_units=config.MAP_SIZE * 1, action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=config.MAP_SIZE, ), score_index=0, step_mul=8, disable_fog=False, visualize=False, realtime=False, ) as env: run_loop.run_loop([agent1], env,max_episodes=config.EPISODES) except KeyboardInterrupt: pass
def main(unused_argv): agent = ZergAgent() try: while True: with sc2_env.SC2Env( map_name="AbyssalReef", players=[ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64)), step_mul=16, game_steps_per_episode=0, visualize=True) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(unused_argv): agent = ZergAgent() try: while True: # Choose environment, player, features with sc2_env.SC2Env( map_name="AbyssalReef", players=[ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=84, minimap=64), use_feature_units=True), # 16 step_mul is similar to 150 APM step_mul=16, game_steps_per_episode=0, visualize=True) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() # Looping, feed detail in agent, receive action then repeat till game end while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) except KeyboardInterrupt: pass
def main(unused_argv): #env = gym.make("SC2GYMENV-v0") #env.settings['map_name'] = 'ScoutSimple64' rs = FLAGS.random_seed if FLAGS.random_seed is None: rs = int((time.time() % 1) * 1000000) logger.configure(dir=FLAGS.train_log_dir, format_strs=['log']) players = [] players.append( sc2_env.Bot(races[FLAGS.bot_race], difficulties[FLAGS.difficulty])) players.append(sc2_env.Agent(races[FLAGS.agent_race])) screen_res = (int(FLAGS.screen_ratio * FLAGS.screen_resolution) // 4 * 4, FLAGS.screen_resolution) if FLAGS.agent_interface_format == 'feature': agent_interface_format = sc2_env.AgentInterfaceFormat( feature_dimensions=sc2_env.Dimensions( screen=screen_res, minimap=FLAGS.minimap_resolution)) elif FLAGS.agent_interface_format == 'rgb': agent_interface_format = sc2_env.AgentInterfaceFormat( rgb_dimensions=sc2_env.Dimensions( screen=screen_res, minimap=FLAGS.minimap_resolution)) else: raise NotImplementedError env = ZergScoutEnv( map_name=FLAGS.map, players=players, step_mul=FLAGS.step_mul, random_seed=rs, game_steps_per_episode=FLAGS.max_step, agent_interface_format=agent_interface_format, score_index=-1, # this indicates the outcome is reward disable_fog=FLAGS.disable_fog, visualize=FLAGS.render) env = make(FLAGS.wrapper, env) network = model(FLAGS.wrapper) #deepq.models.mlp([64, 32]) print('params, lr={} bf={} ef={} ef_eps={}'.format(FLAGS.param_lr, FLAGS.param_bf, FLAGS.param_ef, FLAGS.param_efps)) act = deepq.learn(env, q_func=network, lr=FLAGS.param_lr, max_timesteps=100000, buffer_size=FLAGS.param_bf, exploration_fraction=FLAGS.param_ef, exploration_final_eps=FLAGS.param_efps, checkpoint_path=FLAGS.checkpoint_path, checkpoint_freq=FLAGS.checkpoint_freq, print_freq=10, callback=callback)
def make_arena(game_name): if game_name in ['ImmortalZealotNoReset']: #TODO: add more maps os.environ["http_proxy"] = "" os.environ["https_proxy"] = "" inter_1 = get_mini_inter() inter_2 = get_mini_inter() players = [sc2_env.Agent(sc2_env.Race.terran), sc2_env.Agent(sc2_env.Race.terran)] env = SC2BaseEnv(players=players, agent_interface=None, map_name=game_name, screen_resolution=64, max_steps_per_episode=0, step_mul=1) env = MultiPlayerTerm(env) env = MergeUnits(env) env = EpisodicLife(env, max_lives=100, max_step=1000) env = EnvIntWrapper(env, [inter_1, inter_2]) else: print("Unknown game: '%s'" % str(game_name)) raise NotImplementedError return env
def main(unused_argv): """Run an agent.""" step_mul = FLAGS.step_mul players = 2 screen_res = (int(FLAGS.screen_ratio * FLAGS.screen_resolution) // 4 * 4, FLAGS.screen_resolution) agent_interface_format = None if FLAGS.agent_interface_format == 'feature': agent_interface_format = sc2_env.AgentInterfaceFormat( feature_dimensions=sc2_env.Dimensions( screen=screen_res, minimap=FLAGS.minimap_resolution)) elif FLAGS.agent_interface_format == 'rgb': agent_interface_format = sc2_env.AgentInterfaceFormat( rgb_dimensions=sc2_env.Dimensions( screen=screen_res, minimap=FLAGS.minimap_resolution)) else: raise NotImplementedError players = [ sc2_env.Agent(sc2_env.Race.zerg), sc2_env.Agent(sc2_env.Race.zerg) ] agents = [] bot_difficulty = get_difficulty(FLAGS.difficulty) if FLAGS.player1 == 'Bot': players[0] = sc2_env.Bot(sc2_env.Race.zerg, bot_difficulty) else: agents.append(get_agent(FLAGS.player1)) if FLAGS.player2 == 'Bot': players[1] = sc2_env.Bot(sc2_env.Race.zerg, bot_difficulty) else: agents.append(get_agent(FLAGS.player2)) with sc2_env.SC2Env(map_name=FLAGS.map, visualize=FLAGS.visualize, players=players, step_mul=step_mul, game_steps_per_episode=FLAGS.max_steps_per_episode * step_mul, agent_interface_format=agent_interface_format, disable_fog=FLAGS.disable_fog) as env: run_loop(agents, env, max_frames=0, max_episodes=FLAGS.episodes, sleep_time_per_step=FLAGS.sleep_time_per_step, merge_units_info=FLAGS.merge_units_info)
def __init__(self, **kwargs): super(__class__, self).__init__( map_name='MoveToBeacon', players=[sc2_env.Agent(sc2_env.Race.terran)], agent_interface_format=sc2_env.AgentInterfaceFormat( feature_dimensions=sc2_env.Dimensions(screen=84, minimap=64), ), **kwargs)
def main(): """Run agent""" agent = DefeatRoaches() players = [] players.append( sc2_env.Agent(sc2_env.Race[FLAGS.agent_race], 'CollectMineralShards')) run_thread(agent, players, FLAGS.visualize)
def _main(unused_argv): """Run agents""" if FLAGS.trace: stopwatch.sw.trace() elif FLAGS.profile: stopwatch.sw.enable() maps.get(FLAGS.map) # Assert the map exists. # Setup agents agent_module, agent_name = FLAGS.agent.rsplit(".", 1) agent_cls = getattr(importlib.import_module(agent_module), agent_name) print(agent_module, agent_name, agent_cls) agents = [] players = [] players.append( sc2_env.Agent(sc2_env.Race[FLAGS.agent_race], FLAGS.agent_name or agent_name)) for i in range(PARALLEL): agent = agent_cls(FLAGS.training, FLAGS.feature_minimap_size[0], FLAGS.feature_screen_size[0]) agent.build_model(i > 0, DEVICE[i % len(DEVICE)], FLAGS.net) agents.append(agent) config = tf.ConfigProto(allow_soft_placement=True) config.gpu_options.allow_growth = True sess = tf.Session(config=config) summary_writer = tf.summary.FileWriter(LOG) for i in range(PARALLEL): agents[i].setup(sess, summary_writer) agent.initialize() if not FLAGS.training or FLAGS.continuation: global COUNTER COUNTER = agent.load_model(SNAPSHOT) # Run threads # wrapper_func = run_train_and_eval wrapper_func = run_thread threads = [] for i in range(PARALLEL - 1): t = threading.Thread(target=wrapper_func, args=(agents[i], players, FLAGS.map, False)) threads.append(t) t.daemon = True t.start() time.sleep(5) wrapper_func(agents[-1], players, FLAGS.map, FLAGS.render) for t in threads: t.join() if FLAGS.profile: print(stopwatch.sw)
def main(unused_args): try: for i in range(n_games): print(f'Game {i+1}') with sc2_env.SC2Env( map_name=map_name, players=[ sc2_env.Agent(getattr(sc2_env.Race, agent.race_name)), sc2_env.Bot(getattr(sc2_env.Race, op_race), getattr(sc2_env.Difficulty, op_difficulty), getattr(sc2_env.BotBuild, op_build)) ], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions( screen=RESOLUTION, minimap=RESOLUTION), raw_resolution=RESOLUTION, use_feature_units=True, use_raw_units=True, use_raw_actions=agent.raw_interface, show_cloaked=True, show_burrowed_shadows=True, show_placeholders=True, add_cargo_to_units=True, crop_to_playable_area=True, raw_crop_to_playable_area=True, send_observation_proto=True), step_mul=STEP_MUL, score_index=features.ScoreCumulative.score, visualize=visualize, realtime=realtime, save_replay_episodes=save_replay_episodes, replay_dir='{}\\data\\replays'.format( os.path.abspath(os.getcwd()))) as env: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last() or time and agent.game_step * STEP_MUL > time_iter \ or agent.episode_length is not None \ and agent.game_step * STEP_MUL > agent.episode_length: break timesteps = env.step(step_actions) if time: break if isinstance(agent, SmartZerg): agent.net.save(r'data/net.h5') rewards = np.array([x for sub in agent.rewards for x in sub]) np.save(r'data/rewards.npy', rewards) except KeyboardInterrupt: agent.log.close() return agent
def make_env(opt): map_inst = maps.get(opt.map) players = [] agent_module, agent_name = opt.agent.rsplit(".", 1) players.append( sc2_env.Agent(sc2_env.Race[opt.agent_race], opt.agent_name or agent_name)) if map_inst.players >= 2: if opt.agent2 == "Bot": players.append( sc2_env.Bot(sc2_env.Race[opt.agent2_race], sc2_env.Difficulty[opt.difficulty], sc2_env.BotBuild[opt.bot_build])) else: agent_module, agent_name = opt.agent2.rsplit(".", 1) players.append( sc2_env.Agent(sc2_env.Race[opt.agent2_race], opt.agent2_name or agent_name)) env = sc2_env.SC2Env( map_name=opt.map, battle_net_map=opt.battle_net_map, players=players, agent_interface_format=sc2_env.parse_agent_interface_format( feature_screen=opt.feature_screen_size, feature_minimap=opt.feature_minimap_size, rgb_screen=opt.rgb_screen_size, rgb_minimap=opt.rgb_minimap_size, action_space=opt.action_space, use_feature_units=opt.use_feature_units, use_raw_units=opt.use_raw_units, use_camera_position=True, send_observation_proto=False, camera_width_world_units=48), step_mul=opt.step_mul, game_steps_per_episode=4000, disable_fog=opt.disable_fog, visualize=True, ensure_available_actions=True) return env
def main(unused_argv): """Run an agent.""" stopwatch.sw.enabled = FLAGS.profile or FLAGS.trace stopwatch.sw.trace = FLAGS.trace map_inst = maps.get(FLAGS.map) agent_classes = [] players = [] agent_module, agent_name = FLAGS.agent.rsplit(".", 1) agent_cls = getattr(importlib.import_module(agent_module), agent_name) agent_classes.append(agent_cls) players.append( sc2_env.Agent(sc2_env.Race[FLAGS.agent_race], FLAGS.agent_name or agent_name)) if map_inst.players >= 2: if FLAGS.agent2 == "Bot": players.append( sc2_env.Bot(sc2_env.Race[FLAGS.agent2_race], sc2_env.Difficulty[FLAGS.difficulty])) else: agent_module, agent_name = FLAGS.agent2.rsplit(".", 1) agent_cls = getattr(importlib.import_module(agent_module), agent_name) agent_classes.append(agent_cls) players.append( sc2_env.Agent(sc2_env.Race[FLAGS.agent2_race], FLAGS.agent2_name or agent_name)) threads = [] for _ in range(FLAGS.parallel - 1): t = threading.Thread(target=run_thread, args=(agent_classes, players, FLAGS.map, False)) threads.append(t) t.start() run_thread(agent_classes, players, FLAGS.map, FLAGS.render) for t in threads: t.join() if FLAGS.profile: print(stopwatch.sw)
def get_sc2_env(self, map_name): FLAGS = flags.FLAGS FLAGS(sys.argv) players = [sc2_env.Agent(sc2_env.Race.terran)] env = SC2Env(map_name=map_name, render=False, step_mul=32, players=players) return env
def make_sc2env(**kwargs): interface_format = sc2_env.parse_agent_interface_format( feature_screen=kwargs.pop('screen_size_px'), feature_minimap=kwargs.pop('minimap_size_px')) env = sc2_env.SC2Env(**kwargs, players=[sc2_env.Agent(sc2_env.Race.terran)], agent_interface_format=interface_format) # env = available_actions_printer.AvailableActionsPrinter(env) return env
def __init__(self, env_name): # Initialization # Environment and PPO parameters self.env_name = env_name players = [sc2_env.Agent(sc2_env.Race['terran'])] feature_screen_size = 128 feature_minimap_size = 32 rgb_screen_size = None rgb_minimap_size = None action_space = None use_feature_units = True use_raw_units = False step_mul = 2 game_steps_per_episode = None disable_fog = True visualize = False self.env = sc2_env.SC2Env( map_name=env_name, players=players, agent_interface_format=sc2_env.parse_agent_interface_format( feature_screen=feature_screen_size, feature_minimap=feature_minimap_size, rgb_screen=rgb_screen_size, rgb_minimap=rgb_minimap_size, action_space=action_space, use_feature_units=use_feature_units, use_raw_units=use_raw_units), step_mul=step_mul, game_steps_per_episode=game_steps_per_episode, disable_fog=disable_fog, visualize=visualize) #self.action_size = self.env.action_space.n self.EPISODES, self.max_average = 10000, 5.0 # specific for pong self.lr = 0.000025 self.epsilon = 0.1 self.ROWS = 80 self.COLS = 80 self.REM_STEP = 4 # Instantiate games and plot memory self.state_list, self.action_list, self.reward_list = [], [], [] self.scores, self.episodes, self.average = [], [], [] self.Save_Path = 'Models' self.state_size = (self.REM_STEP, self.ROWS, self.COLS) self.image_memory = np.zeros(self.state_size) if not os.path.exists(self.Save_Path): os.makedirs(self.Save_Path) self.path = '{}_A2C_{}'.format(self.env_name, self.lr) self.Model_name = os.path.join(self.Save_Path, self.path) # Create Actor-Critic network model self.Actor, self.Critic = OurModel()
def main(unused_argv): agent1 = TerranRLAgentWithRawActsAndRawObs() agent2 = TerranRandomAgent() try: with sc2_env.SC2Env( map_name="Simple64", players=[sc2_env.Agent(sc2_env.Race.terran), sc2_env.Agent(sc2_env.Race.terran)], agent_interface_format=features.AgentInterfaceFormat( action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=64, ), step_mul=8, disable_fog=True, ) as env: run_loop.run_loop([agent1, agent2], env, max_episodes=1000) except KeyboardInterrupt: pass
def main(unused_argv): agent1 = SmartAgent() agent2 = RandomAgent() try: with sc2_env.SC2Env( map_name="Simple64", players=[sc2_env.Agent(sc2_env.Race.terran), sc2_env.Agent(sc2_env.Race.terran)], agent_interface_format=features.AgentInterfaceFormat( action_space=actions.ActionSpace.RAW, use_raw_units=True, raw_resolution=64, ), step_mul=53, # 2400/step_mul = apm (48 step_mul is 50 apm, 53 is 45 apm) disable_fog=True, ) as env: run_loop.run_loop([agent1, agent2], env, max_episodes=1000) except KeyboardInterrupt: pass
def __init__(self, screen_size=32, minimap_size=32, visualize=False): self.sc2_env = sc2_env.SC2Env( map_name="MoveToBeacon", players=[sc2_env.Agent(sc2_env.Race.terran)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=screen_size, minimap=minimap_size), use_feature_units=True), step_mul=8, visualize=visualize)
def main(unused_argv): agent = SimpleAgent() map_name = "CollectMineralShards" # "CollectMineralShards" "Simple64" MoveToBeacon if map_name == "Simple64": players = [sc2_env.Agent(sc2_env.Race.terran), sc2_env.Bot(sc2_env.Race.random, sc2_env.Difficulty.very_easy) ]
def test_heterogeneous_observations(self): with sc2_env.SC2Env(map_name="Simple64", players=[ sc2_env.Agent(sc2_env.Race.random), sc2_env.Agent(sc2_env.Race.random) ], agent_interface_format=[ sc2_env.AgentInterfaceFormat( feature_dimensions=sc2_env.Dimensions( screen=(84, 87), minimap=(64, 67))), sc2_env.AgentInterfaceFormat( rgb_dimensions=sc2_env.Dimensions( screen=128, minimap=64)) ]) as env: obs_specs = env.observation_spec() self.assertIsInstance(obs_specs, tuple) self.assertLen(obs_specs, 2) actions_specs = env.action_spec() self.assertIsInstance(actions_specs, tuple) self.assertLen(actions_specs, 2) agents = [] for obs_spec, action_spec in zip(obs_specs, actions_specs): agent = random_agent.RandomAgent() agent.setup(obs_spec, action_spec) agent.reset() agents.append(agent) time_steps = env.reset() for _ in range(100): self.assertIsInstance(time_steps, tuple) self.assertLen(time_steps, 2) actions = [] for i, agent in enumerate(agents): time_step = time_steps[i] obs = time_step.observation self.check_observation_matches_spec(obs, obs_specs[i]) actions.append(agent.step(time_step)) time_steps = env.step(actions)
def test_returns_game_loop_zero_on_first_step_despite_override(self): with sc2_env.SC2Env( map_name="DefeatRoaches", players=[sc2_env.Agent(sc2_env.Race.random)], step_mul=1, agent_interface_format=AGENT_INTERFACE_FORMAT) as env: timestep = env.step(actions=[actions.FUNCTIONS.no_op()], step_mul=1234) self.assertEqual(timestep[0].observation.game_loop[0], 0)
def get_starcraft_env(self, sc2_map, render, step_m): FLAGS = flags.FLAGS FLAGS(sys.argv) players = [sc2_env.Agent(sc2_env.Race.terran)] env = SC2Env(map_name=sc2_map, render=render, players=players, step_mul=step_m, realtime=self.sc2_real_time_rendering) return env
def main(unused_argv): # agent = MoveToBeaconAgent() agent = MoveToBeaconSarsa() try: """ aif = features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=_SCREEN, minimap=_MINIMAP), # rgb_dimensions=features.Dimensions(screen=512, minimap=128), use_feature_units=True, action_space=actions.ActionSpace.FEATURES ) """ with sc2_env.SC2Env( map_name="MoveToBeacon", players=[sc2_env.Agent(sc2_env.Race.terran)], agent_interface_format=features.AgentInterfaceFormat( feature_dimensions=features.Dimensions(screen=_SCREEN, minimap=_MINIMAP), use_feature_units=True ), step_mul=8, game_steps_per_episode=0, visualize=_VISUALIZE ) as env: run_loop.run_loop([agent], env, max_episodes=_EPISODES) if _LEARN: agent.ql.save_q_table() """ while True: agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: step_actions = [agent.step(timesteps[0])] if timesteps[0].last(): break timesteps = env.step(step_actions) agent.ql.save_q_table() # agent.ql.print_q() """ except KeyboardInterrupt: print("Exception") agent.ql.save_q_table() pass