sc2ai 0.0.5 → 0.0.7

data/lib/sc2ai/api/upgrade_id.rb

@@ -299,14 +299,14 @@ module Api
     DIGGINGCLAWS = 293
     CARRIERCARRIERCAPACITY = 294
     CARRIERLEASHRANGEUPGRADE = 295
-    TEMPESTGROUNDATTACKUPGRADE = 296
-    MICROBIALSHROUD = 297
-    SUNDERINGIMPACT = 298
-    AMPLIFIEDSHIELDING = 299
-    PSIONICAMPLIFIERS = 300
-    SECRETEDCOATING = 301
-    ENHANCEDSHOCKWAVES = 302
-    HURRICANETHRUSTERS = 303
-    INTERFERENCEMATRIX = 304
+    HURRICANETHRUSTERS = 296
+    TEMPESTGROUNDATTACKUPGRADE = 297
+    MICROBIALSHROUD = 298
+    INTERFERENCEMATRIX = 299
+    SUNDERINGIMPACT = 300
+    AMPLIFIEDSHIELDING = 301
+    PSIONICAMPLIFIERS = 302
+    SECRETEDCOATING = 303
+    ENHANCEDSHOCKWAVES = 304
   end
 end

data/lib/sc2ai/connection/requests.rb

@@ -279,10 +279,11 @@ module Sc2
       # Advances the game simulation by step_count. Not used in realtime mode.
       # Only constant step size supported - subsequent requests use cache.
       def step(step_count = 1)
-        @_cached_request_step ||= Api::Request.new(
+        @_cached_request_step ||= {}
+        @_cached_request_step[step_count] ||= Api::Request.new(
           step: Api::RequestStep.new(count: step_count)
         ).to_proto
-        send_request_and_ignore(@_cached_request_step)
+        send_request_and_ignore(@_cached_request_step[step_count])
       end
 
       # Additional methods for inspecting game state. Synchronous and must wait on response
@@ -291,7 +292,7 @@ module Sc2
       # @param placements [Array<Api::RequestQueryBuildingPlacement>]
       # @param ignore_resource_requirements [Boolean] Ignores requirements like food, minerals and so on.
       # @return [Api::ResponseQuery]
-      def query(pathing: nil, abilities: nil, placements: nil, ignore_resource_requirements: true)
+      def query(pathing: nil, abilities: nil, placements: nil, ignore_resource_requirements: false)
         send_request_for query: Api::RequestQuery.new(
           pathing:,
           abilities:,
@@ -301,36 +302,37 @@ module Sc2
       end
 
       # Queries one or more pathing queries
-      # @param queries [Array<Api::RequestQueryPathing>, Api::RequestQueryPathing] one or more pathing queries
-      # @return [Array<Api::ResponseQueryPathing>, Api::ResponseQueryPathing] one or more results depending on input size
+      # @param queries [Array<Api::RequestQueryPathing>] one or more pathing queries
+      # @return [Array<Api::ResponseQueryPathing>] one or more results depending on input size
       def query_pathings(queries)
         arr_queries = queries.is_a?(Array) ? queries : [queries]
 
         response = send_request_for query: Api::RequestQuery.new(
           pathing: arr_queries
         )
-        (arr_queries.size > 1) ? response.pathing : response.pathing.first
+        response.pathing
       end
 
       # Queries one or more ability-available checks
-      # @param queries [Array<Api::RequestQueryAvailableAbilities>, Api::RequestQueryAvailableAbilities] one or more pathing queries
+      # @param queries [Array<Api::RequestQueryAvailableAbilities>] one or more pathing queries
       # @param ignore_resource_requirements [Boolean] Ignores requirements like food, minerals and so on.
-      # @return [Array<Api::ResponseQueryAvailableAbilities>, Api::ResponseQueryAvailableAbilities] one or more results depending on input size
-      def query_abilities(queries, ignore_resource_requirements: true)
+      # @return [Array<Api::ResponseQueryAvailableAbilities>] one or more results depending on input size
+      def query_abilities(queries, ignore_resource_requirements: false)
         arr_queries = queries.is_a?(Array) ? queries : [queries]
 
         response = send_request_for query: Api::RequestQuery.new(
           abilities: arr_queries,
           ignore_resource_requirements:
         )
-        (arr_queries.size > 1) ? response.abilities : response.abilities.first
+        response.abilities
       end
 
       # Queries available abilities for units
-      # @param unit_tags [Array<Integer>, Integer] an array of unit tags or a single tag
+      # @param unit_tags [Array<Integer>] an array of unit tags or a single tag
       # @param ignore_resource_requirements [Boolean] Ignores requirements like food, minerals and so on.
-      # @return [Array<Api::ResponseQueryAvailableAbilities>, Api::ResponseQueryAvailableAbilities] one or more results depending on input size
-      def query_abilities_for_unit_tags(unit_tags, ignore_resource_requirements: true)
+      # @return [Array<Api::ResponseQueryAvailableAbilities>] one or more results depending on input size
+      def query_abilities_for_unit_tags(unit_tags, ignore_resource_requirements: false)
+        return [] if unit_tags.nil?
         queries = []
         unit_tags = [unit_tags] unless unit_tags.is_a? Array
         unit_tags.each do |unit_tag|
@@ -340,15 +342,31 @@ module Sc2
         query_abilities(queries, ignore_resource_requirements:)
       end
 
+      # Queries available ability ids for one unit
+      # Shortened response over #query_abilities_for_unit_tags, since we know the tag already
+      # and can just return an array of ability ids.
+      # Note: Querying single units are expensive and should be batched with #query_abilities_for_unit_tags
+      # @param unit [Api::Unit, Integer] a unit or a tag.
+      # @return [Array<Integer>] array of ability ids
+      def query_ability_ids_for_unit(unit, ignore_resource_requirements: false)
+        tag = unit.is_a?(Api::Unit) ? unit.tag : unit
+        result = query_abilities_for_unit_tags([tag], ignore_resource_requirements:)
+        if result.nil?
+          []
+        else
+          result.first.abilities.map(&:ability_id)
+        end
+      end
+
       # Queries one or more pathing queries
-      # @param queries [Array<Api::RequestQueryBuildingPlacement>, Api::RequestQueryBuildingPlacement] one or more placement queries
-      # @return [Array<Api::ResponseQueryBuildingPlacement>, Api::ResponseQueryBuildingPlacement] one or more results depending on input size
+      # @param queries [Array<Api::RequestQueryBuildingPlacement>] one or more placement queries
+      # @return [Array<Api::ResponseQueryBuildingPlacement>] one or more results depending on input size
       def query_placements(queries)
         arr_queries = queries.is_a?(Array) ? queries : [queries]
 
         response = query(placements: arr_queries)
 
-        (arr_queries.size > 1) ? response.placements : response.placements.first
+        response.placements
       end
 
       # Generates a replay.

data/lib/sc2ai/data.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "api/ability_id"
+require_relative "api/unit_type_id"
+require_relative "api/upgrade_id"
+require_relative "api/buff_id"
+require_relative "api/effect_id"
+require_relative "api/tech_tree"
+
+module Sc2
+  # Holds game data from tech tree and Api::ResponseData
+  # Called once on game start
+  class Data
+    # @!attribute abilities
+    #   @return [Hash<Integer, Api::AbilityData]>]  AbilitId => AbilityData
+    attr_accessor :abilities
+    # @!attribute units
+    #   @return [Hash<Integer, Api::UnitTypeData>] UnitId => UnitData
+    attr_accessor :units
+    # @!attribute upgrades
+    #   @return [Hash<Integer, Api::UpgradeData>] UpgradeId => UpgradeData
+    attr_accessor :upgrades
+    # @!attribute buffs
+    # Not particularly useful data. Just use BuffId directly
+    #   @return [Hash<Integer, Api::UpgradeData>] BuffId => BuffData
+    attr_accessor :buffs
+    # @!attribute effects
+    # Not particularly useful data. Just use EffectId directly
+    #   @return [Hash<Integer, Api::UpgradeData>] EffectId => EffectData
+    attr_accessor :effects
+
+    # @param data [Api::ResponseData]
+    def initialize(data)
+      return unless data
+
+      @abilities = abilities_from_proto(data.abilities)
+      @units = units_from_proto(data.units)
+      @upgrades = upgrades_from_proto(data.upgrades)
+      @buffs = buffs_from_proto(data.buffs)
+      @effects = effects_from_proto(data.effects)
+    end
+
+    private
+
+    # Indexes ability data by ability id
+    # @param abilities [Array<Api::AbilityData>]
+    # @return [Hash<Integer, Api::AbilityData] indexed data
+    def abilities_from_proto(abilities)
+      result = {}
+
+      ability_ids = Api::AbilityId.constants.map { |c| Api::AbilityId.const_get(c) }
+      abilities.each do |a|
+        next if a.ability_id.zero?
+        next if ability_ids.delete(a.ability_id).nil?
+
+        result[a.ability_id] = a
+      end
+      result
+    end
+
+    # Indexes unit data by id
+    # @param units [Array<Api::UnitTypeData>]
+    # @return [Hash<Integer, Api::UnitTypeData>] indexed data
+    def units_from_proto(units)
+      result = {}
+      units.each do |u|
+        next unless u.available
+
+        result[u.unit_id] = u
+      end
+      result
+    end
+
+    # Indexes upgrades data by id
+    # @param upgrades [Array<Api::UpgradeData>]
+    # @return [Hash<Integer, Api::UpgradeData] indexed data
+    def upgrades_from_proto(upgrades)
+      result = {}
+      upgrades.each do |u|
+        result[u.upgrade_id] = u
+      end
+      result
+    end
+
+    def effects_from_proto(effects)
+      result = {}
+      effects.each do |e|
+        result[e.effect_id] = e
+      end
+      result
+    end
+
+    def buffs_from_proto(buffs)
+      result = {}
+      buffs.each do |b|
+        result[b.buff_id] = b
+      end
+      result
+    end
+  end
+end

data/lib/sc2ai/local_play/match.rb

@@ -23,8 +23,6 @@ module Sc2
       # end
     end
 
-    # TODO: DEFINE REALTIME AS A PARAM
-
     # @!attribute players Sets the Player(s) for the match
     #   @return [Array<Sc2::Player>] an array of assigned players (ai,bots,humans,observers)
     attr_accessor :players
@@ -66,7 +64,7 @@ module Sc2
         connect_players
         setup_player_hooks
 
-        player_host.create_game(map:, players: @players)
+        player_host.create_game(map:, players: @players, realtime: player_host.realtime)
 
         api_players.each_with_index do |player, player_index|
           run_task.async do

data/lib/sc2ai/player/actions.rb

@@ -45,9 +45,12 @@ module Sc2
 
         target_pos = nil
         target_unit_tag = nil
-        if target.is_a? Api::Point2D
+        case target
+        when Api::Point2D
           target_pos = target
-        elsif target.is_a? Api::Unit
+        when Api::Point
+          target_pos = target.to_p2d
+        when Api::Unit
           target_unit_tag = target.tag
         else
           target_unit_tag = target
@@ -65,7 +68,7 @@ module Sc2
 
       # Builds target unit type using units as source at optional target
       # @param units [Array<Integer>,Integer,Api::Unit] can be an Api::Unit, array of Api::Unit#tag or single tag
-      # @param unit_type_id [Integer] Api::UnitTypeId the unit type which will do the creation
+      # @param unit_type_id [Integer] Api::UnitTypeId the unit type you wish to build
       # @param target [Api::Point2D, Integer, nil] is a unit tag or a Api::Point2D. Nil for addons/orbital
       # @param queue_command [Boolean] shift+command
       def build(units:, unit_type_id:, target: nil, queue_command: false)
@@ -79,9 +82,10 @@ 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 unit_type_id [Integer] Api::UnitTypeId the unit type you wish to build
       # @param queue_command [Boolean] shift+command
       # @param target [Api::Point2D, Integer] is a unit tag or a Api::Point2D
+      # @param units [Array<Integer>, Integer, Api::Unit]
       def warp(unit_type_id:, target:, queue_command:, units: nil)
         warp_ability = Api::TechTree.unit_type_creation_abilities(
           source: Api::UnitTypeId::WARPGATE,

data/lib/sc2ai/player/debug.rb

@@ -133,7 +133,7 @@ module Sc2
       # Debug draws a sphere at position with a radius in color
       # @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
+      # @param color [Api::Color] default white
       # @return [void]
       def debug_draw_sphere(point:, radius: 1.0, color: nil)
         queue_debug_command Api::DebugCommand.new(
@@ -151,14 +151,13 @@ module Sc2
 
       # Other Commands ---
 
-      # Toggles cheat commands on/off (send only once to enable)
       # @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::All_resources
       #  Api::DebugGameState::God
       #  Api::DebugGameState::Minerals
       #  Api::DebugGameState::Gas

data/lib/sc2ai/player/game_state.rb

@@ -16,9 +16,12 @@ module Sc2
 
       extend Forwardable
 
-      # @!attribute game_loop
-      #   @return [Integer] current game loop
-      def_delegators :observation, :game_loop
+      attr_writer :game_loop
+
+      # @return [Integer] current game loop
+      def game_loop
+        @game_loop || 0
+      end
 
       # @!attribute game_info [rw]
       # Access useful game information. Used in parsed pathing grid, terrain height, placement grid.
@@ -38,7 +41,7 @@ module Sc2
       attr_accessor :game_info_loop
 
       # Determines if your game_info will be refreshed at this moment
-      # Has a hard-capped refresh of only ever 2 steps
+      # 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?
@@ -47,7 +50,7 @@ module Sc2
 
         # Note: No minimum step count set anymore
         # We can do something like, only updating every 2+ frames:
-        game_info_loop + 2 <= game_loop
+        game_info_loop + 4 <= game_loop
       end
 
       # @!attribute data
@@ -103,6 +106,34 @@ module Sc2
         @chats_received || []
       end
 
+      # @private
+      # @!attribute available_abilities_loop
+      #   This is the last loop at which available_abilities was queried.
+      #   Used to determine staleness.
+      # @return [Integer]
+      attr_accessor :available_abilities_loop
+      private :available_abilities_loop
+
+      # A Hash by unit tag, holding an array of available ability ids
+      # Synchronously calls RequestQueryAvailableAbilities and caches for this game loop.
+      # @return [Hash<Integer, Array<Integer>>] { unit_tag => [ability_id, ...], ... }
+      def available_abilities
+        # Save/check when last we refreshed abilities
+        if @available_abilities_loop != game_loop
+
+          # Query abilities for all our units + structure tags combined
+          abilities = api.query_abilities_for_unit_tags(units.tags + structures.tags, ignore_resource_requirements: false)
+          # Build the hash by unit tag
+          fresh_available_abilities = {}
+          abilities.each do |row|
+            fresh_available_abilities[row.unit_tag] = row.abilities.map(&:ability_id)
+          end
+          @available_abilities = fresh_available_abilities
+          @available_abilities_loop = game_loop
+        end
+        @available_abilities
+      end
+
       # An alias for observation.player_common to allow easier access to i.e. common.minerals
       # @return [Api::PlayerCommon] common info such as minerals, vespene, supply
       def common