natural_20 0.1.1 → 0.2.0

data/lib/natural_20/cli/map_renderer.rb

@@ -68,6 +68,7 @@ module Natural20
       color = (object_meta.color.presence || DEFAULT_TOKEN_COLOR).to_sym
 
       return nil unless object_meta.token
+      return :inherit if object_meta.token.to_s == 'inherit'
 
       if object_meta.token.is_a?(Array)
         object_meta.token[pos_y - m_y][pos_x - m_x].colorize(color)
@@ -90,7 +91,12 @@ module Natural20
           when '.', '?'
             default_ground
           else
-            object_token(col_index, row_index)&.colorize(background: background_color) || default_ground
+            token = object_token(col_index, row_index)
+            if token && token != :inherit
+              token&.colorize(background: background_color) || default_ground
+            else
+              c
+            end
           end
 
       # render map layer

data/lib/natural_20/concerns/attack_helper.rb

@@ -0,0 +1,53 @@
+# Helper module for utilities in computing attacks
+module Natural20::AttackHelper
+  # Handles after attack event hooks
+  # @param battle [Natural20::Battle]
+  # @param target [Natural20::Entity]
+  # @param source [Natural20::Entity]
+  def after_attack_roll_hook(battle, target, source, attack_roll, effective_ac, opts = {})
+    force_miss = false
+
+    # check prepared spells of target for a possible reaction
+    events = target.prepared_spells.map do |spell|
+      spell_details = battle.session.load_spell(spell)
+      _qty, resource = spell_details[:casting_time].split(':')
+      next unless target.has_reaction?(battle)
+      next unless resource == 'reaction'
+
+      spell_class = spell_details[:spell_class].constantize
+      next unless spell_class.respond_to?(:after_attack_roll)
+
+      result, force_miss_result = spell_class.after_attack_roll(battle, target, source, attack_roll,
+                                                                effective_ac, opts)
+      force_miss = true if force_miss_result == :force_miss
+      result
+    end.flatten.compact
+
+    events.each do |item|
+      Natural20::Action.descendants.each do |klass|
+        klass.apply!(battle, item)
+      end
+    end
+
+    force_miss
+  end
+
+  def effective_ac(battle, target)
+    cover_ac_adjustments = 0
+    ac = if battle.map
+           cover_ac_adjustments = calculate_cover_ac(battle.map, target)
+           target.armor_class + cover_ac_adjustments # calculate AC with cover
+         else
+           target.armor_class
+         end
+    [ac, cover_ac_adjustments]
+  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
+end

data/lib/natural_20/concerns/entity.rb

@@ -3,11 +3,12 @@ module Natural20
   module Entity
     include EntityStateEvaluator
 
-    attr_accessor :entity_uid, :statuses, :color, :session, :death_saves,
-                  :death_fails, :current_hit_die, :max_hit_die
+    attr_accessor :entity_uid, :statuses, :color, :session, :death_saves, :effects,
+                  :death_fails, :current_hit_die, :max_hit_die, :entity_event_hooks
+    attr_reader :casted_effects
 
-    ATTRIBUTE_TYPES = %w[strength dexterity constitution intelligence wisdom charisma]
-    ATTRIBUTE_TYPES_ABBV = %w[str dex con int wis cha]
+    ATTRIBUTE_TYPES = %w[strength dexterity constitution intelligence wisdom charisma].freeze
+    ATTRIBUTE_TYPES_ABBV = %w[str dex con int wis cha].freeze
     def label
       I18n.exists?(name, :en) ? I18n.t(name) : name.humanize
     end
@@ -56,7 +57,7 @@ module Natural20
 
       if unconscious?
         @statuses.delete(:stable)
-        @death_fails += if damage_params[:attack_roll].nat_20?
+        @death_fails += if damage_params[:attack_roll]&.nat_20?
                           2
                         else
                           1
@@ -351,7 +352,8 @@ module Natural20
       entity_state[:statuses].delete(:dodge)
       entity_state[:statuses].delete(:disengage)
       battle.dismiss_help_actions_for(self)
-
+      resolve_trigger(:start_of_turn)
+      cleanup_effects
       entity_state
     end
 
@@ -389,6 +391,8 @@ module Natural20
 
     def break_stealth!(battle)
       entity_state = battle.entity_state_for(self)
+      return unless entity_state
+
       entity_state[:statuses].delete(:hiding)
       entity_state[:stealth] = 0
     end
@@ -410,6 +414,17 @@ module Natural20
       entity_state[:statuses]&.include?(:dodge)
     end
 
+    def has_spells?
+      return false unless @properties[:prepared_spells]
+
+      !@properties[:prepared_spells].empty?
+    end
+
+    def ranged_spell_attack!(battle, spell, advantage: false, disadvantage: false)
+      DieRoll.roll("1d20+#{spell_attack_modifier}", description: t('dice_roll.ranged_spell_attack', spell: spell),
+                                                    entity: self, battle: battle, advantage: advantage, disadvantage: disadvantage)
+    end
+
     def hiding?(battle)
       entity_state = battle.entity_state_for(self)
       return false unless entity_state
@@ -473,6 +488,10 @@ module Natural20
       grappled? ? 0 : battle.entity_state_for(self)[:movement]
     end
 
+    def available_spells
+      []
+    end
+
     def speed
       @properties[:speed]
     end
@@ -587,7 +606,9 @@ module Natural20
     SKILL_AND_ABILITY_MAP.each do |ability, skills|
       skills.each do |skill|
         define_method("#{skill}_mod") do
-          return @properties[:skills][skill.to_sym] if npc? && @properties[:skills] && @properties[:skills][skill.to_sym]
+          if npc? && @properties[:skills] && @properties[:skills][skill.to_sym]
+            return @properties[:skills][skill.to_sym]
+          end
 
           ability_mod = case ability.to_sym
                         when :dex
@@ -797,10 +818,18 @@ module Natural20
     # Equips an item
     # @param item_name [String,Symbol]
     def equip(item_name, ignore_inventory: false)
-      return @properties[:equipped] << item_name.to_s if ignore_inventory
+      @properties[:equipped] ||= []
+      if ignore_inventory
+        @properties[:equipped] << item_name.to_s
+        resolve_trigger(:equip)
+        return
+      end
 
       item = deduct_item(item_name)
-      @properties[:equipped] << item_name.to_s if item
+      if item
+        @properties[:equipped] << item_name.to_s
+        resolve_trigger(:equip)
+      end
     end
 
     # Checks if item can be equipped
@@ -845,6 +874,10 @@ module Natural20
       true
     end
 
+    def wearing_armor?
+      !!equipped_items.detect { |t| %w[armor shield].include?(t[:type]) }
+    end
+
     def hand_slots_required(item)
       return 0.0 if item.type == 'armor'
 
@@ -1055,7 +1088,7 @@ module Natural20
       return true if weapon[:name] == 'Unarmed Attack'
 
       @properties[:weapon_proficiencies]&.detect do |prof|
-        weapon[:proficiency_type]&.include?(prof)
+        weapon[:proficiency_type]&.include?(prof) || weapon[:proficiency_type]&.include?(weapon[:name].underscore)
       end
     end
 
@@ -1139,19 +1172,145 @@ module Natural20
                                           description: t("dice_roll.#{save_type}_saving_throw"))
     end
 
+    def active_effects
+      @effects.values.flatten.reject do |effect|
+        effect[:expiration] && effect[:expiration] <= @session.game_time
+      end.uniq
+    end
+
+    def register_effect(effect_type, handler, method_name = nil, effect: nil, source: nil, duration: nil)
+      @effects[effect_type.to_sym] ||= []
+      effect_descriptor = {
+        handler: handler,
+        method: method_name.nil? ? effect_type : method_name,
+        effect: effect,
+        source: source
+      }
+      effect_descriptor[:expiration] = @session.game_time + duration.to_i
+      @effects[effect_type.to_sym] << effect_descriptor
+    end
+
+    def register_event_hook(event_type, handler, method_name = nil, source: nil, effect: nil, duration: nil)
+      @entity_event_hooks[event_type.to_sym] ||= []
+      event_hook_descriptor = {
+        handler: handler,
+        method: method_name.nil? ? event_type : method_name,
+        effect: effect,
+        source: source
+      }
+      event_hook_descriptor[:expiration] = @session.game_time + duration.to_i if duration
+      @entity_event_hooks[event_type.to_sym] << event_hook_descriptor
+    end
+
+    def spell_slots(_level)
+      0
+    end
+
+    def max_spell_slots(_level)
+      0
+    end
+
+    def dismiss_effect!(effect)
+      dismiss_count = 0
+      effect.source.casted_effects.reject! { |f| f[:effect] == effect }
+
+      @effects = @effects.map do |k, value|
+        delete_effects = value.select do |f|
+          f[:effect] == effect
+        end
+        dismiss_count += delete_effects.size
+        [k, value - delete_effects]
+      end.to_h
+
+      @entity_event_hooks = @entity_event_hooks.map do |k, value|
+        delete_hooks = value.select do |f|
+          f[:effect] == effect
+        end
+        dismiss_count += delete_hooks.size
+        [k, value - delete_hooks]
+      end.to_h
+
+      dismiss_count
+    end
+
+    def add_casted_effect(effect)
+      @casted_effects << effect
+    end
+
+    def has_spell_effect?(spell)
+      active_effects = @effects.values.flatten.reject do |effect|
+        effect[:expiration] && effect[:expiration] <= @session.game_time
+      end
+      !!active_effects.detect { |effect|
+        effect[:effect].id.to_sym == spell.to_sym
+      }
+    end
+
     protected
 
+    def cleanup_effects
+      @effects = @effects.map do |k, value|
+        delete_effects = value.select do |f|
+          f[:expiration] && f[:expiration] <= @session.game_time
+        end
+        [k, value - delete_effects]
+      end.to_h
+
+      @entity_event_hooks = @entity_event_hooks.map do |k, value|
+        delete_hooks = value.select do |f|
+          f[:expiration] && f[:expiration] <= @session.game_time
+        end
+        [k, value - delete_hooks]
+      end.to_h
+
+      @casted_effects = @casted_effects.select do |f|
+        f[:expiration].blank? || f[:expiration] > @session.game_time
+      end
+    end
+
+    def has_effect?(effect_type)
+      return false unless @effects.key?(effect_type.to_sym)
+      return false if @effects[effect_type.to_sym].empty?
+
+      active_effects = @effects[effect_type.to_sym].reject do |effect|
+        effect[:expiration] && effect[:expiration] <= @session.game_time
+      end
+
+      !active_effects.empty?
+    end
+
+    def eval_effect(effect_type, opts = {})
+      active_effect = @effects[effect_type.to_sym].reject do |effect|
+        effect[:expiration] && effect[:expiration] <= @session.game_time
+      end.last
+
+      active_effect[:handler].send(active_effect[:method], self, opts.merge(effect: active_effect[:effect])) if active_effect
+    end
+
+    def resolve_trigger(event_type)
+      return unless @entity_event_hooks[event_type.to_sym]
+
+      active_hook = @entity_event_hooks[event_type.to_sym].reject do |effect|
+        effect[:expiration] && effect[:expiration] <= @session.game_time
+      end.last
+
+      active_hook[:handler].send(active_hook[:method], self, effect: active_hook[:effect]) if active_hook
+    end
+
     # Localization helper
     # @param token [Symbol, String]
     # @param options [Hash]
     # @return [String]
     def t(token, options = {})
-      I18n.t(token, options)
+      I18n.t(token, **options)
     end
 
     def setup_attributes
       @death_saves = 0
       @death_fails = 0
+      @entity_event_hooks = {}
+      @effects = {}
+      @casted_effects = []
     end
 
     def on_take_damage(battle, _damage_params)

data/lib/natural_20/concerns/fighter_actions/second_wind_action.rb

@@ -33,15 +33,13 @@ class SecondWindAction < Natural20::Action
     self
   end
 
-  def apply!(battle)
-    @result.each do |item|
-      case (item[:type])
-      when :second_wind
-        Natural20::EventManager.received_event(action: self.class, source: item[:source], roll: item[:roll],
-                                               event: :second_wind)
-        item[:source].second_wind!(item[:roll].result)
-        battle.entity_state_for(item[:source])[:bonus_action] -= 1
-      end
+  def self.apply!(battle, item)
+    case (item[:type])
+    when :second_wind
+      Natural20::EventManager.received_event(action: self.class, source: item[:source], roll: item[:roll],
+                                             event: :second_wind)
+      item[:source].second_wind!(item[:roll].result)
+      battle.entity_state_for(item[:source])[:bonus_action] -= 1
     end
   end
 

data/lib/natural_20/concerns/fighter_class.rb

@@ -1,5 +1,5 @@
 # typed: false
-require "natural_20/concerns/fighter_actions/second_wind_action"
+require 'natural_20/concerns/fighter_actions/second_wind_action'
 
 module Natural20::FighterClass
   attr_accessor :fighter_level, :second_wind_count
@@ -29,7 +29,7 @@ module Natural20::FighterClass
   end
 
   # hooks for the fighter class during a short rest
-  def short_rest_for_fighter
+  def short_rest_for_fighter(_battle)
     @second_wind_count = 1
   end
 end

data/lib/natural_20/concerns/spell_attack_helper.rb

@@ -0,0 +1,33 @@
+module Natural20::SpellAttackHelper
+  include Natural20::Cover
+  include Natural20::AttackHelper
+
+  def evaluate_spell_attack(battle, entity, target, spell_properties)
+    # DnD 5e advantage/disadvantage checks
+    advantage_mod, adv_info = target_advantage_condition(battle, entity, target, spell_properties)
+
+    attack_roll = entity.ranged_spell_attack!(battle, spell_properties[:name], advantage: advantage_mod.positive?,
+                                                                               disadvantage: advantage_mod.negative?)
+
+    target_ac, _cover_ac = effective_ac(
+      battle, target
+    )
+
+    force_miss = after_attack_roll_hook(battle, target,
+                                        source, attack_roll, target_ac, spell: spell_properties)
+    if !force_miss
+      cover_ac_adjustments = 0
+      hit = if attack_roll.nat_20?
+              true
+            elsif attack_roll.nat_1?
+              false
+            else
+              target_ac, cover_ac_adjustments = effective_ac(battle, target)
+              attack_roll.result >= target_ac
+            end
+    else
+      hit = false
+    end
+    [hit, attack_roll, advantage_mod, cover_ac_adjustments]
+  end
+end

data/lib/natural_20/concerns/wizard_class.rb

@@ -0,0 +1,86 @@
+# typed: false
+module Natural20::WizardClass
+  WIZARD_SPELL_SLOT_TABLE =
+    [
+      # cantrips, 1st, 2nd, 3rd ... etc
+      [3, 2], # 1
+      [3, 3], # 2
+      [3, 4, 2], # 3
+      [4, 4, 3], # 4
+      [4, 4, 3, 2], # 5
+      [4, 4, 3, 3], # 6
+      [4, 4, 3, 3, 1], # 7
+      [4, 4, 3, 3, 2], # 8
+      [4, 4, 3, 3, 3, 1], # 9
+      [5, 4, 3, 3, 3, 2], # 10
+      [5, 4, 3, 3, 3, 2, 1], # 11
+      [5, 4, 3, 3, 3, 2, 1], # 12
+      [5, 4, 3, 3, 3, 2, 1, 1], # 13
+      [5, 4, 3, 3, 3, 2, 1, 1], # 14
+      [5, 4, 3, 3, 3, 2, 1, 1, 1], # 15
+      [5, 4, 3, 3, 3, 2, 1, 1, 1], # 16
+      [5, 4, 3, 3, 3, 2, 1, 1, 1, 1], # 17
+      [5, 4, 3, 3, 3, 3, 1, 1, 1, 1], # 18
+      [5, 4, 3, 3, 3, 3, 2, 1, 1, 1], # 19
+      [5, 4, 3, 3, 3, 3, 2, 2, 1, 1] # 20
+    ].freeze
+
+  attr_accessor :wizard_level, :wizard_spell_slots, :arcane_recovery
+
+  def initialize_wizard
+    @spell_slots[:wizard] = reset_spell_slots
+    @arcane_recovery = 1
+  end
+
+  def spell_attack_modifier
+    proficiency_bonus + int_mod
+  end
+
+  def special_actions_for_wizard(_session, _battle)
+    []
+  end
+
+  # @param battle [Natural20::Battle]
+  def short_rest_for_wizard(battle)
+    if @arcane_recovery.positive?
+      controller = battle.controller_for(self)
+      if controller && controller.respond_to?(:arcane_recovery_ui)
+        max_sum = (wizard_level / 2).ceil
+        loop do
+          current_sum = 0
+          avail_levels = WIZARD_SPELL_SLOT_TABLE[wizard_level - 1].each_with_index.map do |slots, index|
+            next if index.zero?
+            next if index >= 6 # none of the spell sltos can be 6 or higher
+
+            next if @spell_slots[:wizard][index] >= slots
+            next if current_sum > max_sum
+
+            current_sum += index
+            index
+          end.compact
+
+          break if avail_levels.empty?
+
+          level = controller.arcane_recovery_ui(self, avail_levels)
+          break if level.nil?
+
+          @spell_slots[:wizard][level] += 1
+          @arcane_recovery = 0
+          max_sum -= level
+        end
+      end
+    end
+  end
+
+  def max_slots_for_wizard(level)
+    WIZARD_SPELL_SLOT_TABLE[wizard_level - 1][level] || 0
+  end
+
+  protected
+
+  def reset_spell_slots
+    WIZARD_SPELL_SLOT_TABLE[wizard_level - 1].each_with_index.map do |slots, index|
+      [index, slots]
+    end.to_h
+  end
+end