natural_20 0.1.0

data/lib/natural_20/actions/dodge_action.rb

@@ -0,0 +1,45 @@
+# typed: true
+class DodgeAction < 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 = DodgeAction.new(session, source, :attack)
+    action.build_map
+  end
+
+  def resolve(_session, _map, opts = {})
+    @result = [{
+      source: @source,
+      type: :dodge,
+      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
+
+      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

data/lib/natural_20/actions/escape_grapple_action.rb

@@ -0,0 +1,97 @@
+class EscapeGrappleAction < Natural20::Action
+  attr_accessor :target
+
+  def self.can?(entity, battle, _options = {})
+    entity.grappled? && (battle.nil? || entity.total_actions(battle).positive?)
+  end
+
+  def to_s
+    @action_type.to_s.humanize
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_target,
+                         targets: @source.grapples,
+                         num: 1
+                       }
+                     ],
+                     next: lambda { |target|
+                       self.target = target
+                       OpenStruct.new({
+                                        param: nil,
+                                        next: -> { self }
+                                      })
+                     }
+                   })
+  end
+
+  def self.build(session, source)
+    action = EscapeGrappleAction.new(session, source, :escape_grapple)
+    action.build_map
+  end
+
+  # Build the attack roll information
+  # @param session [Natural20::Session]
+  # @param map [Natural20::BattleMap]
+  # @option opts battle [Natural20::Battle]
+  # @option opts target [Natural20::Entity]
+  def resolve(_session, _map, opts = {})
+    battle = opts[:battle]
+    target = @source.grapples.first
+
+    strength_roll = target.athletics_check!(battle)
+    athletics_stats = (@source.athletics_proficient? ? @source.proficiency_bonus : 0) + @source.str_mod
+    acrobatics_stats = (@source.acrobatics_proficient? ? @source.proficiency_bonus : 0) + @source.dex_mod
+
+    contested_roll = athletics_stats > acrobatics_stats ? @source.athletics_check!(battle) : @source.acrobatics_check!(battle)
+    grapple_success = strength_roll.result >= contested_roll.result
+
+    @result = if grapple_success
+                [{
+                  source: @source,
+                  target: target,
+                  type: :grapple_escape,
+                  success: true,
+                  battle: battle,
+                  source_roll: contested_roll,
+                  target_roll: strength_roll
+                }]
+              else
+                [{
+                  source: @source,
+                  target: target,
+                  type: :grapple_escape,
+                  success: false,
+                  battle: battle,
+                  source_roll: contested_roll,
+                  target_roll: strength_roll
+                }]
+              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
+      end
+    end
+  end
+end

data/lib/natural_20/actions/first_aid_action.rb

@@ -0,0 +1,109 @@
+class FirstAidAction < Natural20::Action
+  attr_accessor :target
+
+  def self.can?(entity, battle, _options = {})
+    (battle.nil? || entity.total_actions(battle).positive?) && unconscious_targets(entity, battle).size.positive?
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natural20::Battle]
+  def self.unconscious_targets(entity, battle)
+    return [] unless battle
+
+    adjacent_squares = entity.melee_squares(battle.map, adjacent_only: true)
+    entities = []
+    adjacent_squares.select do |pos|
+      entity_pos = battle.map.entity_at(*pos)
+      next unless entity_pos
+      next if entity_pos == entity
+      next unless battle.map.can_see?(entity, entity_pos)
+
+      entities << entity_pos if entity_pos.unconscious? && !entity_pos.stable? && !entity_pos.dead?
+    end
+    entities
+  end
+
+  def to_s
+    @action_type.to_s.humanize
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_target,
+                         range: 5,
+                         target_types: %i[enemies allies],
+                         filter: 'state:unconscious & state:!stable & state:!dead',
+                         num: 1
+                       }
+                     ],
+                     next: lambda { |target|
+                       self.target = target
+                       OpenStruct.new({
+                                        param: nil,
+                                        next: -> { self }
+                                      })
+                     }
+                   })
+  end
+
+  def self.build(session, source)
+    action = FirstAidAction.new(session, source, :grapple)
+    action.build_map
+  end
+
+  # Build the attack roll information
+  # @param session [Natural20::Session]
+  # @param map [Natural20::BattleMap]
+  # @option opts battle [Natural20::Battle]
+  # @option opts target [Natural20::Entity]
+  def resolve(_session, _map, opts = {})
+    target = opts[:target] || @target
+    battle = opts[:battle]
+    raise 'target is a required option for :first_aid' if target.nil?
+
+    medicine_check = @source.medicine_check!(battle)
+
+    @result = if medicine_check.result >= 10
+                [{
+                  source: @source,
+                  target: target,
+                  type: :first_aid,
+                  success: true,
+                  battle: battle,
+                  roll: medicine_check
+                }]
+              else
+                [{
+                  source: @source,
+                  target: target,
+                  type: :first_aid,
+                  success: false,
+                  battle: battle,
+                  roll: medicine_check
+                }]
+              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
+      end
+    end
+  end
+end

data/lib/natural_20/actions/grapple_action.rb

@@ -0,0 +1,185 @@
+class GrappleAction < Natural20::Action
+  attr_accessor :target
+
+  def self.can?(entity, battle, _options = {})
+    (battle.nil? || entity.total_actions(battle).positive?) && !entity.grappling?
+  end
+
+  def to_s
+    @action_type.to_s.humanize
+  end
+
+  def validate
+    @errors << 'target is a required option for :attack' if target.nil?
+    @errors << t('validation.shove.invalid_target_size') if (target.size_identifier - @source.size_identifier) > 1
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_target,
+                         range: 5,
+                         target_types: %i[enemies allies],
+                         num: 1
+                       }
+                     ],
+                     next: lambda { |target|
+                       self.target = target
+                       OpenStruct.new({
+                                        param: nil,
+                                        next: -> { self }
+                                      })
+                     }
+                   })
+  end
+
+  def self.build(session, source)
+    action = GrappleAction.new(session, source, :grapple)
+    action.build_map
+  end
+
+  # Build the attack roll information
+  # @param session [Natural20::Session]
+  # @param map [Natural20::BattleMap]
+  # @option opts battle [Natural20::Battle]
+  # @option opts target [Natural20::Entity]
+  def resolve(_session, _map, opts = {})
+    target = opts[:target] || @target
+    battle = opts[:battle]
+    raise 'target is a required option for :attack' if target.nil?
+
+    return if (target.size_identifier - @source.size_identifier) > 1
+
+    strength_roll = @source.athletics_check!(battle)
+    athletics_stats = (@target.athletics_proficient? ? @target.proficiency_bonus : 0) + @target.str_mod
+    acrobatics_stats = (@target.acrobatics_proficient? ? @target.proficiency_bonus : 0) + @target.dex_mod
+
+    grapple_success = false
+    if @target.incapacitated? || !battle.opposing?(@source, target)
+      grapple_success = true
+    else
+      contested_roll = if athletics_stats > acrobatics_stats
+                         @target.athletics_check!(battle,
+                                                  description: t('die_roll.contest'))
+                       else
+                         @target.acrobatics_check!(
+                           opts[:battle], description: t('die_roll.contest')
+                         )
+                       end
+      grapple_success = strength_roll.result >= contested_roll.result
+    end
+
+    @result = if grapple_success
+                [{
+                  source: @source,
+                  target: target,
+                  type: :grapple,
+                  success: true,
+                  battle: battle,
+                  source_roll: strength_roll,
+                  target_roll: contested_roll
+                }]
+              else
+                [{
+                  source: @source,
+                  target: target,
+                  type: :grapple,
+                  success: false,
+                  battle: battle,
+                  source_roll: strength_roll,
+                  target_roll: contested_roll
+                }]
+              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
+      end
+    end
+  end
+end
+
+class DropGrappleAction < Natural20::Action
+  attr_accessor :target
+
+  def self.can?(entity, battle, _options = {})
+    battle.nil? || entity.grappling?
+  end
+
+  def to_s
+    @action_type.to_s.humanize
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_target,
+                         targets: @source.grappling_targets,
+                         num: 1
+                       }
+                     ],
+                     next: lambda { |target|
+                       self.target = target
+                       OpenStruct.new({
+                                        param: nil,
+                                        next: -> { self }
+                                      })
+                     }
+                   })
+  end
+
+  def self.build(session, source)
+    action = DropGrappleAction.new(session, source, :grapple)
+    action.build_map
+  end
+
+  # @param session [Natural20::Session]
+  # @param map [Natural20::BattleMap]
+  # @option opts battle [Natural20::Battle]
+  # @option opts target [Natural20::Entity]
+  def resolve(_session, _map, opts = {})
+    target = opts[:target] || @target
+    battle = opts[:battle]
+    @result =
+      [{
+        source: @source,
+        target: target,
+        type: :drop_grapple,
+        battle: battle
+      }]
+  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])
+
+      end
+    end
+  end
+end

data/lib/natural_20/actions/ground_interact_action.rb

@@ -0,0 +1,74 @@
+# typed: true
+class GroundInteractAction < Natural20::Action
+  attr_accessor :target, :ground_items
+
+  def self.can?(entity, battle)
+    battle.nil? || (entity.total_actions(battle).positive? || entity.free_object_interaction?(battle)) && items_on_the_ground_count(entity, battle).positive?
+  end
+
+  def self.build(session, source)
+    action = GroundInteractAction.new(session, source, :ground_interact)
+    action.build_map
+  end
+
+  def self.items_on_the_ground_count(entity, battle)
+    battle.map.items_on_the_ground(entity).inject(0) { |total, item| total + item[1].size }
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_ground_items
+                       }
+                     ],
+                     next: lambda { |object|
+                       self.ground_items = object
+
+                       OpenStruct.new({
+                                        param: nil,
+                                        next: lambda {
+                                                self
+                                              }
+                                      })
+                     }
+                   })
+  end
+
+  def resolve(_session, map = nil, opts = {})
+    battle = opts[:battle]
+
+    actions = ground_items.map do |g, items|
+      [g, { action: :pickup, items: items, source: @source, target: g, battle: opts[:battle] }]
+    end.to_h
+
+    @result << {
+      source: @source,
+      actions: actions,
+      map: map,
+      battle: battle,
+      type: :pickup
+    }
+
+    self
+  end
+
+  def apply!(battle)
+    @result.each do |item|
+      entity = item[:source]
+      case (item[:type])
+      when :pickup
+        item[:actions].each do |g, action|
+          g.use!(nil, action)
+        end
+
+        if item[:cost] == :action
+          battle&.consume!(entity, :action, 1)
+        else
+          battle&.consume!(entity, :free_object_interaction, 1) || battle&.consume!(entity, :action, 1)
+        end
+      end
+    end
+  end
+end