natural_20 0.1.1 → 0.2.0

data/lib/natural_20/cli/builder/fighter_builder.rb

@@ -1,5 +1,5 @@
 module Natural20::FighterBuilder
-  def fighter_builder
+  def fighter_builder(build_values)
     @class_values ||= {
       attributes: [],
       saving_throw_proficiencies: %w[strength constitution],

data/lib/natural_20/cli/builder/rogue_builder.rb

@@ -1,9 +1,9 @@
 module Natural20::RogueBuilder
-  def rogue_builder
+  def rogue_builder(_build_values)
     @class_values ||= {
       attributes: [],
       saving_throw_proficiencies: %w[dexterity intelligence],
-      equipped: ['leather','dagger','dagger'],
+      equipped: %w[leather dagger dagger],
       inventory: [],
       tools: ['thieves_tools'],
       expertise: []
@@ -13,7 +13,7 @@ module Natural20::RogueBuilder
       @values[:skills].each do |skill|
         q.choice t("builder.skill.#{skill}"), skill
       end
-      q.choice t("builder.skill.thieves_tools"), 'thieves_tools'
+      q.choice t('builder.skill.thieves_tools'), 'thieves_tools'
     end
 
     starting_equipment = []
@@ -36,17 +36,17 @@ module Natural20::RogueBuilder
         }
       when :shortbow_and_quiver
         @class_values[:inventory] += [{
-          type: "shortbow",
+          type: 'shortbow',
           qty: 1
         },
-        {
-          type: 'arrows',
-          qty: 20
-        }]
+                                      {
+                                        type: 'arrows',
+                                        qty: 20
+                                      }]
       end
     end
 
-    shortswords = starting_equipment.select { |a| a == :shortword}.size
+    shortswords = starting_equipment.select { |a| a == :shortword }.size
     if shortswords > 0
       @class_values[:inventory] << {
         type: 'shortsword',
@@ -59,4 +59,4 @@ module Natural20::RogueBuilder
 
     @class_values
   end
-end
+end

data/lib/natural_20/cli/builder/wizard_builder.rb

@@ -0,0 +1,77 @@
+module Natural20::WizardBuilder
+  def wizard_builder(build_values)
+    @wizard_info = session.load_class('wizard')
+    @class_values ||= {
+      attributes: [],
+      saving_throw_proficiencies: %w[intelligence wisdom],
+      equipped: [],
+      inventory: [{
+        type: 'spellbook',
+        qty: 1
+      }],
+      prepared_spells: [],
+      spellbook: []
+    }
+
+    starting_equipment = []
+
+    starting_equipment << prompt.select(t('builder.wizard.select_starting_weapon')) do |q|
+      q.choice t('object.weapons.quarterstaff'), :quarterstaff
+      q.choice t('object.weapons.dagger'), :dagger
+    end
+
+    starting_equipment << prompt.select(t('builder.wizard.select_starting_weapon_2')) do |q|
+      q.choice t('object.component_pouch'), :component_pouch
+      q.choice t('object.arcane_focus'), :arcane_focus
+    end
+
+    starting_equipment.each do |equip|
+      case equip
+      when :quarterstaff
+        @class_values[:equipped] << 'quarterstaff'
+      when :dagger
+        @class_values[:equipped] << 'dagger'
+      when :component_pouch
+        @class_values[:inventory] << {
+          type: 'component_pouch',
+          qty: 1
+        }
+      when :arcane_focus
+        arcane_focus = prompt.select(t('builder.wizard.select_arcane_focus')) do |q|
+          %w[crytal orb rod staff wand].each do |equip|
+            q.choice t(:"object.#{equip}"), equip
+          end
+        end
+        @class_values[:inventory] << {
+          type: arcane_focus,
+          qty: 1
+        }
+      end
+    end
+
+    @class_values[:prepared_spells] = prompt.multi_select(t('builder.wizard.select_cantrip'), min: 3, max: 3) do |q|
+      @wizard_info.dig(:spell_list, :cantrip).each do |cantrip|
+        next unless session.load_spell(cantrip)
+
+        q.choice t(:"spell.#{cantrip}"), cantrip
+      end
+    end
+
+    @class_values[:spellbook] = prompt.multi_select(t('builder.wizard.select_spells'), min: 6, max: 6) do |q|
+      @wizard_info.dig(:spell_list, :level_1).each do |spell|
+        next unless session.load_spell(spell)
+
+        q.choice t(:"spell.#{spell}"), spell
+      end
+    end
+
+    prepared_spells_count = modifier_table(build_values[:ability][:int]) + 1
+
+    @class_values[:prepared_spells] = prompt.multi_select(t('builder.wizard.select_prepared_spells'), min: prepared_spells_count, max: prepared_spells_count) do |q|
+      @class_values[:spellbook].each do |spell|
+        q.choice t(:"spell.#{spell}"), spell
+      end
+    end
+    @class_values
+  end
+end

data/lib/natural_20/cli/character_builder.rb

@@ -1,9 +1,11 @@
 require 'natural_20/cli/builder/fighter_builder'
 require 'natural_20/cli/builder/rogue_builder'
+require 'natural_20/cli/builder/wizard_builder'
 module Natural20
   class CharacterBuilder
     include Natural20::FighterBuilder
     include Natural20::RogueBuilder
+    include Natural20::WizardBuilder
     include Natural20::InventoryUI
 
     attr_reader :session, :battle
@@ -47,9 +49,11 @@ module Natural20
           end
         end
 
-        @values[:description] = prompt.multiline(t('builder.description')) do |q|
-          q.default t('buider.default_description')
-        end.join("\n")
+        description = prompt.multiline(t('builder.description')) do |q|
+          q.default t('builder.default_description')
+        end
+
+        @values[:description] = description.is_a?(Array) ? description.join("\n") : description
 
         races = session.load_races
         @values[:race] = prompt.select(t('builder.select_race')) do |q|
@@ -140,7 +144,8 @@ module Natural20
 
         class_skills_selector
 
-        send(:"#{k}_builder")
+        send(:"#{k}_builder", @values)
+
         @values.merge!(@class_values)
         @pc = Natural20::PlayerCharacter.new(session, @values)
         character_sheet(@pc)

data/lib/natural_20/cli/commandline_ui.rb

@@ -1,10 +1,12 @@
 require 'natural_20/cli/inventory_ui'
 require 'natural_20/cli/character_builder'
+require 'natural_20/cli/action_ui'
 
 class CommandlineUI < Natural20::Controller
   include Natural20::InventoryUI
   include Natural20::MovementHelper
   include Natural20::Cover
+  include Natural20::ActionUI
 
   TTY_PROMPT_PER_PAGE = 20
   attr_reader :battle, :map, :session, :test_mode
@@ -54,33 +56,37 @@ class CommandlineUI < Natural20::Controller
     selected_targets = []
     valid_targets = options[:targets] || battle.valid_targets_for(entity, action, target_types: options[:target_types],
                                                                                   range: options[:range], filter: options[:filter])
-    target = prompt.select("#{entity.name} targets") do |menu|
-      valid_targets.each do |target|
-        menu.choice target_name(entity, target, weapon: weapon_details), target
+    total_targets = options[:num] || 1
+    puts t(:"multiple_targets", total_targets: total_targets) if total_targets > 1
+    total_targets.times.each do |index|
+      target = prompt.select("Target #{index + 1}: #{entity.name} targets") do |menu|
+        valid_targets.each do |t|
+          menu.choice target_name(entity, t, weapon: weapon_details), t
+        end
+        menu.choice 'Manual - Use cursor to select a target instead', :manual
+        menu.choice 'Back', nil
       end
-      menu.choice 'Manual - Use cursor to select a target instead', :manual
-      menu.choice 'Back', nil
-    end
 
-    return nil if target == 'Back'
+      return nil if target == 'Back'
 
-    if target == :manual
-      valid_targets = options[:targets] || battle.valid_targets_for(entity, action,
-                                                                    target_types: options[:target_types], range: options[:range],
-                                                                    filter: options[:filter],
-                                                                    include_objects: true)
-      selected_targets = target_ui(entity, weapon: weapon_details, validation: lambda { |selected|
-                                                                                 selected_entities = map.thing_at(*selected)
+      if target == :manual
+        valid_targets = options[:targets] || battle.valid_targets_for(entity, action,
+                                                                      target_types: options[:target_types], range: options[:range],
+                                                                      filter: options[:filter],
+                                                                      include_objects: true)
+        selected_targets += target_ui(entity, weapon: weapon_details, validation: lambda { |selected|
+                                                                                    selected_entities = map.thing_at(*selected)
 
-                                                                                 if selected_entities.empty?
-                                                                                   return false
-                                                                                 end
+                                                                                    if selected_entities.empty?
+                                                                                      return false
+                                                                                    end
+
+                                                                                    selected_entities.detect do |selected_entity|
+                                                                                      valid_targets.include?(selected_entity)
+                                                                                    end
+                                                                                  })
+      end
 
-                                                                                 selected_entities.detect do |selected_entity|
-                                                                                   valid_targets.include?(selected_entity)
-                                                                                 end
-                                                                               })
-    else
       selected_targets << target
     end
 
@@ -184,7 +190,7 @@ class CommandlineUI < Natural20::Controller
     selected_targets = []
     targets = selected.flatten.select { |t| t.hp && t.hp.positive? }.flatten.uniq
 
-    if targets.size > num_select
+    if targets.size > 1
       loop do
         target = prompt.select(t('multiple_target_prompt')) do |menu|
           targets.flatten.uniq.each do |t|
@@ -320,149 +326,34 @@ class CommandlineUI < Natural20::Controller
     end
   end
 
-  # Show action UI
-  # @param action [Natural20::Action]
-  # @param entity [Entity]
-  def action_ui(action, entity)
-    return :stop if action == :stop
-
-    cont = action.build_map
-    loop do
-      param = cont.param&.map do |p|
-        case (p[:type])
-        when :look
-          self
-        when :movement
-          move_path, jump_index = move_ui(entity, p)
-          return nil if move_path.nil?
-
-          [move_path, jump_index]
-        when :target, :select_target
-          targets = attack_ui(entity, action, p)
-          return nil if targets.nil? || targets.empty?
-
-          targets.first
-        when :select_weapon
-          action.using || action.npc_action
-        when :select_item
-          item = prompt.select("#{entity.name} use item", per_page: TTY_PROMPT_PER_PAGE) do |menu|
-            entity.usable_items.each do |d|
-              if d[:consumable]
-                menu.choice "#{d[:label].colorize(:blue)} (#{d[:qty]})", d[:name]
-              else
-                menu.choice d[:label].colorize(:blue).to_s, d[:name]
-              end
-            end
-            menu.choice t(:back).colorize(:blue), :back
-          end
-
-          return nil if item == :back
-
-          item
-        when :select_ground_items
-          selected_items = prompt.multi_select("Items on the ground around #{entity.name}") do |menu|
-            map.items_on_the_ground(entity).each do |ground_item|
-              ground, items = ground_item
-              items.each do |t|
-                item_label = t("object.#{t.label}", default: t.label)
-                menu.choice t('inventory.inventory_items', name: item_label, qty: t.qty), [ground, t]
-              end
-            end
-          end
-
-          return nil if selected_items.empty?
-
-          item_selection = {}
-          selected_items.each do |s_item|
-            ground, item = s_item
-
-            qty = how_many?(item)
-            item_selection[ground] ||= []
-            item_selection[ground] << [item, qty]
-          end
-
-          item_selection.map do |k, v|
-            [k, v]
-          end
-        when :select_object
-          target_objects = entity.usable_objects(map, battle)
-          item = prompt.select("#{entity.name} interact with") do |menu|
-            target_objects.each do |d|
-              menu.choice d.name.humanize.to_s, d
-            end
-            menu.choice t(:manual_target), :manual_target
-            menu.choice t(:back).colorize(:blue), :back
-          end
-
-          return nil if item == :back
-
-          if item == :manual_target
-            item = target_ui(entity, num_select: 1, validation: lambda { |selected|
-              selected_entities = map.thing_at(*selected)
-
-              return false if selected_entities.empty?
-
-              selected_entities.detect do |selected_entity|
-                target_objects.include?(selected_entity)
-              end
-            }).first
-          end
-
-          item
-        when :select_items
-          selected_items = prompt.multi_select(p[:label], per_page: TTY_PROMPT_PER_PAGE) do |menu|
-            p[:items].each do |m|
-              item_label = t("object.#{m.label}", default: m.label)
-              if m.try(:equipped)
-                menu.choice t('inventory.equiped_items', name: item_label), m
-              else
-                menu.choice t('inventory.inventory_items', name: item_label, qty: m.qty), m
-              end
-            end
-            menu.choice t(:back).colorize(:blue), :back
-          end
+  def arcane_recovery_ui(entity, spell_levels)
+    choice = prompt.select(t('action.arcane_recovery', name: entity.name)) do |q|
+      spell_levels.sort.each do |level|
+        q.choice t(:spell_level, level: level), level
+      end
+      q.choice t('action.waive_arcane_recovery'), :waive
+    end
+    return nil if choice == :waive
 
-          return nil if selected_items.include?(:back)
+    choice
+  end
 
-          selected_items = selected_items.map do |m|
-            count = how_many?(m)
-            [m, count]
-          end
-          selected_items
-        when :interact
-          object_action = prompt.select("#{entity.name} will") do |menu|
-            interactions = p[:target].available_interactions(entity)
-            class_key = p[:target].class.to_s
-            if interactions.is_a?(Array)
-              interactions.each do |k|
-                menu.choice t(:"object.#{class_key}.#{k}", default: k.to_s.humanize), k
-              end
-            else
-              interactions.each do |k, options|
-                label = options[:label] || t(:"object.#{class_key}.#{k}", default: k.to_s.humanize)
-                if options[:disabled]
-                  menu.choice label, k, disabled: options[:disabled_text]
-                else
-                  menu.choice label, k
-                end
-              end
-            end
-            menu.choice 'Back', :back
-          end
+  def spell_slots_ui(entity)
+    puts t(:spell_slots)
+    (1..9).each do |level|
+      next unless entity.max_spell_slots(level).positive?
 
-          return nil if item == :back
+      used_slots = entity.max_spell_slots(level) - entity.spell_slots(level)
+      used = used_slots.times.map do
+        '■'
+      end
 
-          object_action
-        when :show_inventory
-          inventory_ui(entity)
-        else
-          raise "unknown #{p[:type]}"
-        end
+      avail = entity.spell_slots(level).times.map do
+        '°'
       end
-      cont = cont.next.call(*param)
-      break if param.nil?
+
+      puts t(:spell_level_slots, level: level, slots: (used + avail).join(' '))
     end
-    @action = cont
   end
 
   def describe_map(map, line_of_sight: [])
@@ -482,9 +373,11 @@ class CommandlineUI < Natural20::Controller
     loop do
       describe_map(battle.map, line_of_sight: entity)
       puts @renderer.render(line_of_sight: entity)
-      puts t(:character_status_line, hp: entity.hp, max_hp: entity.max_hp, total_actions: entity.total_actions(battle), bonus_action: entity.total_bonus_actions(battle),
+      puts t(:character_status_line, ac: entity.armor_class, hp: entity.hp, max_hp: entity.max_hp, total_actions: entity.total_actions(battle), bonus_action: entity.total_bonus_actions(battle),
                                      available_movement: entity.available_movement(battle), statuses: entity.statuses.to_a.join(','))
-
+      entity.active_effects.each do |effect|
+        puts t(:effect_line, effect_name: effect[:effect].label, source: effect[:source].name)
+      end
       action = prompt.select(t('character_action_prompt', name: entity.name, token: entity.token&.first), per_page: TTY_PROMPT_PER_PAGE,
                                                                                                           filter: true) do |menu|
         entity.available_actions(@session, battle).each do |a|

data/lib/natural_20/cli/inventory_ui.rb

@@ -1,6 +1,8 @@
 module Natural20::InventoryUI
   include Natural20::Weapons
 
+  # Displays the character sheet of the specified entity
+  # @param entity [Natural20::Entity]
   def character_sheet(entity)
     puts t('character_sheet.name', name: entity.name)
     puts t('character_sheet.level', level: entity.level)
@@ -15,6 +17,8 @@ module Natural20::InventoryUI
     puts t('character_sheet.hp', current: entity.hp, max: entity.max_hp)
     puts t('character_sheet.ac', ac: entity.armor_class)
     puts t('character_sheet.speed', speed: entity.speed)
+    puts t('character_sheet.proficiency_bonus', bonus: entity.proficiency_bonus)
+    puts t('character_sheet.spell_attack', spell_attack: entity.spell_attack_modifier) if entity.has_spells?
     puts t('character_sheet.languages')
     entity.languages.each do |lang|
       puts "  #{t("language.#{lang}")}"