natural_20 0.1.1 → 0.2.0

data/lib/natural_20/session.rb

@@ -15,6 +15,11 @@ module Natural20
       @session
     end
 
+    # @param session [Natural20::Session]
+    def self.set_session(session)
+      @session = session
+    end
+
     def initialize(root_path = nil)
       @root_path = root_path.presence || '.'
       @session_state = {}
@@ -23,6 +28,7 @@ module Natural20
       @objects = {}
       @thing = {}
       @char_classes = {}
+      @spells = {}
       @settings = {
         manual_dice_roll: false
       }
@@ -124,6 +130,13 @@ module Natural20
       end.to_h
     end
 
+    def load_spell(spell)
+      @spells[spell.to_sym] ||= begin
+        spells = YAML.load_file(File.join(@root_path, 'items', "spells.yml")).deep_symbolize_keys!
+        spells[spell.to_sym].merge(id: spell)
+      end
+    end
+
     def load_class(klass)
       @char_classes[klass.to_sym] ||= begin
         YAML.load_file(File.join(@root_path, 'char_classes', "#{klass}.yml")).deep_symbolize_keys!
@@ -162,7 +175,7 @@ module Natural20
     end
 
     def t(token, options = {})
-      I18n.t(token, options)
+      I18n.t(token, **options)
     end
   end
 end

data/lib/natural_20/spell_library/firebolt.rb

@@ -0,0 +1,72 @@
+class Natural20::Firebolt < Natural20::Spell
+  include Natural20::Cover
+  include Natural20::Weapons
+  include Natural20::SpellAttackHelper
+
+  def build_map(action)
+    OpenStruct.new({
+                     param: [
+                       {
+                         type: :select_target,
+                         num: 1,
+                         range: @properties[:range],
+                         target_types: %i[enemies]
+                       }
+                     ],
+                     next: lambda { |target|
+                             action.target = target
+                             OpenStruct.new({
+                                              param: nil,
+                                              next: lambda {
+                                                      action
+                                                    }
+                                            })
+                           }
+                   })
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natrual20::Battle]
+  # @param spell_action [Natural20::SpellAction]
+  def resolve(entity, battle, spell_action)
+    target = spell_action.target
+
+    hit, attack_roll, advantage_mod, cover_ac_adjustments = evaluate_spell_attack(battle, entity, target, @properties)
+
+    if hit
+      level = 1
+      level += 1 if entity.level >= 5
+      level += 1 if entity.level >= 11
+      level += 1 if entity.level >= 17
+
+      damage_roll = Natural20::DieRoll.roll("#{level}d10", crit: attack_roll.nat_20?, battle: battle, entity: entity,
+                                                           description: t('dice_roll.spells.firebolt'))
+      [{
+        source: entity,
+        target: target,
+        attack_name: t('spell.firebolt'),
+        damage_type: @properties[:damage_type],
+        attack_roll: attack_roll,
+        damage_roll: damage_roll,
+        advantage_mod: advantage_mod,
+        damage: damage_roll,
+        cover_ac: cover_ac_adjustments,
+        type: :spell_damage,
+        spell: @properties
+      }]
+    else
+      [{
+        type: :spell_miss,
+        source: entity,
+        target: target,
+        attack_name: t('spell.firebolt'),
+        damage_type: @properties[:damage_type],
+        attack_roll: attack_roll,
+        damage_roll: damage_roll,
+        advantage_mod: advantage_mod,
+        cover_ac: cover_ac_adjustments,
+        spell: @properties
+      }]
+    end
+  end
+end

data/lib/natural_20/spell_library/mage_armor.rb

@@ -0,0 +1,67 @@
+class Natural20::MageArmor < Natural20::Spell
+  def build_map(action)
+    OpenStruct.new({
+                     param: [
+                       {
+                         type: :select_target,
+                         num: 1,
+                         range: 5,
+                         target_types: %i[allies self]
+                       }
+                     ],
+                     next: lambda { |target|
+                             action.target = target
+                             OpenStruct.new({
+                                              param: nil,
+                                              next: lambda {
+                                                      action
+                                                    }
+                                            })
+                           }
+                   })
+  end
+
+  def validate!(action)
+    @errors.clear
+    @errors << :wearing_armor if action.target.wearing_armor?
+  end
+
+  def self.apply!(battle, item)
+    case item[:type]
+    when :mage_armor
+
+      item[:source].add_casted_effect({ target: item[:target], effect: item[:effect], expiration: battle.session.game_time + 8.hours.to_i })
+      item[:target].register_effect(:ac_override, self, effect: item[:effect], source: item[:source],
+                                                        duration: 8.hours.to_i)
+      item[:target].register_event_hook(:equip, self, effect: item[:effect], effect: item[:effect],
+                                                      source: item[:source],
+                                                      duration: 8.hours.to_i)
+      Natural20::EventManager.received_event(event: :spell_buf, spell: item[:effect], source: item[:source],
+                                             target: item[:target])
+      SpellAction.consume_resource(battle, item)
+    end
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param effect [Object]
+  def self.ac_override(entity, _effect)
+    13 + entity.dex_mod
+  end
+
+  def self.equip(entity, opts = {})
+    entity.dismiss_effect!(opts[:effect]) if entity.wearing_armor?
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natrual20::Battle]
+  # @param spell_action [Natural20::SpellAction]
+  def resolve(_entity, _battle, spell_action)
+    [{
+      type: :mage_armor,
+      target: spell_action.target,
+      source: spell_action.source,
+      effect: self,
+      spell: @properties
+    }]
+  end
+end

data/lib/natural_20/spell_library/mage_hand.rb

@@ -0,0 +1,2 @@
+class Natural20::MagicHand < Natural20::Spell
+end

data/lib/natural_20/spell_library/magic_missile.rb

@@ -0,0 +1,67 @@
+class Natural20::MagicMissile < Natural20::Spell
+  include Natural20::Cover
+  include Natural20::Weapons
+  include Natural20::AttackHelper
+
+  def build_map(action)
+    cast_level = action.at_level || 1
+    darts = 3 + (cast_level - 1)
+
+    OpenStruct.new({
+                     param: [
+                       {
+                         type: :select_target,
+                         num: darts,
+                         range: @properties[:range],
+                         target_types: %i[enemies]
+                       }
+                     ],
+                     next: lambda { |target|
+                             action.target = target
+                             OpenStruct.new({
+                                              param: nil,
+                                              next: lambda {
+                                                      action
+                                                    }
+                                            })
+                           }
+                   })
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natrual20::Battle]
+  # @param spell_action [Natural20::SpellAction]
+  def resolve(entity, battle, spell_action)
+    targets = spell_action.target
+
+    targets.map do |target|
+      after_attack_roll_hook(battle, target,
+        entity, nil, nil, spell: @properties)
+
+      if target.has_spell_effect?(:shield)
+        {
+          source: entity,
+          target: target,
+          attack_name: t('spell.magic_missile'),
+          damage_type: @properties[:damage_type],
+          type: :spell_miss,
+          spell: @properties
+        }
+      else
+        damage_roll = Natural20::DieRoll.roll('1d4+1', battle: battle, entity: entity,
+                                                       description: t('dice_roll.spells.magic_missile'))
+
+        {
+          source: entity,
+          target: target,
+          attack_name: t('spell.magic_missile'),
+          damage_type: @properties[:damage_type],
+          damage_roll: damage_roll,
+          damage: damage_roll,
+          type: :spell_damage,
+          spell: @properties
+        }
+      end
+    end
+  end
+end

data/lib/natural_20/spell_library/shield.rb

@@ -0,0 +1,69 @@
+class Natural20::Shield < Natural20::Spell
+  def build_map(action)
+    OpenStruct.new({
+                     param: nil,
+                     next: lambda {
+                             action
+                           }
+                   })
+  end
+
+  def self.apply!(battle, item)
+    case item[:type]
+    when :shield
+
+      item[:source].add_casted_effect(effect: item[:effect])
+      item[:target].register_effect(:ac_bonus, self, effect: item[:effect], source: item[:source],
+                                                     duration: 8.hours.to_i)
+
+      item[:target].register_event_hook(:start_of_turn, self, effect: item[:effect], effect: item[:effect],
+                                                              source: item[:source])
+      Natural20::EventManager.received_event(event: :spell_buf, spell: item[:effect], source: item[:source],
+                                             target: item[:source])
+      SpellAction.consume_resource(battle, item)
+    end
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param effect [Object]
+  def self.ac_bonus(_entity, _effect)
+    5
+  end
+
+  def self.start_of_turn(entity, opts = {})
+    entity.dismiss_effect!(opts[:effect])
+  end
+
+  # @param battle [Natural20::Battle]
+  # @param entity [Natural20::Entity]
+  # @param attacker [Natural20::Entity]
+  # @param attack_roll [Natural20::DieRoll]
+  # @return [Array<Array<Hash>,Symbol>]
+  def self.after_attack_roll(battle, entity, _attacker, attack_roll, effective_ac, opts = {})
+    spell = battle.session.load_spell('shield')
+    if attack_roll.nil? || attack_roll.result.between?(entity.armor_class, effective_ac + 4)
+      [[{
+        type: :shield,
+        target: entity,
+        source: entity,
+        effect: Natural20::Shield.new(entity, 'shield', spell),
+        spell: spell
+      }], false]
+    else
+      [[], false]
+    end
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natrual20::Battle]
+  # @param spell_action [Natural20::SpellAction]
+  def resolve(_entity, _battle, spell_action)
+    [{
+      type: :shield,
+      target: spell_action.source,
+      source: spell_action.source,
+      effect: self,
+      spell: @properties
+    }]
+  end
+end

data/lib/natural_20/spell_library/spell.rb

@@ -0,0 +1,31 @@
+class Natural20::Spell
+  attr_accessor :errors
+  attr_reader :properties, :source
+
+  def initialize(source, spell_name, details)
+    @name = spell_name
+    @properties = details
+    @source = source
+    @errors = []
+  end
+
+  def label
+    t(:"spell.#{@name}")
+  end
+
+  def id
+    @properties[:id]
+  end
+
+  def self.apply!(battle, item); end
+
+  def validate!(_action)
+    @errors.clear
+  end
+
+  protected
+
+  def t(token, options = {})
+    I18n.t(token, **options)
+  end
+end

data/lib/natural_20/utils/weapons.rb

@@ -30,10 +30,10 @@ module Natural20::Weapons
     disadvantage << :armor_proficiency unless source.proficient_with_equipped_armor?
     advantage << :squeezed if target.squeezed?
     advantage << :being_helped if battle.help_with?(target)
-    disadvantage << :target_long_range if battle.map && battle.map.distance(source, target,
-                                                                            entity_1_pos: source_pos) > weapon[:range]
+    disadvantage << :target_long_range if battle.map && weapon && battle.map.distance(source, target,
+                                                                                      entity_1_pos: source_pos) > weapon[:range]
 
-    if weapon[:type] == 'ranged_attack' && battle.map
+    if weapon && weapon[:type] == 'ranged_attack' && battle.map
       disadvantage << :ranged_with_enemy_in_melee if battle.enemy_in_melee_range?(source, source_pos: source_pos)
       disadvantage << :target_is_prone_range if target.prone?
     end
@@ -43,8 +43,10 @@ module Natural20::Weapons
       advantage << :pack_tactics
     end
 
-    disadvantage << :small_creature_using_heavy if weapon[:properties]&.include?('heavy') && source.size == :small
-    advantage << :target_is_prone if weapon[:type] == 'melee_attack' && target.prone?
+    if weapon && weapon[:properties]&.include?('heavy') && source.size == :small
+      disadvantage << :small_creature_using_heavy
+    end
+    advantage << :target_is_prone if weapon && weapon[:type] == 'melee_attack' && target.prone?
 
     advantage << :unseen_attacker if battle.map && !battle.can_see?(target, source, entity_2_pos: source_pos)
     disadvantage << :invisible_attacker if battle.map && !battle.can_see?(source, target, entity_1_pos: source_pos)
@@ -73,6 +75,6 @@ module Natural20::Weapons
       damage_mod += 2
     end
 
-    "#{damage_roll}+#{damage_mod}"
+    "#{damage_roll}#{damage_mod >= 0 ? "+#{damage_mod}" : damage_mod}"
   end
 end

data/lib/natural_20/version.rb

@@ -1,4 +1,4 @@
 # typed: strict
 module Natural20
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/locales/en.yml

@@ -1,8 +1,9 @@
 ---
 en:
   action:
-    attack_action: '%{name} with %{weapon_name} -> Hit: +%{mod} Dmg: %{dmg}'
-    attack_action_throw: '%{name} with %{weapon_name} (Throw) -> Hit: +%{mod} Dmg: %{dmg}'
+    arcane_recovery: Arcane Recovery for %{name}
+    attack_action: '%{name} with %{weapon_name} -> Hit: %{mod} Dmg: %{dmg}'
+    attack_action_throw: '%{name} with %{weapon_name} (Throw) -> Hit: %{mod} Dmg: %{dmg}'
     dash: Dash
     dash_bonus: Bonus Action -> Dash
     disengage: Disengage
@@ -26,10 +27,14 @@ en:
     push: Shove (Push Away)
     short_rest: Short Rest
     shove: Shove (Knock Prone)
+    spell: Spellcasting
+    spell_choice: '%{spell} (%{level})'
     stand: Stand Up
     use_item: Use Item
+    waive_arcane_recovery: Skip Arcane Recovery
   attack_status:
     being_helped: Being being_helped
+    invisible_attacker: Target is hidden/invisible
     prone: Target Prone
     ranged_with_enemy_in_melee: Ranged weapon with enemy in melee range
     small_creature_using_heavy: Heavy weapon used by small creature
@@ -42,8 +47,6 @@ en:
   back: Back
   battle_end: Battle ended in %{num} rounds
   battle_simulator: Battle Simulator
-  map_description: 'Battle Map (%{width}x%{length}) %{feet_per_grid}ft per square, pov %{pov}:'
-  character_action_prompt: '%{name} (%{token}) will'
   builder:
     ability_score:
       fixed: Fixed ability score 15, 14, 13, 12, 10, 8
@@ -84,21 +87,22 @@ en:
       select_starting_weapon: Select a starting weapon
       select_starting_weapon_2: Select second weapon set
     select_languages: Select languages
-    select_race: Please select a race
-    select_skill: null
-    select_subrace: Please select a sub-race
+    select_race: Please select a racetargets.first -race
     skill:
       acrobatics: Acrobatics
       animal_handling: Animal Handling
+      arcana: Arcana
       athletics: Athletics
       deception: Deception
       history: History
       insight: Insight
       intimidation: Intimidation
       investigation: Investigation
+      medicine: Medicine
       perception: Perception
       performance: Performance
       persuasion: Persuasion
+      religion: Religion
       sleight_of_hand: Sleight of Hand
       stealth: Stealth
       survival: Survival
@@ -111,6 +115,14 @@ en:
       masons_tools: Mason's Tools
       smiths_tools: Smith's Tools
     wis: Select Wisdom ability score
+    wizard:
+      select_cantrip: Select Cantrip
+      select_prepared_spells: Select prepared spells
+      select_skill: Select a wizard skill
+      select_spells: Select starting spells in your spellbook
+      select_starting_weapon: Select starting weapon
+      select_starting_weapon_2: Select starting equipment
+  character_action_prompt: '%{name} (%{token}) will'
   character_builder: Character Builder ...
   character_sheet:
     ac: 'AC: %{ac}'
@@ -121,12 +133,14 @@ en:
     languages: 'Languages:'
     level: 'Level: %{level}'
     name: 'Name: %{name}'
+    proficiency_bonus: 'Proficiency Bonus: +%{bonus}'
     race: 'Race: %{race}'
     skill_mod: '%{prefix} %{skill} %{bonus}'
     skills: Skills
     speed: 'Speed: %{speed}ft.'
+    spell_attack: 'Spell Attack: +%{spell_attack}'
     subrace: 'Subrace: %{race}'
-  character_status_line: 'HP: %{hp}/%{max_hp} actions: %{total_actions} bonus action: %{bonus_action}, movement: %{available_movement} ft. statuses: %{statuses}'
+  character_status_line: 'AC: %{ac} HP: %{hp}/%{max_hp} actions: %{total_actions} bonus action: %{bonus_action}, movement: %{available_movement} ft. statuses: %{statuses}'
   dead_goblin_items: Dead Goblin's items
   dice_roll:
     ability_score: 'Rolling for ability score #%{roll_num}'
@@ -151,12 +165,15 @@ en:
     second_wind: Roll for second wind hp gain
     sneak_attack: Roll for sneak attack damage
     special_weapon_damage: Roll for special weapon additional damage
+    spells:
+      firebolt: Roll for Firebot spell damage
     stealth: Rolling for stealth check
     strength_check: Roll for strength (skill check)
     thieves_tools: Roll for thieves tools (skill check)
     wisdom_check: Roll for wisdom check
   dice_roller: Dice Roller
   drop: Drop Item
+  effect_line: '%{effect_name} (%{source})'
   end_turn: '%{name}: End turn.'
   engine_title: Welcome to Wizards and Goblins (DnD 5e Adventure Engine)
   entity:
@@ -203,6 +220,7 @@ en:
     shove_failure: '%{source_roll} < %{target_roll}. ${source} tried but failed to shove %{target} 5ft away'
     shove_success: '%{source_roll} >= %{target_roll}. ${source} shoves %{target} 5ft away'
     something: (something)
+    spell_buff: '%{source} casts %{spell} on %{target}.'
     status:
       prone: '%{name} is now prone.'
       stand: '%{name} stands up.'
@@ -232,18 +250,22 @@ en:
     thieves_cant: Thieves Cant
     undercommon: Undercommon
   manual_target: Target object using the map
+  map_description: 'Battle Map (%{width}x%{length}) %{feet_per_grid}ft per square, pov %{pov}:'
   missing_game: missing game.yml in the current folder
   multiple_target_prompt: Multiple targets at location(s) please select specific targets
+  multiple_targets: 'Total Targets: %{total_targets}'
   'no': 'No'
   object:
     Arrows: Arrows
     ItemLibrary::Chest:
       loot: Retreive Contents
     Wooden door key: Wooden Door Key
+    arcane_focus: Arcane Focus
     chain_mail: Chain Mail
     chest:
       lock: clink. chest is now locked
       unlock: Ka-chink! chest is now unlocked
+    component_pouch: Component Pouch
     door:
       door_blocked: (door is blocked)
       key_required: (missing key)
@@ -278,6 +300,7 @@ en:
       longbow: Longbow
       longbow_and_arrows: Longbow and Arrows
       longsword: Longsword
+      quarterstaff: Quarterstaff
       rapier: Rapier
       scimitar: Scimitar
       shortbow: Shortbow
@@ -303,6 +326,19 @@ en:
   select_npcs: Select NPCs
   select_party_member: Select Party Member %{index}
   skip_hit_die: Skip Hit Die
+  spell:
+    firebolt: Firebolt
+    mage_armor: Mage Armor
+    magic_missile: Magic Missile
+    shield: Shield
+  spell_level: Recover Spell Level %{level}
+  spell_level_slots: 'level %{level}: %{slots}'
+  spell_slots: Spell Slots
+  spells:
+    disabled:
+      no_action: '- No more actions'
+      no_bonus_action: '- No more bonus actions'
+      no_spell_slot: '- No more spell slots'
   tpk: The entire party has fallen. Game Over!
   unequip: Unequip
   validation: