sc2ai 0.1.0 → 0.3.0

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

@@ -5,18 +5,18 @@ module Api
     # 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))
+      @_ability_id ||= Api::AbilityId.generic_id(@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
+Api::AvailableAbility.prepend Api::AbilityRemapable
+Api::UnitOrder.prepend Api::AbilityRemapable
+Api::ActionRawUnitCommand.prepend Api::AbilityRemapable
+Api::ActionRawToggleAutocast.prepend Api::AbilityRemapable
+Api::ActionError.prepend Api::AbilityRemapable
+Api::ActionSpatialUnitCommand.prepend Api::AbilityRemapable
+Api::BuildItem.prepend Api::AbilityRemapable
+Api::ActionToggleAutocast.prepend Api::AbilityRemapable

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

@@ -0,0 +1,60 @@
+module Api
+  # Adds additional functionality and fixes quirks with color specifically pertaining to debug commands
+  module ActionExtension
+    # Checks the action type and returns corresponding class
+    # @return [Class] class of type, i.e. Api::ActionRaw
+    def action_type
+      @action_type ||= if has_action_raw?
+        Api::ActionRaw
+      elsif has_action_chat?
+        Api::ActionChat
+      elsif has_action_feature_layer?
+        Api::ActionSpatial
+      elsif has_action_ui?
+        Api::ActionUI
+      end
+    end
+
+    # Finds unit tags for action, if applicable
+    # @return [Array<Integer>] an array of unit tags
+    def unit_tags
+      tags = []
+      if action_type == Api::ActionRaw
+        case action_raw.action
+        when :unit_command # ActionRawUnitCommand
+          tags = action_raw.unit_command.unit_tags
+        when :toggle_autocast # ActionRawToggleAutocast
+          tags = action_raw.toggle_autocast.unit_tags
+        end
+        # when Api::ActionSpatial
+        #   if action == :unit_command # ActionSpatialUnitCommand
+        #     # For spatial unit commands, one _could_ assume the errors came from
+        #     # the last selected allied units on the previous frame.
+        #     # Since we don't have bot access here, leaving this empty.
+        #     # tags = @bot.previous.all_units.owned.select(&:is_selected).tags
+        #   end
+      end
+
+      tags
+    end
+
+    # Finds ability_id for the action, if applicable
+    # @return [Integer, nil] Api::AbilityID::* or nil if n/a
+    def ability_id
+      if action_type == Api::ActionRaw
+        case action_raw.action
+        when :unit_command # ActionRawUnitCommand
+          return action_raw.unit_command.ability_id
+        when :toggle_autocast # ActionRawToggleAutocast
+          return action_raw.toggle_autocast.ability_id
+        end
+      elsif action_type == Api::ActionSpatial && action_ui.action == :unit_command  # ActionSpatialUnitCommand
+        return action_ui.unit_command.ability_id
+      end
+
+      nil
+    end
+  end
+end
+
+Api::Action.include Api::ActionExtension

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

@@ -2,15 +2,22 @@ module Api
   # Adds additional functionality to message object Api::Point2D
   module Point2DExtension
     # @private
+    # Hashes on x and y
     def hash
       [x, y].hash
     end
 
+    # @private
     def eql?(other)
       self.class == other.class && hash == other.hash
     end
 
+    # Returns self
+    # @return [self]
+    def to_p2d = self
+
     # Create a new 3d Point, by adding a y axis.
+    # @param z [Float, Integer]
     # @return [Api::Point]
     def to_3d(z: 0)
       Api::Point[x, y, z]
@@ -21,6 +28,8 @@ module Api
       # Shorthand for creating an instance for [x, y]
       # @example
       #   Api::Point2D[2,4] # Where x is 2.0 and y is 4.0
+      # @param x [Float, Integer]
+      # @param y [Float, Integer]
       # @return [Api::Point2D]
       def [](x, y)
         Api::Point2D.new(x: x, y: y)

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

@@ -10,6 +10,8 @@ module Sc2
     # 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.
+    # @param [Sc2::Position] other
+    # @return [Boolean]
     def ==(other)
       if other.is_a? Position
         x == other.x && y == other.y
@@ -61,39 +63,6 @@ module Sc2
     # @see #divide
     alias_method :/, :divide
 
-    # 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
-
-      # 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
     # @param offset [Float]
     # @return [Sc2::Position] new Position
@@ -105,18 +74,22 @@ module Sc2
     # @return [Sc2::Position] self
     def random_offset!(offset)
       offset = offset.to_f
-      range = rand(-offset..offset)
+      range = -offset..offset
       offset!(rand(range), rand(range))
       self
     end
 
     # Creates a new point with x and y which is offset
+    # @param x [Float, Integer]
+    # @param y [Float, Integer]
     # @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
+    # @param x [Float, Integer]
+    # @param y [Float, Integer]
     # @return [Sc2::Position] self
     def offset!(x = 0, y = 0)
       self.x += x
@@ -182,7 +155,7 @@ module Sc2
     end
 
     # The squared distance between this point and the other point.
-    # @param other [Point2D] The other point to calculate the squared distance to.
+    # @param other [Api::Point2D] The other point to calculate the squared distance to.
     # @return [Float]
     def distance_squared_to(other)
       if other.nil? || other == self
@@ -192,13 +165,15 @@ module Sc2
     end
 
     # Distance between this point and coordinate of x and y
+    # @param x [Float, Integer]
+    # @param y [Float, Integer]
     # @return [Float]
     def distance_to_coordinate(x:, y:)
       Math.hypot(self.x - x, self.y - y)
     end
 
     # The distance from this point to the circle.
-    # @param center [Point2D] The center of the circle.
+    # @param center [Api::Point2D] The center of the circle.
     # @param radius [Float] The radius of the circle.
     # @return [Float]
     def distance_to_circle(center, radius)

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

@@ -9,6 +9,9 @@ module Api
       # @example
       #   Api::Point[1,2,3] # Where x is 1.0, y is 2.0 and z is 3.0
       # @return [Api::Point]
+      # @param x [Float, Integer]
+      # @param y [Float, Integer]
+      # @param z [Float, Integer]
       def [](x, y, z)
         Api::Point.new(x: x, y: y, z: z)
       end

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

@@ -9,22 +9,6 @@ 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
@@ -42,6 +26,26 @@ module Api
       @bot.previous.all_units[tag]
     end
 
+    # Returns whether a unit is alive or not
+    # Useful for cached Unit objects to see if they are still relevant.
+    # @return [Boolean] alive
+    def is_alive?
+      !@bot.all_units[tag].nil?
+    end
+
+    # Replaces protobuf values with latest from game
+    # @return [Boolean] true if refreshed or false unchanged
+    def refresh!
+      new_unit = @bot.all_units[tag]
+      return false if new_unit.nil? || new_unit == self
+
+      method(:initialize).parameters.each do |_, entry|
+        send(:"#{entry.name}=", new_unit.send(entry))
+      end
+
+      true
+    end
+
     # Attributes ---
 
     # Returns static [Api::UnitTypeData] for a unit
@@ -53,8 +57,8 @@ module Api
     # Checks unit data for an attribute value
     # @return [Boolean] whether unit has attribute
     # @example
-    #   unit.has_attribute?(Api::Attribute::Mechanical)
-    #   unit.has_attribute?(:Mechanical)
+    #   unit.has_attribute?(Api::Attribute::MECHANICAL)
+    #   unit.has_attribute?(:MECHANICAL)
     def has_attribute?(attribute)
       attributes.include? attribute
     end
@@ -62,67 +66,67 @@ module Api
     # Checks if unit is light
     # @return [Boolean] whether unit has attribute :Light
     def is_light?
-      has_attribute?(:Light)
+      has_attribute?(:LIGHT)
     end
 
     # Checks if unit is armored
     # @return [Boolean] whether unit has attribute :Armored
     def is_armored?
-      has_attribute?(:Armored)
+      has_attribute?(:ARMORED)
     end
 
     # Checks if unit is biological
     # @return [Boolean] whether unit has attribute :Biological
     def is_biological?
-      has_attribute?(:Biological)
+      has_attribute?(:BIOLOGICAL)
     end
 
     # Checks if unit is mechanical
     # @return [Boolean] whether unit has attribute :Mechanical
     def is_mechanical?
-      has_attribute?(:Mechanical)
+      has_attribute?(:MECHANICAL)
     end
 
     # Checks if unit is robotic
     # @return [Boolean] whether unit has attribute :Robotic
     def is_robotic?
-      has_attribute?(:Robotic)
+      has_attribute?(:ROBOTIC)
     end
 
     # Checks if unit is psionic
     # @return [Boolean] whether unit has attribute :Psionic
     def is_psionic?
-      has_attribute?(:Psionic)
+      has_attribute?(:PSIONIC)
     end
 
     # Checks if unit is massive
     # @return [Boolean] whether unit has attribute :Massive
     def is_massive?
-      has_attribute?(:Massive)
+      has_attribute?(:MASSIVE)
     end
 
     # Checks if unit is structure
     # @return [Boolean] whether unit has attribute :Structure
     def is_structure?
-      has_attribute?(:Structure)
+      has_attribute?(:STRUCTURE)
     end
 
     # Checks if unit is hover
     # @return [Boolean] whether unit has attribute :Hover
     def is_hover?
-      has_attribute?(:Hover)
+      has_attribute?(:HOVER)
     end
 
     # Checks if unit is heroic
     # @return [Boolean] whether unit has attribute :Heroic
     def is_heroic?
-      has_attribute?(:Heroic)
+      has_attribute?(:HEROIC)
     end
 
     # Checks if unit is summoned
     # @return [Boolean] whether unit has attribute :Summoned
     def is_summoned?
-      has_attribute?(:Summoned)
+      has_attribute?(:SUMMONED)
     end
 
     # @!group Virtual properties
@@ -375,7 +379,13 @@ module Api
       )
     end
 
-    # Checks whether the unit has
+    # Checks whether a unit is gathering or returning gathered minerals/gas
+    # @return [Boolean] true if either gathering or returning, false otherwise
+    def is_harvesting?
+      is_performing_ability?([Api::AbilityId::HARVEST_GATHER, Api::AbilityId::HARVEST_RETURN])
+    end
+
+    # Checks whether a unit's first order for ability
     # @param ability_ids [Integer, Array<Integer>] accepts one or an array of Api::AbilityId
     def is_performing_ability?(ability_ids)
       return false if orders.empty?
@@ -431,15 +441,15 @@ module Api
     end
 
     # Checks whether a weapon can target a unit
-    # @param unit [Api::unit]
+    # @param unit [Api::Unit]
     # @param weapon [Api::Weapon]
     # @return [Boolean]
     def can_weapon_target_unit?(unit:, weapon:)
       # false if enemy is air and we can only shoot ground
-      return false if unit.is_flying && weapon.type == :Ground # Api::Weapon::TargetType::Ground
+      return false if unit.is_flying && weapon.type == :GROUND # Api::Weapon::TargetType::GROUND
 
       # false if enemy is ground and we can only shoot air
-      return false if unit.is_ground? && weapon.type == :Air # A pi::Weapon::TargetType::Air
+      return false if unit.is_ground? && weapon.type == :AIR # Api::Weapon::TargetType::AIR
 
       # Check if weapon and unit models are in range
       in_attack_range?(unit:, range: weapon.range)
@@ -447,7 +457,7 @@ module Api
 
     def can_ability_target_unit?(unit:, ability:)
       # false if enemy is air and we can only shoot ground
-      return false if ability.target == Api::AbilityData::Target::None
+      return false if ability.target == Api::AbilityData::Target::NONE
 
       # Check if weapon and unit models are in range
       in_attack_range?(unit:, range: ability.cast_range)
@@ -538,7 +548,8 @@ module Api
       when Api::UnitTypeId::STARPORT, Api::UnitTypeId::STARPORTFLYING
         Api::UnitTypeId::STARPORTREACTOR
       end
-      build(unit_type_id: unit_type_id, queue_command:)
+
+      build(unit_type_id: unit_type_id, target: target_for_addon_placement, queue_command:)
     end
 
     # For Terran builds a tech lab add-on on the current structure
@@ -552,7 +563,21 @@ module Api
       when Api::UnitTypeId::STARPORT, Api::UnitTypeId::STARPORTFLYING
         Api::UnitTypeId::STARPORTTECHLAB
       end
-      build(unit_type_id: unit_type_id, queue_command:)
+      build(unit_type_id: unit_type_id, target: target_for_addon_placement, queue_command:)
+    end
+
+    private def target_for_addon_placement
+      # Attempts to auto-move left if not placeable
+      x = pos.x.floor
+      y = pos.y.floor
+      if !bot.geo.placeable?(x: x + 3, y: y - 1) ||
+          !bot.geo.placeable?(x: x + 3, y: y) ||
+          !bot.geo.placeable?(x: x + 2, y: y - 1) ||
+          !bot.geo.placeable?(x: x + 2, y: y)
+        return Api::Point2D[pos.x - 1, pos.y]
+      end
+
+      nil
     end
 
     # PROTOSS Convenience functions ---

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

@@ -15,6 +15,14 @@ module Api
     #   i.e. 250G Broodlord = 100G Corruptor + 150G Morph
     #   @return [Integer] sum of vespene gas costs
     attr_accessor :vespene_cost_sum
+
+    # @!attribute placement_length
+    #   Length of tiles to build.
+    #   i.e. 5 for any Base-type (5x5)
+    #   i.e. 3 for Barracks (3x3)
+    #   i.e. 2 for Supply Depot (2x2)
+    #   @return [Integer] side-length for placement
+    attr_accessor :placement_length
   end
 end
 Api::UnitTypeData.include Api::UnitTypeDataExtension