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
