natural_20 0.1.1 → 0.2.0

data/lib/natural_20/actions/multiattack_action.rb

@@ -9,7 +9,7 @@ class MultiattackAction < Natural20::Action
   def build_map
     OpenStruct.new({
                      param: nil,
-                     next: -> { self },
+                     next: -> { self }
                    })
   end
 
@@ -22,20 +22,19 @@ class MultiattackAction < Natural20::Action
     @result = [{
       source: @source,
       type: :multiattack,
-      battle: opts[:battle],
+      battle: opts[:battle]
     }]
     self
   end
 
   # @param battle [Natural20::Battle]
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :multiattack
-        @total_attacks += 2
-      end
-
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :multiattack
+      @total_attacks += 2
       battle.consume!(:action, 1)
     end
+
+
   end
 end

data/lib/natural_20/actions/prone_action.rb

@@ -27,12 +27,10 @@ class ProneAction < Natural20::Action
     self
   end
 
-  def apply!(_battle)
-    @result.each do |item|
-      case (item[:type])
-      when :prone
-        item[:source].prone!
-      end
+  def apply!(_battle, item)
+    case (item[:type])
+    when :prone
+      item[:source].prone!
     end
   end
 end

data/lib/natural_20/actions/short_rest_action.rb

@@ -39,15 +39,14 @@ class ShortRestAction < Natural20::Action
   end
 
   # @param battle [Natural20::Battle]
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :short_rest
-        Natural20::EventManager.received_event({ source: item[:source], event: :short_rest, targets: item[:targets] })
-        item[:targets].each do |entity|
-          entity.short_rest!(battle, prompt: true)
-        end
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :short_rest
+      Natural20::EventManager.received_event({ source: item[:source], event: :short_rest, targets: item[:targets] })
+      item[:targets].each do |entity|
+        entity.short_rest!(battle, prompt: true)
       end
+      battle.session.increment_game_time!(60 * 60) # increment by an hour
     end
   end
 end

data/lib/natural_20/actions/shove_action.rb

@@ -107,33 +107,29 @@ class ShoveAction < Natural20::Action
               end
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :damage
-        damage_event(item, battle)
-      when :shove
-        if item[:success]
-          if item[:knock_prone]
-            item[:target].prone!
-          elsif item[:shove_loc]
-            item[:battle].map.move_to!(item[:target], *item[:shove_loc], battle)
-          end
-
-          Natural20::EventManager.received_event(event: :shove_success,
-                                                 knock_prone: item[:knock_prone],
-                                                 target: item[:target], source: item[:source],
-                                                 source_roll: item[:source_roll],
-                                                 target_roll: item[:target_roll])
-        else
-          Natural20::EventManager.received_event(event: :shove_failure,
-                                                 target: item[:target], source: item[:source],
-                                                 source_roll: item[:source_roll],
-                                                 target_roll: item[:target_roll])
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :shove
+      if item[:success]
+        if item[:knock_prone]
+          item[:target].prone!
+        elsif item[:shove_loc]
+          item[:battle].map.move_to!(item[:target], *item[:shove_loc], battle)
         end
 
-        battle.entity_state_for(item[:source])[:action] -= 1
+        Natural20::EventManager.received_event(event: :shove_success,
+                                               knock_prone: item[:knock_prone],
+                                               target: item[:target], source: item[:source],
+                                               source_roll: item[:source_roll],
+                                               target_roll: item[:target_roll])
+      else
+        Natural20::EventManager.received_event(event: :shove_failure,
+                                               target: item[:target], source: item[:source],
+                                               source_roll: item[:source_roll],
+                                               target_roll: item[:target_roll])
       end
+
+      battle.entity_state_for(item[:source])[:action] -= 1
     end
   end
 end

data/lib/natural_20/actions/spell_action.rb

@@ -0,0 +1,89 @@
+class SpellAction < Natural20::Action
+  extend Natural20::ActionDamage
+
+  attr_accessor :target, :spell_action, :spell, :other_params, :at_level
+
+  def self.can?(entity, battle, options = {})
+    return false unless entity.has_spells?
+
+    battle.nil? || !battle.ongoing? || can_cast?(entity, battle, options[:spell])
+  end
+
+  # @param battle [Natural20::Battle]
+  # @param spell [Symbol]
+  def self.can_cast?(entity, battle, spell)
+    return true unless spell
+
+    spell_details = battle.session.load_spell(spell)
+    amt, resource = spell_details[:casting_time].split(':')
+
+    return true if resource == ('action') && battle.total_actions(entity).positive?
+
+    false
+  end
+
+  def self.build(session, source)
+    action = SpellAction.new(session, source, :spell)
+    action.build_map
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_spell
+                       }
+                     ],
+                     next: lambda { |spell_choice|
+                             spell, at_level = spell_choice
+                             @spell = session.load_spell(spell)
+                             raise "spell not found #{spell}" unless @spell
+
+                             self.at_level = at_level
+                             @spell_action = @spell[:spell_class].constantize.new(@source, spell, @spell)
+                             @spell_action.build_map(self)
+                           }
+                   })
+  end
+
+  def resolve(_session, _map = nil, opts = {})
+    battle = opts[:battle]
+    @result = spell_action.resolve(@source, battle, self)
+    self
+  end
+
+  def self.apply!(battle, item)
+    Natural20::Spell.descendants.each do |klass|
+      klass.apply!(battle, item)
+    end
+    case item[:type]
+    when :spell_damage
+      damage_event(item, battle)
+      consume_resource(battle, item)
+    when :spell_miss
+      consume_resource(battle, item)
+      Natural20::EventManager.received_event({ attack_roll: item[:attack_roll],
+                                               attack_name: item[:attack_name],
+                                               advantage_mod: item[:advantage_mod],
+                                               as_reaction: !!item[:as_reaction],
+                                               adv_info: item[:adv_info],
+                                               source: item[:source], target: item[:target], event: :miss })
+    end
+  end
+
+  # @param battle [Natural20::Battle]
+  # @param item [Hash]
+  def self.consume_resource(battle, item)
+    amt, resource = item.dig(:spell, :casting_time).split(':')
+    spell_level = item.dig(:spell, :level)
+    case resource
+    when 'action'
+      battle.consume(item[:source], :action)
+    when 'reaction'
+      battle.consume(item[:source], :reaction)
+    end
+
+    item[:source].consume_spell_slot!(spell_level) if spell_level.positive?
+  end
+end

data/lib/natural_20/actions/stand_action.rb

@@ -29,13 +29,11 @@ class StandAction < Natural20::Action
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :stand
-        item[:source].stand!
-        battle.entity_state_for(item[:source])[:movement] -= (item[:source].speed / 2).floor
-      end
+  def apply!(battle, item)
+    case (item[:type])
+    when :stand
+      item[:source].stand!
+      battle.consume(item[:source], :movement, (item[:source].speed / 2).floor)
     end
   end
 

data/lib/natural_20/actions/use_item_action.rb

@@ -43,15 +43,13 @@ class UseItemAction < Natural20::Action
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :use_item
-        Natural20::EventManager.received_event({ event: :use_item, source: item[:source], item: item[:item] })
-        item[:item].use!(item[:target], item)
-        item[:source].deduct_item(item[:item].name, 1) if item[:item].consumable?
-        battle.entity_state_for(item[:source])[:action] -= 1 if battle
-      end
+  def self.apply!(battle, item)
+    case item[:type]
+    when :use_item
+      Natural20::EventManager.received_event({ event: :use_item, source: item[:source], item: item[:item] })
+      item[:item].use!(item[:target], item)
+      item[:source].deduct_item(item[:item].name, 1) if item[:item].consumable?
+      battle.entity_state_for(item[:source])[:action] -= 1 if battle
     end
   end
 end

data/lib/natural_20/ai_controller/standard.rb

@@ -205,7 +205,7 @@ module AiController
         if has_ranged_weapon?(entity)
           range_weight = 2.0
         else
-          melee_weight = 2.0
+          melee_weight = 2.1
         end
 
         # defense_weight = 2.0 if (entity.hp / entity.max_hp) < 0.25

data/lib/natural_20/battle.rb

@@ -337,7 +337,7 @@ module Natural20
     end
 
     # consume action resource and return if something changed
-    def consume!(entity, resource, qty)
+    def consume!(entity, resource, qty = 1)
       current_qty = entity_state_for(entity)[resource.to_sym]
       new_qty = [0, current_qty - qty].max
       entity_state_for(entity)[resource.to_sym] = new_qty
@@ -505,7 +505,11 @@ module Natural20
       return if action.nil?
 
       # check_action_serialization(action)
-      action.apply!(self)
+      action.result.each do |item|
+        Natural20::Action.descendants.each do |klass|
+          klass.apply!(self, item)
+        end
+      end
 
       case action.action_type
       when :move
@@ -528,6 +532,7 @@ module Natural20
     # @param resouce [Symbol]
     def consume(entity, resource, qty = 1)
       raise 'invalid resource' unless %i[action reaction bonus_action movement].include?(resource.to_sym)
+      return unless entity_state_for(entity)
 
       entity_state_for(entity)[resource.to_sym] = [0, entity_state_for(entity)[resource.to_sym] - qty].max
     end
@@ -535,7 +540,7 @@ module Natural20
     protected
 
     def t(key, options = {})
-      I18n.t(key, options)
+      I18n.t(key, **options)
     end
 
     def check_action_serialization(action)

data/lib/natural_20/cli/action_ui.rb

@@ -0,0 +1,180 @@
+module Natural20::ActionUI
+  TTY_PROMPT_PER_PAGE = 20
+
+  # Show action UI
+  # @param action [Natural20::Action]
+  # @param entity [Entity]
+  def action_ui(action, entity)
+    return :stop if action == :stop
+
+    cont = action.build_map
+    loop do
+      param = cont.param&.map do |p|
+        case (p[:type])
+        when :look
+          self
+        when :movement
+          move_path, jump_index = move_ui(entity, p)
+          return nil if move_path.nil?
+
+          [move_path, jump_index]
+        when :target, :select_target
+          targets = attack_ui(entity, action, p)
+          return nil if targets.nil? || targets.empty?
+
+          p[:num] > 1 ? targets : targets.first
+        when :select_spell
+          spell_slots_ui(entity)
+
+          spell = prompt.select("#{entity.name} cast Spell", per_page: TTY_PROMPT_PER_PAGE) do |q|
+            spell_choice(entity, battle, q)
+            q.choice t(:back).colorize(:blue), :back
+          end
+
+          return nil if spell == :back
+
+          spell
+        when :select_weapon
+          action.using || action.npc_action
+        when :select_item
+          item = prompt.select("#{entity.name} use item", per_page: TTY_PROMPT_PER_PAGE) do |menu|
+            entity.usable_items.each do |d|
+              if d[:consumable]
+                menu.choice "#{d[:label].colorize(:blue)} (#{d[:qty]})", d[:name]
+              else
+                menu.choice d[:label].colorize(:blue).to_s, d[:name]
+              end
+            end
+            menu.choice t(:back).colorize(:blue), :back
+          end
+
+          return nil if item == :back
+
+          item
+        when :select_ground_items
+          selected_items = prompt.multi_select("Items on the ground around #{entity.name}") do |menu|
+            map.items_on_the_ground(entity).each do |ground_item|
+              ground, items = ground_item
+              items.each do |t|
+                item_label = t("object.#{t.label}", default: t.label)
+                menu.choice t('inventory.inventory_items', name: item_label, qty: t.qty), [ground, t]
+              end
+            end
+          end
+
+          return nil if selected_items.empty?
+
+          item_selection = {}
+          selected_items.each do |s_item|
+            ground, item = s_item
+
+            qty = how_many?(item)
+            item_selection[ground] ||= []
+            item_selection[ground] << [item, qty]
+          end
+
+          item_selection.map do |k, v|
+            [k, v]
+          end
+        when :select_object
+          target_objects = entity.usable_objects(map, battle)
+          item = prompt.select("#{entity.name} interact with") do |menu|
+            target_objects.each do |d|
+              menu.choice d.name.humanize.to_s, d
+            end
+            menu.choice t(:manual_target), :manual_target
+            menu.choice t(:back).colorize(:blue), :back
+          end
+
+          return nil if item == :back
+
+          if item == :manual_target
+            item = target_ui(entity, num_select: 1, validation: lambda { |selected|
+              selected_entities = map.thing_at(*selected)
+
+              return false if selected_entities.empty?
+
+              selected_entities.detect do |selected_entity|
+                target_objects.include?(selected_entity)
+              end
+            }).first
+          end
+
+          item
+        when :select_items
+          selected_items = prompt.multi_select(p[:label], per_page: TTY_PROMPT_PER_PAGE) do |menu|
+            p[:items].each do |m|
+              item_label = t("object.#{m.label}", default: m.label)
+              if m.try(:equipped)
+                menu.choice t('inventory.equiped_items', name: item_label), m
+              else
+                menu.choice t('inventory.inventory_items', name: item_label, qty: m.qty), m
+              end
+            end
+            menu.choice t(:back).colorize(:blue), :back
+          end
+
+          return nil if selected_items.include?(:back)
+
+          selected_items = selected_items.map do |m|
+            count = how_many?(m)
+            [m, count]
+          end
+          selected_items
+        when :interact
+          object_action = prompt.select("#{entity.name} will") do |menu|
+            interactions = p[:target].available_interactions(entity)
+            class_key = p[:target].class.to_s
+            if interactions.is_a?(Array)
+              interactions.each do |k|
+                menu.choice t(:"object.#{class_key}.#{k}", default: k.to_s.humanize), k
+              end
+            else
+              interactions.each do |k, options|
+                label = options[:label] || t(:"object.#{class_key}.#{k}", default: k.to_s.humanize)
+                if options[:disabled]
+                  menu.choice label, k, disabled: options[:disabled_text]
+                else
+                  menu.choice label, k
+                end
+              end
+            end
+            menu.choice 'Back', :back
+          end
+
+          return nil if item == :back
+
+          object_action
+        when :show_inventory
+          inventory_ui(entity)
+        else
+          raise "unknown #{p[:type]}"
+        end
+      end
+      cont = cont.next.call(*param)
+      break if param.nil?
+    end
+    @action = cont
+  end
+
+  def spell_choice(entity, battle, menu)
+    entity.available_spells(battle).each do |k, details|
+      available_levels = if details[:higher_level]
+                           (details[:level]..9).select { |lvl| entity.max_spell_slots(lvl).positive? }
+                         else
+                           [details[:level]]
+                         end
+      available_levels.each do |spell_level|
+        level_str = spell_level.zero? ? 'cantrip' : "lvl. #{spell_level}"
+        choice_label = t(:"action.spell_choice", spell: t("spell.#{k}"), level: level_str,
+                                                description: details[:description])
+        if details[:disabled].empty?
+          menu.choice(choice_label, [k, spell_level])
+        else
+          disable_reason = details[:disabled].map { |d| t("spells.disabled.#{d}") }.join(', ')
+          menu.choice(choice_label, k, disabled: disable_reason)
+        end
+      end
+    end
+  end
+end