sc2ai 0.6.2 → 0.7.0

data/lib/sc2ai/player/geo.rb

@@ -520,11 +520,11 @@ module Sc2
         point_search_offsets = (-7..7).to_a.product((-7..7).to_a)
         point_search_offsets.select! do |x, y|
           dist = Math.hypot(x, y)
-          dist > 4 && dist <= 8
+          dist > 4.0 && dist <= 8.0
         end
 
         # Split resources by Z axis
-        resources = bot.neutral.minerals.reject_type(Api::UnitTypeId::MINERALFIELD450) + bot.neutral.geysers
+        resources = bot.neutral.minerals - mineral_walls + bot.neutral.geysers
         resource_group_z = resources.group_by do |resource|
           resource.pos.z.round # 32 units of Y, most maps will have use 3. round to nearest.
         end
@@ -591,11 +591,86 @@ module Sc2
             # Choose best fitting point
             best_point = possible_points.keys[possible_points.values.find_index(possible_points.values.min)]
             @expansions[best_point.to_p2d] = UnitGroup.new(clustered_resources)
+
+            # Check if this might be a mirrored base.
+            best_mirror_point = nil
+            geysers = clustered_resources.select { |res| Sc2::UnitGroup::TYPE_GEYSER.include?(res.unit_type) }
+            if geysers.size == 2
+              if geysers[0].pos.y == geysers[1].pos.y || geysers[0].pos.x == geysers[1].pos.x
+                # Mirrored vertical, potentially
+                best_mirror_point = [
+                  best_point[0],
+                  best_point[1] - (best_point[1] - (geysers[0].pos.y + geysers[1].pos.y) / 2.0) * 2.0
+                ]
+                if best_mirror_point != best_point && possible_points.has_key?(best_mirror_point)
+                  @expansions[best_mirror_point.to_p2d] = UnitGroup.new(clustered_resources)
+                else
+                  # Wasn't mirrored the one way. How about the other?...
+                  # Mirrored horizontal, potentially
+                  best_mirror_point = [
+                    best_point[0] - (best_point[0] - (geysers[0].pos.x + geysers[1].pos.x) / 2.0) * 2.0,
+                    best_point[1]
+                  ]
+                  if best_mirror_point != best_point && possible_points.has_key?(best_mirror_point)
+                    @expansions[best_mirror_point.to_p2d] = UnitGroup.new(clustered_resources)
+                  end
+
+                end
+              end
+            end
           end
         end
         @expansions
       end
 
+      # @private
+      # Mineral walls. Defined once upon start of game, mostly based on layout.
+      # @return [Sc2::UnitGroup]
+      private def mineral_walls
+        return @mineral_walls unless @mineral_walls.nil?
+
+        # Find mineral walls.
+        @mineral_walls = []
+        minerals_by_pos = {}
+        bot.neutral.minerals.reject_type(Api::UnitTypeId::MINERALFIELD450)
+          .each do |mineral|
+          minerals_by_pos[mineral.pos.to_axy] = mineral
+        end
+        minerals_by_pos.each do |xy, mineral|
+          x, y = xy
+          # Test X
+          if (side1 = minerals_by_pos[[x - 2, y]]) && (side2 = minerals_by_pos[[x + 2, y]])
+            @mineral_walls << side1
+            @mineral_walls << mineral
+            @mineral_walls << side2
+          end
+
+          # # Test Y
+          if (side1 = minerals_by_pos[[x, y - 1]]) && (side2 = minerals_by_pos[[x, y + 1]])
+            @mineral_walls << side1
+            @mineral_walls << mineral
+            @mineral_walls << side2
+          end
+
+          # Test \
+          if (side1 = minerals_by_pos[[x - 2, y + 1]]) && (side2 = minerals_by_pos[[x + 2, y - 1]])
+            @mineral_walls << side1
+            @mineral_walls << mineral
+            @mineral_walls << side2
+          end
+
+          # Test /
+          if (side1 = minerals_by_pos[[x - 2, y - 1]]) && (side2 = minerals_by_pos[[x + 2, y + 1]])
+            @mineral_walls << side1
+            @mineral_walls << mineral
+            @mineral_walls << side2
+          end
+        end
+        @mineral_walls.uniq!
+
+        @mineral_walls = UnitGroup.new(@mineral_walls) + bot.neutral.minerals.select_type(Api::UnitTypeId::MINERALFIELD450)
+      end
+
       # Returns a list of 2d points for expansion build locations
       # Does not contain mineral info, but the value can be checked against geo.expansions
       #

data/lib/sc2ai/player/units.rb

@@ -304,6 +304,25 @@ module Sc2
         true
       end
 
+      # Checks whether you have met the tech requirements for building a specific unit type
+      # @param [Integer] unit_type_id
+      # @return [Boolean]
+      def tech_requirement_met?(unit_type_id)
+        created_from_unit_type = Api::TechTree.unit_created_from(unit_type_id: unit_type_id)
+        required_building = Api::TechTree.unit_type_creation_abilities(
+          source: created_from_unit_type.first,
+          target: unit_type_id
+        )[:required_building]
+
+        # Ensure we have required building, if there's such a requirement
+        if required_building
+          return false unless all_units.owned.select_type(required_building).completed.size > 0
+        end
+
+        # Ensure we have a completed source which it's created from
+        all_units.owned.select_type(created_from_unit_type).completed.size > 0
+      end
+
       # Micro/Unit-Specific ------
 
       # Returns whether Query Available Ability is true for unit and tag

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

@@ -58,75 +58,74 @@ module Api
     # @return [Boolean] whether unit has attribute
     # @example
     #   unit.has_attribute?(Api::Attribute::MECHANICAL)
-    #   unit.has_attribute?(:MECHANICAL)
     def has_attribute?(attribute)
       attributes.include? attribute
     end
 
     # Checks if unit is light
-    # @return [Boolean] whether unit has attribute :Light
+    # @return [Boolean] whether unit has attribute :LIGHT
     def is_light?
-      has_attribute?(:LIGHT)
+      has_attribute?(Api::Attribute::LIGHT)
     end
 
     # Checks if unit is armored
-    # @return [Boolean] whether unit has attribute :Armored
+    # @return [Boolean] whether unit has attribute :ARMORED
     def is_armored?
-      has_attribute?(:ARMORED)
+      has_attribute?(Api::Attribute::ARMORED)
     end
 
     # Checks if unit is biological
-    # @return [Boolean] whether unit has attribute :Biological
+    # @return [Boolean] whether unit has attribute :BIOLOGICAL
     def is_biological?
-      has_attribute?(:BIOLOGICAL)
+      has_attribute?(Api::Attribute::BIOLOGICAL)
     end
 
     # Checks if unit is mechanical
-    # @return [Boolean] whether unit has attribute :Mechanical
+    # @return [Boolean] whether unit has attribute :MECHANICAL
     def is_mechanical?
-      has_attribute?(:MECHANICAL)
+      has_attribute?(Api::Attribute::MECHANICAL)
     end
 
     # Checks if unit is robotic
-    # @return [Boolean] whether unit has attribute :Robotic
+    # @return [Boolean] whether unit has attribute :ROBOTIC
     def is_robotic?
-      has_attribute?(:ROBOTIC)
+      has_attribute?(Api::Attribute::ROBOTIC)
     end
 
     # Checks if unit is psionic
-    # @return [Boolean] whether unit has attribute :Psionic
+    # @return [Boolean] whether unit has attribute :PSIONIC
     def is_psionic?
-      has_attribute?(:PSIONIC)
+      has_attribute?(Api::Attribute::PSIONIC)
     end
 
     # Checks if unit is massive
-    # @return [Boolean] whether unit has attribute :Massive
+    # @return [Boolean] whether unit has attribute :MASSIVE
     def is_massive?
-      has_attribute?(:MASSIVE)
+      has_attribute?(Api::Attribute::MASSIVE)
     end
 
     # Checks if unit is structure
-    # @return [Boolean] whether unit has attribute :Structure
+    # @return [Boolean] whether unit has attribute :STRUCTURE
     def is_structure?
-      has_attribute?(:STRUCTURE)
+      has_attribute?(Api::Attribute::STRUCTURE)
     end
 
     # Checks if unit is hovering
-    # @return [Boolean] whether unit has attribute :Hover
+    # @return [Boolean] whether unit has attribute :HOVER
     def is_hover?
-      has_attribute?(:HOVER)
+      has_attribute?(Api::Attribute::HOVER)
     end
 
     # Checks if unit is heroic
-    # @return [Boolean] whether unit has attribute :Heroic
+    # @return [Boolean] whether unit has attribute :HEROIC
     def is_heroic?
-      has_attribute?(:HEROIC)
+      has_attribute?(Api::Attribute::HEROIC)
     end
 
     # Checks if unit is summoned
-    # @return [Boolean] whether unit has attribute :Summoned
+    # @return [Boolean] whether unit has attribute :SUMMONED
     def is_summoned?
-      has_attribute?(:SUMMONED)
+      has_attribute?(Api::Attribute::SUMMONED)
     end
 
     # @!group Virtual properties

data/lib/sc2ai/unit_group/filter_ext.rb

@@ -86,6 +86,17 @@ module Sc2
       Api::UnitTypeId::SPORECRAWLER
     ].freeze
 
+    # Protoss: An array of unit types warped from Warp Gate.
+    # @return [Array<Integer>]
+    TYPE_WARPGATE_UNIT = [
+      Api::UnitTypeId::ZEALOT,
+      Api::UnitTypeId::STALKER,
+      Api::UnitTypeId::HIGHTEMPLAR,
+      Api::UnitTypeId::DARKTEMPLAR,
+      Api::UnitTypeId::SENTRY,
+      Api::UnitTypeId::ADEPT
+    ].freeze
+
     # Returns a new UnitGroup containing all units matching unit type id(s)
     # Multiple values work as an "OR" filter
     # @example
@@ -172,7 +183,7 @@ module Sc2
     def select_attribute(attributes)
       cached("#{__method__}:#{attributes.hash}") do
         attributes = [attributes] unless attributes.is_a? Array
-        attributes = attributes.map { |a| a.is_a?(Symbol) ? a : Api::Attribute.lookup(a) }
+        attributes = attributes.map { |a| a.is_a?(Symbol) ? Api::Attribute.lookup(a) : a }
         select do |unit|
           attributes & unit.attributes == attributes
         end
@@ -192,7 +203,7 @@ module Sc2
     def reject_attribute(attributes)
       cached("#{__method__}:#{attributes.hash}") do
         attributes = [attributes] unless attributes.is_a? Array
-        attributes = attributes.map { |a| a.is_a?(Symbol) ? a : Api::Attribute.lookup(a) }
+        attributes = attributes.map { |a| a.is_a?(Symbol) ? Api::Attribute.lookup(a) : a }
         reject do |unit|
           unit.attributes & attributes == attributes
         end

data/lib/sc2ai/version.rb

@@ -1,5 +1,5 @@
 module Sc2
   # gem version
   # @return [String]
-  VERSION = "0.6.2"
+  VERSION = "0.7.0"
 end

data/lib/templates/new/run_example_match.rb.tt

@@ -10,5 +10,5 @@ Sc2::Match.new(
     $bot,
     Sc2::Player::Computer.new(race: Api::Race::RANDOM, difficulty: Api::Difficulty::VERY_EASY)
   ],
-  map: "ThunderbirdAIE" # Or any of the downloaded map names
+  map: "PylonAIE" # Or any of the downloaded map names
 ).run