docs: def reverse_action(self, action):
      """Transform an SC2-style action into an agent-style action.
  
      This should be the inverse of `transform_action`.
  
      Args:
        action: a `sc_pb.Action` to be transformed.
  
      Returns:
        A corresponding `actions.FunctionCall`.
  
      Raises:
        ValueError: if it doesn't know how to transform this action.
      """
      FUNCTIONS = actions.FUNCTIONS  # pylint: disable=invalid-name
  
      aif = self._agent_interface_format
  
      def func_call_ability(ability_id, cmd_type, *args):
        """Get the function id for a specific ability id and action type."""
        if ability_id not in actions.ABILITY_IDS:
          logging.warning("Unknown ability_id: %s. This is probably dance or "
                          "cheer, or some unknown new or map specific ability. "
                          "Treating it as a no-op.", ability_id)
          return FUNCTIONS.no_op()
  
        if aif.hide_specific_actions:
          general_id = next(iter(actions.ABILITY_IDS[ability_id])).general_id
          if general_id:
            ability_id = general_id
  
        for func in actions.ABILITY_IDS[ability_id]:
          if func.function_type is cmd_type:
            return FUNCTIONS[func.id](*args)
        raise ValueError("Unknown ability_id: %s, type: %s. Likely a bug." % (
            ability_id, cmd_type.__name__))
  
      if action.HasField("action_ui"):
        act_ui = action.action_ui
        if act_ui.HasField("multi_panel"):
          return FUNCTIONS.select_unit(act_ui.multi_panel.type - 1,
                                       act_ui.multi_panel.unit_index)
        if act_ui.HasField("control_group"):
          return FUNCTIONS.select_control_group(
              act_ui.control_group.action - 1,
              act_ui.control_group.control_group_index)
        if act_ui.HasField("select_idle_worker"):
          return FUNCTIONS.select_idle_worker(act_ui.select_idle_worker.type - 1)
        if act_ui.HasField("select_army"):
          return FUNCTIONS.select_army(act_ui.select_army.selection_add)
        if act_ui.HasField("select_warp_gates"):
          return FUNCTIONS.select_warp_gates(
              act_ui.select_warp_gates.selection_add)
        if act_ui.HasField("select_larva"):
          return FUNCTIONS.select_larva()
        if act_ui.HasField("cargo_panel"):
          return FUNCTIONS.unload(act_ui.cargo_panel.unit_index)
        if act_ui.HasField("production_panel"):
          return FUNCTIONS.build_queue(act_ui.production_panel.unit_index)
        if act_ui.HasField("toggle_autocast"):
          return func_call_ability(act_ui.toggle_autocast.ability_id,
                                   actions.autocast)
  
      if (action.HasField("action_feature_layer") or
          action.HasField("action_render")):
        act_sp = actions.spatial(action, aif.action_space)
        if act_sp.HasField("camera_move"):
          coord = point.Point.build(act_sp.camera_move.center_minimap)
          return FUNCTIONS.move_camera(coord)
        if act_sp.HasField("unit_selection_point"):
          select_point = act_sp.unit_selection_point
          coord = point.Point.build(select_point.selection_screen_coord)
          return FUNCTIONS.select_point(select_point.type - 1, coord)
        if act_sp.HasField("unit_selection_rect"):
          select_rect = act_sp.unit_selection_rect
          # TODO(tewalds): After looking at some replays we should decide if
          # this is good enough. Maybe we need to simulate multiple actions or
          # merge the selection rects into a bigger one.
          tl = point.Point.build(select_rect.selection_screen_coord[0].p0)
          br = point.Point.build(select_rect.selection_screen_coord[0].p1)
          return FUNCTIONS.select_rect(select_rect.selection_add, tl, br)
        if act_sp.HasField("unit_command"):
          cmd = act_sp.unit_command
          queue = int(cmd.queue_command)
          if cmd.HasField("target_screen_coord"):
            coord = point.Point.build(cmd.target_screen_coord)
            return func_call_ability(cmd.ability_id, actions.cmd_screen,
                                     queue, coord)
          elif cmd.HasField("target_minimap_coord"):
            coord = point.Point.build(cmd.target_minimap_coord)
            return func_call_ability(cmd.ability_id, actions.cmd_minimap,
                                     queue, coord)
          else:
            return func_call_ability(cmd.ability_id, actions.cmd_quick, queue)
  
      if action.HasField("action_raw") or action.HasField("action_render"):
        raise ValueError("Unknown action:\n%s" % action)
  
      return FUNCTIONS.no_op()