terminal_hero 0.1.0

data/lib/terminal_hero/modules/game_controller.rb

@@ -0,0 +1,311 @@
+begin
+  require "remedy"
+  require "json"
+rescue LoadError => e
+  # Display load errors using puts (not calling external methods which may not have been loaded)
+  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 "game_data"
+require_relative "input_handler"
+require_relative "display_controller"
+require_relative "../classes/player"
+require_relative "../classes/map"
+require_relative "../classes/errors/no_feature_error"
+
+# Handles game loops and interactions between main objects
+module GameController
+  include Remedy
+
+  # MAIN GAME STATES
+
+  # Given a symbol corresponding to a key in the GAME_STATES hash (and optionally
+  # an array of parameters), calls a lambda triggering the method for that game
+  # state (which then returns the next game state + parameters).
+  def self.enter(game_state, params = nil)
+    GameData::GAME_STATES[game_state].call(self, params)
+  end
+
+  # Display an exit message and exit the application
+  def self.exit_game
+    DisplayController.display_messages(GameData::MESSAGES[:exit_game])
+    exit
+  end
+
+  # Display title menu, determine the next game state based on command line
+  # arguments or user input, and return a symbol representing the next game state
+  def self.start_game(command_line_args)
+    next_state = InputHandler.process_command_line_args(command_line_args)
+    if next_state == false
+      begin
+        next_state = DisplayController.prompt_title_menu
+        # If selected option has no associated game state, raise a custom error and
+        # re-prompt the user
+        raise NoFeatureError unless GameData::GAME_STATES.keys.include?(next_state)
+      rescue NoFeatureError => e
+        DisplayController.display_messages([e.message])
+        retry
+      end
+    else
+      # Console is cleared when displaying title menu. If menu is skipped with command line args, clear it here instead.
+      DisplayController.clear
+    end
+    return next_state
+  end
+
+  # Ask the player if they want to view the tutorial, and if so, display it.
+  # Give player the option to replay tutorial multiple times.
+  # Return a symbol representing the next game state (character creation).
+  def self.tutorial
+    show_tutorial = DisplayController.prompt_tutorial
+    while show_tutorial
+      DisplayController.display_messages(GameData::MESSAGES[:tutorial].call)
+      show_tutorial = DisplayController.prompt_tutorial(repeat: true)
+    end
+    return :character_creation
+  end
+
+  # Initialise Player or Map instances using given hashes of paramaters
+  # (or if none, default values). Return a hash containing those instances.
+  def self.init_player_and_map(player_data: {}, map_data: {})
+    player = Player.new(**player_data)
+    map = Map.new(player: player, **map_data)
+    { player: player, map: map }
+  end
+
+  # Get user input to create a new character by choosing a name and
+  # allocating stats.
+  def self.character_creation
+    # Prompt, then reprompt unless and until save name is not already taken or user confirms overwrite
+    name = DisplayController.prompt_character_name
+    name = DisplayController.prompt_character_name until confirm_save(name)
+    stats = DisplayController.prompt_stat_allocation
+    player, map = init_player_and_map(player_data: { name: name, stats: stats }).values_at(:player, :map)
+    return [:world_map, [map, player]]
+  end
+
+  # If the user attempts to create a character with the same name as an existing
+  # save file, confirm whether they want to override it
+  def self.confirm_save(name)
+    path = File.join(File.dirname(__FILE__), "../saves")
+    if File.exist?(File.join(path, "#{name.downcase}.json"))
+      return DisplayController.prompt_yes_no(GameData::PROMPTS[:overwrite_save].call(name), default_no: true)
+    end
+
+    return true
+  end
+
+  # MAP MOVEMENT
+
+  # Process monster movements and render the map
+  def self.process_monster_movement(map, player)
+    tile = map.move_monsters(player.coords)
+    DisplayController.draw_map(map, player)
+    return tile
+  end
+
+  # Process player movement and render the map
+  def self.process_player_movement(map, player, key)
+    tile = map.process_movement(player, player.calc_destination(key.name.to_sym))
+    DisplayController.draw_map(map, player)
+    return tile
+  end
+
+  # Get player input and call methods to process player and monster movement on the map
+  def self.get_map_input(map, player)
+    Interaction.new.loop do |key|
+      prompt_quit(map, player) if GameData::EXIT_KEYS.include?(key.name.to_sym)
+      next unless GameData::MOVE_KEYS.keys.include?(key.name.to_sym)
+
+      tile = process_monster_movement(map, player)
+      return [tile.event, [player, map, tile]] unless tile.nil? || tile.event.nil?
+
+      tile = process_player_movement(map, player, key)
+      return [tile.event, [player, map, tile]] unless tile.nil? || tile.event.nil?
+    end
+  end
+
+  def self.prompt_quit(map, player)
+    DisplayController.clear
+    quit = DisplayController.prompt_yes_no(GameData::PROMPTS[:save_and_exit])
+    if quit
+      save_game(player, map)
+      exit_game
+    else
+      DisplayController.draw_map(map, player)
+    end
+  end
+
+  # Calls methods to display map, listen for user input, and update map accordingly
+  def self.map_loop(map, player)
+    # Autosave whenever entering the map
+    save_game(player, map)
+    DisplayController.set_resize_hook(map, player)
+    DisplayController.draw_map(map, player)
+    event_and_params = get_map_input(map, player)
+    DisplayController.cancel_resize_hook
+    return event_and_params
+  end
+
+  # COMBAT
+
+  # Get player input and process their chosen action for a single combat round.
+  def self.player_act(player, enemy)
+    begin
+      action = DisplayController.prompt_combat_action(player, enemy)
+      # Raise a custom error if selected option does not exist
+      raise NoFeatureError unless GameData::COMBAT_ACTIONS.keys.include?(action)
+    rescue NoFeatureError => e
+      DisplayController.display_messages([e.message])
+      retry
+    end
+    outcome = GameData::COMBAT_ACTIONS[action].call(player, enemy)
+    return { action: action, outcome: outcome }
+  end
+
+  # Process one round of action by an enemy in combat.
+  def self.enemy_act(player, enemy)
+    action = :enemy_attack
+    outcome = GameData::COMBAT_ACTIONS[action].call(player, enemy)
+    return { action: action, outcome: outcome }
+  end
+
+  # Return the outcome of a combat encounter along with parameters to pass to the
+  # next game state, or return false if combat has not ended
+  def self.check_combat_outcome(player, enemy, map, escaped: false)
+    return [:post_combat, [player, enemy, map, :defeat]] if player.dead?
+    return [:post_combat, [player, enemy, map, :victory]] if enemy.dead?
+    return [:post_combat, [player, enemy, map, :escaped]] if escaped
+
+    return false
+  end
+
+  # Level up the player, display level up message, and enter stat allocation menu
+  def self.level_up(player)
+    levels = player.level_up
+    DisplayController.level_up(player, levels)
+    player.allocate_stats(
+      DisplayController.prompt_stat_allocation(
+        starting_stats: player.stats,
+        starting_points: GameData::STAT_POINTS_PER_LEVEL * levels
+      )
+    )
+  end
+
+  # Display appropriate messages and take other required actions based on
+  # the outcome of a combat encounters
+  def self.post_combat(player, enemy, map, outcome)
+    enemy.heal_hp(enemy.max_hp) if outcome == :defeat
+    map.post_combat(player, enemy, outcome)
+    xp = player.post_combat(outcome, enemy)
+    DisplayController.post_combat(outcome, player, xp)
+    # If player leveled up, apply and display the level gain and prompt user to allocate stat points
+    level_up(player) if player.leveled_up?
+    DisplayController.clear
+    # Game state returns to the world map after combat
+    return [:world_map, [map, player]]
+  end
+
+  # Returns true if passed the return value of a player_act call where
+  # the player attempted to flee and succeeded
+  def self.fled_combat?(action_outcome)
+    return action_outcome == {
+      action: :player_flee,
+      outcome: true
+    }
+  end
+
+  # Process a turn of combat for the participant whose turn it is, and check if
+  # combat has ended, returning the outcome if so
+  def self.process_combat_turn(actor, player, enemy, map)
+    action_outcome = actor == :player ? player_act(player, enemy) : enemy_act(player, enemy)
+    DisplayController.clear
+    DisplayController.display_messages(GameData::MESSAGES[:combat_status].call(player, enemy), pause: false)
+    DisplayController.display_messages(GameData::MESSAGES[action_outcome[:action]].call(action_outcome[:outcome]))
+    return check_combat_outcome(player, enemy, map, escaped: fled_combat?(action_outcome))
+  end
+
+  # Manages a combat encounter by calling methods to get and process participant
+  # actions each round, determine when combat has ended, and return the outcome
+  def self.combat_loop(player, map, tile, enemy = tile.entity)
+    DisplayController.clear
+    DisplayController.display_messages(GameData::MESSAGES[:enter_combat].call(enemy))
+    actor = :player
+    loop do
+      combat_outcome = process_combat_turn(actor, player, enemy, map)
+      return combat_outcome unless combat_outcome == false
+
+      actor = actor == :enemy ? :player : :enemy
+    end
+  end
+
+  # SAVING AND LOADING
+  
+  # Save all data required to re-initialise the current game state to a file
+  # If save fails, display a message to the user but allow program to continue
+  def self.save_game(player, map)
+    save_data = { player_data: player.export, map_data: map.export }
+    begin
+      path = File.join(File.dirname(__FILE__), "../saves")
+      Dir.mkdir(path) unless Dir.exist?(path)
+      File.write(File.join(path, "#{player.name.downcase}.json"), JSON.dump(save_data))
+    # If save fails, log and display the error, but let the application continue.
+    rescue Errno::EACCES => e
+      DisplayController.display_messages(GameData::MESSAGES[:general_error].call("Autosave", e, Utils.log_error(e)))
+      DisplayController.display_messages(GameData::MESSAGES[:save_permission_error])
+    rescue StandardError => e
+      DisplayController.display_messages(GameData::MESSAGES[:general_error].call("Autosave", e, Utils.log_error(e)))
+    end
+  end
+
+  # Prompt the user for a character name, and attempt to load a savegame file with that name
+  def self.load_game(character_name = nil)
+    begin
+      unless InputHandler.character_name_valid?(character_name)
+        character_name = DisplayController.prompt_save_name(character_name)
+      end
+      # character_name will be false if input failed validation and user chose not to retry
+      return :start_game if character_name == false
+      path = File.join(File.dirname(__FILE__), "../saves")
+      save_data = JSON.parse(File.read(File.join(path, "#{character_name.downcase}.json")), symbolize_names: true)
+      player, map = init_player_and_map(
+        **{ player_data: save_data[:player_data], map_data: save_data[:map_data] }
+      ).values_at(:player, :map)
+    # If load fails, let user choose to retry. When they choose not to, return to title menu.
+    rescue Errno::ENOENT => e
+      DisplayController.display_messages(GameData::MESSAGES[:no_save_file_error])
+      return :start_game unless DisplayController.prompt_yes_no(GameData::PROMPTS[:re_load])
+
+      character_name = nil
+      retry
+    rescue Errno::EACCES => e
+      DisplayController.display_messages(GameData::MESSAGES[:general_error].call("Loading", e, Utils.log_error(e)))
+      DisplayController.display_messages(GameData::MESSAGES[:load_permission_error])
+      return :start_game unless DisplayController.prompt_yes_no(GameData::PROMPTS[:re_load])
+
+      character_name = nil
+      retry
+    rescue JSON::ParserError => e
+      DisplayController.display_messages(GameData::MESSAGES[:parse_error])
+      # Don't display error msg directly as it contains the full JSON file content
+      DisplayController.display_messages(GameData::MESSAGES[:error_hide_msg].call(Utils.log_error(e)))
+      return :start_game unless DisplayController.prompt_yes_no(GameData::PROMPTS[:re_load])
+
+      character_name = nil
+      retry
+    rescue StandardError => e
+      DisplayController.display_messages(GameData::MESSAGES[:general_error].call("Loading", e, Utils.log_error(e)))
+      return :start_game unless DisplayController.prompt_yes_no(GameData::PROMPTS[:re_load])
+
+      character_name = nil
+      retry
+    end
+    map_loop(map, player)
+  end
+end

data/lib/terminal_hero/modules/game_data.rb

@@ -0,0 +1,331 @@
+begin
+  require "colorize"
+rescue LoadError => e
+  # Display load errors using puts (not calling external methods which may not have been loaded)
+  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
+
+# Stores game content and parameters as constants. Keeps data separate from
+# logic, so that content or parameters can be added or adjusted without changing
+# the substantive code.
+module GameData
+  # World map dimensions
+  MAP_WIDTH = 50
+  MAP_HEIGHT = 50
+
+  # Maximum map render distance (field of view)
+  MAX_H_VIEW_DIST = 25
+  MAX_V_VIEW_DIST = 25
+
+  # Constants for calculating XP to next level
+  LEVELING_CONSTANT = 10
+  LEVELING_EXPONENT = 1.6
+
+  # Stat points awarded at character creation and on level up
+  STAT_POINTS_PER_LEVEL = 5
+
+  # Maximum variance of monster levels from player level
+  MONSTER_LEVEL_VARIANCE = 1
+
+  # Multiplier for XP lost (per player level) as compared to XP gained (when defeating a monster of the same level)
+  XP_LOSS_MULTIPLIER = 0.5
+
+  # Default stats for any creature
+  DEFAULT_STATS = {
+    atk: {
+      value: 5, name: "Attack"
+    },
+    dfc: {
+      value: 5, name: "Defence"
+    },
+    con: {
+      value: 5, name: "Constitution"
+    }
+  }.freeze
+
+  # Max HP of a creature is equal to its constitution times this multiplier
+  CON_TO_HP = 10
+
+  # Player default starting coords
+  DEFAULT_COORDS = { x: 2, y: 2 }.freeze
+
+  # World map tile data
+  MAP_TILES = {
+    player: {
+      symbol: "@",
+      blocking: true,
+      color: :blue
+    },
+    forest: {
+      symbol: "T",
+      color: :green
+    },
+    mountain: {
+      symbol: "M",
+      color: :light_black
+    },
+    plain: {
+      symbol: "P",
+      color: :light_yellow
+    },
+    edge: {
+      symbol: "|",
+      color: :default,
+      blocking: true
+    },
+    monster: {
+      symbol: "%",
+      color: :red,
+      blocking: true,
+      event: :combat
+    }
+  }.freeze
+
+  TILE_DESCRIPTIONS = {
+    player: "You, the player.",
+    forest: "A forest of towering trees.",
+    mountain: "Rugged, mountainous terrain.",
+    plain: "Vast, empty plains.",
+    edge: "An impassable wall.",
+    monster: "A terrifying monster. You should fight it!"
+  }.freeze
+
+  MAP_HEADER = lambda { |player|
+    [
+      player.name.upcase.colorize(:light_yellow),
+      "HEALTH: ".colorize(:light_white) +
+        "#{player.current_hp}/#{player.max_hp}".colorize(player.health_color),
+      "ATK: ".colorize(:light_white) +
+        player.stats[:atk][:value].to_s.colorize(:green) +
+        " DEF: ".colorize(:light_white) +
+        player.stats[:dfc][:value].to_s.colorize(:green) +
+        " CON: ".colorize(:light_white) +
+        player.stats[:con][:value].to_s.colorize(:green),
+      "LEVEL: ".colorize(:light_white) +
+        player.level.to_s.colorize(:green) +
+        " XP: ".colorize(:light_white) +
+        player.xp_progress.to_s.colorize(:green),
+      " "
+    ]
+  }
+
+  # Keypress inputs for movement, and their associated coord changes
+  MOVE_KEYS = {
+    left: { x: -1, y: 0 },
+    a: { x: -1, y: 0 },
+    right: { x: 1, y: 0 },
+    d: { x: 1, y: 0 },
+    up: { x: 0, y: -1 },
+    w: { x: 0, y: -1 },
+    down: { x: 0, y: 1 },
+    s: { x: 0, y: 1 },
+  }.freeze
+
+  # Keypress inputs that will attempt to save and then exit the game from the map screen
+  # control_left_square_bracket is equivalent to the escape key
+  EXIT_KEYS = [:q, :control_left_square_bracket].freeze
+
+  GAME_STATES = {
+    start_game: ->(game_controller, _params) { game_controller.start_game([]) },
+    new_game: ->(game_controller, _params) { game_controller.tutorial },
+    load_game: ->(game_controller, params) { game_controller.load_game(params) },
+    exit_game: ->(game_controller, _params) { game_controller.exit_game },
+    character_creation: ->(game_controller, _params) { game_controller.character_creation },
+    world_map: ->(game_controller, params) { game_controller.map_loop(*params) },
+    combat: ->(game_controller, params) { game_controller.combat_loop(*params) },
+    post_combat: ->(game_controller, params) { game_controller.post_combat(*params) }
+  }.freeze
+
+  # Actions that may be taken in combat, and their associated callbacks
+  COMBAT_ACTIONS = {
+    player_attack: ->(player, enemy) { enemy.receive_damage(player.calc_damage_dealt) },
+
+    player_flee: ->(player, enemy) { player.flee(enemy) },
+
+    enemy_attack: ->(player, enemy) { player.receive_damage(enemy.calc_damage_dealt) }
+  }.freeze
+
+  # Title menu options and their return values
+  # Strings used as keys to match tty-prompt requirements
+  TITLE_MENU_OPTIONS = {
+    "New Game" => :new_game,
+    "Load Game" => :load_game,
+    "Exit" => :exit_game
+  }.freeze
+
+  # Combat menu options and their return values
+  COMBAT_MENU_OPTIONS = {
+    "Attack" => :player_attack,
+    "Flee" => :player_flee
+  }.freeze
+
+  COMMAND_LINE_ARGUMENTS = {
+    new_game: ["-n", "--new"],
+    load_game: ["-l", "--load"]
+  }.freeze
+
+  # Validation requirements to display to the user
+  VALIDATION_REQUIREMENTS = {
+    character_name: "Names must contain only letters, numbers and underscores, be 3 to 15 characters in length"\
+    ", and not contain spaces."
+  }.freeze
+
+  PROMPTS = {
+    re_load: "Would you like to try loading again?",
+    overwrite_save: lambda { |name|
+      "It looks like a saved game already exists for that character name. Are you "\
+      "sure you want to overwrite the save file for #{name.upcase.colorize(:light_yellow)}?" },
+    save_and_exit: "Would you like to exit the game? Your progress will be saved."
+  }.freeze
+
+  ASCII_ART = {
+    title: lambda { |font, console_size|
+      # Pad based on console and text size. Ascii text is centered horizontally,
+      #  and about ~1/5 of the way down the screen vertically (leaving room for content below).
+      top_pad = [(console_size.rows / 5), 0].max
+      left_pad = [(console_size.cols / 2) - 22, 0].max
+      return "#{"\n"*top_pad}#{font.write('Terminal'.rjust(left_pad))}\n"\
+             "#{font.write('Hero'.rjust(10 + left_pad))}\n".colorize(:light_yellow)
+    },
+    level_up: lambda { |font, console_size| 
+      top_pad = [(console_size.rows / 5), 0].max
+      left_pad = [(console_size.cols / 2) - 12, 0].max
+      "#{"\n"*top_pad}#{font.write('Level'.rjust(left_pad))}\n#{font.write('Up'.rjust(8 + left_pad))}\n".colorize(:light_yellow)
+    }
+  }
+
+  # Arrays of strings to be displayed in turn by the display controller
+  # (or callbacks generating such arrays)
+  MESSAGES = {
+    not_implemented: ["Sorry, it looks like you're trying to access a feature that hasn't been implemented yet."\
+    "Try choosing something else!"],
+
+    tutorial: lambda {
+      msgs = []
+      msgs.push "Welcome to Terminal Hero! In a moment, you will be prompted to create a character, but first,"\
+      "let's go over how things work."
+      msgs.push "When you enter the game, you will be presented with a map made up of the following symbols:"
+      MAP_TILES.each do |key, tile|
+        msgs.push "  #{tile[:symbol]} : #{TILE_DESCRIPTIONS[key]}".colorize(tile[:color])
+      end
+      msgs.push "You can move your character around the map using the arrow keys or \"WASD\" controls."
+      msgs.push "It's a good idea to expand your terminal to full-screen, so that you can see further on the map."
+      msgs.push "If you run into a monster, you will enter combat."
+      msgs.push "In combat, you and the enemy will take turns to act."\
+      "You will select your action each round from a list of options."
+      msgs.push "Combat continues until you or the enemy loses all their hit points (HP), or you flee the battle."
+      msgs.push "When you defeat an enemy, you will gain experience points (XP). When you lose, you will lose some XP"\
+      "(but you won't lose levels). You will then be revived with full HP."
+      msgs.push "When you gain enough XP, you will level up."
+      msgs.push "Leveling up awards stat points, which you can expend to increase your combat statistics. These are:"
+      msgs.push "#{'Attack'.colorize(:red)}: With higher attack, you will deal more damage in combat."
+      msgs.push "#{'Defence'.colorize(:blue)}: With higher defence, you will receive less damage in combat."
+      msgs.push "#{'Constitution'.colorize(:green)}: Determines your maximum HP."
+      msgs.push "You can see your current level, HP and stats above the map at any time."
+      msgs.push "The game will automatically save after every battle."
+      msgs.push "To load a saved game, select \"load\" from the title menu and enter the name of a character with "\
+      "an existing save file when prompted."
+      msgs.push "Alternatively, you can pass the arguments \"-l\" or \"--load\" followed by a saved character's name"\
+      "when running the game from the command line."
+      msgs.push "You can also pass the arguments \"-n\" or \"--new\" to skip the title menu and "\
+      "jump straight into a new game."
+      msgs.push "You can press \"escape\" or \"q\" on the map screen at any time to save and exit the game."
+      msgs.push "That's all there is to it. Have fun!"
+      return msgs
+    },
+
+    enter_combat: ->(enemy) { ["You encountered a level #{enemy.level} #{enemy.name}!"] },
+
+    combat_status: lambda { |player, enemy|
+      [
+        "Your health: #{"#{player.current_hp} / #{player.max_hp}".colorize(player.health_color)} | "\
+        "Enemy health: #{"#{enemy.current_hp} / #{enemy.max_hp}".colorize(enemy.health_color)}"
+      ]
+    },
+
+    player_attack: lambda { |damage|
+      ["You attacked the enemy, dealing #{damage} damage!\n"]
+    },
+
+    enemy_attack: lambda { |damage|
+      ["The enemy attacked you, dealing #{damage} damage!\n"]
+    },
+
+    player_flee: lambda { |success|
+      msgs = ["You attempt to flee..."]
+      msgs.push("You couldn't get away!") unless success
+      return msgs
+    },
+
+    combat_victory: lambda { |xp|
+      msgs = ["You defeated the enemy!"]
+      msgs.push xp == 1 ? "You received #{xp} experience point!" : "You received #{xp} experience points!"
+      return msgs
+    },
+
+    leveled_up: lambda { |player, levels| 
+      msgs = levels == 1 ? ["You gained #{levels} level!"] : ["You gained #{levels} levels!"]
+      msgs[0] += " You are now level #{player.level}!"
+      return msgs
+    },
+
+    level_progress: ->(player) { ["XP to next level: #{player.xp_progress}"] },
+
+    combat_defeat: ->(xp) { ["You were defeated! You lost #{xp} XP."] },
+
+    combat_escaped: ["You got away!"],
+
+    exit_game: ["Thanks for playing! See you next time."],
+
+    general_error: ->(action, e, file_path, msg: "#{action} failed: an error occurred.") {
+      [
+        msg.colorize(:red),
+        " \"#{e.message}.\"".colorize(:yellow),
+        "Details of the error have been logged to \"#{file_path.colorize(:light_blue)}.\" "\
+        "If you would like to submit a bug report, please include a copy of this file."
+      ]
+    },
+
+    out_of_bounds_error: "You have attempted to move outside the game map. If you loaded the game,"\
+      "your save file may have been modified or corrupted.".colorize(:red),
+
+    error_hide_msg: ->(file_path) {
+      [
+        "Details of the error have been logged to \"#{file_path.colorize(:light_blue)}.\" "\
+        "If you would like to submit a bug report, please include a copy of this file."
+      ]
+    },
+
+    save_permission_error: [
+      "To enable saving, please ensure that the current user has "\
+      "write access to the directory where the game has been installed"\
+      "and to files in the \"termina_hero/saves\" subfolder."
+    ],
+
+    no_save_file_error: [
+      "No save was file found for that character. Input "\
+      "must match the character's name exactly (but is not case sensitive).".colorize(:red)
+    ],
+
+    load_permission_error: [
+      "To enable loading, please ensure that the current user has "\
+      "read access to files in the \"terminal_hero/saves\" subfolder."
+    ],
+
+    parse_error: [
+      "The save file you are trying to load could not be parsed. It may have been modified or corrupted.".colorize(:red)
+    ],
+
+    dependency_load_error: [
+      "It appears that a dependency was not able to be loaded.",
+      "Please try installing dependencies mannually by running the command \"bundle install\" from within the installation directory.",
+      "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\""
+    ]
+  }.freeze
+end