class_docstr: Tests that run through a game, then verify it still works in a replay.
docstr: Start a multiplayer game with options.
docstr_tok: ["Start","a","multiplayer","game","with","options","."]
code: def start_game(self, show_cloaked=True, disable_fog=False, players=2):
      """Start a multiplayer game with options."""
      self._disable_fog = disable_fog
      run_config = run_configs.get()
      self._parallel = (
          run_parallel.RunParallel()
      )  # Needed for multiplayer.
      map_inst = maps.get("Flat64")
      self._map_data = map_inst.data(run_config)
  
      self._ports = (
          portspicker.pick_unused_ports(4) if players == 2 else []
      )
      self._sc2_procs = [
          run_config.start(extra_ports=self._ports, want_rgb=False)
          for _ in range(players)
      ]
      self._controllers = [p.controller for p in self._sc2_procs]
  
      if players == 2:
          for (
              c
          ) in (
              self._controllers
          ):  # Serial due to a race condition on Windows.
              c.save_map(map_inst.path, self._map_data)
  
      self._interface = sc_pb.InterfaceOptions()
      self._interface.raw = True
      self._interface.raw_crop_to_playable_area = True
      self._interface.show_cloaked = show_cloaked
      self._interface.score = False
      self._interface.feature_layer.width = 24
      self._interface.feature_layer.resolution.x = 64
      self._interface.feature_layer.resolution.y = 64
      self._interface.feature_layer.minimap_resolution.x = 64
      self._interface.feature_layer.minimap_resolution.y = 64
  
      create = sc_pb.RequestCreateGame(
          random_seed=1,
          disable_fog=self._disable_fog,
          local_map=sc_pb.LocalMap(map_path=map_inst.path),
      )
      for _ in range(players):
          create.player_setup.add(type=sc_pb.Participant)
      if players == 1:
          create.local_map.map_data = self._map_data
          create.player_setup.add(
              type=sc_pb.Computer,
              race=sc_common.Random,
              difficulty=sc_pb.VeryEasy,
          )
  
      join = sc_pb.RequestJoinGame(
          race=sc_common.Protoss, options=self._interface
      )
      if players == 2:
          join.shared_port = 0  # unused
          join.server_ports.game_port = self._ports[0]
          join.server_ports.base_port = self._ports[1]
          join.client_ports.add(
              game_port=self._ports[2], base_port=self._ports[3]
          )
  
      self._controllers[0].create_game(create)
      self._parallel.run((c.join_game, join) for c in self._controllers)
  
      self._info = self._controllers[0].game_info()
      self._features = features.features_from_game_info(
          self._info, use_raw_units=True
      )
  
      self._map_size = point.Point.build(self._info.start_raw.map_size)
      print("Map size:", self._map_size)
      self.in_game = True
      self.step()
  
imports: import functools
  from absl import logging
  from absl.testing import absltest
  from pysc2 import maps
  from pysc2 import run_configs
  from pysc2.lib import actions
  from pysc2.lib import features
  from pysc2.lib import point
  from pysc2.lib import portspicker
  from pysc2.lib import run_parallel
  from pysc2.lib import stopwatch
  from s2clientprotocol import common_pb2
  from s2clientprotocol import debug_pb2
  from s2clientprotocol import error_pb2
  from s2clientprotocol import raw_pb2
  from s2clientprotocol import sc2api_pb2
label_desc: Use image node_id 2 for calling the GameReplayTestCase obj's underlying member method code with example usage: obj.start_game(show_cloaked, disable_fog, players) without return types