terminal_hero 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eeb49e0681f62399bacf4cd684adf8082d49fe1220ab74a1f4ea5591b1838acc
+  data.tar.gz: 31077f1a8e99df94e28bb9dfbde8aaa6e5c6531e04dbd2dc943a2c2011f25f97
+SHA512:
+  metadata.gz: 6df974bec975cb17a01c02ef7d14aa15b6ec81018be52ec6642947609bd249a84f7647d075f742707a1da67482642d8a3dcf131a66031e166cf698b3d35b255b
+  data.tar.gz: b19dfd9b206ad1528db9e8967a49006784fa8f190e3025f7a656e75f18bf74dc6de2608bc2c4014713ae9835fe754b2fd8e24a332ad5feacafa668232d08ee23

data/bin/terminal_hero

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'terminal_hero'
+ruby terminal_hero.rb

data/lib/terminal_hero.rb

@@ -0,0 +1,5 @@
+require_relative "terminal_hero/modules/game_controller"
+
+next_state = GameController.start_game(ARGV)
+next_state = GameController.enter(*next_state) until next_state == :exit_game
+GameController.exit_game

data/lib/terminal_hero/classes/creature.rb

@@ -0,0 +1,80 @@
+require_relative "../modules/game_data"
+require_relative "../modules/utils"
+
+# Represents a creature that can participate in combat
+# (ie. Player and Monsters)
+class Creature
+  attr_accessor :coords
+  attr_reader :max_hp, :current_hp, :stats, :level, :name, :avatar
+
+  def initialize(name, coords, stats, health_lost, level, avatar)
+    @name = name
+    @level = level
+    @stats = Utils.depth_two_clone(stats)
+    @max_hp = calc_max_hp
+    @current_hp = @max_hp - health_lost
+    @coords = coords
+    @avatar = avatar
+  end
+
+  # Given a direction to move, return the destination coords
+  def calc_destination(direction)
+    return nil if direction.nil?
+
+    return {
+      x: @coords[:x] + GameData::MOVE_KEYS[direction][:x],
+      y: @coords[:y] + GameData::MOVE_KEYS[direction][:y]
+    }
+  end
+
+  # Calculate max HP based on stats (constitution)
+  def calc_max_hp
+    return @stats[:con][:value] * GameData::CON_TO_HP
+  end
+
+  # Calculate damage range based on a given attack stat value,
+  # returning {min: min, max: max}
+  def calc_damage_range(attack: stats[:atk][:value])
+    return { min: attack, max: (attack * 1.5).round }
+  end
+
+  # Determine damage within a range based on a random (or given) roll
+  def calc_damage_dealt(min: calc_damage_range[:min], max: calc_damage_range[:max])
+    return rand(min..max)
+  end
+
+  # Reduce hp by damage taken, after applying defence stat, but not below 0
+  def receive_damage(base_damage, defence: @stats[:dfc][:value])
+    reduction = (defence.to_f / 2).round
+    damage = [base_damage - reduction, 1].max
+    @current_hp = [@current_hp - damage, 0].max
+    return damage
+  end
+
+  # Increase hp by healing received, not exceeding max hp
+  def heal_hp(healing)
+    @current_hp = [@current_hp + healing, @max_hp].min
+    return healing
+  end
+
+  # Attempt to flee from an enemy in combat. Chance of success varies with level difference
+  def flee(enemy)
+    level_difference = @level - enemy.level
+    target = Utils.collar(0.05, 0.5 - (level_difference / 10.0), 0.95)
+    return rand >= target
+  end
+
+  # Returns true if the creature is dead (hp at or below zero)
+  def dead?
+    return @current_hp <= 0
+  end
+
+  # Returns the color to use in displaying the creature's health based on its percentage of max hp
+  def health_color
+    health_percent = @current_hp.to_f / @max_hp * 100
+    return :green if health_percent > 60
+    return :light_yellow if health_percent > 25
+
+    return :red
+  end
+end

data/lib/terminal_hero/classes/errors/invalid_input_error.rb

@@ -0,0 +1,12 @@
+# A custom error raised when providing user input that does not meet validation requirements
+class InvalidInputError < StandardError
+  def initialize(msg: "Invalid input provided.", requirements: "Input must meet validation requirements.")
+    super(msg)
+    @msg = msg
+    @requirements = requirements
+  end
+  def to_s
+    super
+    "#{@msg} #{@requirements}"
+  end
+end

data/lib/terminal_hero/classes/errors/no_feature_error.rb

@@ -0,0 +1,9 @@
+# A custom error raised when accessing a feature not yet implemented
+class NoFeatureError < StandardError
+  def initialize(
+    msg = "Sorry, it looks like you're trying to access a feature that hasn't been implemented yet. "\
+    "Try choosing something else!"
+  )
+    super
+  end
+end

data/lib/terminal_hero/classes/map.rb

@@ -0,0 +1,247 @@
+begin
+  require "colorize"
+rescue LoadError => e
+  # Display load errors using puts (not calling external methods which may not be available)
+  puts "It appears that a dependency was unable to be loaded: "
+  puts e.message
+  puts "Please try installing dependencies mannually by running the command "\
+  "\"bundle install\" from within the installation directory."
+  puts "If you installed this application as a gem, you could try reinstalling it by "\
+  "running \"gem uninstall terminal_hero\" followed by \"gem install terminal_hero\""
+  exit
+end
+require_relative "tile"
+require_relative "monster"
+require_relative "../modules/game_data"
+
+# Represents a map for the player to navigate
+class Map
+  include GameData
+
+  attr_reader :grid, :symbols
+
+  def initialize(player: nil, width: GameData::MAP_WIDTH, height: GameData::MAP_HEIGHT, grid: nil, monsters: [])
+    # Set dimensions of map
+    @width = width
+    @height = height
+    # Dictionary of map symbols
+    @symbols = GameData::MAP_TILES
+    # Array of monsters on the map
+    @monsters = monsters
+    if grid.nil?
+      generate_map(player)
+    else
+      load_map(grid, player)
+    end
+  end
+
+  # SETUP
+
+  # Generate a new map when starting a new game
+  def generate_map(player)
+    # Fill map grid with terrain tiles
+    @grid = setup_grid
+    # Place the Player on the map
+    @grid[player.coords[:y]][player.coords[:x]].entity = player
+    # Populate the map with monsters
+    populate_monsters(player.level)
+  end
+
+  # Randomly populate monsters on the grid up to a fluctuating maximum population
+  def populate_monsters(player_level)
+    # 1/60 map tiles +/- 5 will be populated with monsters
+    max_monsters = [(@width * @height / 80) + rand(-5..5), 1].max
+    # Populate map until max population is reached, or number of iterations equals
+    # number of map tiles (preventing infinite loop if valid tile not found)
+    counter = 0
+    until @monsters.length >= max_monsters || counter >= @width * @height
+      y = rand(1..(@height - 2))
+      x = rand(1..(@width - 2))
+      unless @grid[y][x].blocking
+        monster = Monster.new(coords: { x: x, y: y }, level_base: player_level)
+        @grid[y][x].entity = monster
+        @monsters.push(monster)
+      end
+      counter += 1
+    end
+  end
+
+  # Given a grid from save data, load it into the @grid instance variable
+  def load_grid!(grid)
+    @grid = grid.map do |row|
+      row.map do |tile|
+        # Convert string values generated by JSON back to symbols
+        tile[:color] = tile[:color].to_sym
+        tile[:event] = tile[:event].to_sym unless tile[:event].nil?
+        # Map each hash of tile data to a Tile
+        Tile.new(**tile)
+      end
+    end
+  end
+
+  # Load monsters from save data into @monsters and place them on tiles in @grid
+  def load_monsters!
+    @monsters.map! do |monster_data|
+      monster_data[:event] = monster_data[:event].to_sym
+      monster = Monster.new(**monster_data)
+      @grid[monster.coords[:y]][monster.coords[:x]].entity = monster
+      monster
+    end
+  end
+
+  # Set up the map grid using data loaded from a save file when loading the game
+  def load_map(grid, player)
+    load_grid!(grid)
+    load_monsters!
+    @grid[player.coords[:y]][player.coords[:x]].entity = player
+  end
+
+  # Given indices, centrepoints, a radius, and a modification to the radius,
+  # determine whether indices fall inside the radius from the centrepoints. Used for generating terrain.
+  def in_radius?(indices, centrepoints, radii, variance)
+    y_index, x_index = indices
+    y_centre, x_centre = centrepoints
+    v_radius, h_radius = radii
+    ((y_centre - v_radius - variance)..(y_centre + v_radius + variance)).include?(y_index) &&
+      ((x_centre - h_radius - variance)..(x_centre + h_radius + variance)).include?(x_index)
+  end
+
+  # Calculate relevant paramaters for setup_grid
+  def generate_grid_params
+    # Create 2D array grid
+    grid = []
+    @height.times { grid.push(Array.new(@width, false)) }
+
+    # Return parameters for map generation - centrepoints, base radius of map
+    # regions, and the maximum random variance from that radius
+    return grid, @width / 2, @height / 2, @width / 8, @height / 8, [@width, @height].min / 16
+  end
+
+  # Populate the map grid with terrain tiles in a semi-random distribution of
+  # regions expanding from the centre of the map outwards
+  def setup_grid
+    grid, h_cent, v_cent, h_rad, v_rad, max_variance = generate_grid_params
+    variance = 0
+    # Populate the map grid with terrain tiles
+    grid.each_with_index do |row, y|
+      row.map!.with_index do |_square, x|
+        # First and last row and column are edge tiles
+        if y == 0 || y == @height - 1 || x == 0 || x == @width - 1
+          tile = Tile.new(**@symbols[:edge])
+        # Tiles inside base radius (after variance) are region 1
+        elsif in_radius?([y, x], [v_cent, h_cent], [v_rad, h_rad], variance)
+          tile = Tile.new(**@symbols[:mountain])
+        # Tiles not in region 1 that are inside 2 * base radius are region 2
+        elsif in_radius?([y, x], [v_cent, h_cent], [v_rad * 2, h_rad * 2], variance)
+          tile = Tile.new(**@symbols[:forest])
+        # Everything else is region 3
+        else
+          tile = Tile.new(**@symbols[:plain])
+        end
+        # Change the variance applied to radius so region boundaries are irregular
+        variance = Utils.collar(0, variance + rand(-1..1), max_variance)
+        tile
+      end
+    end
+    return grid
+  end
+
+  # MOVEMENT PROCESSING
+
+  # Given destination coords for movement, update the map, move the moving entity
+  # and return the destination tile
+  def process_movement(mover, destination)
+    # If player destination is out of bounds, display and log error, then exit
+    begin
+      raise InvalidInputError if !valid_move?(destination) && mover.instance_of?(Player)
+    rescue InvalidInputError => e
+      DisplayController
+        .display_messages(GameData::MESSAGES[:general_error]
+        .call("Movement", e, Utils.log_error(e), msg: GameData::MESSAGES[:out_of_bounds_error]))
+      exit
+    end
+    # Return nil if monster tries to move out of bounds
+    return nil unless valid_move?(destination)
+
+    # Process move and if destination is not blocked and return destination tile 
+    unless @grid[destination[:y]][destination[:x]].blocking
+      @grid[mover.coords[:y]][mover.coords[:x]].entity = nil
+      @grid[destination[:y]][destination[:x]].entity = mover
+      mover.coords = destination
+    end
+    return @grid[destination[:y]][destination[:x]]
+  end
+
+  # Call methods for each monster to determine the move it makes (if any) and process
+  # that movement. If a monster encounters the player, return its tile to allow
+  # triggering a combat event.
+  def move_monsters(player_coords)
+    event_tile = nil
+    @monsters.each do |monster|
+      destination = monster.calc_destination(monster.choose_move(player_coords))
+      process_movement(monster, destination)
+      event_tile = @grid[monster.coords[:y]][monster.coords[:x]] if destination == player_coords
+    end
+    return event_tile
+  end
+
+  # Check if coords are a valid destination within the map (but not necessarily open for movement)
+  def valid_move?(coords)
+    return false unless coords.is_a?(Hash)
+    return false unless (0..(@width - 1)).include?(coords[:x])
+    return false unless (0..(@height - 1)).include?(coords[:y])
+
+    return true
+  end
+
+  # COMBAT OUTCOME PROCESSING
+
+  # If player was defeated in combat, move them back to starting location (unless
+  # already there), swapping positions with any entity that is currently occupying that location
+  def process_combat_defeat(player)
+    return if player.coords.values == GameData::DEFAULT_COORDS.values
+
+    shifted_entity = @grid[GameData::DEFAULT_COORDS[:y]][GameData::DEFAULT_COORDS[:x]].entity
+    player_location = player.coords
+    @grid[GameData::DEFAULT_COORDS[:y]][GameData::DEFAULT_COORDS[:x]].entity = nil
+    process_movement(player, GameData::DEFAULT_COORDS)
+    process_movement(shifted_entity, player_location) unless shifted_entity.nil?
+  end
+
+
+  # Remove a monster from the map
+  def remove_monster(monster)
+    @grid[monster.coords[:y]][monster.coords[:x]].entity = nil
+    @monsters.delete(monster)
+  end
+
+  # If a monster was defeated in combat, remove it and repopulate monsters
+  def process_combat_victory(player, monster)
+    remove_monster(monster)
+    populate_monsters(player.level)
+  end
+
+  # When combat ends, call methods to update the map based on the outcome
+  def post_combat(player, monster, outcome)
+    case outcome
+    when :victory
+      process_combat_victory(player, monster)
+    when :defeat
+      process_combat_defeat(player)
+    end
+  end
+
+  # EXPORT FOR SAVE
+
+  # Export all values required for map initialization to a hash, to be stored in a JSON save file
+  def export
+    return {
+      width: @width,
+      height: @height,
+      grid: @grid.map do |row|
+        row.map(&:export)
+      end,
+      monsters: @monsters.map(&:export)
+    }
+  end
+end

data/lib/terminal_hero/classes/monster.rb

@@ -0,0 +1,84 @@
+require_relative "creature"
+require_relative "../modules/game_data"
+require_relative "../modules/utils"
+
+# Represents an enemy that the player can fight
+class Monster < Creature
+  attr_reader :event
+
+  def initialize(
+    name: "Monster",
+    coords: nil,
+    stats: GameData::DEFAULT_STATS,
+    health_lost: 0,
+    level_base: 1,
+    level: nil,
+    avatar: "%".colorize(:red),
+    event: :combat
+  )
+    level = select_level(level_base) if level.nil?
+    stats = allocate_stats(stats, level)
+    super(name, coords, stats, health_lost, level, avatar)
+    @event = event
+  end
+
+  # Set level, based on base level and maximum deviation from that base
+  def select_level(level_base)
+    min = [level_base - GameData::MONSTER_LEVEL_VARIANCE, 1].max
+    max = [level_base + GameData::MONSTER_LEVEL_VARIANCE, 1].max
+    return rand(min..max)
+  end
+
+  # Calculate stat points based on monster level, and randomly allocate them among stats
+  def allocate_stats(starting_stats, level)
+    # Monster starts with 5 less stat points, so Player is slightly stronger
+    stat_points = (level - 1) * GameData::STAT_POINTS_PER_LEVEL
+    stats = Utils.depth_two_clone(starting_stats)
+    # Allocate a random number of available points to each stat, in random order
+    keys = stats.keys.shuffle
+    keys.each do |key|
+      point_spend = rand(0..stat_points)
+      stats[key][:value] += point_spend
+      stat_points -= point_spend
+    end
+    # Allocate remaining stat points to the last stat
+    stats[keys[-1]][:value] += stat_points
+    return stats
+  end
+
+  # Calculate the amount of XP a monster is worth, based on its level and
+  # an exponent and range
+  def calc_xp(level: @level, exponent: GameData::LEVELING_EXPONENT, constant: level)
+    return constant + (level**exponent).round
+  end
+
+  # Decide whether and where to move. There is a 75% chance the monster will move at all, and if it
+  # does, it will move towards the palayer if the player is within 6 tiles of the moster.
+  def choose_move(player_coords)
+    return nil unless rand < 0.75
+
+    x_difference = @coords[:x] - player_coords[:x]
+    y_difference = @coords[:y] - player_coords[:y]
+    directions = { x: [:left, :right], y: [:up, :down] }
+    if x_difference.abs + y_difference.abs <= 6
+      axis = x_difference.abs > y_difference.abs ? :x : :y
+      direction = @coords[axis] > player_coords[axis] ? directions[axis][0] : directions[axis][1]
+    else
+      direction = [:left, :right, :up, :down][rand(0..3)]
+    end
+    return direction
+  end
+
+  # Export all values required for initialization to a hash, to be stored in a JSON save file
+  def export
+    return {
+      name: @name,
+      coords: @coords,
+      level: @level,
+      stats: @stats,
+      health_lost: (@max_hp - @current_hp),
+      avatar: @avatar,
+      event: @event
+    }
+  end
+end