sc2ai 0.0.0.pre → 0.0.2

data/lib/sc2ai/player/actions.rb

@@ -0,0 +1,386 @@
+module Sc2
+  class Player
+    # Holds action list and queues batch
+    module Actions
+      # Holds actions which will be queued off each time we step forward
+      # @!attribute action_queue
+      #   @return [Array<Api::Action>]
+      attr_accessor :action_queue
+
+      # Queues action for performing end of step
+      # @param action [Api::Action]
+      # @return [void]
+      def queue_action(action)
+        @action_queue << action
+      end
+
+      # 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 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)
+        queue_action Api::Action.new(
+          action_raw: Api::ActionRaw.new(
+            unit_command: Api::ActionRawUnitCommand.new(
+              unit_tags: unit_tags,
+              ability_id: ability_id,
+              queue_command: queue_command,
+              target_world_space_pos: target_world_space_pos,
+              target_unit_tag: target_unit_tag
+            )
+          )
+        )
+      end
+
+      # Queues a Api::ActionRawUnitCommand.
+      # Send accepts a Api::Unit, tag or tags and targets Api::Point2D or unit.tag
+      # @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
+      def action(units:, ability_id:, target: nil, queue_command: false)
+        unit_tags = unit_tags_from_source(units)
+
+        target_pos = nil
+        target_unit_tag = nil
+        if target.is_a? Api::Point2D
+          target_pos = target
+        elsif target.is_a? Api::Unit
+          target_unit_tag = target.tag
+        else
+          target_unit_tag = target
+        end
+
+        # noinspection RubyMismatchedArgumentType
+        action_raw_unit_command(
+          unit_tags: unit_tags,
+          ability_id: ability_id,
+          queue_command: queue_command,
+          target_world_space_pos: target_pos,
+          target_unit_tag: target_unit_tag
+        )
+      end
+
+      # Builds target unit type using units as source at optional target
+      # @param unit_type_id [Integer] Api::UnitTypeId the unit type which will do the creation
+      # @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)
+        # Get build ability from target building type
+        action(units:,
+          ability_id: unit_data(unit_type_id).ability_id,
+          target:,
+          queue_command:)
+        subtract_cost(unit_type_id)
+      end
+
+      # 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 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(
+          source: Api::UnitTypeId::WARPGATE,
+          target: unit_type_id
+        )
+        units = structures.warpgates if units.nil?
+        action(units: units,
+          ability_id: warp_ability[:ability],
+          target:,
+          queue_command:)
+        subtract_cost(unit_type_id)
+      end
+
+      # Toggles auto-cast ability for units
+      # @param units [Array<Integer>, Integer, Api::Unit] can be an Api::Unit, array of Tags or single Tag
+      # @param ability_id [Integer]
+      # @return [void]
+      def action_raw_toggle_autocast(units:, ability_id:)
+        unit_tags = unit_tags_from_source(units)
+        queue_action Api::Action.new(
+          action_raw: Api::ActionRaw.new(
+            toggle_autocast: Api::ActionRawToggleAutocast.new(
+              ability_id: ability_id,
+              unit_tags: unit_tags
+            )
+          )
+        )
+      end
+
+      # Toggles auto-cast ability for units
+      # @param point [Api::Point]
+      # @return [void]
+      def action_raw_camera_move(point:)
+        queue_action Api::Action.new(
+          action_raw: Api::ActionRaw.new(
+            camera_move: Api::ActionRawCameraMove.new(
+              center_world_space: point
+            )
+          )
+        )
+      end
+
+      # ActionSpatial - Feature layer --------
+
+      # Issues spatial unit command. Target is either target_screen_coord or target_minimap_coord.
+      # @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
+      # @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(
+          action_raw: Api::ActionSpatial.new(
+            unit_command: Api::ActionSpatialUnitCommand.new(
+              ability_id: ability_id,
+              target_screen_coord: target_screen_coord,
+              target_minimap_coord: target_minimap_coord,
+              queue_command: queue_command
+            )
+          )
+        )
+      end
+
+      # Simulates a click on the minimap to move the camera.
+      # @param center_minimap [Api::Point2I]
+      # @return [void]
+      #
+      def action_spatial_camera_move(center_minimap:)
+        queue_action Api::Action.new(
+          action_feature_layer: Api::ActionSpatial.new(
+            camera_move: Api::ActionSpatialCameraMove.new(
+              center_minimap: center_minimap
+            )
+          )
+        )
+      end
+
+      # Issues spatial unit select point command. Target is either target_screen_coord or target_minimap_coord.
+      # @param type [Integer] 1,2,3,4 = Api::ActionSpatialUnitSelectionPoint::Type::*
+      #   enum Type {
+      #     Select = 1;         // Equivalent to normal click. Changes selection to unit.
+      #     Toggle = 2;         // Equivalent to shift+click. Toggle selection of unit.
+      #     AllType = 3;        // Equivalent to control+click. Selects all units of a given type.
+      #     AddAllType = 4;     // Equivalent to shift+control+click. Selects all units of a given type.
+      #   }
+      # @param selection_screen_coord [Api::PointI]
+      # @return [void]
+      def action_spatial_unit_selection_point(type: Api::ActionSpatialUnitSelectionPoint::Type::Select, selection_screen_coord: nil)
+        queue_action Api::Action.new(
+          action_feature_layer: Api::ActionSpatial.new(
+            unit_selection_point: Api::ActionSpatialUnitSelectionPoint.new(
+              type: type,
+              selection_screen_coord: selection_screen_coord
+            )
+          )
+        )
+      end
+
+      # Issue rectangle select
+      # @param selection_screen_coord [Api::RectangleI] rectangle coordinates
+      # @param selection_add [Boolean] default false Equivalent to shift+drag. Adds units to selection. default false
+      # @return [void]
+      def action_spatial_unit_selection_rect(selection_screen_coord:, selection_add: false)
+        queue_action Api::Action.new(
+          action_feature_layer: Api::ActionSpatial.new(
+            unit_selection_rect: Api::ActionSpatialUnitSelectionRect.new(
+              selection_screen_coord: selection_screen_coord,
+              selection_add: selection_add
+            )
+          )
+        )
+      end
+
+      # ActionUI - Feature layer --------
+
+      # Perform action on control group like setting or recalling, use in conjunction with unit selection.
+      # Populated if Feature Layer or Render interface is enabled.
+      # @param action [Integer] 1-5 = Api::ActionControlGroup::ControlGroupAction::*
+      #   enum ControlGroupAction {
+      #     Recall = 1;             // Equivalent to number hotkey. Replaces current selection with control group.
+      #     Set = 2;                // Equivalent to Control + number hotkey. Sets control group to current selection.
+      #     Append = 3;             // Equivalent to Shift + number hotkey. Adds current selection into control group.
+      #     SetAndSteal = 4;        // Equivalent to Control + Alt + number hotkey. Sets control group to current selection. Units are removed from other control groups.
+      #     AppendAndSteal = 5;     // Equivalent to Shift + Alt + number hotkey. Adds current selection into control group. Units are removed from other control groups.
+      #   }
+      # @param control_group_index [Integer] 0-9
+      # @return [void]
+      def action_ui_control_group(action:, control_group_index:)
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            control_group: Api::ActionControlGroup.new(
+              action: action,
+              control_group_index: control_group_index
+            )
+          )
+        )
+      end
+
+      # Selects army (F2)
+      # @param selection_add [Boolean] default false To add to other selected items
+      # @return [void]
+      def action_ui_select_army(selection_add: false)
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            select_army: Api::ActionSelectArmy.new(
+              selection_add: selection_add
+            )
+          )
+        )
+      end
+
+      # Selects warp gates (Protoss)
+      # @param selection_add [Boolean] default false To add to other selected items
+      # @return [void]
+      def action_ui_select_warp_gates(selection_add: false)
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            select_warp_gates: Api::ActionSelectWarpGates.new(
+              selection_add: selection_add
+            )
+          )
+        )
+      end
+
+      # Selects larva (Zerg)
+      # @return [void]
+      def action_ui_select_larva
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            select_larva: Api::ActionSelectLarva.new
+          )
+        )
+      end
+
+      # Select idle workers
+      # @param type [Integer] 1-4 = Api::ActionSelectIdleWorker::Type::*
+      #
+      #   enum Type {
+      #     Set = 1;        // Equivalent to click with no modifiers. Replaces selection with single idle worker.
+      #     Add = 2;        // Equivalent to shift+click. Adds single idle worker to current selection.
+      #     All = 3;        // Equivalent to control+click. Selects all idle workers.
+      #     AddAll = 4;     // Equivalent to shift+control+click. Adds all idle workers to current selection.
+      #   }
+      def action_ui_select_idle_worker(type:)
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            select_idle_worker: Api::ActionSelectIdleWorker.new(
+              type: type
+            )
+          )
+        )
+      end
+
+      # Multi-panel actions for select/deselect
+      # @param type [Integer] 1-4 = Api::ActionMultiPanel::Type::*
+      # @param unit_index [Integer] n'th unit on panel
+      #   enum Type {
+      #     SingleSelect = 1;         // Click on icon
+      #     DeselectUnit = 2;         // Shift Click on icon
+      #     SelectAllOfType = 3;      // Control Click on icon.
+      #     DeselectAllOfType = 4;    // Control+Shift Click on icon.
+      #   }
+      # message ActionMultiPanel {
+      #   optional Type type = 1;
+      #   optional int32 unit_index = 2;
+      # }
+      def action_ui_multi_panel(type:, unit_index:)
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            multi_panel: Api::ActionMultiPanel.new(
+              type: type,
+              unit_index: unit_index
+            )
+          )
+        )
+      end
+
+      # Cargo panel actions for unloading units.
+      # @param unit_index [Integer] index of unit to unload
+      def action_ui_cargo_panel_unload(unit_index:)
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            cargo_panel: Api::ActionCargoPanelUnload.new(
+              unit_index: unit_index
+            )
+          )
+        )
+      end
+
+      # Remove unit from production queue
+      # @param unit_index [Integer] target unit index
+      def action_ui_production_panel_remove_from_queue(unit_index:)
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            production_panel: Api::ActionProductionPanelRemoveFromQueue.new(
+              unit_index: unit_index
+            )
+          )
+        )
+      end
+
+      # Toggle autocast on selected unit. Also possible with raw actions using a unit target.
+      # @param ability_id [Integer] Api::AbilityId::* ability
+      def action_ui_toggle_autocast(ability_id:)
+        queue_action Api::Action.new(
+          action_ui: Api::ActionUI.new(
+            toggle_autocast: Api::ActionToggleAutocast.new(
+              unit_index: ability_id
+            )
+          )
+        )
+      end
+
+      # Generic --------
+
+      # Send a chat message
+      # @param message [String] to send
+      # @param channel [Integer] 1-2, default:Team  Api::ActionChat::Channel::Broadcast = 1, Api::ActionChat::Channel::Team = 2
+      def action_chat(message, channel: Api::ActionChat::Channel::Team)
+        queue_action Api::Action.new(
+          action_chat: Api::ActionChat.new(
+            channel: channel,
+            message: message.to_s
+          )
+        )
+      end
+
+      private
+
+      # Sends actions via api and flushes action_queue
+      def perform_actions
+        # request_actions = []
+        # @action_queue.each do |queue_type, actions|
+        #   request_actions.push(actions)
+        # end
+
+        @api.action(@action_queue) unless @action_queue.empty?
+        clear_action_queue
+      end
+
+      # Empties and resets @action_queue
+      # @return [void]
+      def clear_action_queue
+        @action_queue = []
+        # TYPES.each do |type|
+        #   @action_queue[type] = []
+        # end
+      end
+
+      # Returns an array of unit tags from a variety of sources
+      # @param source [Integer, Array<Integer>, Api::Unit, Sc2::UnitGroup] unit tag, tags, unit or unit group
+      # @return [Array<Integer>] unit tag array
+      # noinspection RubyMismatchedReturnType
+      def unit_tags_from_source(source)
+        return [] if source.nil?
+        return [source.tag] if source.is_a? Api::Unit
+        return source.tags if source.is_a? Sc2::UnitGroup
+        return [source] unless source.is_a? Array
+
+        source
+      end
+    end
+  end
+end

data/lib/sc2ai/player/debug.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Sc2
+  class Player
+    # WARNING! Debug methods will not be available on Ladder
+    # This provides debug helper functions for RequestDebug
+    module Debug
+      # Holds debug commands which will be queued off each time we step forward
+      # @!attribute debug_commands_queue
+      #   @return [Array<Api::Action>]
+      attr_accessor :debug_command_queue
+
+      # Queues debug command for performing later
+      # @param debug_command [Api::DebugCommand]
+      # @return [void]
+      def queue_debug_command(debug_command)
+        @debug_command_queue << debug_command
+      end
+
+      # Draw Commands ---
+
+      # Prints debug text top left corner
+      # @param text [String] will respect newlines
+      # @param size [Size] of font, default 14px
+      # @return [void]
+      def debug_print(text, size: 14)
+        queue_debug_command Api::DebugCommand.new(
+          draw: Api::DebugDraw.new(
+            text: [
+              Api::DebugText.new(
+                text:,
+                size:,
+                virtual_pos: Api::Point.new(x: 0.01, y: 0.01) # unit or fixed position.
+              )
+            ]
+          )
+        )
+      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
+      # @param color [Api::Color] default white
+      # @return [void]
+      def debug_draw_line(p0:, p1:, color: nil)
+        queue_debug_command Api::DebugCommand.new(
+          draw: Api::DebugDraw.new(
+            lines: [
+              Api::DebugLine.new(
+                color:,
+                line: Api::Line.new(
+                  p0:,
+                  p1:
+                )
+              )
+            ]
+          )
+        )
+      end
+
+      # Draws a box around position xy at base of z. Good for structure boxing.
+      # @example
+      #   # 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
+      # @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
+      # @return [void]
+      def debug_draw_box(point:, radius: 0.5, color: nil)
+        queue_debug_command Api::DebugCommand.new(
+          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),
+                color:
+              )
+            ]
+          )
+        )
+      end
+
+      # 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
+      # @return [void]
+      def debug_draw_sphere(point:, radius: 1.0, color: nil)
+        queue_debug_command Api::DebugCommand.new(
+          draw: Api::DebugDraw.new(
+            spheres: [
+              Api::DebugSphere.new(
+                p: point,
+                r: radius,
+                color:
+              )
+            ]
+          )
+        )
+      end
+
+      # 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::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(
+          game_state: command
+        )
+      end
+
+      # Spawns a quantity of units under an owner at position given
+      # @param unit_type_id [Integer] Api::UnitTypeId::*
+      # @param owner [Integer] typically you are 1 and 2 is enemy (see @common.player_id)
+      # @param pos [Api::Point2D] position in 2d
+      # @param quantity [Integer] default 1
+      # @return [void]
+      def debug_create_unit(unit_type_id:, owner:, pos:, quantity: 1)
+        queue_debug_command Api::DebugCommand.new(
+          create_unit: Api::DebugCreateUnit.new(
+            unit_type: unit_type_id,
+            owner:,
+            pos:,
+            quantity:
+          )
+        )
+      end
+
+      # Kills a target unit or unit tag
+      # @param unit_tags [Integer, Array<Integer>] one or many unit tags to kill
+      # @return [void]
+      def debug_kill_unit(unit_tags:)
+        unit_tags = [unit_tags] if unit_tags.is_a? Integer
+        queue_debug_command Api::DebugCommand.new(
+          kill_unit: Api::DebugKillUnit.new(
+            tag: unit_tags
+          )
+        )
+      end
+
+      # @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 delay_ms [Integer] default 0, how long this test is delayed
+      # @return [void]
+      def debug_test_process(test:, delay_ms: 0)
+        queue_debug_command Api::DebugCommand.new(
+          test_process: Api::DebugTestProcess.new(
+            test:,
+            delay_ms:
+          )
+        )
+      end
+
+      # @private
+      # Useful only for single-player "curriculum" maps
+      # @param score [Float] sets the score
+      def debug_set_score(score: 0.0)
+        queue_debug_command Api::DebugCommand.new(
+          score: Api::DebugSetScore.new(
+            score:
+          )
+        )
+      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
+      # @return [void]
+      def debug_end_game(end_result:)
+        queue_debug_command Api::DebugCommand.new(
+          end_game: Api::DebugEndGame.new(
+            end_result:
+          )
+        )
+      end
+
+      # Sets unit_value Energy, Life or Shields for a specific unit tag to given value
+      # @param unit_tag [Integer]
+      # @param unit_value [Integer] 1=Energy,2=Life,3=Shields one of Api::DebugSetUnitValue::UnitValue::*
+      # @param value [Float] the value which the attribute will be set to
+      # @return [void]
+      def debug_set_unit_value(unit_tag:, unit_value:, value:)
+        queue_debug_command Api::DebugCommand.new(
+          unit_value: Api::DebugSetUnitValue.new(
+            unit_tag:,
+            unit_value:, # property
+            value: # value
+          )
+        )
+      end
+
+      private
+
+      # Sends actions via api and flushes debug_commands_queue
+      def perform_debug_commands
+        @api.debug(@debug_command_queue) unless @debug_command_queue.empty?
+        clear_debug_command_queue
+      end
+
+      # Empties and resets @debug_queue
+      # @return [void]
+      def clear_debug_command_queue
+        @debug_command_queue = []
+      end
+    end
+  end
+end