sc2ai 0.0.0.pre → 0.0.2

data/lib/sc2ai/cli/new.rb

@@ -0,0 +1,88 @@
+require "sc2ai/paths"
+
+module Sc2
+  # Command line utilities
+  class Cli < Thor
+    class New < Thor::Group
+      include Thor::Actions
+      desc "Creates a new bot"
+
+      # Define arguments and options
+      argument :botname, required: true, desc: "Bot name as on aiarena. Used as a file name (short, alpha-num, no spaces!)"
+      argument :race, required: true, desc: "Choose a race", enum: %w[Terran Zerg Protoss Random]
+
+      def self.source_root
+        Sc2::Paths.template_root.to_s
+      end
+
+      def checkname
+        race_arg = Sc2::Cli::New.arguments.find { |a| a.name == "race" }
+        unless race_arg.enum.include?(race)
+          raise Thor::MalformattedArgumentError, "Invalid race #{race}, must be one of #{race_arg.enum}"
+        end
+
+        say "We need to create a filename and classname from botname '#{@botname}'"
+        say "You rename classes and organize files in any way, as long as you generate a valid $bot in boot.rb"
+
+        @botname = botname.gsub(/[^0-9a-z]/i, "")
+        @directory = @botname.downcase
+        @classname = botname.split(/[^0-9a-z]/i).collect { |s| s.sub(/^./, &:upcase) }.join
+        @bot_file = @classname.split(/(?=[A-Z])/).join("_").downcase.concat(".rb")
+        say "Race: #{race}"
+        say "Class name: #{@classname}"
+        say "Create directory: ./#{@directory}"
+        say "Bot file: ./#{@directory}/#{@bot_file}"
+
+        unless ask("Does this look ok?", limited_to: ["y", "n"], default: "y") == "y"
+          raise SystemExit
+        end
+      end
+
+      def create_target
+        if Pathname("./#{@directory}").exist?
+          say "Folder already exists. Refusing to overwrite.", :red
+          raise SystemExit
+        end
+
+        empty_directory "./#{@directory}"
+        self.destination_root = Pathname("./#{@directory}").to_s
+      end
+
+      def create_boot
+        template("new/boot.rb", "boot.rb")
+      end
+
+      def create_example_match
+        template("new/run_example_match.rb", "run_example_match.rb")
+      end
+
+      def create_gemfile
+        template("new/Gemfile", "Gemfile")
+      end
+
+      def create_botfile
+        template("new/my_bot.rb", @bot_file)
+      end
+
+      def create_ignorefile
+        template("new/.ladderignore", ".ladderignore")
+      end
+
+      def copy_api
+        directory("new/api", "api")
+      end
+
+      def bye
+        say ""
+        say "Bot generated, next steps:"
+        say ""
+        say "cd #{@directory} && bundle install", :green
+        say ""
+        say "Once your project is ready, if you haven't done so, setup SC2 v4.10 with:"
+        say ""
+        say "bundle exec sc2ai setup410", :green
+        say ""
+      end
+    end
+  end
+end

data/lib/sc2ai/configuration.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+require_relative "local_play/client/configurable_options"
+
+module Sc2
+  # Global config manager for runtime
+  # @example Manual configuration block
+  #   Sc2.config do |config|
+  #     config.sc2_platform = "WineLinux"
+  #     config.sc2_path = "/c/Program Files (x86)/StarCraft II/"
+  #     config.ports = [5001,5002,5003]
+  #     config.host = '127.0.0.1'
+  #   end
+  class Configuration
+    # Include client launch options
+    include Sc2::Client::ConfigurableOptions
+
+    # Attributes permitted to be read and save from config yaml
+    CONFIG_ATTRIBUTES = %i[
+      sc2_platform
+      sc2_path
+      version
+      ports
+      host
+      display_mode
+      windowwidth
+      windowheight
+      windowx
+      windowy
+      verbose
+      data_dir
+      temp_dir
+      egl_path
+      osmesa_path
+    ].freeze
+
+    # @!attribute sc2_platform
+    # Sc2 platform config alias will override ENV["SC2PF"]
+    #   @return [String] (see Sc2::Paths#platform)
+    attr_accessor :sc2_platform
+
+    # @!attribute sc2_path
+    #   Sc2 Path config alias will override ENV["SC2PATH"]
+    #   @return [String] sc2_path (see Sc2::Paths#platform)
+    attr_accessor :sc2_path
+
+    # @!attribute ports
+    #   if empty, a random port will be picked when launching
+    #   Launch param: -listen
+    #   @return [Array<Integer>]
+    attr_accessor :ports
+
+    # Create a new Configuration and sets defaults and loads config from yaml
+    # @return [Sc2::Configuration]
+    def initialize
+      set_defaults
+
+      load_config(config_file) if config_file.exist?
+
+      # create temp dir on linux
+      ensure_temp_dir
+    end
+
+    # Config file location
+    # @return [Pathname] path
+    def config_file
+      # Pathname(Paths.project_root_dir).join("config", "sc2ai.yml")
+      Pathname(Paths.project_root_dir).join("sc2ai.yml")
+    end
+
+    # Sets defaults when initializing
+    # @return [void]
+    def set_defaults
+      @sc2_platform = Paths.platform
+      @sc2_path = Paths.install_dir
+      @ports = []
+
+      load_default_launch_options
+    end
+
+    # Writes this instance's attributes to yaml config_file
+    # @return [void]
+    def save_config
+      # config_file.dirname.mkpath unless config_file.dirname.exist?
+      config_file.write(to_yaml.to_s)
+      nil
+    end
+
+    # Converts attributes to yaml
+    # @return [Hash] yaml matching stringified keys from CONFIG_ATTRIBUTES
+    def to_yaml
+      to_h.to_yaml
+    end
+
+    # Converts attributes to hash
+    # @return [Hash] hash matching stringified keys from CONFIG_ATTRIBUTES
+    def to_h
+      CONFIG_ATTRIBUTES.map do |name|
+        [name.to_s, instance_variable_get(:"@#{name}")]
+      end.to_h
+    end
+
+    # Loads YAML config
+    # @param file [Pathname,String] location of config file
+    # @return [Boolean] success/failure
+    def load_config(file)
+      file = Pathname(file) unless file.is_a? Pathname
+      return false if !file.exist? || file.size.nil?
+
+      begin
+        content = ::Psych.safe_load(file.read)
+        unless content.is_a? Hash
+          Sc2.logger.warn "Failed to load #{file} because it doesn't contain valid YAML hash"
+          return false
+        end
+        CONFIG_ATTRIBUTES.map(&:to_s).each do |attribute|
+          next unless content.key?(attribute.to_s)
+
+          instance_variable_set(:"@#{attribute}", content[attribute])
+        end
+        return true
+      rescue ArgumentError, Psych::SyntaxError => e
+        Sc2.logger.warn "Failed to load #{file}, #{e}"
+      rescue Errno::EACCES
+        Sc2.logger.warn "Failed to load #{file} due to permissions problem."
+      end
+
+      false
+    end
+
+    private
+
+    # Makes sure we have a temporary directory on linux if not specified
+    # @return [void]
+    def ensure_temp_dir
+      return unless Paths.platform == Paths::PF_LINUX
+
+      return unless @temp_dir.to_s.empty?
+
+      @temp_dir = Paths.generate_temp_dir
+    end
+  end
+end

data/lib/sc2ai/connection/connection_listener.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sc2
+  class Connection
+    # Callbacks should be included on your listening class
+    # noinspection RubyUnusedLocalVariable
+    module ConnectionListener
+      # Called when connection established to application
+      # @param connection [Sc2Ai::Connection]
+      # noinspection
+      def on_connected(connection)
+        Sc2.logger.debug { "#{self.class}.#{__method__} #{connection}" }
+      end
+
+      # Called while waiting on connection to application
+      # @param connection [Sc2Ai::Connection]
+      # noinspection Lint/UnusedMethodArgument
+      def on_connection_waiting(connection)
+        Sc2.logger.debug { "#{self.class}.#{__method__} #{connection}" }
+      end
+
+      # Called when disconnected from application
+      # @param connection [Sc2Ai::Connection]
+      # noinspection Lint/UnusedMethodArgument
+      def on_disconnect(connection)
+        Sc2.logger.debug { "#{self.class}.#{__method__} #{connection}" }
+      end
+    end
+  end
+end

data/lib/sc2ai/connection/requests.rb

@@ -0,0 +1,417 @@
+# frozen_string_literal: true
+
+module Sc2
+  class Connection
+    # Sends protobuf requests over Connection to Client
+    module Requests
+      # GAME MANAGEMENT ----
+
+      # Send to host to initialize game
+      def create_game(map:, players:, realtime: false)
+        send_request_for create_game: Api::RequestCreateGame.new(
+          local_map: Api::LocalMap.new(map_path: map.path),
+          player_setup: players.map do |player|
+            Api::PlayerSetup.new(
+              type: player.type,
+              race: player.race,
+              player_name: player.name,
+              difficulty: player.difficulty,
+              ai_build: player.ai_build
+            )
+          end,
+          realtime:
+        )
+      end
+
+      # Send to host and all clients for game to begin.
+      # @param race [Google::Protobuf::EnumValue] Api::Race
+      # @param name [String] player name
+      # @param server_host [String] hostname or ip of sc2 client
+      # @param port_config [Sc2::PortConfig] port config auto or basic, using start port
+      # @param enable_feature_layer [Boolean] Enables the feature layer at 1x1 pixels
+      # @param interface_options [Hash]
+      # @option interface_options [Boolean] :raw (true) raw interface enabled, default true
+      # @option interface_options [Boolean] :score (false) score game info
+      # @option interface_options [Boolean] :show_cloaked (true) hows details about cloaked units
+      # @option interface_options [Boolean] :show_burrowed_shadows (true) shows some details for those that produce a shadow
+      # @option interface_options [Boolean] :show_placeholders (true) return placeholder units (buildings to be constructed)
+      # @option interface_options [Boolean] :raw_affects_selection (false) for live raw does whatever it wants, for local it keeps your selection by default.
+      # @option interface_options [Boolean] :raw_crop_to_playable_area (true) trims away unplayable parts of map, else map is 255x255 with dead space. performant if true.
+      def join_game(race:, name:, server_host:, port_config:, enable_feature_layer: false, interface_options: {})
+        interface_options ||= {}
+
+        send_request_for join_game: Api::RequestJoinGame.new(
+          # TODO: For Observer support, get player_index for observer,
+          #   don't set race and pass observed_player_id: player_index
+          # observed_player_id: 0, # For observer
+          # --
+          race:,
+          player_name: name,
+          host_ip: server_host,
+          server_ports: port_config.server_port_set,
+          client_ports: port_config.client_port_sets,
+          options: Api::InterfaceOptions.new(
+            {
+              raw: true,
+              score: false,
+              feature_layer: feature_layer_interface_options(enable_feature_layer),
+              show_cloaked: true,
+              show_burrowed_shadows: true,
+              show_placeholders: true,
+              raw_affects_selection: Sc2.ladder?,
+              raw_crop_to_playable_area: true
+            }.merge!(interface_options)
+          )
+        )
+      end
+
+      # @private
+      # Default options for feature layer, which enables it,
+      # but sets the map/minimap size to 1x1 for peak performance.
+      # A user can manually pass in it's own interface options
+      def feature_layer_interface_options(enabled)
+        return nil unless enabled
+
+        ::Api::SpatialCameraSetup.new(
+          width: 1.0,
+          resolution: Api::Size2DI.new(x: 1, y: 1),
+          minimap_resolution: Api::Size2DI.new(x: 1, y: 1),
+          # width: 10.0,
+          # resolution: Api::Size2DI.new(x: 128, y: 128),
+          # minimap_resolution: Api::Size2DI.new(x: 16, y: 16),
+          crop_to_playable_area: true, # has no effect. minimap x and y are respected no matter what
+          allow_cheating_layers: false
+        )
+      end
+
+      protected :feature_layer_interface_options
+
+      # Single player only. Reinitializes the game with the same player setup.
+      def restart_game
+        send_request_for restart_game: Api::RequestRestartGame.new
+      end
+
+      # Given a replay file path or replay file contents, will start the replay
+      # @example
+      #   Sc2.config do |config|
+      #     config.version = "4.10"
+      #   end
+      #   Async do
+      #     client = Sc2::ClientManager.obtain(0)
+      #     observer = Sc2::Player::Observer.new
+      #     observer.connect(host: client.host, port: client.port)
+      #     pp observer.api.start_replay(
+      #       replay_path: Pathname("./replays/test.SC2Replay").realpath
+      #     )
+      #     while observer.status == :in_replay
+      #       #   Step forward
+      #       observer.api.step(1)
+      #       #   fresh observation info
+      #       observation = observer.api.observation
+      #       #   fresh game info
+      #       game_info = observer.api.game_info
+      #     end
+      #   ensure
+      #     Sc2::ClientManager.stop(0)
+      #   end
+      # @param replay_path [String] path to replay
+      # @param replay_data [String] alternative to file, binary string of replay_file.read
+      # @param map_data [String] optional binary string of SC2 map if not present in paths
+      # @param options [Hash] Api:RequestStartReplay options, such as disable_fog, observed_player_id, map_data
+      # @param [Hash] interface_options
+      def start_replay(replay_path: nil, replay_data: nil, map_data: nil, record_replay: true, interface_options: {}, **options)
+        raise Sc2::Error, "Missing replay." if replay_data.nil? && replay_path.nil?
+
+        interface_options ||= {}
+        send_request_for start_replay: Api::RequestStartReplay.new(
+          {
+            replay_path: replay_path.to_s,
+            replay_data: replay_data,
+            map_data: map_data,
+            realtime: false,
+            disable_fog: true,
+            record_replay: record_replay,
+            observed_player_id: 0,
+            options: Api::InterfaceOptions.new(
+              {
+                raw: true,
+                score: true,
+                feature_layer: feature_layer_interface_options(true),
+                show_cloaked: true,
+                show_burrowed_shadows: true,
+                show_placeholders: true,
+                raw_affects_selection: false,
+                raw_crop_to_playable_area: true
+              }.merge!(interface_options)
+            )
+          }.merge(options)
+        )
+      end
+
+      # Multiplayer only. Disconnects from a multiplayer game, equivalent to surrender. Keeps client alive.
+      def leave_game
+        send_request_for leave_game: Api::RequestLeaveGame.new
+      end
+
+      # Saves game to an in-memory bookmark.
+      def request_quick_save
+        send_request_for quick_save: Api::RequestQuickSave.new
+      end
+
+      # Loads from an in-memory bookmark.
+      def request_quick_load
+        send_request_for quick_load: Api::RequestQuickLoad.new
+      end
+
+      # Quits Sc2. Does not work on ladder.
+      def quit
+        send_request_for quit: Api::RequestQuit.new
+      end
+
+      # DURING GAME -
+
+      # // During Game
+
+      # Static data about the current game and map.
+      # @return [Api::ResponseGameInfo]
+      def game_info
+        send_request_for game_info: Api::RequestGameInfo.new
+      end
+
+      # Data about different gameplay elements. May be different for different games.
+      # Note that buff_id and effect_id gives worse quality data than generated from stableids (EffectId and BuffId)
+      # Those options are disabled by default
+      # @param ability_id [Boolean] to include ability data
+      # @param unit_type_id [Boolean] to include unit data
+      # @param upgrade_id [Boolean] to include upgrade data
+      # @param buff_id [Boolean] to get include buff data
+      # @param effect_id [Boolean] to get to include effect data
+      # @return [Api::ResponseData]
+      def data(ability_id: true, unit_type_id: true, upgrade_id: true, buff_id: true, effect_id: true)
+        send_request_for data: Api::RequestData.new(
+          ability_id:,
+          unit_type_id:,
+          upgrade_id:,
+          buff_id:,
+          effect_id:
+        )
+      end
+
+      # Snapshot of the current game state. Primary source for raw information
+      # @param game_loop [Integer] you wish to wait for (realtime only)
+      def observation(game_loop: nil)
+        # Sc2.logger.debug { "#{self.class}.#{__method__} game_loop: #{game_loop}" }
+        if game_loop.nil?
+          # Uncomment to enable multiple gc
+          # Async do
+          #   result = Async do
+
+          @_cached_request_observation ||= Api::Request.new(
+            observation: Api::RequestObservation.new
+          ).to_proto
+          @websocket.send_binary(@_cached_request_observation)
+          response = Api::Response.decode(@websocket.read.to_str)
+
+          if @status != response.status
+            @status = response.status
+            @listeners[StatusListener.name]&.each { _1.on_status_change(@status) }
+          end
+
+          response.observation
+
+          # Uncomment to enable manual GC
+          # end
+
+          #   Async do
+          #     # A step command is synchronous for both bots.
+          #     # Bot A will wait for Bot B, then both get responses.
+          #     # If we're ahead or even not, we can perform a minor GC sweep while we wait.
+          #     # If the server notifies the other machine first
+          #     # This smooths out unexpected hiccups and reduces overall major gc sweeps, possibly for free.
+          #     begin
+          #       GC.start(full_mark: false, immediate_sweep: true)
+          #       # if rand(100).zero? # Just below every 5 seconds
+          #       #   GC.compact
+          #       # end
+          #     rescue
+          #       # noop - just here for cleaner exceptions on interrupt
+          #     end
+          #   end
+          #   result.wait
+          # end.wait
+
+        else
+          send_request_for observation: Api::RequestObservation.new(game_loop:)
+        end
+      end
+
+      # Executes an array of [Api::Action] for a participant
+      # @param actions [Array<Api::Action>] to perform
+      # @return [Api::ResponseAction]
+      def action(actions)
+        send_request_for action: Api::RequestAction.new(
+          actions: actions
+        )
+      end
+
+      # Executes an actions for an observer.
+      # @param actions [Array<Api::ObserverAction>]
+      def observer_action(actions)
+        # ActionObserverCameraMove camera_move = 2;
+        # ActionObserverCameraFollowPlayer camera_follow_player = 3;
+        send_request_for obs_action: Api::RequestObserverAction.new(
+          actions: actions
+        )
+      end
+
+      # Moves observer camera to a position at a distance
+      # @param world_pos [Api::Point2D]
+      # @param distance [Float] Distance between camera and terrain. Larger value zooms out camera. Defaults to standard camera distance if set to 0.
+      def observer_action_camera_move(world_pos, distance = 0)
+        observer_action([Api::ObserverAction.new(
+          camera_move: Api::ActionObserverCameraMove.new(
+            world_pos:,
+            distance:
+          )
+        )])
+      end
+
+      # Advances the game simulation by step_count. Not used in realtime mode.
+      # Only constant step size supported - subsequent requests use cache.
+      def step(step_count = 1)
+        @_cached_request_step ||= Api::Request.new(
+          step: Api::RequestStep.new(count: step_count)
+        ).to_proto
+        send_request_and_ignore(@_cached_request_step)
+      end
+
+      # Additional methods for inspecting game state. Synchronous and must wait on response
+      # @param pathing [Array<Api::RequestQueryPathing>]
+      # @param abilities [Array<Api::RequestQueryAvailableAbilities>]
+      # @param placements [Array<Api::RequestQueryBuildingPlacement>]
+      # @param ignore_resource_requirements [Boolean] Ignores requirements like food, minerals and so on.
+      # @return [Api::ResponseQuery]
+      def query(pathing: nil, abilities: nil, placements: nil, ignore_resource_requirements: true)
+        send_request_for query: Api::RequestQuery.new(
+          pathing:,
+          abilities:,
+          placements:,
+          ignore_resource_requirements:
+        )
+      end
+
+      # Queries one or more pathing queries
+      # @param queries [Array<Api::RequestQueryPathing>, Api::RequestQueryPathing] one or more pathing queries
+      # @return [Array<Api::ResponseQueryPathing>, Api::ResponseQueryPathing] one or more results depending on input size
+      def query_pathings(queries)
+        arr_queries = queries.is_a?(Array) ? queries : [queries]
+
+        response = send_request_for query: Api::RequestQuery.new(
+          pathing: arr_queries
+        )
+        (arr_queries.size > 1) ? response.pathing : response.pathing.first
+      end
+
+      # Queries one or more ability-available checks
+      # @param queries [Array<Api::RequestQueryAvailableAbilities>, Api::RequestQueryAvailableAbilities] one or more pathing queries
+      # @param ignore_resource_requirements [Boolean] Ignores requirements like food, minerals and so on.
+      # @return [Array<Api::ResponseQueryAvailableAbilities>, Api::ResponseQueryAvailableAbilities] one or more results depending on input size
+      def query_abilities(queries, ignore_resource_requirements: true)
+        arr_queries = queries.is_a?(Array) ? queries : [queries]
+
+        response = send_request_for query: Api::RequestQuery.new(
+          abilities: arr_queries,
+          ignore_resource_requirements:
+        )
+        (arr_queries.size > 1) ? response.abilities : response.abilities.first
+      end
+
+      # Queries available abilities for units
+      # @param unit_tags [Array<Integer>, Integer] an array of unit tags or a single tag
+      # @param ignore_resource_requirements [Boolean] Ignores requirements like food, minerals and so on.
+      # @return [Array<Api::ResponseQueryAvailableAbilities>, Api::ResponseQueryAvailableAbilities] one or more results depending on input size
+      def query_abilities_for_unit_tags(unit_tags, ignore_resource_requirements: true)
+        queries = []
+        unit_tags = [unit_tags] unless unit_tags.is_a? Array
+        unit_tags.each do |unit_tag|
+          queries << Api::RequestQueryAvailableAbilities.new(unit_tag: unit_tag)
+        end
+
+        query_abilities(queries, ignore_resource_requirements:)
+      end
+
+      # Queries one or more pathing queries
+      # @param queries [Array<Api::RequestQueryBuildingPlacement>, Api::RequestQueryBuildingPlacement] one or more placement queries
+      # @return [Array<Api::ResponseQueryBuildingPlacement>, Api::ResponseQueryBuildingPlacement] one or more results depending on input size
+      def query_placements(queries)
+        arr_queries = queries.is_a?(Array) ? queries : [queries]
+
+        response = query(placements: arr_queries)
+
+        (arr_queries.size > 1) ? response.placements : response.placements.first
+      end
+
+      # Generates a replay.
+      def save_replay
+        send_request_for save_replay: Api::RequestSaveReplay.new
+      end
+
+      # MapCommand does not actually gracefully trigger start/restart
+      # RequestMapCommand map_command = 22;         // Execute a particular trigger through a string interface
+
+      # Returns metadata about a replay file. Does not load the replay.
+      # RequestReplayInfo replay_info = 16;         //
+      # @param replay_path [String] path to replay
+      # @param replay_data [String] alternative to file, binary string of replay_file.read
+      # @param download_data [String] if true, ensure the data and binary are downloaded if this is an old version replay.
+      # @return [Api::ResponseReplayInfo]
+      def replay_info(replay_path: nil, replay_data: nil, download_data: false)
+        raise Sc2::Error, "Missing replay." if replay_data.nil? && replay_path.nil?
+
+        send_request_for replay_info: Api::RequestReplayInfo.new(
+          replay_path: replay_path.to_s,
+          replay_data: replay_data,
+          download_data: download_data
+        )
+      end
+
+      # Returns directory of maps that can be played on.
+      # @return [Api::ResponseAvailableMaps] which has #local_map_paths and #battlenet_map_names arrays
+      def available_maps
+        send_request_for available_maps: Api::RequestAvailableMaps.new
+      end
+
+      # Saves binary map data to the local temp directory.
+      def save_map
+        send_request_for save_map: Api::RequestSaveMap.new
+      end
+
+      # Network ping for testing connection.
+      def ping
+        send_request_for ping: Api::RequestPing.new
+      end
+
+      # Display debug information and execute debug actions
+      # @param commands [Array<Api::DebugCommand>]
+      # @return [void]
+      def debug(commands)
+        send_request_for debug: Api::RequestDebug.new(
+          debug: commands
+        )
+      end
+
+      # Sends request for type and returns response that type, i.e.
+      #    send_request_for(observation: RequestObservation)
+      # Is identical to
+      #    send_request(
+      #      Api::Request.new(observation: RequestObservation)
+      #    )[:observation]
+      def send_request_for(**kwargs)
+        response = send_request(Api::Request.new(kwargs))
+        response[kwargs.keys.first.to_s]
+      end
+
+      private
+    end
+  end
+end

data/lib/sc2ai/connection/status_listener.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Sc2
+  class Connection
+    # Callbacks when game status changes
+    module StatusListener
+      # Called when game status changes
+      # @param status [:launched, :in_game, :in_replay, :ended, :quit, :unknown] game state, i.e. :in_game, :ended, :launched
+      # noinspection
+      def on_status_change(status)
+        Sc2.logger.debug { "#{self.class}.#{__method__} #{status}" }
+      end
+    end
+  end
+end