gamefic 0.2.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cdcd6a0fe04e0a8bbe946261ff8284fb4667e2f7
-  data.tar.gz: 98bafd885d73b32653194ca36ad50285e2656d45
+  metadata.gz: f89e42b74949fc2f51e9e5b277ab1c2cf8278f62
+  data.tar.gz: 94b6aed64c5b1805c98fde960a125b9c1f716cda
 SHA512:
-  metadata.gz: 5cef4896f4506c22cbc82dff02846805b64b8062ccc90ead1e9aeeac1df9e9cc50a2a79bffd0159da33896f497bb2ce4bdeec68a45c7bef715384846e2c9a842
-  data.tar.gz: 2d2f4b0df8f65e54d1da9826e4e4ca1febf3b9a5858f200f81c4163afbbfd75502c8ceb187a4f7db102135683843bfe0dc3f2d6fd5bca258988f60e85a8e69ee
+  metadata.gz: 3279a5663b92106d222f2468d9a0add3c05fedeceedcc2077f050764d5c6c5077ae38c72a1bdd475ee04bb734c57046c1976311569626246a2299e6cd22249c5
+  data.tar.gz: 9f32e56986a439a517d7d5783a4f37cf05e8e6884caf60caff044015c40baf8754c830b5f29bb3c98fac430e0c69419cf9dd09bf4e96b80666b1c0599f4fe2bc

data/lib/gamefic/action.rb

@@ -1,65 +1,96 @@
 module Gamefic
 
-	class Action
-		attr_reader :command, :order_key
-		@@defaults = Array.new
+  # Actions manage the execution of commands that Characters can perform.
+  # 
+  class Action
+    attr_reader :order_key, :queries
+    attr_writer :meta
     @@order_key_seed = 0
-		def initialize(story, command, *queries, &proc)
-      @plot = story
+    
+    def initialize(plot, verb, *queries, &proc)
+      if !verb.kind_of?(Symbol)
+        verb = verb.to_s
+        verb = nil if verb == ''
+      end
+      @plot = plot
       @order_key = @@order_key_seed
       @@order_key_seed += 1
-			if (command.kind_of?(Symbol) == false and !command.nil?)
-				raise "Action commands must be symbols"
-			end
-			if (queries.length + 1 != proc.arity) and (queries.length == 0 and proc.arity != -1)
-				raise "Number of contexts is not compatible with proc arguments"
-			end
-			@command = command
-			@queries = queries
-			@proc = proc
-			if story == nil
-				@@defaults.push self
-			else
-				story.send :add_action, self
-			end
-		end
-		def self.defaults
-			@@defaults.clone
-		end
-		def specificity
-			spec = 0
-			magnitude = 1
-			@queries.each { |q|
-				if q.kind_of?(Query::Base)
-					spec += (q.specificity * magnitude)
-				else
-					spec += magnitude
-				end
-				#magnitude = magnitude * 10
-			}
-			return spec
-		end
-		def key
-			@key
-		end
-		def queries
-			@queries
-		end
+      @proc = proc
+      if (verb.kind_of?(Symbol) == false and !verb.nil?)
+        raise "Action verbs must be symbols"
+      end
+      if !@proc.nil?
+        if (queries.length + 1 != @proc.arity) and (queries.length == 0 and @proc.arity != -1)
+          raise "Number of queries is not compatible with proc arguments"
+        end
+      end
+      @verb = verb
+      @queries = queries
+      if !plot.nil?
+        plot.send :add_action, self
+      end
+    end
+    
+    # Get the specificity of the Action.
+    # Specificity indicates how narrowly the Action's queries filter matches.
+    # Actions with higher specificity are given higher priority when searching
+    # for the Action that matches a character command. For example, an Action
+    # with a Query that filters for a specific class of Entity has a higher
+    # specificity than an Action with a Query that accepts arbitrary text.
+    #
+    # @return [Fixnum]
+    def specificity
+      spec = 0
+      if verb.nil?
+        spec = -100
+      end
+      magnitude = 1
+      @queries.each { |q|
+        if q.kind_of?(Query::Base)
+          spec += (q.specificity * magnitude)
+        else
+          spec += magnitude
+        end
+        #magnitude = magnitude * 10
+      }
+      return spec
+    end
+    
+    # Get the verb associated with this Action.
+    # The verb is represented by a Symbol in the imperative form, such as
+    # :take or :look_under.
+    #
+    # @return [Symbol] The Symbol representing the verb.
+    def verb
+      @verb
+    end
+    
+    # Execute this Action. This method is typically called by the Plot when
+    # a Character performs a command.
     def execute *args
-      @proc.call *args
+      @proc.call(*args)
+    end
+    
+    def signature
+      sig = ["#{@verb}"]
+      @queries.each { |q|
+        sig.push q.signature
+      }
+      "#{sig.join(', ').gsub(/Gamefic::(Query::)?/, '')}(#{specificity})"
+    end
+    
+    # Is this a meta Action?
+    # If an Action is flagged meta, it usually means that it provides
+    # information about the game or manages some aspect of the user interface.
+    # It shouldn't represent an Action that the player's character performs in
+    # the game world. Examples include Actions to display credits or
+    # instructions.
+    #
+    # @return [Boolean]
+    def meta?
+      @meta ||= false
     end
-		private
-			def self.explode(entity)
-				arr = Array.new
-				arr.push entity
-				cls = entity.class
-				while cls != Object
-					arr.push cls
-					cls = cls.superclass
-				end
-				arr.push String
-				arr.push nil
-			end
-	end
+    
+  end
 
 end

data/lib/gamefic/ansi.rb

@@ -0,0 +1,55 @@
+module Gamefic
+
+  # Constants for ANSI codes, plus Extras for custom formatting.
+  module Ansi
+    module Code
+      class Nonstandard < String
+      
+      end
+      module Attribute
+        NORMAL = 0
+        BOLD = 1
+        UNDERSCORE = 4
+        BLINK = 5
+        REVERSE = 7
+        CONCEALED = 8
+      end
+      module Foreground
+        BLACK = 30
+        RED = 31
+        GREEN = 32
+        YELLOW = 33
+        BLUE = 34
+        MAGENTA = 35
+        CYAN = 36
+        WHITE = 37
+      end
+      module Background
+        BLACK = 40
+        RED = 41
+        GREEN = 42
+        YELLOW = 43
+        BLUE = 44
+        MAGENTA = 45
+        CYAN = 46
+        WHITE = 47
+      end
+      module Extra
+        BLOCK = Nonstandard.new("block")
+        HREF = Nonstandard.new("href")
+        IMAGE = Nonstandard.new("image")
+        SRC = Nonstandard.new("src")
+        UPPERCASE = Nonstandard.new("uppercase")
+        COMMAND = Nonstandard.new("command")
+        IGNORED = Nonstandard.new("ignored")
+        LINE = Nonstandard.new("line")
+      end
+    end  
+    def self.graphics_mode(*settings)
+      ansi = settings.flatten.that_are_not(Code::Nonstandard)
+      return '' if ansi.length == 0
+      "\e[#{ansi.join(';')}m"
+    end
+  end
+
+end

data/lib/gamefic/character.rb

@@ -1,82 +1,136 @@
-module Gamefic
+require 'gamefic/director'
 
-	class Character < Thing
-		attr_reader :state, :queue, :user, :last_command
-    attr_accessor :object_of_pronoun
-		def initialize(plot, args = {})
-			@state = CharacterState.new(self)
-			@queue = Array.new
+module Gamefic
+  class Character < Entity
+    attr_reader :queue, :user
+    # @return [Gamefic::Director::Order]
+    attr_reader :last_order
+    # @return [Entity,nil]
+    attr_reader :last_object
+    attr_accessor :object_of_pronoun, :scene
+    
+    def initialize(plot, args = {})
+      @queue = Array.new
+      super
+      @buffer_stack = 0
+      @buffer = ""
+    end
+    
+    # Connect a User.
+    #
+    # @param user [User]
+    def connect(user)
+      @user = user
+    end
+    
+    # Disconnect the current User.
+    #
+    def disconnect
+      # TODO: We might need some cleanup here. Like, move the character out of the game, or set a timeout to allow dropped users to reconnect... figure it out.
+      @user = nil
+    end
+    
+    # Perform a command.
+    # The command can be specified as a String or a set of tokens. Either form
+    # should yield the same result, but using tokens can yield better
+    # performance since it doesn't need to parse the command first.
+    #
+    # The command will be executed immediately regardless of game state.
+    #
+    # @example Send a command as a string
+    #   character.perform "take the key"
+    #
+    # @example Send a command as a set of tokens
+    #   character.perform :take, @key
+    #
+    def perform(*command)
+      Director.dispatch(self, *command)
+    end
+    
+    # Quietly perform a command.
+    # This method executes the command exactly as #perform does, except it
+    # buffers the resulting output instead of sending it to the user.
+    #
+    # @return [String] The output that resulted from performing the command.
+    def quietly(*command)
+      if @buffer_stack == 0
+        @buffer = ""
+      end
+      @buffer_stack += 1
+      self.perform *command
+      @buffer_stack -= 1
+      @buffer
+    end
+    
+    # Send a message to the Character.
+    # This method will automatically wrap the message in HTML paragraphs.
+    # To send a message without paragraph formatting, use #stream instead.
+    #
+    # @param message [String]
+    def tell(message)
+      if user != nil and message.to_s != ''
+        if @buffer_stack > 0
+          @buffer += message
+        else
+          message = "<p>#{message}</p>"
+          # This method uses String#gsub instead of String#gsub! for
+          # compatibility with Opal.
+          message = message.gsub(/\n\n/, '</p><p>')
+          message = message.gsub(/\n/, '<br/>')
+          user.stream.send message
+        end
+      end
+    end
+    
+    # Send a message to the Character as raw text.
+    # Unlike #tell, this method will not wrap the message in HTML paragraphs.
+    #
+    # @param message [String]
+    def stream(message)
+      user.stream.send message
+    end
+    
+    def destroy
+      if @user != nil
+        @user.quit
+      end
       super
-		end
-		def connect(user)
-			@user = user
-		end
-		def disconnect
-			# TODO: We might need some cleanup here. Like, move the character out of the game, or set a timeout to allow dropped users to reconnect... figure it out.
-			@user = nil
-		end
-		def perform(command)
-			#if command != nil
-			#	@queue.push command
-			#end
-      @last_command = command
-			if state.busy? == false
-				Director.dispatch(self, command)
-			else
-				@queue.push command
-			end
-		end
-		#def inject(command)
-		#	Director.dispatch(self, command)
-		#end
-		def tell(message, refresh = false)
-			if user != nil and message.to_s != ''
-				user.stream.send "#{message}\n"
-				if (refresh == true)
-					user.refresh
-				end
-			end
-		end
-		def state=(new_state)
-			@state = new_state
-		end
-		def destroy
-			if @user != nil
-				@user.quit
-			end
-			super
-		end
-		def update
-			super
-			@state.update
-		end
-	end
-	class CharacterState
-		def initialize(character)
-			@character = character
-			post_initialize
-		end
-		def post_initialize
-			# TODO: Required by subclasses?
-		end
-		def busy?
-			false
-		end
-		def update
-			while (line = @character.queue.shift)
-				@character.perform line
-				if @character.state != self
-					break
-				end
-			end
-		end
-    def prompt
-      "> "
     end
-	end
-  class GameOverState < CharacterState
-    def prompt
-      "GAME OVER"
+    
+    # Proceed to the next Action in the current stack.
+    # This method is typically used in Action blocks to cascade through
+    # multiple implementations of the same verb.
+    #
+    # @example Proceed through two implementations of a verb
+    #   introduction do |actor|
+    #     actor[:has_eaten] = false # Initial value
+    #   end
+    #   respond :eat do |actor|
+    #     actor[:has_eaten] = true
+    #   end
+    #   respond :eat do |actor|
+    #     # This version will be executed first because it was implemented last
+    #     actor.tell "You eat something."
+    #     actor[:has_eaten] # Will be false on the first run
+    #     actor.proceed # Execute the previous implementation
+    #     actor[:has_eaten] #=> true
+    #   end
+    #
+    def proceed
+      return if delegate_stack.last.nil?
+      delegate_stack.last.proceed
+    end
+    
+    private
+    def delegate_stack
+      @delegate_stack ||= []
+    end
+    def last_order=(order)
+      return if order.nil?
+      @last_order = order
+      if !order.action.meta? and !order.arguments[0].nil? and !order.arguments[0][0].nil? and order.arguments[0][0].kind_of?(Entity)
+        @last_object = order.arguments[0][0]
+      end
     end
   end
 

data/lib/gamefic/command.rb

@@ -0,0 +1,19 @@
+module Gamefic
+  # A Command is a collection of tokens parsed from a Syntax.
+  # The Director uses Commands to find and execute corresponding Actions.
+  #
+  class Command
+    # @!attribute [r] verb
+    #   @return [Symbol] A Symbol representing the command's verb or verbal phrase.
+    attr_reader :verb
+    
+    # @!attribute [r] arguments
+    #   @return [Array<String>] An Array of arguments to be mapped to an Action's Queries.
+    attr_reader :arguments
+    
+    def initialize verb, arguments
+      @verb = verb
+      @arguments = arguments
+    end
+  end
+end

data/lib/gamefic/core_ext/array.rb

@@ -1,47 +1,58 @@
 class Array
-	def that_are(cls)
-		if (cls.kind_of?(Class) or cls.kind_of?(Module))
-			return self.clone.delete_if { |i| i.kind_of?(cls) == false }
+  # @return [Array]
+  def that_are(cls)
+    if (cls.kind_of?(Class) or cls.kind_of?(Module))
+      return self.clone.delete_if { |i| i.kind_of?(cls) == false }
     elsif cls.kind_of?(Symbol)
-      return self.clone.delete_if { |i| i.option_selected?(cls) == false }
-		else
-			if self.include?(cls)
-				return [cls]
-			end
-			return Array.new
-		end
-	end
-	def that_are_not(cls)
-		if (cls.kind_of?(Class) or cls.kind_of?(Module))
-			return self.clone.delete_if { |i| i.kind_of?(cls) == true }
+      return self.clone.delete_if { |i| i.send(cls) == false }      
+    else
+      if self.include?(cls)
+        return [cls]
+      end
+      return Array.new
+    end
+  end
+  # @return [Array]
+  def that_are_not(cls)
+    if (cls.kind_of?(Class) or cls.kind_of?(Module))
+      return self.clone.delete_if { |i| i.kind_of?(cls) == true }
     elsif cls.kind_of?(Symbol)
-      return self.clone.delete_if { |i| i.option_selected?(cls) == true }
-		else
-			return self.clone - [cls]
-		end
-	end
-	def random
-		return self[rand(self.length)]
-	end
+      return self.clone.delete_if { |i| i.send(cls) == true }
+    else
+      return self.clone - [cls]
+    end
+  end
+  def random
+    return self[rand(self.length)]
+  end
   def pop_random
     delete_at(rand(self.length))
   end
-	def shuffle
-		self.sort { |a, b|
-			rand(3) <=> rand(3)
-		}
-	end
-	def shuffle!
-		self.sort! { |a, b|
-			rand(3) <=> rand(3)
-		}
-	end
-	def join_and(sep = ', ', andSep = ' and ', serial = true)
-		if self.length < 3
-			self.join(andSep)
-		else
-			start = self - [self.last]
-			start.join(sep) + "#{serial ? sep.strip : ''}#{andSep}#{self.last}"
-		end
-	end
+  # @return [Array]
+  def shuffle
+    self.sort { |a, b|
+      rand(3) <=> rand(3)
+    }
+  end
+  # @return [Array]
+  def shuffle!
+    self.sort! { |a, b|
+      rand(3) <=> rand(3)
+    }
+  end
+  # Get a string representation of the array that separated elements with
+  # commas and adds a conjunction before the last element.
+  # @return [String]
+  def join_and(sep = ', ', andSep = ' and ', serial = true)
+    if self.length < 3
+      self.join(andSep)
+    else
+      start = self - [self.last]
+      start.join(sep) + "#{serial ? sep.strip : ''}#{andSep}#{self.last}"
+    end
+  end
+  # @return [String]
+  def join_or(sep = ', ', orSep = ' or ', serial = true)
+    join_and(sep, orSep, serial)
+  end
 end

data/lib/gamefic/core_ext/string.rb

@@ -1,10 +1,14 @@
 class String
+  # Capitalize the first letter without changing the rest of the string.
+  # (String#capitalize makes the rest of the string lower-case.)
 	def capitalize_first
 		"#{self[0,1].upcase}#{self[1,self.length]}"
 	end
+	# @return [String]
 	def cap_first
 		self.capitalize_first
 	end
+	# @return [Array]
 	def split_words
 		self.gsub(/ +/, ' ').strip.split
 	end