natural_20 0.1.0

data/lib/natural_20/session.rb

@@ -0,0 +1,168 @@
+# typed: true
+module Natural20
+  class Session
+    attr_reader :root_path, :game_properties, :game_time
+
+    # @param root_path [String] The current adventure working folder
+    # @return [Natural20::Session]
+    def self.new_session(root_path = nil)
+      @session = Natural20::Session.new(root_path)
+      @session
+    end
+
+    # @return [Natural20::Session]
+    def self.current_session
+      @session
+    end
+
+    def initialize(root_path = nil)
+      @root_path = root_path.presence || '.'
+      @session_state = {}
+      @weapons = {}
+      @equipment = {}
+      @objects = {}
+      @thing = {}
+      @char_classes = {}
+      @settings = {
+        manual_dice_roll: false
+      }
+      @game_time = 0 # game time in seconds
+
+      I18n.load_path << Dir[File.join(@root_path, 'locales') + '/*.yml']
+      I18n.default_locale = :en
+      if File.exist?(File.join(@root_path, 'game.yml'))
+        @game_properties = YAML.load_file(File.join(@root_path, 'game.yml')).deep_symbolize_keys!
+      else
+        raise t(:missing_game)
+      end
+    end
+
+    VALID_SETTINGS = %i[manual_dice_roll].freeze
+
+    # @options settings manual_dice_roll [Boolean]
+    def update_settings(settings = {})
+      settings.each_key { |k| raise 'invalid settings' unless VALID_SETTINGS.include?(k.to_sym) }
+
+      @settings.deep_merge!(settings.deep_symbolize_keys)
+    end
+
+    def setting(k)
+      raise 'invalid settings' unless VALID_SETTINGS.include?(k.to_sym)
+
+      @settings[k.to_sym]
+    end
+
+    def increment_game_time!(seconds = 6)
+      @game_time += seconds
+    end
+
+    def load_characters
+      files = Dir[File.join(@root_path, 'characters', '*.yml')]
+      @characters ||= files.map do |file|
+        YAML.load_file(file)
+      end
+      @characters.map do |char_content|
+        Natural20::PlayerCharacter.new(self, char_content)
+      end
+    end
+
+    # store a state
+    # @param state_type [String,Symbol]
+    # @param value [Hash]
+    def save_state(state_type, value = {})
+      @session_state[state_type.to_sym] ||= {}
+      @session_state[state_type.to_sym].deep_merge!(value)
+    end
+
+    def load_state(state_type)
+      @session_state[state_type.to_sym] || {}
+    end
+
+    def has_save_game?
+      File.exist?(File.join(@root_path, 'savegame.yml'))
+    end
+
+    # @param battle [Natural20::BattleMap]
+    def save_game(battle)
+      File.write(File.join(@root_path, 'savegame.yml'), battle.to_yaml)
+    end
+
+    def save_character(name, data)
+      File.write(File.join(@root_path, 'characters', "#{name}.yml"), data.to_yaml)
+    end
+
+    # @return [Natural20::Battle]
+    def load_save
+      YAML.load_file(File.join(@root_path, 'savegame.yml'))
+    end
+
+    def npc(npc_type, options = {})
+      Natural20::Npc.new(self, npc_type, options)
+    end
+
+    def load_npcs
+      files = Dir[File.join(@root_path, 'npcs', '*.yml')]
+      files.map do |fname|
+        npc_name = File.basename(fname, '.yml')
+        Natural20::Npc.new(self, npc_name, rand_life: true)
+      end
+    end
+
+    def load_races
+      files = Dir[File.join(@root_path, 'races', '*.yml')]
+      files.map do |fname|
+        race_name = File.basename(fname, '.yml')
+        [race_name, YAML.load_file(fname).deep_symbolize_keys!]
+      end.to_h
+    end
+
+    def load_classes
+      files = Dir[File.join(@root_path, 'char_classes', '*.yml')]
+      files.map do |fname|
+        class_name = File.basename(fname, '.yml')
+        [class_name, YAML.load_file(fname).deep_symbolize_keys!]
+      end.to_h
+    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!
+      end
+    end
+
+    def load_weapon(weapon)
+      @weapons[weapon.to_sym] ||= begin
+        weapons = YAML.load_file(File.join(@root_path, 'items', 'weapons.yml')).deep_symbolize_keys!
+        weapons[weapon.to_sym]
+      end
+    end
+
+    def load_weapons
+      YAML.load_file(File.join(@root_path, 'items', 'weapons.yml')).deep_symbolize_keys!
+    end
+
+    def load_thing(item)
+      @thing[item.to_sym] ||= begin
+        load_weapon(item) || load_equipment(item) || load_object(item)
+      end
+    end
+
+    def load_equipment(item)
+      @equipment[item.to_sym] ||= begin
+        equipment = YAML.load_file(File.join(@root_path, 'items', 'equipment.yml')).deep_symbolize_keys!
+        equipment[item.to_sym]
+      end
+    end
+
+    def load_object(object_name)
+      @objects[object_name.to_sym] ||= begin
+        objects = YAML.load_file(File.join(@root_path, 'items', 'objects.yml')).deep_symbolize_keys!
+        objects[object_name.to_sym]
+      end
+    end
+
+    def t(token, options = {})
+      I18n.t(token, options)
+    end
+  end
+end

data/lib/natural_20/utils/cover.rb

@@ -0,0 +1,35 @@
+module Natural20::Cover
+  # @param map [Natural20::BattleMap]
+  # @param source [Natural20::Entity]
+  # @param target [Natural20::Entity]
+  # @param entity_1_pos [Array<Integer,Integer>]
+  # @param entity_2_pos [Array<Integer,Integer>]
+  # @return [Integer]
+  def cover_calculation(map, source, target, entity_1_pos: nil, entity_2_pos: nil, naturally_stealthy: false)
+    source_squares = entity_1_pos ? map.entity_squares_at_pos(source, *entity_1_pos) : map.entity_squares(source)
+    target_squares = entity_2_pos ? map.entity_squares_at_pos(target, *entity_2_pos) : map.entity_squares(target)
+    source_position = map.position_of(source)
+    source_melee_square = source.melee_squares(map, target_position: source_position, adjacent_only: true)
+
+    source_squares.map do |source_pos|
+      target_squares.map do |target_pos|
+        cover_characteristics = map.line_of_sight?(*source_pos, *target_pos, nil, true, naturally_stealthy)
+        next 0 unless cover_characteristics
+
+        max_ac = 0
+        cover_characteristics.each do |cover|
+          cover_type, pos = cover
+
+          next if cover_type == :none
+          next if source_melee_square.include?(pos)
+
+          max_ac = [max_ac, 2].max if cover_type == :half
+          max_ac = [max_ac, 5].max if cover_type == :three_quarter
+
+          return 1 if cover_type.is_a?(Integer) && naturally_stealthy && (cover_type - target.size_identifier) >= 1
+        end
+        max_ac
+      end.min
+    end.min || 0
+  end
+end

data/lib/natural_20/utils/ray_tracer.rb

@@ -0,0 +1,90 @@
+# typed: false
+# class used for ray trace and path trace computations
+class RayTracer
+  def initialize(map)
+    @map = map
+  end
+
+  def ray_trace(pos1_x, pos1_y, pos2_x, pos2_y, _max_distance)
+    return true if [pos1_x, pos1_y] == [pos2_x, pos2_y]
+
+    if pos2_x == pos1_x
+      scanner = pos2_y > pos1_y ? (pos1_y...pos2_y) : (pos2_y...pos1_y)
+
+      scanner.each_with_index do |y, index|
+        return false if !distance.nil? && index > distance
+        next if (y == pos1_y) || (y == pos2_y)
+        return false if @map.opaque?(pos1_x, y)
+      end
+      true
+    else
+      m = (pos2_y - pos1_y).to_f / (pos2_x - pos1_x)
+      scanner = pos2_x > pos1_x ? (pos1_x...pos2_x) : (pos2_x...pos1_x)
+      if m.zero?
+
+        scanner.each_with_index do |x, index|
+          return false if !distance.nil? && index > distance
+          next if (x == pos1_x) || (x == pos2_x)
+          return false if @map.opaque?(x, pos2_y)
+        end
+
+        true
+      else
+
+        b = pos1_y - m * pos1_x
+        step = m.abs > 1 ? 1 / m.abs : m.abs
+
+        scanner.step(step).each_with_index do |x, index|
+          y = (m * x + b).round
+
+          return false if !distance.nil? && index > distance
+          next if (x.round == pos1_x && y == pos1_y) || (x.round == pos2_x && y == pos2_y)
+          return false if @map.opaque?(x.round, y)
+        end
+        true
+      end
+    end
+  end
+
+  def line_of_sight?(pos1_x, pos1_y, pos2_x, pos2_y, distance = nil)
+    return true if [pos1_x, pos1_y] == [pos2_x, pos2_y]
+
+    if pos2_x == pos1_x
+      scanner = pos2_y > pos1_y ? (pos1_y...pos2_y) : (pos2_y...pos1_y)
+
+      scanner.each_with_index do |y, index|
+        return false if !distance.nil? && index > distance
+        next if (y == pos1_y) || (y == pos2_y)
+        return false if @map.opaque?(pos1_x, y)
+      end
+      true
+    else
+      m = (pos2_y - pos1_y).to_f / (pos2_x - pos1_x)
+      if m == 0
+        scanner = pos2_x > pos1_x ? (pos1_x...pos2_x) : (pos2_x...pos1_x)
+
+        scanner.each_with_index do |x, index|
+          return false if !distance.nil? && index > distance
+          next if (x == pos1_x) || (x == pos2_x)
+          return false if @map.opaque?(x, pos2_y)
+        end
+
+        true
+      else
+        scanner = pos2_x > pos1_x ? (pos1_x...pos2_x) : (pos2_x...pos1_x)
+
+        b = pos1_y - m * pos1_x
+        step = m.abs > 1 ? 1 / m.abs : m.abs
+
+        scanner.step(step).each_with_index do |x, index|
+          y = (m * x + b).round
+
+          return false if !distance.nil? && index > distance
+          next if (x.round == pos1_x && y == pos1_y) || (x.round == pos2_x && y == pos2_y)
+          return false if @map.opaque?(x.round, y)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/natural_20/utils/static_light_builder.rb

@@ -0,0 +1,72 @@
+module Natural20
+  class StaticLightBuilder
+    attr_reader :lights
+
+    # @param battlemap [Natural20::BattleMap] location of the map yml file
+    def initialize(battlemap)
+      @map = battlemap
+      @properties = battlemap.properties
+      @light_properties = @properties[:lights]
+      @light_map = @properties.dig(:map, :light)
+      @base_illumniation = @properties.dig(:map, :illumination) || 1.0
+      @lights = []
+      if @light_map && @light_properties
+        @light_map.each_with_index do |row, cur_y|
+          row.each_char.map(&:to_sym).each_with_index do |key, cur_x|
+            next unless @light_properties[key]
+
+            @lights << {
+              position: [cur_x, cur_y]
+            }.merge(@light_properties[key])
+          end
+        end
+      end
+    end
+
+    def build_map
+      max_x, max_y = @map.size
+      max_y.times.map do |y|
+        max_x.times.map do |x|
+          @lights.inject(@base_illumniation) do |intensity, light|
+            light_pos_x, light_pos_y = light[:position]
+            bright_light = light.fetch(:bright, 10) / @map.feet_per_grid
+            dim_light = light.fetch(:dim, 5) / @map.feet_per_grid
+
+            intensity + if @map.line_of_sight?(x, y, light_pos_x, light_pos_y, bright_light, false)
+                          1.0
+                        elsif @map.line_of_sight?(x, y, light_pos_x, light_pos_y, bright_light + dim_light, false)
+                          0.5
+                        else
+                          0.0
+                        end
+          end
+        end
+      end.transpose
+    end
+
+    # @param pos_x [Integer]
+    # @parma pos_y [Integer]
+    # @return [Float]
+    def light_at(pos_x, pos_y)
+      (@map.entities.keys + @map.interactable_objects.keys).inject(0.0) do |intensity, entity|
+        next intensity if entity.light_properties.nil?
+
+        light = entity.light_properties
+        bright_light = light.fetch(:bright, 0.0) / @map.feet_per_grid
+        dim_light = light.fetch(:dim, 0.0) / @map.feet_per_grid
+
+        next intensity if (bright_light + dim_light) <= 0.0
+
+        light_pos_x, light_pos_y = @map.entity_or_object_pos(entity)
+
+        intensity + if @map.line_of_sight?(pos_x, pos_y, light_pos_x, light_pos_y, bright_light, false)
+                      1.0
+                    elsif @map.line_of_sight?(pos_x, pos_y, light_pos_x, light_pos_y, bright_light + dim_light, false)
+                      0.5
+                    else
+                      0.0
+                    end
+      end
+    end
+  end
+end

data/lib/natural_20/utils/weapons.rb

@@ -0,0 +1,78 @@
+# reusable utility methods for weapon calculations
+module Natural20::Weapons
+  # Check all the factors that affect advantage/disadvantage in attack rolls
+  def target_advantage_condition(battle, source, target, weapon, source_pos: nil)
+    advantages, disadvantages = compute_advantages_and_disadvantages(battle, source, target, weapon,
+                                                                     source_pos: source_pos)
+
+    return [0, [advantages, disadvantages]] if advantages.empty? && disadvantages.empty?
+    return [0, [advantages, disadvantages]] if !advantages.empty? && !disadvantages.empty?
+
+    return [1, [advantages, disadvantages]] unless advantages.empty?
+
+    [-1, [advantages, disadvantages]]
+  end
+
+  # Compute all advantages and disadvantages
+  # @param battle [Natural20::Battle]
+  # @param source [Natural20::Entity]
+  # @param target [Natural20::Entity]
+  # @option weapon type [String]
+  # @return [Array]
+  def compute_advantages_and_disadvantages(battle, source, target, weapon, source_pos: nil)
+    weapon = battle.session.load_weapon(weapon) if weapon.is_a?(String) || weapon.is_a?(Symbol)
+    advantage = []
+    disadvantage = []
+
+    disadvantage << :prone if source.prone?
+    disadvantage << :squeezed if source.squeezed?
+    disadvantage << :target_dodge if target.dodge?(battle)
+    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]
+
+    if 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
+
+    if source.class_feature?('pack_tactics') && battle.ally_within_enemey_melee_range?(source, target,
+                                                                                       source_pos: source_pos)
+      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?
+
+    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)
+    [advantage, disadvantage]
+  end
+
+  # Calculates weapon damage roll
+  # @param entity [Natural20::Entity]
+  # @param weapon [Hash] weapon descriptor
+  # @param second_hand [Boolean] Second hand to be used for two weapon fighting
+  # @return [String]
+  def damage_modifier(entity, weapon, second_hand: false)
+    damage_mod = entity.attack_ability_mod(weapon)
+
+    damage_mod = [damage_mod, 0].min if second_hand && !entity.class_feature?('two_weapon_fighting')
+
+    # compute damage roll using versatile weapon property
+    damage_roll = if weapon[:properties]&.include?('versatile') && entity.used_hand_slots <= 1.0
+                    weapon[:damage_2]
+                  else
+                    weapon[:damage]
+                  end
+
+    # duelist class feature
+    if entity.class_feature?('dueling') && weapon[:type] == 'melee_attack' && entity.used_hand_slots(weapon_only: true) <= 1.0
+      damage_mod += 2
+    end
+
+    "#{damage_roll}+#{damage_mod}"
+  end
+end