sc2ai 0.2.0 → 0.3.0

data/lib/sc2ai/player/geo.rb

@@ -11,10 +11,30 @@ module Sc2
       #   @return [Sc2::Player] player with active connection
       attr_accessor :bot
 
+      # @private
       def initialize(bot)
         @bot = bot
       end
 
+      # @private
+      # Called once per update loop.
+      # It will clear memoization and caches where necessary
+      # @return [void]
+      def reset
+        # Only re-parse and cache-bust if strings don't match
+        if bot.game_info.start_raw.pathing_grid.data != bot.previous&.game_info&.start_raw&.pathing_grid&.data
+          @parsed_pathing_grid = nil
+          clear_placement_cache
+        end
+        if bot.observation.raw_data.map_state.creep.data != bot.previous.observation.raw_data&.map_state&.creep&.data
+          @parsed_creep = nil
+          clear_placement_cache
+        end
+        if bot.observation.raw_data.map_state.visibility.data != bot.previous.observation.raw_data&.map_state&.visibility&.data
+          @parsed_visibility_grid = nil
+        end
+      end
+
       # Gets the map tile width. Range is 1-255.
       # Effected by crop_to_playable_area
       # @return [Integer]
@@ -78,13 +98,13 @@ 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]
+      # @return [::Numo::Bit]
       def parsed_placement_grid
         if @parsed_placement_grid.nil?
           image_data = bot.game_info.start_raw.placement_grid
           # Fix endian for Numo bit parser
           data = image_data.data.unpack("b*").pack("B*")
-          @parsed_placement_grid = ::Numo::Bit.from_binary(data, [image_data.size.y, image_data.size.x])
+          @parsed_placement_grid = Numo::Bit.from_binary(data, [image_data.size.y, image_data.size.x])
         end
         @parsed_placement_grid
       end
@@ -99,7 +119,7 @@ module Sc2
       end
 
       # Returns a grid where only the expo locations are marked
-      # @return [Numo::Bit]
+      # @return [::Numo::Bit]
       def expo_placement_grid
         if @expo_placement_grid.nil?
           @expo_placement_grid = Numo::Bit.zeros(map_height, map_width)
@@ -108,7 +128,7 @@ module Sc2
             y = point.y.floor
 
             # For zerg, reserve a layer at the bottom for larva->egg
-            if bot.race == Api::Race::Zerg
+            if bot.race == Api::Race::ZERG
               # Reserve one row lower, meaning (y-3) instead of (y-2)
               @expo_placement_grid[(y - 3).clamp(map_tile_range_y)..(y + 2).clamp(map_tile_range_y),
                                    (x - 2).clamp(map_tile_range_x)..(x + 2).clamp(map_tile_range_x)] = 1
@@ -123,7 +143,7 @@ module Sc2
 
       # Returns a grid where only placement obstructions are marked
       # includes Tumors and lowered Supply Depots
-      # @return [Numo::Bit]
+      # @return [::Numo::Bit]
       private def placement_obstruction_grid
         # Get obstructing structures
         obstructure_types = [Api::UnitTypeId::SUPPLYDEPOTLOWERED, Api::UnitTypeId::CREEPTUMORQUEEN, Api::UnitTypeId::CREEPTUMOR, Api::UnitTypeId::CREEPTUMORBURROWED]
@@ -158,7 +178,7 @@ module Sc2
       end
 
       # Returns a grid where powered locations are marked true
-      # @return [Numo::Bit]
+      # @return [::Numo::Bit]
       def parsed_power_grid
         # Cache for based on power unit tags
         cache_key = bot.power_sources.map(&:tag).sort.hash
@@ -188,7 +208,7 @@ module Sc2
         # 00001111110000
         # perf: Saving pre-created shape for speed (0.5ms saved) by using hardcode from .to_binary.unpack("C*")
         blueprint_data = [0, 0, 254, 193, 255, 248, 127, 254, 159, 255, 231, 243, 249, 124, 254, 159, 255, 231, 255, 241, 63, 248, 7, 0, 0].pack("C*")
-        blueprint_pylon = ::Numo::Bit.from_binary(blueprint_data, [14, 14])
+        blueprint_pylon = Numo::Bit.from_binary(blueprint_data, [14, 14])
 
         # Warp Prism
         # 00011000
@@ -200,7 +220,7 @@ module Sc2
         # 01111110
         # 00011000
         blueprint_data = [24, 126, 126, 255, 255, 126, 126, 24].pack("C*")
-        blueprint_prism = ::Numo::Bit.from_binary(blueprint_data, [8, 8])
+        blueprint_prism = Numo::Bit.from_binary(blueprint_data, [8, 8])
 
         # Print each power-source on map using shape above
         bot.power_sources.each do |ps|
@@ -273,20 +293,13 @@ module Sc2
       #   parsed_pathing_grid[0,0] # reads bottom left corner
       #   # use helper function #pathable
       #   pathable?(x: 0, y: 0) # reads bottom left corner
-      # @return [Numo::Bit] Numo array
+      # @return [::Numo::Bit] Numo array
       def parsed_pathing_grid
-        if bot.game_info_stale?
-          previous_data = bot.game_info.start_raw.pathing_grid.data
-          bot.refresh_game_info
-          # Only re-parse if binary strings don't match
-          clear_cached_pathing_grid if previous_data != bot.game_info.start_raw.pathing_grid.data
-        end
-
         if @parsed_pathing_grid.nil?
           image_data = bot.game_info.start_raw.pathing_grid
           # Fix endian for Numo bit parser
           data = image_data.data.unpack("b*").pack("B*")
-          @parsed_pathing_grid = ::Numo::Bit.from_binary(data, [image_data.size.y, image_data.size.x])
+          @parsed_pathing_grid = Numo::Bit.from_binary(data, [image_data.size.y, image_data.size.x])
         end
         @parsed_pathing_grid
       end
@@ -294,8 +307,7 @@ module Sc2
       # Clears pathing-grid dependent objects like placements.
       # Called when pathing grid gets updated
       #
-      private def clear_cached_pathing_grid
-        @parsed_pathing_grid = nil
+      private def clear_placement_cache
         @_build_coordinates = {}
         @_build_coordinate_tree = {}
       end
@@ -318,13 +330,13 @@ module Sc2
 
       # Returns a parsed terrain_height from bot.game_info.start_raw.
       # Each value in [row][column] holds a float value which is the z height
-      # @return [Numo::SFloat] Numo array
+      # @return [::Numo::SFloat] Numo array
       def parsed_terrain_height
         if @parsed_terrain_height.nil?
 
           image_data = bot.game_info.start_raw.terrain_height
-          @parsed_terrain_height = ::Numo::UInt8.from_binary(image_data.data,
-            [image_data.size.y, image_data.size.x])
+          @parsed_terrain_height = Numo::UInt8
+            .from_binary(image_data.data, [image_data.size.y, image_data.size.x])
             .cast_to(Numo::SFloat)
 
           # Values are between -16 and +16. The api values is a float height compressed to rgb range (0-255) in that range of 32.
@@ -339,7 +351,7 @@ module Sc2
       # Returns one of three Integer visibility indicators at tile for x & y
       # @param x [Float, Integer]
       # @param y [Float, Integer]
-      # @return [Integer] 0=Hidden,1= Snapshot,2=Visible
+      # @return [Integer] 0=HIDDEN,1=SNAPSHOT,2=VISIBLE
       def visibility(x:, y:)
         parsed_visibility_grid[y.to_i, x.to_i]
       end
@@ -371,12 +383,13 @@ module Sc2
       # Returns a parsed map_state.visibility from bot.observation.raw_data.
       # Each value in [row][column] holds one of three integers (0,1,2) to flag a vision type
       # @see #visibility for reading from this value
-      # @return [Numo::SFloat] Numo array
+      # @return [::Numo::SFloat] Numo array
       def parsed_visibility_grid
         if @parsed_visibility_grid.nil?
           image_data = bot.observation.raw_data.map_state.visibility
-          @parsed_visibility_grid = ::Numo::UInt8.from_binary(image_data.data,
-            [image_data.size.y, image_data.size.x])
+          # Fix endian for Numo bit parser
+          data = image_data.data.unpack("b*").pack("B*")
+          @parsed_visibility_grid = Numo::UInt8.from_binary(data, [image_data.size.y, image_data.size.x])
         end
         @parsed_visibility_grid
       end
@@ -391,17 +404,16 @@ module Sc2
       end
 
       # Provides parsed minimap representation of creep spread
-      # Caches for 4 frames
-      # @return [Numo::Bit] Numo array
+      # Caches for this frame
+      # @return [::Numo::Bit] Numo array
       def parsed_creep
-        if @parsed_creep.nil? || @parsed_creep[1] + 4 < bot.game_loop
+        if @parsed_creep.nil? # || image_data != previous_data
           image_data = bot.observation.raw_data.map_state.creep
           # Fix endian for Numo bit parser
           data = image_data.data.unpack("b*").pack("B*")
-          result = ::Numo::Bit.from_binary(data, [image_data.size.y, image_data.size.x])
-          @parsed_creep = [result, bot.game_loop]
+          @parsed_creep = Numo::Bit.from_binary(data, [image_data.size.y, image_data.size.x])
         end
-        @parsed_creep[0]
+        @parsed_creep
       end
 
       # TODO: Removing. Better name or more features for this? Maybe check nearest units.
@@ -416,7 +428,7 @@ module Sc2
       # TODO: Remove this method if it has no use. Build points uses this code directly for optimization.
       # Reduce the dimensions of a grid by merging cells using length x length squares.
       # Merged cell keeps it's 1 value only if all merged cells are equal to 1, else 0
-      # @param input_grid [Numo::Bit] Bit grid like parsed_pathing_grid or parsed_placement_grid
+      # @param input_grid [::Numo::Bit] Bit grid like parsed_pathing_grid or parsed_placement_grid
       # @param length [Integer] how many cells to merge, i.e. 3 for finding 3x3 placement
       def divide_grid(input_grid, length)
         height = input_grid.shape[0]
@@ -713,7 +725,7 @@ module Sc2
         length = 1 if length < 1
         @_build_coordinates ||= {}
         cache_key = [length, on_creep, in_power].hash
-        return @_build_coordinates[cache_key] if !@_build_coordinates[cache_key].nil? && !bot.game_info_stale?
+        return @_build_coordinates[cache_key] unless @_build_coordinates[cache_key].nil?
 
         result = []
         input_grid = parsed_pathing_grid & parsed_placement_grid & ~expo_placement_grid & ~placement_obstruction_grid
@@ -722,7 +734,6 @@ module Sc2
         else
           ~parsed_creep & input_grid
         end
-
         input_grid = parsed_power_grid & input_grid if in_power
 
         # Dimensions
@@ -736,35 +747,14 @@ module Sc2
         # Build points are in center of square, i.e. 1.5 inwards for a 3x3 building
         offset_to_inside = length / 2.0
 
-        # Note, these loops are structured for speed
-        y = 0
-        while y < capped_height
-          x = 0
-          while x < capped_width
-            # We are on the bottom-left of a placement tile of Length x Length
-            # Check right- and upwards for any negatives and break both loops, as soon as we find one
-            valid_position = true
-            inner_y = 0
-            while inner_y < length
-              inner_x = 0
-              while inner_x < length
-                if (input_grid[y + inner_y, x + inner_x]).zero?
-                  # break sub-cells check and don't save position
-                  valid_position = false
-                  inner_y = length
-                  break
-                end
-                inner_x += 1
-              end
-              inner_y += 1
-            end
-            # End of checking sub-cells
-
-            result << [x + offset_to_inside, y + offset_to_inside] if valid_position
-            x += length
-          end
-          y += length
+        output_grid = input_grid[0...capped_height, 0...capped_width]
+          .reshape(capped_height / length, length, capped_width / length, length)
+          .all?(1, 3)
+        output_grid.where.each do |true_index|
+          y, x = true_index.divmod(capped_width / length)
+          result << [x * length + offset_to_inside, y * length + offset_to_inside]
         end
+
         @_build_coordinates[cache_key] = result
       end
 
@@ -781,7 +771,7 @@ module Sc2
         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
+        on_creep = bot.race == Api::Race::ZERG
 
         coordinates = build_coordinates(length:, on_creep:, in_power:)
         cache_key = coordinates.hash

data/lib/sc2ai/player/units.rb

@@ -23,7 +23,7 @@ module Sc2
       #   @return [Sc2::UnitGroup] a group of placeholder structures
       attr_accessor :placeholders
 
-      # All units with alliance :Neutral
+      # All units with alliance :NEUTRAL
       # @!attribute neutral
       #   @return [Sc2::UnitGroup] a group of neutral units
       attr_accessor :neutral
@@ -125,7 +125,7 @@ module Sc2
           target: unit_type_id
         )
 
-        origin = if unit_data(source_unit_types.first).attributes.include?(:Structure)
+        origin = if unit_data(source_unit_types.first).attributes.include?(Api::Attribute::STRUCTURE)
           structures
         else
           units
@@ -215,12 +215,12 @@ module Sc2
 
       # Checks unit data for an attribute value
       # @param unit [Integer,Api::Unit] Api::UnitTypeId or Api::Unit
-      # @param attribute [Symbol] Api::Attribute, i.e. Api::Attribute::Mechanical or :Mechanical
+      # @param attribute [Symbol] Api::Attribute, i.e. Api::Attribute::MECHANICAL or :Mechanical
       # @return [Boolean] whether unit has attribute
       # @example
-      #   unit_has_attribute?(Api::UnitTypeId::SCV, Api::Attribute::Mechanical)
-      #   unit_has_attribute?(units.workers.first, :Mechanical)
-      #   unit_has_attribute?(Api::UnitTypeId::SCV, :Mechanical)
+      #   unit_has_attribute?(Api::UnitTypeId::SCV, Api::Attribute::MECHANICAL)
+      #   unit_has_attribute?(units.workers.first, :MECHANICAL)
+      #   unit_has_attribute?(Api::UnitTypeId::SCV, :MECHANICAL)
       def unit_has_attribute?(unit, attribute)
         unit_data(unit).attributes.include? attribute
       end
@@ -355,7 +355,7 @@ module Sc2
           # Categorize own units/structures, enemy units/structures, neutral
           if unit.is_blip
             @blips[tag] = unit
-          elsif unit.display_type == :Placeholder
+          elsif unit.display_type == :PLACEHOLDER
             @placeholders[tag] = unit
           elsif unit.alliance == own_alliance || unit.alliance == enemy_alliance
             if unit.alliance == own_alliance
@@ -368,7 +368,7 @@ module Sc2
             end
 
             unit_data = unit_data(unit.unit_type)
-            if unit_data.attributes.include? :Structure
+            if unit_data.attributes.include?(Api::Attribute::STRUCTURE)
               structure_collection[tag] = unit
             else
               unit_collection[tag] = unit
@@ -379,8 +379,8 @@ module Sc2
 
           # Dont parse callbacks on first loop or for neutral units
           if !@previous.all_units.nil? &&
-              unit.alliance != :Neutral &&
-              unit.display_type != :Placeholder &&
+              unit.alliance != :NEUTRAL &&
+              unit.display_type != :PLACEHOLDER &&
               unit.is_blip == false
 
             previous_unit = @previous.all_units[unit.tag]
@@ -402,23 +402,23 @@ module Sc2
 
       # @private
       # Returns alliance based on whether you are a player or an enemy
-      # @return [:Symbol] :Self or :Enemy from Api::Alliance
+      # @return [:Symbol] :SELF or :ENEMY from Api::Alliance
       def own_alliance
         if is_a? Sc2::Player::Enemy
-          Api::Alliance.lookup(Api::Alliance::Enemy)
+          Api::Alliance.lookup(Api::Alliance::ENEMY)
         else
-          Api::Alliance.lookup(Api::Alliance::Self)
+          Api::Alliance.lookup(Api::Alliance::SELF)
         end
       end
 
       # @private
       # Returns enemy alliance based on whether you are a player or an enemy
-      # @return [:Symbol] :Self or :Enemy from Api::Alliance
+      # @return [:Symbol] :SELF or :ENEMY from Api::Alliance
       def enemy_alliance
         if is_a? Sc2::Player::Enemy
-          Api::Alliance.lookup(Api::Alliance::Self)
+          Api::Alliance.lookup(Api::Alliance::SELF)
         else
-          Api::Alliance.lookup(Api::Alliance::Enemy)
+          Api::Alliance.lookup(Api::Alliance::ENEMY)
         end
       end
 

data/lib/sc2ai/player.rb

@@ -21,10 +21,10 @@ module Sc2
     extend Forwardable
     def_delegators :@api, :add_listener
 
-    # Known races for detecting race on Api::Race::Random or nil
+    # Known races for detecting race on Api::Race::RANDOM or nil
     # @!attribute IDENTIFIED_RACES
-    #   @return [Array<Integer>]
-    IDENTIFIED_RACES = [Api::Race::Protoss, Api::Race::Terran, Api::Race::Zerg].freeze
+    # @return [Array<Integer>]
+    IDENTIFIED_RACES = [Api::Race::PROTOSS, Api::Race::TERRAN, Api::Race::ZERG].freeze
 
     # @!attribute api
     #   Manages connection to client and performs Requests
@@ -57,16 +57,16 @@ module Sc2
     # @return [String] in-game name
     attr_accessor :name
 
-    # @return [Api::PlayerType::Participant, Api::PlayerType::Computer, Api::PlayerType::Observer] PlayerType
+    # @return [Integer] Api::PlayerType::PARTICIPANT, Api::PlayerType::COMPUTER, Api::PlayerType::OBSERVER
     attr_accessor :type
 
-    # if @type is Api::PlayerType::Computer, set one of Api::Difficulty scale 1 to 10
+    # if @type is Api::PlayerType::COMPUTER, set one of Api::Difficulty scale 1 to 10
     # @see Api::Difficulty for options
-    # @return [Api::Difficulty::VeryEasy] if easiest, int 1
-    # @return [Api::Difficulty::CheatInsane] if toughest, int 10
+    # @return [Integer]
     attr_accessor :difficulty
 
     # @see Api::AIBuild proto for options
+    # @return [Integer]
     attr_accessor :ai_build
 
     # @return [String] ladder matches will set an opponent id
@@ -148,7 +148,7 @@ module Sc2
     def join_game(server_host:, port_config:)
       Sc2.logger.debug { "Player \"#{@name}\" joining game..." }
       response = @api.join_game(name: @name, race: @race, server_host:, port_config:, enable_feature_layer: @enable_feature_layer, interface_options: @interface_options)
-      if response.error != :EnumResponseJoinGameErrorUnset && response.error != :MissingParticipation
+      if response.error != :ENUM_RESPONSE_JOIN_GAME_ERROR_UNSET && response.error != :MISSING_PARTICIPATION
         raise Sc2::Error, "Player \"#{@name}\" join_game failed: #{response.error}"
       end
       add_listener(self, klass: Connection::StatusListener)
@@ -167,7 +167,7 @@ module Sc2
     # Bot
     # race != None
     # name=''
-    # type: Api::PlayerType::Participant
+    # type: Api::PlayerType::PARTICIPANT
 
     # An object which interacts with an SC2 client and is game-aware.
     class Bot < Player
@@ -188,7 +188,7 @@ module Sc2
       attr_accessor :geo
 
       def initialize(race:, name:)
-        super(race:, name:, type: Api::PlayerType::Participant, difficulty: nil, ai_build: nil)
+        super(race:, name:, type: Api::PlayerType::PARTICIPANT, difficulty: nil, ai_build: nil)
         @previous = Sc2::Player::PreviousState.new
         @geo = Sc2::Player::Geo.new(self)
 
@@ -206,11 +206,12 @@ module Sc2
       #   end
       def configure
       end
+
       alias_method :before_join, :configure
 
       # TODO: If this suffices for Bot and Observer, they should share this code.
       # Initializes and refreshes game data and runs the game loop
-      # @return [Api::Result::Victory, Api::Result::Defeat, Api::Result::Tie, Api::Result::Undecided] result
+      # @return [Integer] One of Api::Result::VICTORY, Api::Result::DEFEAT, Api::Result::TIE, Api::Result::UNDECIDED
       def play
         # Step 0
         prepare_start
@@ -222,16 +223,45 @@ module Sc2
         # Callback for step 0
         on_step
 
+        # Local play prints out avg times
+        unless Sc2.ladder?
+          running_avg_step_times = []
+          average_runtime = 0.0
+        end
+
         puts ""
+
         # Step 1 to n
+        i = 0
         loop do
+          if i >= 5
+            i = 0
+          end
           r = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
           perform_actions
           perform_debug_commands unless Sc2.ladder?
           step_forward
-          print "\e[2K#{game_loop - @previous.game_loop} Steps Took (ms): #{(::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - r) * 1000}\n\e[1A\r"
+
+          unless Sc2.ladder?
+            time_delta = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - r) * 1000
+            step_delta = game_loop - @previous.game_loop
+            # running_avg_step_times.shift if running_avg_step_times.size == 5
+            running_avg_step_times << [time_delta, step_delta]
+
+            if i == 0
+              sum_t, sum_s = running_avg_step_times.each_with_object([0, 0]) do |n, total|
+                total[0] += n[0]
+                total[1] += n[1]
+              end
+              average_runtime = sum_t / sum_s
+              running_avg_step_times.clear
+            end
+            print "\e[2K#{step_delta} Step(s) Took (ms): #{"%.2f" % time_delta} | Avg (ms/frame): #{"%.2f" % average_runtime}\n\e[1A\r"
+          end
+
+          i += 1
           return @result unless @result.nil?
-          break if @status != :in_game
+          break if @status != :IN_GAME
         end
       end
 
@@ -256,11 +286,11 @@ module Sc2
       # Callbacks ---
 
       # Override to handle game result (:Victory/:Loss/:Tie)
-      # Called when game has ended with a result, i.e. result = ::Victory
-      # @param result [Symbol] Api::Result::Victory or Api::Result::Victory::Defeat or Api::Result::Victory::Undecided
+      # Called when game has ended with a result, i.e. result = :Victory
+      # @param result [Symbol] Api::Result::VICTORY or Api::Result::DEFEAT or Api::Result::UNDECIDED
       # @example
       #   def on_finish(result)
-      #     if result == :Victory
+      #     if result == :VICTORY
       #       puts "Yay!"
       #     else
       #       puts "Lets try again!"
@@ -272,7 +302,7 @@ module Sc2
 
       # Called when Random race is first detected.
       # Override to handle race identification of random enemy.
-      # @param race [Integer] Api::Race::* excl *::Random
+      # @param race [Integer] see {Api::Race}
       def on_random_race_detected(race)
       end
 
@@ -296,9 +326,9 @@ module Sc2
       # @example
       #   alerts.each do |alert|
       #     case alert
-      #     when :NuclearLaunchDetected
+      #     when :NUCLEAR_LAUNCH_DETECTED
       #       pp "TAKE COVER!"
-      #     when :NydusWormDetected
+      #     when :NYDUS_WORM_DETECTED
       #       pp "FIND THE WORM!"
       #     end
       #   end
@@ -418,26 +448,26 @@ module Sc2
     # Allows using CLI launch options hash or "laddorconfig.json"-complient launcher.
     class BotProcess < Player
       def initialize(race:, name:)
-        super(race:, name:, type: Api::PlayerType::Participant)
+        super(race:, name:, type: Api::PlayerType::PARTICIPANT)
         raise "not implemented"
       end
     end
 
     # A Computer opponent using the game's built-in AI for a Match
     class Computer < Player
-      # @param race [Integer] (see Api::Race)
-      # @param difficulty [Integer] see Api::Difficulty::VeryEasy,Api::Difficulty::VeryHard,etc.)
-      # @param ai_build [Api::AIBuild::RandomBuild] (see Api::AIBuild)
+      # @param race [Integer] see {Api::Race}
+      # @param difficulty [Integer] Api::Difficulty::VERY_EASY, Api::Difficulty::VERY_HARD,etc.
+      # @param ai_build [Integer] default: Api::AIBuild::RANDOM_BUILD
       # @param name [String]
       # @return [Sc2::Computer]
-      def initialize(race:, difficulty: Api::Difficulty::VeryEasy, ai_build: Api::AIBuild::RandomBuild,
+      def initialize(race:, difficulty: Api::Difficulty::VERY_EASY, ai_build: Api::AIBuild::RANDOM_BUILD,
         name: "Computer")
-        difficulty = Api::Difficulty::VeryEasy if difficulty.nil?
-        ai_build = Api::AIBuild::RandomBuild if ai_build.nil?
+        difficulty = Api::Difficulty::VERY_EASY if difficulty.nil?
+        ai_build = Api::AIBuild::RANDOM_BUILD if ai_build.nil?
         raise Error, "unknown difficulty: '#{difficulty}'" if Api::Difficulty.lookup(difficulty).nil?
         raise Error, "unknown difficulty: '#{ai_build}'" if Api::AIBuild.lookup(ai_build).nil?
 
-        super(race:, name:, type: Api::PlayerType::Computer, difficulty:, ai_build:)
+        super(race:, name:, type: Api::PlayerType::COMPUTER, difficulty:, ai_build:)
       end
 
       # Returns whether or not the player requires a sc2 instance
@@ -455,14 +485,14 @@ module Sc2
     # A human player for a Match
     class Human < Player
       def initialize(race:, name:)
-        super(race:, name:, type: Api::PlayerType::Participant)
+        super(race:, name:, type: Api::PlayerType::PARTICIPANT)
       end
     end
 
     # A spectator for a Match
     class Observer < Player
       def initialize(name: nil)
-        super(race: Api::Race::NoRace, name:, type: Api::PlayerType::Observer)
+        super(race: Api::Race::NO_RACE, name:, type: Api::PlayerType::OBSERVER)
       end
     end
 
@@ -476,6 +506,29 @@ module Sc2
 
     private
 
+    # @private
+    CALLBACK_METHODS = %i[on_finish
+      on_random_race_detected
+      on_action_errors
+      on_actions_performed
+      on_alerts
+      on_upgrades_completed
+      on_parse_observation_unit
+      on_unit_destroyed
+      on_unit_created
+      on_unit_type_changed
+      on_structure_started
+      on_structure_completed
+      on_unit_damaged]
+
+    # @private
+    # Checks if callback method is defined on our bot
+    # Used to skip processing on unused callbacks
+    # @param callback [Symbol]
+    def callback_defined?(callback)
+      CALLBACK_METHODS.include?(callback)
+    end
+
     # Initialize data on step 0 before stepping and before on_start is called
     def prepare_start
       @data = Sc2::Data.new(@api.data)
@@ -520,6 +573,10 @@ module Sc2
 
       # Save previous frame before continuing
       @previous.reset(self)
+
+      # We can request game info async, while we process observation
+      refresh_game_info
+
       # Reset
       self.observation = response_observation.observation
       self.game_loop = observation.game_loop
@@ -527,17 +584,14 @@ module Sc2
       self.spent_minerals = 0
       self.spent_vespene = 0
       self.spent_supply = 0
-      # Geometric/map
-      if observation.raw_data.map_state.visibility != previous.observation&.raw_data&.map_state&.visibility
-        @parsed_visibility_grid = nil
-      end
+      geo.reset
 
-      # Only grab game_info if unset (loop 0 or first realtime loop). It's lazily loaded otherwise as needed
-      # This is heavy processing, because it contains image data
-      if game_info.nil?
-        refresh_game_info
+      # First game-loop: set enemy and our race if random
+      if enemy.nil?
+        # Finish game_info load immediately, because we need it's info
+        game_info
         set_enemy
-        set_race_for_random if race == Api::Race::Random
+        set_race_for_random if race == Api::Race::RANDOM
       end
 
       parse_observation_units(response_observation.observation)
@@ -549,7 +603,12 @@ module Sc2
 
       # Actions performed and errors (only if implemented)
       on_actions_performed(response_observation.actions) unless response_observation.actions.empty?
-      on_action_errors(response_observation.action_errors) unless response_observation.action_errors.empty?
+      if callback_defined?(:on_action_errors)
+        unless response_observation.action_errors.empty?
+          @action_errors.concat(response_observation.action_errors.to_a)
+        end
+        on_action_errors(@action_errors) unless @action_errors&.empty?
+      end
       on_alerts(observation.alerts) unless observation.alerts.empty?
 
       # Diff previous observation upgrades to see if anything new completed
@@ -578,7 +637,10 @@ module Sc2
     # Refreshes bot#game_info ignoring all caches
     # @return [void]
     public def refresh_game_info
-      self.game_info = @api.game_info
+      @game_info_task = Async do
+        self.game_info = @api.game_info
+        @game_info_task = nil
+      end
     end
 
     # Enemy -----------------------
@@ -595,7 +657,7 @@ module Sc2
       self.enemy = Sc2::Player::Enemy.from_proto(player_info: enemy_player_info)
 
       if enemy.nil?
-        self.enemy = Sc2::Player::Enemy.new(name: "Unknown", race: Api::Race::Random)
+        self.enemy = Sc2::Player::Enemy.new(name: "Unknown", race: Api::Race::RANDOM)
       end
       if enemy.race_unknown?
         detected_race = enemy.detect_race_from_units

data/lib/sc2ai/ports.rb

@@ -135,7 +135,7 @@ module Sc2
     def initialize(start_port:, num_players:, ports: [])
       @start_port = start_port
       @server_port_set = nil
-      @client_port_sets = nil
+      @client_port_sets = []
       return if num_players <= 1
 
       return if ports.empty?