sc2ai 0.0.0.pre → 0.0.2

data/lib/sc2ai/connection.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/io/stream"
+require "async/http/endpoint"
+require "async/websocket"
+require_relative "connection/requests"
+
+module Sc2
+  # Manages client connection to the Api
+  class Connection
+    # Api requests
+    include Sc2::Connection::Requests
+
+    attr_accessor :host, :port, :websocket
+
+    # Last known game status, i.e. :launched, :ended, :unknown
+    #   :launched // Game has been launch and is not yet doing anything.
+    #   :init_game // Create game has been called, and the host is awaiting players.
+    #   :in_game // In a single or multiplayer game.
+    #   :in_replay // In a replay.
+    #   :ended // Game has ended, can still request game info, but ready for a new game.
+    #   :quit // Application is shutting down.
+    #   :unknown // Should not happen, but indicates an error if it occurs.
+    #   @return [Symbol] game status
+    attr_reader :status
+
+    # @!attribute listeners
+    #   @return [Hash<String,Array>] of callbacks
+    attr_reader :listeners
+
+    # @param host [String]
+    # @param port [Integer]
+    # #param [Sc2::CallbackListener] listener
+    def initialize(host:, port:)
+      @host = host
+      @port = port
+      @listeners = {}
+      @websocket = nil
+      @status = :unknown
+      # Only allow one request at a time.
+      # TODO: Since it turns out the client websocket can only handle 1 request at a time, we don't stricly need Async
+      @scheduler = Async::Semaphore.new(1)
+    end
+
+    # Attempts to connect for a period of time, ignoring errors nad performing on_* callbacks
+    # @return [void]
+    def connect
+      attempt = 1
+      Sc2.logger.debug { "Waiting for client..." } if (attempt % 5).zero?
+
+      begin
+        @websocket = Async::WebSocket::Client.connect(endpoint) # , handler: Sc2::Connection::Connection)
+        @listeners[ConnectionListener.name]&.each { _1.on_connected(self) }
+        # do initial ping to ensure status is set and connection is working
+        response_ping = ping
+        Sc2.logger.debug { "Game version: #{response_ping.game_version}" }
+      rescue Errno::ECONNREFUSED
+        raise Error, "Connection timeout. Max retry exceeded." unless (attempt += 1) < 30 # 30s attempts
+
+        @listeners[ConnectionListener.name]&.each { _1.on_connection_waiting(self) }
+        sleep(1)
+        retry
+      rescue Error => e
+        Sc2.logger.error "#{e.class}: #{e.message}"
+        @listeners[ConnectionListener.name]&.each { _1.on_disconnect(self) }
+      end
+      nil
+    end
+
+    # Closes Connection to client
+    # @return [void]
+    def close
+      @websocket&.close
+      @listeners[ConnectionListener.name]&.each { _1.on_disconnect(self) }
+    end
+
+    # Add a listener of specific callback type
+    # @param listener [Object]
+    # @param klass [Module<Sc2::Connection::ConnectionListener>,Module<Sc2::Connection::StatusListener>]
+    def add_listener(listener, klass:)
+      @listeners[klass.to_s] ||= []
+      @listeners[klass.to_s].push(listener)
+    end
+
+    # Removes a listener of specific callback type
+    # @param listener [Object]
+    # @param klass [Module<Sc2::Connection::ConnectionListener>,Module<Sc2::Connection::StatusListener>]
+    def remove_listener(listener, klass:)
+      @listeners[klass.to_s].delete(listener)
+    end
+
+    # ---------------------------------------------------------
+    # Sends a request synchronously and returns Api::Response type
+    # @return [Api::Response] response
+    def send_request(request)
+      @scheduler.async do |_task|
+        # r = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) #debug
+        # name =  request.is_a?(String) ? request : request.request #debug
+        request = request.to_proto unless request.is_a?(String)
+        @websocket.send_binary(request)
+        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
+
+        # Sc2.logger.debug { response }
+        # puts "#{(::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - r) * 1000} - #{name}" #debug
+        response
+      end.wait
+    rescue EOFError => e
+      Sc2.logger.error e
+      close
+    end
+
+    # Sends and ignores response.
+    # Meant to be used as optimization for RequestStep.
+    # No other command sends and ignores.
+    # Expects request to be to_proto'd already
+    # @return [void]
+    def send_request_and_ignore(request)
+      @scheduler.async do |_task|
+        @websocket.send_binary(request)
+        while @websocket.read_frame
+          if @websocket.frames.last&.finished?
+            @websocket.frames = []
+            break
+          end
+        end
+      end.wait
+
+      nil
+    end
+
+    private
+
+    attr_writer :status, :listeners
+
+    # @return [HTTP::Endpoint] websocket url for establishing protobuf connection
+    def endpoint
+      Async::HTTP::Endpoint.parse("ws://#{@host}:#{@port}/sc2api")
+    end
+  end
+end

data/lib/sc2ai/local_play/client/configurable_options.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Sc2
+  class Client
+    # Attributes shared by Configuration and Client
+    module ConfigurableOptions
+      # @!attribute host
+      # Sc2 host param on which to listen for connections, default '0.0.0.0'
+      #
+      # Launch param: -host 0.0.0.0
+      # @return [String,nil]
+      attr_accessor :host
+
+      # @!attribute data_dir
+      # Override the path to find the data package.
+      #
+      # Required if the binary is not in the standard versions folder location.
+      #
+      # Launch param: -dataDir ../../
+      # @return [String,nil]
+      attr_accessor :data_dir
+
+      # @!attribute verbose
+      # If set to true, will send param to client.
+      #
+      # Enables logging of all protocol requests/responses to std::err.
+      #
+      # Launch param: -verbose
+      # @return [Boolean]
+      attr_accessor :verbose
+
+      # @!attribute temp_dir
+      # Override the path if you really need to set your own temp dir
+      #
+      # Implicit default is /tmp/
+      #
+      # Launch param: -tempDir ../../
+      # @return [String,nil]
+      attr_accessor :temp_dir
+
+      # @!attribute egl_path
+      # Sets the path the to hardware rendering library.
+      #
+      # Required for using the rendered interface with hardware rendering
+      #
+      # Launch param: -eglpath
+      #
+      # Example: /usr/lib/nvidia-384/libEGL.so
+      # @return [String,nil]
+      attr_accessor :egl_path
+
+      # @!attribute osmesa_path
+      # Sets the path the to software rendering library.
+      #
+      # Required for using the rendered interface with software rendering
+      #
+      # Launch param: -eglpath
+      #
+      # Example: /usr/lib/x86_64-linux-gnu/libOSMesa.so
+      # @return [String,nil]
+      attr_accessor :osmesa_path
+
+      # @!attribute display_mode
+      # Launch param: -displayMode
+      # @return [0,1,nil] 0 for window, 1 for fullscreen, nil for system default
+      attr_accessor :display_mode
+      # @!attribute windowwidth
+      # pixel width of game window
+      # @return [Integer]
+      attr_accessor :windowwidth # -windowwidth
+      # @!attribute windowheight
+      # pixel height of game window
+      # @return [Integer]
+      attr_accessor :windowheight # -windowheight
+      # @!attribute windowx
+      # left position of window if windowed
+      # @return [Integer]
+      attr_accessor :windowx # -windowx
+      # @!attribute windowy
+      # top position of window if windowed
+      # @return [Integer]
+      attr_accessor :windowy # -windowy
+
+      # @!attribute version
+      # Version number such as "4.10". Leave blank to use latest
+      # @return [String,nil]
+      attr_accessor :version
+
+      # Resets configurable launch options to their defaults
+      def load_default_launch_options
+        @host = "0.0.0.0" # -listen
+        if Paths.wsl?
+          @host = "#{Socket.gethostname}.mshome.net"
+        elsif Gem.win_platform?
+          @host = "127.0.0.1"
+        end
+
+        @display_mode = 0 # -displayMode
+        @windowwidth = nil # -windowwidth
+        @windowheight = nil # -windowheight
+        @windowx = nil # -windowx
+        @windowy = nil # -windowy
+        @verbose = false # -verbose
+
+        # Linux
+        @data_dir = nil # -dataDir '../../'
+        @temp_dir = nil # -tempDir '/tmp/'
+        @egl_path = nil # -eglpath '/usr/lib/nvidia-384/libEGL.so'
+        @osmesa_path = nil # -osmesapath '/usr/lib/x86_64-linux-gnu/libOSMesa.so'
+
+        @version = nil # calculates -dataVersion and Base% executable
+      end
+    end
+  end
+end

data/lib/sc2ai/local_play/client.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative "client/configurable_options"
+
+module Sc2
+  # Manages client connection to the Api
+  class Client
+    include Sc2::Client::ConfigurableOptions
+
+    # @!attribute port
+    # Sc2 port param on which to listen for connections, default is randomly selected<br>
+    # Launch param: -port 12345
+    # @return [Integer]
+    attr_accessor :port
+
+    # @!attribute base_build
+    # Sc2 build number determines where to look for correct executable version binary
+    # @return [Integer]
+    attr_accessor :base_build
+
+    # @!attribute data_version
+    # Sc2 data param, typically only required when launching older versions and Linux
+    # Launch param: -dataVersion "B89B5D6FA7CBF6452E721311BFBC6CB2"
+    # @return [String]
+    attr_accessor :data_version
+
+    # Whether the Sc2 process is running or not
+    # @return [Boolean]
+    def running?
+      !!@task&.running?
+    end
+
+    # Initialize new Sc2 client (starts with #launch)
+    # @param host [String] to listen on, i.e. "0.0.0.0", "127.0.0.1"
+    # @param port [Integer] 5001
+    # @param options [Hash] (see Sc2::Client::ConfigurableOptions)
+    def initialize(host:, port:, **options)
+      raise Error, "Invalid port: #{port}" if port.to_s.empty?
+
+      load_default_launch_options
+      options.each do |key, value|
+        instance_variable_set(:"@#{key}", value)
+      end
+
+      # Require these at a minimum
+      @port = port
+      @host = host
+      return if @version.nil?
+
+      use_version(@version.to_s)
+    end
+
+    # Launches and returns pid or proc
+    def launch
+      cwd = Paths.exec_working_dir
+      @task = Async do |task|
+        options = {}
+
+        if Gem.win_platform?
+          options[:new_pgroup] = true
+        else
+          options[:pgroup] = true
+        end
+        unless cwd.nil?
+          options[:chdir] = cwd
+        end
+        begin
+          ::Async::Process.spawn(command_string, **options)
+        rescue
+          Sc2.logger.info("Client exited unexpectedly")
+          task&.stop
+        end
+      end
+    end
+
+    # Stops the Sc2 instance<br/>
+    # This naturally disconnects attached players too
+    # @return [void]
+    def stop
+      @task&.stop
+    end
+
+    # Reads "base-version" and "data-hash" for corresponding version
+    # @example
+    #   client.base_build => nil
+    #   client.data_version => nil
+    #   client.use_version("4.10")
+    #   client.base_build => 75689
+    #   client.data_version => "B89B5D6FA7CBF6452E721311BFBC6CB2"
+    # @param version [String]
+    # return [Array<Integer,String>] tuple base_build and data_version
+    def use_version(version)
+      found_base_build = nil
+      found_data_version = nil
+      versions_json.each do |node|
+        version_clean = version.gsub(".#{node["base-version"]}", "")
+        if version_clean == node["label"]
+          found_base_build = node["base-version"]
+          found_data_version = node["data-hash"]
+          @version = version_clean
+          break
+        end
+      end
+      if found_base_build.nil? || found_data_version.nil?
+        Sc2.logger.warn "Requested version #{version} not found. Omit to auto-discover latest installed version"
+        return false
+      end
+
+      @base_build = found_base_build
+      @data_version = found_data_version
+      true
+    end
+
+    private
+
+    # @!attribute task
+    # The async task running Sc2. Used when interrupting.
+    # @return [Async::Task]
+    attr_accessor :task
+
+    # @private
+    # Takes all configuration and Sc2 executable string with arguments
+    # @return [String] command to launch Sc2
+    def command_string
+      command = "\"#{Sc2::Paths.executable(base_build: @base_build)}\" "
+      command += " -port #{@port}"
+      if Paths.platform == Paths::PF_WSL2
+        # For WSL2, always let windows listen on all 0.0.0.0
+        #   and let the ws connect @host which is the internal bridged windows ip
+        command += " -listen 0.0.0.0"
+      else
+        command += " -listen #{@host}" unless @host.nil?
+      end
+
+      command += " -dataVersion #{@data_version}" unless @data_version.nil?
+      command += " -verbose" if @verbose
+
+      command += " -displayMode #{@display_mode}" unless @display_mode.nil?
+      command += " -windowwidth #{@windowwidth}" unless @windowwidth.nil?
+      command += " -windowheight #{@windowheight}" unless @windowheight.nil?
+      command += " -windowx #{@windowx}" unless @windowx.nil?
+      command += " -windowy #{@windowy}" unless @windowy.nil?
+
+      command += " -dataDir #{@data_dir}" unless @data_dir.nil?
+      command += " -tempDir #{@temp_dir}" unless @temp_dir.nil?
+      command += " -eglpath #{@egl_path}" unless @egl_path.nil?
+      command += " -osmesapath #{@osmesa_path}" unless @osmesa_path.nil?
+
+      command
+    end
+
+    # @private
+    # Reads bundled versions.json
+    # @return [JSON] contents of versions.json
+    def versions_json
+      JSON.load_file(Paths.gem_data_versions_path)
+    end
+  end
+end

data/lib/sc2ai/local_play/client_manager.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "forwardable"
+
+module Sc2
+  # Starts, stops and holds reference to clients
+  class ClientManager
+    include Singleton
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, :obtain, :get, :start, :stop
+    end
+
+    # Gets client for player X or starts an instance
+    def obtain(player_index)
+      client = get(player_index)
+      if client.nil? || !client.running?
+        client = start(player_index)
+        @clients[player_index] = client
+      end
+      client
+    end
+
+    # Gets Sc2::Client client for player index
+    # @param player_index [Integer] normally 0,1
+    # @return [Sc2::Connection, nil] running client or nil if not set
+    def get(player_index)
+      @clients[player_index]
+    end
+
+    # Starts an Sc2 client for player_index. Will stop existing client if present.
+    # @param player_index [Integer] normally 0,1
+    # @return [Sc2::Client] started client
+    def start(player_index)
+      existing = @clients[player_index]
+      stop(player_index) if !existing.nil? && existing.running?
+
+      client = Client.new(host: @host, port: @ports[player_index], **Sc2.config.to_h)
+      client.launch
+      @clients[player_index] = client
+      client
+    end
+
+    # Stops client at player index
+    # @param player_index [Integer]
+    # @return [void]
+    def stop(player_index)
+      return unless @clients[player_index]
+
+      @clients[player_index]&.stop
+      @clients[player_index] = nil
+    end
+
+    private
+
+    attr_accessor :clients, :ports
+
+    def initialize
+      super
+      @ports = Sc2.config.ports
+      @ports = [] unless ports.is_a? Array
+      @ports.push(Ports.random_available_port) while @ports.size < 3
+
+      @host = Sc2.config.host
+      @clients = []
+    end
+  end
+end

data/lib/sc2ai/local_play/map_file.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Sc2
+  # Helps easily locate a map and fetch input for Api::LocalMap
+  class MapFile
+    # File extension used for maps
+    EXTENSION = ".SC2Map"
+
+    # @!attribute [r] path
+    #   @return [String] path map location for use in LocalMap.map_path
+    attr_reader :path
+
+    # Accepts a map file name and initializes a local map object
+    # @example
+    #   map = Sc2::Map.new("2000AtmospheresAIE")
+    #   map = Sc2::Map.new("2000AtmospheresAIE.SC2Map")
+    #   map = Sc2::Map.new("/absolute/path/to/2000AtmospheresAIE.SC2Map")
+    #   # If within your Sc2 Maps folder, you have a sub-folder "sc2ai_2022_season3"
+    #   map = Sc2::Map.new("sc2ai_2022_season3/2000AtmospheresAIE.SC2Map")
+    # @param name [String] absolute path or path relative to maps
+    def initialize(name)
+      raise Error if name.empty?
+
+      name = "#{name}#{EXTENSION}" unless name.end_with? EXTENSION
+
+      @path = name.to_s
+      return if Pathname(name).absolute?
+
+      @path = Pathname(Paths.maps_dir).glob("**/#{name}").first.to_s
+      if Paths.wsl?
+        @path = Paths.wsl_to_win(path: @path)
+      end
+    end
+
+    # Returns contents of map file for user with LocalMap.map_data
+    # @return [String, nil] contents of file
+    def data
+      file = Pathname(@path)
+      return file.read if file.exist?
+
+      nil
+    end
+
+    private
+
+    attr_writer :path
+  end
+end