sc2ai 0.1.0 → 0.3.0

data/lib/sc2ai/player/debug.rb

@@ -22,7 +22,7 @@ module Sc2
 
       # Prints debug text top left corner
       # @param text [String] will respect newlines
-      # @param size [Size] of font, default 14px
+      # @param size [Integer] of font, default 14px
       # @return [void]
       def debug_print(text, size: 14)
         queue_debug_command Api::DebugCommand.new(
@@ -43,7 +43,7 @@ module Sc2
       # @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
+      # @param size [Integer] 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(
@@ -67,7 +67,7 @@ module Sc2
       # @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
+      # @param size [Integer] of font, default 14px
       # @return [void]
       def debug_text_world(text, point:, color: nil, size: 14)
         queue_debug_command Api::DebugCommand.new(
@@ -121,8 +121,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.02),
-                max: Api::Point.new(x: point.x + radius, y: point.y + radius, z: point.z + (radius * 2) + 0.02),
+                min: Api::Point.new(x: point.x - radius, y: point.y - radius, z: point.z + 0.03),
+                max: Api::Point.new(x: point.x + radius, y: point.y + radius, z: point.z + (radius * 2) + 0.03),
                 color:
               )
             ]
@@ -149,22 +149,56 @@ module Sc2
         )
       end
 
+      # Renders a block on the floor, drawn by 4 lines
+      # Pass in either a pos (Position/Unit) or exact x * y coordinates
+      # Optional indentation adds padding on borders inward
+      # @param pos [Api::Unit, Sc2::Position]
+      # @param x [Float, Integer]
+      # @param y [Float, Integer]
+      # @param color [Api::Color]
+      # @param indent [Float] default 0.05. should be lower than < 1.0
+      # @example
+      #   debug_tile(x: 12.3, y: 4.56, color: Api::Color.new(r: 255, g: 0, b: 0))
+      #   debug_tile(some_unit)
+      #   debug_tile(some_unit.pos)
+      def debug_tile(pos = nil, x: nil, y: nil, color: nil, indent: 0.05)
+        if pos.is_a?(Api::Unit)
+          x = pos.pos.x.floor
+          y = pos.pos.y.floor
+        elsif pos.is_a?(Sc2::Position)
+          x = pos.x.floor
+          y = pos.y.floor
+        end
+
+        # Raise above floor to prevent texture clipping
+        z = geo.terrain_height(x:, y:).to_f + 0.1
+        tl = Api::Point[x + indent, y + 1.0 - indent, z]
+        bl = Api::Point[x + indent, y + indent, z]
+        br = Api::Point[x + 1.0 - indent, y + indent, z]
+        tr = Api::Point[x + 1.0 - indent, y + 1.0 - indent, z]
+
+        debug_draw_line(p0: tl, p1: bl, color:)
+        debug_draw_line(p0: bl, p1: br, color:)
+        debug_draw_line(p0: br, p1: tr, color:)
+        debug_draw_line(p0: tr, p1: tl, color:)
+      end
+
       # Other Commands ---
 
       # @param command [Integer] one of Api::DebugGameState::*
       # Possible values:
-      #  Api::DebugGameState::Show_map
-      #  Api::DebugGameState::Control_enemy
-      #  Api::DebugGameState::Food
-      #  Api::DebugGameState::Free
-      #  Api::DebugGameState::All_resources
-      #  Api::DebugGameState::God
-      #  Api::DebugGameState::Minerals
-      #  Api::DebugGameState::Gas
-      #  Api::DebugGameState::Cooldown
-      #  Api::DebugGameState::Tech_tree
-      #  Api::DebugGameState::Upgrade
-      #  Api::DebugGameState::Fast_build
+      #  Api::DebugGameState::SHOW_MAP
+      #  Api::DebugGameState::CONTROL_ENEMY
+      #  Api::DebugGameState::FOOD
+      #  Api::DebugGameState::FREE
+      #  Api::DebugGameState::ALL_RESOURCES
+      #  Api::DebugGameState::GOD
+      #  Api::DebugGameState::MINERALS
+      #  Api::DebugGameState::GAS
+      #  Api::DebugGameState::COOLDOWN
+      #  Api::DebugGameState::TECH_TREE
+      #  Api::DebugGameState::UPGRADE
+      #  Api::DebugGameState::FAST_BUILD
       # @return [void]
       def debug_game_state(command)
         queue_debug_command Api::DebugCommand.new(
@@ -203,7 +237,7 @@ module Sc2
 
       # @private
       # Hangs, crashes and exits the Sc2 client. DO NOT USE.
-      # @param test [Integer] one of Api::DebugTestProcess::Test::Crash, Api::DebugTestProcess::Test::Hang, Api::DebugTestProcess::Test::Exit
+      # @param test [Integer] one of Api::DebugTestProcess::Test::CRASH, Api::DebugTestProcess::Test::HANG, Api::DebugTestProcess::Test::EXIT
       # @param delay_ms [Integer] default 0, how long this test is delayed
       # @return [void]
       def debug_test_process(test:, delay_ms: 0)
@@ -226,8 +260,8 @@ module Sc2
         )
       end
 
-      # Ends game with a specified result of either Surrender or DeclareVictory
-      # @param end_result [Integer] either 1/2.  Api::DebugEndGame::EndResult::Surrender or Api::DebugEndGame::EndResult::DeclareVictory
+      # Ends game with a specified result of either :SURRENDER or :DECLARE_VICTORY
+      # @param end_result [Integer] either 1/2.  Api::DebugEndGame::EndResult::SURRENDER or Api::DebugEndGame::EndResult::DECLARE_VICTORY
       # @return [void]
       def debug_end_game(end_result:)
         queue_debug_command Api::DebugCommand.new(

data/lib/sc2ai/player/game_state.rb

@@ -5,7 +5,7 @@ module Sc2
     # Holds game state
     module GameState
       # @!attribute status
-      #   @return [:launched, :in_game, :in_replay, :ended, :quit, :unknown] status
+      #   @return [:LAUNCHED, :IN_GAME, :IN_REPLAY, :ENDED, :QUIT, :UNKNOWN] status
       attr_accessor :status
 
       include Connection::StatusListener
@@ -27,10 +27,16 @@ module Sc2
       # Access useful game information. Used in parsed pathing grid, terrain height, placement grid.
       # Holds Api::ResponseGameInfo::#start_locations.
       # @return [Api::ResponseGameInfo]
-      attr_reader :game_info
+      def game_info
+        if @game_info_task&.running?
+          @game_info_task&.wait
+          @game_info_task = nil
+        end
+        @game_info
+      end
 
       def game_info=(new_info)
-        @game_info_loop = game_loop || 0
+        @game_info_loop = game_loop
         @game_info = new_info
       end
 
@@ -40,19 +46,6 @@ module Sc2
       # @return [Integer]
       attr_accessor :game_info_loop
 
-      # Determines if your game_info will be refreshed at this moment
-      # Has a hard-capped refresh of only ever 4 steps
-      # In general game_info is only refreshed Player::Bot reads from pathing_grid or placement_grid
-      # @return [Boolean]
-      def game_info_stale?
-        return true if game_info_loop.nil? || game_info.nil?
-        return false if game_info_loop == game_loop
-
-        # Note: No minimum step count set anymore
-        # We can do something like, only updating every 2+ frames:
-        game_info_loop + 4 <= game_loop
-      end
-
       # @!attribute data
       #   @return [Api::ResponseData]
       attr_accessor :data
@@ -141,14 +134,14 @@ module Sc2
           player_id: 0,
           minerals: 50,
           vespene: 0,
-          food_cap: ((race == Api::Race::Zerg) ? 14 : 15),
+          food_cap: ((race == Api::Race::ZERG) ? 14 : 15),
           food_used: 12,
           food_army: 0,
           food_workers: 12,
           idle_worker_count: 0,
           army_count: 0,
           warp_gate_count: 0,
-          larva_count: ((race == Api::Race::Zerg) ? 3 : 0)
+          larva_count: ((race == Api::Race::ZERG) ? 3 : 0)
         )
       end
 

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,13 +128,13 @@ 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_y)..(x + 2).clamp(map_tile_range_y)] = 1
+                                   (x - 2).clamp(map_tile_range_x)..(x + 2).clamp(map_tile_range_x)] = 1
             else
               @expo_placement_grid[(y - 2).clamp(map_tile_range_y)..(y + 2).clamp(map_tile_range_y),
-                                   (x - 2).clamp(map_tile_range_y)..(x + 2).clamp(map_tile_range_y)] = 1
+                                   (x - 2).clamp(map_tile_range_x)..(x + 2).clamp(map_tile_range_x)] = 1
             end
           end
         end
@@ -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
@@ -91,6 +91,17 @@ module Sc2
       # For this unit type, tells you how many are in progress by checking orders for all it's sources.
       # @return [Integer]
       def units_in_progress(unit_type_id)
+        if unit_type_id == Api::UnitTypeId::REACTOR
+          return units_in_progress(Api::UnitTypeId::BARRACKSREACTOR) +
+              units_in_progress(Api::UnitTypeId::FACTORYREACTOR) +
+              units_in_progress(Api::UnitTypeId::STARPORTREACTOR)
+        elsif unit_type_id == Api::UnitTypeId::TECHLAB
+          return units_in_progress(Api::UnitTypeId::BARRACKSTECHLAB) +
+              units_in_progress(Api::UnitTypeId::FACTORYTECHLAB) +
+              units_in_progress(Api::UnitTypeId::STARPORTTECHLAB)
+        end
+
+        # Get source unit
         source_unit_types = Api::TechTree.unit_created_from(unit_type_id: unit_type_id)
 
         # When building from LARVA, check the intermediate models
@@ -114,14 +125,27 @@ 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
         end
+        # For SCV, the structure might be completed but dangling order for a few frames.
+        source_is_scv = source_unit_types.include?(Api::UnitTypeId::SCV)
+
+        # Let's count orders matching the ability
         total_in_progress = origin.select_type(source_unit_types).sum do |source|
           source.orders.count do |order|
-            true if order.ability_id == unit_create_ability
+            if order.ability_id == unit_create_ability
+              if source_is_scv
+                # If we are a SCV, do not count our order if the target is a completed structure pos
+                structures.select_type(unit_type_id).completed.none? do |structure|
+                  structure.pos == order.target_world_space_pos
+                end
+              else
+                true
+              end
+            end
           end
         end
         total_in_progress *= 2 if unit_type_id == Api::UnitTypeId::ZERGLING
@@ -191,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
@@ -331,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
@@ -344,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
@@ -355,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]
@@ -378,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