natural_20 0.1.1 → 0.2.0

data/lib/natural_20/die_roll.rb

@@ -69,7 +69,7 @@ module Natural20
     end
 
     def t(key, options = {})
-      I18n.t(key, options)
+      I18n.t(key, **options)
     end
   end
 
@@ -325,7 +325,7 @@ module Natural20
     end
 
     def self.t(key, options = {})
-      I18n.t(key, options)
+      I18n.t(key, **options)
     end
   end
 end

data/lib/natural_20/event_manager.rb

@@ -53,10 +53,10 @@ module Natural20
     def self.standard_cli
       Natural20::EventManager.clear
       event_handlers = { died: lambda { |event|
-                                 puts "#{show_name(event)} died."
+                                 output "#{show_name(event)} died."
                                },
                          unconscious: lambda { |event|
-                                        puts "#{show_name(event)} unconscious."
+                                        output "#{show_name(event)} unconscious."
                                       },
                          attacked: lambda { |event|
                                      advantage_mod = event[:advantage_mod]
@@ -68,7 +68,7 @@ module Natural20
                                      if event[:cover_ac].try(:positive?)
                                        cover_str = " (behind cover +#{event[:cover_ac]} ac)"
                                      end
-
+                                     Time.at(82800).utc.strftime("%I:%M%p")
                                      advantage_str = if advantage_mod&.positive?
                                                        ' with advantage'.colorize(:green)
                                                      elsif advantage_mod&.negative?
@@ -77,7 +77,7 @@ module Natural20
                                                        ''
                                                      end
                                      str_token = event[:attack_roll] ? 'event.attack' : 'event.attack_no_roll'
-                                     puts t(str_token, opportunity: event[:as_reaction] ? 'Opportunity Attack: ' : '',
+                                     output t(str_token, opportunity: event[:as_reaction] ? 'Opportunity Attack: ' : '',
                                                        source: show_name(event),
                                                        target: "#{event[:target].name}#{cover_str}",
                                                        attack_name: event[:attack_name],
@@ -87,126 +87,128 @@ module Natural20
                                                        damage: damage_str)
                                    },
                          damage: lambda { |event|
-                                   puts "#{show_name(event)} #{event[:source].describe_health}"
+                                   output "#{show_name(event)} #{event[:source].describe_health}"
                                  },
                          miss: lambda { |event|
                                  advantage_mod = event[:advantage_mod]
-                                 advantage_str = if advantage_mod.positive?
+                                 advantage_str = if advantage_mod&.positive?
                                                    ' with advantage'.colorize(:green)
-                                                 elsif advantage_mod.negative?
+                                                 elsif advantage_mod&.negative?
                                                    ' with disadvantage'.colorize(:red)
                                                  else
                                                    ''
                                                  end
-                                 puts "#{event[:as_reaction] ? 'Opportunity Attack: ' : ''} rolled #{advantage_str} #{event[:attack_roll]} ... #{event[:source].name&.colorize(:blue)} missed his attack #{event[:attack_name].colorize(:red)} on #{event[:target].name.colorize(:green)}"
+                                 output "#{event[:as_reaction] ? 'Opportunity Attack: ' : ''} rolled #{advantage_str} #{event[:attack_roll]} ... #{event[:source].name&.colorize(:blue)} missed his attack #{event[:attack_name].colorize(:red)} on #{event[:target].name.colorize(:green)}"
                                },
                          initiative: lambda { |event|
-                                       puts "#{show_name(event)} rolled a #{event[:roll]} = (#{event[:value]}) with dex tie break for initiative."
+                                       output "#{show_name(event)} rolled a #{event[:roll]} = (#{event[:value]}) with dex tie break for initiative."
                                      },
                          move: lambda { |event|
-                                 puts "#{show_name(event)} moved #{(event[:path].size - 1) * event[:feet_per_grid]}ft."
+                                 output "#{show_name(event)} moved #{(event[:path].size - 1) * event[:feet_per_grid]}ft."
                                },
                          dodge: lambda { |event|
-                                  puts t('event.dodge', name: show_name(event))
+                                  output t('event.dodge', name: show_name(event))
                                 },
                          help: lambda { |event|
-                                 puts "#{show_name(event)} is helping to attack #{event[:target].name&.colorize(:red)}"
+                                 output "#{show_name(event)} is helping to attack #{event[:target].name&.colorize(:red)}"
                                },
                          second_wind: lambda { |event|
-                                        puts SecondWindAction.describe(event)
+                                        output SecondWindAction.describe(event)
                                       },
                          heal: lambda { |event|
-                                 puts "#{show_name(event)} heals for #{event[:value]}hp"
+                                 output "#{show_name(event)} heals for #{event[:value]}hp"
                                },
                          hit_die: lambda { |event|
-                           puts t('event.hit_die', source: show_name(event), roll: event[:roll].to_s,
+                           output t('event.hit_die', source: show_name(event), roll: event[:roll].to_s,
                                                    value: event[:roll].result)
                          },
                          object_interaction: lambda { |event|
                                                if event[:roll]
-                                                 puts "#{event[:roll]} = #{event[:roll].result} -> #{event[:reason]}"
+                                                 output "#{event[:roll]} = #{event[:roll].result} -> #{event[:reason]}"
                                                else
-                                                 puts (event[:reason]).to_s
+                                                 output (event[:reason]).to_s
                                                end
                                              },
                          perception: lambda { |event|
-                                       puts "#{show_name(event)} rolls #{event[:perception_roll]} on perception"
+                                       output "#{show_name(event)} rolls #{event[:perception_roll]} on perception"
                                      },
 
                          death_save: lambda { |event|
-                                       puts t('event.death_save', name: show_name(event), roll: event[:roll].to_s, value: event[:roll].result,
+                                       output t('event.death_save', name: show_name(event), roll: event[:roll].to_s, value: event[:roll].result,
                                                                   saves: event[:saves], fails: event[:fails]).colorize(:blue)
                                      },
 
                          death_fail: lambda { |event|
                                        if event[:roll]
-                                         puts t('event.death_fail', name: show_name(event), roll: event[:roll].to_s, value: event[:roll].result,
+                                         output t('event.death_fail', name: show_name(event), roll: event[:roll].to_s, value: event[:roll].result,
                                                                     saves: event[:saves], fails: event[:fails]).colorize(:red)
                                        else
-                                         puts t('event.death_fail_hit', name: show_name(event), saves: event[:saves],
+                                         output t('event.death_fail_hit', name: show_name(event), saves: event[:saves],
                                                                         fails: event[:fails]).colorize(:red)
                                        end
                                      },
                          great_weapon_fighting_roll: lambda { |event|
-                                                       puts t('event.great_weapon_fighting_roll', name: show_name(event),
+                                                       output t('event.great_weapon_fighting_roll', name: show_name(event),
                                                                                                   roll: event[:roll], prev_roll: event[:prev_roll])
                                                      },
                          feature_protection: lambda { |event|
-                                               puts t('event.feature_protection', source: event[:source]&.name,
+                                               output t('event.feature_protection', source: event[:source]&.name,
                                                                                   target: event[:target]&.name, attacker: event[:attacker]&.name)
                                              },
                          prone: lambda { |event|
-                                  puts t('event.status.prone', name: show_name(event))
+                                  output t('event.status.prone', name: show_name(event))
                                 },
 
                          stand: lambda { |event|
-                                  puts t('event.status.stand', name: show_name(event))
+                                  output t('event.status.stand', name: show_name(event))
                                 },
 
                          %i[acrobatics athletics] => lambda { |event|
                                                        if event[:success]
-                                                         puts t("event.#{event[:event]}.success", name: show_name(event), roll: event[:roll],
+                                                         output t("event.#{event[:event]}.success", name: show_name(event), roll: event[:roll],
                                                                                                   value: event[:roll].result)
                                                        else
-                                                         puts t("event.#{event[:event]}.failure", name: show_name(event), roll: event[:roll],
+                                                         output t("event.#{event[:event]}.failure", name: show_name(event), roll: event[:roll],
                                                                                                   value: event[:roll].result)
                                                        end
                                                      },
 
                          start_of_combat: lambda { |event|
-                           puts t('event.combat_start')
+                           output t('event.combat_start')
                            event[:combat_order].each_with_index do |entity_and_initiative, index|
                              entity, initiative = entity_and_initiative
-                             puts "#{index + 1}. #{decorate_name(entity)} #{initiative}"
+                             output "#{index + 1}. #{decorate_name(entity)} #{initiative}"
                            end
                          },
-
+                         spell_buff: lambda { |event|
+                          output t('event.spell_buff', source: show_name(event), spell: event[:spell].label, target: event[:target]&.name)
+                        },
                          end_of_combat: lambda { |_event|
-                                          puts t('event.combat_end')
+                                          output t('event.combat_end')
                                         },
                          grapple_success: lambda { |event|
                            if event[:target_roll]
-                             puts t('event.grapple_success',
+                             output t('event.grapple_success',
                                     source: show_name(event), target: event[:target]&.name,
                                     source_roll: event[:source_roll],
                                     source_roll_value: event[:source_roll].result,
                                     target_roll: event[:target_roll],
                                     target_roll_value: event[:target_roll].result)
                            else
-                             puts t('event.grapple_success_no_roll',
+                             output t('event.grapple_success_no_roll',
                                     source: show_name(event), target: event[:target]&.name)
                            end
                          },
                          first_aid: lambda { |event|
-                           puts t('event.first_aid', name: show_name(event),
+                           output t('event.first_aid', name: show_name(event),
                                                      target: event[:target]&.name, roll: event[:roll], value: event[:roll].result)
                          },
                          first_aid_failure: lambda { |event|
-                                              puts t('event.first_aid_failure', name: show_name(event),
+                                              output t('event.first_aid_failure', name: show_name(event),
                                                                                 target: event[:target]&.name, roll: event[:roll], value: event[:roll].result)
                                             },
                          grapple_failure: lambda { |event|
-                           puts t('event.grapple_failure',
+                           output t('event.grapple_failure',
                                   source: show_name(event), target: event[:target]&.name,
                                   source_roll: event[:source_roll],
                                   source_roll_value: event[:source_roll].result,
@@ -214,11 +216,11 @@ module Natural20
                                   target_roll_value: event[:target_roll_value].result)
                          },
                          drop_grapple: lambda { |event|
-                                         puts t('event.drop_grapple',
+                                         output t('event.drop_grapple',
                                                 source: show_name(event), target: event[:target]&.name)
                                        },
                          flavor: lambda { |event|
-                                   puts t("event.flavor.#{event[:text]}", source: event[:source]&.name,
+                                   output t("event.flavor.#{event[:text]}", source: event[:source]&.name,
                                                                           target: event[:target]&.name)
                                  },
                          shove_success: lambda do |event|
@@ -230,9 +232,9 @@ module Natural20
                              target_roll_value: event[:target_roll].result
                            }
                            if event[:knock_prone]
-                             puts t('event.knock_prone_success', opts)
+                             output t('event.knock_prone_success', opts)
                            else
-                             puts t('event.shove_success', opts)
+                             output t('event.shove_success', opts)
                            end
                          end,
                          shove_failure: lambda do |event|
@@ -244,13 +246,13 @@ module Natural20
                                             target_roll_value: event[:target_roll].result
                                           }
                                           if event[:knock_prone]
-                                            puts t('event.knock_prone_failure', opts)
+                                            output t('event.knock_prone_failure', opts)
                                           else
-                                            puts t('event.shove_failure', opts)
+                                            output t('event.shove_failure', opts)
                                           end
                                         end,
                          %i[escape_grapple_success escape_grapple_failure] => lambda { |event|
-                                                                                puts t("event.#{event[:event]}",
+                                                                                output t("event.#{event[:event]}",
                                                                                        source: show_name(event), target: event[:target]&.name,
                                                                                        source_roll: event[:source_roll],
                                                                                        source_roll_value: event[:source_roll].result,
@@ -267,6 +269,10 @@ module Natural20
       decorate_name(event[:source])
     end
 
+    def self.output(string)
+      puts "[#{Session.current_session&.game_time || 0}] #{string}"
+    end
+
     # @param event [Hash]
     def self.decorate_name(entity)
       if @battle && @current_entity_context && entity
@@ -282,7 +288,7 @@ module Natural20
     end
 
     def self.t(token, options = {})
-      I18n.t(token, options)
+      I18n.t(token, **options)
     end
   end
 end

data/lib/natural_20/item_library/base_item.rb

@@ -21,7 +21,7 @@ module ItemLibrary
     protected
 
     def t(key, options = {})
-      I18n.t(key, options)
+      I18n.t(key, **options)
     end
   end
 end

data/lib/natural_20/npc.rb

@@ -137,6 +137,10 @@ module Natural20
       true
     end
 
+    def prepared_spells
+      @properties.fetch(:prepared_spells, [])
+    end
+
     def generate_npc_attack_actions(battle, opportunity_attack: false)
       actions = []
 

data/lib/natural_20/player_character.rb

@@ -4,20 +4,21 @@ module Natural20
     include Natural20::Entity
     include Natural20::RogueClass
     include Natural20::FighterClass
+    include Natural20::WizardClass
     include Natural20::HealthFlavor
     prepend Natural20::Lootable
     include Multiattack
 
-    attr_accessor :hp, :other_counters, :resistances, :experience_points, :class_properties
+    attr_accessor :hp, :other_counters, :resistances, :experience_points, :class_properties, :spell_slots
 
-    ACTION_LIST = %i[first_aid look attack move dash hide help dodge disengage use_item interact ground_interact inventory disengage_bonus
+    ACTION_LIST = %i[spell first_aid look attack move dash hide help dodge disengage use_item interact ground_interact inventory disengage_bonus
                      dash_bonus hide_bonus grapple escape_grapple drop_grapple shove push prone stand short_rest two_weapon_attack].freeze
 
     # @param session [Natural20::Session]
     def initialize(session, properties)
       @session = session
       @properties = properties.deep_symbolize_keys!
-
+      @spell_slots = {}
       @ability_scores = @properties[:ability]
       @equipped = @properties[:equipped]
       @race_properties = YAML.load_file(File.join(session.root_path, 'races',
@@ -65,7 +66,16 @@ module Natural20
     end
 
     def armor_class
-      equipped_ac
+      current_ac = if has_effect?(:ac_override)
+                     eval_effect(:ac_override, armor_class: equipped_ac)
+                   else
+                     equipped_ac
+                   end
+      if has_effect?(:ac_bonus)
+        current_ac + eval_effect(:ac_bonus)
+      else
+        current_ac
+      end
     end
 
     def level
@@ -152,7 +162,7 @@ module Natural20
 
       all_weapon_proficiencies = weapon_proficiencies
 
-      return true if all_weapon_proficiencies.include?(weapon[:name])
+      return true if all_weapon_proficiencies.include?(weapon[:name].to_s.underscore)
 
       all_weapon_proficiencies&.detect do |prof|
         weapon[:proficiency_type]&.include?(prof)
@@ -218,7 +228,7 @@ module Natural20
                              %w[ranged_attack melee_attack]
                            end
 
-      weapon_attacks = @properties[:equipped].map do |item|
+      weapon_attacks = @properties[:equipped]&.map do |item|
         weapon_detail = session.load_weapon(item)
         next if weapon_detail.nil?
         next unless valid_weapon_types.include?(weapon_detail[:type])
@@ -238,7 +248,7 @@ module Natural20
         end
 
         attacks
-      end.flatten.compact
+      end&.flatten&.compact || []
 
       unarmed_attack = AttackAction.new(session, self, :attack)
       unarmed_attack.using = 'unarmed_attack'
@@ -317,6 +327,8 @@ module Natural20
           action = ShoveAction.new(session, self, type)
           action.knock_prone = true
           action
+        when :spell
+          SpellAction.new(session, self, type)
         when :two_weapon_attack
           two_weapon_attack_actions(battle)
         when :push
@@ -328,7 +340,7 @@ module Natural20
     end
 
     def two_weapon_attack_actions(battle)
-      @properties[:equipped].each do |item|
+      @properties[:equipped]&.each do |item|
         weapon_detail = session.load_weapon(item)
         next if weapon_detail.nil?
         next unless weapon_detail[:type] == 'melee_attack'
@@ -373,16 +385,67 @@ module Natural20
       false
     end
 
+    # Returns the number of spell slots
+    # @param level [Integer]
+    # @return [Integer]
+    def spell_slots(level, character_class = nil)
+      character_class = @spell_slots.keys.first if character_class.nil?
+      @spell_slots[character_class].fetch(level, 0)
+    end
+
+    # Returns the number of spell slots
+    # @param level [Integer]
+    # @return [Integer]
+    def max_spell_slots(level, character_class = nil)
+      character_class = @spell_slots.keys.first if character_class.nil?
+
+      return send(:"max_slots_for_#{character_class}", level) if respond_to?(:"max_slots_for_#{character_class}")
+
+      0
+    end
+
+    # Consumes a characters spell slot
+    def consume_spell_slot!(level, character_class = nil, qty = 1)
+      character_class = @spell_slots.keys.first if character_class.nil?
+      if @spell_slots[character_class][level]
+        @spell_slots[character_class][level] = [@spell_slots[character_class][level] - qty, 0].max
+      end
+    end
+
     def pc?
       true
     end
 
+    def prepared_spells
+      @properties.fetch(:cantrips, []) + @properties.fetch(:prepared_spells, [])
+    end
+
+    # Returns the available spells for the current user
+    # @param battle [Natural20::Battle]
+    # @return [Hash]
+    def available_spells(battle)
+      prepared_spells.map do |spell|
+        details = session.load_spell(spell)
+        next unless details
+
+        _qty, resource = details[:casting_time].split(':')
+
+        disable_reason = []
+        disable_reason << :no_action if resource == 'action' && battle && battle.ongoing? && total_actions(battle).zero?
+        if resource == 'bonus_action' && battle.ongoing? && total_bonus_actions(battle).zero?
+          disable_reason << :no_bonus_action
+        end
+        disable_reason << :no_spell_slot if details[:level].positive? && spell_slots(details[:level]).zero?
+
+        [spell, details.merge(disabled: disable_reason)]
+      end.compact.to_h
+    end
+
     # @param hit_die_num [Integer] number of hit die to use
     def short_rest!(battle, prompt: false)
       super
-
-      @class_properties.keys do |klass|
-        send(:"short_rest_for_#{klass}") if respond_to?(:"short_rest_for_#{klass}")
+      @class_properties.keys.each do |klass|
+        send(:"short_rest_for_#{klass}", battle) if respond_to?(:"short_rest_for_#{klass}")
       end
     end
 
@@ -400,7 +463,7 @@ module Natural20
     def equipped_ac
       @equipments ||= YAML.load_file(File.join(session.root_path, 'items', 'equipment.yml')).deep_symbolize_keys!
 
-      equipped_meta = @equipped.map { |e| @equipments[e.to_sym] }.compact
+      equipped_meta = @equipped&.map { |e| @equipments[e.to_sym] }&.compact || []
       armor = equipped_meta.detect do |equipment|
         equipment[:type] == 'armor'
       end