sc2ai 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4d88f09b0eaa016360346fe4b150664feb3072792ded12302267a2cf64d2854
-  data.tar.gz: 50f38a9008d26a62fbe9fae1f05076dee04544ea73b8e72e8f9447371501f54b
+  metadata.gz: fcc96e2f18e9cc95b0fd8b9427d3c76866551031b69811251b547eeb13284cba
+  data.tar.gz: 88c3dce17dba1e6b4378c306de8d754e1f33dcd092a9e44ac7477e50940ca911
 SHA512:
-  metadata.gz: e3f980a5519d31a49cb890cb529d213b34819dd3a4888301ea7dfde1b2edf9fda7685fb62d28c4187809b5b9a646e1bed2e4af6b86f037c5207c8d515306d88a
-  data.tar.gz: 579de21d38e0f596cdc7fc29a43d878caa4e72b4a9a995e22c26edc0b3bfda4c79b266703a8eaea0e60b513e88a6bcaa5de196d8e8d90e353344925666bb7ecb
+  metadata.gz: 39997d407d6fbf2ffc936c387f703d4b12d6aff1f016bc1905148a6590f156c4f39acee982074be28d33ea9451cbbf483f985c62a902693c65da450465d915e2
+  data.tar.gz: af9ed623bf2ee6ce905127fb89828a45c95456b4996e1aa4f6c3d477d31b383ed54d425de80abcd28f2df9cf08bfa127fbd36c89f822e226804b116bf20e73c1

data/lib/sc2ai/player/actions.rb

@@ -17,7 +17,7 @@ module Sc2
       # Queues a Api::ActionRaw. Perform ability on unit_tags optionally on target_world_space_pos/target_unit_tag
       # @param unit_tags [Array<Integer>]
       # @param ability_id [Integer]
-      # @param queue_command [Boolean] Shift+Click, default: false
+      # @param queue_command [Boolean] shift+command
       # @param target_world_space_pos [Api::Point2D]
       # @param target_unit_tag [Integer]
       def action_raw_unit_command(unit_tags:, ability_id:, queue_command: false, target_world_space_pos: nil, target_unit_tag: nil)
@@ -39,7 +39,7 @@ module Sc2
       # @param units [Array<Integer>,Integer,Api::Unit] can be an Api::Unit, array of Api::Unit#tag or single tag
       # @param ability_id [Integer]
       # @param target [Api::Unit, Integer, Api::Point2D] is a unit, unit tag or a Api::Point2D
-      # @param queue_command [Boolean] Shift+Click, default: false
+      # @param queue_command [Boolean] shift+command
       def action(units:, ability_id:, target: nil, queue_command: false)
         unit_tags = unit_tags_from_source(units)
 
@@ -79,6 +79,7 @@ module Sc2
       # Warps in unit type at target (location or pylon) with optional source units (warp gates)
       # When not specifying the specific warp gate(s), all warpgates will be used
       # @param unit_type_id [Integer] Api::UnitTypeId the unit type which will do the creation
+      # @param queue_command [Boolean] shift+command
       # @param target [Api::Point2D, Integer] is a unit tag or a Api::Point2D
       def warp(unit_type_id:, target:, queue_command:, units: nil)
         warp_ability = Api::TechTree.unit_type_creation_abilities(
@@ -128,7 +129,7 @@ module Sc2
       # @param ability_id [Api::AbilityId]
       # @param target_screen_coord [Api::Point2I]
       # @param target_minimap_coord [Api::Point2I]
-      # @param queue_command [Boolean] Shift+Click, default: false
+      # @param queue_command [Boolean] shift+command
       # @return [void]
       def action_spatial_unit_command(ability_id:, target_screen_coord: nil, target_minimap_coord: nil, queue_command: false)
         queue_action Api::Action.new(

data/lib/sc2ai/player/debug.rb

@@ -37,6 +37,52 @@ module Sc2
         )
       end
 
+      # Prints text on screen from top and left
+      # @param text [String] will respect newlines
+      # @param left_percent [Numeric] range 0..100. percent from left of screen
+      # @param top_percent [Numeric] range 0..100. percent from top of screen
+      # @param color [Api::Color] default white
+      # @param size [Size] of font, default 14px
+      # @return [void]
+      def debug_text_screen(text, left_percent: 1.0, top_percent: 1.0, color: nil, size: 14)
+        queue_debug_command Api::DebugCommand.new(
+          draw: Api::DebugDraw.new(
+            text: [
+              Api::DebugText.new(
+                text:,
+                virtual_pos: Api::Point.new(
+                  x: left_percent.to_f / 100,
+                  y: top_percent.to_f / 100
+                ),
+                color:,
+                size:
+              )
+            ]
+          )
+        )
+      end
+
+      # Prints text on screen at 3d world position
+      # @param text [String] will respect newlines
+      # @param point [Api::Point] point in the world, i.e. unit.pos
+      # @param color [Api::Color] default white
+      # @param size [Size] of font, default 14px
+      # @return [void]
+      def debug_text_world(text, point:, color: nil, size: 14)
+        queue_debug_command Api::DebugCommand.new(
+          draw: Api::DebugDraw.new(
+            text: [
+              Api::DebugText.new(
+                text:,
+                world_pos: point,
+                color:,
+                size:
+              )
+            ]
+          )
+        )
+      end
+
       # Draws a line between two Api::Point's for color
       # @param p0 [Api::Point] the first point
       # @param p1 [Api::Point] the second point
@@ -63,8 +109,8 @@ module Sc2
       #   # Draws a box on structure placement grid
       #   debug_draw_box(point: unit.pos, radius: unit.footprint_radius)
       #
-      # Note: Api::Color RGB is broken for this command. Will use min(r,b)
-      # Note: Z index is elevated 0.01 so the line is visible and doesn't clip through terrain
+      # @note Api::Color RGB is broken for this command. Will use min(r,b)
+      # @note Z index is elevated 0.02 so the line is visible and doesn't clip through terrain
       # @param point [Api::Point]
       # @param radius [Float] default one tile wide, 1.0
       # @param color [Api::Color] default white. min(r,b) is used for both r&b
@@ -74,8 +120,8 @@ module Sc2
           draw: Api::DebugDraw.new(
             boxes: [
               Api::DebugBox.new(
-                min: Api::Point.new(x: point.x - radius, y: point.y - radius, z: point.z + 0.01),
-                max: Api::Point.new(x: point.x + radius, y: point.y + radius, z: point.z + (radius * 2) + 0.01),
+                min: Api::Point.new(x: point.x - radius, y: point.y - radius, z: point.z + 0.02),
+                max: Api::Point.new(x: point.x + radius, y: point.y + radius, z: point.z + (radius * 2) + 0.02),
                 color:
               )
             ]

data/lib/sc2ai/player/geometry.rb

@@ -7,7 +7,7 @@ module Sc2
   class Player
     # Holds map and geography helper functions
     class Geometry
-      # @!attribute Holds the parent bot object
+      # @!attribute bot
       #   @return [Sc2::Player] player with active connection
       attr_accessor :bot
 
@@ -72,6 +72,7 @@ module Sc2
       # Each value in [row][column] holds a boolean value represented as an integer
       # It does not say whether a position is occupied by another building.
       # One pixel covers one whole block. Rounds fractionated positions down.
+      # @return [Numo::Bit]
       def parsed_placement_grid
         if @parsed_placement_grid.nil?
           image_data = bot.game_info.start_raw.placement_grid
@@ -83,6 +84,7 @@ module Sc2
       end
 
       # Returns a grid where ony the expo locations are marked
+      # @return [Numo::Bit]
       def expo_placement_grid
         if @expo_placement_grid.nil?
           @expo_placement_grid = Numo::Bit.zeros(map_height, map_width)
@@ -97,6 +99,7 @@ module Sc2
       end
 
       # Returns a grid where powered locations are marked true
+      # @return [Numo::Bit]
       def parsed_power_grid
         # Cache for based on power unit tags
         cache_key = bot.power_sources.map(&:tag).sort.hash
@@ -399,12 +402,25 @@ module Sc2
         output_grid
       end
 
+      # Returns own 2d start position as set by initial camera
+      # This differs from position of first base structure
+      # @return [Api::Point2D]
+      def start_position
+        @start_position ||= bot.observation.raw_data.player.camera
+      end
+
+      # Returns the enemy 2d start position
+      # @return [Api::Point2D]
+      def enemy_start_position
+        bot.game_info.start_raw.start_locations.first
+      end
+
       # Gets expos and surrounding minerals
       # The index is a build location for an expo and the value is a UnitGroup, which has minerals and geysers
       # @example
-      #   random_expo = expansions.keys.sample #=> Point2D
+      #   random_expo = geo.expansions.keys.sample #=> Point2D
       #   expo_resources = geo.expansions[random_expo] #=> UnitGroup
-      #   alive_minerals = expo_resources.minerals - neutral.minerals
+      #   alive_minerals = expo_resources.minerals & neutral.minerals
       #   geysers = expo_resources.geysers
       # @return [Hash<Api::Point2D, UnitGroup>] Location => UnitGroup of resources (minerals+geysers)
       def expansions
@@ -503,24 +519,77 @@ module Sc2
       end
 
       # Returns a slice of #expansions where a base hasn't been built yet
+      # The has index is a build position and the value is a UnitGroup of resources for the base
       # @example
       #   # Lets find the nearest unoccupied expo
       #   expo_pos = expansions_unoccupied.keys.min { |p2d| p2d.distance_to(structures.hq.first) }
       #   # What minerals/geysers does it have?
       #   puts expansions_unoccupied[expo_pos].minerals # or expansions[expo_pos]... => UnitGroup
       #   puts expansions_unoccupied[expo_pos].geysers # or expansions[expo_pos]... => UnitGroup
-      # @return [Hash<Api::Point2D], UnitGroup] Location => UnitGroup of resources (minerals+geysers)
+      # @return [Hash<Api::Point2D, UnitGroup>] Location => UnitGroup of resources (minerals+geysers)
       def expansions_unoccupied
         taken_bases = bot.structures.hq.map { |hq| hq.pos.to_p2d } + bot.enemy.structures.hq.map { |hq| hq.pos.to_p2d }
         remaining_points = expansion_points - taken_bases
         expansions.slice(*remaining_points)
       end
 
+      # Gets minerals for a base or base position
+      # @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)
+      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
+      end
+
+      # @private
+      # @param base [Api::Unit, Sc2::Position] base Unit or Position
+      # @return [Sc2::UnitGroup] UnitGroup of resources (minerals+geysers)
+      private def resources_for_base(base)
+        pos = base.is_a?(Api::Unit) ? base.pos : base
+
+        # If we have a base setup for this exact position, use it
+        if expansions.has_key?(pos)
+          return expansions[pos]
+        end
+
+        # Tolerance for misplaced base: Find the nearest base to this position
+        pos = expansion_points.min_by { |p| p.distance_to(pos) }
+
+        expansions[pos]
+      end
+
+      # Gets gasses 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 gas_for_base(base)
+        # No gas structures at all yet, return nothing
+        return UnitGroup.new if bot.structures.gas.size.zero?
+
+        geysers = geysers_for_base(base)
+
+        # Mineral-only base, return nothing
+        return UnitGroup.new if geysers.size == 0
+
+        # Loop and collect gasses places exactly on-top of geysers
+        bot.structures.gas.select do |gas|
+          geysers.any? { |geyser| geyser.pos.to_p2d.eql?(gas.pos.to_p2d) }
+        end
+      end
+
       # Gets buildable point grid for squares of size, i.e. 3 = 3x3 placements
       # Uses pathing grid internally, to ignore taken positions
       # Does not query the api and is generally fast.
       # @param length [Integer] length of the building, 2 for depot/pylon, 3 for rax/gate
-      # @param on_creep [Boolean] whether this build locatin should be on creep
+      # @param on_creep [Boolean] whether this build location should be on creep
+      # @return [Array<Array<(Float, Float)>>] Array of [x,y] tuples
       def build_coordinates(length:, on_creep: false, in_power: false)
         length = 1 if length < 1
         @_build_coordinates ||= {}

data/lib/sc2ai/player/units.rb

@@ -47,10 +47,10 @@ module Sc2
 
       # Event-driven unit groups ---
 
+      # @!attribute event_units_created
       # Units created since last frame (visible only, units not structures)
       # Read this on_step. Alternative to callback on_unit_created
-      # Note: Morphed units should watch #event_units_type_changed
-      # @!attribute event_units_created
+      # @note Morphed units should watch #event_units_type_changed
       #   @return [Sc2::UnitGroup] group of created units
       attr_accessor :event_units_created
 

data/lib/sc2ai/player.rb

@@ -97,7 +97,7 @@ module Sc2
       @difficulty = difficulty
       @ai_build = ai_build
       @realtime = false
-      @step_count = 1
+      @step_count = 2
 
       @enable_feature_layer = false
       @interface_options = {}
@@ -201,7 +201,7 @@ module Sc2
 
       # Override to customize initialization
       # Alias of before_join
-      # You can enable_feature_layer=true, set step_size, define
+      # You can enable_feature_layer=true, set step_count, define
       # @example
       #   def configure
       #     step_count = 4 # Update less frequently
@@ -490,6 +490,8 @@ module Sc2
     def started
       # Calculate expansions
       geo.expansions
+      # Set our start position base on camera
+      geo.start_position
     end
 
     # Moves emulation ahead and calls back #on_step
@@ -498,9 +500,7 @@ module Sc2
       # Sc2.logger.debug "#{self.class} step_forward"
 
       unless @realtime
-        # ##TODO: Numsteps as config
-        num_steps = 1
-        @api.step(num_steps)
+        @api.step(@step_count)
       end
 
       refresh_state
@@ -610,9 +610,9 @@ module Sc2
     # ##TODO: perfect loop implementation
     # observation has an optional param game_loop and will only return once that step is reached (blocking).
     # without it, it returns things as they are.
-    # broadly, i think this is what it should be doing, with step_size being minimum of 1, so no zero-steps occur.
+    # broadly, i think this is what it should be doing, with step_count being minimum of 1, so no zero-steps occur.
     # @example
-    # desired_game_loop = current_game_loop + step_size
+    # desired_game_loop = current_game_loop + step_count
     # response = client.observation(game_loop: desired_game_loop)
     #
     #   if response.game_loop > desired_game_loop {

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

@@ -1,6 +1,15 @@
 module Api
   # Adds additional functionality to message object Api::Point
   module PointExtension
+    # @private
+    def hash
+      [x, y, z].hash
+    end
+
+    def eql?(other)
+      self.class == other.class && hash == other.hash
+    end
+
     # Creates a Point2D using x and y
     # @return [Api::Point2D]
     def to_p2d
@@ -13,6 +22,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 [Float] x
+      # @param [Float] y
+      # @param [Float] z
       def [](x, y, z)
         Api::Point.new(x: x, y: y, z: z)
       end
@@ -20,4 +32,4 @@ module Api
   end
 end
 Api::Point.include Api::PointExtension
-Api::Point.include Api::PointExtension::ClassMethods
+Api::Point.extend Api::PointExtension::ClassMethods

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

@@ -179,6 +179,26 @@ module Api
       action(ability_id: Api::AbilityId::SMART, target:, queue_command:)
     end
 
+    # Shorthand for performing action MOVE
+    # @param target [Api::Unit, Integer, Api::Point2D] is a unit, unit tag or a Api::Point2D
+    # @param queue_command [Boolean] shift+command
+    def move(target:, queue_command: false)
+      action(ability_id: Api::AbilityId::MOVE, target:, queue_command:)
+    end
+
+    # Shorthand for performing action STOP
+    # @param queue_command [Boolean] shift+command
+    def stop(queue_command: false)
+      action(ability_id: Api::AbilityId::STOP, queue_command:)
+    end
+
+    # Shorthand for performing action HOLDPOSITION
+    # @param queue_command [Boolean] shift+command
+    def hold(queue_command: false)
+      action(ability_id: Api::AbilityId::HOLDPOSITION, queue_command:)
+    end
+    alias_method :hold_position, :hold
+
     # Shorthand for performing action ATTACK
     # @param target [Api::Unit, Integer, Api::Point2D] is a unit, unit tag or a Api::Point2D
     # @param queue_command [Boolean] shift+command
@@ -224,6 +244,7 @@ module Api
     # Draws a placement outline
     # @param color [Api::Color] optional api color, default white
     # @return [void]
+    # noinspection RubyArgCount
     def debug_draw_placement(color = nil)
       # Slightly elevate the Z position so that the line doesn't clip into the terrain at same Z level
       z_elevated = pos.z + 0.01
@@ -432,6 +453,12 @@ module Api
       build_progress == 1.0 # standard:disable Lint/FloatComparison
     end
 
+    # Returns true if build progress is < 100%
+    # @return [Boolean]
+    def in_progress?
+      !is_completed?
+    end
+
     # Convenience functions ---
 
     # TERRAN Convenience functions ---
@@ -444,7 +471,7 @@ module Api
 
     # Returns whether the structure has a reactor add-on
     # @return [Boolean] if the unit has a reactor attached
-    def has_reactor
+    def has_reactor?
       Sc2::UnitGroup::TYPE_REACTOR.include?(add_on&.unit_type)
     end
 
@@ -455,26 +482,46 @@ module Api
     #   # Get the actual tech-lab with #add_on
     #   sp.add_on.research ...
     # @return [Boolean] if the unit has a tech lab attached
-    def has_tech_lab
+    def has_tech_lab?
       Sc2::UnitGroup::TYPE_TECHLAB.include?(add_on&.unit_type)
     end
 
     # For Terran builds a tech lab add-on on the current structure
     # @return [void]
-    def build_reactor
-      build(unit_type_id: Api::UnitTypeId::REACTOR)
+    def build_reactor(queue_command: false)
+      unit_type_id = case unit_type
+      when Api::UnitTypeId::BARRACKS, Api::UnitTypeId::BARRACKSFLYING
+        Api::UnitTypeId::BARRACKSREACTOR
+      when Api::UnitTypeId::FACTORY, Api::UnitTypeId::FACTORYFLYING
+        Api::UnitTypeId::FACTORYREACTOR
+      when Api::UnitTypeId::STARPORT, Api::UnitTypeId::STARPORTFLYING
+        Api::UnitTypeId::STARPORTREACTOR
+      end
+      build(unit_type_id: unit_type_id, queue_command:)
     end
 
     # For Terran builds a tech lab add-on on the current structure
     # @return [void]
-    def build_tech_lab
-      build(unit_type_id: Api::UnitTypeId::TECHLAB)
+    def build_tech_lab(queue_command: false)
+      unit_type_id = case unit_type
+      when Api::UnitTypeId::BARRACKS, Api::UnitTypeId::BARRACKSFLYING
+        Api::UnitTypeId::BARRACKSTECHLAB
+      when Api::UnitTypeId::FACTORY, Api::UnitTypeId::FACTORYFLYING
+        Api::UnitTypeId::FACTORYTECHLAB
+      when Api::UnitTypeId::STARPORT, Api::UnitTypeId::STARPORTFLYING
+        Api::UnitTypeId::STARPORTTECHLAB
+      end
+      build(unit_type_id: unit_type_id, queue_command:)
     end
 
+    # GENERAL Convenience functions ---
+
+    # ...
+
     private
 
     # @private
-    # Reduces repitition in the is_*action*?(target:) methods
+    # Reduces repetition in the is_*action*?(target:) methods
     def is_performing_ability_on_target?(abilities, target: nil)
       # Exit if not actioning the ability
       return false unless is_performing_ability?(abilities)

data/lib/sc2ai/unit_group/action_ext.rb

@@ -46,7 +46,7 @@ module Sc2
     # @param queue_command [Boolean] shift+command
     def warp(unit_type_id:, target: nil, queue_command: false)
       return if size.zero?
-      bot&.warp(units: self, unit_type_id:, target: target, queue_command:)
+      bot&.warp(units: self, unit_type_id:, target:, queue_command:)
     end
 
     # Shorthand for performing action SMART (right-click)
@@ -56,11 +56,31 @@ module Sc2
       action(ability_id: Api::AbilityId::SMART, target:, queue_command:)
     end
 
+    # Shorthand for performing action MOVE
+    # @param target [Api::Unit, Integer, Api::Point2D] is a unit, unit tag or a Api::Point2D
+    # @param queue_command [Boolean] shift+command
+    def move(target:, queue_command: false)
+      action(ability_id: Api::AbilityId::MOVE, target:, queue_command:)
+    end
+
+    # Shorthand for performing action STOP
+    # @param queue_command [Boolean] shift+command
+    def stop(queue_command: false)
+      action(ability_id: Api::AbilityId::STOP, queue_command:)
+    end
+
+    # Shorthand for performing action HOLDPOSITION
+    # @param queue_command [Boolean] shift+command
+    def hold(queue_command: false)
+      action(ability_id: Api::AbilityId::HOLDPOSITION, queue_command:)
+    end
+    alias_method :hold_position, :hold
+
     # Shorthand for performing action ATTACK
     # @param target [Api::Unit, Integer, Api::Point2D] is a unit, unit tag or a Api::Point2D
     # @param queue_command [Boolean] shift+command
     def attack(target:, queue_command: false)
-      action(ability_id: Api::AbilityId::ATTACK, target: target, queue_command: queue_command)
+      action(ability_id: Api::AbilityId::ATTACK, target:, queue_command:)
     end
 
     # Issues repair command on target

data/lib/sc2ai/unit_group.rb

@@ -89,27 +89,32 @@ module Sc2
       @units[tags.at(index)]
     end
 
+    # Meta documentation methods
+    # @!method first
+    #   @return [Api::Unit]
+    # @!method last
+    #   @return [Api::Unit]
+
     # Calls the given block with each Api::Unit value
     # @example
-    #   unit_group.each {|unit| puts unit.tag } #=> 1234 ...
-    #
     #   unit_group.each do |unit|
     #      puts unit.tag #=> 1234 ...
     #   end
-    def each(&block)
-      @units.each_value(&block)
+    # @yieldparam unit [Api::Unit]
+    def each(&)
+      @units.each_value(&)
     end
 
     # Calls the given block with each key-value pair
     # @return [self] a new unit group with items merged
     # @example
-    #   unit_group.each {|tag, unit| puts "#{tag}: #{unit}"} #=> "12345: #<Api::Unit ...>"
-    #
-    #   unit_group.each do |tag, unit|
+    #   unit_group.each_with_tag do |tag, unit|
     #      puts "#{tag}: #{unit}"} #=> "12345: #<Api::Unit ...>"
     #   end
-    def each_with_tag(&block)
-      @units.each(&block)
+    # @yieldparam tag [Integer]
+    # @yieldparam unit [Api::Unit]
+    def each_with_tag(&)
+      @units.each(&)
       self
     end
 
@@ -229,12 +234,19 @@ module Sc2
     end
 
     # Selects a single random Unit without a parameter or an array of Units with a param, i.e. self.random(2)
-    # @return []
+    # @return [Api::Unit]
     def sample(...)
       @units.values.sample(...)
     end
     alias_method :random, :sample
 
+    # Returns the first Unit for which the block returns a truthy value
+    # @return [Api::Unit]
+    def detect(...)
+      @units.values.find(...)
+    end
+    alias_method :find, :detect
+
     # def select_or(*procs)
     #   result = UnitGroup.new
     #   procs.each do |proc|

data/lib/sc2ai/version.rb

@@ -2,5 +2,5 @@
 
 module Sc2
   # gem version
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

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

@@ -4,14 +4,13 @@ class <%= @classname %> < Sc2::Player::Bot
 
   def configure
     @realtime = false # Step-mode vs Bot, Realtime vs Humans
-    @step_size = 1 # Gives 22.4ms, typically compete at 2 (44.8ms) or 4 (179.2ms).
+    @step_count = 2 # 2s/22.4 = ~89.29ms step cycle time allowance
     @enable_feature_layer = false; # Enables ui_ and spatial_ actions. Advanced, and has performance cost.
   end
 
   def on_step
     if game_loop == 0
-      enemy_start_pos = game_info.start_raw.start_locations.first
-      units.workers.attack(target: enemy_start_pos)
+      units.workers.attack(target: geo.enemy_start_position)
     end
 
     # If your attack fails, "good game" and exit