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)