natural_20 0.1.0

data/lib/natural_20/actions/help_action.rb

@@ -0,0 +1,56 @@
+# typed: true
+class HelpAction < Natural20::Action
+  attr_accessor :target
+
+  def self.can?(entity, battle)
+    battle && entity.total_actions(battle).positive?
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_target,
+                         target_types: %i[allies enemies],
+                         range: 5,
+                         num: 1,
+                       },
+                     ],
+                     next: lambda { |target|
+                       self.target = target
+                       OpenStruct.new({
+                         param: nil,
+                         next: -> { self },
+                       })
+                     },
+                   })
+  end
+
+  def self.build(session, source)
+    action = HelpAction.new(session, source, :help)
+    action.build_map
+  end
+
+  def resolve(_session, _map, opts = {})
+    @result = [{
+      source: @source,
+      target: @target,
+      type: :help,
+      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
+    end
+  end
+end

data/lib/natural_20/actions/hide_action.rb

@@ -0,0 +1,53 @@
+class HideAction < Natural20::Action
+  attr_accessor :as_bonus_action
+
+  def self.can?(entity, battle)
+    battle && entity.total_actions(battle).positive?
+  end
+
+  def build_map
+    OpenStruct.new({
+                     param: nil,
+                     next: -> { self }
+                   })
+  end
+
+  def self.build(session, source)
+    action = HideAction.new(session, source, :attack)
+    action.build_map
+  end
+
+  def resolve(_session, _map, opts = {})
+    stealth_roll = @source.stealth_check!(opts[:battle])
+    @result = [{
+      source: @source,
+      type: :hide,
+      roll: stealth_roll,
+      battle: opts[:battle]
+    }]
+    self
+  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
+
+      if as_bonus_action
+        battle.entity_state_for(item[:source])[:bonus_action] -= 1
+      else
+        battle.entity_state_for(item[:source])[:action] -= 1
+      end
+    end
+  end
+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?
+  end
+end

data/lib/natural_20/actions/interact_action.rb

@@ -0,0 +1,91 @@
+# typed: true
+class InteractAction < Natural20::Action
+  attr_accessor :target, :object_action, :other_params
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natural20::Battle]
+  def self.can?(entity, battle)
+    battle.nil? || !battle.ongoing? || entity.total_actions(battle).positive? || entity.free_object_interaction?(battle)
+  end
+
+  def self.build(session, source)
+    action = InteractAction.new(session, source, :attack)
+    action.build_map
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_object
+                       }
+                     ],
+                     next: lambda { |object|
+                       self.target = object
+                       OpenStruct.new({
+                                        param: [
+                                          {
+                                            type: :interact,
+                                            target: object
+                                          }
+                                        ],
+                                        next: lambda { |action|
+                                                self.object_action = action
+
+                                                custom_action = object.try(:build_map, action, self)
+
+                                                if custom_action.nil?
+                                                  OpenStruct.new({
+                                                                   param: nil,
+                                                                   next: lambda {
+                                                                           self
+                                                                         }
+                                                                 })
+                                                else
+                                                  custom_action
+                                                end
+                                              }
+
+                                      })
+                     }
+                   })
+  end
+
+  def resolve(_session, map = nil, opts = {})
+    battle = opts[:battle]
+
+    result = target.resolve(@source, object_action, other_params, opts)
+
+    return [] if result.nil?
+
+    result_payload = {
+      source: @source,
+      target: target,
+      object_action: object_action,
+      map: map,
+      battle: battle,
+      type: :interact
+    }.merge(result)
+    @result = [result_payload]
+    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])
+      end
+    end
+  end
+end

data/lib/natural_20/actions/inventory_action.rb

@@ -0,0 +1,23 @@
+# typed: true
+class InventoryAction < Natural20::Action
+  def self.can?(_entity, _battle)
+    true
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :show_inventory,
+                       },
+                     ],
+                     next: lambda { |_path|
+                       OpenStruct.new({
+                                              param: nil,
+                                              next: -> { self },
+                                            })
+                     },
+                   })
+  end
+end

data/lib/natural_20/actions/look_action.rb

@@ -0,0 +1,63 @@
+class LookAction < Natural20::Action
+  attr_accessor :ui_callback
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natural20::Battle]
+  def self.can?(entity, battle)
+    battle.nil? || !battle.ongoing? || battle.entity_state_for(entity)[:active_perception].zero?
+  end
+
+  def build_map
+    OpenStruct.new({
+                     param: [
+                       {
+                         type: :look,
+                         num: 1
+                       }
+                     ],
+                     next: lambda { |callback|
+                       self.ui_callback = callback
+                       OpenStruct.new({
+                                        param: nil,
+                                        next: -> { self }
+                                      })
+                     }
+                   })
+  end
+
+  def self.build(session, source)
+    action = LookAction.new(session, source, :look)
+    action.build_map
+  end
+
+  def resolve(_session, _map, opts = {})
+    perception_check = @source.perception_check!(opts[:battle])
+    perception_check_2 = @source.perception_check!(opts[:battle])
+
+    perception_check_disadvantage = [perception_check, perception_check_2].min
+    @result = [{
+      source: @source,
+      type: :look,
+      die_roll: perception_check,
+      die_roll_disadvantage: perception_check_disadvantage,
+      battle: opts[:battle]
+    }]
+    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
+    end
+  end
+end

data/lib/natural_20/actions/move_action.rb

@@ -0,0 +1,254 @@
+# typed: true
+class MoveAction < Natural20::Action
+  include Natural20::MovementHelper
+  include Natural20::ActionDamage
+
+  attr_accessor :move_path, :jump_index, :as_dash, :as_bonus_action
+
+  def self.can?(entity, battle)
+    battle.nil? || entity.available_movement(battle).positive?
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :movement
+                       }
+                     ],
+                     next: lambda { |path_and_jump_index|
+                       path, jump_index = path_and_jump_index
+                       self.move_path = path
+                       self.jump_index = jump_index
+                       OpenStruct.new({
+                                        param: nil,
+                                        next: -> { self }
+                                      })
+                     }
+                   })
+  end
+
+  def self.build(session, source)
+    action = MoveAction.new(session, source, :move)
+    action.build_map
+  end
+
+  # @param map [Natural20::BattleMap]
+  # @option opts battle [Natural20::Battle]
+  def resolve(_session, map, opts = {})
+    raise 'no path specified' if (move_path.nil? || move_path.empty?) && opts[:move_path].nil?
+
+    @result = []
+    # check for melee opportunity attacks
+    battle = opts[:battle]
+
+    current_moves = move_path.presence || opts[:move_path]
+    jumps = jump_index || []
+
+    actual_moves = []
+    additional_effects = []
+
+    movement_budget = if as_dash
+                        (@source.speed / 5).floor
+                      else
+                        (@source.available_movement(battle) / 5).floor
+                      end
+
+    movement = compute_actual_moves(@source, current_moves, map, battle, movement_budget, manual_jump: jumps)
+    actual_moves = movement.movement
+
+    actual_moves.pop while actual_moves.last && !map.placeable?(@source, *actual_moves.last, battle)
+
+    actual_moves = check_opportunity_attacks(@source, actual_moves, battle)
+
+    # check if movement requires athletics checks
+    actual_moves = check_movement_athletics(actual_moves, movement.athletics_check_locations, battle, map)
+
+    # check if movement requires dex checks, e.g. jumping and landing on difficult terrain
+    actual_moves = check_movement_acrobatics(actual_moves, movement.acrobatics_check_locations, battle)
+
+    # calculate for area based triggers
+    cutoff = false
+
+    safe_moves = []
+    actual_moves.each_with_index do |move, _index|
+      is_flying_or_jumping = movement.jump_locations.include?(move)
+      trigger_results = map.area_trigger!(@source, move, is_flying_or_jumping)
+      if trigger_results.empty?
+        safe_moves << move
+      else
+        safe_moves << move
+        additional_effects += trigger_results
+        break
+      end
+    end
+
+    movement = compute_actual_moves(@source, safe_moves, map, battle, movement_budget, manual_jump: jumps)
+
+    # compute grappled entity movement
+    if @source.grappling?
+      grappled_movement = movement.movement.dup
+      grappled_movement.pop
+
+      @source.grappling_targets.each do |grappling_target|
+        start_pos = map.entity_or_object_pos(grappling_target)
+        grappled_entity_movement = [start_pos] + grappled_movement
+
+        additional_effects << {
+          source: grappling_target,
+          map: map,
+          battle: battle,
+          type: :move,
+          path: grappled_entity_movement,
+          move_cost: 0,
+          position: grappled_entity_movement.last
+        }
+
+        grappled_movement.pop
+      end
+    end
+
+    @result << {
+      source: @source,
+      map: map,
+      battle: battle,
+      type: :move,
+      path: movement.movement,
+      move_cost: movement_budget - movement.budget,
+      position: movement.movement.last
+    }
+    @result += additional_effects
+
+    self
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param move_list [Array<Array<Integer,Integer>>]
+  # @param battle [Natural20::Battle]
+  def check_opportunity_attacks(entity, move_list, battle, grappled: false)
+    if battle && !@source.disengage?(battle)
+      opportunity_attacks = opportunity_attack_list(entity, move_list, battle, battle.map)
+      opportunity_attacks.each do |enemy_opporunity|
+        next unless enemy_opporunity[:source].has_reaction?(battle)
+        next if @source.grappling_targets.include?(enemy_opporunity[:source])
+
+        original_location = move_list[0...enemy_opporunity[:path]]
+        attack_location = original_location.last
+        battle.trigger_opportunity_attack(enemy_opporunity[:source], entity, *attack_location)
+
+        if !grappled && !entity.conscious?
+          move_list = original_location
+          break
+        end
+      end
+    end
+    move_list
+  end
+
+  def opportunity_attack_list(entity, current_moves, battle, map)
+    # get opposing forces
+    opponents = battle.opponents_of?(entity)
+    entered_melee_range = Set.new
+    left_melee_range = []
+    current_moves.each_with_index do |path, index|
+      opponents.each do |enemy|
+        entered_melee_range.add(enemy) if enemy.entered_melee?(map, entity, *path)
+        if !left_melee_range.include?(enemy) && entered_melee_range.include?(enemy) && !enemy.entered_melee?(map,
+                                                                                                             entity, *path)
+          left_melee_range << { source: enemy, path: index }
+        end
+      end
+    end
+    left_melee_range
+  end
+
+  def apply!(battle)
+    @result.each do |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,
+                                                 roll: item[:roll])
+        else
+          Natural20::EventManager.received_event(source: item[:source], event: item[:type], success: false,
+                                                 roll: item[:roll])
+          item[:source].prone!
+        end
+      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])
+
+      when :move
+        item[:map].move_to!(item[:source], *item[:position], battle)
+        if as_dash && as_bonus_action
+          battle.entity_state_for(item[:source])[:bonus_action] -= 1
+        elsif 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
+        end
+
+        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 })
+      end
+    end
+  end
+
+  private
+
+  # @param actual_moves [Array]
+  # @param dexterity_checks [Array]
+  # @param battle [Natural20::Battle]
+  # @return [Array]
+  def check_movement_acrobatics(actual_moves, dexterity_checks, battle)
+    cutoff = actual_moves.size - 1
+    actual_moves.each_with_index do |m, index|
+      next unless dexterity_checks.include?(m)
+
+      acrobatics_roll = @source.acrobatics_check!(battle)
+      if acrobatics_roll.result >= 10
+        @result << { source: @source, type: :acrobatics, success: true, roll: acrobatics_roll, location: m }
+      else
+        @result << { source: @source, type: :acrobatics, success: false, roll: acrobatics_roll, location: m }
+        cutoff = index
+        break
+      end
+    end
+    actual_moves[0..cutoff]
+  end
+
+  # @param actual_moves [Array]
+  # @param athletics_checks [Array]
+  # @param battle [Natural20::Battle]
+  # @param map [Natural20::BattleMap]
+  # @return [Array]
+  def check_movement_athletics(actual_moves, athletics_checks, battle, map)
+    cutoff = actual_moves.size - 1
+    actual_moves.each_with_index do |m, index|
+      next unless athletics_checks.include?(m)
+
+      athletics_roll = @source.athletics_check!(battle)
+      if athletics_roll.result >= 10
+        @result << { source: @source, type: :athletics, success: true, roll: athletics_roll, location: m }
+      else
+        @result << { source: @source, type: :athletics, success: false, roll: athletics_roll, location: m }
+        cutoff = index - 1
+        cutoff -= 1 while cutoff >= 0 && !map.placeable?(@source, *actual_moves[cutoff], battle)
+        break
+      end
+    end
+
+    actual_moves[0..cutoff]
+  end
+end