docs: def main(unused_argv):
    """Run SC2 to play a game or a replay."""
    stopwatch.sw.enabled = FLAGS.profile or FLAGS.trace
    stopwatch.sw.trace = FLAGS.trace
  
    if (FLAGS.map and FLAGS.replay) or (not FLAGS.map and not FLAGS.replay):
      sys.exit("Must supply either a map or replay.")
  
    if FLAGS.replay and not FLAGS.replay.lower().endswith("sc2replay"):
      sys.exit("Replay must end in .SC2Replay.")
  
    if FLAGS.realtime and FLAGS.replay:
      # TODO(tewalds): Support realtime in replays once the game supports it.
      sys.exit("realtime isn't possible for replays yet.")
  
    if FLAGS.render and (FLAGS.realtime or FLAGS.full_screen):
      sys.exit("disable pygame rendering if you want realtime or full_screen.")
  
    if platform.system() == "Linux" and (FLAGS.realtime or FLAGS.full_screen):
      sys.exit("realtime and full_screen only make sense on Windows/MacOS.")
  
    if not FLAGS.render and FLAGS.render_sync:
      sys.exit("render_sync only makes sense with pygame rendering on.")
  
    run_config = run_configs.get()
  
    interface = sc_pb.InterfaceOptions()
    interface.raw = FLAGS.render
    interface.score = True
    interface.feature_layer.width = 24
    if FLAGS.feature_screen_size and FLAGS.feature_minimap_size:
      FLAGS.feature_screen_size.assign_to(interface.feature_layer.resolution)
      FLAGS.feature_minimap_size.assign_to(
          interface.feature_layer.minimap_resolution)
    if FLAGS.rgb_screen_size and FLAGS.rgb_minimap_size:
      FLAGS.rgb_screen_size.assign_to(interface.render.resolution)
      FLAGS.rgb_minimap_size.assign_to(interface.render.minimap_resolution)
  
    max_episode_steps = FLAGS.max_episode_steps
  
    if FLAGS.map:
      map_inst = maps.get(FLAGS.map)
      if map_inst.game_steps_per_episode:
        max_episode_steps = map_inst.game_steps_per_episode
      create = sc_pb.RequestCreateGame(
          realtime=FLAGS.realtime,
          disable_fog=FLAGS.disable_fog,
          local_map=sc_pb.LocalMap(map_path=map_inst.path,
                                   map_data=map_inst.data(run_config)))
      create.player_setup.add(type=sc_pb.Participant)
      create.player_setup.add(type=sc_pb.Computer,
                              race=sc2_env.Race[FLAGS.bot_race],
                              difficulty=sc2_env.Difficulty[FLAGS.difficulty])
      join = sc_pb.RequestJoinGame(
          options=interface, race=sc2_env.Race[FLAGS.user_race],
          player_name=FLAGS.user_name)
      version = None
    else:
      replay_data = run_config.replay_data(FLAGS.replay)
      start_replay = sc_pb.RequestStartReplay(
          replay_data=replay_data,
          options=interface,
          disable_fog=FLAGS.disable_fog,
          observed_player_id=FLAGS.observed_player)
      version = get_replay_version(replay_data)
  
    with run_config.start(version=version,
                          full_screen=FLAGS.full_screen) as controller:
      if FLAGS.map:
        controller.create_game(create)
        controller.join_game(join)
      else:
        info = controller.replay_info(replay_data)
        print(" Replay info ".center(60, "-"))
        print(info)
        print("-" * 60)
        map_path = FLAGS.map_path or info.local_map_path
        if map_path:
          start_replay.map_data = run_config.map_data(map_path)
        controller.start_replay(start_replay)
  
      if FLAGS.render:
        renderer = renderer_human.RendererHuman(
            fps=FLAGS.fps, step_mul=FLAGS.step_mul,
            render_sync=FLAGS.render_sync, video=FLAGS.video)
        renderer.run(
            run_config, controller, max_game_steps=FLAGS.max_game_steps,
            game_steps_per_episode=max_episode_steps,
            save_replay=FLAGS.save_replay)
      else:  # Still step forward so the Mac/Windows renderer works.
        try:
          while True:
            frame_start_time = time.time()
            if not FLAGS.realtime:
              controller.step(FLAGS.step_mul)
            obs = controller.observe()
  
            if obs.player_result:
              break
            time.sleep(max(0, frame_start_time + 1 / FLAGS.fps - time.time()))
        except KeyboardInterrupt:
          pass
        print("Score: ", obs.observation.score.score)
        print("Result: ", obs.player_result)
        if FLAGS.map and FLAGS.save_replay:
          replay_save_loc = run_config.save_replay(
              controller.save_replay(), "local", FLAGS.map)
          print("Replay saved to:", replay_save_loc)
          # Save scores so we know how the human player did.
          with open(replay_save_loc.replace("SC2Replay", "txt"), "w") as f:
            f.write("{}\n".format(obs.observation.score.score))
  
    if FLAGS.profile:
      print(stopwatch.sw)