natural_20 0.1.0

data/lib/natural_20/concerns/evaluator/entity_state_evaluator.rb

@@ -0,0 +1,59 @@
+module Natural20
+  module EntityStateEvaluator
+    # Safely evaluates a DSL to return a boolean expression
+    # @param conditions [String]
+    # @param context [Hash]
+    # @return [Boolean]
+    def eval_if(conditions, context = {})
+      or_groups = conditions.split('|')
+      !!or_groups.detect do |g|
+        and_groups = g.split('&')
+        and_groups.detect do |and_g|
+          cmd, test_expression = and_g.strip.split(':')
+          invert = test_expression[0] == '!'
+          test_expression = test_expression[1..test_expression.size - 1] if test_expression[0] == '!'
+          result = case cmd.to_sym
+                   when :inventory
+                     item_count(test_expression).positive?
+                   when :equipped
+                     equipped_items.map(&:name).include?(test_expression.to_sym)
+                   when :object_type
+                     context[:item_type].to_s.downcase == test_expression.to_s.downcase
+                   when :target
+                     (test_expression == 'object' && context[:target].object?)
+                   when :entity
+                     (test_expression == 'pc' && pc?) ||
+                     (test_expression == 'npc' && npc?)
+                   when :state
+                     case test_expression
+                     when 'unconscious'
+                       unconscious?
+                     when 'stable'
+                       stable?
+                     when 'dead'
+                       dead?
+                     when 'conscious'
+                       conscious?
+                     end
+                   else
+                     raise "Invalid expression #{cmd} #{test_expression}"
+                   end
+
+          invert ? result : !result
+        end.nil?
+      end
+    end
+
+    def apply_effect(expression, context = {})
+      action, value = expression.split(':')
+      case action
+      when 'status'
+        {
+          source: self,
+          type: value.to_sym,
+          battle: context[:battle]
+        }
+      end
+    end
+  end
+end

data/lib/natural_20/concerns/fighter_actions/second_wind_action.rb

@@ -0,0 +1,51 @@
+# typed: true
+class SecondWindAction < Natural20::Action
+  def self.can?(entity, battle)
+    (battle.nil? || entity.total_bonus_actions(battle).positive?) && entity.second_wind_count.positive?
+  end
+
+  def label
+    'Second Wind'
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: nil,
+                     next: -> { self }
+                   })
+  end
+
+  def self.build(session, source)
+    action = SecondWindAction.new(session, source, :second_wind)
+    action.build_map
+  end
+
+  def resolve(_session, _map, opts = {})
+    second_wind_roll = Natural20::DieRoll.roll(@source.second_wind_die, description: t('dice_roll.second_wind'),
+                                                                        entity: @source, battle: opts[:battle])
+    @result = [{
+      source: @source,
+      roll: second_wind_roll,
+      type: :second_wind,
+      battle: opts[:battle]
+    }]
+    self
+  end
+
+  def apply!(battle)
+    @result.each do |item|
+      case (item[:type])
+      when :second_wind
+        Natural20::EventManager.received_event(action: self.class, source: item[:source], roll: item[:roll],
+                                               event: :second_wind)
+        item[:source].second_wind!(item[:roll].result)
+        battle.entity_state_for(item[:source])[:bonus_action] -= 1
+      end
+    end
+  end
+
+  def self.describe(event)
+    "#{event[:source].name.colorize(:green)} uses " + 'Second Wind'.colorize(:blue) + " with #{event[:roll]} healing"
+  end
+end

data/lib/natural_20/concerns/fighter_class.rb

@@ -0,0 +1,35 @@
+# typed: false
+require "natural_20/concerns/fighter_actions/second_wind_action"
+
+module Natural20::FighterClass
+  attr_accessor :fighter_level, :second_wind_count
+
+  def initialize_fighter
+    @second_wind_count = 1
+  end
+
+  def second_wind_die
+    "1d10+#{@fighter_level}"
+  end
+
+  def second_wind!(amt)
+    @second_wind_count -= 1
+    heal!(amt)
+  end
+
+  def special_actions_for_fighter(session, battle)
+    %i[second_wind].map do |type|
+      next unless "#{type.to_s.camelize}Action".constantize.can?(self, battle)
+
+      case type
+      when :second_wind
+        SecondWindAction.new(session, self, :second_wind)
+      end
+    end.compact
+  end
+
+  # hooks for the fighter class during a short rest
+  def short_rest_for_fighter
+    @second_wind_count = 1
+  end
+end

data/lib/natural_20/concerns/health_flavor.rb

@@ -0,0 +1,27 @@
+# typed: false
+module Natural20::HealthFlavor
+  def describe_health
+    return '' if hp.zero? || hp.negative?
+
+    percentage = (hp.to_f / max_hp) * 100
+
+    token = if dead?
+              'dead'
+            elsif unconscious?
+              'unconscious'
+            elsif percentage > 90
+              'max'
+            elsif percentage > 75
+              'over_75'
+            elsif percentage > 50
+              'over_50'
+            elsif percentage > 25
+              'over_25'
+            elsif percentage > 10
+              'over_10'
+            else
+              'almost_dead'
+            end
+    t("entity.health_flavor.#{token}")
+  end
+end

data/lib/natural_20/concerns/lootable.rb

@@ -0,0 +1,94 @@
+module Natural20::Lootable
+  include Natural20::Container
+
+  # 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 :give
+      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 + equipped_items
+                         }
+                       ],
+                       next: lambda { |items|
+                               action_object.other_params = items
+                               OpenStruct.new({
+                                                param: nil,
+                                                next: lambda {
+                                                        action_object
+                                                      }
+                                              })
+                             }
+                     })
+    end
+  end
+
+  # Lists default available interactions for an entity
+  # @param entity [Natural20::Entity]
+  # @param battle [Natural20::Battle]
+  # @return [Array] List of availabel actions
+  def available_interactions(entity, battle = nil)
+    other_interactions = super entity, battle
+    other_interactions << :give if !npc? || object?
+    # other_interactions << :pickpocket if !unconscious && npc?
+    other_interactions << :loot if (dead? || unconscious? || opened?) && inventory_count.positive?
+
+    other_interactions
+  end
+
+  def interactable?
+    true
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param action [InteractAction]
+  # @param other_params [Hash]
+  def resolve(entity, action, other_params, opts = {})
+    return if action.nil?
+
+    case action
+    when :give, :loot
+      { action: action, items: other_params, source: entity, target: self, battle: opts[:battle] }
+    end
+  end
+
+  # @param entity [Natural20::Entity]
+  # @option result action [Symbol]
+  # @option result items [Array]
+  # @option result source [Natural20::Entity]
+  def use!(_entity, result)
+    case (result[:action])
+    when :give
+      store(result[:battle], result[:source], result[:target], result[:items])
+    when :loot
+      retrieve(result[:battle], result[:source], result[:target], result[:items])
+    end
+  end
+end

data/lib/natural_20/concerns/movement_helper.rb

@@ -0,0 +1,195 @@
+# typed: true
+module Natural20::MovementHelper
+  class Movement
+    def initialize(movement, original_budget, acrobatics_check_locations, athletics_check_locations, jump_locations, jump_start_locations, land_locations, jump_budget, budget, impediment)
+      @jump_start_locations = jump_start_locations
+      @athletics_check_locations = athletics_check_locations
+      @jump_locations = jump_locations
+      @land_locations = land_locations
+      @jump_budget = jump_budget
+      @movement = movement
+      @original_budget = original_budget
+      @acrobatics_check_locations = acrobatics_check_locations
+      @impediment = impediment
+      @budget = budget
+    end
+
+    # @return [Natural20::Movement]
+    def self.empty
+      Movement.new([], 0, [], [], [], [], [], 0, 0, :nil)
+    end
+
+    # @return [Integer]
+    attr_reader :budget
+
+    # @return [Symbol]
+    attr_reader :impediment
+
+    # @return [Array]
+    attr_reader :movement
+
+    # @return [Integer]
+    attr_reader :jump_budget
+
+    # @return [Array]
+    attr_reader :jump_start_locations
+
+    # @return [Array]
+    attr_reader :jump_locations
+
+    # @return [Array]
+    attr_reader :land_locations
+
+    # @return [Array]
+    attr_reader :acrobatics_check_locations
+
+    # @return [Array]
+    attr_reader :athletics_check_locations
+
+    # @return [Integer]
+    def cost
+      (@original_budget - @budget)
+    end
+  end
+
+  # Checks if move path is valid
+  # @param entity [Natural20::Entity]
+  # @param path [Array]
+  # @param battle [Natural20::Battle]
+  # @param map [Natural20::BattleMap]
+  # @param test_placement [Boolean]
+  # @param manual_jump [Array]
+  # @return [Boolean]
+  def valid_move_path?(entity, path, battle, map, test_placement: true, manual_jump: [])
+    path == compute_actual_moves(entity, path, map, battle, entity.available_movement(battle) / map.feet_per_grid,
+                                 test_placement: test_placement, manual_jump: manual_jump).movement
+  end
+
+  # Determine if entity needs to squeeze to get through terrain
+  # @param entity [Natural20::Entity]
+  # @param pos_x [Integer]
+  # @param pos_y [Integer]
+  # @param map [Natural20::BattleMap]
+  # @param battle [Natural20::Battle]
+  # @return [Boolean]
+  def requires_squeeze?(entity, pos_x, pos_y, map, battle = nil)
+    !map.passable?(entity, pos_x, pos_y, battle, false) && map.passable?(entity, pos_x, pos_y, battle, true)
+  end
+
+  # @param entity [Natural20::Entity]
+  # @param current_moves [Array]
+  # @param map [Natural20::BattleMap]
+  # @param battle [Natural20::Battle]
+  # @param movement_budget [Integer] movement budget in number of squares (feet/5 by default)
+  # @param test_placement [Boolean] If true tests if last move is placeable on the map
+  # @param manual_jump [Array] Indices of moves that are supposed to be jumps
+  # @return [Movement]
+  def compute_actual_moves(entity, current_moves, map, battle, movement_budget, fixed_movement: false, test_placement: true, manual_jump: [])
+    actual_moves = []
+    provisional_moves = []
+    jump_budget = (entity.standing_jump_distance / map.feet_per_grid).floor
+    running_distance = 1
+    jump_distance = 0
+    jumped = false
+    acrobatics_check_locations = []
+    athletics_check_locations = []
+    jump_start_locations = []
+    land_locations = []
+    jump_locations = []
+    impediment = nil
+    original_budget = movement_budget
+
+    current_moves.each_with_index do |m, index|
+      raise "invalid move coordinate" unless m.size == 2 # assert move correctness
+
+      unless index.positive?
+        actual_moves << m
+        next
+      end
+
+      unless map.passable?(entity, *m, battle)
+        impediment = :path_blocked
+        break
+      end
+
+      if fixed_movement
+        movement_budget -= 1
+      else
+        movement_budget -= if !manual_jump.include?(index) && map.difficult_terrain?(entity, *m, battle)
+                             2
+                           else
+                             1
+                           end
+        movement_budget -= 1 if requires_squeeze?(entity, *m, map, battle)
+        movement_budget -= 1 if entity.prone?
+        movement_budget -= 1 if entity.grappling?
+      end
+
+      if movement_budget.negative?
+        impediment = :movement_budget
+        break
+      end
+
+      if !fixed_movement && (map.jump_required?(entity, *m) || manual_jump.include?(index))
+        if entity.prone? # can't jump if prone
+          impediment = :prone_need_to_jump
+          break
+        end
+
+        jump_start_locations << m unless jumped
+        jump_locations << m
+        jump_budget -= 1
+        jump_distance += 1
+        if !fixed_movement && jump_budget.negative?
+          impediment = :jump_distance_not_enough
+          break
+        end
+
+        running_distance = 0
+        jumped = true
+        provisional_moves << m
+
+        entity_at_square = map.entity_at(*m)
+        athletics_check_locations << m if entity_at_square&.conscious? && !entity_at_square&.prone?
+      else
+        actual_moves += provisional_moves
+        provisional_moves.clear
+
+        land_locations << m if jumped
+        acrobatics_check_locations << m if jumped && map.difficult_terrain?(entity, *m,
+                                                                            battle)
+        running_distance += 1
+
+        # if jump not required reset jump budgets
+        jump_budget = if running_distance > 1
+                        (entity.long_jump_distance / map.feet_per_grid).floor
+                      else
+                        (entity.standing_jump_distance / map.feet_per_grid).floor
+                      end
+        jumped = false
+        jump_distance = 0
+        actual_moves << m
+      end
+    end
+
+    # handle case where end is a jump, in that case we land if this is possible
+    unless provisional_moves.empty?
+      actual_moves += provisional_moves
+      m = actual_moves.last
+      land_locations << m if jumped
+      acrobatics_check_locations << m if jumped && map.difficult_terrain?(entity, *m,
+                                                                          battle)
+      jump_locations.delete(actual_moves.last)
+    end
+
+    while test_placement && !map.placeable?(entity, *actual_moves.last, battle)
+      impediment = :not_placeable
+      jump_locations.delete(actual_moves.last)
+      actual_moves.pop
+    end
+
+    Movement.new(actual_moves, original_budget, acrobatics_check_locations, athletics_check_locations, jump_locations, jump_start_locations, land_locations, jump_budget,
+                 movement_budget, impediment)
+  end
+
+end