natural_20 0.1.0

data/lib/natural_20/event_manager.rb

@@ -0,0 +1,288 @@
+# typed: true
+module Natural20
+  class EventManager
+    class EventLogger
+      # @param log_level [Integer,String]
+      def initialize(log_level)
+        @log_level = log_level.to_i
+      end
+
+      def debug(message = '')
+        puts message if @log_level < 1
+      end
+    end
+
+    def self.clear
+      @event_listeners = {}
+    end
+
+    # Registers an event listener
+    # @param events [Symbol,Array<Symbol>] list of event types
+    # @param callable [Proc] handler
+    def self.register_event_listener(events, callable)
+      events = [events] unless events.is_a?(Array)
+      @event_listeners ||= {}
+      events.each do |event|
+        @event_listeners[event] ||= []
+        @event_listeners[event] << callable unless @event_listeners[event].include?(callable)
+      end
+    end
+
+    def self.received_event(event)
+      return if @event_listeners.nil?
+
+      @event_listeners[event[:event]]&.each do |callable|
+        callable.call(event)
+      end
+    end
+
+    # Sets the current player so that event text can be customized
+    # @param battle [Natural20::Battle] Current battle
+    # @param entites [Array] An array of entities
+    def self.set_context(battle, entities = [])
+      @battle = battle
+      @current_entity_context = entities
+    end
+
+    #  @return [EventLogger]
+    def self.logger
+      @logger ||= EventLogger.new(ENV['NAT20_LOG_LEVEL'].presence || '1')
+      @logger
+    end
+
+    def self.standard_cli
+      Natural20::EventManager.clear
+      event_handlers = { died: lambda { |event|
+                                 puts "#{show_name(event)} died."
+                               },
+                         unconscious: lambda { |event|
+                                        puts "#{show_name(event)} unconscious."
+                                      },
+                         attacked: lambda { |event|
+                                     advantage_mod = event[:advantage_mod]
+                                     advantage, disadvantage = event[:adv_info]
+                                     sneak = event[:sneak_attack] ? (event[:sneak_attack]).to_s : nil
+                                     damage = (event[:damage_roll]).to_s
+                                     damage_str = "#{[damage,
+                                                      sneak].compact.join(' + sneak ')} = #{event[:value]} #{event[:damage_type]}"
+                                     if event[:cover_ac].try(:positive?)
+                                       cover_str = " (behind cover +#{event[:cover_ac]} ac)"
+                                     end
+
+                                     advantage_str = if advantage_mod&.positive?
+                                                       ' with advantage'.colorize(:green)
+                                                     elsif advantage_mod&.negative?
+                                                       ' with disadvantage'.colorize(:red)
+                                                     else
+                                                       ''
+                                                     end
+                                     str_token = event[:attack_roll] ? 'event.attack' : 'event.attack_no_roll'
+                                     puts t(str_token, opportunity: event[:as_reaction] ? 'Opportunity Attack: ' : '',
+                                                       source: show_name(event),
+                                                       target: "#{event[:target].name}#{cover_str}",
+                                                       attack_name: event[:attack_name],
+                                                       advantage: advantage_str,
+                                                       attack_roll: event[:attack_roll].to_s.colorize(:green),
+                                                       attack_value: event[:attack_roll]&.result,
+                                                       damage: damage_str)
+                                   },
+                         damage: lambda { |event|
+                                   puts "#{show_name(event)} #{event[:source].describe_health}"
+                                 },
+                         miss: lambda { |event|
+                                 advantage_mod = event[:advantage_mod]
+                                 advantage_str = if advantage_mod.positive?
+                                                   ' with advantage'.colorize(:green)
+                                                 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)}"
+                               },
+                         initiative: lambda { |event|
+                                       puts "#{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."
+                               },
+                         dodge: lambda { |event|
+                                  puts t('event.dodge', name: show_name(event))
+                                },
+                         help: lambda { |event|
+                                 puts "#{show_name(event)} is helping to attack #{event[:target].name&.colorize(:red)}"
+                               },
+                         second_wind: lambda { |event|
+                                        puts SecondWindAction.describe(event)
+                                      },
+                         heal: lambda { |event|
+                                 puts "#{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,
+                                                   value: event[:roll].result)
+                         },
+                         object_interaction: lambda { |event|
+                                               if event[:roll]
+                                                 puts "#{event[:roll]} = #{event[:roll].result} -> #{event[:reason]}"
+                                               else
+                                                 puts (event[:reason]).to_s
+                                               end
+                                             },
+                         perception: lambda { |event|
+                                       puts "#{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,
+                                                                  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,
+                                                                    saves: event[:saves], fails: event[:fails]).colorize(:red)
+                                       else
+                                         puts 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),
+                                                                                                  roll: event[:roll], prev_roll: event[:prev_roll])
+                                                     },
+                         feature_protection: lambda { |event|
+                                               puts 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))
+                                },
+
+                         stand: lambda { |event|
+                                  puts 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],
+                                                                                                  value: event[:roll].result)
+                                                       else
+                                                         puts 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')
+                           event[:combat_order].each_with_index do |entity_and_initiative, index|
+                             entity, initiative = entity_and_initiative
+                             puts "#{index + 1}. #{decorate_name(entity)} #{initiative}"
+                           end
+                         },
+
+                         end_of_combat: lambda { |_event|
+                                          puts t('event.combat_end')
+                                        },
+                         grapple_success: lambda { |event|
+                           if event[:target_roll]
+                             puts 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',
+                                    source: show_name(event), target: event[:target]&.name)
+                           end
+                         },
+                         first_aid: lambda { |event|
+                           puts 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),
+                                                                                target: event[:target]&.name, roll: event[:roll], value: event[:roll].result)
+                                            },
+                         grapple_failure: lambda { |event|
+                           puts t('event.grapple_failure',
+                                  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_value].result)
+                         },
+                         drop_grapple: lambda { |event|
+                                         puts 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,
+                                                                          target: event[:target]&.name)
+                                 },
+                         shove_success: lambda do |event|
+                           opts = {
+                             source: event[:source]&.name, 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
+                           }
+                           if event[:knock_prone]
+                             puts t('event.knock_prone_success', opts)
+                           else
+                             puts t('event.shove_success', opts)
+                           end
+                         end,
+                         shove_failure: lambda do |event|
+                                          opts = {
+                                            source: event[:source]&.name, 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
+                                          }
+                                          if event[:knock_prone]
+                                            puts t('event.knock_prone_failure', opts)
+                                          else
+                                            puts t('event.shove_failure', opts)
+                                          end
+                                        end,
+                         %i[escape_grapple_success escape_grapple_failure] => lambda { |event|
+                                                                                puts t("event.#{event[:event]}",
+                                                                                       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)
+                                                                              } }
+      event_handlers.each do |k, v|
+        EventManager.register_event_listener(k, v)
+      end
+    end
+
+    # @param event [Hash]
+    def self.show_name(event)
+      decorate_name(event[:source])
+    end
+
+    # @param event [Hash]
+    def self.decorate_name(entity)
+      if @battle && @current_entity_context && entity
+
+        seen_attacker = @current_entity_context.detect do |c|
+          c == entity || @battle.map.can_see?(c, entity)
+        end
+        color = @battle.entity_group_for(seen_attacker) != @battle.entity_group_for(entity) ? :red : :blue
+        seen_attacker ? entity.name&.colorize(color) : I18n.t('event.something')
+      else
+        entity.name&.colorize(:blue)
+      end
+    end
+
+    def self.t(token, options = {})
+      I18n.t(token, options)
+    end
+  end
+end

data/lib/natural_20/item_library/base_item.rb

@@ -0,0 +1,27 @@
+# typed: true
+module ItemLibrary
+  class BaseItem
+    attr_reader :name
+
+    def initialize(name, properties)
+      @name = name
+      @properties = properties
+    end
+
+    def consumable?
+      !!@properties[:consumable]
+    end
+
+    def item?
+      true
+    end
+
+    def use!(battle, map, entity); end
+
+    protected
+
+    def t(key, options = {})
+      I18n.t(key, options)
+    end
+  end
+end

data/lib/natural_20/item_library/chest.rb

@@ -0,0 +1,230 @@
+# typed: false
+module ItemLibrary
+  class Chest < 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 :store
+        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 :loot
+        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 unlock!
+      @locked = false
+    end
+
+    def lock!
+      @locked = true
+    end
+
+    def locked?
+      @locked
+    end
+
+    def passable?
+      true
+    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?
+
+      t = opened? ? "\u2610" : "\u2610"
+      [t]
+    end
+
+    def color
+      opened? ? :white : super
+    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?
+        %i[close store loot]
+      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 :loot, :store
+        { action: action, items: other_params, source: entity, target: self, battle: opts[:battle] }
+      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 :store
+        store(result[:battle], result[:source], result[:target], result[:items])
+      when :loot
+        retrieve(result[:battle], result[:source], result[:target], result[:items])
+      when :open
+        open! if closed?
+      when :close
+        return unless opened?
+
+        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: t(:"object.chest.unlock"))
+      when :lockpick_fail
+        return unless locked?
+
+        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: t('object.lockpick_failed'))
+
+      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.chest.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.chest.lock"))
+      when :door_locked
+        Natural20::EventManager.received_event(source: self, user: entity, event: :object_interaction,
+                                               sub_type: :open_failed, result: :failed, reason: 'Cannot open chest since chest 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 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