def _connect_remote(self, host, host_port, lan_ports, race, name, map_inst,
save_map, interface):
"""Make sure this stays synced with bin/agent_remote.py."""
# Connect!
logging.info("Connecting...")
self._controllers = [
remote_controller.RemoteController(host, host_port)
]
logging.info("Connected")
if map_inst and save_map:
run_config = run_configs.get()
self._controllers[0].save_map(map_inst.path,
map_inst.data(run_config))
# Create the join request.
join = sc_pb.RequestJoinGame(options=interface)
join.race = race
join.player_name = name
join.shared_port = 0 # unused
join.server_ports.game_port = lan_ports.pop(0)
join.server_ports.base_port = lan_ports.pop(0)
join.client_ports.add(game_port=lan_ports.pop(0),
base_port=lan_ports.pop(0))
logging.info("Joining game.")
self._controllers[0].join_game(join)
self._in_game = True
logging.info("Game joined.")
def __init__(self, run_config, full_screen=False, game_version=None,
data_version=None, **kwargs):
self._proc = None
self._sock = None
self._controller = None
self._tmp_dir = tempfile.mkdtemp(prefix="sc-", dir=run_config.tmp_dir)
self._port = portpicker.pick_unused_port()
exec_path = run_config.exec_path(game_version)
self._check_exists(exec_path)
args = [
exec_path,
"-listen", "127.0.0.1",
"-port", str(self._port),
"-dataDir", os.path.join(run_config.data_dir, ""),
"-tempDir", os.path.join(self._tmp_dir, ""),
"-displayMode", "1" if full_screen else "0",
]
if data_version:
args += ["-dataVersion", data_version]
try:
self._proc = self._launch(run_config, args, **kwargs)
self._sock = self._connect(self._port)
client = protocol.StarcraftProtocol(self._sock)
self._controller = remote_controller.RemoteController(client)
with sw("startup"):
self._controller.ping()
except:
self.close()
raise
def _connect_remote(self, host, host_port, lan_port, race, map_inst,
interface):
"""Make sure this stays synced with bin/agent_remote.py."""
# Connect!
logging.info("Connecting...")
self._controllers = [
remote_controller.RemoteController(host, host_port)
]
logging.info("Connected")
# Create the join request.
ports = [lan_port + p
for p in range(4)] # 2 * num players *in the game*.
join = sc_pb.RequestJoinGame(options=interface)
join.race = race
join.shared_port = 0 # unused
join.server_ports.game_port = ports.pop(0)
join.server_ports.base_port = ports.pop(0)
join.client_ports.add(game_port=ports.pop(0), base_port=ports.pop(0))
if map_inst:
run_config = run_configs.get()
self._controllers[0].save_map(map_inst.path,
map_inst.data(run_config))
self._controllers[0].join_game(join)
def testVsAgent(self):
parallel = run_parallel.RunParallel()
for _ in range(NUM_MATCHES):
with host_remote_agent.VsAgent() as game:
game.create_game("Simple64")
controllers = [
remote_controller.RemoteController(host=host,
port=host_port)
for host, host_port in zip(game.hosts, game.host_ports)
]
join = sc_pb.RequestJoinGame(options=sc_pb.InterfaceOptions(
raw=True))
join.race = sc_common.Random
join.shared_port = 0
join.server_ports.game_port = game.lan_ports[0]
join.server_ports.base_port = game.lan_ports[1]
join.client_ports.add(game_port=game.lan_ports[2],
base_port=game.lan_ports[3])
parallel.run((c.join_game, join) for c in controllers)
for _ in range(STEPS):
parallel.run(c.step for c in controllers)
response_observations = [c.observe() for c in controllers]
if response_observations[0].player_result:
break
parallel.run(c.leave for c in controllers)
parallel.run(c.close for c in controllers)
def __init__(self,
run_config,
exec_path,
data_version=None,
full_screen=False,
extra_args=None,
verbose=False,
host="127.0.0.1",
connect=True,
**kwargs):
self._proc = None
self._controller = None
self._tmp_dir = tempfile.mkdtemp(prefix="sc-", dir=run_config.tmp_dir)
self._host = host
self._port = portpicker.pick_unused_port()
self._check_exists(exec_path)
args = [
exec_path,
"-listen",
host,
"-port",
str(self._port),
"-dataDir",
os.path.join(run_config.data_dir, ""),
"-tempDir",
os.path.join(self._tmp_dir, ""),
"-displayMode",
"1" if full_screen else "0",
]
if verbose or FLAGS.sc2_verbose:
args += ["-verbose"]
if data_version:
args += ["-dataVersion", data_version.upper()]
if extra_args:
args += extra_args
logging.info("Launching SC2: %s", " ".join(args))
try:
with sw("startup"):
self._proc = self._launch(run_config, args, **kwargs)
if connect:
self._controller = remote_controller.RemoteController(
host, self._port, self)
except:
self.close()
raise
def testVsBot(self):
bot_first = True
for _ in range(NUM_MATCHES):
with host_remote_agent.VsBot() as game:
game.create_game(map_name="Simple64",
bot_difficulty=sc_pb.VeryHard,
bot_first=bot_first)
controller = remote_controller.RemoteController(
host=game.host, port=game.host_port)
join = sc_pb.RequestJoinGame(options=sc_pb.InterfaceOptions(
raw=True))
join.race = sc_common.Random
controller.join_game(join)
for _ in range(STEPS):
controller.step()
response_observation = controller.observe()
if response_observation.player_result:
break
controller.leave()
controller.close()
bot_first = not bot_first
def __init__(self, run_config, exec_path, version, full_screen=False,
extra_args=None, verbose=False, host=None, port=None,
connect=True, timeout_seconds=None, window_size=(640, 480),
window_loc=(50, 50), **kwargs):
"""Launch the SC2 process.
Args:
run_config: `run_configs.lib.RunConfig` object.
exec_path: Path to the binary to run.
version: `run_configs.lib.Version` object.
full_screen: Whether to launch the game window full_screen on win/mac.
extra_args: List of additional args for the SC2 process.
verbose: Whether to have the SC2 process do verbose logging.
host: IP for the game to listen on for its websocket. This is
usually "127.0.0.1", or "::1", but could be others as well.
port: Port SC2 should listen on for the websocket.
connect: Whether to create a RemoteController to connect.
timeout_seconds: Timeout for the remote controller.
window_size: Screen size if not full screen.
window_loc: Screen location if not full screen.
**kwargs: Extra arguments for _launch (useful for subclasses).
"""
self._proc = None
self._controller = None
self._check_exists(exec_path)
self._tmp_dir = tempfile.mkdtemp(prefix="sc-", dir=run_config.tmp_dir)
self._host = host or "127.0.0.1"
self._port = FLAGS.sc2_port or port or portpicker.pick_unused_port()
self._version = version
args = [
exec_path,
"-listen", self._host,
"-port", str(self._port),
"-dataDir", os.path.join(run_config.data_dir, ""),
"-tempDir", os.path.join(self._tmp_dir, ""),
]
if ":" in self._host:
args += ["-ipv6"]
if platform.system() != "Linux":
if full_screen:
args += ["-displayMode", "1"]
else:
args += [
"-displayMode", "0",
"-windowwidth", str(window_size[0]),
"-windowheight", str(window_size[1]),
"-windowx", str(window_loc[0]),
"-windowy", str(window_loc[1]),
]
if verbose or FLAGS.sc2_verbose:
args += ["-verbose"]
if FLAGS.sc2_verbose_mp:
args += ["-verboseMP"]
if self._version and self._version.data_version:
args += ["-dataVersion", self._version.data_version.upper()]
if extra_args:
args += extra_args
if FLAGS.sc2_gdb:
print("Launching: gdb", args[0])
print("GDB run command:")
print(" run %s" % " ".join(args[1:]))
print("\n")
args = ["gdb", args[0]]
timeout_seconds = 3600 * 6
elif FLAGS.sc2_strace:
strace_out = "/tmp/sc2-strace.txt"
print("Launching in strace. Redirecting output to", strace_out)
args = ["strace", "-f", "-o", strace_out] + args
else:
logging.info("Launching SC2: %s", " ".join(args))
try:
with sw("startup"):
if not FLAGS.sc2_port:
self._proc = self._launch(run_config, args, **kwargs)
if connect:
self._controller = remote_controller.RemoteController(
self._host, self._port, self, timeout_seconds=timeout_seconds)
except:
self.close()
raise
def __init__(self,
run_config,
exec_path,
data_version=None,
full_screen=False,
extra_args=None,
verbose=False,
host=None,
connect=True,
timeout_seconds=None,
window_size=(640, 480),
window_loc=(50, 50),
**kwargs):
self._proc = None
self._controller = None
self._check_exists(exec_path)
self._tmp_dir = tempfile.mkdtemp(prefix="sc-", dir=run_config.tmp_dir)
self._host = host or "127.0.0.1"
self._port = portpicker.pick_unused_port()
args = [
exec_path,
"-listen",
self._host,
"-port",
str(self._port),
"-dataDir",
os.path.join(run_config.data_dir, ""),
"-tempDir",
os.path.join(self._tmp_dir, ""),
]
if ":" in self._host:
args += ["-ipv6"]
if full_screen:
args += ["-displayMode", "1"]
else:
args += [
"-displayMode",
"0",
"-windowwidth",
str(window_size[0]),
"-windowheight",
str(window_size[1]),
"-windowx",
str(window_loc[0]),
"-windowy",
str(window_loc[1]),
]
if verbose or FLAGS.sc2_verbose:
args += ["-verbose"]
if data_version:
args += ["-dataVersion", data_version.upper()]
if extra_args:
args += extra_args
logging.info("Launching SC2: %s", " ".join(args))
try:
with sw("startup"):
self._proc = self._launch(run_config, args, **kwargs)
if connect:
self._controller = remote_controller.RemoteController(
self._host,
self._port,
self,
timeout_seconds=timeout_seconds)
except:
self.close()
raise
def _reconnect(self, **kwargs):
if not self._controller:
self._controller = remote_controller.RemoteController(
self._process.host, self._process.port, self._process, **kwargs)
def _reconnect(self, **kwargs):
if not self._controllers:
self._controllers = [
remote_controller.RemoteController(p.host, p.port, p, **kwargs)
for p in self._processes]
def main(argv):
"""Compare the observations from multiple binaries."""
if len(argv) <= 1:
sys.exit(
"Please specify binaries to run / to connect to. For binaries to run, "
"specify the executable name. For remote connections, specify "
"<hostname>:<port>. The version must match the replay.")
targets = argv[1:]
interface = sc_pb.InterfaceOptions()
interface.raw = True
interface.raw_affects_selection = True
interface.raw_crop_to_playable_area = True
interface.score = True
interface.show_cloaked = True
interface.show_placeholders = True
interface.feature_layer.width = 24
interface.feature_layer.resolution.x = 48
interface.feature_layer.resolution.y = 48
interface.feature_layer.minimap_resolution.x = 48
interface.feature_layer.minimap_resolution.y = 48
interface.feature_layer.crop_to_playable_area = True
interface.feature_layer.allow_cheating_layers = True
run_config = run_configs.get()
replay_data = run_config.replay_data(FLAGS.replay)
start_replay = sc_pb.RequestStartReplay(replay_data=replay_data,
options=interface,
observed_player_id=1,
realtime=False)
version = replay.get_replay_version(replay_data)
timers = []
controllers = []
procs = []
for target in targets:
timer = stopwatch.StopWatch()
timers.append(timer)
with timer("launch"):
if _is_remote(target):
host, port = target.split(":")
controllers.append(
remote_controller.RemoteController(host, int(port)))
else:
proc = run_configs.get(version=version._replace(
binary=target)).start(want_rgb=False)
procs.append(proc)
controllers.append(proc.controller)
diff_counts = [0] * len(controllers)
diff_paths = all_collections_generated_classes.Counter()
try:
print("-" * 80)
print(controllers[0].replay_info(replay_data))
print("-" * 80)
for controller, t in zip(controllers, timers):
with t("start_replay"):
controller.start_replay(start_replay)
# Check the static data.
static_data = []
for controller, t in zip(controllers, timers):
with t("data"):
static_data.append(controller.data_raw())
if FLAGS.diff:
diffs = {
i: proto_diff.compute_diff(static_data[0], d)
for i, d in enumerate(static_data[1:], 1)
}
if any(diffs.values()):
print(" Diff in static data ".center(80, "-"))
for i, diff in diffs.items():
if diff:
print(targets[i])
diff_counts[i] += 1
print(diff.report(truncate_to=FLAGS.truncate))
for path in diff.all_diffs():
diff_paths[
path.with_anonymous_array_indices()] += 1
else:
print("No diffs in static data.")
# Run some steps, checking speed and diffing the observations.
for _ in range(FLAGS.count):
for controller, t in zip(controllers, timers):
with t("step"):
controller.step(FLAGS.step_mul)
obs = []
for controller, t in zip(controllers, timers):
with t("observe"):
obs.append(controller.observe())
if FLAGS.diff:
for o in obs:
_clear_non_deterministic_fields(o)
diffs = {
i: proto_diff.compute_diff(obs[0], o)
for i, o in enumerate(obs[1:], 1)
}
if any(diffs.values()):
print((" Diff on step: %s " %
obs[0].observation.game_loop).center(80, "-"))
for i, diff in diffs.items():
if diff:
print(targets[i])
diff_counts[i] += 1
print(
diff.report(
[image_differencer.image_differencer],
truncate_to=FLAGS.truncate))
for path in diff.all_diffs():
diff_paths[
path.with_anonymous_array_indices()] += 1
if obs[0].player_result:
break
except KeyboardInterrupt:
pass
finally:
for c in controllers:
c.quit()
c.close()
for p in procs:
p.close()
if FLAGS.diff:
print(" Diff Counts by target ".center(80, "-"))
for target, count in zip(targets, diff_counts):
print(" %5d %s" % (count, target))
print()
print(" Diff Counts by observation path ".center(80, "-"))
for path, count in diff_paths.most_common(100):
print(" %5d %s" % (count, path))
print()
print(" Timings ".center(80, "-"))
for v, t in zip(targets, timers):
print(v)
print(t)
