natural_20 0.1.0

data/lib/natural_20/concerns/multiattack.rb

@@ -0,0 +1,54 @@
+# typed: false
+module Multiattack
+  def setup_attributes
+    super
+  end
+
+  # Get available multiattack actions
+  # @param session [Natural20::Session]
+  # @param battle [Natural20::Battle]
+  # @return [Array]
+  def multi_attack_actions(session, battle)
+  end
+
+  # @param battle [Natural20::Battle]
+  def reset_turn!(battle)
+    entity_state = super battle
+
+    return entity_state unless class_feature?("multiattack")
+
+    multiattack_groups = {}
+    @properties[:actions].select { |a| a[:multiattack_group] }.each do |a|
+      multiattack_groups[a[:multiattack_group]] ||= []
+      multiattack_groups[a[:multiattack_group]] << a[:name]
+    end
+
+    entity_state[:multiattack] = multiattack_groups
+
+    entity_state
+  end
+
+  # @param battle [Natural20::Battle]
+  def clear_multiattack!(battle)
+    entity_state = battle.entity_state_for(self)
+    entity_state[:multiattack] = {}
+  end
+
+  # @param battle [Natural20::Battle]
+  # @param npc_action [Hash]
+  def multiattack?(battle, npc_action)
+    return false unless npc_action
+    return false unless class_feature?("multiattack")
+
+    entity_state = battle.entity_state_for(self)
+
+    return false unless entity_state[:multiattack]
+    return false unless npc_action[:multiattack_group]
+
+    entity_state[:multiattack].each do |_group, attacks|
+      return true if attacks.include?(npc_action[:name])
+    end
+
+    false
+  end
+end

data/lib/natural_20/concerns/navigation.rb

@@ -0,0 +1,87 @@
+module Natural20::Navigation
+  include Natural20::Weapons
+
+  # @param map [natural20::BattleMap]
+  # @param battle [Natural20::Battle]
+  # @param entity [Natural20::Entity]
+  def candidate_squares(map, battle, entity)
+    compute = AiController::PathCompute.new(battle, map, entity)
+    cur_pos_x, cur_pos_y = map.entity_or_object_pos(entity)
+
+    compute.build_structures(cur_pos_x, cur_pos_y)
+    compute.path
+
+    candidate_squares = [[[cur_pos_x, cur_pos_y], 0]]
+    map.size[0].times.each do |pos_x|
+      map.size[1].times.each do |pos_y|
+        next unless map.line_of_sight_for?(entity, pos_x, pos_y)
+        next unless map.placeable?(entity, pos_x, pos_y, battle)
+
+        path, cost = compute.incremental_path(cur_pos_x, cur_pos_y, pos_x, pos_y)
+        next if path.nil?
+
+        candidate_squares << [[pos_x, pos_y], cost.floor]
+      end
+    end
+    candidate_squares.uniq.to_h
+  end
+
+  # @param map [Natural20::BattleMap]
+  # @param battle [Natural20::Battle]
+  # @param entity [Natural20::Entity]
+  # @param opponents [Array<Natural20::Entity>]
+  def evaluate_square(map, battle, entity, opponents)
+    melee_attack_squares = {}
+    opponents.each do |opp|
+      opp.melee_squares(map).each do |pos|
+        melee_attack_squares[pos] ||= 0
+        melee_attack_squares[pos] += 1
+      end
+    end
+
+    attack_options = if entity.npc?
+                       entity.npc_actions.map do |npc_action|
+                         next if npc_action[:ammo] && entity.item_count(npc_action[:ammo]) <= 0
+                         next if npc_action[:if] && !entity.eval_if(npc_action[:if])
+                         next unless npc_action[:type] == 'melee_attack'
+
+                         npc_action
+                       end.first
+                     end
+
+    destinations = candidate_squares(map, battle, entity)
+    destinations.map do |d, _cost|
+      # evaluate defense
+      melee_offence = 0.0
+      ranged_offence = 0.0
+      defense = 0.0
+      mobility = 0.0
+      support = 0.0
+
+      if melee_attack_squares.key?(d)
+        melee_offence += 0.1
+        defense -= 0.05 * melee_attack_squares[d]
+        if attack_options
+          opponents.each do |opp|
+            adv, _adv_info = target_advantage_condition(battle, entity, opp, attack_options, source_pos: d)
+            melee_offence += adv
+          end
+        end
+      else
+        ranged_offence += 0.1
+        opponents.each do |opp|
+          defense += map.cover_calculation(map, opp, entity, entity_2_pos: d,
+                                                             naturally_stealthy: entity.class_feature?('naturally_stealthy')).to_f
+        end
+      end
+
+      if map.requires_squeeze?(entity, *d, map, battle)
+        mobility -= 1.0
+        melee_offence -= 0.5
+        ranged_offence -= 0.5
+      end
+
+      [d, [melee_offence, ranged_offence, defense, mobility, support]]
+    end.to_h
+  end
+end

data/lib/natural_20/concerns/notable.rb

@@ -0,0 +1,37 @@
+module Natural20
+  # Concerns used for objects that can have notes
+  module Notable
+    # List notes on object
+    # @param entity [Natural20::Entity]
+    # @param perception [Integer]
+    # @return [Array]
+    def list_notes(entity, perception, highlight: false)
+      @properties[:notes]&.map do |note|
+        next if highlight && !note[:highlight]
+        next if note[:if].presence && !eval_if(note[:if])
+
+        perception_dc = note[:perception_dc] || 0
+        if perception >= perception_dc
+          note_language = note[:language].presence
+
+          result = if note_language
+                     note_content = if entity.languages.include?(note_language)
+                                      note[:note]
+                                    else
+                                      '???'
+                                    end
+                     t('perception.note_with_language', note_language: note_language, note: note_content)
+                   else
+                     note[:note]
+                   end
+
+          if perception_dc.positive?
+            t('perception.passed', note: result)
+          else
+            result
+          end
+        end
+      end&.compact || []
+    end
+  end
+end

data/lib/natural_20/concerns/rogue_class.rb

@@ -0,0 +1,26 @@
+# typed: false
+module Natural20::RogueClass
+  attr_accessor :rogue_level
+
+  def initialize_rogue
+  end
+
+  def sneak_attack_level
+    [
+      "1d6", "1d6",
+      "2d6", "2d6",
+      "3d6", "3d6",
+      "4d6", "4d6",
+      "5d6", "5d6",
+      "6d6", "6d6",
+      "7d6", "7d6",
+      "8d6", "8d6",
+      "9d6", "9d6",
+      "10d6", "10d6",
+    ][level]
+  end
+
+  def special_actions_for_rogue(session, battle)
+    []
+  end
+end

data/lib/natural_20/controller.rb

@@ -0,0 +1,11 @@
+module Natural20
+  class Controller
+    def roll_for(entity, die_type, number_of_times, description, advantage: false, disadvantage: false); end
+
+    # Return moves by a player using the commandline UI
+    # @param entity [Natural20::Entity] The entity to compute moves for
+    # @param battle [Natural20::Battle] An instance of the current battle
+    # @return [Array(Natural20::Action)]
+    def move_for(entity, battle); end
+  end
+end

data/lib/natural_20/die_roll.rb

@@ -0,0 +1,331 @@
+# typed: true
+module Natural20
+  class DieRollDetail
+    # @return [Integer]
+    attr_accessor :die_count
+
+    # @return [String]
+    attr_accessor :die_type
+
+    # @return [Integer]
+    attr_accessor :modifier
+
+    # @return [Symbol]
+    attr_accessor :modifier_op
+  end
+
+  class Roller
+    attr_reader :roll_str, :crit, :advantage, :disadvantage, :description, :entity, :battle
+
+    def initialize(roll_str, crit: false, disadvantage: false, advantage: false, description: nil, entity: nil, battle: nil)
+      @roll_str = roll_str
+      @crit = crit
+      @advantage = advantage
+      @disadvantage = disadvantage
+      @description = description
+      @entity = entity
+      @battle = battle
+    end
+
+    # @param lucky [Boolean] This is a lucky feat reroll
+    def roll(lucky: false, description_override: nil)
+      die_sides = 20
+
+      detail = DieRoll.parse(roll_str)
+      number_of_die = detail.die_count
+      die_type_str = detail.die_type
+      modifier_str = detail.modifier
+      modifier_op = detail.modifier_op
+
+      if die_type_str.blank?
+        return Natural20::DieRoll.new([number_of_die], "#{modifier_op}#{modifier_str}".to_i, 0,
+                                      roller: self)
+      end
+
+      die_sides = die_type_str.to_i
+
+      number_of_die *= 2 if crit
+
+      description = t('dice_roll.description', description: description_override.presence || @description,
+                                               roll_str: roll_str)
+      description = lucky ? "(lucky) #{description}" : description
+
+      description = '(with advantage)'.colorize(:blue) + description if advantage
+      description = '(with disadvantage)'.colorize(:red) + description if disadvantage
+      rolls = if advantage || disadvantage
+                if battle
+                  battle.roll_for(entity, die_sides, number_of_die, description, advantage: advantage,
+                                                                                 disadvantage: disadvantage)
+                else
+                  number_of_die.times.map { [(1..die_sides).to_a.sample, (1..die_sides).to_a.sample] }
+                end
+              elsif battle
+                battle.roll_for(entity, die_sides, number_of_die, description)
+              else
+                number_of_die.times.map { (1..die_sides).to_a.sample }
+              end
+      Natural20::DieRoll.new(rolls, modifier_str.blank? ? 0 : "#{modifier_op}#{modifier_str}".to_i, die_sides,
+                             advantage: advantage, disadvantage: disadvantage, roller: self)
+    end
+
+    def t(key, options = {})
+      I18n.t(key, options)
+    end
+  end
+
+  class DieRoll
+    class DieRolls
+      attr_accessor :rolls
+
+      def initialize(rolls = [])
+        @rolls = rolls
+      end
+
+      def add_to_front(die_roll)
+        if die_roll.is_a?(Natural20::DieRoll)
+          @rolls.unshift(die_roll)
+        elsif die_roll.is_a?(DieRolls)
+          @rolls = die_roll.rolls + @rolls
+        end
+      end
+
+      def +(other)
+        if other.is_a?(Natural20::DieRoll)
+          @rolls << other
+        elsif other.is_a?(DieRolls)
+          @rolls += other.rolls
+        end
+      end
+
+      def result
+        @rolls.inject(0) do |sum, roll|
+          sum + roll.result
+        end
+      end
+
+      def ==(other)
+        return false if other.rolls.size != @rolls.size
+
+        @rolls.each_with_index do |roll, index|
+          return false if other.rolls[index] != roll
+        end
+
+        true
+      end
+
+      def to_s
+        @rolls.map(&:to_s).join(' + ')
+      end
+    end
+
+    attr_reader :rolls, :modifier, :die_sides, :roller
+
+    # This represents a dice roll
+    # @param rolls [Array] Integer dice roll representations
+    # @param modifier [Integer] a constant value to add to the roll
+    def initialize(rolls, modifier, die_sides = 20, advantage: false, disadvantage: false, description: nil, roller: nil)
+      @rolls = rolls
+      @modifier = modifier
+      @die_sides = die_sides
+      @advantage = advantage
+      @disadvantage = disadvantage
+      @description = description
+      @roller = roller
+    end
+
+    # This is a natural 20 or critical roll
+    # @return [Boolean]
+    def nat_20?
+      if @advantage
+        @rolls.map(&:max).detect { |r| r == 20 }
+      elsif @disadvantage
+        @rolls.map(&:min).detect { |r| r == 20 }
+      else
+        @rolls.include?(20)
+      end
+    end
+
+    def nat_1?
+      if @advantage
+        @rolls.map(&:max).detect { |r| r == 1 }
+      elsif @disadvantage
+        @rolls.map(&:min).detect { |r| r == 1 }
+      else
+        @rolls.include?(1)
+      end
+    end
+
+    def reroll(lucky: false)
+      @roller.roll(lucky: lucky)
+    end
+
+    # computes the integer result of the dice roll
+    # @return [Integer]
+    def result
+      sum = if @advantage
+              @rolls.map(&:max).sum
+            elsif @disadvantage
+              @rolls.map(&:min).sum
+            else
+              @rolls.sum
+            end
+
+      sum + @modifier
+    end
+
+    # adds color flair to the roll depending on value
+    # @param roll [String,Integer]
+    # @return [String]
+    def color_roll(roll)
+      case roll
+      when 1
+        roll.to_s.colorize(:red)
+      when @die_sides
+        roll.to_s.colorize(:green)
+      else
+        roll.to_s
+      end
+    end
+
+    def to_s
+      rolls = @rolls.map do |r|
+        if @advantage
+          r.map do |i|
+            i == r.max ? color_roll(i).bold : i.to_s.colorize(:gray)
+          end.join(' | ')
+        elsif @disadvantage
+          r.map do |i|
+            i == r.min ? color_roll(i).bold : i.to_s.colorize(:gray)
+          end.join(' | ')
+        else
+          color_roll(r)
+        end
+      end
+
+      if @modifier != 0
+        "(#{rolls.join(' + ')}) + #{@modifier}"
+      else
+        "(#{rolls.join(' + ')})"
+      end
+    end
+
+    def self.numeric?(c)
+      return true if c =~ /\A\d+\Z/
+
+      begin
+        true if Float(c)
+      rescue StandardError
+        false
+      end
+    end
+
+    def ==(other)
+      return true if other.rolls == @rolls && other.modifier == @modifier && other.die_sides == @die_sides
+
+      false
+    end
+
+    def <=>(other)
+      result <=> other.result
+    end
+
+    def +(other)
+      if other.is_a?(DieRolls)
+        other.add_to_front(self)
+        other
+      else
+        DieRolls.new([self, other])
+      end
+    end
+
+    # @param die_roll_str [String]
+    # @return [Natural20::DieRollDetail]
+    def self.parse(roll_str)
+      die_count_str = ''
+      die_type_str = ''
+      modifier_str = ''
+      modifier_op = ''
+      state = :initial
+
+      roll_str.strip.each_char do |c|
+        case state
+        when :initial
+          if numeric?(c)
+            die_count_str << c
+          elsif c == 'd'
+            state = :die_type
+          elsif c == '+'
+            state = :modifier
+          end
+        when :die_type
+          next if c == ' '
+
+          if numeric?(c)
+            die_type_str << c
+          elsif c == '+'
+            state = :modifier
+          elsif c == '-'
+            modifier_op = '-'
+            state = :modifier
+          end
+        when :modifier
+          next if c == ' '
+
+          modifier_str << c if numeric?(c)
+        end
+      end
+
+      if state == :initial
+        modifier_str = die_count_str
+        die_count_str = '0'
+      end
+
+      number_of_die = die_count_str.blank? ? 1 : die_count_str.to_i
+
+      detail = Natural20::DieRollDetail.new
+      detail.die_count = number_of_die
+      detail.die_type = die_type_str
+      detail.modifier = modifier_str
+      detail.modifier_op = modifier_op
+      detail
+    end
+
+    # Rolls the dice, details on dice rolls and its values are preserved
+    # @param roll_str [String] A dice roll expression
+    # @param entity [Natural20::Entity]
+    # @param crit [Boolean] A critial hit damage roll - double dice rolls
+    # @param advantage [Boolean] Roll with advantage, roll twice and select the highest
+    # @param disadvantage [Boolean] Roll with disadvantage, roll twice and select the lowest
+    # @param battle [Natural20::Battle]
+    # @return [Natural20::DieRoll]
+    def self.roll(roll_str, crit: false, disadvantage: false, advantage: false, description: nil, entity: nil, battle: nil)
+      roller = Roller.new(roll_str, crit: crit, disadvantage: disadvantage, advantage: advantage,
+                                    description: description, entity: entity, battle: battle)
+      roller.roll
+    end
+
+    # Rolls the dice checking lucky feat, details on dice rolls and its values are preserved
+    # @param entity [Natural20::Entity]
+    # @param roll_str [String] A dice roll expression
+    # @param entity [Natural20::Entity]
+    # @param crit [Boolean] A critial hit damage roll - double dice rolls
+    # @param advantage [Boolean] Roll with advantage, roll twice and select the highest
+    # @param disadvantage [Boolean] Roll with disadvantage, roll twice and select the lowest
+    # @param battle [Natural20::Battle]
+    # @return [Natural20::DieRoll]
+    def self.roll_with_lucky(entity, roll_str, crit: false, disadvantage: false, advantage: false, description: nil, battle: nil)
+      roller = Roller.new(roll_str, crit: crit, disadvantage: disadvantage, advantage: advantage,
+                                    description: description, entity: entity, battle: battle)
+      result = roller.roll
+      if result.nat_1? && entity.class_feature?('lucky')
+        roller.roll(lucky: true)
+      else
+        result
+      end
+    end
+
+    def self.t(key, options = {})
+      I18n.t(key, options)
+    end
+  end
+end