gamefic 0.2.0 → 0.6.0

data/lib/gamefic/describable.rb

@@ -1,40 +1,76 @@
-require "gamefic/keywords"
+require 'gamefic/keywords'
+require 'gamefic/grammar'
 
 module Gamefic
 
-	module Describable
+  # Add a variety of text properties for naming, describing, and properly
+  # referencing objects.
+  module Describable
+    include Grammar::Person, Grammar::Plural
     attr_reader :name
-		attr_accessor :synonyms, :indefinite_article
+    attr_accessor :synonyms, :indefinite_article
     attr_writer :definite_article
-		def keywords
-			Keywords.new "#{name} #{synonyms}"
-		end
-		def keywords=(value)
-			@keywords = value
-		end
+    
+    # Get a set of Keywords associated with the object.
+    # Keywords are typically the words in the object's name plus its synonyms.
+    #
+    # @return [Keywords]
+    def keywords
+      Keywords.new "#{name} #{synonyms}"
+    end
+    
+    # Get the name of the object with an indefinite article.
+    # Note: proper-named objects never append an article, though an article
+    # may be included in its proper name.
+    #
+    # @return [String]
     def indefinitely
-      (proper_named? ? '' : "#{indefinite_article} ") + name
+      ((proper_named? or indefinite_article == '') ? '' : "#{indefinite_article} ") + name
     end
+    
+    # Get the name of the object with a definite article.
+    # Note: proper-named objects never append an article, though an article
+    # may be included in its proper name.
     def definitely
-      (proper_named? ? '' : "#{definite_article} ") + name
+      ((proper_named? or definite_article == '') ? '' : "#{definite_article} ") + name
     end
+    
+    # Get the definite article for this object.
+    #
+    # @return [String]
     def definite_article
       @definite_article || "the"
     end
+    
+    # Is the object proper-named?
+    # Proper-named objects typically do not add articles to their names when
+    # referenced #definitely or #indefinitely, e.g., "Jane Doe" instead of
+    # "a Jane Doe" or "the Jane Doe."
+    #
+    # @return [Boolean]
     def proper_named?
       (@proper_named == true)
     end
-    def proper_named=(value)
-      if value == true
+    
+    # Set whether the object has a proper name.
+    #
+    # @param [Boolean]
+    def proper_named=(bool)
+      if bool == true
         if @definite_article != nil
           @name = "#{@definite_article} #{@name}"
           @definite_article = nil
         end
       end
-      @proper_named = value
+      @proper_named = bool
     end
+    
+    # Set the name of the object.
+    # Setting the name performs some magic to determine how to handle
+    # articles ("an object" and "the object").
+    #
+    # @param value [String]
     def name=(value)
-      # TODO: Split article from name
       words = value.split_words
       if ['a','an'].include?(words[0].downcase)
         @indefinite_article = words[0].downcase
@@ -42,8 +78,12 @@ module Gamefic
         value = value[words[0].length+1..-1].strip
       else
         if words[0].downcase == 'the'
-          @definite_article = 'the'
-          value = value[4..-1].strip
+          if proper_named?
+            @definite_article = nil
+          else
+            @definite_article = 'the'
+            value = value[4..-1].strip
+          end
         end
         # Try to guess the indefinite article
         if ['a','e','i','o','u'].include?(value[0,1].downcase)
@@ -54,34 +94,56 @@ module Gamefic
       end
       @name = value
     end
-		def description
-			@description.to_s != '' ? @description : "Nothing special."
-		end
-		def description=(value)
-			@description = value
-		end
-		def to_s
-			indefinitely
-		end
-	end
-
-  def self.a(entity)
-    entity.indefinitely
-  end
-  def self.an(entity)
-    entity.indefinitely
-  end
-  def self.the(entity)
-    entity.definitely
-  end
-  def self.A(entity)
-    entity.indefinitely.cap_first
-  end
-  def self.An(entity)
-    entity.indefinitely.cap_first
-  end
-  def self.The(entity)
-    entity.definitely.cap_first
+    
+    # Does the object have a description?
+    #
+    # @return [Boolean]
+    def has_description?
+      (@description.to_s != '')
+    end
+    
+    # Get the object's description.
+    #
+    # @return [String]
+    def description
+      @description || (Describable.default_description % { :name => self.definitely, :Name => self.definitely.capitalize_first })
+    end
+    
+    # Set the object's description.
+    #
+    # @param text [String]
+    def description=(text)
+      if text != (Describable.default_description % { :name => self.definitely, :Name => self.definitely.capitalize_first })
+        @description = text
+      else
+        @description = nil
+      end
+    end
+    
+    # Set the object's default description.
+    # The default description is typically set in an object's initialization
+    # to ensure that a non-empty string is available when a instance-specific
+    # description is not provided
+    #
+    # @param text [String]
+    def self.default_description=(text)
+      @default_description = text
+    end
+    
+    # Get the object's default description.
+    #
+    # @return [String]
+    def self.default_description
+      @default_description || "There's nothing special about %{name}."
+    end
+    
+    # Get a String representation of the object. By default, this is the
+    # object's name with an indefinite article, e.g., "a person" or "a red
+    # dog."
+    #
+    # @return [String]
+    def to_s
+      indefinitely
+    end
   end
-
 end

data/lib/gamefic/direction.rb

@@ -0,0 +1,46 @@
+module Gamefic
+
+  class Direction
+    attr_accessor :name, :adjective, :adverb, :reverse
+    def initialize args = {}
+      args.each { |key, value|
+        send "#{key}=", value
+      }
+      if !reverse.nil?
+        reverse.reverse = self
+      end
+      proper_named = true
+    end
+    def adjective
+      @adjective || @name
+    end
+    def adverb
+      @adverb || @name
+    end
+    def reverse=(dir)
+      @reverse = dir
+    end
+    def synonyms
+      "#{adjective} #{adverb}"
+    end
+    def to_s
+      @name
+    end
+    def self.find(str)
+      x = { "north" => NORTH, "south" => SOUTH, "west" => WEST, "east" => EAST, "up" => UP, "down" => DOWN, "northwest" => NORTHWEST, "northeast" => NORTHEAST, "southwest" => SOUTHWEST, "southeast" => SOUTHEAST }
+      x[str]
+    end
+  end
+
+  NORTH = Direction.new(:name => 'north', :adjective => 'northern')
+  SOUTH = Direction.new(:name => 'south', :adjective => 'southern', :reverse => NORTH)
+  WEST = Direction.new(:name => 'west', :adjective => 'western')
+  EAST = Direction.new(:name => 'east', :adjective => 'eastern', :reverse => WEST)
+  NORTHWEST = Direction.new(:name => 'northwest', :adjective => 'northwestern')
+  SOUTHEAST = Direction.new(:name => 'southeast', :adjective => 'southeastern', :reverse => NORTHWEST)
+  NORTHEAST = Direction.new(:name => 'northeast', :adjective => 'northeastern')
+  SOUTHWEST = Direction.new(:name => 'southwest', :adjective => 'southwestern', :reverse => NORTHEAST)
+  UP = Direction.new(:name => 'up', :adjective => 'upwards')
+  DOWN = Direction.new(:name => 'down', :adjective => 'downwards', :reverse => UP)
+
+end

data/lib/gamefic/director/delegate.rb

@@ -0,0 +1,91 @@
+module Gamefic
+  module Director
+    class Delegate
+      # If we use Query::Base.new in the @disambiguator declaration, Opal
+      # passes the block to the query instead of the action.
+      base = Query::Base.new
+      @@disambiguator = Action.new nil, nil, base do |actor, entities|
+        definites = []
+        entities.each { |entity|
+          definites.push entity.definitely
+        }
+        actor.tell "I don't know which you mean: #{definites.join_or}."
+      end
+      @@disambiguator.meta = true
+      def initialize(actor, orders)
+        @actor = actor
+        @orders = orders
+      end
+      def proceed
+        return if @orders.length == 0
+        @actor.send(:delegate_stack).push self
+        executed = false
+        while !executed
+          order = @orders.shift
+          break if order.nil?
+          arg_i = 0
+          final_arguments = []
+          order.arguments.each { |argument|
+            if argument.length > 1 and !order.action.queries[arg_i].allow_many?
+              if argument[0].kind_of?(Array)
+                # This thing refers to multiple items. Just keep going.
+                final_arguments = nil
+                break
+              else
+                ambiguous = argument
+              end
+              order = Order.new(@actor, @@disambiguator, [])
+              final_arguments = [ambiguous]
+              break
+            end
+            valid = []
+            if order.action.queries[arg_i].allow_ambiguous?
+              valid = argument.flatten
+            else
+              argument.each { |m|
+                if order.action.queries[arg_i].validate(@actor, m)
+                  valid.push m
+                else
+                  final_arguments = nil
+                  break
+                end
+              }
+            end
+            if order.action == @@disambiguator or final_arguments.nil?
+              break
+            end
+            if order.action.queries[arg_i].allow_many?
+              final_arguments.push valid.flatten
+            elsif valid.length == 1
+              final_arguments.push valid[0]
+            else
+              final_arguments = nil
+              break
+            end
+            arg_i += 1
+          }
+          if !final_arguments.nil?
+            # The actor is always the first argument to an Action proc
+            final_arguments.unshift @actor
+            order.action.execute(*final_arguments)
+            executed = true
+          end
+        end
+        @actor.send(:delegate_stack).pop
+      end
+      def execute
+        return if @orders.length == 0
+        if !@orders[0].action.meta?
+          @actor.plot.asserts.each_pair { |name, rule|
+            result = rule.test(@actor, @orders[0].action.verb, @orders[0].arguments)
+            if result == false
+              return
+            end
+          }
+        end
+        proceed
+      end
+      private
+    end
+  end
+end

data/lib/gamefic/director/order.rb

@@ -0,0 +1,10 @@
+module Gamefic
+  class Director::Order
+    attr_reader :actor, :action, :arguments
+    def initialize(actor, action, arguments)
+      @actor = actor
+      @action = action
+      @arguments = arguments
+    end
+  end
+end

data/lib/gamefic/director/parser.rb

@@ -0,0 +1,119 @@
+require 'gamefic/director/order'
+
+module Gamefic
+  module Director
+  
+    module Parser
+      def self.from_tokens(actor, tokens)
+          options = []
+          command = tokens.shift
+          actions = actor.plot.actions_with_verb(command.to_sym)
+          actions.each { |action|
+            if action.queries.length == tokens.length
+              valid = true
+              index = 0
+              action.queries.each { |query|
+                if query.validate(actor, tokens[index]) == false
+                  valid = false
+                  break
+                end
+                index += 1
+              }
+              if valid
+                arguments = []
+                tokens.each { |token|
+                    arguments.push [token]
+                }
+                options.push Order.new(actor, action, arguments)
+              end
+            end
+          }
+          if options.length == 0
+            tokens.unshift command
+          end
+          options
+      end
+      def self.from_string(actor, command)
+        options = []
+        if command.to_s == ''
+          return options
+        end
+        matches = Syntax.tokenize(command, actor.plot.syntaxes)
+        matches.each { |match|
+          actions = actor.plot.actions_with_verb(match.verb)
+          actions.each { |action|
+            options.concat bind_contexts_in_result(actor, match.arguments, action)
+          }
+        }
+        options
+      end
+      class << self
+        private
+        def bind_contexts_in_result(actor, handler, action)
+          queries = action.queries.clone
+          objects = execute_query(actor, handler.clone, queries, action)
+          num_nil = 0
+          while objects.length == 0 and queries.last.optional?
+            num_nil +=1
+            queries.pop
+            objects = execute_query(actor, handler.clone, queries, action, num_nil)
+          end
+          return objects
+        end
+        def execute_query(actor, arguments, queries, action, num_nil = 0)
+          # If the action verb is nil, treat the first argument as a query
+          arguments.shift unless action.verb.nil?
+          prepared = Array.new
+          objects = Array.new
+          valid = true
+          last_remainder = nil
+          queries.clone.each { |context|
+            arg = arguments.shift.to_s
+            if last_remainder.to_s > ''
+              arg = (last_remainder + " " + arg).strip
+            end
+            if arg.nil? or arg == ''
+              valid = false
+              next
+            end
+            if context == String
+              prepared.push [arg]
+            elsif context.kind_of?(Query::Base)
+              result = context.execute(actor, arg)
+              if result.objects.length == 0
+                valid = false
+                next
+              else
+                prepared.push result.objects
+                last_remainder = result.remainder
+              end
+            else
+              raise TypeError.new("Action parameters must inherit from Query::Base")
+            end
+          }
+          if valid == true
+            if last_remainder.nil? or last_remainder.empty?
+              prepared.each { |p|
+                p.uniq!
+              }
+              num_nil.times do
+                prepared.push [nil]
+              end
+              objects.push Order.new(actor, action, prepared)
+            else
+              if !action.queries.last.allow_many? or action.queries.last.allow_ambiguous?
+                misunderstood = Action.new nil, nil, Query::Text.new do |actor, text|
+                  actor.tell "I understand the first part of your command but not \"#{text}.\""
+                end
+                misunderstood.meta = true
+                objects.push Order.new(actor, misunderstood, [[last_remainder]])
+              end
+            end
+          end
+          objects
+        end
+      end
+    end
+
+  end
+end

data/lib/gamefic/director.rb

@@ -1,204 +1,23 @@
 module Gamefic
 
-	class Director
-		def self.dispatch(actor, command)
-			command.strip!
-      if command.to_s == ''
-        return
+  module Director
+    autoload :Parser, 'gamefic/director/parser'
+    autoload :Delegate, 'gamefic/director/delegate'
+    autoload :Order, 'gamefic/director/order'
+    
+    def self.dispatch(actor, *args)
+      orders = []
+      if args.length > 1
+        orders = Parser.from_tokens(actor, args)
       end
-      begin
-        handlers = Syntax.match(command, actor.plot)
-      rescue Exception => e
-        puts "#{e}"
-        return
+      if orders.length == 0
+        orders = Parser.from_string(actor, args.join(' ').strip)
       end
-      befores = Array.new
-			options = Array.new
-			handlers.each { |handler|
-				actions = actor.plot.commands[handler.command]
-				if actions != nil
-					actions.each { |action|
-            if action.queries.length == 0 and handler.arguments.length > 0
-              next
-            end
-						orders = bind_contexts_in_result(actor, handler, action)
-						orders.each { |order|
-							args = Array.new
-							args.push actor
-							order.arguments.each { |a|
-								if a.length > 1
-									longnames = Array.new
-									a.each { |b|
-										longnames.push "#{b.definitely}"
-									}
-									actor.tell "I don't know which you mean: #{longnames.join_and(', ', ' or ')}."
-									return
-								end
-								args.push a[0]
-							}
-              if order.action.kind_of?(Before)
-                befores.push [order.action, args]
-              else
-                options.push [order.action, args]
-              end
-						}
-					}
-				end
-			}
-			del = Delegate.new(actor, befores, options)
-			del.execute
-		end
-		private
-		def self.bind_contexts_in_result(actor, handler, action)
-      queries = action.queries.clone
-      objects = self.execute_query(actor, handler.arguments.clone, queries, action)
-      num_nil = 0
-      while objects.length == 0 and queries.last.optional?
-        num_nil +=1
-        queries.pop
-        objects = self.execute_query(actor, handler.arguments.clone, queries, action, num_nil)
-      end
-      return objects
-		end
-    def self.execute_query(actor, arguments, queries, action, num_nil = 0)
-			prepared = Array.new
-			objects = Array.new
-			valid = true
-			queries.clone.each { |context|
-				arg = arguments.shift
-				if arg == nil or arg == ''
-					valid = false
-					next
-				end
-				if context == String
-					prepared.push [arg]
-				elsif context.kind_of?(Query::Base)
-          if arg == 'it' and actor.object_of_pronoun != nil
-            result = context.execute(actor, "#{actor.object_of_pronoun.name}")
-          else
-            result = context.execute(actor, arg)
-          end
-					if result.objects.length == 0
-						valid = false
-						next
-					else
-						prepared.push result.objects
-						if result.remainder
-							arguments.push result.remainder
-						end
-					end
-				else
-					# TODO: Better message
-					raise "Invalid object"
-				end
-			}
-			if valid == true
-				prepared.each { |p|
-					p.uniq!
-				}
-        num_nil.times do
-          prepared.push [nil]
-        end
-				objects.push Order.new(action, prepared)
-			end
-      objects
+      first_order = orders[0]
+      del = Delegate.new(actor, orders)
+      del.execute
+      first_order
     end
-	end
-	
-	class Director
-		class Delegate
-      @@assertion_stack = Array.new
-			@@delegation_stack = Array.new
-			def initialize(actor, befores, actions)
-        @actor = actor
-        @befores = befores
-				@actions = actions
-			end
-			def execute
-        @@assertion_stack.push Hash.new
-        @@delegation_stack.push @befores
-        handle @befores
-        @@delegation_stack.pop
-        if @@assertion_stack.last[:everything] == false
-          @@assertion_stack.pop
-          return
-        end
-        result = true
-        @@delegation_stack.push @actions
-        # Nil commands pass assertions to facilitate error messages.
-        if @@assertion_stack.last[:everything] != true and Director::Delegate.next_command != nil
-          @actor.plot.rules.each { |k, v|
-            if @@assertion_stack.last[k] == true
-              next
-            elsif @@assertion_stack.last[k] == false
-              result = false
-              break
-            end
-            result = v.test(@actor)
-            if result == false
-              break
-            end
-            result = true
-          }
-        end
-        @@assertion_stack.pop
-        if result == true
-          handle @actions
-        end
-        @@delegation_stack.pop
-			end
-      def handle options
-				if options.length > 0
-					opt = options.shift
-					if opt[1].length == 1
-						opt[0].execute(opt[1][0])
-            opt[1][0].object_of_pronoun = nil
-					else
-            if opt[1].length == 2 and opt[1][1].kind_of?(Entity) and opt[1][0].parent != opt[1][1]
-              opt[1][0].object_of_pronoun = opt[1][1]
-            elsif opt[1][0].parent == opt[1][1]
-              opt[1][0].object_of_pronoun = nil
-            end
-						opt[0].execute(opt[1])
-					end
-				end
-      end
-      def self.pass requirement
-        @@assertion_stack.last[requirement] = true
-      end
-      def self.deny requirement
-        @@assertion_stack.last[requirement] = false
-      end
-      def self.next_command
-        return nil if @@delegation_stack.last.nil? or @@delegation_stack.last[0].length == 0
-        return @@delegation_stack.last[0][0].command
-      end
-			def self.passthru
-				if @@delegation_stack.last != nil
-					if @@delegation_stack.last.length > 0
-						opt = @@delegation_stack.last.shift
-						if opt[1].length == 1
-							opt[0].execute(opt[1][0])
-              opt[1][0].object_of_pronoun = nil
-						else
-              if opt[1].length == 2 and opt[1][1].kind_of?(Entity) and opt[1][0].parent != opt[1][1]
-                opt[1][0].object_of_pronoun = opt[1][1]
-              elsif opt[1][0].parent == opt[1][1]
-                opt[1][0].object_of_pronoun = nil
-              end
-							opt[0].execute(opt[1])
-						end
-					end
-				end
-			end
-		end
-		class Order
-			attr_reader :action, :arguments
-			def initialize(action, arguments)
-				@action = action
-				@arguments = arguments
-			end
-		end
-	end
+  end
 
 end