rpg-prompt 1.1

data/lib/rpg-prompt/message.rb

@@ -0,0 +1,294 @@
+module Message
+  class Language
+    @@language = nil
+
+    def initialize(valid_languages)
+      @@Valid_Languages = valid_languages.clone
+      if @@language.nil?
+        @@language = @@Valid_Languages[0]
+      end
+    end
+  end
+
+  class Dictionary < Language
+    @@language = nil
+
+    def initialize(valid_languages)
+      @dict_hash = Hash.new("no lang")
+      super(valid_languages)
+      @@Valid_Languages.each do |l|
+        @dict_hash[l] = Hash.new("no word")
+      end
+    end
+
+    def self.language=(l)
+      unless @@Valid_Languages.nil?
+        if @@Valid_Languages.include?(l)
+          @@language = l
+          Questionnaire.set_option(l, Questionnaire.type)
+        end
+      end
+    end
+
+    def add_word(s, w)
+      @dict_hash[@@language][s] = w
+    end
+
+    def word(s)
+      @dict_hash[@@language][s]
+    end
+
+    def symbol(w)
+      @dict_hash[@@language].key(w)
+    end
+  end
+  
+  valid_languages = [:english, :spanish]
+
+  @@message_dict = Message::Dictionary.new(valid_languages)
+  @@help_dict = Message::Dictionary.new(valid_languages)
+  @@weapon_dict = Message::Dictionary.new(valid_languages)
+  @@armor_dict = Message::Dictionary.new(valid_languages)
+  @@skill_dict = Message::Dictionary.new(valid_languages)
+  @@skill_help_hash = Message::Dictionary.new(valid_languages)
+
+  class Option < Language
+    @@option = nil
+    @@valid_options = nil
+
+    def initialize(valid_languages, valid_types)
+      super(valid_languages)
+      @@Valid_Types = valid_types.clone
+      if @@valid_options.nil?
+        @@valid_options = Array.new
+      end
+      @@Valid_Languages.each do |l|
+        @@Valid_Types.each do |t|
+          @@valid_options.push([l, t])
+        end
+      end
+      if @@option.nil?
+        @@option = @@valid_options[0]
+      end
+    end
+  end
+
+  class Questionnaire < Option
+    def initialize(valid_languages, valid_types)
+      @dict_hash = Hash.new("no lang")
+      super(valid_languages, valid_types)
+      @@valid_options.each do |l|
+        @dict_hash[l] = Hash.new("no word")
+      end
+    end
+
+    def self.set_option(l, t)
+      unless @@valid_options.nil?
+        if @@valid_options.include?([l,t])
+          @@option = [l, t]
+          @@language = l
+        end
+      end
+    end
+
+    def self.set_type(t)
+      unless @@valid_options.nil?
+        if @@valid_options.include?([@@language,t])
+          @@option = [@@language, t]
+        end
+      end
+    end
+
+    def add_word(s, w)
+      @dict_hash[@@option][s] = w
+    end
+
+    def word(s)
+      @dict_hash[@@option][s]
+    end
+
+    def self.type
+      unless @@option.nil?
+        @@option[1]
+      else
+        nil
+      end
+    end
+  end
+
+  valid_languages = [:english, :spanish]
+  valid_types = [:character, :foe, :spawn]
+
+  @@questionnaire_dict = Message::Questionnaire.new(valid_languages, valid_types)
+  @@load_prompt_dict = Message::Questionnaire.new(valid_languages, valid_types)
+
+# *****************  message_dict  ***************** #  
+  def self.add_message(s, m)
+    @@message_dict.add_word(s, m)
+  end
+  
+  def self.message(s)
+    puts @@message_dict.word(s)
+  end
+
+# *****************  help_dict  ***************** #
+  def self.add_help(s, h)
+    @@help_dict.add_word(s, h)
+  end
+  
+  def self.help(s, arg)
+    puts @@help_dict.word(s) % arg
+  end
+
+  def self.help_string(s, arg)
+    @@help_dict.word(s) % arg
+  end
+
+  def self.print_help
+    data_dir = Gem.datadir("rpg-prompt")
+    data_dir = data_dir ? data_dir : ""
+    @@Help_file_name = data_dir + "/help.txt"
+    puts open(@@Help_file_name).read
+  end
+  
+  def self.print_example
+    data_dir = Gem.datadir("rpg-prompt")
+    data_dir = data_dir ? data_dir : ""
+    @@Example_file_name = data_dir + "/example.txt"
+    puts open(@@Example_file_name).read
+  end
+
+# *****************  weapon_dict  ***************** #  
+  def self.add_weapon(s, w)
+    @@weapon_dict.add_word(s, w)
+  end
+
+  def self.weapon_word(s)
+    @@weapon_dict.word(s)
+  end
+
+  def self.weapon_symbol(w)
+    @@weapon_dict.symbol(w)
+  end
+
+# *****************  armor_dict  ***************** #  
+  def self.add_armor(s, w)
+    @@armor_dict.add_word(s, w)
+  end
+
+  def self.armor_word(s)
+    @@armor_dict.word(s)
+  end
+
+  def self.armor_symbol(w)
+    @@armor_dict.symbol(w)
+  end
+
+# *****************  skill_dict  ***************** #
+  def self.add_skill(s, w)
+    @@skill_dict.add_word(s, w)
+  end
+
+  def self.skill_word(s)
+    @@skill_dict.word(s)
+  end
+
+  def self.skill_symbol(w)
+    @@skill_dict.symbol(w)
+  end
+
+  def self.skill_help(s)
+    @@skill_help_hash.word(s)
+  end
+
+# *****************  questionnaire_dict  ***************** #
+  def self.add_question(s, q)
+    @@questionnaire_dict.add_word(s, w)
+  end
+
+  def self.question(s)
+    puts @@questionnaire_dict.word(s)
+  end
+
+  def self.question_symbol(w)
+    @@questionnaire_dict.symbol(w)
+  end
+
+# *****************  load_prompt_dict  ***************** #
+  def self.add_load_prompt(s, q)
+    @@load_prompt_dict.add_word(s, w)
+  end
+
+  def self.load_prompt(s, arg)
+    puts @@load_prompt_dict.word(s) % arg
+  end
+
+# *****************  lists  ***************** #
+  def self.puts_weapons_list(weapons_available)
+    s = ""
+    (0...weapons_available.length).each do |i|
+      s += Message.weapon_word(weapons_available[i]) + " / "
+      if (((i+1)%5) == 0) || (i == (weapons_available.length-1))
+        puts s
+        s = ""
+      end
+    end
+  end
+
+  def self.puts_armors_list(armors_available)
+    s = ""
+    (0...armors_available.length).each do |i|
+      s += Message.armor_word(armors_available[i]) + " / "
+    end
+    puts s
+  end
+
+# *****************  status and readable  ***************** #
+  def self.pool_status(pool)
+    pool.each do |name, sheet|
+      if not(sheet.spawned?)
+        if sheet[:type] != :spawn
+          Message.help(:warrior_in_one_line, sheet)
+        else
+          Message.help(:spawn_in_one_line, sheet)
+        end
+      end
+    end
+  end
+
+  def self.combat_status(combat, pool)
+    combat.each do |name, ep|
+      sheet = pool[name]
+      Message.short_readable(sheet)
+    end
+  end
+
+  def self.combat_status_verbose(combat, pool)
+    combat.each do |name, ep|
+      sheet = pool[name]
+      if (sheet.unique?) || (sheet.spawned?)
+        Message.help(:full_name, sheet)
+        Message.readable(sheet)
+      end
+    end
+  end
+
+  def self.short_readable(sheet)
+    puts Message.help_string(:warrior_in_one_line_hp, sheet)
+  end
+
+  def self.readable(sheet)
+    s = sheet.to_s
+    s = s.gsub(", ","\n")
+    s = s.gsub("=>\"","=>")
+    s = s.gsub("=>","=> ")
+    s = s.gsub("\""," ")
+    s = s.gsub("{","")
+    s = s.gsub("}","")
+    puts s + "\n\n"
+  end
+
+  def self.load_language(lang)
+    file_name = ".#{lang}.csv"
+  end
+end

data/lib/rpg-prompt/parse_line.rb

@@ -0,0 +1,123 @@
+# require "rpg-prompt/manage_command.rb"   # required at the en of the file
+# require "rpg-prompt/commands.rb"         # required at the en of the file
+
+module ParseLine
+  class Line
+    @@line_regexp_hash = nil
+    @help = false
+
+    def self.line_regexp_hash
+      @@line_regexp_hash
+    end
+
+    def remove_extra_separators
+      ret_line = @line.clone
+      ret_line = ret_line.gsub(/\s+/, " ")
+      ret_line = ret_line.gsub(/^\s*/, "")
+      ret_line = ret_line.gsub(/\s*$/, "")
+      ret_line = ret_line.gsub(/,/, "")
+      @line = ret_line.clone
+    end
+
+    def initialize(line)
+      if @@line_regexp_hash.nil?
+        @@line_regexp_hash = Hash.new([/^$/,/^$/])
+      end
+      @line = line
+    end
+
+    def Line.add_command(symbol, command, options)
+      if @@line_regexp_hash.nil?
+        @@line_regexp_hash = Hash.new([/^$/,[]])
+      end
+      unless (symbol.class != Symbol) || (command.class != Regexp)
+        o = "(?<options> [-"
+        r = []
+        options.each do |t|
+          o += t
+          r.push(Regexp.new("^" + t + "$"))
+        end
+        o += "]+)?"
+        c = Regexp.new("^" + command.source + o + "$")
+        @@line_regexp_hash[symbol] = [c, r]
+      end
+    end
+    
+    def parse
+      c = ManageCommand::Command.new(:unkown_command, Hash.new, Hash.new)
+
+      self.remove_extra_separators
+      @@line_regexp_hash.each do |symbol, regex_constant|
+        command_regex = regex_constant[0]
+        options_array = regex_constant[1]
+
+        if (@line.match(command_regex))
+          line_array = @line.gsub(":", " : ").gsub("  "," ").split(" ")
+          options = @line.match(command_regex)[:options]
+          
+          unless options.nil?
+            is_known, options =  process_line_options(options, options_array)
+            if is_known == :known_options
+              line_array.pop
+              c = ManageCommand::Command.new(symbol, line_array, options)
+            elsif is_known == :unknown_options
+              line_array.pop
+              c = ManageCommand::Command.new(symbol, line_array, Hash.new())
+            elsif is_known == :no_options
+              c = ManageCommand::Command.new(symbol, line_array, Hash.new())
+            end
+          else
+            c = ManageCommand::Command.new(symbol, line_array, Hash.new())
+          end
+        elsif @line.length == 0
+          c = ManageCommand::Command.new(:empty, Hash.new, Hash.new)
+        end
+      end
+
+      c
+    end
+
+    def process_line_options(options, regex)
+      # there are options
+      if (options.length > 1) && (options[1] == '-')
+        l = options.length-1
+        o = Array.new
+        (0..l).each do |i|
+          unless options[i].match(/^[- ]$/)
+            o.push(options[i])
+          end
+        end
+
+        valid_options = Hash.new(false)  # default, all are invalid
+        o.each do |opt|
+          regex.each do |reg|
+            if opt.match(reg)
+              valid_options[opt] = true  #only if they are valid
+            end
+          end
+        end
+
+        valid = (valid_options.length >= 1)  #tentatively
+        o.each do |opt|
+          # Only if all are valid, options are in fact known
+          valid &&= valid_options[opt]
+        end
+
+        if valid
+          return :known_options, o
+        else
+          # this should never occur, if the Regexp are well written
+          return :unknown_options, Hash.new
+        end
+
+      # there are no options
+      else
+        return :no_options, Hash.new
+      end
+
+    end
+  end
+end
+
+require "rpg-prompt/manage_command.rb"
+require "rpg-prompt/commands.rb"

data/lib/rpg-prompt/rules_default.rb

@@ -0,0 +1,226 @@
+require "rpg-prompt/rules_default_hashes.rb"
+require "rpg-prompt/message.rb"
+require "rpg-prompt/texts_default.rb"
+require "rpg-prompt/keypress.rb"
+
+ParseLine::Line.add_command(:hits,
+  /(?<atk>\w+) hits (?<def>\w+)/, ["c", "f", "r", "h", "s", "u", "d"])
+ParseLine::Line.add_command(:hits_short,
+  /(?<atk>\w+) h (?<def>\w+)/, ["c", "f", "r", "h", "s", "u", "d"])
+
+ParseLine::Line.add_command(:skill,
+  /skill (?<ch>\w+) (?<skill>\w+)( [+-]\d+)?/,
+  ["c", "r", "e", "l", "m", "h", "v", "e", "s", "a", "c", "u", "i", "d", "p"])
+ParseLine::Line.add_command(:skill_short,
+  /(?<ch>\w+)( )?:( )?(?<skill>\w+)( [+-]\d+)?/,
+  ["c", "r", "e", "l", "m", "h", "v", "e", "s", "a", "c", "u", "i", "d", "p"])
+
+module Rules
+  module Dice
+    def self.roll(type_of_roll)
+      case type_of_roll
+      when :d6
+        1+rand(6)
+      when :d10
+        1+rand(10)
+      end
+    end
+
+    def self.prompt_roll(type_of_roll)
+      case type_of_roll
+      when :d6
+        roll_prompt = :ask_for_d6
+        roll_limit = 6
+      else
+        roll_prompt = :ask_for_d10
+        roll_limit = 10
+      end
+      roll = 0
+      Message.message(:preset_roll_prompt)
+      case Keypress.read_char
+      when "r"
+        Message.message(roll_prompt)
+        loop do
+          roll = $stdin.gets.to_i
+          if (roll > roll_limit) || (roll <= 0)
+            Message.message(:bad_range)
+            redo
+          else
+            Message.help(:rolling, {roll: roll})
+          end
+          break
+        end
+      else
+        roll = Dice.roll(type_of_roll)
+        Message.help(:rolling, {roll: roll})
+      end
+      roll
+    end
+  end
+
+  class Turn
+    def resolve
+    end
+  end
+
+  class AttackTurn
+    @no_damage = nil
+    @modifier = nil
+
+    def initialize(attacker_sheet, defender_sheet)
+      @attacker_sheet = attacker_sheet
+      @defender_sheet = defender_sheet
+      @weapon = Weapon.new(@attacker_sheet)
+      @armor = Armor.new(@defender_sheet)
+      if @no_damage == nil
+        @no_damage = false
+        @modifier = 0
+      end
+    end
+
+    def process_options(options)
+      @no_damage = false
+      @modifier = 0
+      distance = 0
+      options.each do |option|
+        c = option[0]
+        option[0] = ' '
+        case c
+        when 'c' #check
+          @no_damage = true
+        when 'f' #flank
+          @modifier += 1
+        when 'b' #back
+          @modifier += 2
+        when 'h' #higher ground
+          @modifier += 1
+        when 's' #surprise
+          @modifier += 2
+        when 'u' #unsheathing
+          @modifier -= -1
+        when 'd' #distance
+          distance += 1
+        end
+      end
+      if (distance > 0) && (distance < @weapon.weapon[:distance_mod].length)
+        @modifier += @weapon.weapon[:distance_mod][distance][1]
+      elsif (distance > 0) && (distance >= @weapon.weapon[:distance_mod].length)
+        @no_damage = true
+      end
+      return @no_damage, @modifier
+    end
+
+    def resolve
+      roll = Dice.prompt_roll(:d10)
+      mod_roll = roll + @modifier
+      
+      damage = @weapon.damage_roll(@armor, mod_roll)
+
+      unless @no_damage then @defender_sheet.reduce_health(damage) end
+      
+      if damage > 0
+        Message.help(:hits_lose_hp,
+          {full_name: @defender_sheet.full_name, damage: damage})
+      end
+    end
+  end
+
+  class ActionTurn < Turn
+    @@skill_hash = nil
+    @skill_sym = nil
+
+    def initialize(sheet, skill)
+      @sheet = sheet
+      unless @skill_sym
+        @skill_sym = Message.skill_symbol(skill)
+        @@skill_hash = RulesHashes::SkillHash.new
+      end
+      @skill_bonus = @sheet[@skill_sym] ? @sheet[@skill_sym] : 0
+    end
+
+    def self.skill?(skill)
+      unless @skill_sym
+        @skill_sym = Message.skill_symbol(skill)
+        @@skill_hash = RulesHashes::SkillHash.new
+      end
+      @@skill_hash.key?(@skill_sym)
+    end
+
+  
+    def process_options(options, command_mod)
+      @modifier = command_mod
+      @no_action = false
+      options.each do |option|
+        c = option[0]
+        option[0] = ' '
+        case c
+        when 'c' #check
+          @no_action = true
+        when 'e' #easy
+          @modifier += 3
+        when 'm' #medium
+          @modifier += 0
+        when 'h' #hard
+          @modifier -= 3
+        end
+      end
+      @modifier += @skill_bonus
+      return @no_action, @modifier
+    end
+
+    def truncate_val(v)
+      v = (v > 500) ? 500 : v
+      v = (v < -500) ? -500 : v
+    end
+
+    def action_table_result(roll)
+      r = truncate_val(roll)
+      @@action_table = RulesHashes::ActionTable.new
+      action_result = :failure
+      @@action_table.each do |ar, l|
+        if (r >= l[0]) && (r < l[1])
+          action_result = ar
+        end
+      end
+      action_result
+    end
+
+    def mod_roll(roll)
+      r = roll + @modifier
+      Message.help(:skill_roll, {r: r, roll: roll, modifier: @modifier})
+      r
+    end
+
+    def resolve
+      roll = Dice.prompt_roll(:d10)
+      action_result = action_table_result(mod_roll(roll))
+      Message.skill_word(action_result)
+    end
+  end
+
+  class Weapon
+    attr_accessor :weapon
+
+    def initialize(sheet)
+      @@weapon_hash = RulesHashes::WeaponHash.new()
+      @weapon = @@weapon_hash[sheet[:weapon]]
+    end
+
+    def damage_roll(armor, mod_roll)
+      if (mod_roll >= armor[:armor])
+        Message.message(:hits_success)
+        Dice.prompt_roll(:d6)
+      else
+        Message.message(:hits_fail)
+        0
+      end
+    end
+  end
+
+  class Armor < Hash
+    def initialize(sheet)
+      @@weapon_hash = RulesHashes::ArmorHash.new()
+      self[:armor] = @@weapon_hash[sheet[:armor]]
+    end
+  end
+end