sc2ai 0.0.5 → 0.0.7

data/lib/sc2ai/player/geometry.rb

@@ -20,7 +20,7 @@ module Sc2
       # @return [Integer]
       def map_width
         # bot.bot.game_info
-        bot.game_info.start_raw.map_size.x
+        @map_width ||= bot.game_info.start_raw.map_size.x
       end
 
       # Gets the map tile height. Range is 1-255.
@@ -28,7 +28,13 @@ module Sc2
       # @return [Integer]
       def map_height
         # bot.bot.game_info
-        bot.game_info.start_raw.map_size.y
+        @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
@@ -83,6 +89,15 @@ module Sc2
         @parsed_placement_grid
       end
 
+      # Whether this tile is where an expansion is supposed to be placed.
+      # To see if a unit/structure is blocking an expansion, pass their coordinates to this method.
+      # @param x [Float, Integer]
+      # @param y [Float, Integer]
+      # @return [Boolean] true if location has creep on it
+      def expo_placement?(x:, y:)
+        expo_placement_grid[y.to_i, x.to_i] == 1
+      end
+
       # Returns a grid where ony the expo locations are marked
       # @return [Numo::Bit]
       def expo_placement_grid
@@ -91,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
@@ -112,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
@@ -153,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)
@@ -260,6 +274,7 @@ module Sc2
       end
 
       # Returns the terrain height (z) at position x and y for a point
+      # @param position [Sc2::Position]
       # @return [Float] z axis position between -16 and 16
       def terrain_height_for_pos(position)
         terrain_height(x: position.x, y: position.y)
@@ -340,15 +355,17 @@ module Sc2
       end
 
       # Provides parsed minimap representation of creep spread
+      # Caches for 4 frames
       # @return [Numo::Bit] Numo array
       def parsed_creep
-        if @parsed_creep.nil?
+        if @parsed_creep.nil? || @parsed_creep[1] + 4 < bot.game_loop
           image_data = bot.observation.raw_data.map_state.creep
           # Fix endian for Numo bit parser
           data = image_data.data.unpack("b*").pack("B*")
-          @parsed_creep = ::Numo::Bit.from_binary(data, [image_data.size.y, image_data.size.x])
+          result = ::Numo::Bit.from_binary(data, [image_data.size.y, image_data.size.x])
+          @parsed_creep = [result, bot.game_loop]
         end
-        @parsed_creep
+        @parsed_creep[0]
       end
 
       # TODO: Removing. Better name or more features for this? Maybe check nearest units.
@@ -412,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
@@ -543,16 +560,75 @@ module Sc2
       # @param base [Api::Unit, Sc2::Position] base Unit or Position
       # @return [Sc2::UnitGroup] UnitGroup of minerals for the base
       def minerals_for_base(base)
-        # resources_for_base contains what we need, but slice neutral.minerals,
-        # so that only active patches remain
-        bot.neutral.minerals.slice(*resources_for_base(base).minerals.tags)
+        base_resources = resources_for_base(base)
+        cached_tags = base_resources.minerals.tags
+        observed_tags = bot.neutral.minerals.tags
+
+        # BACK-STORY: Mineral id's are fixed when in vision.
+        # Snapshots get random id's every time an object leaves vision.
+        # At game launch when we calculate and save minerals, which are mostly snapshot.
+
+        # Currently, we might have moved vision over minerals, so that their id's have changed.
+        # The alive object share a Position with our cached one, so we can get the correct id and update our cache.
+
+        # PERF: Fix takes 0.70ms, cache takes 0.10ms - we mostly call cached. This is the way.
+        # PERF: In contrast, repeated calls to neutral.minerals.units_in_circle? always costs 0.22ms
+
+        missing_tags = cached_tags - observed_tags
+        unless missing_tags.empty?
+          other_alive_minerals = bot.neutral.minerals.slice(*(observed_tags - cached_tags))
+          # For each missing calculated mineral patch...
+          missing_tags.each do |tag|
+            missing_resource = base_resources.delete(tag)
+
+            # Find an alive mineral at that position
+            new_resource = other_alive_minerals.find { |live_mineral| live_mineral.pos == missing_resource.pos }
+            base_resources.add(new_resource) unless new_resource.nil?
+          end
+        end
+
+        base_resources.minerals
       end
 
       # Gets geysers for a base or base position
       # @param base [Api::Unit, Sc2::Position] base Unit or Position
       # @return [Sc2::UnitGroup] UnitGroup of geysers for the base
       def geysers_for_base(base)
-        resources_for_base(base).geysers
+        # @see #minerals_for_base for backstory on these fixes
+        base_resources = resources_for_base(base)
+        cached_tags = base_resources.geysers.tags
+        observed_tags = bot.neutral.geysers.tags
+
+        missing_tags = cached_tags - observed_tags
+        unless missing_tags.empty?
+          other_alive_geysers = bot.neutral.geysers.slice(*(observed_tags - cached_tags))
+          # For each missing calculated geyser patch...
+          missing_tags.each do |tag|
+            missing_resource = base_resources.delete(tag)
+
+            # Find an alive geyser at that position
+            new_resource = other_alive_geysers.find { |live_geyser| live_geyser.pos == missing_resource.pos }
+            base_resources.add(new_resource) unless new_resource.nil?
+          end
+        end
+
+        base_resources.geysers
+      end
+
+      # Gets geysers which have not been taken for a base or base position
+      # @param base [Api::Unit, Sc2::Position] base Unit or Position
+      # @return [Sc2::UnitGroup] UnitGroup of geysers for the base
+      def geysers_open_for_base(base)
+        geysers = geysers_for_base(base)
+
+        # Mineral-only base, return nothing
+        return UnitGroup.new if geysers.size == 0
+
+        # Reject all which have a gas structure on-top
+        gas_positions = bot.structures.gas.map { |gas| gas.pos }
+        geysers.reject do |geyser|
+          gas_positions.include?(geyser.pos)
+        end
       end
 
       # @private
@@ -560,6 +636,7 @@ module Sc2
       # @return [Sc2::UnitGroup] UnitGroup of resources (minerals+geysers)
       private def resources_for_base(base)
         pos = base.is_a?(Api::Unit) ? base.pos : base
+        pos = pos.to_p2d if base.is_a?(Api::Point)
 
         # If we have a base setup for this exact position, use it
         if expansions.has_key?(pos)
@@ -599,12 +676,17 @@ module Sc2
       def build_coordinates(length:, on_creep: false, in_power: false)
         length = 1 if length < 1
         @_build_coordinates ||= {}
-        cache_key = [length, on_creep].hash
+        cache_key = [length, on_creep, in_power].hash
         return @_build_coordinates[cache_key] if !@_build_coordinates[cache_key].nil? && !bot.game_info_stale?
 
         result = []
         input_grid = parsed_pathing_grid & parsed_placement_grid & ~expo_placement_grid
-        input_grid = parsed_creep & input_grid if on_creep
+        input_grid = if on_creep
+          parsed_creep & input_grid
+        else
+          ~parsed_creep & input_grid
+        end
+
         input_grid = parsed_power_grid & input_grid if in_power
 
         # Dimensions
@@ -657,23 +739,24 @@ module Sc2
       # @param length [Integer] length of the building, 2 for depot/pylon, 3 for rax/gate
       # @param target [Api::Unit, Sc2::Position] near where to find a placement
       # @param random [Integer] number of nearest points to randomly choose from. 1 for nearest point.
+      # @param in_power [Boolean] whether this must be on a power field
       # @return [Api::Point2D, nil] buildable location, nil if no buildable location found
-      def build_placement_near(length:, target:, random: 1)
+      def build_placement_near(length:, target:, random: 1, in_power: false)
         target = target.pos if target.is_a? Api::Unit
         random = 1 if random.to_i.negative?
         length = 1 if length < 1
         on_creep = bot.race == Api::Race::Zerg
 
-        coordinates = build_coordinates(length:, on_creep:)
+        coordinates = build_coordinates(length:, on_creep:, in_power:)
+        cache_key = coordinates.hash
         @_build_coordinate_tree ||= {}
-        cache_key = [length, on_creep].hash
         if @_build_coordinate_tree[cache_key].nil?
           @_build_coordinate_tree[cache_key] = Kdtree.new(
             coordinates.each_with_index.map { |coords, index| coords + [index] }
           )
         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
@@ -819,14 +902,14 @@ module Sc2
       # @example
       #   Randomly randomly adjust both x and y by a range of -3.5 or +3.5
       #   geo.point_random_near(point: structures.hq.first, offset: 3.5)
-      # @param pos [Sc2::Location]
+      # @param pos [Sc2::Position]
       # @param offset [Float]
       # @return [Api::Point2D]
       def point_random_near(pos:, offset: 1.0)
         pos.random_offset(offset)
       end
 
-      # @param pos [Sc2::Location]
+      # @param pos [Sc2::Position]
       # @param radius [Float]
       # @return [Api::Point2D]
       def point_random_on_circle(pos:, radius: 1.0)

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
@@ -24,7 +25,7 @@ module Sc2
         @status = bot.status
         @game_info = bot.game_info
         @observation = bot.observation
-
+        @game_loop = bot.observation.game_loop
         @spent_minerals = bot.spent_minerals
         @spent_vespene = bot.spent_vespene
         @spent_supply = bot.spent_supply

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
@@ -77,6 +82,47 @@ module Sc2
         false
       end
 
+      # For this unit type, tells you how many are in progress by checking orders for all it's sources.
+      # @return [Integer]
+      def units_in_progress(unit_type_id)
+        source_unit_types = Api::TechTree.unit_created_from(unit_type_id: unit_type_id)
+
+        # When building from LARVA, check the intermediate models
+        if source_unit_types.include?(Api::UnitTypeId::LARVA)
+          source_unit_types << Api::UnitTypeId::EGG
+        elsif source_unit_types.include?(Api::UnitTypeId::BANELING)
+          # For certain Zerg types, return the count of specific intermediate egg/cocoon
+          return units.select_type(Api::UnitTypeId::BANELINGCOCOON).size
+        elsif source_unit_types.include?(Api::UnitTypeId::RAVAGER)
+          return units.select_type(Api::UnitTypeId::RAVAGERCOCOON).size
+        elsif source_unit_types.include?(Api::UnitTypeId::OVERSEER)
+          return units.select_type(Api::UnitTypeId::OVERLORDCOCOON).size
+        elsif source_unit_types.include?(Api::UnitTypeId::LURKERMP)
+          return units.select_type(Api::UnitTypeId::LURKERMPEGG).size
+        elsif source_unit_types.include?(Api::UnitTypeId::BROODLORD)
+          return units.select_type(Api::UnitTypeId::BROODLORDCOCOON).size
+        end
+
+        unit_create_ability = Api::TechTree.unit_type_creation_ability_id(
+          source: source_unit_types.first,
+          target: unit_type_id
+        )
+
+        origin = if unit_data(source_unit_types.first).attributes.include?(:Structure)
+          structures
+        else
+          units
+        end
+        total_in_progress = origin.select_type(source_unit_types).sum do |source|
+          source.orders.count do |order|
+            true if order.ability_id == unit_create_ability
+          end
+        end
+        total_in_progress *= 2 if unit_type_id == Api::UnitTypeId::ZERGLING
+
+        total_in_progress
+      end
+
       # An array of Protoss power sources, which have a point, radius and unit tag
       # @!attribute power_sources
       #   @return [Array<Api::PowerSource>] an array of power sources
@@ -84,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 ---
 
@@ -247,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
@@ -258,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
@@ -294,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
@@ -301,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)
@@ -314,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

@@ -226,13 +226,14 @@ module Sc2
         # Callback for step 0
         on_step
 
+        puts ""
         # Step 1 to n
         loop do
           r = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
           perform_actions
           perform_debug_commands # TODO: Detect IS_LADDER? -> unless IS_LADDER?
           step_forward
-          puts (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - r) * 1000
+          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
@@ -525,6 +526,7 @@ module Sc2
       @previous.reset(self)
       # Reset
       self.observation = response_observation.observation
+      self.game_loop = observation.game_loop
       self.chats_received = response_observation.chat
       self.spent_minerals = 0
       self.spent_vespene = 0
@@ -547,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)
@@ -584,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/ability_remapable.rb

@@ -0,0 +1,22 @@
+module Api
+  # This module make sure that a read from method ability_id always returns the proper source id
+  module AbilityRemapable
+    # Ability Id. The generic id or "remapid".
+    # i.e. Api::AbilityId::ATTACK_BATTLECRUISER returns generic Api::AbilityId::ATTACK
+    # @return [Integer]
+    def ability_id
+      @ability_id ||= Api::AbilityId.generic_id(send(:method_missing, :ability_id))
+    end
+  end
+end
+
+# AbilityData should not include, since it holds exact info and contains the remap id as attr
+# Similarly Request* methods only do requests and ew supply correct id's.
+Api::AvailableAbility.include Api::AbilityRemapable
+Api::UnitOrder.include Api::AbilityRemapable
+Api::ActionRawUnitCommand.include Api::AbilityRemapable
+Api::ActionRawToggleAutocast.include Api::AbilityRemapable
+Api::ActionError.include Api::AbilityRemapable
+Api::ActionSpatialUnitCommand.include Api::AbilityRemapable
+Api::BuildItem.include Api::AbilityRemapable
+Api::ActionToggleAutocast.include Api::AbilityRemapable

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

@@ -3,7 +3,9 @@ module Api
   module PointExtension
     # @private
     def hash
-      [x, y, z].hash
+      # Only one plane is ever used. Ignore hashing on z
+      # [x, y, z].hash
+      [x, y].hash
     end
 
     def eql?(other)

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