rpg-prompt 1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2cb37842ec6500eb1e3fc62a13d0b8bf942ed8c71ad97d7d8d9753a692cbb827
+  data.tar.gz: 3fdf422337ad6a336e8a05a9cce2e9062a16872a62b1b75c22045e6f2dbdaf01
+SHA512:
+  metadata.gz: c0426b1466fde458ab9ae4a3b07b79d5fc0fd1fd541eade5e3871c2fad81727be045d396fedbc06f14e59770586e2d9eb2ca591d1ca4762e41455d1f6d34be8b
+  data.tar.gz: 98528b0029f2bd9600b3925468a7b848b5f0ef137e52d47c4f892921a531abb985e4c8ae8ac2afc8acb8456c50095cb1e7b0a9ef519918f96788b46d90d329da

data/bin/rpg-prompt

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require "rpg-prompt/parse_line.rb"
+
+# Settings_file_name = "./rpg-prompt.settings" # defined in manage_command.m
+# default value
+$language = "english"
+
+if File.exists?(Settings_file_name)
+  File.readlines(Settings_file_name).each do |line|
+    m = line.match(/(?<setting>\w*): (?<val>\w*)/)
+    if m == nil
+      break
+    else
+      case m[:setting]
+      when "language"
+        $language = m[:val]
+      end
+    end
+  end
+end
+
+Message::Dictionary.language = $language.to_sym
+
+Message.message(:greeting)
+
+Backup_file_name = "./.backup.marshal"
+
+if File.exist?(Backup_file_name)
+  line = ParseLine::Line.new("rrr")
+  command_symbol = line.parse.command
+end
+
+loop do
+  print (">>>")
+  line = ParseLine::Line.new($stdin.gets.chomp)
+  command_symbol = line.parse.command
+  puts
+  if command_symbol == :quit
+    break
+  end
+end
+
+Save.delete_pool
+Message.message(:goodbye)
+

data/data/rpg-prompt/example.txt

@@ -0,0 +1,190 @@
+|
+|  Example of use the RPG Combat Assistant, by Guillermo Regodón.
+|  
+|  First, we should create a character for each player. For example:
+|  
+|  >>>cc billy
+|  
+|  to create a Character for player billy. Answer the questionnaire. Each character
+|  has a {short_name} to handle it, billy in this case. Then it has a full name, an
+|  optional nickname, a race, health points, a weapon, an armor, and a movement
+|  capacity. In these simple rules, the race, the weapon and the movement capacity
+|  have no effect in the game. Let us say that we create Billy the warrior, a human
+|  who uses a broad sword and plate armor.
+|  
+|  Full name => Billy
+|  Nickname => the warrior
+|  Race => Human
+|  Health Points => 10
+|  Weapon => broad sword
+|  Armor => plate
+|  Movement Capacity => 10
+|  
+|  Then we create an enemy, Azog the white goblin, an orc who uses a mace and hardened
+|  leather armor. He has 8 health points and a movement capacity 10.
+|  
+|  >>>cf azog
+|  
+|  In the pool we have 2 warriors so far.
+|  
+|  >>>pool
+|  billy: Billy the Warrior
+|  azog: Azog the white goblin
+|  
+|  You may just type "p" instead of "pool". Similarly you could have typed "createchar"
+|  and "createfoe" instead of "cc" and "cf". Let the warriors join the combat. type
+|  "save w billy" ("sw billy") and "save w azog" ("sw azog") to save them in files.
+|  
+|  >>>join billy
+|  >>>join azog
+|  >>>combatstatus
+|  billy: Billy the Warrior: 10 hp
+|  azog: Azog the white goblin: 8 hp
+|  
+|  Or just "s" to get the status of the combat, with the health points prompted. Then
+|  combat starts with an attack from Billy the Warrior to Azog the white goblin.
+|  
+|  >>>billy hits azog
+|  ¡Billy the Warrior attacks Azog the white goblin!
+|  Press 'r' to enter a roll or any other key for a random roll.
+|  
+|  You may enter the roll if you prefer to roll real dice instead of getting random
+|  numbers from an unknown algorithm. Let us trust the random number generator to be
+|  a fair judge of the warriors destiny.
+|  
+|  >>>billy hits azog
+|  ¡Billy the Warrior attacks Azog the white goblin!
+|  Press 'r' to enter a roll or any other key for a random roll.
+|  Dice rolling... ¡5!
+|  The attack succeeds!
+|  Press 'r' to enter a roll or any other key for a random roll.
+|  
+|  The attack succeeding, a new roll is needed to get the damage.
+|  
+|  >>>billy hits azog
+|  ¡Billy the Warrior attacks Azog the white goblin!
+|  Press 'r' to enter a roll or any other key for a random roll.
+|  Dice rolling... ¡5!
+|  The attack succeeds!
+|  Press 'r' to enter a roll or any other key for a random roll.
+|  Dice rolling... ¡2!
+|  ¡Azog the white goblin loses 2 hp!
+|  
+|  A call to "combatstatus" prompts
+|  
+|  >>>s
+|  billy: Billy the Warrior: 10 hp
+|  azog: Azog the white goblin: 6 hp
+|  
+|  Let the cries of pain from azog attract his hench-orcs. We have to create them
+|  before. As a generic type of enemy, it has to be created as a Spawn template.
+|  The difference is that it may have many possible names and nicknames.
+|  
+|  >>>createspawn orc
+|  Enter names for this kind of enemy, recomended 10 or more,
+|    "q" to finish. Enter only the race if it is an enemy without name.
+|  Ulag
+|  Urglu
+|  Shagrath
+|  Gorbagh
+|  Karg
+|  Zulburg
+|  Groggash
+|  Skumzag
+|  Agash
+|  Zudak
+|  q
+|  Enter nicknames for this kind of enemy, recomended 10 or more,
+|    "q" to finish.
+|  the Smelly
+|  the Dumb
+|  the Cruel
+|  the Elfslayer
+|  the Destroyer
+|  the Crazy Lamb
+|  the Poisson Razer
+|  the Gross
+|  the Fearless
+|  the Hunchback
+|  q
+|  
+|  "cs orc" could have been used. They are Orcs, have 5 health points, use
+|  scimitars and hardened leather, and they may move up to 10 meters per assault.
+|  They join the combat by typing
+|  
+|  >>>spawn orc x3
+|  Spawning enemies: 3 of type orc
+|  
+|  >>>s
+|  billy: Billy the Warrior: 10 hp
+|  azog: Azog the white goblin: 6 hp
+|  orc1: Karg the Hunchback: 5 hp
+|  orc2: Skumzag the Cruel: 5 hp
+|  orc3: Zulburg the Poisson Razer: 5 hp
+|  
+|  They may bring wolfs as well, the only difference is that they would not have
+|  names, and we woould type "Wolf" for the full name. They may have nicknames,
+|  like "alfa", "old", "defiant" or "black". Billy is in trouble, which was
+|  expected when he was entering an orc cave alone, he should have brought allies,
+|  like Edana the shadow queen. The warriors leave the combat when they die, or when
+|  "leave billy" is typed.
+|  
+|  For the next game we could prepare scenes. Let us prepare an orc_hall and a
+|  wolf_cave. Type "lw" to list the available warriors in saved files, and
+|  "free all" to start a pool and a combat from scratch.
+|  
+|  >>>free all
+|  >>>lw
+|  wolf
+|  billy
+|  orc
+|  edana
+|  azog
+|  
+|  Let us create the "orc_hall" scene.
+|  
+|  >>>lw azog
+|  >>>lw orc
+|  
+|  >>>join azog
+|  >>>spawn orc x3
+|  
+|  >>>s
+|  azog: Azog the white goblin: 10 hp
+|  orc1: Agash the Gross: 5 hp
+|  orc2: Ulag the Cruel: 5 hp
+|  orc3: Gorbagh the Smelly: 5 hp
+|  
+|  >>>save s orc_hall
+|  Saving...
+|  Scene saved.
+|  
+|  Similarly, the "wolf_cave" scene.
+|  
+|  >>>spawn wolf x5
+|  Spawning enemies: 5 of type wolf
+|  
+|  >>>s
+|  wolf1: Wolf old: 6 hp
+|  wolf2: Wolf beta: 6 hp
+|  wolf3: Wolf grey: 6 hp
+|  wolf4: Wolf alfa: 6 hp
+|  wolf5: Wolf scarred: 6 hp
+|  
+|  >>>ss wolf_cave
+|  Saving...
+|  Scene saved.
+|  
+|  We have use "ss" as a short version of "save s". Let us list the save scenes
+|  
+|  >>>ls
+|  orc_hall
+|  wolf_cave
+|  
+|  The command "load s orc_hall" or "ls orc_hall" loads azog and the orc
+|  template into the pool, and Azog the white goblin, Agash the Gross, Ulag
+|  the Cruel and Gorbagh the Smelly into the combat.
+|  
+|  You make quit and save the temporal pool and combat using "quit -s" or
+|  dismiss them with "quit -q".
+|  

data/data/rpg-prompt/help.txt

@@ -0,0 +1,108 @@
+Welcome to the RPG Combat Assistant, by Guillermo Regodón
+
+With this Ruby Gem, you can handle complex RPG systems automatically, by means of 
+a set of options that can be passed in a prompt. I have included a simple set of
+rules of my own creation, but you may use this gem to program in Ruby your own
+rules or a set of commercial rules for your personal use. I have not included any
+set of commercial rules for copyright issues, even when I have programmed some for
+my pesonal use.
+
+Install the Gem, create your directory and type "rpg-prompt" to start. To start
+your personal set of rules, type "clone rules {new_rules_system}" indicating the
+name of your set of rules. after quitting "rpg-prompt" you will see the edittable
+files that code the new set of rules. Code them in Ruby, and start using them in
+your games.
+
+There are three types of warriors:
+   - Characters, which will be handled by players
+   - Foes, which are enemies of the players
+   - Spawns, generic enemies of which several with the same attributes may appears
+
+The warrios can be in the pool, meaning that they have been loaded but are not in
+combat. Type "pool" or "p" to print the pool. Spawns in the pool are templates.
+
+The warriors can be in combat, after being loaded. Type "combatstatus" or "s" to
+print the combat. Health points will be printed as well. Spawns in combat are
+copies of the template.
+
+Warriors can be loaded, saved and created
+   - To create a warrior, type "createchar" ("cc"), "createfoe" ("cf") or
+     "createspawn" ("cs") followed by the short name (no spaces) that you
+     will use to handle the warrior. A questionnaire will be prompt asking
+     for the values to fill the character sheet.
+     Spawns are special, they will have many names and full names, so that
+     when they are spawned into combat, random combinations will be used
+   - To save a warrior, type "save w {short_name}" or "sw {short_name}"
+   - To list the saved warriors, type "lw"
+   - To load a warrior, type "load w {short_name}" or "lw {short_name}"
+   - You may delete the file or delete from the prompt, using
+     "delete w {short_name}" or "dw {short_name}"
+
+Characters and Foes can be joined to the combat using "join {short_name}".
+Spawns have to be spawned into combat using "spawn {short_name} xN". N Spawns
+using the template will be spawned into combat. From this point, each spawn is
+a separate enemy named with the short name followed by a number (check using
+"combatstatus" or "s").
+
+Warriors leave the combat as they die, but they can also be removed:
+   - "leave {short_name}" for a warrior to leave the combat.
+   - "free {short_name}" to remove a warrior or a template from the pool
+   - "free all" to clean both the Combat and the pool
+
+Scenes are combinations of warriors to be saved and loaded at once. This allows
+you to prepare a scene and load it when the players enter a cetain place or trigger
+a certain event in your game.
+   - To save a scene, type "save s {scene_name}" or "ss {scene_name}"
+   - To list the saved scenes, type "ls"
+   - To load a scene, type "load s {scene_name}" or "ls {scene_name}"
+   - You may delete the file or delete from the prompt, using
+     "delete s {scene_name}" or "dw {scene_name}"
+
+You may pass a round using "round" or "round +N". Although, in the simple rules
+provided in this RPG helper, this has no effect.
+
+To perform an attack, use:
+   - "{attacker_short_name} hits {defender_short_name} -options"
+
+The options that are included in these simple rules are:
+   -c: to check the result of the attack but not apply the sometimes nasty
+       consequences. For kind Gamemasters.
+   -f: for a flank attack. It applies a bonus to the attack.
+   -r: for a rear attack. It applies a better bonus to the attack.
+   -h: for am attack from higher ground. It applies a bonus to the attack.
+   -s: for a surprise attack. It applies a bonus to the attack.
+   -u: for an attack while unsheathing the weapon. It applies a malus to
+       the attack.
+   -d: for an attack from a distance. It applies a malus to the attack.
+       Each time it is used, the attack is performed with a lower chance
+       of success.
+
+Options may be applied without consecutive slashes, but the first one is
+required. This may not make sense but for the distance modifier.
+   
+To perform an action, type:
+   - "skill {short_name} {skill_name} +/-mod -options"
+
+The mod modifier is of free use for the Gamemaster to match the special
+circumstances of the scene. Generic options can be applied. In these simple
+rules, the options are:
+   -c: to check the result of the action. Useless in these simple rules.
+   -e: to apply an "easy" bonus.
+   -m: to apply a "medium" bonus. Standard actions uses this modifier by
+       default.
+   -h: to apply a "hard" malus.
+
+To show the help for a certain skill, type "skill_help {skill_name}" or 
+just "sh {skill_name}". Type "skill_list" to show a list of the available
+skills.
+
+Type:
+   - "help" to print this help.
+   - "example" to print an example of use.
+   - "undo" to undo the last attack, in case the consequences are too nasty.
+   - "quit -s" to save and quit. Next time rpg-prompt is called, it will load
+     the status of the Pool and the Combat.
+   - "quit -q" to quit without saving.
+   - "clone rules {new_rules_system}" to clone the basic files to program,
+     in Ruby, a new set of rules.
+

data/data/rpg-prompt/rules_default.rb

@@ -0,0 +1,314 @@
+# default value
+$system = "default"
+
+if File.exists?(Settings_file_name)
+  File.readlines(Settings_file_name).each do |line|
+    m = line.match(/(?<setting>\w*): (?<val>\w*)/)
+    if m == nil
+      break
+    else
+      case m[:setting]
+      when "system"
+        $system = m[:val]
+      end
+    end
+  end
+end
+
+unless $system == "default"
+  $hashes_file_name = "./rules_" + $system + "_hashes.rb"
+  unless (File.exist?($rules_file_name)) && (File.exist?($hashes_file_name)) && (File.exist?($texts_file_name))
+    Message.message(:wrong_config)
+    return -1
+  end
+else
+  $hashes_file_name = "rpg-prompt/rules_default_hashes.rb"
+end
+
+require $hashes_file_name
+
+require "rpg-prompt/message.rb"
+require "rpg-prompt/texts_default.rb"
+require "rpg-prompt/keypress.rb"
+require "rpg-prompt/parse_line.rb"
+
+
+# With these lines, we include the options available for the attacks and the
+# actions. You may also include more commands or more options for these
+# commands. I have included a version of the commands with full words and
+# with abbreviatures. Take special care that no two regular expressions match
+# the same input line!
+
+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", "e", "m", "h"])
+ParseLine::Line.add_command(:skill_short,
+  /(?<ch>\w+)( )?:( )?(?<skill>\w+)( [+-]\d+)?/,
+  ["c", "e", "m", "h"])
+
+
+# Rules module
+module Rules
+
+  # Module to define the possible rolls
+  module Dice
+
+    # The roll itself
+    def self.roll(type_of_roll)
+      case type_of_roll
+      when :d6
+        1+rand(6)
+      when :d10
+        1+rand(10)
+      end
+    end
+
+    # A small prompt to require a roll o perfomr a random roll
+    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
+
+  # Generic type of Turn for a character
+  class Turn
+    def resolve
+    end
+  end
+
+  # Attack turn.
+  # A new AttackTurn object is created for each attack action
+  #    - The initializer receives the attacker and the defender sheets, from
+  #      where it extracts the attacker weapon and defender armor used
+  #    - The process_options method is the key help of this gem. The options
+  #      from your rules system are coded into characters to be used in the 
+  #      prompt after a '-'
+  #    - The resolve method resolves the attack action
+  class AttackTurn
+    @no_damage = nil
+    @modifier = nil
+
+    # Extracts the attacker weapon and defender armor used
+    # Defines the globals to handle the options
+    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
+
+    # Process the options matching a rule with a character to be typed
+    # in the prompt after a slash
+    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 modifiers, no damage is done
+          @no_damage = true
+        when 'f' #flank attack
+          @modifier += 1
+        when 'r' #attack from the rear
+          @modifier += 2
+        when 'h' #higher ground
+          @modifier += 1
+        when 's' #surprise
+          @modifier += 2
+        when 'u' #attack while unsheathing
+          @modifier -= -1
+        when 'd' #distance modifier
+          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
+
+    #helper method for resolve. It prompts the modifier
+    def mod_roll(roll)
+      r = roll + @modifier
+      Message.help(:attack_roll, {r: r, roll: roll, modifier: @modifier})
+      r
+    end
+    
+    # Resolves the attack, with the modifier from process_options
+    def resolve
+      # In these rules, attacks are resolved with  d10
+      roll = Dice.prompt_roll(:d10)
+      mod_roll = mod_roll(roll)
+      
+      # damage may be different for each weapon-armor combination
+      damage = @weapon.damage_roll(@armor, mod_roll)
+
+      # unless check option, reduce defender health points
+      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
+
+  # Action turn
+  # Characters can perform non attack actions, with modifier
+  class ActionTurn < Turn
+    @@skill_hash = nil
+    @skill_sym = nil
+
+    # If the character has a bonus in he skill, it is added to the modifiers
+    # Note that in these simple set of rules, no character ever has a bonus,
+    #  because it was not included in the character creation Questionnaire.
+    # A bonus can be given using the set command.
+    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
+
+    # checks if the skill has been defined in RulesHashes
+    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
+  
+    # In these simple set of rules, only a basic difficulty rule is included
+    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
+
+    # Helper method for action_table_result. It guarantees in range 
+    def truncate_val(v)
+      v = (v > 500) ? 500 : v
+      v = (v < -500) ? -500 : v
+    end
+
+    # Checks for the result in the ActionTable
+    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
+
+    # Helper method for resolve. It prompts the modifier
+    def mod_roll(roll)
+      r = roll + @modifier
+      Message.help(:skill_roll, {r: r, roll: roll, modifier: @modifier})
+      r
+    end
+
+    # Rresolves the action, with the options from process_options
+    def resolve
+      roll = Dice.prompt_roll(:d10)
+      action_result = action_table_result(mod_roll(roll))
+      Message.skill_word(action_result)
+    end
+  end
+
+  # Weapon
+  # Each weapon is responsible of returning the damage that it can make to 
+  # each armor, for a given modified roll. In these simple rules, the damage
+  # is always a d6, if the modified roll surpasses the armor value
+  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
+
+  # Armor
+  # Each armor has to provide enough information to the weapon for it to
+  # calculate the damage. In these simple rules, it returns only a threshold
+  # for each armor type
+  class Armor < Hash
+    def initialize(sheet)
+      @@weapon_hash = RulesHashes::ArmorHash.new()
+      self[:armor] = @@weapon_hash[sheet[:armor]]
+    end
+  end
+end