gamefic 1.4.1 → 1.5.0

data/lib/gamefic/plot/command_mount.rb

@@ -3,31 +3,6 @@ require 'gamefic/action'
 module Gamefic
 
   module Plot::CommandMount
-    # Create a Meta Action that responds to a command.
-    # Meta Actions are very similar to standard Actions, except the Plot
-    # understands them to be commands that operate above and/or outside of the
-    # actual game world. Examples of Meta Actions are commands that report the
-    # player's current score, save and restore saved games, or list the game's
-    # credits.
-    #
-    # @example A simple Meta Action
-    #   meta :credits do |actor|
-    #     actor.tell "This game was written by John Smith."
-    #   end
-    #
-    # @param command [Symbol] An imperative verb for the command
-    # @param *queries [Array<Query::Base>] Queries to filter the command's tokens
-    # @yieldparam [Character]
-    def meta(command, *queries, &proc)
-      act = self.action(command, *queries, &proc)
-      act.meta = true
-      act
-    end
-    def action(command, *queries, &proc)
-      act = Action.new(command, *queries, &proc)
-      add_action act
-      act
-    end
     # Create an Action that responds to a command.
     # An Action uses the command argument to identify the imperative verb that
     # triggers the action.
@@ -51,8 +26,59 @@ module Gamefic
     # @param *queries [Array<Query::Base>] Queries to filter the command's tokens
     # @yieldparam [Character]
     def respond(command, *queries, &proc)
-      self.action(command, *queries, &proc)
+      playbook.respond(command, *queries, &proc)
     end
+
+    # Create a Meta Action that responds to a command.
+    # Meta Actions are very similar to standard Actions, except the Plot
+    # understands them to be commands that operate above and/or outside of the
+    # actual game world. Examples of Meta Actions are commands that report the
+    # player's current score, save and restore saved games, or list the game's
+    # credits.
+    #
+    # @example A simple Meta Action
+    #   meta :credits do |actor|
+    #     actor.tell "This game was written by John Smith."
+    #   end
+    #
+    # @param command [Symbol] An imperative verb for the command
+    # @param *queries [Array<Query::Base>] Queries to filter the command's tokens
+    # @yieldparam [Character]
+    def meta(command, *queries, &proc)
+      playbook.meta command, *queries, &proc
+    end
+
+    # @deprecated
+    def action(command, *queries, &proc)
+      respond 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::Character]
+    # @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]
+    def validate &block
+      playbook.validate &block
+    end
+
     # Create an alternate Syntax for an Action.
     # The command and its translation can be parameterized.
     #
@@ -68,23 +94,27 @@ module Gamefic
     # @param translation [String] The format of the translated command
     # @return [Syntax] the Syntax object
     def interpret command, translation
-      xlate command, translation
+      playbook.interpret command, translation
     end
-    def syntax(*args)
-      xlate(*args)
+
+    # @deprecated
+    def xlate command, translation
+      interpret command, translation
     end
-    def xlate(*args)
-      syn = Syntax.new(*args)
-      add_syntax syn
-      syn
+
+    # Get an Array of available verbs.
+    # If the to_s parameter is true, convert Symbols to Strings.
+    #
+    # @return [Array<Symbol|String>]
+    def verbs to_s: false
+      to_s ? playbook.verbs.map { |v| v.to_s } : playbook.verbs
     end
-    def commandwords
-      words = Array.new
-      syntaxes.each { |s|
-        word = s.first_word
-        words.push(word) if !word.nil?
-      }
-      words.uniq
+
+    # Get an Array of all Actions defined in the Plot.
+    #
+    # @return [Array<Action>]
+    def actions
+      playbook.actions
     end
   end
   

data/lib/gamefic/plot/entities.rb

@@ -0,0 +1,82 @@
+module Gamefic
+
+  class Plot
+    module Entities
+      # Make a new Entity with the provided properties.
+      #
+      # @example Create an Entity
+      #   chair = make Entity, name: 'red chair'
+      #   chair.name #=> 'red chair'
+      #
+      # @param cls [Class] The Class of the Entity to be created.
+      # @param args [Hash] The entity's properties.
+      # @return The Entity instance.
+      def make cls, args = {}, &block
+        ent = cls.new args, &block
+        if ent.kind_of?(Entity) == false
+          raise "Invalid entity class"
+        end
+        p_entities.push ent
+        p_dynamic.push ent if running?
+        ent.playbook = playbook if ent.kind_of?(Character)
+        ent
+      end
+
+      def destroy entity
+        if p_dynamic.include?(entity)
+          p_entities.delete entity
+          p_dynamic.delete entity
+          p_players.delete entity
+        end
+        entity.parent = nil
+      end
+
+      # Pick an entity based on its description.
+      # The description provided must match exactly one entity; otherwise
+      # an error is raised.
+      #
+      # @example Select the Entity that matches the description
+      #   red_chair = make Entity, :name => 'red chair'
+      #   blue_chair make Entity, :name => 'blue chair'
+      #   pick "red chair" #=> red_chair
+      #   pick "blue chair" #=> blue_chair
+      #   pick "chair" #=> IndexError: description is ambiguous
+      #
+      # @param @description [String] The description of the entity
+      # @return [Entity] The entity that matches the description
+      def pick(description)
+        query = Gamefic::Query::Base.new
+        result = query.match(description, entities)
+        if result.objects.length == 0
+          raise IndexError.new("Unable to find entity from '#{description}'")
+        elsif result.objects.length > 1
+          raise IndexError.new("Ambiguous entities found from '#{description}'")
+        end
+        result.objects[0]
+      end
+
+      def entities
+        p_entities.clone
+      end
+
+      def players
+        p_players.clone
+      end
+
+      private
+
+      def p_entities
+        @p_entities ||= []
+      end
+
+      def p_players
+        @p_players ||= []
+      end
+
+      def p_dynamic
+        @p_dynamic ||= []
+      end
+    end
+  end
+
+end

data/lib/gamefic/plot/host.rb

@@ -0,0 +1,46 @@
+require 'gamefic/subplot'
+
+module Gamefic
+
+  module Plot::Host
+    # Get an array of all the current subplots.
+    #
+    # @return [Array<Subplot>]
+    def subplots
+      p_subplots.clone
+    end
+    
+    # Start a new subplot based on the provided class.
+    #
+    # @param [Class] The class of the subplot to be created (Subplot by default)
+    # @return [Subplot]
+    def branch subplot_class = Gamefic::Subplot, introduce: nil
+      subplot = subplot_class.new(self, introduce: introduce)
+      p_subplots.push subplot
+      subplot
+    end
+
+    # Get the player's current subplot or nil if none exists.
+    #
+    # @return [Subplot]
+    def subplot_for player
+      subplots.each { |s|
+        return s if s.players.include?(player)
+      }
+      nil
+    end
+
+    # Determine whether the player is involved in a subplot.
+    #
+    # @return [Boolean]
+    def subbed? player
+      !subplot_for(player).nil?
+    end
+
+    private
+    def p_subplots
+      @p_subplots ||= []
+    end
+  end
+
+end

data/lib/gamefic/plot/playbook.rb

@@ -0,0 +1,192 @@
+module Gamefic
+
+  class Plot
+    class Playbook
+      def initialize commands: {}, syntaxes: [], validators: [], disambiguator: nil
+        @commands = commands
+        @syntaxes = syntaxes
+        @validators = validators
+        @disambiguator = disambiguator
+      end
+
+      def syntaxes
+        @syntaxes
+      end
+
+      def actions
+        @commands.values.flatten
+      end
+
+      def verbs
+        @commands.keys
+      end
+
+      def validators
+        @validators
+      end
+
+      def disambiguator
+        @disambiguator ||= Action.new(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
+
+      def disambiguate &block
+        @disambiguator = Action.new(nil, Query::Base.new, &block)
+        @disambiguator.meta = true
+        @disambiguator
+      end
+
+      def validate &block
+        @validators.push block
+      end
+
+      # 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
+      def actions_for verb
+        @commands[verb] || []
+      end
+
+      # Create an Action that responds to a command.
+      # An Action uses the command argument to identify the imperative verb that
+      # triggers the action.
+      # It can also accept queries to tokenize the remainder of the input and
+      # filter for particular entities or properties.
+      # The block argument contains the code to be executed when the input
+      # matches all of the Action's criteria (i.e., verb and queries).
+      #
+      # @example A simple Action.
+      #   respond :salute do |actor|
+      #     actor.tell "Hello, sir!"
+      #   end
+      #   # The command "salute" will respond "Hello, sir!"
+      #
+      # @example An Action that accepts a Character
+      #   respond :salute, Use.visible(Character) do |actor, character|
+      #     actor.tell "#{The character} returns your salute."
+      #   end
+      #
+      # @param command [Symbol] An imperative verb for the command
+      # @param *queries [Array<Query::Base>] Queries to filter the command's tokens
+      # @yieldparam [Character]
+      def respond(command, *queries, &proc)
+        act = Action.new(command, *queries, &proc)
+        add_action act
+        act
+      end
+
+      # Create a Meta Action that responds to a command.
+      # Meta Actions are very similar to standard Actions, except the Plot
+      # understands them to be commands that operate above and/or outside of the
+      # actual game world. Examples of Meta Actions are commands that report the
+      # player's current score, save and restore saved games, or list the game's
+      # credits.
+      #
+      # @example A simple Meta Action
+      #   meta :credits do |actor|
+      #     actor.tell "This game was written by John Smith."
+      #   end
+      #
+      # @param command [Symbol] An imperative verb for the command
+      # @param *queries [Array<Query::Base>] Queries to filter the command's tokens
+      # @yieldparam [Character]
+      def meta(command, *queries, &proc)
+        act = respond(command, *queries, &proc)
+        act.meta = true
+        act
+      end
+
+      # Create an alternate Syntax for an Action.
+      # The command and its translation can be parameterized.
+      #
+      # @example Create a synonym for the Inventory Action.
+      #   interpret "catalogue", "inventory"
+      #   # The command "catalogue" will be translated to "inventory"
+      #
+      # @example Create a parameterized synonym for the Look Action.
+      #   interpret "scrutinize :entity", "look :entity"
+      #   # The command "scrutinize chair" will be translated to "look chair"
+      #
+      # @param command [String] The format of the original command
+      # @param translation [String] The format of the translated command
+      # @return [Syntax] the Syntax object
+      def interpret(*args)
+        syn = Syntax.new(*args)
+        add_syntax syn
+        syn
+      end
+
+      # Duplicate the playbook.
+      # This method will duplicate the commands hash and the syntax array so
+      # the new playbook can be modified without affecting the original.
+      #
+      # @return [Playbook]
+      def dup
+        Playbook.new commands: @commands.dup, syntaxes: @syntaxes.dup
+      end
+
+      def freeze
+        @commands.freeze
+        @syntaxes.freeze
+      end
+
+      private
+
+      def add_action(action)
+        @commands[action.verb] ||= []
+        @commands[action.verb].unshift action
+        @commands[action.verb].sort! { |a, b|
+          if a.specificity == b.specificity
+            # Newer action takes precedence
+            b.order_key <=> a.order_key
+          else
+            # Higher specificity takes precedence
+            b.specificity <=> a.specificity
+          end
+        }
+        generate_default_syntax action
+      end
+
+      def generate_default_syntax action
+        user_friendly = action.verb.to_s.gsub(/_/, ' ')
+        args = []
+        used_names = []
+        action.queries.each { |c|
+          num = 1
+          new_name = ":var"
+          while used_names.include? new_name
+            num = num + 1
+            new_name = ":var#{num}"
+          end
+          used_names.push new_name
+          user_friendly += " #{new_name}"
+          args.push new_name
+        }
+        add_syntax Syntax.new(user_friendly.strip, "#{action.verb} #{args.join(' ')}")
+      end
+
+      def add_syntax syntax
+        if @commands[syntax.verb] == nil
+          raise "No actions exist for \"#{syntax.verb}\""
+        end
+        @syntaxes.unshift syntax
+        @syntaxes.uniq
+        @syntaxes.sort! { |a, b|
+          if a.token_count == b.token_count
+            # For syntaxes of the same length, length of action takes precedence
+            b.first_word <=> a.first_word
+          else
+            b.token_count <=> a.token_count
+          end
+        }
+      end
+    end
+  end
+
+end