sc2ai 0.2.0 → 0.4.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,10 +2,12 @@ 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
@@ -15,6 +17,7 @@ module Api
     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]
@@ -25,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
@@ -111,12 +80,16 @@ module Sc2
     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
@@ -55,8 +39,8 @@ module Api
       new_unit = @bot.all_units[tag]
       return false if new_unit.nil? || new_unit == self
 
-      self.class.descriptor.entries.each do |entry|
-        send(:"#{entry.name}=", new_unit.send(:method_missing, entry.name.to_sym))
+      method(:initialize).parameters.each do |_, entry|
+        send(:"#{entry.name}=", new_unit.send(entry))
       end
 
       true
@@ -73,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
@@ -82,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
@@ -457,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)
@@ -473,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)