gamefic 1.7.0 → 2.1.0

data/lib/gamefic/plot/callbacks.rb

@@ -1,126 +0,0 @@
-module Gamefic
-
-  module Plot::Callbacks    
-    # Add a block to be executed on preparation of every turn.
-    #
-    # @example Increment a turn counter
-    #   turn = 0
-    #   on_ready do
-    #     turn += 1
-    #   end
-    #
-    def on_ready &block
-      p_ready_procs.push block
-    end
-
-    # Add a block to be executed after the Plot is finished updating a turn.
-    #
-    def on_update &block
-      p_update_procs.push block
-    end
-
-    # Add a block to be executed for each player at the beginning of a turn.
-    #
-    # @example Tell the player how many turns they've played.
-    #   on_player_ready do |player|
-    #     player[:turns] ||= 0
-    #     if player[:turns] > 0
-    #       player.tell "Turn #{player[:turns]}"
-    #     end
-    #     player[:turns] += 1
-    #   end
-    #
-    # @yieldparam [Gamefic::Performance]
-    def on_player_ready &block
-      p_player_ready_procs.push block
-    end
-
-    # Add a block to be executed for each player before an update.
-    #
-    # @yieldparam[Character]
-    def before_player_update &block
-      p_before_player_update_procs.push block
-    end
-
-    # Add a block to be executed for each player at the end of a turn.
-    #
-    # @yieldparam [Character]
-    def on_player_update &block
-      p_player_update_procs.push block
-    end
-
-    private
-
-    # Execute the on_ready blocks. This method is typically called by the
-    # Plot while beginning a turn.
-    #
-    def call_ready
-      p_ready_procs.each { |p| p.call }
-    end
-
-    # Execute the on_update blocks. This method is typically called by the
-    # Plot while ending a turn.
-    #
-    def call_update
-      p_update_procs.each { |p| p.call }
-    end
-
-    # Execute the before_player_update blocks for each player. This method is
-    # typically called by the Plot while updating a turn, immediately before
-    # processing player input.
-    #
-    def call_before_player_update
-      p_players.each { |player|
-        player.flush
-        p_before_player_update_procs.each { |block| block.call player }
-      }
-    end
-
-    # Execute the on_player_ready blocks for each player. This method is
-    # typically called by the Plot while beginning a turn, immediately after
-    # the on_ready blocks.
-    #
-    def call_player_ready
-      p_players.each { |player|
-        unless player.next_scene.nil?
-          player.cue player.next_scene
-        end
-        player.cue default_scene if player.scene.nil?
-        #player.prepare nil
-        #player.cue this_scene #unless player.scene.class == this_scene
-        p_player_ready_procs.each { |block| block.call player }
-      }
-    end
-
-    # Execute the on_player_update blocks for each player. This method is
-    # typically called by the Plot while ending a turn, immediately before the
-    # on_ready blocks.
-    #
-    def call_player_update
-      p_players.each { |player|
-        p_player_update_procs.each { |block| block.call player }
-      }
-    end
-
-    def p_ready_procs
-      @p_ready_procs ||= []
-    end
-
-    def p_update_procs
-      @p_update_procs ||= []
-    end
-
-    def p_before_player_update_procs
-      @p_before_player_update_procs ||= []
-    end
-
-    def p_player_ready_procs
-      @p_player_ready_procs ||= []
-    end
-
-    def p_player_update_procs
-      @p_player_update_procs ||= []
-    end
-  end
-
-end

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