natural_20 0.1.1 → 0.2.0

data/lib/natural_20/actions/disengage_action.rb

@@ -22,23 +22,21 @@ class DisengageAction < Natural20::Action
     @result = [{
       source: @source,
       type: :disengage,
+      as_bonus_action: as_bonus_action,
       battle: opts[:battle]
     }]
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :disengage
-        Natural20::EventManager.received_event({ source: item[:source], event: :disengage })
-        item[:source].disengage!(battle)
-      end
-
-      if as_bonus_action
-        battle.entity_state_for(item[:source])[:bonus_action] -= 1
+  def self.apply!(battle, item)
+    case item[:type]
+    when :disengage
+      Natural20::EventManager.received_event({ source: item[:source], event: :disengage })
+      item[:source].disengage!(battle)
+      if item[:as_bonus_action]
+        battle.consume(item[:source], :bonus_action)
       else
-        battle.entity_state_for(item[:source])[:action] -= 1
+        battle.consume(item[:source], :action)
       end
     end
   end
@@ -48,6 +46,7 @@ class DisengageBonusAction < DisengageAction
   # @param entity [Natural20::Entity]
   # @param battle [Natural20::Battle]
   def self.can?(entity, battle)
-    battle && battle.combat? && entity.any_class_feature?(%w[cunning_action nimble_escape]) && entity.total_bonus_actions(battle) > 0
+    battle && battle.combat? && entity.any_class_feature?(%w[cunning_action
+                                                             nimble_escape]) && entity.total_bonus_actions(battle) > 0
   end
 end

data/lib/natural_20/actions/dodge_action.rb

@@ -22,20 +22,19 @@ class DodgeAction < Natural20::Action
     @result = [{
       source: @source,
       type: :dodge,
+      as_bonus: as_bonus_action,
       battle: opts[:battle]
     }]
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :dodge
-        Natural20::EventManager.received_event({ source: item[:source], event: :dodge })
-        item[:source].dodging!(battle)
-      end
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :dodge
+      Natural20::EventManager.received_event({ source: item[:source], event: :dodge })
+      item[:source].dodging!(battle)
 
-      if as_bonus_action
+      if item[:as_bonus_action]
         battle.entity_state_for(item[:source])[:bonus_action] -= 1
       else
         battle.entity_state_for(item[:source])[:action] -= 1

data/lib/natural_20/actions/escape_grapple_action.rb

@@ -73,25 +73,23 @@ class EscapeGrappleAction < Natural20::Action
               end
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :grapple_escape
-        if item[:success]
-          @source.escape_grapple_from!(item[:target])
-          Natural20::EventManager.received_event(event: :escape_grapple_success,
-                                                 target: item[:target], source: @source,
-                                                 source_roll: item[:source_roll],
-                                                 target_roll: item[:target_roll])
-        else
-          Natural20::EventManager.received_event(event: :escape_grapple_failure,
-                                                 target: item[:target], source: @source,
-                                                 source_roll: item[:source_roll],
-                                                 target_roll: item[:target_roll])
-        end
-
-        battle.entity_state_for(item[:source])[:action] -= 1
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :grapple_escape
+      if item[:success]
+        item[:source].escape_grapple_from!(item[:target])
+        Natural20::EventManager.received_event(event: :escape_grapple_success,
+                                               target: item[:target], source: item[:source],
+                                               source_roll: item[:source_roll],
+                                               target_roll: item[:target_roll])
+      else
+        Natural20::EventManager.received_event(event: :escape_grapple_failure,
+                                               target: item[:target], source: item[:source],
+                                               source_roll: item[:source_roll],
+                                               target_roll: item[:target_roll])
       end
+
+      battle.consume(item[:source], :action)
     end
   end
 end

data/lib/natural_20/actions/first_aid_action.rb

@@ -88,23 +88,21 @@ class FirstAidAction < Natural20::Action
               end
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :first_aid
-        if item[:success]
-          item[:target].stable!
-          Natural20::EventManager.received_event(event: :first_aid,
-                                                 target: item[:target], source: @source,
-                                                 roll: item[:roll])
-        else
-          Natural20::EventManager.received_event(event: :first_aid_failure,
-                                                 target: item[:target], source: @source,
-                                                 roll: item[:roll])
-        end
-
-        battle.entity_state_for(item[:source])[:action] -= 1
+  def self.apply!(battle, item)
+    case item[:type]
+    when :first_aid
+      if item[:success]
+        item[:target].stable!
+        Natural20::EventManager.received_event(event: :first_aid,
+                                               target: item[:target], source: item[:source],
+                                               roll: item[:roll])
+      else
+        Natural20::EventManager.received_event(event: :first_aid_failure,
+                                               target: item[:target], source: item[:source],
+                                               roll: item[:roll])
       end
+
+      battle.consume(item[:source], :action)
     end
   end
 end

data/lib/natural_20/actions/grapple_action.rb

@@ -94,25 +94,23 @@ class GrappleAction < Natural20::Action
               end
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :grapple
-        if item[:success]
-          item[:target].grappled_by!(@source)
-          Natural20::EventManager.received_event(event: :grapple_success,
-                                                 target: item[:target], source: @source,
-                                                 source_roll: item[:source_roll],
-                                                 target_roll: item[:target_roll])
-        else
-          Natural20::EventManager.received_event(event: :grapple_failure,
-                                                 target: item[:target], source: @source,
-                                                 source_roll: item[:source_roll],
-                                                 target_roll: item[:target_roll])
-        end
-
-        battle.entity_state_for(item[:source])[:action] -= 1
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :grapple
+      if item[:success]
+        item[:target].grappled_by!(item[:source])
+        Natural20::EventManager.received_event(event: :grapple_success,
+                                               target: item[:target], source: item[:source],
+                                               source_roll: item[:source_roll],
+                                               target_roll: item[:target_roll])
+      else
+        Natural20::EventManager.received_event(event: :grapple_failure,
+                                               target: item[:target], source: item[:source],
+                                               source_roll: item[:source_roll],
+                                               target_roll: item[:target_roll])
       end
+
+      battle.consume(item[:source], :action)
     end
   end
 end
@@ -169,17 +167,15 @@ class DropGrappleAction < Natural20::Action
       }]
   end
 
-  def apply!(_battle)
-    @result.each do |item|
-      case (item[:type])
-      when :drop_grapple
-        item[:target].escape_grapple_from!(@source)
-        Natural20::EventManager.received_event(event: :drop_grapple,
-                                               target: item[:target], source: @source,
-                                               source_roll: item[:source_roll],
-                                               target_roll: item[:target_roll])
+  def self.apply!(_battle, item)
+    case item[:type]
+    when :drop_grapple
+      item[:target].escape_grapple_from!(item[:source])
+      Natural20::EventManager.received_event(event: :drop_grapple,
+                                             target: item[:target], source: item[:source],
+                                             source_roll: item[:source_roll],
+                                             target_roll: item[:target_roll])
 
-      end
     end
   end
 end

data/lib/natural_20/actions/ground_interact_action.rb

@@ -59,8 +59,7 @@ class GroundInteractAction < Natural20::Action
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
+  def self.apply!(battle, item)
       entity = item[:source]
       case (item[:type])
       when :pickup
@@ -74,6 +73,5 @@ class GroundInteractAction < Natural20::Action
           battle&.consume!(entity, :free_object_interaction, 1) || battle&.consume!(entity, :action, 1)
         end
       end
-    end
   end
 end

data/lib/natural_20/actions/help_action.rb

@@ -14,16 +14,16 @@ class HelpAction < Natural20::Action
                          type: :select_target,
                          target_types: %i[allies enemies],
                          range: 5,
-                         num: 1,
-                       },
+                         num: 1
+                       }
                      ],
                      next: lambda { |target|
                        self.target = target
                        OpenStruct.new({
-                         param: nil,
-                         next: -> { self },
-                       })
-                     },
+                                        param: nil,
+                                        next: -> { self }
+                                      })
+                     }
                    })
   end
 
@@ -37,20 +37,17 @@ class HelpAction < Natural20::Action
       source: @source,
       target: @target,
       type: :help,
-      battle: opts[:battle],
+      battle: opts[:battle]
     }]
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :help
-        Natural20::EventManager.received_event({ source: item[:source], target: item[:target], event: :help })
-        item[:source].help!(item[:battle], item[:target])
-      end
-
-      battle.entity_state_for(item[:source])[:action] -= 1
+  def self.apply!(battle, item)
+    case item[:type]
+    when :help
+      Natural20::EventManager.received_event({ source: item[:source], target: item[:target], event: :help })
+      item[:source].help!(item[:battle], item[:target])
+      battle.consume!(item[:source], :action)
     end
   end
 end

data/lib/natural_20/actions/hide_action.rb

@@ -30,14 +30,11 @@ class HideAction < Natural20::Action
   end
 
   # @param battle [Natural20::Battle]
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :hide
-        Natural20::EventManager.received_event({ source: item[:source], roll: item[:roll], event: :hide })
-        item[:source].hiding!(battle, item[:roll].result)
-      end
-
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :hide
+      Natural20::EventManager.received_event({ source: item[:source], roll: item[:roll], event: :hide })
+      item[:source].hiding!(battle, item[:roll].result)
       if item[:bonus_action]
         battle.consume(item[:source], :bonus_action)
       else
@@ -49,6 +46,7 @@ end
 
 class HideBonusAction < HideAction
   def self.can?(entity, battle)
-    battle && entity.any_class_feature?(%w[cunning_action nimble_escape]) && entity.total_bonus_actions(battle).positive?
+    battle && entity.any_class_feature?(%w[cunning_action
+                                           nimble_escape]) && entity.total_bonus_actions(battle).positive?
   end
 end

data/lib/natural_20/actions/interact_action.rb

@@ -71,21 +71,19 @@ class InteractAction < Natural20::Action
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      entity = item[:source]
-      case (item[:type])
-      when :interact
-        item[:target].use!(entity, item)
-        if item[:cost] == :action
-          battle&.consume!(entity, :action, 1)
-        else
-          battle&.consume!(entity, :free_object_interaction, 1) || battle&.consume!(entity, :action, 1)
-        end
-
-        Natural20::EventManager.received_event(event: :interact, source: entity, target: item[:target],
-                                               object_action: item[:object_action])
+  def self.apply!(battle, item)
+    entity = item[:source]
+    case (item[:type])
+    when :interact
+      item[:target].use!(entity, item)
+      if item[:cost] == :action
+        battle&.consume!(entity, :action, 1)
+      else
+        battle&.consume!(entity, :free_object_interaction, 1) || battle&.consume!(entity, :action, 1)
       end
+
+      Natural20::EventManager.received_event(event: :interact, source: entity, target: item[:target],
+                                             object_action: item[:object_action])
     end
   end
 end

data/lib/natural_20/actions/look_action.rb

@@ -3,7 +3,7 @@ class LookAction < Natural20::Action
 
   # @param entity [Natural20::Entity]
   # @param battle [Natural20::Battle]
-  def self.can?(entity, battle)
+  def self.can?(entity, battle, options = {})
     battle.nil? || !battle.ongoing? || battle.entity_state_for(entity)[:active_perception].zero?
   end
 
@@ -40,24 +40,23 @@ class LookAction < Natural20::Action
       type: :look,
       die_roll: perception_check,
       die_roll_disadvantage: perception_check_disadvantage,
-      battle: opts[:battle]
+      battle: opts[:battle],
+      ui_callback: ui_callback
     }]
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :look
-        battle.entity_state_for(item[:source])[:active_perception] = item[:die_roll].result
-        battle.entity_state_for(item[:source])[:active_perception_disadvantage] = item[:die_roll_disadvantage].result
-        Natural20::EventManager.received_event({
-                                                 source: item[:source],
-                                                 perception_roll: item[:die_roll],
-                                                 event: :perception
-                                               })
-        ui_callback&.target_ui(item[:source], perception: item[:die_roll].result, look_mode: true)
-      end
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :look
+      battle.entity_state_for(item[:source])[:active_perception] = item[:die_roll].result
+      battle.entity_state_for(item[:source])[:active_perception_disadvantage] = item[:die_roll_disadvantage].result
+      Natural20::EventManager.received_event({
+                                               source: item[:source],
+                                               perception_roll: item[:die_roll],
+                                               event: :perception
+                                             })
+      item[:ui_callback]&.target_ui(item[:source], perception: item[:die_roll].result, look_mode: true)
     end
   end
 end

data/lib/natural_20/actions/move_action.rb

@@ -1,7 +1,7 @@
 # typed: true
 class MoveAction < Natural20::Action
   include Natural20::MovementHelper
-  include Natural20::ActionDamage
+  extend Natural20::ActionDamage
 
   attr_accessor :move_path, :jump_index, :as_dash, :as_bonus_action
 
@@ -101,6 +101,8 @@ class MoveAction < Natural20::Action
           battle: battle,
           type: :move,
           path: grappled_entity_movement,
+          as_dash: as_dash,
+          as_bonus_action: as_bonus_action,
           move_cost: 0,
           position: grappled_entity_movement.last
         }
@@ -113,6 +115,8 @@ class MoveAction < Natural20::Action
       source: @source,
       map: map,
       battle: battle,
+      as_dash: as_dash,
+      as_bonus_action: as_bonus_action,
       type: :move,
       path: movement.movement,
       move_cost: movement_budget - movement.budget,
@@ -140,15 +144,12 @@ class MoveAction < Natural20::Action
     move_list
   end
 
-  def apply!(battle)
-    @result.each do |item|
+  def self.apply!(battle, item)
       case (item[:type])
       when :state
         item[:params].each do |k, v|
           item[:source].send(:"#{k}=", v)
         end
-      when :damage
-        damage_event(item, battle)
       when :acrobatics, :athletics
         if item[:success]
           Natural20::EventManager.received_event(source: item[:source], event: item[:type], success: true,
@@ -167,9 +168,9 @@ class MoveAction < Natural20::Action
 
       when :move
         item[:map].move_to!(item[:source], *item[:position], battle)
-        if as_dash && as_bonus_action
+        if item[:as_dash] && item[:as_bonus_action]
           battle.entity_state_for(item[:source])[:bonus_action] -= 1
-        elsif as_dash
+        elsif item[:as_dash]
           battle.entity_state_for(item[:source])[:action] -= 1
         elsif battle
           battle.entity_state_for(item[:source])[:movement] -= item[:move_cost] * battle.map.feet_per_grid
@@ -177,9 +178,8 @@ class MoveAction < Natural20::Action
 
         Natural20::EventManager.received_event({ event: :move, source: item[:source], position: item[:position], path: item[:path],
                                                  feet_per_grid: battle.map&.feet_per_grid,
-                                                 as_dash: as_dash, as_bonus: as_bonus_action })
+                                                 as_dash: item[:as_dash], as_bonus: item[:as_bonus_action] })
       end
-    end
   end
 
   private