natural_20 0.1.0

data/lib/natural_20/actions/multiattack_action.rb

@@ -0,0 +1,41 @@
+# typed: true
+class MultiattackAction < Natural20::Action
+  attr_accessor :as_bonus_action
+
+  def self.can?(entity, battle)
+    battle && entity.total_actions(battle).positive?
+  end
+
+  def build_map
+    OpenStruct.new({
+                     param: nil,
+                     next: -> { self },
+                   })
+  end
+
+  def self.build(session, source)
+    action = MultiattackAction.new(session, source, :multiattack)
+    action.build_map
+  end
+
+  def resolve(_session, _map, opts = {})
+    @result = [{
+      source: @source,
+      type: :multiattack,
+      battle: opts[:battle],
+    }]
+    self
+  end
+
+  # @param battle [Natural20::Battle]
+  def apply!(battle)
+    @result.each do |item|
+      case (item[:type])
+      when :multiattack
+        @total_attacks += 2
+      end
+
+      battle.consume!(:action, 1)
+    end
+  end
+end

data/lib/natural_20/actions/prone_action.rb

@@ -0,0 +1,38 @@
+# typed: true
+class ProneAction < Natural20::Action
+  attr_accessor :as_bonus_action
+
+  def self.can?(entity, battle)
+    battle && !entity.prone?
+  end
+
+  def build_map
+    OpenStruct.new({
+                     param: nil,
+                     next: -> { self }
+                   })
+  end
+
+  def self.build(session, source)
+    action = ProneAction.new(session, source, :attack)
+    action.build_map
+  end
+
+  def resolve(_session, _map, opts = {})
+    @result = [{
+      source: @source,
+      type: :prone,
+      battle: opts[:battle]
+    }]
+    self
+  end
+
+  def apply!(_battle)
+    @result.each do |item|
+      case (item[:type])
+      when :prone
+        item[:source].prone!
+      end
+    end
+  end
+end

data/lib/natural_20/actions/short_rest_action.rb

@@ -0,0 +1,53 @@
+class ShortRestAction < Natural20::Action
+  attr_accessor :as_bonus_action
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natural20::Battle]
+  def self.can?(entity, battle)
+    battle && !battle.combat? && (entity.conscious? || entity.stable?)
+  end
+
+  def build_map
+    OpenStruct.new({
+                     param: nil,
+                     next: -> { self }
+                   })
+  end
+
+  def self.build(session, source)
+    action = ShortRestAction.new(session, source, :short_rest)
+    action.build_map
+  end
+
+  # @option opts battle [Natural20::Battle]
+  def resolve(_session, _map, opts = {})
+    battle = opts[:battle]
+
+    # determine who in the party is eligible for short rest
+    entities = battle.current_party.select do |entity|
+      entity.conscious? || entity.stable?
+    end
+
+    @result = [{
+      source: @source,
+      targets: entities,
+      type: :short_rest,
+      battle: battle
+    }]
+
+    self
+  end
+
+  # @param battle [Natural20::Battle]
+  def apply!(battle)
+    @result.each do |item|
+      case (item[:type])
+      when :short_rest
+        Natural20::EventManager.received_event({ source: item[:source], event: :short_rest, targets: item[:targets] })
+        item[:targets].each do |entity|
+          entity.short_rest!(battle, prompt: true)
+        end
+      end
+    end
+  end
+end

data/lib/natural_20/actions/shove_action.rb

@@ -0,0 +1,142 @@
+class ShoveAction < Natural20::Action
+  include Natural20::ActionDamage
+  attr_accessor :target, :knock_prone
+
+  def self.can?(entity, battle, _options = {})
+    (battle.nil? || entity.total_actions(battle).positive?)
+  end
+
+  def validate
+    @errors << 'target is a required option for :attack' if target.nil?
+    @errors << t('validation.shove.invalid_target_size') if (target.size_identifier - @source.size_identifier) > 1
+  end
+
+  def to_s
+    @action_type.to_s.humanize
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_target,
+                         range: 5,
+                         target_types: %i[enemies],
+                         num: 1
+                       }
+                     ],
+                     next: lambda { |target|
+                       self.target = target
+                       OpenStruct.new({
+                                        param: nil,
+                                        next: -> { self }
+                                      })
+                     }
+                   })
+  end
+
+  def self.build(session, source)
+    action = ShoveAction.new(session, source, :shove)
+    action.build_map
+  end
+
+  # Build the attack roll information
+  # @param session [Natural20::Session]
+  # @param map [Natural20::BattleMap]
+  # @option opts battle [Natural20::Battle]
+  # @option opts target [Natural20::Entity]
+  def resolve(_session, map, opts = {})
+    target = opts[:target] || @target
+    battle = opts[:battle]
+    raise 'target is a required option for :attack' if target.nil?
+
+    return if (target.size_identifier - @source.size_identifier) > 1
+
+    strength_roll = @source.athletics_check!(battle)
+    athletics_stats = (@target.athletics_proficient? ? @target.proficiency_bonus : 0) + @target.str_mod
+    acrobatics_stats = (@target.acrobatics_proficient? ? @target.proficiency_bonus : 0) + @target.dex_mod
+
+    shove_success = false
+    if @target.incapacitated?
+      shove_success = true
+    else
+      contested_roll = if athletics_stats > acrobatics_stats
+                         @target.athletics_check!(battle,
+                                                  description: t('die_roll.contest'))
+                       else
+                         @target.acrobatics_check!(
+                           opts[:battle], description: t('die_roll.contest')
+                         )
+                       end
+      shove_success = strength_roll.result >= contested_roll.result
+    end
+
+    shove_loc = nil
+    additional_effects = []
+    unless knock_prone
+      shove_loc = @target.push_from(map, *map.entity_or_object_pos(@source))
+      if shove_loc
+        trigger_results = map.area_trigger!(@target, shove_loc, false)
+        additional_effects += trigger_results
+      end
+    end
+    @result = if shove_success
+                [{
+                  source: @source,
+                  target: target,
+                  type: :shove,
+                  success: true,
+                  battle: battle,
+                  shove_loc: shove_loc,
+                  knock_prone: knock_prone,
+                  source_roll: strength_roll,
+                  target_roll: contested_roll
+                }] + additional_effects
+              else
+                [{
+                  source: @source,
+                  target: target,
+                  type: :shove,
+                  success: false,
+                  battle: battle,
+                  knock_prone: knock_prone,
+                  source_roll: strength_roll,
+                  target_roll: contested_roll
+                }]
+              end
+  end
+
+  def apply!(battle)
+    @result.each do |item|
+      case (item[:type])
+      when :damage
+        damage_event(item, battle)
+      when :shove
+        if item[:success]
+          if item[:knock_prone]
+            item[:target].prone!
+          elsif item[:shove_loc]
+            item[:battle].map.move_to!(item[:target], *item[:shove_loc], battle)
+          end
+
+          Natural20::EventManager.received_event(event: :shove_success,
+                                                 knock_prone: item[:knock_prone],
+                                                 target: item[:target], source: item[:source],
+                                                 source_roll: item[:source_roll],
+                                                 target_roll: item[:target_roll])
+        else
+          Natural20::EventManager.received_event(event: :shove_failure,
+                                                 target: item[:target], source: item[:source],
+                                                 source_roll: item[:source_roll],
+                                                 target_roll: item[:target_roll])
+        end
+
+        battle.entity_state_for(item[:source])[:action] -= 1
+      end
+    end
+  end
+end
+
+class PushAction < ShoveAction
+end

data/lib/natural_20/actions/stand_action.rb

@@ -0,0 +1,47 @@
+# typed: true
+class StandAction < Natural20::Action
+  attr_accessor :as_bonus_action
+
+  # @param entity [Natural20::Entity]
+  # @param battle [Natural20::Battle]
+  def self.can?(entity, battle)
+    battle && entity.prone? && entity.speed.positive? && entity.available_movement(battle) >= required_movement(entity)
+  end
+
+  def build_map
+    OpenStruct.new({
+                     param: nil,
+                     next: -> { self }
+                   })
+  end
+
+  def self.build(session, source)
+    action = StandAction.new(session, source, :attack)
+    action.build_map
+  end
+
+  def resolve(_session, _map, opts = {})
+    @result = [{
+      source: @source,
+      type: :stand,
+      battle: opts[:battle]
+    }]
+    self
+  end
+
+  def apply!(battle)
+    @result.each do |item|
+      case (item[:type])
+      when :stand
+        item[:source].stand!
+        battle.entity_state_for(item[:source])[:movement] -= (item[:source].speed / 2).floor
+      end
+    end
+  end
+
+  # required movement available to stand
+  # @param entity [Natural20::Entity]
+  def self.required_movement(entity)
+    (entity.speed / 2).floor
+  end
+end

data/lib/natural_20/actions/use_item_action.rb

@@ -0,0 +1,57 @@
+# typed: true
+class UseItemAction < Natural20::Action
+  attr_accessor :target, :target_item
+
+  def self.can?(entity, battle)
+    battle.nil? || entity.total_actions(battle).positive?
+  end
+
+  def self.build(session, source)
+    action = UseItemAction.new(session, source, :attack)
+    action.build_map
+  end
+
+  def build_map
+    OpenStruct.new({
+                     action: self,
+                     param: [
+                       {
+                         type: :select_item
+                       }
+                     ],
+                     next: lambda { |item|
+                             item_details = session.load_equipment(item)
+                             raise "item #{item_details[:name]} not usable!" unless item_details[:usable]
+
+                             @target_item = item_details[:item_class].constantize.new(item, item_details)
+                             @target_item.build_map(self)
+                           }
+                   })
+  end
+
+  def resolve(_session, map = nil, opts = {})
+    battle = opts[:battle]
+    result_payload = {
+      source: @source,
+      target: target,
+      map: map,
+      battle: battle,
+      type: :use_item,
+      item: target_item
+    }.merge(target_item.resolve(@source, battle))
+    @result = [result_payload]
+    self
+  end
+
+  def apply!(battle)
+    @result.each do |item|
+      case (item[:type])
+      when :use_item
+        Natural20::EventManager.received_event({ event: :use_item, source: item[:source], item: item[:item] })
+        item[:item].use!(item[:target], item)
+        item[:source].deduct_item(item[:item].name, 1) if item[:item].consumable?
+        battle.entity_state_for(item[:source])[:action] -= 1 if battle
+      end
+    end
+  end
+end

data/lib/natural_20/ai_controller/path_compute.rb

@@ -0,0 +1,140 @@
+# typed: false
+require 'pqueue'
+module AiController
+  MAX_DISTANCE = 4_000_000
+  # Path finding algorithm
+  class PathCompute
+    # Creates a path finder
+    # @param battle [Natural20::Battle]
+    # @param map [Natural20::BattleMap]
+    # @param entity [Natural20::Entity]
+    def initialize(battle, map, entity)
+      @entity = entity
+      @map = map
+      @battle = battle
+      @max_x, @max_y = @map.size
+    end
+
+    def build_structures(source_x, source_y)
+      @pq = PQueue.new([]) { |a, b| a[1] < b[1] }
+      @visited_nodes = Set.new
+
+      @distances = @max_x.times.map do
+        @max_y.times.map do
+          MAX_DISTANCE
+        end
+      end
+
+      @current_node = [source_x, source_y]
+      @distances[source_x][source_y] = 0
+      @visited_nodes.add(@current_node)
+    end
+
+    def backtrace(source_x, source_y, destination_x, destination_y, show_cost: false)
+      path = []
+      current_node = [destination_x, destination_y]
+      return nil if @distances[destination_x][destination_y] == MAX_DISTANCE # no route!
+
+      path << current_node
+      cost = @distances[destination_x][destination_y]
+      visited_nodes = Set.new
+      visited_nodes.add(current_node)
+      Kernel.loop do
+        adjacent_squares = get_adjacent_from(*current_node)
+        adjacent_squares += get_adjacent_from(*current_node, squeeze: true)
+
+        min_node = nil
+        min_distance = nil
+
+        adjacent_squares.reject { |n| visited_nodes.include?(n) }.each do |node|
+          line_distance = Math.sqrt((destination_x - node[0])**2 + (destination_y - node[1])**2)
+          current_distance = @distances[node[0]][node[1]].to_f + line_distance / MAX_DISTANCE.to_f
+          if min_node.nil? || current_distance < min_distance
+            min_distance = current_distance
+            min_node = node
+          end
+        end
+
+        return nil if min_node.nil?
+
+        path << min_node
+        current_node = min_node
+        visited_nodes.add(current_node)
+        break if current_node == [source_x, source_y]
+      end
+
+      show_cost ? [path.reverse, cost] : path.reverse
+    end
+
+    def path(destination = nil)
+      Kernel.loop do
+        distance = @distances[@current_node[0]][@current_node[1]]
+
+        adjacent_squares = get_adjacent_from(*@current_node)
+        visit_squares(@pq, adjacent_squares, @visited_nodes, @distances, distance)
+
+        # with squeezing into terrain
+        squeeze_adjacent_squares = get_adjacent_from(*@current_node, squeeze: true)
+
+        squeeze_adjacent_squares -= adjacent_squares
+
+        unless squeeze_adjacent_squares.empty?
+          visit_squares(@pq, squeeze_adjacent_squares, @visited_nodes, @distances, distance,
+                        2)
+        end
+
+        break if destination && @current_node == destination
+
+        @visited_nodes.add(@current_node)
+
+        @current_node, node_d = @pq.pop
+        break if @current_node.nil?
+
+        return nil if node_d == MAX_DISTANCE
+      end
+    end
+
+    # compute path using Djikstras shortest path
+    def compute_path(source_x, source_y, destination_x, destination_y)
+      build_structures(source_x, source_y)
+      path([destination_x, destination_y])
+      backtrace(source_x, source_y, destination_x, destination_y)
+    end
+
+    def incremental_path(source_x, source_y, destination_x, destination_y)
+      rpath = backtrace(source_x, source_y, destination_x, destination_y, show_cost: true)
+      return rpath if rpath && rpath.size > 1
+
+      nil
+    end
+
+    # @param pq [PQueue]
+    # @param adjacent_squares [Array<Array<Integer,Integer>>]
+    def visit_squares(pq, adjacent_squares, visited_nodes, distances, distance, override_move_cost = nil)
+      adjacent_squares.reject { |n| visited_nodes.include?(n) }.each do |node|
+        move_cost = override_move_cost || @map.difficult_terrain?(@entity, node[0], node[1], @battle) ? 2 : 1
+        current_distance = distance + move_cost
+        distances[node[0]][node[1]] = current_distance if distances[node[0]][node[1]] > current_distance
+        pq << [node, distances[node[0]][node[1]]]
+      end
+    end
+
+    def get_adjacent_from(pos_x, pos_y, squeeze: false)
+      valid_paths = Set.new
+      [-1, 0, 1].each do |x_op|
+        [-1, 0, 1].each do |y_op|
+          cur_x = pos_x + x_op
+          cur_y = pos_y + y_op
+
+          next if cur_x < 0 || cur_y < 0 || cur_x >= @max_x || cur_y >= @max_y
+          next if x_op.zero? && y_op.zero?
+          next unless @map.passable?(@entity, cur_x, cur_y, @battle, squeeze)
+
+          valid_paths.add([cur_x, cur_y])
+        end
+      end
+
+      valid_paths
+    end
+  end
+end