gamefic 2.4.0 → 3.0.0

data/lib/gamefic/world/playbook.rb

@@ -1,233 +0,0 @@
-require 'set'
-
-module Gamefic
-  module World
-    # A collection of rules for performing commands.
-    #
-    class Playbook
-      ActionHook = Struct.new(:verb, :block)
-
-      # An array of available syntaxes.
-      #
-      # @return [Array<Gamefic::Syntax>]
-      attr_reader :syntaxes
-
-      # An array of blocks to execute before actions.
-      #
-      # @return [Array<Proc>]
-      attr_reader :before_actions
-
-      # An array of blocks to execute after actions.
-      #
-      # @return [Array<Proc>]
-      attr_reader :after_actions
-
-      # @param commands [Hash]
-      # @param syntaxes [Array<Syntax>, Set<Syntax>]
-      # @param before_actions [Array]
-      # @param after_actions [Array]
-      def initialize commands: {}, syntaxes: [], before_actions: [], after_actions: []
-        @commands = commands
-        @syntax_set = syntaxes.to_set
-        sort_syntaxes
-        @before_actions = before_actions
-        @after_actions = after_actions
-      end
-
-      # An array of available actions.
-      #
-      # @return [Array<Gamefic::Action>]
-      def actions
-        @commands.values.flatten
-      end
-
-      # An array of recognized verbs.
-      #
-      # @return [Array<Symbol>]
-      def verbs
-        @commands.keys
-      end
-
-      # Add a proc to be evaluated before a character executes an action.
-      # When a verb is specified, the proc will only be evaluated if the
-      # action's verb matches it.
-      #
-      # @param verb [Symbol, nil]
-      # @yieldparam [Gamefic::Action]
-      def before_action verb = nil, &block
-        @before_actions.push ActionHook.new(verb, block)
-      end
-      alias validate before_action
-
-      # Add a proc to be evaluated after a character executes an action.
-      # When a verb is specified, the proc will only be evaluated if the
-      # action's verb matches it.
-      #
-      # @param verb [Symbol, nil]
-      # @yieldparam [Gamefic::Action]
-      def after_action verb = nil, &block
-        @after_actions.push ActionHook.new(verb, 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<Class<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 verb [Symbol] An imperative verb for the command
-      # @param queries [Array<Query::Base>] Filters for the command's tokens
-      # @yieldparam [Gamefic::Actor]
-      # @return [Class<Gamefic::Action>]
-      def respond(verb, *queries, &proc)
-        act = Action.subclass verb, *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 verb [Symbol] An imperative verb for the command
-      # @param queries [Array<Query::Base>] Filters for the command's tokens
-      # @yieldparam [Gamefic::Actor]
-      # @return [Class<Gamefic::Action>]
-      def meta(verb, *queries, &proc)
-        act = Action.subclass verb, *queries, meta: true, &proc
-        add_action act
-        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 input [String] The format of the original command
-      # @param translation [String] The format of the translated command
-      # @return [Syntax] the Syntax object
-      def interpret(input, translation)
-        syn = Syntax.new(input, translation)
-        add_syntax syn
-        syn
-      end
-
-      # Get a Dispatcher to select actions that can potentially be executed
-      # from the specified command string.
-      #
-      # @param actor [Actor]
-      # @param text [String]
-      # @return [Dispatcher]
-      def dispatch(actor, text)
-        commands = Syntax.tokenize(text, actor.syntaxes)
-        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,
-      # that the actor can potentially execute.
-      #
-      # @return [Array<Gamefic::Action>]
-      def dispatch_from_params actor, verb, params
-        available = actions_for(verb)
-        Dispatcher.new(actor, [Command.new(verb, params)], sort_and_reduce_actions(available))
-      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].push action
-        generate_default_syntax action
-      end
-
-      def generate_default_syntax action
-        user_friendly = action.verb.to_s.gsub(/_/, ' ')
-        args = []
-        used_names = []
-        action.queries.each do |_c|
-          num = 1
-          new_name = ":var"
-          while used_names.include? new_name
-            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
-        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, sort first word
-            b.first_word <=> a.first_word
-          else
-            b.token_count <=> a.token_count
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gamefic/world/players.rb

@@ -1,37 +0,0 @@
-module Gamefic
-  module World
-    module Players
-      include Gamefic::World::Entities
-      include Gamefic::World::Commands
-
-      # An array of entities that are currently connected to users.
-      #
-      # @return [Array<Gamefic::Actor>]
-      def players
-        @players ||= []
-      end
-
-      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 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

@@ -1,228 +0,0 @@
-module Gamefic
-  module World
-    module Scenes
-      include Commands
-      include Players
-
-      # @return [Class<Gamefic::Scene::Activity>]
-      def default_scene
-        @default_scene ||= Scene::Activity
-      end
-
-      # @return [Class<Gamefic::Scene::Conclusion>]
-      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::Actor]
-      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::Actor]
-      # @return [void]
-      def introduce(player)
-        player.playbooks.push playbook unless player.playbooks.include?(playbook)
-        player.cue default_scene
-        players.push player
-        @introduction&.call(player)
-      end
-
-      # Create a multiple-choice scene.
-      # The user will be required to make a valid choice to continue.
-      #
-      # @example
-      #   @scene = multiple_choice 'Go to work', 'Go to school' do |actor, scene|
-      #     # Assuming user selected the first choice:
-      #     scene.selection #=> 'Go to work'
-      #     scene.index     #=> 0
-      #     scene.number    #=> 1
-      #   end
-      #
-      # @yieldparam [Gamefic::Actor]
-      # @yieldparam [Gamefic::Scene::MultipleChoice]
-      # @return [Class<Gamefic::Scene::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.
-      #
-      # @example
-      #   @scene = yes_or_no 'What is your answer?' do |actor, scene|
-      #     if scene.yes?
-      #       actor.tell "You said yes."
-      #     else
-      #       actor.tell "You said no."
-      #     end
-      #   end
-      #
-      # @param prompt [String, nil]
-      # @yieldparam [Gamefic::Actor]
-      # @yieldparam [Gamefic::Scene::YesOrNo]
-      # @return [Class<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
-      #
-      # @param prompt [String]
-      # @yieldparam [Gamefic::Actor]
-      # @yieldparam [Gamefic::Scene::Base]
-      # @return [Class<Gamefic::Scene::Base>]
-      def question prompt = 'What is your answer?', &block
-        s = Scene::Base.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.
-      #
-      # @example
-      #   @scene = pause 'Continue' do |actor|
-      #     actor.tell "After you continue, you will be prompted for a command."
-      #     actor.prepare default_scene
-      #   end
-      #
-      # @param prompt [String, nil] The text to display when prompting the user to continue
-      # @yieldparam [Gamefic::Actor]
-      # @return [Class<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)
-        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.
-      #
-      # @example
-      #   @scene = conclusion do |actor|
-      #     actor.tell 'Game over'
-      #   end
-      #
-      # @yieldparam [Gamefic::Actor]
-      # @return [Class<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::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 |actor, scene|
-      #     scene.prompt = "What's your name?"
-      #     scene.on_finish do
-      #       actor.name = scene.input
-      #       actor.tell "Hello, #{actor.name}!"
-      #       actor.cue default_scene
-      #     end
-      #   end
-      #
-      # @param cls [Class<Scene::Base>] The class of scene to be instantiated.
-      # @yieldparam [Gamefic::Actor]
-      # @return [Class<Gamefic::Scene::Base>]
-      def custom cls = Scene::Base, &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::Actor]
-      # @yieldparam [Gamefic::Scene::MultipleScene]
-      # @return [Class<Gamefic::Scene::MultipleScene>]
-      def multiple_scene map = {}, &block
-        s = Scene::MultipleScene.subclass do |actor, scene|
-          map.each_pair do |k, v|
-            scene.map k, v
-          end
-          block&.call actor, scene
-        end
-        scene_classes.push s
-        s
-      end
-
-      # @return [Array<Class<Gamefic::Scene::Base>>]
-      def scene_classes
-        @scene_classes ||= []
-      end
-    end
-  end
-end

data/lib/gamefic/world.rb

@@ -1,18 +0,0 @@
-module Gamefic
-  # A collection of classes and modules related to generating a world model.
-  #
-  module World
-    autoload :Playbook,  'gamefic/world/playbook'
-    autoload :Entities,  'gamefic/world/entities'
-    autoload :Commands,  'gamefic/world/commands'
-    autoload :Callbacks, 'gamefic/world/callbacks'
-    autoload :Scenes,    'gamefic/world/scenes'
-    autoload :Players,   'gamefic/world/players'
-
-    include Entities
-    include Commands
-    include Callbacks
-    include Scenes
-    include Players
-  end
-end