sc2ai 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d5fa6b7fff442809e2ec57d6be947f77411cfd2885a984806d05a7cd086aa78
-  data.tar.gz: 2c154a7a33c3c0fe9409f122e4d938f9f0c6184cd46fd119662084ff23852c17
+  metadata.gz: 862f9bd2e2dac28e0ffdb6eba214d106598dea2906e315747617c02cb3fa5943
+  data.tar.gz: b86e9e3447dd98b8b2ba41fbdbc400d64d1f26f20a7ee6b6abe01807610c67ce
 SHA512:
-  metadata.gz: 99941030dbe574eea5f1f022d91ce688a9cbf0ea7480f0c228f38f882deee486379377fbc2e173845e2201bc738640b5516e951e868c63d5387c82fe260e87c4
-  data.tar.gz: 851c9f29edbc84cf6081b59d0808ec1ee132f407c8d663b17ea376e4308db0cf8dbc40b122052f2aa3cd7011bb6a3a226ba5ae656180f1cb8a764349020fca83
+  metadata.gz: 5b2d60204bd3d066d76e91db725e182ec2a0c21700c5f1eae5b8818ae8fc3294ad6805e264535a6429054aad7e938dec72763a1e680503334ddcbe5b047c549a
+  data.tar.gz: adc9fadf404d42070faaf3d28d7c90b27487f290bd0d17a60e1ea6390662566707511fc2b9ff5f7836bc3950422e01095e03b7168f23f41794449841088796eb

data/lib/docker_build/Dockerfile.ruby

@@ -4,7 +4,7 @@ LABEL service="bot-ruby-local"
 USER root
 WORKDIR /root/ruby-builder
 
-ARG RUBY_VERSION=3.3.0
+ARG RUBY_VERSION=3.3.1
 ARG DEBIAN_DISABLE_RUBYGEMS_INTEGRATION=true
 
 # Deps - Ruby build

data/lib/sc2ai/api/data.rb

@@ -148,9 +148,6 @@ module Sc2
           unit_data.vespene_cost = 75
         when Api::UnitTypeId::OVERSEER
           unit_data.mineral_cost = 50
-        when Api::UnitTypeId::QUEENMP
-          unit_data.mineral_cost = 150
-          unit_data.food_required = 2
         when Api::UnitTypeId::RAVAGER
           unit_data.mineral_cost = 25
           unit_data.vespene_cost = 75

data/lib/sc2ai/connection/requests.rb

@@ -301,21 +301,21 @@ module Sc2
       end
 
       # Queries one or more pathing queries
-      # @param queries [Array<Api::RequestQueryPathing>, Api::RequestQueryPathing] one or more pathing queries
-      # @return [Array<Api::ResponseQueryPathing>, Api::ResponseQueryPathing] one or more results depending on input size
+      # @param queries [Array<Api::RequestQueryPathing>] one or more pathing queries
+      # @return [Array<Api::ResponseQueryPathing>] one or more results depending on input size
       def query_pathings(queries)
         arr_queries = queries.is_a?(Array) ? queries : [queries]
 
         response = send_request_for query: Api::RequestQuery.new(
           pathing: arr_queries
         )
-        (arr_queries.size > 1) ? response.pathing : response.pathing.first
+        response.pathing
       end
 
       # Queries one or more ability-available checks
-      # @param queries [Array<Api::RequestQueryAvailableAbilities>, Api::RequestQueryAvailableAbilities] one or more pathing queries
+      # @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>, Api::ResponseQueryAvailableAbilities] one or more results depending on input size
+      # @return [Array<Api::ResponseQueryAvailableAbilities>] one or more results depending on input size
       def query_abilities(queries, ignore_resource_requirements: true)
         arr_queries = queries.is_a?(Array) ? queries : [queries]
 
@@ -323,13 +323,13 @@ module Sc2
           abilities: arr_queries,
           ignore_resource_requirements:
         )
-        (arr_queries.size > 1) ? response.abilities : response.abilities.first
+        response.abilities
       end
 
       # Queries available abilities for units
-      # @param unit_tags [Array<Integer>, Integer] an array of unit tags or a single tag
+      # @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>, Api::ResponseQueryAvailableAbilities] one or more results depending on input size
+      # @return [Array<Api::ResponseQueryAvailableAbilities>] one or more results depending on input size
       def query_abilities_for_unit_tags(unit_tags, ignore_resource_requirements: true)
         queries = []
         unit_tags = [unit_tags] unless unit_tags.is_a? Array
@@ -340,15 +340,30 @@ module Sc2
         query_abilities(queries, ignore_resource_requirements:)
       end
 
+      # Queries available ability ids for one unit
+      # Shortened response over #query_abilities_for_unit_tags, since we know the tag already
+      # 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)
+        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
+        end
+      end
+
       # Queries one or more pathing queries
-      # @param queries [Array<Api::RequestQueryBuildingPlacement>, Api::RequestQueryBuildingPlacement] one or more placement queries
-      # @return [Array<Api::ResponseQueryBuildingPlacement>, Api::ResponseQueryBuildingPlacement] one or more results depending on input size
+      # @param queries [Array<Api::RequestQueryBuildingPlacement>] one or more placement queries
+      # @return [Array<Api::ResponseQueryBuildingPlacement>] one or more results depending on input size
       def query_placements(queries)
         arr_queries = queries.is_a?(Array) ? queries : [queries]
 
         response = query(placements: arr_queries)
 
-        (arr_queries.size > 1) ? response.placements : response.placements.first
+        response.placements
       end
 
       # Generates a replay.

data/lib/sc2ai/player/game_state.rb

@@ -16,9 +16,12 @@ module Sc2
 
       extend Forwardable
 
-      # @!attribute game_loop
-      #   @return [Integer] current game loop
-      def_delegators :observation, :game_loop
+      attr_writer :game_loop
+
+      # @return [Integer] current game loop
+      def game_loop
+        @game_loop || 0
+      end
 
       # @!attribute game_info [rw]
       # Access useful game information. Used in parsed pathing grid, terrain height, placement grid.
@@ -38,7 +41,7 @@ module Sc2
       attr_accessor :game_info_loop
 
       # Determines if your game_info will be refreshed at this moment
-      # Has a hard-capped refresh of only ever 2 steps
+      # Has a hard-capped refresh of only ever 4 steps
       # In general game_info is only refreshed Player::Bot reads from pathing_grid or placement_grid
       # @return [Boolean]
       def game_info_stale?
@@ -47,7 +50,7 @@ module Sc2
 
         # Note: No minimum step count set anymore
         # We can do something like, only updating every 2+ frames:
-        game_info_loop + 2 <= game_loop
+        game_info_loop + 4 <= game_loop
       end
 
       # @!attribute data

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,7 @@ 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
 
       # Returns zero to map_width as range
@@ -83,6 +83,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
@@ -260,6 +269,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 +350,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.
@@ -543,16 +555,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 +631,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 +671,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,16 +734,17 @@ 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] }
@@ -819,14 +897,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

@@ -24,7 +24,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

@@ -77,6 +77,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

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#{@step_count} 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

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/position.rb

@@ -1,12 +1,23 @@
 module Sc2
   # A unified construct that tames Api::* messages which contain location data
-  # Items which are of type Sc2::Location will have #x and #y property at the least.
+  # Items which are of type Sc2::Position will have #x and #y property at the least.
   module Position
     # Tolerance for floating-point comparisons.
     TOLERANCE = 1e-9
 
     # Basic operations
 
+    # Loose equality matches on floats x and y.
+    # We never check z-axis, because the map is single-level.
+    # TODO: We should almost certainly introduce TOLERANCE here, but verify it's cost first.
+    def ==(other)
+      if other.is_a? Position
+        x == other.x && y == other.y
+      else
+        false
+      end
+    end
+
     # A new point representing the sum of this point and the other point.
     # @param other [Api::Point2D, Numeric] The other point/number to add.
     # @return [Api::Point2D]
@@ -50,12 +61,38 @@ module Sc2
     # @see #divide
     alias_method :/, :divide
 
-    # Bug: Psych implements method 'y' on Kernel, but protobuf uses method_missing to read AbstractMethod
-    # We send method missing ourselves when y to fix this chain.
+    # Returns x coordinate
+    # @return [Float]
+    def x
+      # Perf: Memoizing attributes which are hit hard, show gain
+      @x ||= send(:method_missing, :x)
+    end
+
+    # Sets x coordinate
+    # @return [Float]
+    def x=(x)
+      send(:method_missing, :x=, x)
+      @x = x
+    end
+
+    # Returns y coordinate
+    # @return [Float]
     def y
+      # Bug: Psych implements method 'y' on Kernel, but protobuf uses method_missing to read AbstractMethod
+      # We send method missing ourselves when y to fix this chain.
       # This is correct, but an unnecessary conditional:
       # raise NoMethodError unless location == self
-      send(:method_missing, :y)
+
+      # Perf: Memoizing attributes which are hit hard, show gain
+
+      @y ||= send(:method_missing, :y)
+    end
+
+    # Sets y coordinate
+    # @return [Float]
+    def y=(y)
+      send(:method_missing, :y=, y)
+      @y = y
     end
 
     # Randomly adjusts both x and y by a range of: -offset..offset

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

@@ -9,6 +9,22 @@ module Api
       tag || super
     end
 
+    # Returns an integer unique identifier
+    # If the unit goes out of vision and is snapshot-able, they get a random id
+    # - Such a unit gets the same unit tag when it re-enters vision
+    # @return [Integer]
+    def tag
+      # Perf: This speeds up hash and therefore common UnitGroup operations. Sometimes 3x!
+      @tag ||= send(:method_missing, :tag)
+    end
+
+    # Sets unit tag
+    # @return [Integer]
+    def tag=(tag)
+      send(:method_missing, :tag=, tag)
+      @tag = tag
+    end
+
     # Every unit gets access back to the bot to allow api access.
     # For your own units, this allows API access.
     # @return [Sc2::Player] player with active connection
@@ -161,6 +177,15 @@ module Api
 
     # @!endgroup Virtual properties
 
+    # Whether unit is effected by buff_id
+    # @example
+    #   unit.has_buff??(Api::BuffId::QUEENSPAWNLARVATIMER)
+    # @param [Integer] buff_id
+    # @return [Boolean]
+    def has_buff?(buff_id)
+      buff_ids.include?(buff_id)
+    end
+
     # @!group Actions
 
     # Performs action on this unit

data/lib/sc2ai/unit_group/filter_ext.rb

@@ -235,6 +235,11 @@ module Sc2
       select(&:is_completed?)
     end
 
+    # Selects only units which do not have orders
+    def idle
+      select { |unit| unit.orders.empty? }
+    end
+
     # NEUTRAL ------------------------------------------
 
     # Selects mineral fields
@@ -290,7 +295,13 @@ module Sc2
     # Selects overlords
     # @return [Sc2::UnitGroup]
     def overlords
-      select_type([Api::UnitTypeId::OVERLORD, Api::UnitTypeId::OVERLORDCOCOON])
+      select_type([Api::UnitTypeId::OVERLORD, Api::UnitTypeId::OVERLORDTRANSPORT, Api::UnitTypeId::TRANSPORTOVERLORDCOCOON])
+    end
+
+    # Selects overseers
+    # @return [Sc2::UnitGroup]
+    def overseers
+      select_type([Api::UnitTypeId::OVERLORDCOCOON, Api::UnitTypeId::OVERSEER, Api::UnitTypeId::OVERSEERSIEGEMODE])
     end
 
     # Selects creep tumors (all)

data/lib/sc2ai/unit_group/geo_ext.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "sc2ai/unit_group"
+
+module Sc2
+  # A set geometric/map/math methods for unit group
+  class UnitGroup
+    # Returns the center (average) position of all units or nil if the group is empty.
+    # Outliers effect this point
+    # @return [Api::Point2D, nil]
+    def pos_centroid
+      return nil if size == 0
+      size = @units.size
+      sum_x = 0.0
+      sum_y = 0.0
+      i = 0
+
+      while i < size
+        unit = at(i)
+        sum_x += unit.pos.x.to_f
+        sum_y += unit.pos.y.to_f
+        i += 1
+      end
+
+      Api::Point2D[sum_x / size.to_f, sum_y / size.to_f]
+    end
+  end
+end

data/lib/sc2ai/unit_group.rb

@@ -182,6 +182,8 @@ module Sc2
       UnitGroup.new(@units.reject { |tag, _unit| other_unit_group.units.has_key?(tag) })
     end
 
+    alias_method :-, :subtract
+
     # Merges unit_group with our units and returns a new unit group
     # @return [Sc2::UnitGroup] a new unit group with items merged
     def merge(unit_group)
@@ -295,3 +297,4 @@ end
 
 require_relative "unit_group/action_ext"
 require_relative "unit_group/filter_ext"
+require_relative "unit_group/geo_ext"

data/lib/sc2ai/version.rb

@@ -2,5 +2,5 @@
 
 module Sc2
   # gem version
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end