gamefic 1.5.1 → 1.6.0

data/lib/gamefic/plot/entities.rb

@@ -10,7 +10,7 @@ module Gamefic
       #
       # @param cls [Class] The Class of the Entity to be created.
       # @param args [Hash] The entity's properties.
-      # @return [Entity]
+      # @return [Gamefic::Entity]
       def make cls, args = {}, &block
         ent = cls.new args, &block
         if ent.kind_of?(Entity) == false
@@ -42,8 +42,8 @@ module Gamefic
       #   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
+      # @param  description [String] The description of the entity
+      # @return [Gamefic::Entity] The entity that matches the description
       def pick(description)
         query = Gamefic::Query::Base.new
         result = query.match(description, entities)

data/lib/gamefic/plot/host.rb

@@ -12,10 +12,10 @@ module Gamefic
     
     # Start a new subplot based on the provided class.
     #
-    # @param [Class] The class of the subplot to be created (Subplot by default)
+    # @param subplot_class [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)
+    def branch subplot_class = Gamefic::Subplot, introduce: nil, next_cue: nil, busy_cue: nil
+      subplot = subplot_class.new(self, introduce: introduce, next_cue: next_cue, busy_cue: busy_cue)
       p_subplots.push subplot
       subplot
     end

data/lib/gamefic/plot/playbook.rb

@@ -35,11 +35,11 @@ module Gamefic
         end
       end
 
-      def disambiguate &block
-        @disambiguator = Action.new(nil, Query::Base.new, &block)
-        @disambiguator.meta = true
-        @disambiguator
-      end
+      #def disambiguate &block
+      #  @disambiguator = Action.new(nil, Query::Base.new, &block)
+      #  @disambiguator.meta = true
+      #  @disambiguator
+      #end
 
       def validate &block
         @validators.push block
@@ -72,11 +72,12 @@ module Gamefic
       #     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)
+      # @param verb [Symbol] An imperative verb for the command
+      # @param queries [Array<Query::Base>] Filters for the command's tokens
+      # @yieldparam [Gamefic::Character]
+      # @return [Gamefic::Action]
+      def respond(verb, *queries, &proc)
+        act = Action.subclass verb, *queries, order_key: raise_order_key, &proc
         add_action act
         act
       end
@@ -93,12 +94,12 @@ module Gamefic
       #     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
+      # @param verb [Symbol] An imperative verb for the command
+      # @param queries [Array<Query::Base>] Filters for the command's tokens
+      # @yieldparam [Gamefic::Character]
+      def meta(verb, *queries, &proc)
+        act = Action.subclass verb, *queries, meta: true, &proc
+        add_action act
         act
       end
 
@@ -113,15 +114,55 @@ module Gamefic
       #   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 input [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)
+      def interpret(input, translation)
+        syn = Syntax.new(input, translation)
         add_syntax syn
         syn
       end
 
+      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.sort! { |a,b|
+          if a.rank == b.rank
+            b.order_key <=> a.order_key
+          else
+            b.rank <=> a.rank
+          end
+        }
+        result.uniq{|a| a.class}
+      end
+
+      def dispatch_from_string actor, text
+        result = []
+        commands = Syntax.tokenize(text, syntaxes)
+        commands.each { |c|
+          available = actions_for(c.verb)
+          available.each { |a|
+            o = a.attempt(actor, c.arguments)
+            result.unshift o unless o.nil?
+          }
+        }
+        result
+      end
+
+      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)
+        }
+        result
+      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.
@@ -140,16 +181,11 @@ module Gamefic
 
       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
-        }
+        @commands[action.verb].push action
+        #@commands[action.verb].uniq!
+        #@commands[action.verb].sort! { |a, b|
+        #  b.rank <=> a.rank
+        #}
         generate_default_syntax action
       end
 
@@ -176,7 +212,7 @@ module Gamefic
           raise "No actions exist for \"#{syntax.verb}\""
         end
         @syntaxes.unshift syntax
-        @syntaxes.uniq
+        @syntaxes.uniq!
         @syntaxes.sort! { |a, b|
           if a.token_count == b.token_count
             # For syntaxes of the same length, length of action takes precedence
@@ -186,6 +222,14 @@ module Gamefic
           end
         }
       end
+
+      def raise_order_key
+        @order_key ||= 0
+        tmp = @order_key
+        @order_key += 1
+        tmp
+      end
+
     end
   end
 

data/lib/gamefic/plot/scenes.rb

@@ -0,0 +1,149 @@
+module Gamefic
+
+  module Plot::Scenes
+    def default_scene
+      @default_scene ||= Scene::Active
+    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.playbook = 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
+      Scene::MultipleChoice.subclass do |actor, scene|
+        scene.options.concat choices
+        scene.on_finish &block
+      end
+    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
+      Scene::YesOrNo.subclass do |actor, scene|
+        scene.prompt = prompt
+        scene.on_finish &block
+      end
+    end
+    
+    def question prompt = 'What is your answer?', &block
+      Scene::Custom.subclass do |actor, scene|
+        scene.prompt = prompt
+        scene.on_finish &block
+      end
+    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
+      Scene::Pause.subclass do |actor, scene|
+        scene.prompt = prompt unless prompt.nil?
+        block.call(actor, scene) unless block.nil?
+      end
+    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
+      Scene::Conclusion.subclass &block
+    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
+      cls.subclass &block
+    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
+    #
+    # @param map [Hash] A Hash of options and associated scene keys.
+    # @yieldparam [Gamefic::Character]
+    # @yieldparam [Gamefic::Scene::MultipleScene]
+    def multiple_scene map = {}, &block
+      Scene::MultipleScene.subclass do |actor, scene|
+        map.each_pair { |k, v|
+          scene.map k, v
+        }
+        block.call actor, scene unless block.nil?
+      end
+    end
+  end
+
+end

data/lib/gamefic/plot/snapshot.rb

@@ -20,13 +20,14 @@ module Gamefic
       end
       return {
         entities: store,
-        subplots: save_subplots
+        subplots: save_subplots,
+        metadata: metadata
       }
     end
     
     # Restore the plot to the state of the provided snapshot.
     #
-    # @param [Hash]
+    # @param snapshot [Hash]
     def restore snapshot
       restore_initial_state
       internal_restore snapshot[:entities]
@@ -47,36 +48,15 @@ module Gamefic
     
     def get_entity_hash
       store = []
-      index = 0
       entities.each { |e|
         hash = {}
-        e.serialized_attributes.each {|m|
-          con = m.to_s
-          if con.end_with?("?")
-            con = con[0..-2]
-          end
-          if e.respond_to?(m) == true
-            begin
-              val = e.send(m)
-              if val == false
-                hash[con] = false
-              elsif val
-                hash[con] = serialize_obj(val)
-              else
-                hash[con] = nil
-              end
-            rescue Exception => error
-              hash[con] = nil
-            end
-          end
+        e.instance_variables.each { |k|
+          next if k == :@children
+          v = e.instance_variable_get(k)
+          hash[k] = v
         }
         hash[:class] = e.class.to_s
-        hash[:session] = {}
-        e.session.each_pair { |k, v|
-          hash[:session][k] = serialize_obj(v)
-        }
-        store.push hash
-        index += 1
+        store.push serialize_object(hash)
       }
       store
     end
@@ -98,13 +78,8 @@ module Gamefic
       hash.each { |k, v|
         if k == :scene
           entities[index].cue v.to_sym
-        elsif (k != :session and k != :class)
-          entities[index].send("#{k}=", unserialize(v))
-        end
-        unless hash[:session].nil?
-          hash[:session].each_pair { |k, v|
-            entities[index].session[k.to_sym] = unserialize(v)
-          }
+        elsif (k != :class)
+          entities[index].instance_variable_set(k, unserialize(v))
         end
       }
       nil
@@ -135,7 +110,7 @@ module Gamefic
       false
     end
 
-    def serialize_obj obj
+    def serialize_object obj
       return nil if obj.nil?
       return false if obj == false
       if obj.kind_of?(Hash)
@@ -156,7 +131,7 @@ module Gamefic
       hash = {}
       obj.each_pair { |k, v|
         if can_serialize?(k) and can_serialize?(v)
-          hash[serialize_obj(k)] = serialize_obj(v)
+          hash[serialize_object(k)] = serialize_object(v)
         end
       }
       return hash
@@ -166,7 +141,7 @@ module Gamefic
       arr = []
       obj.each_index { |i|
         if can_serialize?(obj[i])
-          arr[i] = serialize_obj(obj[i])
+          arr[i] = serialize_object(obj[i])
         else
           raise "Bad array in snapshot"
         end
@@ -215,7 +190,7 @@ module Gamefic
         s.instance_variables.each { |k|
           v = s.instance_variable_get(k)
           if can_serialize?(v)
-            hash[k] = serialize_obj(v)
+            hash[k] = serialize_object(v)
           end
         }
         arr.push hash