gamefic 1.7.0 → 2.0.0

data/lib/gamefic/plot/commands.rb

@@ -1,120 +0,0 @@
-require 'gamefic/action'
-
-module Gamefic
-
-  module Plot::Commands
-    # 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>] Filters for the command's tokens
-    # @yieldparam [Character]
-    def respond(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>] Filters for 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.
-    #
-    # @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 command, translation
-      playbook.interpret command, translation
-    end
-
-    # @deprecated
-    def xlate command, translation
-      interpret command, translation
-    end
-
-    # Get an Array of available verbs.
-    #
-    # @return [Array<String>]
-    def verbs
-      playbook.verbs.map { |v| v.to_s }.reject{ |v| v.start_with?('_') }
-    end
-
-    # Get an Array of all Actions defined in the Plot.
-    #
-    # @return [Array<Action>]
-    def actions
-      playbook.actions
-    end
-  end
-  
-end

data/lib/gamefic/plot/players.rb

@@ -1,15 +0,0 @@
-module Gamefic
-
-  module Plot::Players
-    def players
-      p_players.clone
-    end
-
-    private
-
-    def p_players
-      @p_players ||= []
-    end
-  end
-
-end

data/lib/gamefic/plot/scenes.rb

@@ -1,187 +0,0 @@
-module Gamefic
-
-  module Plot::Scenes
-    def default_scene
-      @default_scene ||= Scene::Activity
-    end
-
-    def default_conclusion
-      @default_conclusion ||= Scene::Conclusion
-    end
-
-    # Add a block to be executed when a player is added to the game.
-    # Each Plot can only have one introduction. Subsequent calls will
-    # overwrite the existing one.
-    #
-    # @example Welcome the player to the game
-    #   introduction do |actor|
-    #     actor.tell "Welcome to the game!"
-    #   end
-    #
-    # @yieldparam [Gamefic::Character]
-    def introduction(&proc)
-      @introduction = proc
-    end
-
-    # Introduce a player to the game.
-    # This method is typically called by the Engine that manages game execution.
-    #
-    # @param [Gamefic::Character]
-    def introduce(player)
-      player.playbooks.push playbook unless player.playbooks.include?(playbook)
-      player.cue default_scene
-      p_players.push player
-      @introduction.call(player) unless @introduction.nil?
-    end
-
-    # Create a multiple-choice scene.
-    # The user will be required to make a valid choice to continue.
-    #
-    # @yieldparam [Gamefic::Character]
-    # @yieldparam [Gamefic::Scene::Data::MultipleChoice]
-    def multiple_choice *choices, &block
-      s = Scene::MultipleChoice.subclass do |actor, scene|
-        scene.options.concat choices
-        scene.on_finish &block
-      end
-      scene_classes.push s
-      s
-    end
-    
-    # Create a yes-or-no scene.
-    # The user will be required to answer Yes or No to continue.
-    #
-    # @yieldparam [Gamefic::Character]
-    # @yieldparam [Gamefic::Scene::YesOrNo]
-    def yes_or_no prompt = nil, &block
-      s = Scene::YesOrNo.subclass do |actor, scene|
-        scene.prompt = prompt
-        scene.on_finish &block
-      end
-      scene_classes.push s
-      s
-    end
-
-    # Create a scene with custom processing on user input.
-    #
-    # @example Echo the user's response
-    #   @scene = question 'What do you say?' do |actor, scene|
-    #     actor.tell "You said #{scene.input}"
-    #   end
-    #
-    # @yieldparam [Gamefic::Character]
-    # @yieldparam [Gamefic::Scene::YesOrNo]
-    def question prompt = 'What is your answer?', &block
-      s = Scene::Custom.subclass do |actor, scene|
-        scene.prompt = prompt
-        scene.on_finish &block
-      end
-      scene_classes.push s
-      s
-    end
-
-    # Create a scene that pauses the game.
-    # This scene will execute the specified block and wait for input from the
-    # the user (e.g., pressing Enter) to continue.
-    #
-    # @param prompt [String] The text to display when prompting the user to continue.
-    # @yieldparam [Gamefic::Character]
-    # @yieldparam [Gamefic::Scene::Pause]
-    def pause prompt = nil, &block
-      s = Scene::Pause.subclass do |actor, scene|
-        scene.prompt = prompt unless prompt.nil?
-        block.call(actor, scene) unless block.nil?
-      end
-      scene_classes.push s
-      s
-    end
-    
-    # Create a conclusion.
-    # The game (or the character's participation in it) will end after this
-    # scene is complete.
-    #
-    # @yieldparam [Gamefic::Character]
-    # @yieldparam [Gamefic::Scene::Conclusion]
-    def conclusion &block
-      s = Scene::Conclusion.subclass &block
-      scene_classes.push s
-      s
-    end
-    
-    # Create a custom scene.
-    #
-    # 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
-    # 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
-    #       actor.tell "Hello, #{actor.name}!"
-    #       actor.cue :active
-    #     end
-    #   end
-    #
-    # @param cls [Class] The class of scene to be instantiated.
-    # @yieldparam [Gamefic::Character]
-    # @yieldparam [Scene::Custom] The instantiated scene.
-    def custom cls = Scene::Custom, &block
-      s = cls.subclass &block
-      scene_classes.push s
-      s
-    end
-
-    # Choose a new scene based on a list of options.
-    # This is a specialized type of multiple-choice scene that determines
-    # which scene to cue based on a Hash of choices and scene keys.
-    #
-    # @example Select a scene
-    #   scene_one = pause do |actor|
-    #     actor.tell "You went to scene one"
-    #   end
-    #
-    #   scene_two = pause do |actor|
-    #     actor.tell "You went to scene two"
-    #   end
-    #
-    #   select_one_or_two = multiple_scene "One" => scene_one, "Two" => scene_two
-    #
-    #   introduction do |actor|
-    #     actor.cue select_one_or_two # The actor will be prompted to select "one" or "two" and get sent to the corresponding scene
-    #   end
-    #
-    # @example Customize options
-    #   scene_one = pause # do...
-    #   scene_two = pause # do...
-    #
-    #   # Some event in the game sets actor[:can_go_to_scene_two] to true
-    #
-    #   select_one_or_two = multiple_scene do |actor, scene|
-    #     scene.map "Go to scene one", scene_one
-    #     scene.map "Go to scene two", scene_two if actor[:can_go_to_scene_two]
-    #   end
-    #
-    # @param map [Hash] A Hash of options and associated scenes.
-    # @yieldparam [Gamefic::Character]
-    # @yieldparam [Gamefic::Scene::MultipleScene]
-    def multiple_scene map = {}, &block
-      s = Scene::MultipleScene.subclass do |actor, scene|
-        map.each_pair { |k, v|
-          scene.map k, v
-        }
-        block.call actor, scene unless block.nil?
-      end
-      scene_classes.push s
-      s
-    end
-
-    def scene_classes
-      @scene_classes ||= []
-    end
-  end
-
-end

data/lib/gamefic/plot/theater.rb

@@ -1,73 +0,0 @@
-module Gamefic
-
-  module Plot::Theater
-    # Execute a block of code in a subset of the object's scope. An object's
-    # stage is an isolated namespace that has its own instance variables and
-    # access to its owner's public methods.
-    #
-    # There are two ways to execute code on the stage. It will accept either a
-    # string of code with an optional file name and line number, or a proc
-    # with optional arguments. See module_eval and module_exec for more
-    # information.
-    #
-    # @example Evaluate a string of code
-    #   stage "puts 'Hello'"
-    #
-    # @example Evaluate a string of code with a file name and line number
-    #   stage "puts 'Hello'", "file.rb", 1
-    #
-    # @example Execute a block of code
-    #   stage {
-    #     puts 'Hello'
-    #   }
-    #
-    # @example Execute a block of code with arguments
-    #   stage 'hello' { |message|
-    #     puts message # <- prints 'hello'
-    #   }
-    #
-    # @example Use an instance variable
-    #   stage "@message = 'hello'"
-    #   stage "puts @message" # <- prints 'hello'
-    #
-    # @return [Object] The value returned by the executed code
-    def stage *args, &block
-      if block.nil?
-        theater.module_eval *args
-      else
-        theater.module_exec *args, &block
-      end
-    end
-
-    # The module that acts as an isolated namespace for staged code.
-    #
-    # @return [Module]
-    def theater
-      return @theater unless @theater.nil?
-      instance = self
-
-      @theater = Module.new do
-        define_singleton_method :method_missing do |symbol, *args, &block|
-          instance.public_send :public_send, symbol, *args, &block
-        end
-
-        define_singleton_method :stage do |*args|
-          raise NoMethodError.new("The stage method is not available from inside staged scripts")
-        end
-
-        define_singleton_method :to_s do
-          "[Theater]"
-        end
-      end
-
-      # HACK: Include the theater module in Object so that classes and modules
-      # defined in scripts are accessible from procs passed to the stage.
-      Object.class_exec(@theater) do |t|
-        include t
-      end
-      
-      @theater
-    end
-  end
-
-end

data/lib/gamefic/plot/you_mount.rb

@@ -1,22 +0,0 @@
-require 'gamefic'
-require 'gamefic/grammar'
-
-module Gamefic
-  module Plot::YouMount
-    class YouGrammarSet
-      include Grammar::Gender
-      include Grammar::Person
-      include Grammar::Plural
-      include Grammar::WordAdapter
-    end
-    # @return [YouGrammarSet]
-    def you
-      if @you.nil?
-        @you = YouGrammarSet.new
-        @you.person = 2
-      end
-      @you
-    end
-  end
-  
-end

data/lib/gamefic/script.rb

@@ -1,13 +0,0 @@
-module Gamefic
-
-  # Script classes provide code to be executed in Plots. They are accessed
-  # through Source classes, e.g., a Source::Text object is used to find
-  # Source::Files. 
-  #
-  module Script
-    autoload :Base, 'gamefic/script/base'
-    autoload :File, 'gamefic/script/file'
-    autoload :Text, 'gamefic/script/text'
-  end
-
-end

data/lib/gamefic/script/base.rb

@@ -1,42 +0,0 @@
-module Gamefic
-
-  class Script::Base
-    def initialize
-      raise "#initialize must be defined in subclasses"
-    end
-
-    # Get the script's text.
-    # The text must be source code suitable for evaluation via Plot#stage.
-    #
-    # @return [String]
-    def read
-      raise "#read must be defined in subclasses"
-    end
-
-    # Get the script's path.
-    #
-    # @return [String]
-    def path
-      raise "#path must be defined in subclasses"
-    end
-
-    # Get the absolute path of the script's original file, or its URL for
-    # sources that are not file-based.
-    #
-    # @return [String]
-    def absolute_path
-      raise "#absolute_path must be defined in subclasses"
-    end
-
-    # Script objects are equal if their relative paths are the same. Note that
-    # they are still considered equal if their absolute paths are different,
-    # or even if they come from different types of sources.
-    #
-    # @param other[Script::Base]
-    # @return [Boolean]
-    def==(other)
-      path == other.path
-    end
-  end
-
-end