gamefic 2.0.2 → 2.2.0

data/lib/gamefic/subplot.rb

@@ -11,8 +11,9 @@ module Gamefic
     attr_reader :plot
 
     # @param plot [Gamefic::Plot]
-    # @param introduce [Gamefic::Actor]
-    # @param next_cue [Class<Gamefic::Scene::Base>]
+    # @param introduce [Gamefic::Actor, nil]
+    # @param next_cue [Class<Gamefic::Scene::Base>, nil]
+    # @param more [Hash]
     def initialize plot, introduce: nil, next_cue: nil, **more
       @plot = plot
       @next_cue = next_cue
@@ -98,15 +99,5 @@ module Gamefic
     #
     def configure more
     end
-
-    # def to_serial(index)
-    #   puts "Serializing #{self}"
-    #   super
-    # end
-
-    # def from_serial index = []
-    #   # @todo Customize subplot unserialization
-    #   super
-    # end
   end
 end

data/lib/gamefic/syntax.rb

@@ -1,5 +1,3 @@
-require 'gamefic/command'
-
 module Gamefic
   class Syntax
     attr_reader :token_count, :first_word, :verb, :template, :command
@@ -57,17 +55,18 @@ module Gamefic
       m = text.match(@regexp)
       return nil if m.nil?
       arguments = []
-      # HACK: Skip the first word if the verb is not nil.
-      # This is ugly.
       b = @verb.nil? ? 0 : 1
+      xverb = @verb
       @replace.to_s.split_words[b..-1].each { |r|
         if r.match(/^\{\$[0-9]+\}$/)
           arguments.push m[r[2..-2].to_i]
+        elsif arguments.empty? && xverb.nil?
+          xverb = r.to_sym
         else
           arguments.push r
         end
       }
-      Command.new @verb, arguments
+      Command.new xverb, arguments
     end
 
     # Determine if the specified text matches the syntax's expected pattern.
@@ -86,28 +85,36 @@ module Gamefic
     end
 
     def ==(other)
+      return false unless other.is_a?(Syntax)
       signature == other.signature
     end
 
-    # Tokenize an Array of Commands from the specified text.
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      signature.hash
+    end
+
+    # Tokenize an Array of Commands from the specified text. The resulting
+    # array is in descending order of specificity, i.e., most to least matched
+    # tokens.
     #
     # @param text [String] The text to tokenize.
     # @param syntaxes [Array<Gamefic::Syntax>] The Syntaxes to use.
     # @return [Array<Gamefic::Command>] The tokenized commands.
     def self.tokenize text, syntaxes
-      matches = []
-      syntaxes.each { |syntax|
-        result = syntax.tokenize text
-        matches.push(result) if !result.nil?
-      }
-      matches.sort! { |a,b|
-        if a.arguments.length == b.arguments.length
-          b.verb.to_s <=> a.verb.to_s
-        else
-          b.arguments.length <=> a.arguments.length
+      syntaxes
+        .map { |syn| syn.tokenize(text) }
+        .reject(&:nil?)
+        .sort do |a, b|
+          if a.arguments.length == b.arguments.length
+            b.verb.to_s <=> a.verb.to_s
+          else
+            b.arguments.length <=> a.arguments.length
+          end
         end
-      }
-      matches
     end
   end
 end

data/lib/gamefic/version.rb

@@ -1,3 +1,3 @@
 module Gamefic
-  VERSION = '2.0.2'
+  VERSION = '2.2.0'
 end

data/lib/gamefic/world/commands.rb

@@ -95,25 +95,6 @@ module Gamefic
         playbook.meta command, *queries, &proc
       end
 
-      # Declare a dismabiguation response for actions.
-      # The disambigurator is executed when an action expects an argument to
-      # reference a specific entity but its query matched more than one. For
-      # example, "red" might refer to either a red key or a red book.
-      #
-      # If a disambiguator is not defined, the playbook will use its default
-      # implementation.
-      #
-      # @example Tell the player the list of ambiguous entities.
-      #   disambiguate do |actor, entities|
-      #     actor.tell "I don't know which you mean: #{entities.join_or}."
-      #   end
-      #
-      # @yieldparam [Gamefic::Actor]
-      # @yieldparam [Array<Gamefic::Entity>]
-      def disambiguate &block
-        playbook.disambiguate &block
-      end
-
       # Validate an order before a character can execute its command.
       #
       # @yieldparam [Gamefic::Director::Order]
@@ -144,7 +125,7 @@ module Gamefic
       #
       # @return [Array<String>]
       def verbs
-        playbook.verbs.map { |v| v.to_s }.reject{ |v| v.start_with?('_') }
+        playbook.verbs.map(&:to_s).reject { |v| v.start_with?('_') }
       end
 
       # Get an Array of all Actions defined in the Plot.
@@ -164,20 +145,20 @@ module Gamefic
 
       private
 
+      # @param queries [Array]
+      # @return [Array<Query::Base>]
       def map_response_args queries
-        result = []
-        queries.each do |q|
+        queries.map do |q|
           if q.is_a?(Regexp)
-            result.push Gamefic::Query::Text.new(q)
+            Gamefic::Query::Text.new(q)
           elsif q.is_a?(Gamefic::Query::Base)
-            result.push q
+            q
           elsif q.is_a?(Gamefic::Element) || (q.is_a?(Class) && q <= Gamefic::Element)
-            result.push get_default_query.new(q)
+            get_default_query.new(q)
           else
             raise ArgumentError.new("Invalid argument for response: #{q}")
           end
         end
-        result
       end
     end
   end

data/lib/gamefic/world/entities.rb

@@ -93,16 +93,6 @@ module Gamefic
       def players
         @players ||= []
       end
-
-      # private
-
-      # def mark_static_entities
-      #   @static_entity_length ||= entities.length
-      # end
-
-      # def static_entity_length
-      #   @static_entity_length || 0
-      # end
     end
   end
 end

data/lib/gamefic/world/playbook.rb

@@ -1,20 +1,28 @@
+require 'set'
+
 module Gamefic
   module World
     # A collection of rules for performing commands.
     #
     class Playbook
-      def initialize commands: {}, syntaxes: [], validators: [], disambiguator: nil
-        @commands = commands
-        @syntaxes = syntaxes
-        @validators = validators
-        @disambiguator = disambiguator
-      end
-
       # An array of available syntaxes.
       #
       # @return [Array<Gamefic::Syntax>]
-      def syntaxes
-        @syntaxes
+      attr_reader :syntaxes
+
+      # An array of defined validators.
+      #
+      # @return [Array<Proc>]
+      attr_reader :validators
+
+      # @param commands [Hash]
+      # @param syntaxes [Array<Syntax>, Set<Syntax>]
+      # @param validators [Array]
+      def initialize commands: {}, syntaxes: [], validators: []
+        @commands = commands
+        @syntax_set = syntaxes.to_set
+        sort_syntaxes
+        @validators = validators
       end
 
       # An array of available actions.
@@ -31,32 +39,6 @@ module Gamefic
         @commands.keys
       end
 
-      # An array of defined validators.
-      #
-      # @return [Array<Proc>]
-      def validators
-        @validators
-      end
-
-      # Get the action for handling ambiguous entity references.
-      #
-      def disambiguator
-        @disambiguator ||= Action.subclass(nil, Query::Base.new) do |actor, entities|
-          definites = []
-          entities.each { |entity|
-            definites.push entity.definitely
-          }
-          actor.tell "I don't know which you mean: #{definites.join_or}."
-        end
-      end
-
-      # Set the action for handling ambiguous entity references.
-      #
-      def disambiguate &block
-        @disambiguator = Action.subclass(nil, Query::Base.new, meta: true, &block)
-        @disambiguator
-      end
-
       # Add a block that determines whether an action can be executed.
       #
       def validate &block
@@ -66,7 +48,7 @@ module Gamefic
       # Get an Array of all Actions associated with the specified verb.
       #
       # @param verb [Symbol] The Symbol for the verb (e.g., :go or :look)
-      # @return [Array<Action>] The verb's associated Actions
+      # @return [Array<Class<Action>>] The verb's associated Actions
       def actions_for verb
         @commands[verb] || []
       end
@@ -142,40 +124,16 @@ module Gamefic
         syn
       end
 
-      # Get an array of actions, derived from the specified command, that the
-      # actor can potentially execute.
-      # The command can either be a single string (e.g., "examine book") or a
-      # list of tokens (e.g., :examine, @book).
+      # Get a Dispatcher to select actions that can potentially be executed
+      # from the specified command string.
       #
-      # @return [Array<Gamefic::Action>]
-      def dispatch(actor, *command)
-        result = []
-        if command.length > 1
-          result.concat dispatch_from_params(actor, command[0], command[1..-1])
-        end
-        if result.empty?
-          result.concat dispatch_from_string(actor, command.join(' '))
-        end
-        result
-      end
-
-      # Get an array of actions, derived from the specified command, that the
-      # actor can potentially execute.
-      # The command should be a plain-text string, e.g., "examine the book."
-      #
-      # @return [Array<Gamefic::Action>]
-      def dispatch_from_string actor, text
-        result = []
+      # @param actor [Actor]
+      # @param text [String]
+      # @return [Dispatcher]
+      def dispatch(actor, text)
         commands = Syntax.tokenize(text, actor.syntaxes)
-        commands.each { |c|
-          available = actions_for(c.verb)
-          available.each { |a|
-            next if a.hidden?
-            o = a.attempt(actor, c.arguments)
-            result.unshift o unless o.nil?
-          }
-        }
-        sort_and_reduce_actions result
+        actions = commands.flat_map { |cmd| actions_for(cmd.verb).reject(&:hidden?) }
+        Dispatcher.new(actor, commands, sort_and_reduce_actions(actions))
       end
 
       # Get an array of actions, derived from the specified verb and params,
@@ -183,12 +141,8 @@ module Gamefic
       #
       # @return [Array<Gamefic::Action>]
       def dispatch_from_params actor, verb, params
-        result = []
         available = actions_for(verb)
-        available.each { |a|
-          result.unshift a.new(actor, params) if a.valid?(actor, params)
-        }
-        sort_and_reduce_actions result
+        Dispatcher.new(actor, [Command.new(verb, params)], sort_and_reduce_actions(available))
       end
 
       # Duplicate the playbook.
@@ -217,38 +171,38 @@ module Gamefic
         user_friendly = action.verb.to_s.gsub(/_/, ' ')
         args = []
         used_names = []
-        action.queries.each { |c|
+        action.queries.each do |_c|
           num = 1
           new_name = ":var"
           while used_names.include? new_name
-            num = num + 1
+            num += 1
             new_name = ":var#{num}"
           end
           used_names.push new_name
           user_friendly += " #{new_name}"
           args.push new_name
-        }
+        end
         add_syntax Syntax.new(user_friendly.strip, "#{action.verb} #{args.join(' ')}") unless action.verb.to_s.start_with?('_')
       end
 
       def add_syntax syntax
-        if @commands[syntax.verb] == nil
-          raise "No actions exist for \"#{syntax.verb}\""
-        end
-        @syntaxes.unshift syntax
-        @syntaxes.uniq! &:signature
-        @syntaxes.sort! { |a, b|
+        raise "No actions exist for \"#{syntax.verb}\"" if @commands[syntax.verb].nil?
+        sort_syntaxes if @syntax_set.add?(syntax)
+      end
+
+      def sort_and_reduce_actions arr
+        arr.sort_by.with_index { |a, i| [a.rank, i] }.reverse.uniq
+      end
+
+      def sort_syntaxes
+        @syntaxes = @syntax_set.sort do |a, b|
           if a.token_count == b.token_count
-            # For syntaxes of the same length, length of action takes precedence
+            # For syntaxes of the same length, sort first word
             b.first_word <=> a.first_word
           else
             b.token_count <=> a.token_count
           end
-        }
-      end
-
-      def sort_and_reduce_actions arr
-        arr.sort_by.with_index{|a, i| [a.rank, -i]}.reverse.uniq(&:class)
+        end
       end
     end
   end

data/lib/gamefic/world/players.rb

@@ -2,6 +2,7 @@ module Gamefic
   module World
     module Players
       include Gamefic::World::Entities
+      include Gamefic::World::Commands
 
       # An array of entities that are currently connected to users.
       #
@@ -10,12 +11,27 @@ module Gamefic
         @players ||= []
       end
 
-      # Get the character that the player will control on introduction.
+      def player_class cls = nil
+        STDERR.puts "Modifying player_class this way is deprecated. Use set_player_class instead" unless cls.nil?
+        @player_class = cls unless cls.nil?
+        @player_class ||= Gamefic::Actor
+      end
+
+      # @param cls [Class]
+      def set_player_class cls
+        unless cls < Gamefic::Active && cls <= Gamefic::Entity
+          raise ArgumentError, "Player class must be an active entity"
+        end
+        @player_class = cls
+      end
+
+      # Make a character that a player will control on introduction.
       #
       # @return [Gamefic::Actor]
-      def get_player_character
+      def make_player_character
         cast player_class, name: 'yourself', synonyms: 'self myself you me', proper_named: true
       end
+      alias get_player_character make_player_character
     end
   end
 end

data/lib/gamefic/world/scenes.rb

@@ -95,10 +95,10 @@ module Gamefic
       #
       # @param prompt [String]
       # @yieldparam [Gamefic::Actor]
-      # @yieldparam [Gamefic::Scene::Custom]
-      # @return [Class<Gamefic::Scene::Custom>]
+      # @yieldparam [Gamefic::Scene::Base]
+      # @return [Class<Gamefic::Scene::Base>]
       def question prompt = 'What is your answer?', &block
-        s = Scene::Custom.subclass do |actor, scene|
+        s = Scene::Base.subclass do |actor, scene|
           scene.prompt = prompt
           scene.on_finish &block
         end
@@ -150,23 +150,23 @@ module Gamefic
       # Custom scenes should always specify the next scene to be cued or
       # prepared. If not, the scene will get repeated on the next turn.
       #
-      # This method creates a Scene::Custom by default. You can customize other
+      # This method creates a Scene::Base by default. You can customize other
       # scene types by specifying the class to create.
       #
       # @example Ask the user for a name
-      #   @scene = custom do |scene|
-      #     data.prompt = "What's your name?"
-      #     scene.on_finish do |actor, data|
-      #       actor.name = data.input
+      #   @scene = custom do |actor, scene|
+      #     scene.prompt = "What's your name?"
+      #     scene.on_finish do
+      #       actor.name = scene.input
       #       actor.tell "Hello, #{actor.name}!"
-      #       actor.cue :active
+      #       actor.cue default_scene
       #     end
       #   end
       #
       # @param cls [Class] The class of scene to be instantiated.
       # @yieldparam [Gamefic::Actor]
-      # @return [Class<Gamefic::Scene::Custom>]
-      def custom cls = Scene::Custom, &block
+      # @return [Class<Gamefic::Scene::Base>]
+      def custom cls = Scene::Base, &block
         s = cls.subclass &block
         scene_classes.push s
         s