sc2ai 0.6.5 → 0.8.0

data/lib/sc2ai/connection.rb

@@ -11,6 +11,11 @@ module Sc2
     # Api requests
     include Sc2::Connection::Requests
 
+    # @private
+    # Total milliseconds spent waiting on SC2 responses
+    # @return [Float]
+    attr_accessor :external_time
+
     attr_accessor :host, :port, :websocket
 
     # Last known game status, i.e. :launched, :ended, :unknown
@@ -37,6 +42,7 @@ module Sc2
       @listeners = {}
       @websocket = nil
       @status = :unknown
+      @external_time = 0.0
       # 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)
@@ -94,19 +100,20 @@ module Sc2
     # @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)
+
+        time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
         @websocket.send_binary(request)
-        response = Api::Response.decode(@websocket.read.to_str)
+        response = @websocket.read.to_str
+        @external_time += Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - time
+
+        response = Api::Response.decode(response)
 
         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
@@ -121,6 +128,7 @@ module Sc2
     # @return [void]
     def send_request_and_ignore(request)
       @scheduler.async do |_task|
+        time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
         @websocket.send_binary(request)
         while @websocket.read_frame
           if @websocket.frames.last&.finished?
@@ -128,6 +136,7 @@ module Sc2
             break
           end
         end
+        @external_time += Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - time
       end.wait
 
       nil

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

@@ -82,7 +82,7 @@ module Sc2
       attr_accessor :windowy # -windowy
 
       # @!attribute version
-      # Version number such as "4.10". Leave blank to use latest
+      # Version number such as "ladder" or "4.10". Leave blank to use latest
       # @return [String,nil]
       attr_accessor :version
 

data/lib/sc2ai/local_play/client.rb

@@ -5,6 +5,27 @@ require_relative "client/configurable_options"
 module Sc2
   # Manages client connection to the Api
   class Client
+    class << self
+      # @private
+      # Reads bundled versions.json
+      # See tact archive or blizztrack for update config file
+      # https://github.com/mdX7/tact_configs/blob/77ecc4176689ab6c50be342e1ad73127ffe358d7/tpr/sc2/config/08/b3/08b331b39d9fbe95c338ec370e63f2e2#L4
+      # https://blizztrack.com/config/s2/bc/8453c2f1c98b955334c7284215429c36
+      # @example
+      #     {
+      #       "base-version": 92028, # <- from "build-name" [1..-1] = "B92028"
+      #       "data-hash": "2B7746A6706F919775EF1BADFC95EA1C", # <- from "root"
+      #       "fixed-hash": "163B1CDF46F09B621F6312CD6901228E", # <- from "build-fixed-hash"
+      #       "label": "5.0.13", # <- check game client
+      #       "replay-hash": "BE64E420B329BD2A7D10EEBC0039D6E5", # <- from "build-replay-hash"
+      #       "version": 92028 <- always same as base-version these days
+      #     },
+      # @return [Array] JSON contents of versions.json
+      def versions_json
+        JSON.load_file(Paths.gem_data_versions_path)
+      end
+    end
+
     include Sc2::Client::ConfigurableOptions
 
     # @!attribute port
@@ -92,12 +113,11 @@ module Sc2
     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"]
+      Sc2::Client.versions_json.each do |node|
+        if version == node["label"]
           found_base_build = node["base-version"]
           found_data_version = node["data-hash"]
-          @version = version_clean
+          @version = version
           break
         end
       end
@@ -122,7 +142,11 @@ module Sc2
     # 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 = ""
+      if Paths.platform == Paths::PF_WINE
+        command = "#{ENV["WINE"] || "wine"} "
+      end
+      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
@@ -148,12 +172,5 @@ module Sc2
 
       command
     end
-
-    # @private
-    # Reads bundled versions.json
-    # @return [Array] 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

@@ -10,6 +10,7 @@ module Sc2
 
     class << self
       extend Forwardable
+
       def_delegators :instance, :obtain, :get, :start, :stop, :stop_all, :host
     end
 

data/lib/sc2ai/local_play/map_file.rb

@@ -29,6 +29,9 @@ module Sc2
       @path = Pathname(Paths.maps_dir).glob("**/#{name}").first.to_s
       if Paths.wsl?
         @path = Paths.wsl_to_win(path: @path)
+      elsif Paths.platform == Paths::PF_WINE
+        # Get relative path based on Maps folder
+        @path = Pathname(@path.gsub(Pathname(Paths.maps_dir).to_s, "")).to_s
       end
     end
 

data/lib/sc2ai/player/actions.rb

@@ -2,6 +2,29 @@ module Sc2
   class Player
     # Holds action list and queues batch
     module Actions
+      COMBINABLE_ABILITIES = [
+        Api::AbilityId::MOVE,
+        Api::AbilityId::ATTACK,
+        Api::AbilityId::SCAN_MOVE,
+        Api::AbilityId::STOP,
+        Api::AbilityId::SMART,
+        Api::AbilityId::HOLDPOSITION,
+        Api::AbilityId::PATROL,
+        Api::AbilityId::HARVEST_GATHER,
+        Api::AbilityId::HARVEST_RETURN,
+        Api::AbilityId::EFFECT_REPAIR,
+        Api::AbilityId::LIFT,
+        Api::AbilityId::BURROWDOWN,
+        Api::AbilityId::BURROWUP,
+        Api::AbilityId::SIEGEMODE_SIEGEMODE,
+        Api::AbilityId::UNSIEGE_UNSIEGE,
+        Api::AbilityId::MORPH_LIBERATORAAMODE,
+        Api::AbilityId::EFFECT_STIM,
+        Api::AbilityId::MORPH_UPROOT,
+        Api::AbilityId::EFFECT_BLINK,
+        Api::AbilityId::MORPH_ARCHON
+      ]
+
       # Holds actions which will be queued off each time we step forward
       # @!attribute action_queue
       #   @return [Array<Api::Action>]
@@ -382,6 +405,7 @@ module Sc2
       # @return [Api::ResponseAction, nil]
       def perform_actions
         return nil if @action_queue.empty?
+        combine_similar_actions
 
         response_action = @api.action(@action_queue)
         if callback_defined?(:on_action_errors)
@@ -404,6 +428,37 @@ module Sc2
         response_action
       end
 
+      # @private
+      # Makes 10x unit moves to the same target turn into one action
+      # with many unit_tags
+      # @return [void]
+      private def combine_similar_actions
+        grouped_actions = @action_queue.group_by do |action|
+          unit_command = action&.action_raw&.unit_command
+          [unit_command.nil? || !!unit_command&.queue_command,
+            unit_command&.ability_id,
+            unit_command&.target_world_space_pos,
+            unit_command&.target_unit_tag]
+        end
+
+        grouped_actions.each do |key, dupe_actions|
+          # Don't merge if it's not a unit command
+          # or queue_command is true
+          # or the action is unique
+          next if key[0] || dupe_actions.size < 2
+          # Skip if not a combinable ability such as Attack or Move
+          next unless COMBINABLE_ABILITIES.include?(key[1])
+
+          new_action = dupe_actions.first.dup
+          unit_tags = dupe_actions.flat_map do |dupe_action|
+            dupe_action.action_raw.unit_command.unit_tags
+          end
+          new_action.action_raw.unit_command.unit_tags = unit_tags
+          @action_queue = @action_queue.difference(dupe_actions)
+          @action_queue.unshift(new_action)
+        end
+      end
+
       # Empties and resets @action_queue
       # @return [void]
       def clear_action_queue

data/lib/sc2ai/player/game_state.rb

@@ -9,6 +9,7 @@ module Sc2
       attr_accessor :status
 
       include Connection::StatusListener
+
       # Callback when game status changes
       def on_status_change(status)
         self.status = status

data/lib/sc2ai/player/geo.rb

@@ -347,14 +347,14 @@ module Sc2
 
       # Returns a parsed terrain_height from bot.game_info.start_raw.
       # Each value in [row][column] holds a float value which is the z height
-      # @return [::Numo::SFloat] Numo array
+      # @return [::Numo::DFloat] Numo array
       def parsed_terrain_height
         if @parsed_terrain_height.nil?
 
           image_data = bot.game_info.start_raw.terrain_height
           @parsed_terrain_height = Numo::UInt8
             .from_binary(image_data.data, [image_data.size.y, image_data.size.x])
-            .cast_to(Numo::SFloat)
+            .cast_to(Numo::DFloat)
 
           # Values are between -16 and +16. The api values is a float height compressed to rgb range (0-255) in that range of 32.
           # real_height = -16 + (value / 255) * 32
@@ -400,7 +400,7 @@ module Sc2
       # Returns a parsed map_state.visibility from bot.observation.raw_data.
       # Each value in [row][column] holds one of three integers (0,1,2) to flag a vision type
       # @see #visibility for reading from this value
-      # @return [::Numo::SFloat] Numo array
+      # @return [::Numo::UInt8] Numo array
       def parsed_visibility_grid
         if @parsed_visibility_grid.nil?
           image_data = bot.observation.raw_data.map_state.visibility
@@ -520,11 +520,11 @@ module Sc2
         point_search_offsets = (-7..7).to_a.product((-7..7).to_a)
         point_search_offsets.select! do |x, y|
           dist = Math.hypot(x, y)
-          dist > 4 && dist <= 8
+          dist > 4.0 && dist <= 8.0
         end
 
         # Split resources by Z axis
-        resources = bot.neutral.minerals.reject_type(Api::UnitTypeId::MINERALFIELD450) + bot.neutral.geysers
+        resources = bot.neutral.minerals - mineral_walls + bot.neutral.geysers
         resource_group_z = resources.group_by do |resource|
           resource.pos.z.round # 32 units of Y, most maps will have use 3. round to nearest.
         end
@@ -591,11 +591,86 @@ module Sc2
             # Choose best fitting point
             best_point = possible_points.keys[possible_points.values.find_index(possible_points.values.min)]
             @expansions[best_point.to_p2d] = UnitGroup.new(clustered_resources)
+
+            # Check if this might be a mirrored base.
+            best_mirror_point = nil
+            geysers = clustered_resources.select { |res| Sc2::UnitGroup::TYPE_GEYSER.include?(res.unit_type) }
+            if geysers.size == 2
+              if geysers[0].pos.y == geysers[1].pos.y || geysers[0].pos.x == geysers[1].pos.x
+                # Mirrored vertical, potentially
+                best_mirror_point = [
+                  best_point[0],
+                  best_point[1] - (best_point[1] - (geysers[0].pos.y + geysers[1].pos.y) / 2.0) * 2.0
+                ]
+                if best_mirror_point != best_point && possible_points.has_key?(best_mirror_point)
+                  @expansions[best_mirror_point.to_p2d] = UnitGroup.new(clustered_resources)
+                else
+                  # Wasn't mirrored the one way. How about the other?...
+                  # Mirrored horizontal, potentially
+                  best_mirror_point = [
+                    best_point[0] - (best_point[0] - (geysers[0].pos.x + geysers[1].pos.x) / 2.0) * 2.0,
+                    best_point[1]
+                  ]
+                  if best_mirror_point != best_point && possible_points.has_key?(best_mirror_point)
+                    @expansions[best_mirror_point.to_p2d] = UnitGroup.new(clustered_resources)
+                  end
+
+                end
+              end
+            end
           end
         end
         @expansions
       end
 
+      # @private
+      # Mineral walls. Defined once upon start of game, mostly based on layout.
+      # @return [Sc2::UnitGroup]
+      private def mineral_walls
+        return @mineral_walls unless @mineral_walls.nil?
+
+        # Find mineral walls.
+        @mineral_walls = []
+        minerals_by_pos = {}
+        bot.neutral.minerals.reject_type(Api::UnitTypeId::MINERALFIELD450)
+          .each do |mineral|
+          minerals_by_pos[mineral.pos.to_axy] = mineral
+        end
+        minerals_by_pos.each do |xy, mineral|
+          x, y = xy
+          # Test X
+          if (side1 = minerals_by_pos[[x - 2, y]]) && (side2 = minerals_by_pos[[x + 2, y]])
+            @mineral_walls << side1
+            @mineral_walls << mineral
+            @mineral_walls << side2
+          end
+
+          # # Test Y
+          if (side1 = minerals_by_pos[[x, y - 1]]) && (side2 = minerals_by_pos[[x, y + 1]])
+            @mineral_walls << side1
+            @mineral_walls << mineral
+            @mineral_walls << side2
+          end
+
+          # Test \
+          if (side1 = minerals_by_pos[[x - 2, y + 1]]) && (side2 = minerals_by_pos[[x + 2, y - 1]])
+            @mineral_walls << side1
+            @mineral_walls << mineral
+            @mineral_walls << side2
+          end
+
+          # Test /
+          if (side1 = minerals_by_pos[[x - 2, y - 1]]) && (side2 = minerals_by_pos[[x + 2, y + 1]])
+            @mineral_walls << side1
+            @mineral_walls << mineral
+            @mineral_walls << side2
+          end
+        end
+        @mineral_walls.uniq!
+
+        @mineral_walls = UnitGroup.new(@mineral_walls) + bot.neutral.minerals.select_type(Api::UnitTypeId::MINERALFIELD450)
+      end
+
       # Returns a list of 2d points for expansion build locations
       # Does not contain mineral info, but the value can be checked against geo.expansions
       #

data/lib/sc2ai/player/units.rb

@@ -44,7 +44,7 @@ module Sc2
       # Shorthand for observation.raw_data.player.upgrade_ids
       # @!attribute [r] upgrades_completed
       #   @return [Array<Integer>] a group of neutral units
-      def upgrades_completed = observation&.raw_data&.player&.upgrade_ids.to_a || [] # not a unit
+      def upgrades_completed = observation&.raw_data&.player&.upgrade_ids.to_a # not a unit
 
       # Returns true if this upgrade has finished researching
       # @return [Boolean]
@@ -170,7 +170,7 @@ module Sc2
 
       # @private
       # @!attribute all_seen_unit_tags
-      # Privately keep track of all seen Unit tags (excl structures) in order to detect new created units
+      # Privately keep track of all seen Unit tags in order to detect new created units
       attr_accessor :_all_seen_unit_tags
       private :_all_seen_unit_tags
 
@@ -188,14 +188,6 @@ module Sc2
       #   @return [Sc2::UnitGroup] group of dead units
       attr_accessor :event_units_destroyed
 
-      # TODO: Unit buff disabled, because it calls back too often (mineral in hand). Put back if useful
-      # @private
-      # Units (Unit/Structure) on which a new buff_ids appeared this frame
-      # See which buffs via: unit.buff_ids - unit.previous.buff_ids
-      # Read this on_step. Alternative to callback on_unit_buffed
-      # @!attribute event_units_destroyed
-      # attr_accessor :event_units_buffed
-
       # Returns static [Api::UnitTypeData] for a unit
       # @param unit [Integer,Api::Unit] Api::UnitTypeId or Api::Unit
       # @return [Api::UnitTypeData]
@@ -360,7 +352,6 @@ module Sc2
 
         # Event-driven unit groups as callback alternatives
         @event_units_damaged = UnitGroup.new
-        # @event_units_buffed = UnitGroup.new
 
         # Categorization of self/enemy, structure/unit ---
         own_alliance = self.own_alliance
@@ -470,7 +461,7 @@ module Sc2
           on_unit_type_changed(unit, previous_unit.unit_type)
         end
 
-        # Check if a unit type has changed
+        # Check if a unit has taken damage
         if unit.health < previous_unit.health || unit.shield < previous_unit.shield
           damage_amount = previous_unit.health - unit.health + previous_unit.shield - unit.shield
           @event_units_damaged.add(unit)

data/lib/sc2ai/player.rb

@@ -19,6 +19,7 @@ module Sc2
     # include Sc2::Connection::ConnectionListener
 
     extend Forwardable
+
     def_delegators :@api, :add_listener
 
     # Known races for detecting race on Api::Race::RANDOM or nil
@@ -72,6 +73,21 @@ module Sc2
     # @return [String] ladder matches will set an opponent id
     attr_accessor :opponent_id
 
+    # @!attribute timer
+    #   Keeps track of time spent in steps.
+    #   @see Sc2::StepTimer
+    #   @example
+    #     # Useful for step-time as on ladder
+    #     @timer.avg_step_time
+    #     # Recent steps time, updated periodically. Good for debug ui
+    #     @timer.avg_recent_step_time
+    #     # Step time between now and previous measure and how many steps
+    #     @timer.previous_on_step_time # Time we spent on step
+    #     @timer.previous_on_step_count # How many steps we took
+    #
+    #   @return [Sc2::StepTimer]
+    attr_accessor :timer
+
     # @param race [Integer] see {Api::Race}
     # @param name [String]
     # @param type [Integer] see {Api::PlayerType}
@@ -217,59 +233,31 @@ module Sc2
       def configure
       end
 
-      alias_method :before_join, :configure
-
       # TODO: If this suffices for Bot and Observer, they should share this code.
       # Initializes and refreshes game data and runs the game loop
       # @return [Integer] One of Api::Result::VICTORY, Api::Result::DEFEAT, Api::Result::TIE, Api::Result::UNDECIDED
       def play
+        @timer = StepTimer.new(self)
+
         # Step 0
         prepare_start
         refresh_state
         started
 
+        @timer.update
+
         # Callback before first step is taken
         on_start
+
         # Callback for step 0
         on_step
 
-        # Local play prints out avg times
-        unless Sc2.ladder?
-          running_avg_step_times = []
-          average_runtime = 0.0
-        end
-
-        puts ""
-
         # Step 1 to n
-        i = 0
         loop do
-          if i >= 5
-            i = 0
-          end
-          r = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
           perform_actions
           perform_debug_commands unless Sc2.ladder?
           step_forward
 
-          unless Sc2.ladder?
-            time_delta = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - r) * 1000
-            step_delta = game_loop - @previous.game_loop
-            # running_avg_step_times.shift if running_avg_step_times.size == 5
-            running_avg_step_times << [time_delta, step_delta]
-
-            if i == 0
-              sum_t, sum_s = running_avg_step_times.each_with_object([0, 0]) do |n, total|
-                total[0] += n[0]
-                total[1] += n[1]
-              end
-              average_runtime = sum_t / sum_s
-              running_avg_step_times.clear
-            end
-            print "\e[2K#{step_delta} Step(s) Took (ms): #{"%.2f" % time_delta} | Avg (ms/frame): #{"%.2f" % average_runtime}\n\e[1A\r"
-          end
-
-          i += 1
           return @result unless @result.nil?
           break if @status != :IN_GAME
         end
@@ -587,6 +575,7 @@ module Sc2
       end
 
       refresh_state
+      @timer.update # Runtimes calc
       on_step if @result.nil?
     end
 
@@ -595,7 +584,6 @@ module Sc2
     # @return [void]
     # TODO: After cleaning up all the comments, review whether this is too heavy or not. #perf #clean
     def refresh_state
-      # Process.clock_gettime(Process::CLOCK_MONOTONIC)
       step_to_loop = @realtime ? game_loop + @step_count : nil
       response_observation = @api.observation(game_loop: step_to_loop)
       return if response_observation.nil?
@@ -622,8 +610,7 @@ module Sc2
 
       # First game-loop: set enemy and our race if random
       if enemy.nil?
-        # Finish game_info load immediately, because we need it's info
-        game_info
+        # Finish game_info load immediately, because we need its info
         set_enemy
         set_race_for_random if race == Api::Race::RANDOM
       end

data/lib/sc2ai/ports.rb

@@ -113,7 +113,8 @@ module Sc2
       end
 
       # Will bind tcp port and return port if successful
-      # if port is zero, it will return random port bound to
+      # when port is zero, it will return random port bound to
+      # @param port [Integer]
       # @return [Integer, Boolean] port if bind succeeds, false on failure
       def bind(port)
         socket = ::Socket.new(:AF_INET, :SOCK_STREAM, 0)
@@ -130,8 +131,19 @@ module Sc2
 
   # A port configuration for a Match which allows generating Api::PortSet
   class PortConfig
-    attr_reader :start_port, :server_port_set, :client_port_sets
-
+    # @!attribute start_port
+    #   @return [Integer]
+    attr_reader :start_port
+    # @!attribute server_port_set
+    #   @return [Array<Integer>]
+    attr_reader :server_port_set
+    # @!attribute client_port_sets
+    #   @return [Array<Integer>]
+    attr_reader :client_port_sets
+
+    # @param [Integer] start_port
+    # @param [Integer] num_players
+    # @param [Array<Integer>] ports
     def initialize(start_port:, num_players:, ports: [])
       @start_port = start_port
       @server_port_set = nil

data/lib/sc2ai/protocol/extensions/position.rb

@@ -5,6 +5,14 @@ module Sc2
     # Tolerance for floating-point comparisons.
     TOLERANCE = 1e-9
 
+    # Returns self.
+    # If you're ever unsure if you have a Unit or Position in hand,
+    # this method allows safely calling `unknown_target.pos` to return a position.
+    # @example
+    #   target.pos
+    # @return [Sc2::Position]
+    def pos = self
+
     # Basic operations
 
     # Loose equality matches on floats x and y.
@@ -70,10 +78,12 @@ module Sc2
       dup.random_offset!(offset)
     end
 
-    # Changes this point's x and y by the supplied offset
+    # Randomly change this point's x and y by the supplied offset.
+    # i.e. offset=2 can adjust x and y by any number in range -2..2
+    # @param offset [Float]
     # @return [Sc2::Position] self
     def random_offset!(offset)
-      offset = offset.to_f
+      offset = offset.to_f.abs
       range = -offset..offset
       offset!(rand(range), rand(range))
       self
@@ -136,6 +146,7 @@ module Sc2
 
     # Linear interpolation between this point and another for scale
     # Finds a point on a line between two points at % along the way. 0.0 returns self,  1.0 returns other, 0.5 is halfway.
+    # @param other [Sc2::Position]
     # @param scale [Float] a value between 0.0..1.0
     # @return [Api::Point2D]
     def lerp(other, scale)
@@ -214,12 +225,13 @@ module Sc2
 
     # Returns [x,y] array tuple where floats are cast to ints
     # Useful when trying to find the tile which something is on
-    # @return [Array<Integer, Integer>
+    # @return [Array<Integer, Integer>]
     def to_atile
       [x.to_i, y.to_i]
     end
 
     # @private
+    # @return [String]
     def to_s
       "#<#{self.class} x=#{x} y=#{y}>"
     end