natural_20 0.1.1 → 0.2.0

data/items/spells.yml

@@ -0,0 +1,58 @@
+---
+firebolt:
+  base_damage: 1d10
+  casting_time: 1:action
+  components:
+    - verbal
+    - sematic
+  damage_increase:
+    - 5
+    - 11
+    - 17
+  damage_type: fire
+  description: You hurl a mote of fire at a creature or object within range. A flammable object hit by this spell ignites if it isn't being worn or carried.
+  duration: instant
+  level: 0
+  name: Firebolt
+  range: 120
+  school: evocation
+  spell_class: Natural20::Firebolt
+  type: ranged_attack
+mage_armor:
+  casting_time: 1:action
+  components:
+    - verbal
+    - sematic
+    - material
+  description: You touch a willing creature who isn't wearing armor, and a protective magical force surrounds it until the spell ends. The target's base AC becomes 13 + its Dexterity modifier. The spell ends if the target dons armor or if you dismiss the spell as an action.
+  duration: 8h
+  level: 1
+  materials:
+    - cured_leather
+  name: Mage Armor
+  school: abjuration
+  spell_class: Natural20::MageArmor
+  type: buff
+magic_missile:
+  casting_time: 1:action
+  damage_type: force
+  level: 1
+  name: Magic Missile
+  range: 120
+  school: evocation
+  description: You create three glowing darts of magical force. Each dart hits a creature of your choice that you can see within range.
+  spell_class: Natural20::MagicMissile
+  type: force
+  higher_level: true
+shield:
+  casting_time: 1:reaction
+  level: 1
+  name: Shield
+  range: 0
+  duration: 1R
+  school: abjuration
+  spell_class: Natural20::Shield
+  components:
+    - verbal
+    - sematic
+  type: warding

data/items/weapons.yml

@@ -39,6 +39,66 @@ dagger:
     range_max: 120
   type: melee_attack
   weight: 10
+quarterstaff:
+  cost: 2sp
+  damage: 1d6
+  damage_2: 1d8
+  damage_type: bludgeoning
+  meta:
+    noise_source: 5
+    noise_target: 5
+  modifiers: null
+  name: Quarterstaff
+  proficiency_type:
+    - simple
+  properties:
+    - versatile
+  range: 5
+  subtype: weapon
+  type: melee_attack
+  weight: 4
+sling:
+  ammo: pellet
+  cost: 1sp
+  damage: 1d4
+  damage_type: bludgeoning
+  meta:
+    noise_source: 5
+    noise_target: 5
+  modifiers: null
+  name: Sling
+  proficiency_type:
+    - simple
+  properties:
+    - ammunition
+    - ranged
+  range: 30
+  range_max: 120
+  subtype: weapon
+  type: ranged_attack
+  weight: 0
+dart:
+  ammo: dart
+  cost: 2
+  damage: 1d4
+  damage_type: piercing
+  meta:
+    noise_source: 5
+    noise_target: 5
+  modifiers: null
+  name: Dart
+  proficiency_type:
+    - simple
+  properties:
+    - thrown
+    - finesse
+  range: 5
+  subtype: weapon
+  thrown:
+    range: 20
+    range_max: 60
+  type: ranged_attack
+  weight: 0.25
 greatclub:
   cost: 2sp
   damage: 1d8
@@ -162,24 +222,6 @@ light_hammer:
     range_max: 60
   type: melee_attack
   weight: 2
-warhammer:
-  cost: 2
-  damage: 1d8
-  damage_2: 1d10
-  damage_type: bludgeoning
-  meta:
-    noise_source: 5
-    noise_target: 5
-  modifiers: null
-  name: Warhammer
-  proficiency_type:
-    - martial
-  properties:
-    - versatile
-  range: 5
-  subtype: weapon
-  type: melee_attack
-  weight: 2
 longbow:
   ammo: arrows
   cost: 50
@@ -351,4 +393,22 @@ vicious_rapier:
   rarity: very_rare
   subtype: weapon
   type: melee_attack
+  weight: 2
+warhammer:
+  cost: 2
+  damage: 1d8
+  damage_2: 1d10
+  damage_type: bludgeoning
+  meta:
+    noise_source: 5
+    noise_target: 5
+  modifiers: null
+  name: Warhammer
+  proficiency_type:
+    - martial
+  properties:
+    - versatile
+  range: 5
+  subtype: weapon
+  type: melee_attack
   weight: 2

data/lib/natural_20.rb

@@ -9,6 +9,7 @@ require 'natural_20/concerns/lootable'
 require 'natural_20/concerns/evaluator/entity_state_evaluator'
 require 'natural_20/concerns/entity'
 require 'natural_20/item_library/object'
+require 'natural_20/concerns/attack_helper'
 require 'natural_20/concerns/movement_helper'
 require 'natural_20/utils/cover'
 require 'natural_20/utils/weapons'
@@ -16,6 +17,7 @@ require 'natural_20/concerns/navigation'
 require 'natural_20/actions/action'
 require 'natural_20/concerns/fighter_class'
 require 'natural_20/concerns/rogue_class'
+require 'natural_20/concerns/wizard_class'
 require 'natural_20/actions/concerns/action_damage'
 require 'natural_20/actions/look_action'
 require 'natural_20/actions/attack_action'
@@ -37,6 +39,13 @@ require 'natural_20/actions/escape_grapple_action'
 require 'natural_20/actions/ground_interact_action'
 require 'natural_20/actions/first_aid_action'
 require 'natural_20/actions/shove_action'
+require 'natural_20/concerns/spell_attack_helper'
+require 'natural_20/spell_library/spell'
+require 'natural_20/spell_library/mage_armor'
+require 'natural_20/spell_library/firebolt'
+require 'natural_20/spell_library/magic_missile'
+require 'natural_20/spell_library/shield'
+require 'natural_20/actions/spell_action'
 require 'natural_20/battle'
 require 'natural_20/utils/ray_tracer'
 require 'natural_20/battle_map'

data/lib/natural_20/actions/action.rb

@@ -27,14 +27,14 @@ module Natural20
     def validate
     end
 
-    def apply!(battle); end
+    def self.apply!(battle, item); end
 
     def resolve(session, map, opts = {}); end
 
     protected
 
     def t(k, options = {})
-      I18n.t(k, options)
+      I18n.t(k, **options)
     end
   end
 end

data/lib/natural_20/actions/attack_action.rb

@@ -2,7 +2,8 @@
 class AttackAction < Natural20::Action
   include Natural20::Cover
   include Natural20::Weapons
-  include Natural20::ActionDamage
+  include Natural20::AttackHelper
+  extend Natural20::ActionDamage
 
   attr_accessor :target, :using, :npc_action, :as_reaction, :thrown, :second_hand
   attr_reader :advantage_mod
@@ -31,7 +32,7 @@ class AttackAction < Natural20::Action
 
       i18n_token = thrown ? 'action.attack_action_throw' : 'action.attack_action'
 
-      t(i18n_token, name: @action_type.to_s.humanize, weapon_name: weapon[:name], mod: attack_mod,
+      t(i18n_token, name: @action_type.to_s.humanize, weapon_name: weapon[:name], mod: attack_mod >= 0 ? "+#{attack_mod}" : attack_mod,
                     dmg: damage_modifier(@source, weapon, second_hand: second_hand))
     end
   end
@@ -70,76 +71,82 @@ class AttackAction < Natural20::Action
   end
 
   # @param battle [Natural20::Battle]
-  def apply!(battle)
-    @result.each do |item|
-      if item[:flavor]
-        Natural20::EventManager.received_event({ event: :flavor, source: item[:source], target: item[:target],
-                                                 text: item[:flavor] })
-      end
-      case (item[:type])
-      when :prone
-        item[:source].prone!
-      when :damage
-        damage_event(item, battle)
-      when :miss
-        Natural20::EventManager.received_event({ attack_roll: item[:attack_roll],
-                                                 attack_name: item[:attack_name],
-                                                 advantage_mod: item[:advantage_mod],
-                                                 as_reaction: !!as_reaction,
-                                                 adv_info: item[:adv_info],
-                                                 source: item[:source], target: item[:target], event: :miss })
-      end
-
-      # handle ammo
-      item[:source].deduct_item(item[:ammo], 1) if item[:ammo]
-
-      # hanle thrown items
-      if item[:thrown]
-        if item[:source].item_count(item[:weapon]).positive?
-          item[:source].deduct_item(item[:weapon], 1)
-        else
-          item[:source].unequip(item[:weapon], transfer_inventory: false)
-        end
+  def self.apply!(battle, item)
+    if item[:flavor]
+      Natural20::EventManager.received_event({ event: :flavor, source: item[:source], target: item[:target],
+                                               text: item[:flavor] })
+    end
+    case (item[:type])
+    when :prone
+      item[:source].prone!
+    when :damage
+      damage_event(item, battle)
+      consume_resource(battle, item)
+    when :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
 
-        if item[:type] == :damage
-          item[:target].add_item(item[:weapon])
-        else
-          ground_pos = item[:battle].map.entity_or_object_pos(item[:target])
-          ground_object = item[:battle].map.objects_at(*ground_pos).detect { |o| o.is_a?(ItemLibrary::Ground) }
-          ground_object&.add_item(item[:weapon])
-        end
+  # @param battle [Natural20::Battle]
+  # @param item [Hash]
+  def self.consume_resource(battle, item)
+    # handle ammo
+    item[:source].deduct_item(item[:ammo], 1) if item[:ammo]
+
+    # hanle thrown items
+    if item[:thrown]
+      if item[:source].item_count(item[:weapon]).positive?
+        item[:source].deduct_item(item[:weapon], 1)
+      else
+        item[:source].unequip(item[:weapon], transfer_inventory: false)
       end
 
-      if as_reaction
-        battle.consume(item[:source], :reaction)
-      elsif item[:second_hand]
-        battle.consume(item[:source], :bonus_action)
+      if item[:type] == :damage
+        item[:target].add_item(item[:weapon])
       else
-        battle.consume(item[:source], :action)
+        ground_pos = item[:battle].map.entity_or_object_pos(item[:target])
+        ground_object = item[:battle].map.objects_at(*ground_pos).detect { |o| o.is_a?(ItemLibrary::Ground) }
+        ground_object&.add_item(item[:weapon])
       end
+    end
 
-      item[:source].break_stealth!(battle)
+    if item[:as_reaction]
+      battle.consume(item[:source], :reaction)
+    elsif item[:second_hand]
+      battle.consume(item[:source], :bonus_action)
+    else
+      battle.consume(item[:source], :action)
+    end
 
-      # handle two-weapon fighting
-      weapon = session.load_weapon(item[:weapon]) if item[:weapon]
+    item[:source].break_stealth!(battle)
 
-      if weapon && weapon[:properties]&.include?('light') && !battle.two_weapon_attack?(item[:source]) && !item[:second_hand]
-        battle.entity_state_for(item[:source])[:two_weapon] = item[:weapon]
-      else
-        battle.entity_state_for(item[:source])[:two_weapon] = nil
-      end
+    # handle two-weapon fighting
+    weapon = battle.session.load_weapon(item[:weapon]) if item[:weapon]
 
-      # handle multiattacks
+    if weapon && weapon[:properties]&.include?('light') && !battle.two_weapon_attack?(item[:source]) && !item[:second_hand]
+      battle.entity_state_for(item[:source])[:two_weapon] = item[:weapon]
+    elsif battle.entity_state_for(item[:source])
+      battle.entity_state_for(item[:source])[:two_weapon] = nil
+    end
+
+    # handle multiattacks
+    if battle.entity_state_for(item[:source])
       battle.entity_state_for(item[:source])[:multiattack]&.each do |_group, attacks|
         if attacks.include?(item[:attack_name])
           attacks.delete(item[:attack_name])
           item[:source].clear_multiattack!(battle) if attacks.empty?
         end
       end
-
-      # dismiss help actions
-      battle.dismiss_help_for(item[:target])
     end
+
+    # dismiss help actions
+    battle.dismiss_help_for(item[:target])
   end
 
   def with_advantage?
@@ -172,7 +179,13 @@ class AttackAction < Natural20::Action
 
     npc_action = @source.npc_actions.detect { |a| a[:name].downcase == using.downcase } if @source.npc? && using
 
-    if npc_action
+    if @source.npc?
+
+      if npc_action.nil?
+        npc_action = @source.properties[actions].detect do |action|
+          action[:name].downcase == using.to_s.downcase
+        end
+      end
       weapon = npc_action
       attack_name = npc_action[:name]
       attack_mod = npc_action[:attack]
@@ -199,6 +212,8 @@ class AttackAction < Natural20::Action
 
     # handle the lucky feat
     attack_roll = attack_roll.reroll(lucky: true) if @source.class_feature?('lucky') && attack_roll.nat_1?
+    target_ac, _cover_ac = effective_ac(battle, target)
+    after_attack_roll_hook(battle, target, source, attack_roll, target_ac)
 
     if @source.class_feature?('sneak_attack') && (weapon[:properties]&.include?('finesse') || weapon[:type] == 'ranged_attack') && (with_advantage? || battle.enemy_in_melee_range?(
       target, [@source]
@@ -233,8 +248,8 @@ class AttackAction < Natural20::Action
           elsif attack_roll.nat_1?
             false
           else
-            cover_ac_adjustments = calculate_cover_ac(battle.map, target) if battle.map
-            attack_roll.result >= (target.armor_class + cover_ac_adjustments)
+            target_ac, cover_ac_adjustments = effective_ac(battle, target)
+            attack_roll.result >= target_ac
           end
 
     if hit
@@ -309,14 +324,6 @@ class AttackAction < Natural20::Action
     self
   end
 
-  # Computes cover armor class adjustment
-  # @param map [Natural20::BattleMap]
-  # @param target [Natural20::Entity]
-  # @return [Integer]
-  def calculate_cover_ac(map, target)
-    cover_calculation(map, @source, target)
-  end
-
   protected
 
   # determine eligibility for the 'Protection' fighting style
@@ -371,4 +378,6 @@ class TwoWeaponAttackAction < AttackAction
   def label
     "Bonus Action -> #{super}"
   end
+
+  def self.apply!(battle, item); end
 end

data/lib/natural_20/actions/concerns/action_damage.rb

@@ -1,6 +1,8 @@
 module Natural20::ActionDamage
   def damage_event(item, battle)
-    Natural20::EventManager.received_event({ source: item[:source], attack_roll: item[:attack_roll], target: item[:target], event: :attacked,
+    Natural20::EventManager.received_event({ source: item[:source],
+                                             attack_roll: item[:attack_roll],
+                                             target: item[:target], event: :attacked,
                                              attack_name: item[:attack_name],
                                              damage_type: item[:damage_type],
                                              advantage_mod: item[:advantage_mod],

data/lib/natural_20/actions/dash_action.rb

@@ -9,7 +9,7 @@ class DashAction < Natural20::Action
                    })
   end
 
-  def self.can?(entity, battle)
+  def self.can?(entity, battle, _options = {})
     battle && entity.total_actions(battle).positive?
   end
 
@@ -22,14 +22,11 @@ class DashAction < Natural20::Action
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :dash
-        Natural20::EventManager.received_event({ source: item[:source], event: :dash })
-        battle.entity_state_for(item[:source])[:movement] += item[:source].speed
-      end
-
+  def self.apply!(battle, item)
+    case item[:type]
+    when :dash
+      Natural20::EventManager.received_event({ source: item[:source], event: :dash })
+      battle.entity_state_for(item[:source])[:movement] += item[:source].speed
       if as_bonus_action
         battle.entity_state_for(item[:source])[:bonus_action] -= 1
       else
@@ -40,7 +37,7 @@ class DashAction < Natural20::Action
 end
 
 class DashBonusAction < DashAction
-  def self.can?(entity, battle)
+  def self.can?(entity, battle, options = {})
     battle && entity.class_feature?('cunning_action') && entity.total_bonus_actions(battle) > 0
   end
 end