skirmish 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmI3OGUyNzQyMTE3NDcwOWFhNjFkNDZlZWRkMjkzZDNlMzQ1YWE0Yg==
+  data.tar.gz: !binary |-
+    OTY0NmQzMGNlMzhhMDMyNGVkYzFhMmJiZTdmNmRjYzlkNDljZDBkNA==
+SHA512:
+  metadata.gz: !binary |-
+    NWIwZGY1MTE3ZjNjNmUzOTcwZTM5ZDYxYzFkMmY2ZDhjNmY5NjY5MmY2YjVm
+    YWE5ZmVlNjgyYzhkZmE4YTMzOWJhMmI2ZWVlM2U4ZmU3OTYwNjU2NTM2ODEx
+    NWNkZjRhYjhiM2U1NWYwMmNkYTY2MWI5YTg0MDE5ZTA4Y2VjZTg=
+  data.tar.gz: !binary |-
+    NjY3ZWVlZmM2MjgxZDAzMmU2MDIyNWM4ODAyMWI3Y2QyNzg3NTM2MDVmNWZj
+    MzdhMjU3ZjVlMzQzZDEwMzdhZTIxM2QwMTkxM2Q3NzM1NjZmZjkxYmU0YTY4
+    ZTEzYTYzYjg3Y2QzMWE0Mjg2Yzk3YzJjMDZlODhhODdjYmMzYjE=

data/bin/skirmish

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+# skirmish is a single-player game in the style of CircleMUD.
+# This script runs the game.
+#
+# Author::    Andy Mikula  (mailto:andy@andymikula.ca)
+# Copyright:: Copyright (c) 2016 Andy Mikula
+# License::   MIT
+
+require_relative '../lib/skirmish'
+Skirmish.play

data/lib/skirmish.rb

@@ -0,0 +1,93 @@
+# skirmish is a single-player game in the style of CircleMUD.
+# This file holds the main class and game loop.
+#
+# Author::    Andy Mikula  (mailto:andy@andymikula.ca)
+# Copyright:: Copyright (c) 2016 Andy Mikula
+# License::   MIT
+
+require 'curses'
+require_relative 'skirmish/world'
+require_relative 'skirmish/utilities'
+require_relative 'skirmish/commands'
+require_relative 'skirmish/character'
+
+class Skirmish
+
+  # Set up the world and run the game loop
+  # TODO: Load the player / world state from a save file
+  def self.play
+    $world = World.new "lib/world/30.wld"
+    $player = Player.new
+    $input_buffer = Array.new
+    $command_history = Command_History.new
+
+    # TODO: Generate a number of mobiles that may or may not be a part of the
+    # player's quest. This shouldn't happen explicitly in the play method, but
+    # it does serve to demonstrate the functionality of the 'look' command
+    @mobile = Mobile.new("Bob", 1, 3014, "Bob is a character, just like you!", "bob")
+
+    # Set up the screen for curses and begin time
+    setup_screen
+    time = 0
+
+    # Main game loop
+    loop do
+      time += 1
+
+      case $player.state
+        # Player is entering their name
+        # TODO: Ask for confirmation on the name before continuing on.
+        when :CREATING
+          show_prompt("Welcome! What is your name?")
+          name = get_input
+
+          # TODO: Adding two newlines here is ugly.
+          unless name.nil?
+            $win.addstr("\n\n")
+            $player.name = name
+            cmd_stats($player, nil)
+            $player.state = :ROLLING
+          end
+
+        # Player is rolling stats
+        when :ROLLING
+          show_prompt("Is this acceptable (y/n)?")
+          choice = get_input
+          unless choice.nil?
+            $win.addstr("\n\n")
+            if choice =~ /\An\Z/i
+              $player.roll_stats
+              cmd_stats($player, nil)
+            elsif choice =~ /\Ay\Z/i
+              # Stats OK - set timeout for getch and show the player where
+              # they are in the world
+              $win.timeout = 100
+              $player.state = :PLAYING
+              cmd_look($player, "")
+            else
+              cmd_stats($player, nil)
+            end
+          end
+
+        # Player is in the game, walking around
+        when :PLAYING
+          # TODO: Pick a reasonable length of time for a 'tick'
+          if time % 20 == 0
+            time = 0
+            # Tick! Do world stuff
+          end
+
+          show_prompt(">")
+          handle_input(get_input)
+
+        # Player is engaged in a fight
+        when :FIGHTING
+          # Nothing yet...
+      end
+    end
+  end
+
+  if __FILE__ == $0
+    play
+  end
+end

data/lib/skirmish/character.rb

@@ -0,0 +1,79 @@
+# skirmish is a single-player game in the style of CircleMUD.
+# This file holds the Character class, as well as the Player and Mobile
+# subclasses.
+#
+# Author::    Andy Mikula  (mailto:andy@andymikula.ca)
+# Copyright:: Copyright (c) 2016 Andy Mikula
+# License::   MIT
+
+# The Character class represents a being that lives in the world. Human players
+# and NPCs are both 'Character's.
+class Character
+  attr_accessor :name, :height, :weight, :str, :dex, :con, :int, :wis, :cha,
+    :maxhp, :hp, :xp, :armour, :level, :state, :location, :description, :keywords
+
+  # Create the character, which by default begins at level one and starts life
+  # at the temple (room 3001)
+  def initialize(name="", initial_level=1, initial_location=3001, description="", keywords=Array.new)
+    @state = :CREATING
+    @name = name
+    @description = description
+    @keywords = keywords
+
+    roll_stats initial_level
+    @location = initial_location
+    $world.move_character(self, 0, initial_location)
+  end
+
+  # Roll stats for the character. This is based on the D&D 5e creation rules,
+  # with some tweaks.
+  def roll_stats(initial_level = 1)
+    size_roll = roll_dice(2, 10)
+    @height = 60 + size_roll                        #inches
+    @weight = 110 + roll_dice(2, 3) * size_roll     #pounds
+
+    # Roll 3d6 for each attribute and sort the rolls by size
+    rolls = Array.new
+    6.times do
+      rolls.push roll_dice(3,6)
+    end
+    rolls.sort! { |a, b| a <=> b }
+
+    # Assign rolls in the standard order for a 'fighter'
+    @str = rolls.pop()
+    @con = rolls.pop()
+    @dex = rolls.pop()
+    @cha = rolls.pop()
+    @wis = rolls.pop()
+    @int = rolls.pop()
+    @maxhp = @con + 10
+    @hp = @maxhp
+    @xp = 0
+    @armour = @dex + 10
+    @level = initial_level
+  end
+
+  # Character's attack each time is calculated based on a roll of 1d10 * level,
+  # or as otherwise specified
+  def attack(num=1, size=10)
+    return roll_dice(num, size) * @level
+  end
+end
+
+# A 'Player' is the human-controlled Character in the game
+# TODO: Track playing time
+class Player < Character
+  def initialize(name="", initial_level=1, initial_location=3001, description="You're...you!", keywords="self")
+    super(name, initial_level, initial_location, description, keywords)
+    @quest = nil
+  end
+end
+
+# A 'Mobile' is any non-player character in the game
+# TODO: Write 'act' method for Mobile to be called on game ticks (or some
+# multiple thereof)
+class Mobile < Character
+  def initialize(name="", initial_level=1, initial_location=3001, description="", keywords=Array.new)
+    super(name, initial_level, initial_location, description, keywords)
+  end
+end

data/lib/skirmish/commands.rb

@@ -0,0 +1,152 @@
+# skirmish is a single-player game in the style of CircleMUD.
+# This file holds player commands.
+#
+# Author::    Andy Mikula  (mailto:andy@andymikula.ca)
+# Copyright:: Copyright (c) 2016 Andy Mikula
+# License::   MIT
+
+# Implementation of player commands. Each command must accept two arguments - a
+# character object and the original input string
+
+# TODO: Write commands as classes, so they can be aware of possible arguments
+# and support tab-completion / notification to the user of incorrect arguments
+
+# Move the character in the specified direction, if possible
+def cmd_move_character(character, direction)
+  # Ask the world if there's a room in the direction we want to move
+  new_location = $world.get_destination(character.location,
+	case direction
+		when /\An/i then 0
+		when /\Ae/i then 1
+		when /\As/i then 2
+		when /\Aw/i then 3
+		when /\Au/i then 4
+ 		when /\Ad/i then 5
+	end
+	)
+  # If there's a room to go to, tell the world where the character is going, and
+  # let the character track it as well. If character is a player, either display
+  # their new location or a message telling them they are unable to move in that
+  # direction
+  unless new_location.nil?
+    $world.move_character character, character.location, new_location
+    character.location = new_location
+    if character.is_a?(Player)
+      cmd_look character, ""
+    end
+  else
+    if character.is_a?(Player)
+      print_line "You can't go that way!\n"
+    end
+  end
+end
+
+# List the available exits from the room the player is currently in
+def cmd_list_exits(player, input)
+  exits = $world.get_exits player.location
+
+  exits_list = "[ Exits: "
+  until exits.empty? do
+    exits_list << "#{exits.shift} "
+  end
+  exits_list << "]\n"
+
+  print_line exits_list, :cyan
+end
+
+# List the commands available to the player
+# TODO: Pretty this output up a little bit - even columns would be nice
+def cmd_list_commands(player, input)
+  commands = $commands.keys
+
+  print_line commands.join(" ")
+  print_line
+end
+
+# For the Player's current location, display the room name, description, and any
+# other characters who are in the room with the player
+def cmd_look(player, input)
+
+  look_at = input.split[1..-1]
+
+  # If the player has specified a target / keyword, try to find it in the list
+  # of keywords on characters in the room
+  # TODO: Look at room keywords as well (i.e. 'look sign', etc.)
+  unless look_at.nil? || look_at.first.nil?
+    matches = $world.get_room_characters(player.location)
+              .select { |c| c.keywords =~ /\A#{Regexp.escape(look_at.first)}/i }
+    unless matches.first.nil?
+      print_line matches.first.description + "\n"
+    else
+      print_line "There is nothing to look at with that name.\n"
+    end
+  # No target specified - just show them the room name / description, any other
+  # characters who might be present, and the available exits
+  # TODO: Get the '...is standing here' description from the character
+  else
+    print_line $world.get_room_name(player.location), :cyan
+    print_line $world.get_room_description(player.location)
+    $world.get_room_characters(player.location).each do | char |
+      unless char.name == player.name
+        print_line char.name + " is standing here.", :white
+      end
+    end
+    cmd_list_exits player, nil
+  end
+end
+
+# Print the player's statistics to the screen
+def cmd_stats(player, input)
+
+  # Height is stored in inches, but it's nice to have something like 5'10"
+  feet = player.height / 12
+  inches = player.height % 12
+
+  print_line("Your name is %s. You are %d'%d\" tall and you weigh %d lbs." %
+  [player.name, feet, inches, player.weight])
+  print_line("You are level %d and have %d experience points." %
+  [player.level, player.xp])
+  print_line("============================================================")
+  print_line("Hitpoints:   %6d / %d" % [player.hp, player.maxhp])
+  print_line("Attack:      %6d - %2d" % [player.level, player.level * 10])
+  print_line("Armour:           %6d" % player.armour)
+  print_line("============================================================")
+  print_line("Strength:    %6d                     Charisma:    %6d" % [player.str, player.cha])
+  print_line("Constitution:%6d                     Wisdom:      %6d" % [player.con, player.wis])
+  print_line("Dexterity:   %6d                     Intelligence:%6d" % [player.dex, player.int])
+  print_line
+end
+
+# Quit the game. Make sure the player is sure! We don't want to quit on an
+# accidental 'q', for example
+# TODO: Save player / world state
+def cmd_quit(player, input)
+  unless input =~ /quit/i
+    print_line "You must type the entire word 'quit' to quit.\n"
+  else
+    print_line "Until next time..."
+    $win.refresh
+    sleep 3
+    $win.close
+    exit
+  end
+end
+
+# The possible command strings and their associated methods. To be able to use
+# a new command, it must be implemented above and added here. Ruby remembers the
+# order in which keys are added to a hash, which is convenient - we always match
+# the first key we see. As a result, entries higher up in the list have greater
+# precedence (making sure we match 'north' on 'n' instead of 'nap', for example)
+$commands = { "north" => method(:cmd_move_character),
+              "east" => method(:cmd_move_character),
+              "south" => method(:cmd_move_character),
+              "west" => method(:cmd_move_character),
+              "up" => method(:cmd_move_character),
+              "down" => method(:cmd_move_character),
+
+              "commands" => method(:cmd_list_commands),
+              "exits" => method(:cmd_list_exits),
+              "look" => method(:cmd_look),
+              "stats" => method(:cmd_stats),
+              "quit" => method(:cmd_quit)
+}

data/lib/skirmish/utilities.rb

@@ -0,0 +1,186 @@
+# skirmish is a single-player game in the style of CircleMUD.
+# This file holds the Command_History class, as well as functions for I/O, die
+# rolling, and the like.
+#
+# Author::    Andy Mikula  (mailto:andy@andymikula.ca)
+# Copyright:: Copyright (c) 2016 Andy Mikula
+# License::   MIT
+
+# This class stores the commands that have been entered by the player, so we can
+# have bash-style command history.
+class Command_History
+  def initialize
+    @history = Array.new
+    @position = 0 # The current 'position' in the list of commands
+  end
+
+  # The user entered a command - store it to the list and update the pointer
+  def add_command(command)
+    @history.push command
+    @position = @history.length - 1
+  end
+
+  # Unless we're already looking at the first item in the list, return the
+  # command at the current position and decrement the 'position' pointer
+  def get_previous
+    unless @position == 0
+      previous_command = @history[@position]
+      @position -= 1
+      return previous_command
+    else
+      return nil
+    end
+  end
+
+  # Unless we're already looking at the most recent item in the list, increment
+  # the 'position' pointer and return the command at the new position
+  def get_next
+    unless @position == @history.length - 1
+      @position += 1
+      next_command = @history[@position]
+      return next_command
+    else
+      return nil
+    end
+  end
+end
+
+# Look for input from the player, and return it once they have pressed 'enter'.
+# Otherwise, return nil
+def get_input
+  case char = $win.getch
+    # Backspace: Remove the last character from the input buffer
+    when Curses::KEY_BACKSPACE
+      $input_buffer.pop
+      return nil
+
+    # Up: Look for the previous command in the command history. If something
+    # exists, clear the input buffer and replace it with the last command
+    when Curses::KEY_UP
+      previous_command = $command_history.get_previous
+      unless previous_command.nil?
+        $input_buffer.clear
+        previous_command.each_char { |chr|  $input_buffer.push chr }
+      end
+      return nil
+
+    # Down: Look for the next command in the command history. If something
+    # exists, clear the input buffer and replace it with the next command
+    when Curses::KEY_DOWN
+      next_command = $command_history.get_next
+      unless next_command.nil?
+        $input_buffer.clear
+        next_command.each_char { |chr|  $input_buffer.push chr }
+      end
+      return nil
+
+    # Tab: See if there's a command that will match to what's currently in the
+    # input buffer. If there is, clear the buffer and replace with the command.
+    # If not, do nothing
+    when 9
+      possible_commands = $commands.select { |c| c =~ /\A#{Regexp.escape($input_buffer.join)}/i }
+      # TODO: Look for a space in the buffer instead of this horribe hack.
+      # We don't want to tab-complete the argument to a command
+      unless possible_commands.nil? or possible_commands.first.nil?
+        $input_buffer.clear
+        possible_commands.first.first.each_char { |chr|  $input_buffer.push chr }
+      end
+      return nil
+
+    # Enter: Add the input buffer to the command history, and return the input
+    # as a string
+    when 10 , 13
+      input = $input_buffer.join
+      $input_buffer.clear
+      $command_history.add_command input
+      return input
+
+    # Any printable character: Add the character to the input buffer
+    when /[[:print:]]/
+      $input_buffer << char
+      return nil
+  end
+end
+
+# Curses screen setup and color pair definitions
+def setup_screen
+  Curses.init_screen
+  Curses.start_color
+  Curses.cbreak
+  Curses.noecho
+  Curses.nl
+
+  # Color pairs. Arguments: color_number, foreground color, background color
+  Curses.init_pair 1, Curses::COLOR_GREEN, Curses::COLOR_BLACK
+  Curses.init_pair 2, Curses::COLOR_CYAN, Curses::COLOR_BLACK
+  Curses.init_pair 3, Curses::COLOR_WHITE, Curses::COLOR_BLACK
+
+  # Set up the window to fill the whole terminal
+  $win = Curses::Window.new(0, 0, 0, 0)
+  # Set the initial color to green on black
+  $win.color_set(1)
+  # Allow the screen to scroll, and allow the terminal to scroll as well
+  $win.scrollok true
+  $win.idlok true
+  # Allow capture of non-alpha key inputs (arrows, enter, etc.)
+  $win.keypad = true
+end
+
+# Find a command to invoke based on input from a character.
+def handle_input(input)
+  return if input.nil?
+
+  input.chomp!
+
+  # Print functions clear the current line, so if we're handling input, we need
+  # to move down a few lines so we can see what we entered on our screen.
+  $win.addstr("\n\n")
+
+  if input.length == 0
+    print_line("Please enter a valid command. A list of commands is available by typing 'commands'.\n")
+    return nil
+  end
+
+  # See if we can find a command key that matches the first word of the input
+  matches = $commands.select { |c| c =~ /\A#{Regexp.escape(input.split.first)}/i }
+  command = matches.first
+
+  unless command.nil?
+    # We have a match! Call the method associated with the command
+    return command[1].call($player, input)
+  else
+    print_line("\"#{input}\" is not a valid command. A list of commands is available by typing 'commands'.\n")
+  end
+end
+
+# Show a prompt to the player
+def show_prompt(prompt=">")
+  $win.color_set(3)
+  $win.setpos($win.cury, 0)
+  $win.deleteln
+  $win.addstr(prompt + " " + $input_buffer.join)
+  $win.color_set(1)
+end
+
+# Print a line to the screen.
+def print_line(line = "", color = :green)
+  case color
+  when :green
+    $win.color_set(1)
+  when :cyan
+    $win.color_set(2)
+  when :white
+    $win.color_set(3)
+  end
+
+  $win.setpos($win.cury, 0)
+  $win.deleteln
+  $win.addstr(line + "\n")
+
+  $win.color_set(1)
+end
+
+# Roll number_of_dice with size_of_dice sides, and return the result
+def roll_dice(number_of_dice, size_of_dice)
+  (1..number_of_dice).inject(0){ | sum, _ | sum + rand(1..size_of_dice) }
+end

data/lib/skirmish/world.rb

@@ -0,0 +1,129 @@
+# skirmish is a single-player game in the style of CircleMUD.
+# This file holds the World class, as well as structures to hold room and
+# description data.
+#
+# Author::    Andy Mikula  (mailto:andy@andymikula.ca)
+# Copyright:: Copyright (c) 2016 Andy Mikula
+# License::   MIT
+
+class World
+
+  # Create the world, using the specified file to load rooms.
+  # TODO: Load multiple room files from a folder
+  # TODO: Write world files in json or something similar
+  def initialize(world_file)
+    # Set up collections for rooms, characters, and potential mobile names
+    # TODO: Move @names to mobile class for use during creation
+    @rooms = Hash.new
+    @characters = Array.new
+    #@names = Array.new
+
+    # Not used currently
+    #f = File.open("lib/mobiles/names") or die "Unable to open 'names' file."
+    #f.each_line {|name| @names.push name}
+    #f.close
+
+    # Parse the CircleMUD .wld file. This is ugly, and I do not recommend
+    # touching it. Each room is given a name, description, and exits, and is
+    # added to the rooms list
+    # TODO: Get extra description data (signs, etc.)
+    File.read(world_file).split(/^\#/).drop(1).each do |chunk|
+      room = chunk.split(/\r?\n|\r/)
+      new_room = Room.new
+
+      room_number = room.shift.to_i
+      new_room.name = room.shift[0..-2]
+
+      new_room.description = room.shift
+      line = room.shift
+      until line == "~"
+        new_room.description.concat "\n"
+        new_room.description.concat line
+        line = room.shift
+      end
+
+      2.times {line = room.shift}
+
+      until line == "S"
+        if line[0] == "D"
+          direction = line[1]
+          dest = room.shift
+          dest = room.shift until dest == "~"
+          room.shift
+          dest = room.shift.split[-1]
+          new_room.direction_data.store(direction.to_i, dest.to_i)
+          line = room.shift
+        else
+          line = room.shift until line == "~"
+          line = room.shift
+        end
+      end
+      @rooms[room_number] = new_room
+    end
+  end
+
+  # If we know about the room in question, return its name
+  def get_room_name(room_number)
+    @rooms.key?(room_number) ? @rooms[room_number].name : nil
+  end
+
+  # If we know about the room in question, return its description
+  def get_room_description(room_number)
+    @rooms.key?(room_number) ? @rooms[room_number].description : nil
+  end
+
+  # If we know about the room in question, and have data for the room in the
+  # specified direction, return the number of the destination room. This is
+  # likely a bit of an abuse of the ternary operator
+  def get_destination(room_number, direction)
+    @rooms.key?(room_number) && @rooms.key?(@rooms[room_number].direction_data[direction]) ? @rooms[room_number].direction_data[direction] : nil
+  end
+
+  # Return the list of characters who are currently in the specified room
+  def get_room_characters(room_number)
+    return @rooms[room_number].characters
+  end
+
+  # Move a character from original_location to new_location - each room's
+  # 'characters' list should contain each character who is currently there
+  def move_character(character, original_location, new_location)
+    if @rooms.key?(original_location)
+      @rooms[original_location].characters.delete(character)
+    end
+    @rooms[new_location].characters.push character
+  end
+
+  # Return an array of characters signifying the possible exits from the
+  # specified room
+  def get_exits(room_number)
+    directions = ["n", "e", "s", "w", "u", "d"]
+    exits = Array.new
+
+    6.times do |i|
+      if @rooms.key?(@rooms[room_number].direction_data[i])
+        exits.push(directions[i])
+      end
+    end
+    return exits
+  end
+end
+
+# This does not need to be a whole class by itself, and is not currently used
+# TODO: Make Room.extra_descriptions a hash, so we can store
+# keyword => description pairs
+#class DescriptionData
+#  @keyword
+#  @description
+#end
+
+# A class to represent a room. A room is uniquely identified by its number,
+# knows which characters and objects are in it, and knows which rooms are
+# connected to it and in which direction
+class Room
+  attr_accessor :number, :name, :description, :direction_data, :characters
+
+  def initialize
+    @direction_data = Hash.new
+    @characters = Array.new
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: skirmish
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andy Mikula
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-17 00:00:00.000000000 Z
+dependencies: []
+description: A single-player text-based game compatible with CircleMUD world files
+email: andy@andymikula.ca
+executables:
+- skirmish
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/skirmish
+- lib/skirmish.rb
+- lib/skirmish/character.rb
+- lib/skirmish/commands.rb
+- lib/skirmish/utilities.rb
+- lib/skirmish/world.rb
+homepage: http://andy-j.github.io/skirmish
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: skirmish
+test_files: []