sc2ai 0.0.3 → 0.0.5

data/lib/sc2ai/player/debug.rb

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

data/lib/sc2ai/player/geometry.rb

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

data/lib/sc2ai/player/previous_state.rb

@@ -36,13 +36,13 @@ module Sc2
       # Override to modify the previous frame before being set to current
       # @param bot [Sc2::Player::Bot]
       def before_reset(bot)
-        # pp "### before_reset"
+        # no op
       end
 
       # Override to modify previous frame after reset is complete
       # @param bot [Sc2::Player::Bot]
       def after_reset(bot)
-        # pp "### after_reset"
+        # no op
       end
     end
   end

data/lib/sc2ai/player/units.rb

@@ -30,6 +30,53 @@ module Sc2
       #   @return [Sc2::UnitGroup] a group of neutral units
       attr_accessor :effects # not a unit
 
+      # Returns the upgrade ids you have acquired such as weapon upgrade and armor upgrade ids.
+      # Shorthand for observation.raw_data.player.upgrade_ids
+      # @!attribute [r] upgrades_completed
+      #   @return [Array<Integer>] a group of neutral units
+      def upgrades_completed = observation&.raw_data&.player&.upgrade_ids.to_a || [] # not a unit
+
+      # Returns the upgrade ids which are researching or queued
+      # Not set for enemy.
+      # @return [Array<Integer>]
+      def upgrades_in_progress
+        # We need to scan every structure which performs upgrades for any order with an upgrade ability
+
+        result = []
+        # Loop every upgrade structure
+        structures
+          .select_type(Api::TechTree.upgrade_structure_unit_type_ids)
+          .each do |structure|
+          next unless structure.is_active? # Skip idle
+
+          # Check if any order at a structure contains an upgrade ability
+          structure.orders.each do |order|
+            Api::TechTree.upgrade_ability_data(structure.unit_type).each do |upgrade_id, update_info|
+              if update_info[:ability] == order.ability_id
+                # Save the upgrade_id
+                result << upgrade_id
+              end
+            end
+          end
+        end
+
+        # If the API told use it's complete, but an order still lingers, trust the API
+        result - upgrades_completed
+      end
+
+      # Returns the upgrade ids which are researching or queued
+      # @return [Boolean]
+      def upgrade_in_progress?(upgrade_id)
+        structure_unit_type_id = Api::TechTree.upgrade_researched_from(upgrade_id: upgrade_id)
+        research_ability_id = Api::TechTree.upgrade_research_ability_id(upgrade_id: upgrade_id)
+        structures.select_type(structure_unit_type_id).each do |structure|
+          structure.orders.each do |order|
+            return true if order.ability_id == research_ability_id
+          end
+        end
+        false
+      end
+
       # An array of Protoss power sources, which have a point, radius and unit tag
       # @!attribute power_sources
       #   @return [Array<Api::PowerSource>] an array of power sources
@@ -47,10 +94,10 @@ module Sc2
 
       # Event-driven unit groups ---
 
+      # @!attribute event_units_created
       # Units created since last frame (visible only, units not structures)
       # Read this on_step. Alternative to callback on_unit_created
-      # Note: Morphed units should watch #event_units_type_changed
-      # @!attribute event_units_created
+      # @note Morphed units should watch #event_units_type_changed
       #   @return [Sc2::UnitGroup] group of created units
       attr_accessor :event_units_created
 
@@ -107,6 +154,13 @@ module Sc2
         data.abilities[ability_id]
       end
 
+      # Returns static [Api::UpgradeData] for an upgrade id
+      # @param upgrade_id [Integer] Api::UpgradeId::*
+      # @return [Api::UpgradeData]
+      def upgrade_data(upgrade_id)
+        data.upgrades[upgrade_id]
+      end
+
       # 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
@@ -141,17 +195,13 @@ module Sc2
       def subtract_cost(unit_type_id)
         unit_type_data = unit_data(unit_type_id)
 
-        # food_required is a float. ensure half units are counted as full
-        # TODO: Extend UnitTypeData message. def food_required = unit_id ==  Api::UnitTypeId::ZERGLING ? 1 : send("method_missing", :food_required)
-        supply_cost = unit_type_data.food_required
-        supply_cost = 1 if unit_type_id == Api::UnitTypeId::ZERGLING
-
         @spent_minerals += unit_type_data.mineral_cost
         @spent_vespene += unit_type_data.vespene_cost
-        @spent_supply += supply_cost
+        @spent_supply += unit_type_data.food_required
       end
 
       # Checks whether you have the resources to construct quantity of unit type
+      # @return [Boolean]
       def can_afford?(unit_type_id:, quantity: 1)
         unit_type_data = unit_data(unit_type_id)
         return false if unit_type_data.nil?
@@ -178,6 +228,25 @@ module Sc2
         true
       end
 
+      # Checks whether you have the resources to
+      # @return [Boolean]
+      def can_afford_upgrade?(upgrade_id)
+        unit_type_data = upgrade_data(upgrade_id)
+        return false if unit_type_data.nil?
+
+        mineral_cost = unit_type_data.mineral_cost
+        if common.minerals - spent_minerals < mineral_cost
+          return false # not enough minerals
+        end
+
+        vespene_cost = unit_type_data.vespene_cost
+        if common.vespene - spent_vespene < vespene_cost
+          return false # you require more vespene gas
+        end
+
+        true
+      end
+
       private
 
       # @private

data/lib/sc2ai/player.rb

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

data/lib/sc2ai/protocol/_meta_documentation.rb

@@ -21,6 +21,8 @@
 #     class Point < Google::Protobuf::AbstractMessage; end;
 #     # Protobuf virtual class.
 #     class Unit < Google::Protobuf::AbstractMessage; end;
+#     # Protobuf virtual class.
+#     class UnitTypeData < Google::Protobuf::AbstractMessage; end;
 #   end
 
 # Protobuf enums ---

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

@@ -1,6 +1,15 @@
 module Api
   # Adds additional functionality to message object Api::Point
   module PointExtension
+    # @private
+    def hash
+      [x, y, z].hash
+    end
+
+    def eql?(other)
+      self.class == other.class && hash == other.hash
+    end
+
     # Creates a Point2D using x and y
     # @return [Api::Point2D]
     def to_p2d
@@ -13,6 +22,9 @@ module Api
       # @example
       #   Api::Point[1,2,3] # Where x is 1.0, y is 2.0 and z is 3.0
       # @return [Api::Point]
+      # @param [Float] x
+      # @param [Float] y
+      # @param [Float] z
       def [](x, y, z)
         Api::Point.new(x: x, y: y, z: z)
       end
@@ -20,4 +32,4 @@ module Api
   end
 end
 Api::Point.include Api::PointExtension
-Api::Point.include Api::PointExtension::ClassMethods
+Api::Point.extend Api::PointExtension::ClassMethods

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

@@ -10,6 +10,12 @@ module Api
       self.class == other.class && hash == other.hash
     end
 
+    # Create a new 3d Point, by adding a y axis.
+    # @return [Api::Point]
+    def to_3d(z:)
+      Api::Point[x, y, z]
+    end
+
     # Adds additional functionality to message class Api::Point2D
     module ClassMethods
       # Shorthand for creating an instance for [x, y]

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

@@ -37,9 +37,8 @@ module Api
     # Checks unit data for an attribute value
     # @return [Boolean] whether unit has attribute
     # @example
-    #   has_attribute?(Api::UnitTypeId::SCV, Api::Attribute::Mechanical)
-    #   has_attribute?(units.workers.first, :Mechanical)
-    #   has_attribute?(Api::UnitTypeId::SCV, :Mechanical)
+    #   unit.has_attribute?(Api::Attribute::Mechanical)
+    #   unit.has_attribute?(:Mechanical)
     def has_attribute?(attribute)
       attributes.include? attribute
     end
@@ -179,6 +178,26 @@ module Api
       action(ability_id: Api::AbilityId::SMART, target:, queue_command:)
     end
 
+    # Shorthand for performing action MOVE
+    # @param target [Api::Unit, Integer, Api::Point2D] is a unit, unit tag or a Api::Point2D
+    # @param queue_command [Boolean] shift+command
+    def move(target:, queue_command: false)
+      action(ability_id: Api::AbilityId::MOVE, target:, queue_command:)
+    end
+
+    # Shorthand for performing action STOP
+    # @param queue_command [Boolean] shift+command
+    def stop(queue_command: false)
+      action(ability_id: Api::AbilityId::STOP, queue_command:)
+    end
+
+    # Shorthand for performing action HOLDPOSITION
+    # @param queue_command [Boolean] shift+command
+    def hold(queue_command: false)
+      action(ability_id: Api::AbilityId::HOLDPOSITION, queue_command:)
+    end
+    alias_method :hold_position, :hold
+
     # Shorthand for performing action ATTACK
     # @param target [Api::Unit, Integer, Api::Point2D] is a unit, unit tag or a Api::Point2D
     # @param queue_command [Boolean] shift+command
@@ -213,10 +232,18 @@ module Api
 
     # Issues repair command on target
     # @param target [Api::Unit, Integer] is a unit or unit tag
+    # @param queue_command [Boolean] shift+command
     def repair(target:, queue_command: false)
       action(ability_id: Api::AbilityId::EFFECT_REPAIR, target:, queue_command:)
     end
 
+    # Research a specific upgrade
+    # @param upgrade_id [Integer] Api::UnitTypeId the unit type which will do the creation
+    # @param queue_command [Boolean] shift+command
+    def research(upgrade_id:, queue_command: false)
+      @bot.research(units: self, upgrade_id:, queue_command:)
+    end
+
     # @!endgroup Actions
     #
     # Debug ----
@@ -224,6 +251,7 @@ module Api
     # Draws a placement outline
     # @param color [Api::Color] optional api color, default white
     # @return [void]
+    # noinspection RubyArgCount
     def debug_draw_placement(color = nil)
       # Slightly elevate the Z position so that the line doesn't clip into the terrain at same Z level
       z_elevated = pos.z + 0.01
@@ -432,6 +460,12 @@ module Api
       build_progress == 1.0 # standard:disable Lint/FloatComparison
     end
 
+    # Returns true if build progress is < 100%
+    # @return [Boolean]
+    def in_progress?
+      !is_completed?
+    end
+
     # Convenience functions ---
 
     # TERRAN Convenience functions ---
@@ -444,7 +478,7 @@ module Api
 
     # Returns whether the structure has a reactor add-on
     # @return [Boolean] if the unit has a reactor attached
-    def has_reactor
+    def has_reactor?
       Sc2::UnitGroup::TYPE_REACTOR.include?(add_on&.unit_type)
     end
 
@@ -455,26 +489,46 @@ module Api
     #   # Get the actual tech-lab with #add_on
     #   sp.add_on.research ...
     # @return [Boolean] if the unit has a tech lab attached
-    def has_tech_lab
+    def has_tech_lab?
       Sc2::UnitGroup::TYPE_TECHLAB.include?(add_on&.unit_type)
     end
 
     # For Terran builds a tech lab add-on on the current structure
     # @return [void]
-    def build_reactor
-      build(unit_type_id: Api::UnitTypeId::REACTOR)
+    def build_reactor(queue_command: false)
+      unit_type_id = case unit_type
+      when Api::UnitTypeId::BARRACKS, Api::UnitTypeId::BARRACKSFLYING
+        Api::UnitTypeId::BARRACKSREACTOR
+      when Api::UnitTypeId::FACTORY, Api::UnitTypeId::FACTORYFLYING
+        Api::UnitTypeId::FACTORYREACTOR
+      when Api::UnitTypeId::STARPORT, Api::UnitTypeId::STARPORTFLYING
+        Api::UnitTypeId::STARPORTREACTOR
+      end
+      build(unit_type_id: unit_type_id, queue_command:)
     end
 
     # For Terran builds a tech lab add-on on the current structure
     # @return [void]
-    def build_tech_lab
-      build(unit_type_id: Api::UnitTypeId::TECHLAB)
+    def build_tech_lab(queue_command: false)
+      unit_type_id = case unit_type
+      when Api::UnitTypeId::BARRACKS, Api::UnitTypeId::BARRACKSFLYING
+        Api::UnitTypeId::BARRACKSTECHLAB
+      when Api::UnitTypeId::FACTORY, Api::UnitTypeId::FACTORYFLYING
+        Api::UnitTypeId::FACTORYTECHLAB
+      when Api::UnitTypeId::STARPORT, Api::UnitTypeId::STARPORTFLYING
+        Api::UnitTypeId::STARPORTTECHLAB
+      end
+      build(unit_type_id: unit_type_id, queue_command:)
     end
 
+    # GENERAL Convenience functions ---
+
+    # ...
+
     private
 
     # @private
-    # Reduces repitition in the is_*action*?(target:) methods
+    # Reduces repetition in the is_*action*?(target:) methods
     def is_performing_ability_on_target?(abilities, target: nil)
       # Exit if not actioning the ability
       return false unless is_performing_ability?(abilities)

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Api
+  # Adds additional functionality to message object Api::UnitTypeData
+  module UnitTypeDataExtension
+    # @!attribute mineral_cost_sum
+    #   Sum of all morphs mineral cost
+    #   i.e. 550M Orbital command = 400M CC + 150M Upgrade
+    #   i.e. 350M Hatchery = 50M Drone + 300M Build
+    #   @return [Integer] sum of mineral costs
+    attr_accessor :mineral_cost_sum
+
+    # @!attribute vespene_cost_sum
+    #   Sum of all morphs vespene gas cost
+    #   i.e. 250G Broodlord = 100G Corruptor + 150G Morph
+    #   @return [Integer] sum of vespene gas costs
+    attr_accessor :vespene_cost_sum
+  end
+end
+Api::UnitTypeData.include Api::UnitTypeDataExtension