natural_20 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5be1c9cb751acb1ca14c7fd56510c5cd3546319402847845d42340dcc56ee5c9
-  data.tar.gz: 6cb35a23e305f0218e21f2ad9e3b750df99436c3f8bdb9a5fa210ba1380c406a
+  metadata.gz: e33ce92d3b1d8ebf75e0262bb56ab3e990702897632c2ebdb476e814d8abfe4a
+  data.tar.gz: c3aa5ca94f3d587466f4ec93fd44c05a58af2f009cd58cdf50f36b9e9be1bd75
 SHA512:
-  metadata.gz: d84d618418d15c13d6845ce947331c0d0adf61e8be9ea8e6766da2aa239c063516c5d3871075aecfcf5099d84af8dcc1206548523ec5560c49573a30fbcef5f5
-  data.tar.gz: 7c7b48733c61254779b5037cd7ec95303faf4a1c1088f38ece602e4b665b31b6b98136b229387ae0bca0c315e71c35c77673a2824ecbfbd40e5d2116850d5187
+  metadata.gz: 568d09d82b1bdfb16696f19082e673ce540f01ff9688ec8293898685497df8c14c4b8f29ccb42ec6b2d7c0e971645074f05a282dd76e347acf0e45b7744fb95f
+  data.tar.gz: a2896d2bc69e40345675a7b4243b18b72562266ee39c32017ea420b00b68d996f12e0fbe410fc0fa10383dfdcc205a0be7c7d70f044605460281275f8b1b59dc

data/README.md

@@ -9,12 +9,14 @@ Features:
  - Simulation of doors, traps, treasure chests and cover
  - Rudimentary AI and pathfinding
  - Text based UI
+ - Support for automatic and manual dice rolling
  - Easily extensible to incorporate in your own games
 
  Supported Races:
  - Human
  - Elf
  - Halfling
+ - Dwarf
  - More to come
 
  Supported Classes;
@@ -69,6 +71,13 @@ game.yml
 
 These are all text readable for you to customize to your liking.
 
+## Screenshots
+
+![Screenshot from 2021-02-06 13-14-48](https://user-images.githubusercontent.com/949459/107109725-91212000-687d-11eb-8f59-3ecd2d5efa9e.png)
+![Screenshot from 2021-02-06 13-15-13](https://user-images.githubusercontent.com/949459/107109730-941c1080-687d-11eb-94ad-565d4bde5cfd.png)
+![Screenshot from 2021-02-06 13-15-37](https://user-images.githubusercontent.com/949459/107109733-95e5d400-687d-11eb-8928-53caad6f9b28.png)
+
+
 ## Creating your own adventures
 
 You can generate a skeleton adventure using:
@@ -79,6 +88,19 @@ nat20author
 
 A prompt based system will launch for you to create your own game.
 
+The end result will be a folder containing a bunch of YAML files describing your game
+
+## Map making guide
+
+A map is a YAML file that consists of the following:
+
+- Base Layer - contains terrain information like ground, grass, walls, doors, traps and various obstacles
+- Meta Layer - contains information about dynamic objects like player tokens, NPCs
+- Light Layer - contains information about static lights in the map
+- Legend - A mapping from the layers to details about the terrain and tokens
+- Map Triggers - A map level trigger
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/fixtures/hide_test.yml

@@ -0,0 +1,27 @@
+name: Natural20::Battle Sim
+description: Map for Natural20::Battle Sim
+map:
+  base:
+    - ......
+    - ......
+    - .MMMM.
+    - .MMMM.
+    - .MMMM.
+    - ......
+  meta:
+    - ......
+    - ......
+    - ......
+    - ..A...
+    - ......
+    - .B....
+legend:
+  A:
+    name: spawn_point_1
+    type: spawn_point
+  B:
+    name: spawn_point_2
+    type: spawn_point
+  M:
+    name: Tall Grass
+    type: briar

data/items/objects.yml

@@ -61,6 +61,29 @@ water:
   passable: true
   token:
     - ^
+briar:
+  color: green
+  passable: true
+  placeable: true
+  movement_cost: 2
+  cover: half
+  default_ac: 10
+  hp_die: 1d4
+  max_hp: 4
+  allow_hide: true
+  token:
+    - ▓
+tree:
+  color: green
+  passable: true
+  placeable: true
+  cover: half
+  default_ac: 10
+  hp_die: 1d8
+  max_hp: 8
+  allow_hide: true
+  token:
+    - '*'
 wooden_door:
   color: magenta
   default_ac: 15

data/items/weapons.yml

@@ -1,4 +1,22 @@
 ---
+battleaxe:
+  cost: 10
+  damage: 1d8
+  damage_2: 1d10
+  damage_type: slashing
+  meta:
+    noise_source: 5
+    noise_target: 5
+  modifiers: null
+  name: Battleaxe
+  proficiency_type:
+    - martial
+  properties:
+    - versatile
+  range: 5
+  subtype: weapon
+  type: melee_attack
+  weight: 4
 dagger:
   cost: 2
   damage: 1d4
@@ -123,6 +141,45 @@ light_crossbow:
   subtype: weapon
   type: ranged_attack
   weight: 2
+light_hammer:
+  cost: 2
+  damage: 1d4
+  damage_type: bludgeoning
+  meta:
+    noise_source: 5
+    noise_target: 5
+  modifiers: null
+  name: Light Hammer
+  proficiency_type:
+    - simple
+  properties:
+    - light
+    - thrown
+  range: 5
+  subtype: weapon
+  thrown:
+    range: 20
+    range_max: 60
+  type: melee_attack
+  weight: 2
+warhammer:
+  cost: 2
+  damage: 1d8
+  damage_2: 1d10
+  damage_type: bludgeoning
+  meta:
+    noise_source: 5
+    noise_target: 5
+  modifiers: null
+  name: Warhammer
+  proficiency_type:
+    - martial
+  properties:
+    - versatile
+  range: 5
+  subtype: weapon
+  type: melee_attack
+  weight: 2
 longbow:
   ammo: arrows
   cost: 50

data/lib/natural_20/actions/attack_action.rb

@@ -11,7 +11,9 @@ class AttackAction < Natural20::Action
   # @param battle [Natural20::Battle]
   # @return [Boolean]
   def self.can?(entity, battle, options = {})
-    battle.nil? || entity.total_actions(battle).positive? || (options[:opportunity_attack] && entity.total_reactions(battle).positive?) || entity.multiattack?(
+    return entity.total_reactions(battle).positive? if battle && options[:opportunity_attack]
+
+    battle.nil? || entity.total_actions(battle).positive? || entity.multiattack?(
       battle, options[:npc_action]
     )
   end
@@ -109,11 +111,11 @@ class AttackAction < Natural20::Action
       end
 
       if as_reaction
-        battle.entity_state_for(item[:source])[:reaction] -= 1
+        battle.consume(item[:source], :reaction)
       elsif item[:second_hand]
-        battle.entity_state_for(item[:source])[:bonus_action] -= 1
+        battle.consume(item[:source], :bonus_action)
       else
-        battle.entity_state_for(item[:source])[:action] -= 1
+        battle.consume(item[:source], :action)
       end
 
       item[:source].break_stealth!(battle)
@@ -339,7 +341,7 @@ class AttackAction < Natural20::Action
       _advantage, disadvantage = adv_info
       disadvantage << :protection
       @advantage_mod = -1
-      battle.entity_state_for(entity)[:reaction] -= 1
+      battle.consume(entity, :reaction)
     end
   end
 
@@ -357,9 +359,9 @@ class TwoWeaponAttackAction < AttackAction
   # @param entity [Natural20::Entity]
   # @param battle [Natural20::Battle]
   def self.can?(entity, battle, options = {})
-    battle.nil? || (entity.total_bonus_actions(battle).positive? && battle.two_weapon_attack?(entity) && options[:weapon] != battle.first_hand_weapon(entity) || entity.equipped_weapons.select do |a|
-      a == battle.first_hand_weapon(entity)
-    end.size >= 2)
+    battle.nil? || (entity.total_bonus_actions(battle).positive? && battle.two_weapon_attack?(entity) && (options[:weapon] != battle.first_hand_weapon(entity) || entity.equipped_weapons.select do |a|
+      a.to_s == battle.first_hand_weapon(entity)
+    end.size >= 2))
   end
 
   def second_hand

data/lib/natural_20/actions/first_aid_action.rb

@@ -9,6 +9,7 @@ class FirstAidAction < Natural20::Action
   # @param battle [Natural20::Battle]
   def self.unconscious_targets(entity, battle)
     return [] unless battle
+    return [] unless battle.map
 
     adjacent_squares = entity.melee_squares(battle.map, adjacent_only: true)
     entities = []

data/lib/natural_20/actions/ground_interact_action.rb

@@ -11,7 +11,12 @@ class GroundInteractAction < Natural20::Action
     action.build_map
   end
 
+  # @param entity [Natural20::Entity]
+  # @param battle [Natural20::Battle]
+  # @return [Integer]
   def self.items_on_the_ground_count(entity, battle)
+    return 0 unless battle.map
+
     battle.map.items_on_the_ground(entity).inject(0) { |total, item| total + item[1].size }
   end
 

data/lib/natural_20/actions/hide_action.rb

@@ -21,6 +21,7 @@ class HideAction < Natural20::Action
     stealth_roll = @source.stealth_check!(opts[:battle])
     @result = [{
       source: @source,
+      bonus_action: as_bonus_action,
       type: :hide,
       roll: stealth_roll,
       battle: opts[:battle]
@@ -37,10 +38,10 @@ class HideAction < Natural20::Action
         item[:source].hiding!(battle, item[:roll].result)
       end
 
-      if as_bonus_action
-        battle.entity_state_for(item[:source])[:bonus_action] -= 1
+      if item[:bonus_action]
+        battle.consume(item[:source], :bonus_action)
       else
-        battle.entity_state_for(item[:source])[:action] -= 1
+        battle.consume(item[:source], :action)
       end
     end
   end

data/lib/natural_20/actions/move_action.rb

@@ -127,42 +127,19 @@ class MoveAction < Natural20::Action
   # @param move_list [Array<Array<Integer,Integer>>]
   # @param battle [Natural20::Battle]
   def check_opportunity_attacks(entity, move_list, battle, grappled: false)
-    if battle && !@source.disengage?(battle)
-      opportunity_attacks = opportunity_attack_list(entity, move_list, battle, battle.map)
-      opportunity_attacks.each do |enemy_opporunity|
-        next unless enemy_opporunity[:source].has_reaction?(battle)
-        next if @source.grappling_targets.include?(enemy_opporunity[:source])
+    if battle
 
+      retrieve_opportunity_attacks(entity, move_list, battle).each do |enemy_opporunity|
         original_location = move_list[0...enemy_opporunity[:path]]
         attack_location = original_location.last
         battle.trigger_opportunity_attack(enemy_opporunity[:source], entity, *attack_location)
 
-        if !grappled && !entity.conscious?
-          move_list = original_location
-          break
-        end
+        return original_location if !grappled && !entity.conscious?
       end
     end
     move_list
   end
 
-  def opportunity_attack_list(entity, current_moves, battle, map)
-    # get opposing forces
-    opponents = battle.opponents_of?(entity)
-    entered_melee_range = Set.new
-    left_melee_range = []
-    current_moves.each_with_index do |path, index|
-      opponents.each do |enemy|
-        entered_melee_range.add(enemy) if enemy.entered_melee?(map, entity, *path)
-        if !left_melee_range.include?(enemy) && entered_melee_range.include?(enemy) && !enemy.entered_melee?(map,
-                                                                                                             entity, *path)
-          left_melee_range << { source: enemy, path: index }
-        end
-      end
-    end
-    left_melee_range
-  end
-
   def apply!(battle)
     @result.each do |item|
       case (item[:type])

data/lib/natural_20/ai_controller/standard.rb

@@ -127,7 +127,7 @@ module AiController
       # generate available targets
       valid_actions = []
 
-      if enemy_positions.empty? && LookAction.can?(entity, battle)
+      if enemy_positions.empty? && investigate_location.empty? && LookAction.can?(entity, battle)
         action = LookAction.new(battle.session, entity, :look)
         return action
       end
@@ -163,6 +163,19 @@ module AiController
         valid_actions += generate_moves_for_positions(battle, entity, investigate_location)
       end
 
+      if HideBonusAction.can?(entity, battle) # bonus action hide if able
+        hide_action = HideBonusAction.new(battle.session, entity, :hide_bonus)
+        hide_action.as_bonus_action = true
+        valid_actions << hide_action
+      end
+
+      if valid_actions.first&.action_type == :move && DisengageBonusAction.can?(entity,
+                                                                                battle) && !retrieve_opportunity_attacks(
+                                                                                  entity, valid_actions.first.move_path, battle
+                                                                                ).empty?
+        return DisengageBonusAction.new(battle.session, entity, :disengage_bonus)
+      end
+
       valid_actions << DodgeAction.new(battle.session, entity, :dodge) if entity.action?(battle)
 
       return valid_actions.first unless valid_actions.empty?
@@ -195,7 +208,7 @@ module AiController
           melee_weight = 2.0
         end
 
-        defense_weight = 2.0 if (entity.hp / entity.max_hp) < 0.25
+        # defense_weight = 2.0 if (entity.hp / entity.max_hp) < 0.25
 
         [square, melee_weight * melee + range_weight * ranged + defense_weight * defense + mobility * mobolity_weight]
       end

data/lib/natural_20/battle.rb

@@ -64,7 +64,7 @@ module Natural20
 
     # Adds an entity to the battle
     # @param entity [Natural20::Entity] The entity to add to the battle
-    # @param group [Symbol] A symbol denoting which group this entity belongs to
+    # @param group [Symbol] A symbol denoting which opposing group this entity belongs to
     # @param controller [AiController::Standard] Ai controller to use
     # @param position [Array, Symbol] Starting location in the map can be a position or a spawn point
     # @param token [String, Symbol] The token to use
@@ -279,6 +279,7 @@ module Natural20
 
       cover_value = @map.cover_calculation(@map, entity1, entity2, entity_1_pos: entity_1_pos,
                                                                    naturally_stealthy: entity2.class_feature?('naturally_stealthy'))
+
       if cover_value.positive?
         entity_2_state = entity_state_for(entity2)
         return false if entity_2_state[:stealth] > [active_perception, entity1.passive_perception].max
@@ -382,7 +383,7 @@ module Natural20
 
     def while_active(max_rounds = nil, &block)
       loop do
-        Natural20::EventManager.received_event(source: self, event: :start_of_round)
+        Natural20::EventManager.received_event(source: self, event: :start_of_round, in_battle: ongoing?)
 
         current_turn.death_saving_throw!(self) if current_turn.unconscious? && !current_turn.stable?
 
@@ -522,6 +523,15 @@ module Natural20
       @map.activate_map_triggers(event, source, opt.merge(ui_controller: controller_for(source)))
     end
 
+    # Consumes an action resource
+    # @param entity [Natural20::Entity]
+    # @param resouce [Symbol]
+    def consume(entity, resource, qty = 1)
+      raise 'invalid resource' unless %i[action reaction bonus_action movement].include?(resource.to_sym)
+
+      entity_state_for(entity)[resource.to_sym] = [0, entity_state_for(entity)[resource.to_sym] - qty].max
+    end
+
     protected
 
     def t(key, options = {})

data/lib/natural_20/battle_map.rb

@@ -135,7 +135,7 @@ module Natural20
     # Get object at map location
     # @param pos_x [Integer]
     # @param pos_y [Integer]
-    # @return [ItemLibrary::Object]
+    # @return [Array<ItemLibrary::Object>]
     def objects_at(pos_x, pos_y)
       @objects[pos_x][pos_y]
     end
@@ -228,13 +228,13 @@ module Natural20
     # @param entity1 [Natural20::Entity]
     # @param entity2 [Natural20::Entity]
     # @result [Integer]
-    def distance(entity1, entity2, entity_1_pos: nil)
+    def distance(entity1, entity2, entity_1_pos: nil, entity_2_pos: nil)
       raise 'entity 1 param cannot be nil' if entity1.nil?
       raise 'entity 2 param cannot be nil' if entity2.nil?
 
       # entity 1 squares
       entity_1_sq = entity_1_pos ? entity_squares_at_pos(entity1, *entity_1_pos) : entity_squares(entity1)
-      entity_2_sq = entity_squares(entity2)
+      entity_2_sq = entity_2_pos ? entity_squares_at_pos(entity2, *entity_2_pos) : entity_squares(entity2)
 
       entity_1_sq.map do |ent1_pos|
         entity_2_sq.map do |ent2_pos|
@@ -245,6 +245,20 @@ module Natural20
       end.flatten.min
     end
 
+    # Returns the line distance between an entity and a location
+    # @param entity [Natural20::Entity]
+    # @param pos2_x [Integer]
+    # @param pos2_y [Integer]
+    # @result [Integer]
+    def line_distance(entity1, pos2_x, pos2_y, entity_1_pos: nil)
+      entity_1_sq = entity_1_pos ? entity_squares_at_pos(entity1, *entity_1_pos) : entity_squares(entity1)
+
+      entity_1_sq.map do |ent1_pos|
+        pos1_x, pos1_y = ent1_pos
+        Math.sqrt((pos1_x - pos2_x)**2 + (pos1_y - pos2_y)**2).floor
+      end.flatten.min
+    end
+
     # Get all the location of the squares occupied by said entity (e.g. for large, huge creatures)
     # @param entity [Natural20::Entity]
     # @return [Array]

data/lib/natural_20/cli/character_builder.rb

@@ -21,14 +21,14 @@ module Natural20
         ability: {},
         skills: [],
         level: 1,
-        token: ['X']
+        token: ['X'],
+        tools: []
       }
       loop do
         ability_method = :random
 
         @values[:name] = prompt.ask(t('builder.enter_name'), default: @values[:name]) do |q|
           q.required true
-          q.validate(/\A\w+\Z/)
           q.modify :capitalize
         end
 
@@ -88,6 +88,15 @@ module Natural20
         @values[:classes][k.to_sym] = 1
         @class_properties = session.load_class(k)
 
+        if race_detail[:tool_proficiencies_choice]
+          num_tools_choices = race_detail[:tool_proficiencies_choice]
+          @values[:tools] = prompt.multi_select(t('builder.select_tools_proficiency'), min: num_tools_choices, max: num_tools_choices) do |q|
+            race_detail[:tool_proficiencies].each do |prof|
+              q.choice t("builder.tools.#{prof}"), prof
+            end
+          end
+        end
+
         ability_method = prompt.select(t('builder.ability_score_method')) do |q|
           q.choice t('builder.ability_score.random'), :random
           q.choice t('builder.ability_score.fixed'), :fixed

data/lib/natural_20/cli/commandline_ui.rb

@@ -468,7 +468,7 @@ class CommandlineUI < Natural20::Controller
   def describe_map(map, line_of_sight: [])
     line_of_sight = [line_of_sight] unless line_of_sight.is_a?(Array)
     pov = line_of_sight.map(&:name).join(',')
-    puts "Battle Map (#{map.size[0]}x#{map.size[1]}) #{map.feet_per_grid}ft per square, pov #{pov}:"
+    puts t('map_description', width: map.size[0], length: map.size[1], feet_per_grid: map.feet_per_grid, pov: pov)
   end
 
   # Return moves by a player using the commandline UI
@@ -485,10 +485,10 @@ class CommandlineUI < Natural20::Controller
       puts t(:character_status_line, hp: entity.hp, max_hp: entity.max_hp, total_actions: entity.total_actions(battle), bonus_action: entity.total_bonus_actions(battle),
                                      available_movement: entity.available_movement(battle), statuses: entity.statuses.to_a.join(','))
 
-      action = prompt.select("#{entity.name} (#{entity.token&.first}) will", per_page: TTY_PROMPT_PER_PAGE,
-                                                                             filter: true) do |menu|
-        entity.available_actions(@session, battle).each do |action|
-          menu.choice action.label, action
+      action = prompt.select(t('character_action_prompt', name: entity.name, token: entity.token&.first), per_page: TTY_PROMPT_PER_PAGE,
+                                                                                                          filter: true) do |menu|
+        entity.available_actions(@session, battle).each do |a|
+          menu.choice a.label, a
         end
         # menu.choice 'Console (Developer Mode)', :console
         menu.choice 'End'.colorize(:red), :end
@@ -523,6 +523,7 @@ class CommandlineUI < Natural20::Controller
           cycles += 1
           session.save_game(battle)
           action = battle.move_for(entity)
+
           if action.nil?
 
             unless battle.current_party.include?(entity)

data/lib/natural_20/cli/map_renderer.rb

@@ -15,11 +15,23 @@ module Natural20
     # @param select_pos [Array] coordinate position to render selection cursor
     # @param update_on_drop [Boolean] If true, only render line of sight if movement has been confirmed
     # @return [String]
-    def render(entity: nil, line_of_sight: nil, path: [], acrobatics_checks: [], athletics_checks: [], select_pos: nil, update_on_drop: true, path_char: nil, highlight: {})
+    def render(entity: nil, line_of_sight: nil, path: [], acrobatics_checks: [], athletics_checks: [], select_pos: nil, update_on_drop: true, path_char: nil, highlight: {}, viewport_size: nil, top_position: [
+      0, 0
+    ])
       highlight_positions = highlight.keys.map { |entity| @map.entity_squares(entity) }.flatten(1)
 
-      base_map.transpose.each_with_index.map do |row, row_index|
-        row.each_with_index.map do |c, col_index|
+      viewport_size ||= map.size
+
+      top_x, top_y = top_position
+      top_x = map.size[0] - top_x < viewport_size[0] ? map.size[0] - viewport_size[0] : top_x if viewport_size
+      top_y = map.size[0] - top_y < viewport_size[1] ? map.size[1] - viewport_size[1] : top_y if viewport_size
+
+      right_x = top_x + viewport_size[0] >= map.size[1] ? map.size[1] - 1 : top_x + viewport_size[0]
+      right_y = top_y + viewport_size[1] >= map.size[0] ? map.size[0] - 1 : top_y + viewport_size[1]
+
+      (top_x..right_x).map do |row_index|
+        (top_y..right_y).map do |col_index|
+          c = map.base_map[col_index][row_index]
           display = render_position(c, col_index, row_index, path: path, override_path_char: path_char, entity: entity, line_of_sight: line_of_sight,
                                                              update_on_drop: update_on_drop, acrobatics_checks: acrobatics_checks,
                                                              athletics_checks: athletics_checks)

data/lib/natural_20/concerns/entity.rb

@@ -205,11 +205,7 @@ module Natural20
       ofs_x /= map.feet_per_grid
       ofs_y /= map.feet_per_grid
 
-      if map.placeable?(self, x + ofs_x, y + ofs_y)
-        [x + ofs_x, y + ofs_y]
-      else
-        nil
-      end
+      [x + ofs_x, y + ofs_y] if map.placeable?(self, x + ofs_x, y + ofs_y)
     end
 
     # @param map [Natural20::BattleMap]
@@ -591,6 +587,8 @@ module Natural20
     SKILL_AND_ABILITY_MAP.each do |ability, skills|
       skills.each do |skill|
         define_method("#{skill}_mod") do
+          return @properties[:skills][skill.to_sym] if npc? && @properties[:skills] && @properties[:skills][skill.to_sym]
+
           ability_mod = case ability.to_sym
                         when :dex
                           dex_mod

data/lib/natural_20/concerns/movement_helper.rb

@@ -100,7 +100,7 @@ module Natural20::MovementHelper
     original_budget = movement_budget
 
     current_moves.each_with_index do |m, index|
-      raise "invalid move coordinate" unless m.size == 2 # assert move correctness
+      raise 'invalid move coordinate' unless m.size == 2 # assert move correctness
 
       unless index.positive?
         actual_moves << m
@@ -192,4 +192,36 @@ module Natural20::MovementHelper
                  movement_budget, impediment)
   end
 
+  # Checks if a move provokes opportunity attacks
+  # @param entity [Natural20::Entity]
+  # @param move_list [Array<Array<Integer,Integer>>]
+  # @param battle [Natural20::Battle]
+  # @return [Array<Hash>]
+  def retrieve_opportunity_attacks(entity, move_list, battle)
+    return [] if entity.disengage?(battle)
+
+    opportunity_attacks = opportunity_attack_list(entity, move_list, battle, battle.map)
+    opportunity_attacks.select do |enemy_opporunity|
+      enemy_opporunity[:source].has_reaction?(battle) && !entity.grappling_targets.include?(enemy_opporunity[:source])
+    end
+  end
+
+  protected
+
+  def opportunity_attack_list(entity, current_moves, battle, map)
+    # get opposing forces
+    opponents = battle.opponents_of?(entity)
+    entered_melee_range = Set.new
+    left_melee_range = []
+    current_moves.each_with_index do |path, index|
+      opponents.each do |enemy|
+        entered_melee_range.add(enemy) if enemy.entered_melee?(map, entity, *path)
+        if !left_melee_range.include?(enemy) && entered_melee_range.include?(enemy) && !enemy.entered_melee?(map,
+                                                                                                             entity, *path)
+          left_melee_range << { source: enemy, path: index }
+        end
+      end
+    end
+    left_melee_range
+  end
 end

data/lib/natural_20/concerns/navigation.rb

@@ -59,7 +59,7 @@ module Natural20::Navigation
       support = 0.0
 
       if melee_attack_squares.key?(d)
-        melee_offence += 0.1
+        melee_offence += 0.2
         defense -= 0.05 * melee_attack_squares[d]
         if attack_options
           opponents.each do |opp|
@@ -81,6 +81,7 @@ module Natural20::Navigation
         ranged_offence -= 0.5
       end
 
+      mobility -= 0.001 * map.line_distance(entity, *d)
       [d, [melee_offence, ranged_offence, defense, mobility, support]]
     end.to_h
   end

data/lib/natural_20/item_library/object.rb

@@ -73,6 +73,17 @@ module ItemLibrary
       @properties[:cover] == 'half'
     end
 
+    def cover_ac
+      case @properties[:cover].to_sym
+      when :half
+        2
+      when :three_quarter
+        5
+      else
+        0
+      end
+    end
+
     def three_quarter_cover?
       @properties[:cover] == 'three_quarter'
     end
@@ -81,6 +92,10 @@ module ItemLibrary
       @properties[:cover] == 'total'
     end
 
+    def can_hide?
+      @properties.fetch(:allow_hide, false)
+    end
+
     def interactable?
       false
     end

data/lib/natural_20/player_character.rb

@@ -31,7 +31,7 @@ module Natural20
       @statuses = Set.new
       @resistances = []
       entity_uid = SecureRandom.uuid
-      setup_attributes
+
       @max_hit_die = {}
       @current_hit_die = {}
 
@@ -48,6 +48,8 @@ module Natural20
 
         [klass.to_sym, character_class_properties]
       end.to_h
+
+      setup_attributes
     end
 
     def name
@@ -55,7 +57,11 @@ module Natural20
     end
 
     def max_hp
-      @properties[:max_hp]
+      if class_feature?('dwarven_toughness')
+        @properties[:max_hp] + level
+      else
+        @properties[:max_hp]
+      end
     end
 
     def armor_class
@@ -243,8 +249,12 @@ module Natural20
     def available_actions(session, battle, opportunity_attack: false)
       return [] if unconscious?
 
-      if opportunity_attack && AttackAction.can?(self, battle, opportunity_attack: true)
-        return player_character_attack_actions(battle, opportunity_attack: true)
+      if opportunity_attack
+        if AttackAction.can?(self, battle, opportunity_attack: true)
+          return player_character_attack_actions(battle, opportunity_attack: true)
+        else
+          return []
+        end
       end
 
       ACTION_LIST.map do |type|
@@ -324,10 +334,10 @@ module Natural20
         next unless weapon_detail[:type] == 'melee_attack'
 
         next unless weapon_detail[:properties] && weapon_detail[:properties].include?('light') && TwoWeaponAttackAction.can?(
-          self, battle, weapon: weapon_detail[:name]
+          self, battle, weapon: item
         )
 
-        action = TwoWeaponAttackAction.new(session, self, :attack)
+        action = TwoWeaponAttackAction.new(session, self, :attack, weapon: item)
         action.using = item
         return action
       end
@@ -384,7 +394,7 @@ module Natural20
 
     def setup_attributes
       super
-      @hp = @properties[:max_hp]
+      @hp = max_hp
     end
 
     def equipped_ac

data/lib/natural_20/utils/cover.rb

@@ -17,6 +17,13 @@ module Natural20::Cover
         next 0 unless cover_characteristics
 
         max_ac = 0
+
+        # check if any objects in the area provide cover
+        objs = map.objects_at(*target_pos)
+        objs.each do |object|
+          max_ac = [max_ac, object.cover_ac].max if object.can_hide?
+        end
+
         cover_characteristics.each do |cover|
           cover_type, pos = cover
 

data/lib/natural_20/version.rb

@@ -1,4 +1,4 @@
 # typed: strict
 module Natural20
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/locales/en.yml

@@ -42,6 +42,8 @@ en:
   back: Back
   battle_end: Battle ended in %{num} rounds
   battle_simulator: Battle Simulator
+  map_description: 'Battle Map (%{width}x%{length}) %{feet_per_grid}ft per square, pov %{pov}:'
+  character_action_prompt: '%{name} (%{token}) will'
   builder:
     ability_score:
       fixed: Fixed ability score 15, 14, 13, 12, 10, 8
@@ -70,7 +72,9 @@ en:
     races:
       dark_elf: Dark Elf
       high_elf: High Elf
+      hill_dwarf: Hill Dwarf
       lightfoot: Lightfoot
+      mountain_dwarf: Mountain Dwarf
       stout: Stout
       wood_elf: Wood Elf
     review: Confirm this character?
@@ -102,6 +106,10 @@ en:
     str: Select Strength ability score
     token: Select a token to represent this character on the board
     token_color: Select a color for your token
+    tools:
+      brewers_supplies: Brewer's Supplies
+      masons_tools: Mason's Tools
+      smiths_tools: Smith's Tools
     wis: Select Wisdom ability score
   character_builder: Character Builder ...
   character_sheet:
@@ -118,7 +126,7 @@ en:
     skills: Skills
     speed: 'Speed: %{speed}ft.'
     subrace: 'Subrace: %{race}'
-  character_status_line: '%{hp}/%{max_hp} actions: %{total_actions} bonus action: %{bonus_action}, movement: %{available_movement} ft. statuses: %{statuses}'
+  character_status_line: 'HP: %{hp}/%{max_hp} actions: %{total_actions} bonus action: %{bonus_action}, movement: %{available_movement} ft. statuses: %{statuses}'
   dead_goblin_items: Dead Goblin's items
   dice_roll:
     ability_score: 'Rolling for ability score #%{roll_num}'
@@ -224,8 +232,8 @@ en:
     thieves_cant: Thieves Cant
     undercommon: Undercommon
   manual_target: Target object using the map
-  multiple_target_prompt: Multiple targets at location(s) please select specific targets
   missing_game: missing game.yml in the current folder
+  multiple_target_prompt: Multiple targets at location(s) please select specific targets
   'no': 'No'
   object:
     Arrows: Arrows
@@ -263,6 +271,7 @@ en:
     two_handaxes: Two handaxes
     two_martial_weapons: (2) Martial Weapons
     weapons:
+      battleaxe: Battleaxe
       chain_mail: Chain Mail
       dagger: Dagger
       hand_crossbow: Hand Crossbow
@@ -273,6 +282,7 @@ en:
       scimitar: Scimitar
       shortbow: Shortbow
       shortsword: Shortsword
+      warhammer: Warhammer
   options:
     automatic_roll: Roll Dice for me automatically (Computer will roll for you)
     dice_roll: Toggle Manual Dice Roll ...

data/races/dwarf.yml

@@ -0,0 +1,35 @@
+base_speed: 25
+size: medium
+darkvision: 60
+attribute_bonus:
+  con: 2
+skills:
+  - perception
+languages:
+  - common
+  - dwarvish
+race_features:
+  - dwarven_resilience
+  - stonecunning
+weapon_proficiencies:
+  - battleaxe
+  - handaxe
+  - light_hammer
+  - warhammer
+tool_proficiencies_choice: 1
+tool_proficiencies:
+  - smiths_tools
+  - brewers_supplies
+  - masons_tools
+subrace:
+  hill_dwarf:
+    attribute_bonus:
+      wis: 1
+    race_features:
+      - dwarven_toughness
+  mountain_dwarf:
+    attribute_bonus:
+      str: 1
+    weapon_proficiencies:
+      - light_armor
+      - medium_armor

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: natural_20
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Joseph Dayo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-06 00:00:00.000000000 Z
+date: 2021-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -257,6 +257,7 @@ files:
 - fixtures/corridors.yml
 - fixtures/elf_rogue.yml
 - fixtures/halfling_rogue.yml
+- fixtures/hide_test.yml
 - fixtures/high_elf_fighter.yml
 - fixtures/human_fighter.yml
 - fixtures/path_finding_test.yml
@@ -334,12 +335,14 @@ files:
 - lib/natural_20/version.rb
 - locales/en.yml
 - maps/game_map.yml
+- natural_20-0.1.0.gem
 - natural_20.gemspec
 - npcs/goblin.yml
 - npcs/human_guard.yml
 - npcs/ogre.yml
 - npcs/owlbear.yml
 - npcs/wolf.yml
+- races/dwarf.yml
 - races/elf.yml
 - races/halfling.yml
 - races/human.yml