sc2ai 0.0.6 → 0.0.7

data/lib/sc2ai/api/upgrade_id.rb

@@ -299,14 +299,14 @@ module Api
     DIGGINGCLAWS = 293
     CARRIERCARRIERCAPACITY = 294
     CARRIERLEASHRANGEUPGRADE = 295
-    TEMPESTGROUNDATTACKUPGRADE = 296
-    MICROBIALSHROUD = 297
-    SUNDERINGIMPACT = 298
-    AMPLIFIEDSHIELDING = 299
-    PSIONICAMPLIFIERS = 300
-    SECRETEDCOATING = 301
-    ENHANCEDSHOCKWAVES = 302
-    HURRICANETHRUSTERS = 303
-    INTERFERENCEMATRIX = 304
+    HURRICANETHRUSTERS = 296
+    TEMPESTGROUNDATTACKUPGRADE = 297
+    MICROBIALSHROUD = 298
+    INTERFERENCEMATRIX = 299
+    SUNDERINGIMPACT = 300
+    AMPLIFIEDSHIELDING = 301
+    PSIONICAMPLIFIERS = 302
+    SECRETEDCOATING = 303
+    ENHANCEDSHOCKWAVES = 304
   end
 end

data/lib/sc2ai/connection/requests.rb

@@ -279,10 +279,11 @@ module Sc2
       # 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(
+        @_cached_request_step ||= {}
+        @_cached_request_step[step_count] ||= Api::Request.new(
           step: Api::RequestStep.new(count: step_count)
         ).to_proto
-        send_request_and_ignore(@_cached_request_step)
+        send_request_and_ignore(@_cached_request_step[step_count])
       end
 
       # Additional methods for inspecting game state. Synchronous and must wait on response
@@ -291,7 +292,7 @@ module Sc2
       # @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)
+      def query(pathing: nil, abilities: nil, placements: nil, ignore_resource_requirements: false)
         send_request_for query: Api::RequestQuery.new(
           pathing:,
           abilities:,
@@ -316,7 +317,7 @@ module Sc2
       # @param queries [Array<Api::RequestQueryAvailableAbilities>] one or more pathing queries
       # @param ignore_resource_requirements [Boolean] Ignores requirements like food, minerals and so on.
       # @return [Array<Api::ResponseQueryAvailableAbilities>] one or more results depending on input size
-      def query_abilities(queries, ignore_resource_requirements: true)
+      def query_abilities(queries, ignore_resource_requirements: false)
         arr_queries = queries.is_a?(Array) ? queries : [queries]
 
         response = send_request_for query: Api::RequestQuery.new(
@@ -330,7 +331,8 @@ module Sc2
       # @param unit_tags [Array<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>] one or more results depending on input size
-      def query_abilities_for_unit_tags(unit_tags, ignore_resource_requirements: true)
+      def query_abilities_for_unit_tags(unit_tags, ignore_resource_requirements: false)
+        return [] if unit_tags.nil?
         queries = []
         unit_tags = [unit_tags] unless unit_tags.is_a? Array
         unit_tags.each do |unit_tag|
@@ -345,13 +347,14 @@ module Sc2
       # and can just return an array of ability ids.
       # Note: Querying single units are expensive and should be batched with #query_abilities_for_unit_tags
       # @param unit [Api::Unit, Integer] a unit or a tag.
-      def query_ability_ids_for_unit(unit, ignore_resource_requirements: true)
+      # @return [Array<Integer>] array of ability ids
+      def query_ability_ids_for_unit(unit, ignore_resource_requirements: false)
         tag = unit.is_a?(Api::Unit) ? unit.tag : unit
         result = query_abilities_for_unit_tags([tag], ignore_resource_requirements:)
         if result.nil?
           []
         else
-          result.first.abilities
+          result.first.abilities.map(&:ability_id)
         end
       end
 

data/lib/sc2ai/data.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "api/ability_id"
+require_relative "api/unit_type_id"
+require_relative "api/upgrade_id"
+require_relative "api/buff_id"
+require_relative "api/effect_id"
+require_relative "api/tech_tree"
+
+module Sc2
+  # Holds game data from tech tree and Api::ResponseData
+  # Called once on game start
+  class Data
+    # @!attribute abilities
+    #   @return [Hash<Integer, Api::AbilityData]>]  AbilitId => AbilityData
+    attr_accessor :abilities
+    # @!attribute units
+    #   @return [Hash<Integer, Api::UnitTypeData>] UnitId => UnitData
+    attr_accessor :units
+    # @!attribute upgrades
+    #   @return [Hash<Integer, Api::UpgradeData>] UpgradeId => UpgradeData
+    attr_accessor :upgrades
+    # @!attribute buffs
+    # Not particularly useful data. Just use BuffId directly
+    #   @return [Hash<Integer, Api::UpgradeData>] BuffId => BuffData
+    attr_accessor :buffs
+    # @!attribute effects
+    # Not particularly useful data. Just use EffectId directly
+    #   @return [Hash<Integer, Api::UpgradeData>] EffectId => EffectData
+    attr_accessor :effects
+
+    # @param data [Api::ResponseData]
+    def initialize(data)
+      return unless data
+
+      @abilities = abilities_from_proto(data.abilities)
+      @units = units_from_proto(data.units)
+      @upgrades = upgrades_from_proto(data.upgrades)
+      @buffs = buffs_from_proto(data.buffs)
+      @effects = effects_from_proto(data.effects)
+    end
+
+    private
+
+    # Indexes ability data by ability id
+    # @param abilities [Array<Api::AbilityData>]
+    # @return [Hash<Integer, Api::AbilityData] indexed data
+    def abilities_from_proto(abilities)
+      result = {}
+
+      ability_ids = Api::AbilityId.constants.map { |c| Api::AbilityId.const_get(c) }
+      abilities.each do |a|
+        next if a.ability_id.zero?
+        next if ability_ids.delete(a.ability_id).nil?
+
+        result[a.ability_id] = a
+      end
+      result
+    end
+
+    # Indexes unit data by id
+    # @param units [Array<Api::UnitTypeData>]
+    # @return [Hash<Integer, Api::UnitTypeData>] indexed data
+    def units_from_proto(units)
+      result = {}
+      units.each do |u|
+        next unless u.available
+
+        result[u.unit_id] = u
+      end
+      result
+    end
+
+    # Indexes upgrades data by id
+    # @param upgrades [Array<Api::UpgradeData>]
+    # @return [Hash<Integer, Api::UpgradeData] indexed data
+    def upgrades_from_proto(upgrades)
+      result = {}
+      upgrades.each do |u|
+        result[u.upgrade_id] = u
+      end
+      result
+    end
+
+    def effects_from_proto(effects)
+      result = {}
+      effects.each do |e|
+        result[e.effect_id] = e
+      end
+      result
+    end
+
+    def buffs_from_proto(buffs)
+      result = {}
+      buffs.each do |b|
+        result[b.buff_id] = b
+      end
+      result
+    end
+  end
+end

data/lib/sc2ai/local_play/match.rb

@@ -23,8 +23,6 @@ module Sc2
       # end
     end
 
-    # TODO: DEFINE REALTIME AS A PARAM
-
     # @!attribute players Sets the Player(s) for the match
     #   @return [Array<Sc2::Player>] an array of assigned players (ai,bots,humans,observers)
     attr_accessor :players
@@ -66,7 +64,7 @@ module Sc2
         connect_players
         setup_player_hooks
 
-        player_host.create_game(map:, players: @players)
+        player_host.create_game(map:, players: @players, realtime: player_host.realtime)
 
         api_players.each_with_index do |player, player_index|
           run_task.async do

data/lib/sc2ai/player/actions.rb

@@ -45,9 +45,12 @@ module Sc2
 
         target_pos = nil
         target_unit_tag = nil
-        if target.is_a? Api::Point2D
+        case target
+        when Api::Point2D
           target_pos = target
-        elsif target.is_a? Api::Unit
+        when Api::Point
+          target_pos = target.to_p2d
+        when Api::Unit
           target_unit_tag = target.tag
         else
           target_unit_tag = target
@@ -65,7 +68,7 @@ module Sc2
 
       # Builds target unit type using units as source at optional target
       # @param units [Array<Integer>,Integer,Api::Unit] can be an Api::Unit, array of Api::Unit#tag or single tag
-      # @param unit_type_id [Integer] Api::UnitTypeId the unit type which will do the creation
+      # @param unit_type_id [Integer] Api::UnitTypeId the unit type you wish to build
       # @param target [Api::Point2D, Integer, nil] is a unit tag or a Api::Point2D. Nil for addons/orbital
       # @param queue_command [Boolean] shift+command
       def build(units:, unit_type_id:, target: nil, queue_command: false)
@@ -79,9 +82,10 @@ module Sc2
 
       # Warps in unit type at target (location or pylon) with optional source units (warp gates)
       # When not specifying the specific warp gate(s), all warpgates will be used
-      # @param unit_type_id [Integer] Api::UnitTypeId the unit type which will do the creation
+      # @param unit_type_id [Integer] Api::UnitTypeId the unit type you wish to build
       # @param queue_command [Boolean] shift+command
       # @param target [Api::Point2D, Integer] is a unit tag or a Api::Point2D
+      # @param units [Array<Integer>, Integer, Api::Unit]
       def warp(unit_type_id:, target:, queue_command:, units: nil)
         warp_ability = Api::TechTree.unit_type_creation_abilities(
           source: Api::UnitTypeId::WARPGATE,

data/lib/sc2ai/player/debug.rb

@@ -133,7 +133,7 @@ module Sc2
       # Debug draws a sphere at position with a radius in color
       # @param point [Api::Point]
       # @param radius [Float] default one tile wide, 1.0
-      # @param color [Api::Color] default white. min(r,b) is used for both r&b
+      # @param color [Api::Color] default white
       # @return [void]
       def debug_draw_sphere(point:, radius: 1.0, color: nil)
         queue_debug_command Api::DebugCommand.new(
@@ -151,14 +151,13 @@ module Sc2
 
       # Other Commands ---
 
-      # Toggles cheat commands on/off (send only once to enable)
       # @param command [Integer] one of Api::DebugGameState::*
       # Possible values:
       #  Api::DebugGameState::Show_map
       #  Api::DebugGameState::Control_enemy
       #  Api::DebugGameState::Food
       #  Api::DebugGameState::Free
-      #  Api::DebugGameState::all_resources
+      #  Api::DebugGameState::All_resources
       #  Api::DebugGameState::God
       #  Api::DebugGameState::Minerals
       #  Api::DebugGameState::Gas

data/lib/sc2ai/player/game_state.rb

@@ -106,6 +106,34 @@ module Sc2
         @chats_received || []
       end
 
+      # @private
+      # @!attribute available_abilities_loop
+      #   This is the last loop at which available_abilities was queried.
+      #   Used to determine staleness.
+      # @return [Integer]
+      attr_accessor :available_abilities_loop
+      private :available_abilities_loop
+
+      # A Hash by unit tag, holding an array of available ability ids
+      # Synchronously calls RequestQueryAvailableAbilities and caches for this game loop.
+      # @return [Hash<Integer, Array<Integer>>] { unit_tag => [ability_id, ...], ... }
+      def available_abilities
+        # Save/check when last we refreshed abilities
+        if @available_abilities_loop != game_loop
+
+          # Query abilities for all our units + structure tags combined
+          abilities = api.query_abilities_for_unit_tags(units.tags + structures.tags, ignore_resource_requirements: false)
+          # Build the hash by unit tag
+          fresh_available_abilities = {}
+          abilities.each do |row|
+            fresh_available_abilities[row.unit_tag] = row.abilities.map(&:ability_id)
+          end
+          @available_abilities = fresh_available_abilities
+          @available_abilities_loop = game_loop
+        end
+        @available_abilities
+      end
+
       # An alias for observation.player_common to allow easier access to i.e. common.minerals
       # @return [Api::PlayerCommon] common info such as minerals, vespene, supply
       def common

data/lib/sc2ai/player/geometry.rb

@@ -31,6 +31,12 @@ module Sc2
         @map_height ||= bot.game_info.start_raw.map_size.y
       end
 
+      # Center of the map
+      # @return [Api::Point2D]
+      def map_center
+        @map_center ||= Api::Point2D[map_width / 2, map_height / 2]
+      end
+
       # Returns zero to map_width as range
       # @return [Range] 0 to map_width
       def map_range_x
@@ -100,8 +106,16 @@ module Sc2
           expansion_points.each do |point|
             x = point.x.floor
             y = point.y.floor
-            @expo_placement_grid[(y - 2).clamp(map_tile_range_y)..(y + 2).clamp(map_tile_range_y),
-                                 (x - 2).clamp(map_tile_range_y)..(x + 2).clamp(map_tile_range_y)] = 1
+
+            # For zerg, reserve a layer at the bottom for larva->egg
+            if bot.race == Api::Race::Zerg
+              # Reserve one row lower, meaning (y-3) instead of (y-2)
+              @expo_placement_grid[(y - 3).clamp(map_tile_range_y)..(y + 2).clamp(map_tile_range_y),
+                                   (x - 2).clamp(map_tile_range_y)..(x + 2).clamp(map_tile_range_y)] = 1
+            else
+              @expo_placement_grid[(y - 2).clamp(map_tile_range_y)..(y + 2).clamp(map_tile_range_y),
+                                   (x - 2).clamp(map_tile_range_y)..(x + 2).clamp(map_tile_range_y)] = 1
+            end
           end
         end
         @expo_placement_grid
@@ -121,40 +135,11 @@ module Sc2
           return result
         end
 
-        radius = power_source.radius
-        radius_tile = radius.ceil
-
-        # Keep this code-block, should we need to make power sources dynamic again:
-        # START: Dynamic blueprint
-        # # Build a blueprint and mark it everywhere we need to
-        # # Lets mark everything as powered with 1 and then disable non-powered with a 0
-        # blueprint = Numo::Bit.ones(radius.ceil * 2, radius.ceil * 2)
-        # #blueprint[radius_tile, radius_tile] = 0
-        # blueprint[(radius_tile - 1)..radius_tile, (radius_tile - 1)..radius_tile] = 0
-        # # Loop over top-right quadrant of a circle, so we don't have to +/- for distance calcs.
-        # # Additionally, we only measure if in the upper triangle, since the inner is all inside the circle.
-        # # Then apply to all four quadrants.
-        # quadrant_size = radius_tile - 1
-        # point_search_offsets = (0..quadrant_size).to_a.product((0..quadrant_size).to_a)
-        # point_search_offsets.each do |y, x|
-        #   next if x < quadrant_size - y # Only upper Triangle
-        #
-        #   dist = Math.hypot(x, y)
-        #   if dist >= radius
-        #     # Mark as outside x4
-        #     blueprint[radius_tile + y, radius_tile + x] = 0
-        #     blueprint[radius_tile + y, radius_tile - 1 - x] = 0
-        #     blueprint[radius_tile - 1 - y, radius_tile + x] = 0
-        #     blueprint[radius_tile - 1 - y, radius_tile - 1 - x] = 0
-        #   end
-        # end
-        # END: Dynamic blueprint ---
-
         # Hard-coding this shape for pylon power
         # 00001111110000
+        # 00011111111000
         # 00111111111100
         # 01111111111110
-        # 01111111111110
         # 11111111111111
         # 11111111111111
         # 11111100111111
@@ -162,15 +147,35 @@ module Sc2
         # 11111111111111
         # 11111111111111
         # 01111111111110
-        # 01111111111110
         # 00111111111100
+        # 00011111111000
         # 00001111110000
-
         # perf: Saving pre-created shape for speed (0.5ms saved) by using hardcode from .to_binary.unpack("C*")
-        blueprint_data = [240, 3, 255, 227, 255, 249, 127, 255, 255, 255, 255, 243, 255, 252, 255, 255, 255, 239, 255, 249, 127, 252, 15, 252, 0].pack("C*")
-        blueprint = ::Numo::Bit.from_binary(blueprint_data, [radius_tile * 2, radius_tile * 2])
-
+        blueprint_data = [0, 0, 254, 193, 255, 248, 127, 254, 159, 255, 231, 243, 249, 124, 254, 159, 255, 231, 255, 241, 63, 248, 7, 0, 0].pack("C*")
+        blueprint_pylon = ::Numo::Bit.from_binary(blueprint_data, [14, 14])
+
+        # Warp Prism
+        # 00011000
+        # 01111110
+        # 01111110
+        # 11111111
+        # 11111111
+        # 01111110
+        # 01111110
+        # 00011000
+        blueprint_data = [24, 126, 126, 255, 255, 126, 126, 24].pack("C*")
+        blueprint_prism = ::Numo::Bit.from_binary(blueprint_data, [8, 8])
+
+        # Print each power-source on map using shape above
         bot.power_sources.each do |ps|
+          radius_tile = ps.radius.ceil
+          # Select blueprint for 7-tile radius (Pylon) or 4-tile radius (Prism)
+          blueprint = if radius_tile == 4
+            blueprint_prism
+          else
+            blueprint_pylon
+          end
+
           x_tile = ps.pos.x.floor
           y_tile = ps.pos.y.floor
           replace_start_x = (x_tile - radius_tile)
@@ -424,7 +429,7 @@ module Sc2
       # This differs from position of first base structure
       # @return [Api::Point2D]
       def start_position
-        @start_position ||= bot.observation.raw_data.player.camera
+        @start_position ||= bot.observation.raw_data.player.camera.to_p2d
       end
 
       # Returns the enemy 2d start position
@@ -751,7 +756,7 @@ module Sc2
           )
         end
         nearest = @_build_coordinate_tree[cache_key].nearestk(target.x, target.y, random)
-        return nil if nearest.nil?
+        return nil if nearest.nil? || nearest.empty?
 
         coordinates[nearest.sample].to_p2d
       end

data/lib/sc2ai/player/previous_state.rb

@@ -16,6 +16,7 @@ module Sc2
         @all_units = bot.all_units
         @units = bot.units
         @structures = bot.structures
+        @placeholders = bot.placeholders
         @neutral = bot.neutral
         @effects = bot.effects
         @power_sources = bot.power_sources

data/lib/sc2ai/player/units.rb

@@ -15,9 +15,14 @@ module Sc2
 
       # A full list of all your structures (non-units)
       # @!attribute units
-      #   @return [Sc2::UnitGroup] a group of units
+      #   @return [Sc2::UnitGroup] a group of structures
       attr_accessor :structures
 
+      # A list of structures which haven't started
+      # @!attribute units
+      #   @return [Sc2::UnitGroup] a group of placeholder structures
+      attr_accessor :placeholders
+
       # All units with alliance :Neutral
       # @!attribute neutral
       #   @return [Sc2::UnitGroup] a group of neutral units
@@ -125,13 +130,14 @@ module Sc2
 
       # An array of Sensor tower rings as per minimap. It has a `pos` and a `radius`
       # @!attribute power_sources
-      #   @return [Array<Api::RadarRing>] an array of power sources
+      #   @return [Array<Api::RadarRing>] an array of radar rings sources
       attr_accessor :radar_rings # not a unit but has a tag
 
       # @private
       # @!attribute all_seen_unit_tags
       # Privately keep track of all seen Unit tags (excl structures) in order to detect new created units
       attr_accessor :_all_seen_unit_tags
+      private :_all_seen_unit_tags
 
       # Event-driven unit groups ---
 
@@ -288,6 +294,17 @@ module Sc2
         true
       end
 
+      # Micro/Unit-Specific ------
+
+      # Returns whether Query Available Ability is true for unit and tag
+      # Queries API if necessary. Uses batching in the background.
+      # @param [Integer] unit_tag
+      # @param [Integer] ability_id
+      # @return [Boolean]
+      def unit_ability_available?(unit_tag:, ability_id:)
+        !!available_abilities[unit_tag]&.include?(ability_id)
+      end
+
       private
 
       # @private
@@ -299,8 +316,10 @@ module Sc2
         # Clear previous units and prep for categorization
         @units = UnitGroup.new
         @structures = UnitGroup.new
+        @placeholders = UnitGroup.new
         @enemy.units = UnitGroup.new
         @enemy.structures = UnitGroup.new
+        @enemy.all_units = UnitGroup.new
         @neutral = UnitGroup.new
         @effects = observation.raw_data.effects # not a unit
         @power_sources = observation.raw_data.player.power_sources # not a unit
@@ -335,6 +354,8 @@ module Sc2
           # Categorize own units/structures, enemy units/structures, neutral
           if unit.is_blip
             @blips[tag] = unit
+          elsif unit.display_type == :Placeholder
+            @placeholders[tag] = unit
           elsif unit.alliance == own_alliance || unit.alliance == enemy_alliance
             if unit.alliance == own_alliance
               structure_collection = @structures
@@ -342,6 +363,7 @@ module Sc2
             else
               structure_collection = @enemy.structures
               unit_collection = @enemy.units
+              @enemy.all_units[tag] = unit
             end
 
             unit_data = unit_data(unit.unit_type)
@@ -355,7 +377,7 @@ module Sc2
           end
 
           # Dont parse callbacks on first loop or for neutral units
-          if !game_loop.zero? &&
+          if !@previous.all_units.nil? &&
               unit.alliance != :Neutral &&
               unit.display_type != :Placeholder &&
               unit.is_blip == false

data/lib/sc2ai/player.rb

@@ -233,7 +233,7 @@ module Sc2
           perform_actions
           perform_debug_commands # TODO: Detect IS_LADDER? -> unless IS_LADDER?
           step_forward
-          print "\e[2K#{@step_count} Steps Took (ms): #{(::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - r) * 1000}\n\e[1A\r"
+          print "\e[2K#{game_loop - @previous.game_loop} Steps Took (ms): #{(::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - r) * 1000}\n\e[1A\r"
           return @result unless @result.nil?
           break if @status != :in_game
         end
@@ -549,7 +549,7 @@ module Sc2
       # Having loaded all the necessities for the current state...
       # If we're on the first frame of the game, say previous state and current are the same
       # This is better than having a bunch of random zero and nil values
-      @previous.reset(self) if game_loop.zero?
+      @previous.reset(self) if @previous.all_units.nil?
 
       # TODO: remove @events attributes if we don't use them for performance gains
       # Actions performed and errors (only if implemented)
@@ -586,7 +586,7 @@ module Sc2
       self.game_info = @api.game_info
     end
 
-    # Data Parsing -----------------------
+    # Enemy -----------------------
 
     # If you're random, best to set #race to match after launched
     def set_race_for_random

data/lib/sc2ai/protocol/_meta_documentation.rb

@@ -23,8 +23,26 @@
 #     class Unit < Google::Protobuf::AbstractMessage; end;
 #     # Protobuf virtual class.
 #     class UnitTypeData < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class AvailableAbility < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class UnitOrder < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class ActionRawUnitCommand < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class ActionRawToggleAutocast < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class ActionError < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class ActionSpatialUnitCommand < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class BuildItem < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class ActionToggleAutocast < Google::Protobuf::AbstractMessage; end;
 #   end
 
+
+
 # Protobuf enums ---
 # Protobuf classes
 # @!parse

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

@@ -12,7 +12,7 @@ module Api
 
     # Create a new 3d Point, by adding a y axis.
     # @return [Api::Point]
-    def to_3d(z:)
+    def to_3d(z: 0)
       Api::Point[x, y, z]
     end
 

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

@@ -0,0 +1,11 @@
+# This class was partially generated with the help of AI.
+
+module Api
+  # Adds additional functionality to message object Api::Unit
+  module PointDistanceExtension
+  end
+end
+Api::Point.include Api::PointDistanceExtension
+Api::Point2D.include Api::PointDistanceExtension
+Api::PointI.include Api::PointDistanceExtension
+Api::Size2DI.include Api::PointDistanceExtension

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

@@ -84,7 +84,6 @@ module Sc2
       # raise NoMethodError unless location == self
 
       # Perf: Memoizing attributes which are hit hard, show gain
-
       @y ||= send(:method_missing, :y)
     end
 
@@ -97,9 +96,9 @@ module Sc2
 
     # Randomly adjusts both x and y by a range of: -offset..offset
     # @param offset [Float]
-    # @return [Api::Point2D]
+    # @return [Sc2::Position] new Position
     def random_offset(offset)
-      Api::Point2D.new[x, y].random_offset!(offset)
+      dup.random_offset!(offset)
     end
 
     # Changes this point's x and y by the supplied offset
@@ -112,17 +111,16 @@ module Sc2
     end
 
     # Creates a new point with x and y which is offset
-    # @return [Api::Point2D] self
-    def offset(x, y)
-      Api::Point2D.new[x, y].offset!(x, y)
-      self
+    # @return [Sc2::Position] new Position
+    def offset(x = 0, y = 0)
+      dup.offset!(x, y)
     end
 
     # Changes this point's x and y by the supplied offset
     # @return [Sc2::Position] self
-    def offset!(x, y)
-      self.x -= x
-      self.y -= y
+    def offset!(x = 0, y = 0)
+      self.x += x
+      self.y += y
       self
     end