natural_20 0.1.0

data/lib/natural_20/item_library/door_object.rb

@@ -0,0 +1,189 @@
+# typed: false
+module ItemLibrary
+  class DoorObject < Object
+    attr_reader :state, :locked, :key_name
+
+    def opaque?
+      closed? && !dead?
+    end
+
+    def unlock!
+      @locked = false
+    end
+
+    def lock!
+      @locked = true
+    end
+
+    def locked?
+      @locked
+    end
+
+    def passable?
+      opened? || dead?
+    end
+
+    def closed?
+      @state == :closed
+    end
+
+    def opened?
+      @state == :opened
+    end
+
+    def open!
+      @state = :opened
+    end
+
+    def close!
+      @state = :closed
+    end
+
+    def token
+      return '`' if dead?
+
+      pos_x, pos_y = position
+      t = if map.wall?(pos_x - 1, pos_y) || map.wall?(pos_x + 1, pos_y)
+            opened? ? '-' : '='
+          else
+            opened? ? '|' : '║'
+          end
+
+      [t]
+    end
+
+    def token_opened
+      @properties[:token_open].presence || '-'
+    end
+
+    def token_closed
+      @properties[:token_closed].presence || '='
+    end
+
+    # Returns available interaction with this object
+    # @param entity [Natural20::PlayerCharacter]
+    # @return [Array]
+    def available_interactions(entity, battle = nil)
+      interaction_actions = {}
+      if locked?
+        interaction_actions[:unlock] = { disabled: !entity.item_count(:"#{key_name}").positive?,
+                                         disabled_text: t('object.door.key_required') }
+        if entity.item_count('thieves_tools').positive? && entity.proficient?('thieves_tools')
+          interaction_actions[:lockpick] =
+            { disabled: !entity.action?(battle), disabled_text: t('object.door.action_required') }
+        end
+        return interaction_actions
+      end
+
+      if opened?
+        { close: { disabled: someone_blocking_the_doorway?, disabled_text: t('object.door.door_blocked') } }
+      else
+        { open: {}, lock: { disabled: !entity.item_count(:"#{key_name}").positive?,
+                            disabled_text: t('object.door.key_required') } }
+      end
+    end
+
+    def interactable?
+      true
+    end
+
+    # @param entity [Natural20::Entity]
+    # @param action [InteractAction]
+    def resolve(entity, action, _other_params, opts = {})
+      return if action.nil?
+
+      case action
+      when :open
+        if !locked?
+          {
+            action: action
+          }
+        else
+          {
+            action: :door_locked
+          }
+        end
+      when :close
+        {
+          action: action
+        }
+      when :lockpick
+        lock_pick_roll = entity.lockpick!(opts[:battle])
+
+        if lock_pick_roll.result >= lockpick_dc
+          { action: :lockpick_success, roll: lock_pick_roll, cost: :action }
+        else
+          { action: :lockpick_fail, roll: lock_pick_roll, cost: :action }
+        end
+      when :unlock
+        entity.item_count(:"#{key_name}").positive? ? { action: :unlock } : { action: :unlock_failed }
+      when :lock
+        entity.item_count(:"#{key_name}").positive? ? { action: :lock } : { action: :lock_failed }
+      end
+    end
+
+    # @param entity [Natural20::Entity]
+    # @param result [Hash]
+    def use!(entity, result)
+      case (result[:action])
+      when :open
+        open! if closed?
+      when :close
+        return unless opened?
+
+        if someone_blocking_the_doorway?
+          return Natural20::EventManager.received_event(source: self, user: entity, event: :object_interaction,
+                                                        sub_type: :close_failed, result: :failed, reason: 'Cannot close door since something is in the doorway')
+        end
+
+        close!
+      when :lockpick_success
+        return unless locked?
+
+        unlock!
+        Natural20::EventManager.received_event(source: self, user: entity, event: :object_interaction,
+                                               sub_type: :unlock, result: :success, lockpick: true, roll: result[:roll], reason: 'Door unlocked using lockpick.')
+      when :lockpick_fail
+        entity.deduct_item('thieves_tools')
+        Natural20::EventManager.received_event(source: self, user: entity, event: :object_interaction,
+                                               sub_type: :unlock, result: :failed, roll: result[:roll], reason: 'Lockpicking failed and the theives tools are now broken')
+      when :unlock
+        return unless locked?
+
+        unlock!
+        Natural20::EventManager.received_event(source: self, user: entity, event: :object_interaction,
+                                               sub_type: :unlock, result: :success, reason: t('object.door.unlock'))
+      when :lock
+        return unless unlocked?
+
+        lock!
+        Natural20::EventManager.received_event(source: self, user: entity, event: :object_interaction,
+                                               sub_type: :lock, result: :success, reason: t('object.door.lock'))
+      when :door_locked
+        Natural20::EventManager.received_event(source: self, user: entity, event: :object_interaction,
+                                               sub_type: :open_failed, result: :failed, reason: 'Cannot open door since door is locked.')
+      when :unlock_failed
+        Natural20::EventManager.received_event(source: self, user: entity, event: :object_interaction,
+                                               sub_type: :unlock_failed, result: :failed, reason: 'Correct Key missing.')
+      end
+    end
+
+    def lockpick_dc
+      (@properties[:lockpick_dc].presence || 10)
+    end
+
+    protected
+
+    def someone_blocking_the_doorway?
+      !!map.entity_at(*position)
+    end
+
+    def on_take_damage(battle, damage_params); end
+
+    def setup_other_attributes
+      @state = @properties[:state]&.to_sym || :closed
+      @locked = @properties[:locked]
+      @key_name = @properties[:key]
+    end
+  end
+end

data/lib/natural_20/item_library/ground.rb

@@ -0,0 +1,124 @@
+# typed: false
+module ItemLibrary
+  class Ground < Object
+    include Natural20::Container
+
+    attr_reader :state, :locked, :key_name
+
+    # Builds a custom UI map
+    # @param action [Symbol] The item specific action
+    # @param action_object [InteractAction]
+    # @return [OpenStruct]
+    def build_map(action, action_object)
+      case action
+      when :drop
+        OpenStruct.new({
+                         action: action_object,
+                         param: [
+                           {
+                             type: :select_items,
+                             label: action_object.source.items_label,
+                             items: action_object.source.inventory
+                           }
+                         ],
+                         next: lambda { |items|
+                                 action_object.other_params = items
+                                 OpenStruct.new({
+                                                  param: nil,
+                                                  next: lambda {
+                                                          action_object
+                                                        }
+                                                })
+                               }
+                       })
+      when :pickup
+        OpenStruct.new({
+                         action: action_object,
+                         param: [
+                           {
+                             type: :select_items,
+                             label: items_label,
+                             items: inventory
+                           }
+                         ],
+                         next: lambda { |items|
+                                 action_object.other_params = items
+                                 OpenStruct.new({
+                                                  param: nil,
+                                                  next: lambda {
+                                                          action_object
+                                                        }
+                                                })
+                               }
+                       })
+      end
+    end
+
+    def opaque?
+      false
+    end
+
+    def passable?
+      true
+    end
+
+    def placeable?
+      true
+    end
+
+    def token
+      ["\u00B7".encode('utf-8')]
+    end
+
+    def color
+      :cyan
+    end
+
+    # Returns available interaction with this object
+    # @param entity [Natural20::PlayerCharacter]
+    # @return [Array]
+    def available_interactions(_entity, _battle = nil)
+      []
+    end
+
+    def interactable?
+      false
+    end
+
+    # @param entity [Natural20::Entity]
+    # @param action [InteractAction]
+    def resolve(entity, action, other_params, opts = {})
+      return if action.nil?
+
+      case action
+      when :drop, :pickup
+        { action: action, items: other_params, source: entity, target: self, battle: opts[:battle] }
+      end
+    end
+
+    # @param entity [Natural20::Entity]
+    # @param result [Hash]
+    def use!(_entity, result)
+      case result[:action]
+      when :drop
+        store(result[:battle], result[:source], result[:target], result[:items])
+      when :pickup
+        retrieve(result[:battle], result[:source], result[:target], result[:items])
+      end
+    end
+
+    def list_notes(_entity, _perception, highlight: false)
+      inventory.map do |_item|
+        t("object.#{m.label}", default: m.label)
+      end
+    end
+
+    protected
+
+    def on_take_damage(battle, damage_params); end
+
+    def setup_other_attributes
+      @inventory = {}
+    end
+  end
+end

data/lib/natural_20/item_library/healing_potion.rb

@@ -0,0 +1,51 @@
+# typed: true
+module ItemLibrary
+  class HealingPotion < BaseItem
+    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 initialize(name, properties)
+      @name = name
+      @properties = properties
+    end
+
+    def consumable?
+      @properties[:consumable]
+    end
+
+    # @param entity [Natural20::Entity]
+    # @param battle [Natrual20::Battle]
+    def resolve(entity, battle)
+      hp_regain_roll = Natural20::DieRoll.roll(@properties[:hp_regained], description: t('dice_roll.healing_potion'),
+                                                                          entity: entity,
+                                                                          battle: battle)
+
+      {
+        hp_gain_roll: hp_regain_roll
+      }
+    end
+
+    def use!(entity, result)
+      entity.heal!(result[:hp_gain_roll].result)
+    end
+  end
+end

data/lib/natural_20/item_library/object.rb

@@ -0,0 +1,153 @@
+# typed: true
+module ItemLibrary
+  module AreaTrigger
+    def area_trigger_handler(_entity, _entity_pos, is_flying); end
+  end
+
+  class Object
+    class InvalidInteractionAction < StandardError
+      attr_reader :action, :valid_actions
+
+      # @param action [Symbol]
+      # @param valid_actions [Array]
+      def initialize(action, valid_actions = [])
+        @action = action
+        @valid_actions = valid_actions
+      end
+
+      def message
+        "Invalid action specified #{action}. should be in #{valid_actions.join(',')}"
+      end
+    end
+
+    include Natural20::Entity
+    include Natural20::Notable
+
+    attr_accessor :hp, :statuses, :resistances, :name, :map
+
+    def initialize(map, properties)
+      @name = properties[:name]
+      @map = map
+      @session = map.session
+      @statuses = Set.new
+      @properties = properties
+      @resistances = properties[:resistances].presence || []
+      setup_other_attributes
+      @hp = if !properties[:hp_die].blank?
+              Natural20::DieRoll.roll(properties[:hp_die]).result
+            else
+              properties[:max_hp]
+            end
+      if @properties[:inventory]
+        @inventory = @properties[:inventory].map do |inventory|
+          [inventory[:type].to_sym, OpenStruct.new({ qty: inventory[:qty] })]
+        end.to_h
+      end
+    end
+
+    def name
+      @properties[:label] || @name
+    end
+
+    def label
+      @properties[:label] || name
+    end
+
+    def position
+      map.position_of(self)
+    end
+
+    def color
+      @properties[:color]
+    end
+
+    def armor_class
+      @properties[:default_ac]
+    end
+
+    def opaque?
+      @properties[:opaque]
+    end
+
+    def half_cover?
+      @properties[:cover] == 'half'
+    end
+
+    def three_quarter_cover?
+      @properties[:cover] == 'three_quarter'
+    end
+
+    def total_cover?
+      @properties[:cover] == 'total'
+    end
+
+    def interactable?
+      false
+    end
+
+    def placeable?
+      @properties.key?(:placeable) ? @properties[:placeable] : true
+    end
+
+    def movement_cost
+      @properties[:movement_cost] || 1
+    end
+
+    def token
+      @properties[:token]
+    end
+
+    def size
+      @properties[:size] || :medium
+    end
+
+    def available_interactions(_entity, _battle)
+      []
+    end
+
+    def light_properties
+      @properties[:light]
+    end
+
+    # This terrain needs to be jumped over for movement
+    def jump_required?
+      @properties[:jump]
+    end
+
+    def passable?
+      @properties[:passable]
+    end
+
+    def wall?
+      @properties[:wall]
+    end
+
+    def concealed?
+      false
+    end
+
+    def describe_health
+      ''
+    end
+
+    def object?
+      true
+    end
+
+    def npc?
+      false
+    end
+
+    def pc?
+      false
+    end
+
+    def items_label
+      I18n.t(:"object.#{self.class}.item_label", default: "#{name} Items")
+    end
+
+    protected
+
+    def setup_other_attributes; end
+  end
+end