class Gemwarrior::Evaluator

Constants

CHANGE_PARAMS
DEBUG_LIST_PARAMS
DEBUG_STAT_PARAMS
ERROR_ATTACK_PARAM_INVALID
ERROR_ATTACK_PARAM_MISSING
ERROR_BREAKTHRU_INEXPERIENCED
ERROR_BREAKTHRU_PARAM_INVALID
ERROR_BREAKTHRU_PARAM_MISSING
ERROR_CHANGE_PARAM_INVALID
ERROR_CHANGE_PARAM_MISSING
ERROR_COMMAND_INVALID
ERROR_DEBUG_GLOBAL_VAR_INVALID
ERROR_DEBUG_STAT_INV_PARAM_INVALID
ERROR_DEBUG_STAT_PARAM_INVALID
ERROR_DEBUG_STAT_PARAM_MISSING
ERROR_DEBUG_TELEPORT_PARAMS_INVALID
ERROR_DEBUG_TELEPORT_PARAMS_MISSING
ERROR_DEBUG_TELEPORT_PARAMS_NEEDED
ERROR_DIRECTION_PARAM_INVALID
ERROR_DROP_PARAM_MISSING
ERROR_EQUIP_PARAM_MISSING
ERROR_GO_PARAM_INVALID
ERROR_GO_PARAM_MISSING
ERROR_LIST_PARAM_INVALID
ERROR_LIST_PARAM_MISSING
ERROR_LOOK_AT_PARAM_MISSING
ERROR_TAKE_PARAM_MISSING
ERROR_TALK_PARAM_INVALID
ERROR_TALK_PARAM_UNTALKABLE
ERROR_TALK_TO_PARAM_MISSING
ERROR_UNEQUIP_PARAM_MISSING
ERROR_USE_PARAM_INVALID
ERROR_USE_PARAM_MISSING
ERROR_USE_PARAM_UNUSEABLE
GO_PARAMS
PROGRAM_NAME

CONSTANTS

QUIT_MESSAGE
RESUME_MESSAGE

Attributes

aliases[RW]
cmd_descriptions[RW]
commands[RW]
devaliases[RW]
devcmd_descriptions[RW]
devcommands[RW]
devextras[RW]
extras[RW]
world[RW]

Public Class Methods

new(world) click to toggle source
# File lib/gemwarrior/evaluator.rb, line 62
def initialize(world)
  self.world = world

  self.devcommands  = %w(god beast constants list vars map stat global teleport spawn levelbump restfight)
  self.devaliases   = %w(gd bs cn ls vs m st gl tp sp lb rf)
  self.devextras    = %w()
  self.devcmd_descriptions = [
    'Toggle god mode (i.e. invincible)',
    'Toggle beast mode (i.e. super strength)',
    'List all GameAssets',
    'List all instances of a specific entity type',
    'List all the variables in the world',
    'Show a map of the world',
    'Change player stat',
    'Change world global variable',
    'Teleport to coordinates (5 0 0) or name (\'Home\')',
    'Spawn random monster',
    'Bump your character up *n* levels',
    'Rest, but ensure battle for testing'
  ]

  self.commands     = %w(character look rest take talk inventory use open drop equip unequip go north east south west attack breakthru change version checkupdate help quit quit!)
  self.aliases      = %w(c l r t tk i u o d eq ue g n e s w a br ch v cu h q qq)
  self.extras       = %w(exit exit! x xx fight f ? ?? ???)
  self.cmd_descriptions = [
    'Display character information',
    'Look around your current location',
    'Take a load off and regain HP',
    'Take item',
    'Talk to person',
    'Look in your inventory',
    'Use item (in inventory or environment)',
    'Open item (in inventory or environment)',
    'Drop item',
    'Equip item',
    'Unequip item',
    'Go in a direction',
    'Go north (shortcut)',
    'Go east (shortcut)',
    'Go south (shortcut)',
    'Go west (shortcut)',
    'Attack a monster (also fight)',
    'Teleport to a location (if you are experienced enough)',
    'Change attribute',
    'Display game version',
    'Check for newer game releases',
    'This help menu (also ?)',
    'Quit w/ confirmation (also exit/x)',
    'Quit w/o confirmation (also exit!/xx)'
  ]
end

Public Instance Methods

parse(input) click to toggle source
# File lib/gemwarrior/evaluator.rb, line 114
def parse(input)
  case input
  # Ctrl-D or empty command
  when nil, ''
    return
  # real command
  else
    return ERROR_COMMAND_INVALID.colorize(:red) unless input_valid?(input)
  end

  tokens = input.split
  command = tokens.first.downcase
  param1 = tokens[1]
  param2 = tokens[2]
  param3 = tokens[3]

  # helpful
  player_cur_location = world.location_by_coords(world.player.cur_coords)

  # dev commands
  if GameOptions.data['debug_mode']
    case command
    when 'god', 'gd'
      GameOptions.data['god_mode'] = !GameOptions.data['god_mode']
      return "God mode set to #{GameOptions.data['god_mode']}"
    when 'beast', 'bs'
      GameOptions.data['beast_mode'] = !GameOptions.data['beast_mode']
      return "Beast mode set to #{GameOptions.data['beast_mode']}"
    when 'constants', 'cn'
      puts 'GameCreatures'.colorize(:yellow)
      puts GameCreatures.data
      STDIN.getc
      puts 'GameMonsters'.colorize(:yellow)
      puts GameMonsters.data
      STDIN.getc
      puts 'GamePeople'.colorize(:yellow)
      puts GamePeople.data
      STDIN.getc
      puts 'GameItems'.colorize(:yellow)
      puts GameItems.data
      STDIN.getc
      puts 'GameArmor'.colorize(:yellow)
      puts GameArmor.data
      STDIN.getc
      puts 'GameWeapons'.colorize(:yellow)
      puts GameWeapons.data
    when 'vars', 'vs'
      if param1
        world.print_vars(param1)
      else
        world.print_vars
      end
    when 'list', 'ls'
      if param1.nil?
        puts ERROR_LIST_PARAM_MISSING
        return DEBUG_LIST_PARAMS
      else
        return world.list(param1, param2)
      end
    when 'map', 'm'
      world.print_map(param1)
    when 'stat', 'st'
      if param1.nil?
        puts ERROR_DEBUG_STAT_PARAM_MISSING
        return DEBUG_STAT_PARAMS
      else
        case param1
        when 'hp_cur', 'hp'
          unless param2.nil?
            param2 = param2.to_i
            if param2.is_a? Numeric
              if param2 > 0
                world.player.hp_cur = param2
              end
            end
          end
        when 'atk_lo'
          unless param2.nil?
            param2 = param2.to_i
            if param2.is_a? Numeric
              if param2 >= 0
                world.player.atk_lo = param2
              end
            end
          end
        when 'atk_hi'
          unless param2.nil?
            param2 = param2.to_i
            if param2.is_a? Numeric
              if param2 >= 0
                world.player.atk_hi = param2
              end
            end
          end
        when 'strength', 'str', 'st'
          unless param2.nil?
            param2 = param2.to_i
            if param2.is_a? Numeric
              if param2 >= 0
                world.player.atk_lo = param2
                world.player.atk_hi = param2
              end
            end
          end
        when 'dexterity', 'dex'
          unless param2.nil?
            param2 = param2.to_i
            if param2.is_a? Numeric
              if param2 >= 0
                world.player.dexterity = param2
              end
            end
          end
        when 'defense', 'def'
          unless param2.nil?
            param2 = param2.to_i
            if param2.is_a? Numeric
              if param2 >= 0
                world.player.defense = param2
              end
            end
          end
        when 'rox', 'r', '$'
          unless param2.nil?
            param2 = param2.to_i
            if param2.is_a? Numeric
              if param2 >= 0
                world.player.rox = param2
              end
            end
          end
        when 'experience', 'xp'
          unless param2.nil?
            param2 = param2.to_i
            if param2.is_a? Numeric
              if param2 >= 0
                world.player.xp = param2
              end
            end
          end
        when 'inventory', 'inv'
          unless param2.nil?
            begin
              item_const_name = Gemwarrior.const_get(Formatting.upstyle(param2, no_space: true))
              item = item_const_name.new
              world.player.inventory.items.push(item)
              return "#{item.name.colorize(:yellow)} added to player inventory."
            rescue
              return ERROR_DEBUG_STAT_INV_PARAM_INVALID
            end
          end
        else
          return ERROR_DEBUG_STAT_PARAM_INVALID
        end
      end
    when 'global', 'gl'
      if param1.nil?
        return world.instance_variables.join(', ')
      elsif world.instance_variable_get("@#{param1}").nil?
        return ERROR_DEBUG_GLOBAL_VAR_INVALID
      elsif param2.nil?
        return world.instance_variable_get("@#{param1}").to_s
      else
        val = false
        val = param2.eql?('true') ? true : val

        world.instance_variable_set("@#{param1}", val)
        return "Instance variable #{param1} has been set to #{val}."
      end
    when 'spawn', 'sp'
      player_cur_location = world.location_by_coords(world.player.cur_coords)
      player_cur_location.populate_monsters(GameMonsters.data, true, param1)
      return world.describe(player_cur_location)
    when 'teleport', 'tp'
      if param1.nil?
        return ERROR_DEBUG_TELEPORT_PARAMS_MISSING
      else
        if (param1.to_i.to_s == param1)
          # we got at least an x coordinate
          if (param2.to_i.to_s == param2)
            # we got a y coordinate, too
            x_coord = param1.to_i
            y_coord = param2.to_i
            # grab the z coordinate, if present, otherwise default to current level
            z_coord = param3.to_i.to_s == param3 ? param3.to_i : world.player.cur_coords[:z]

            # check to make sure new location exists
            if world.location_by_coords(x: x_coord, y: y_coord, z: z_coord)
              world.player.cur_coords = { x: x_coord, y: y_coord, z: z_coord }
            else
              return ERROR_DEBUG_TELEPORT_PARAMS_INVALID
            end
          else
            # we only got an x coordinate
            return ERROR_DEBUG_TELEPORT_PARAMS_NEEDED
          end
        else
          # we got a place name instead, potentially
          place_to_match = tokens[1..tokens.length].join(' ').downcase
          locations = []
          world.locations.each do |l|
            locations << l.name.downcase
          end
          if locations.include?(place_to_match)
            world.player.cur_coords = world.location_coords_by_name(place_to_match)
          else
            return ERROR_DEBUG_TELEPORT_PARAMS_INVALID
          end
        end

        # stats
        world.player.movements_made += 1

        Animation.run(phrase: '** TELEPORT! **', speed: :insane)
        player_cur_location = world.location_by_coords(world.player.cur_coords)
        return world.describe(player_cur_location)
      end
    when 'levelbump', 'lb'
      new_level = param1.nil? ? 1 : param1.to_i
      world.player.update_stats(reason: :level_bump, value: new_level)
    when 'restfight', 'rf'
      result = world.player.rest(world, 0, true)

      if result.eql?('death')
        player_death_resurrection
      end
    end
  end

  # normal commands
  case command
  when 'character', 'c'
    # bypass puts so it prints out with newlines properly
    print world.player.check_self
  when 'inventory', 'i'
    if param1
      world.player.inventory.describe_item(param1)
    else
      world.player.list_inventory
    end
  when 'look', 'l'
    if param1
      # convert 'look at' to 'look'
      if param1.eql?('at')
        if param2
          param1 = param2
        else
          return ERROR_LOOK_AT_PARAM_MISSING
        end
      end
      world.describe_entity(player_cur_location, param1)
    else
      world.describe(player_cur_location)
    end
  when 'rest', 'r'
    tent_uses = 0
    player_inventory = world.player.inventory

    if player_inventory.contains_item?('tent')
      player_inventory.items.each do |i|
        if i.name.eql?('tent')
          if i.number_of_uses > 0
            result = i.use(world)
            tent_uses = i.number_of_uses
            i.number_of_uses -= 1

            puts ">> tent can be used when resting #{i.number_of_uses} more time(s)."
          end
        end
      end
    elsif player_cur_location.contains_item?('tent')
      player_cur_location.items.each do |i|
        if i.name.eql?('tent')
          if i.number_of_uses > 0
            result = i.use(world)
            tent_uses = i.number_of_uses
            i.number_of_uses -= 1

            puts ">> tent can be used when resting #{i.number_of_uses} more time(s)."
          end
        end
      end
    end

    result = world.player.rest(world, tent_uses)

    if result.eql?('death')
      player_death_resurrection
    else
      result
    end
  when 'take', 't'
    if param1.nil?
      ERROR_TAKE_PARAM_MISSING
    else
      world.player.inventory.add_item(param1, player_cur_location, world.player)
    end
  when 'talk', 'tk'
    if param1.nil?
      return ERROR_TALK_TO_PARAM_MISSING
    elsif param1.eql?('to')
      if param2
        param1 = param2
      else
        return ERROR_TALK_TO_PARAM_MISSING
      end
    end

    talkable_name = param1

    player_inventory = world.player.inventory

    if player_inventory.contains_item?(talkable_name)
      player_inventory.items.each do |person|
        if person.name.eql?(talkable_name)
          if person.talkable
            return self.parse("use #{talkable_name}")
          else
            return ERROR_TALK_PARAM_UNTALKABLE
          end
        end
      end
    elsif player_cur_location.contains_item?(talkable_name)
      player_cur_location.items.each do |person|
        if person.name.eql?(talkable_name)
          if person.talkable
            return self.parse("use #{talkable_name}")
          else
            return ERROR_TALK_PARAM_UNTALKABLE
          end
        end
      end
    elsif player_cur_location.has_monster?(talkable_name)
      player_cur_location.monsters_abounding.each do |monster|
        if monster.name.eql?(talkable_name)
          if monster.talkable
            return self.parse("use #{talkable_name}")
          else
            return ERROR_TALK_PARAM_UNTALKABLE
          end
        end
      end
    elsif player_cur_location.has_boss?(talkable_name)
      player_cur_location.bosses_abounding.each do |boss|
        if boss.name.eql?(talkable_name)
          if boss.talkable
            return self.parse("use #{talkable_name}")
          else
            return ERROR_TALK_PARAM_UNTALKABLE
          end
        end
      end
    end
  when 'use', 'u', 'open', 'o'
    if param1.nil?
      ERROR_USE_PARAM_MISSING
    else
      item_name = param1
      result = nil

      player_inventory = world.player.inventory

      if player_inventory.contains_item?(item_name)
        player_inventory.items.each do |i|
          if i.name.eql?(item_name)
            if i.useable
              if !i.number_of_uses.nil?
                if i.number_of_uses > 0
                  result = i.use(world)
                  i.number_of_uses -= 1
                  puts ">> #{i.name} can be used #{i.number_of_uses} more time(s)."
                  break
                else
                  return ">> #{i.name} cannot be used anymore."
                end
              elsif i.consumable
                result = i.use(world)
                world.player.inventory.remove_item(i.name)
                break
              else
                result = i.use(world)
                break
              end
            else
              return ERROR_USE_PARAM_UNUSEABLE
            end
          end
        end
      elsif player_cur_location.contains_item?(item_name)
        player_cur_location.items.each do |i|
          if i.name.eql?(item_name)
            if i.useable
              if !i.number_of_uses.nil?
                if i.number_of_uses > 0
                  result = i.use(world)
                  i.number_of_uses -= 1
                  puts ">> #{i.name} can be used #{i.number_of_uses} more time(s)."
                  break
                else
                  return ">> #{i.name} cannot be used anymore."
                end
              elsif i.consumable
                result = i.use(world)
                location.remove_item(i.name)
                break
              else
                result = i.use(world)
                break
              end
            else
              return ERROR_USE_PARAM_UNUSEABLE
            end
          end
        end
      elsif player_cur_location.has_monster?(item_name)
        player_cur_location.monsters_abounding.each do |i|
          if i.name.eql?(item_name)
            return i.use(world)
          end
        end
      elsif player_cur_location.has_boss?(item_name)
        player_cur_location.bosses_abounding.each do |i|
          if i.name.eql?(item_name)
            return i.use(world)
          end
        end
      end

      if result.nil?
        ERROR_USE_PARAM_INVALID
      else
        case result[:type]
        when 'move'
          world.player.cur_coords = world.location_coords_by_name(result[:data])
          player_cur_location = world.location_by_coords(world.player.cur_coords)
          world.describe(player_cur_location)
        when 'move_dangerous'
          dmg = rand(0..2)
          puts ">> You lose #{dmg} hit point(s)." if dmg > 0
          world.player.take_damage(dmg)

          world.player.cur_coords = world.location_coords_by_name(result[:data])
          player_cur_location = world.location_by_coords(world.player.cur_coords)
          world.describe(player_cur_location)
        when 'dmg'
          result = world.player.take_damage(result[:data])

          if result.eql?('death')
            player_death_resurrection
          end
        when 'rest', 'health'
          world.player.heal_damage(result[:data])
          return
        when 'xp'
          world.player.update_stats(reason: :xp, value: result[:data])
          return
        when 'tent'
          world.player.rest(world, result[:data])
        when 'action'
          case result[:data]
          when 'map'
            world.print_map(world.player.cur_coords[:z])
          end
        when 'arena'
          arena = Arena.new(world: world, player: world.player)
          result = arena.start

          if result.eql?('death')
            player_death_resurrection
          end
        when 'item'
          player_cur_location.add_item(result[:data])
          return
        when 'purchase'
          result[:data].each do |i|
            world.player.inventory.items.push(i)
          end
          return
        else
          return
        end
      end
    end
  when 'drop', 'd'
    if param1.nil?
      ERROR_DROP_PARAM_MISSING
    else
      world.player.inventory.drop_item(param1, player_cur_location)
    end
  when 'equip', 'eq'
    if param1.nil?
      ERROR_EQUIP_PARAM_MISSING
    else
      world.player.inventory.equip_item(param1)
    end
  when 'unequip', 'ue'
    if param1.nil?
      ERROR_UNEQUIP_PARAM_MISSING
    else
      world.player.inventory.unequip_item(param1)
    end
  when 'go', 'g'
    if param1.nil?
      puts ERROR_GO_PARAM_MISSING
      GO_PARAMS
    else
      direction = param1
      try_to_move_player(direction)
    end
  when 'n'
    if param1
      ERROR_DIRECTION_PARAM_INVALID
    else
      try_to_move_player('north')
    end
  when 'e'
    if param1
      ERROR_DIRECTION_PARAM_INVALID
    else
      try_to_move_player('east')
    end
  when 's'
    if param1
      ERROR_DIRECTION_PARAM_INVALID
    else
      try_to_move_player('south')
    end
  when 'w'
    if param1
      ERROR_DIRECTION_PARAM_INVALID
    else
      try_to_move_player('west')
    end
  when 'attack', 'a', 'fight', 'f'
    if param1.nil?
      if GameOptions.data['fight_completion']
        if player_cur_location.has_any_monsters?
          monster_param = player_cur_location.monsters_abounding[0].name
          self.parse("attack #{monster_param}")
        else
          ERROR_ATTACK_PARAM_INVALID
        end
      else
        ERROR_ATTACK_PARAM_MISSING
      end
    else
      monster_name = param1
      if world.has_monster_to_attack?(monster_name)
        monster = player_cur_location.monster_by_name(monster_name)
        result = world.player.attack(world, monster, param2)

        if result.eql?('death')
          return player_death_resurrection
        elsif result.eql?('exit')
          return 'exit'
        end

        unless result.nil?
          case result[:type]
          when 'message'
            result[:data]
          when 'move'
            world.player.cur_coords = world.location_coords_by_name(result[:data])
            player_cur_location = world.location_by_coords(world.player.cur_coords)
            world.describe(player_cur_location)
          end
        end
      else
        ERROR_ATTACK_PARAM_INVALID
      end
    end
  when 'breakthru', 'br'
    if world.player.special_abilities.include?(:breakthru)
      if param1.nil?
        return ERROR_BREAKTHRU_PARAM_MISSING
      else
        place_to_match = tokens[1..tokens.length].join(' ').downcase
        locations = []
        world.locations.each do |l|
          locations << l.name.downcase
        end
        if locations.include?(place_to_match)
          world.player.cur_coords = world.location_coords_by_name(place_to_match)
        else
          return ERROR_BREAKTHRU_PARAM_INVALID
        end
      end

      # stats
      world.player.movements_made += 1

      Animation.run(phrase: '** BREAK THROUGH! **')
      player_cur_location = world.location_by_coords(world.player.cur_coords)
      return world.describe(player_cur_location)
    else
      ERROR_BREAKTHRU_INEXPERIENCED
    end
  when 'change', 'ch'
    if param1.nil?
      puts ERROR_CHANGE_PARAM_MISSING
      CHANGE_PARAMS
    else
      case param1
      when 'name'
        world.player.modify_name
      else
        ERROR_CHANGE_PARAM_INVALID
      end
    end
  when 'help', 'h', '?', '??', '???'
    list_commands
  when 'version', 'v'
    Gemwarrior::VERSION
  when 'checkupdate', 'cu'
    'checkupdate'
  when 'quit', 'exit', 'q', 'x'
    print 'You sure you want to quit? (y/n) '
    answer = gets.chomp.downcase

    case answer
    when 'y', 'yes'
      puts QUIT_MESSAGE.colorize(:yellow)
      return 'exit'
    else
      puts RESUME_MESSAGE.colorize(:green)
    end
  when 'quit!', 'exit!', 'qq', 'xx'
    puts QUIT_MESSAGE.colorize(:yellow)
    return 'exit'
  else
    return
  end
end

Private Instance Methods

input_valid?(input) click to toggle source
# File lib/gemwarrior/evaluator.rb, line 818
def input_valid?(input)
  tokens = input.split
  command = tokens[0]
  commands_and_aliases = commands | aliases | extras

  if GameOptions.data['debug_mode']
    commands_and_aliases = commands_and_aliases | devcommands | devaliases | devextras
  end

  if commands_and_aliases.include?(command.downcase)
    if tokens.size.between?(1, 4)
      return true
    end
  elsif tokens.empty?
    return true
  end
end
list_commands() click to toggle source
# File lib/gemwarrior/evaluator.rb, line 795
def list_commands
  i = 0
  Hr.print('=')
  puts ' COMMAND     | ALIAS | DESCRIPTION '
  Hr.print('=')
  commands.each do |cmd|
    puts " #{cmd.ljust(11)} | #{aliases[i].ljust(5)} | #{cmd_descriptions[i]}"
    i += 1
  end
  Hr.print('=')

  if GameOptions.data['debug_mode']
    puts ' DEBUG COMMANDS'
    Hr.print('=')
    i = 0
    devcommands.each do |cmd|
      puts " #{cmd.ljust(11)} | #{devaliases[i].ljust(5)} | #{devcmd_descriptions[i]}"
      i += 1
    end
    Hr.print('=')
  end
end
player_death_resurrection() click to toggle source
# File lib/gemwarrior/evaluator.rb, line 775
def player_death_resurrection
  Audio.play_synth(:player_resurrection)

  puts 'Somehow, though, your adventure does not end here!'.colorize(:yellow)
  puts 'Instead, you are whisked back home via some magical force.'.colorize(:yellow)
  puts 'A bit worse for the weary and somewhat poorer, but you are ALIVE!'.colorize(:yellow)
  puts

  world.player.hp_cur = 1
  world.player.rox -= (world.player.rox * 0.1).to_i
  if world.player.rox < 0
    world.player.rox = 0
  end
  world.player.cur_coords = world.location_coords_by_name('Home')
  player_cur_location = world.location_by_coords(world.player.cur_coords)
  world.describe(player_cur_location)
  world.player.deaths += 1
  return
end
try_to_move_player(direction) click to toggle source
# File lib/gemwarrior/evaluator.rb, line 750
def try_to_move_player(direction)
  if world.can_move?(direction)
    world.player.go(world, direction)
    player_cur_location = world.location_by_coords(world.player.cur_coords)
    player_cur_location.checked_for_monsters = false

    if player_cur_location.name.include?('pain_quarry')
      if player_cur_location.has_boss?('garynetty')
        roll = rand(0..100) + world.player.dexterity
        roll_display = roll < 25 ? "#{roll}".colorize(:red) : "#{roll}".colorize(:green)
        puts "[Pain Quarry Garynetty Roll: #{roll_display}]" if GameOptions.data['debug_mode']
        if roll < 25
          self.parse("attack garynetty is_ambush")
        else
          puts 'You nearly got attacked by a vicious Garynetty! Be careful, your next move might not be as lucky.'.colorize(:yellow)
        end
      end
    end

    world.describe(player_cur_location)
  else
    return ERROR_GO_PARAM_INVALID.colorize(:red)
  end
end