gamefic 1.6.0 → 2.0.3

data/lib/gamefic/{matchable.rb → keywords.rb}

@@ -1,50 +1,52 @@
-module Gamefic
-  module Matchable
-    SPLIT_REGEXP = /[\s]+/
-
-    # Get an array of keywords associated with this object.
-    # The default implementation splits the value of self.to_s into an array.
-    #
-    # @return [Array<String>]
-    def keywords
-      self.to_s.downcase.split(SPLIT_REGEXP).uniq
-    end
-
-    # Determine if this object matches the provided description.
-    # In a regular match, every word in the description must be a keyword.
-    # Fuzzy matches accept words if a keyword starts with it, e.g., "red"
-    # would be a fuzzy match for "reddish."
-    #
-    # @example
-    #   dog = "big red dog"
-    #   dog.extend Gamefic::Matchable
-    #
-    #   dog.match?("red dog")  #=> true
-    #   dog.match?("gray dog") #=> false
-    #   dog.match?("red do")   #=> false
-    #
-    #   dog.match?("re do", fuzzy: true)  #=> true
-    #   dog.match?("red og", fuzzy: true) #=> false
-    #
-    # @return [Boolean]
-    def match? description, fuzzy: false
-      words = description.split(SPLIT_REGEXP)
-      return false if words.empty?
-      matches = 0
-      available = keywords
-      words.each { |w|
-        if fuzzy
-          available.each { |k|
-            if k.gsub(/[^a-z0-9]/, '').start_with?(w.downcase.gsub(/[^a-z0-9]/, ''))
-              matches +=1
-              break
-            end
-          }
-        else
-          matches +=1 if available.include?(w.downcase)
-        end
-      }
-      matches == words.length
-    end
-  end
-end
+module Gamefic
+  module Keywords
+    SPLIT_REGEXP = /[\s]+/
+
+    # Get an array of keywords associated with this object.
+    # The default implementation splits the value of self.to_s into an array.
+    #
+    # @return [Array<String>]
+    def keywords
+      self.to_s.downcase.split(SPLIT_REGEXP).uniq
+    end
+
+    # Determine if this object matches the provided description.
+    # In a regular match, every word in the description must be a keyword.
+    # Fuzzy matches accept words if a keyword starts with it, e.g., "red"
+    # would be a fuzzy match for "reddish."
+    #
+    # @example
+    #   dog = "big red dog"
+    #   dog.extend Gamefic::Matchable
+    #
+    #   dog.specified?("red dog")  #=> true
+    #   dog.specified?("gray dog") #=> false
+    #   dog.specified?("red do")   #=> false
+    #
+    #   dog.specified?("re do", fuzzy: true)  #=> true
+    #   dog.specified?("red og", fuzzy: true) #=> false
+    #
+    # @param description [String] The description to be compared
+    # @param fuzzy [Boolean] Use fuzzy matching (default is false)
+    # @return [Boolean]
+    def specified? description, fuzzy: false
+      words = description.split(SPLIT_REGEXP)
+      return false if words.empty?
+      matches = 0
+      available = keywords
+      words.each { |w|
+        if fuzzy
+          available.each { |k|
+            if k.gsub(/[^a-z0-9]/, '').start_with?(w.downcase.gsub(/[^a-z0-9]/, ''))
+              matches +=1
+              break
+            end
+          }
+        else
+          matches +=1 if available.include?(w.downcase)
+        end
+      }
+      matches == words.length
+    end
+  end
+end

data/lib/gamefic/messaging.rb

@@ -1,45 +1,43 @@
-module Gamefic
-  module Messaging
-    # Send a message to the entity.
-    # This method will automatically wrap the message in HTML paragraphs.
-    # To send a message without paragraph formatting, use #stream instead.
-    #
-    # @param message [String]
-    def tell(message)
-      message = "<p>#{message.strip}</p>"
-      # This method uses String#gsub instead of String#gsub! for
-      # compatibility with Opal.
-      message = message.gsub(/[ \t\r]*\n[ \t\r]*\n[ \t\r]*/, '</p><p>')
-      message = message.gsub(/[ \t]*\n[ \t]*/, ' ')
-      #user.send message
-      p_set_messages messages + message
-    end
-
-    # Send a message to the Character as raw text.
-    # Unlike #tell, this method will not wrap the message in HTML paragraphs.
-    #
-    # @param message [String]
-    def stream(message)
-      p_set_messages messages + message.strip
-    end
-
-    # @return [String]
-    def messages
-      @messages ||= ''
-    end
-    
-    def output
-      messages
-    end
-
-    def flush
-      p_set_messages '' unless messages.empty?
-    end
-
-    private
-
-    def p_set_messages str
-      @messages = str
-    end
-  end
-end
+module Gamefic
+  module Messaging
+    # Send a message to the entity.
+    # This method will automatically wrap the message in HTML paragraphs.
+    # To send a message without paragraph formatting, use #stream instead.
+    #
+    # @param message [String]
+    def tell(message)
+      @messages = @messages.to_s + format(message)
+    end
+
+    # Send a message to the Character as raw text.
+    # Unlike #tell, this method will not wrap the message in HTML paragraphs.
+    #
+    # @param message [String]
+    def stream(message)
+      @messages = @messages.to_s + message
+    end
+
+    # Get all the currently buffered messages consolidated in a single string.
+    #
+    # @return [String]
+    def messages
+      @messages ||= ''
+    end
+
+    # Clear the buffered messages.
+    #
+    def flush
+      @messages = ''
+    end
+
+    private
+
+    def format message
+      "<p>#{message.strip}</p>"
+        .gsub(/[ \t\r]*\n[ \t\r]*\n[ \t\r]*/, "</p><p>")
+        .gsub(/[ \t]*\n[ \t]*/, ' ')
+        .gsub(/<p>[\s]*<p>/, '<p>')
+        .gsub(/<\/p>[\s]*<\/p>/, '</p>')
+    end
+  end
+end

data/lib/gamefic/node.rb

@@ -1,31 +1,37 @@
 # Exception raised when setting a node's parent would cause
 # a circular reference, e.g., A -> A or A -> B -> A
-class CircularNodeReferenceError < Exception
-end
+class CircularNodeReferenceError < RuntimeError; end
 
 module Gamefic
-
   module Node
+    # An array of the object's children.
+    #
     # @return [Array]
     def children
       @children ||= []
       @children.clone
     end
 
+    # Get a flat array of all descendants.
+    #
     # @return [Array]
     def flatten
       array = Array.new
       children.each { |child|
         array = array + recurse_flatten(child)
       }
-      return array
+      array
     end
 
+    # The object's parent.
+    #
     # @return [Object]
     def parent
       @parent
     end
 
+    # Set the object's parent.
+    #
     def parent=(node)
       return if node == @parent 
       if node == self
@@ -49,6 +55,10 @@ module Gamefic
       end
     end
 
+    # Determine if external objects can interact with this object's children.
+    # For example, a game can designate that the contents of a bowl are
+    # accessible, while the contents of a locked safe are not.
+    #
     # @return [Boolean]
     def accessible?
       true
@@ -81,5 +91,4 @@ module Gamefic
       return array
     end
   end
-
 end

data/lib/gamefic/plot.rb

@@ -1,123 +1,111 @@
-# TODO: JSON support is currently experimental.
-#require 'gamefic/entityloader'
-require 'gamefic/tester'
-require 'gamefic/source'
-require 'gamefic/script'
 require 'gamefic/query'
 
 module Gamefic
-
+  # A plot controls the game narrative and manages the world model.
+  # Authors typically build plots through scripts that are executed in a
+  # special container called a stage. All of the elements that compose the
+  # narrative (characters, locations, scenes, etc.) reside in the stage's
+  # scope. Game engines use the plot to receive game data and process user
+  # input.
+  #
   class Plot
-    autoload :Scenes,    'gamefic/plot/scenes'
-    autoload :Commands,  'gamefic/plot/commands'
-    autoload :Entities,  'gamefic/plot/entities'
-    autoload :Articles,  'gamefic/plot/articles'
-    autoload :YouMount,  'gamefic/plot/you_mount'
     autoload :Snapshot,  'gamefic/plot/snapshot'
+    autoload :Darkroom,  'gamefic/plot/darkroom'
     autoload :Host,      'gamefic/plot/host'
-    autoload :Players,   'gamefic/plot/players'
-    autoload :Playbook,  'gamefic/plot/playbook'
-    autoload :Callbacks, 'gamefic/plot/callbacks'
-    autoload :Theater,   'gamefic/plot/theater'
 
-    attr_reader :commands, :imported_scripts, :source
-    # TODO: Metadata could use better protection
-    attr_accessor :metadata
-    include Theater
-    include Gamefic, Tester, Players, Scenes, Commands, Entities
-    include Articles, YouMount, Snapshot, Host, Callbacks
+    # @return [Hash]
+    attr_reader :metadata
 
-    # @param source [Source::Base]
-    def initialize(source = nil)
-      @source = source || Source::Text.new({})
-      @working_scripts = []
-      @imported_scripts = []
-      @running = false
-      post_initialize
-    end
+    attr_reader :static
 
-    # @return [Gamefic::Plot::Playbook]
-    def playbook
-      @playbook ||= Gamefic::Plot::Playbook.new
-    end
+    include World
+    include Scriptable
+    # @!parse extend Scriptable::ClassMethods
+    include Snapshot
+    include Host
+    include Serialize
 
-    def running?
-      @running
-    end
+    exclude_from_serial [:@static]
 
-    # Get an Array of all scripts that have been imported into the Plot.
-    #
-    # @return [Array<Script>] The imported scripts
-    def imported_scripts
-      @imported_scripts ||= []
-    end
-    
-    def post_initialize
-      # TODO: Should this method be required by extended classes?
+    # @param metadata [Hash]
+    def initialize metadata: {}
+      @metadata = metadata
+      run_scripts
+      @static = [self] + scene_classes + entities
     end
-    
+
     # Get an Array of the Plot's current Syntaxes.
     #
     # @return [Array<Syntax>]
     def syntaxes
       playbook.syntaxes
     end
-    
+
     # Prepare the Plot for the next turn of gameplay.
-    # This method is typically called by the Engine that manages game execution.
+    # This method is typically called by the Engine that manages game
+    # execution.
+    #
     def ready
       playbook.freeze
-      @running = true
       call_ready
       call_player_ready
-      p_subplots.each { |s| s.ready }
+      subplots.each { |s| s.ready }
+      players.each do |p|
+        p.state.replace(
+          p.scene.state
+          .merge({
+            messages: p.messages,
+            last_prompt: p.last_prompt,
+            last_input: p.last_input,
+            queue: p.queue
+          })
+          .merge(p.state)
+        )
+        p.output.replace(p.state)
+        p.state.clear
+      end
     end
-    
+
     # Update the Plot's current turn of gameplay.
-    # This method is typically called by the Engine that manages game execution.
+    # This method is typically called by the Engine that manages game
+    # execution.
+    #
     def update
       entities.each { |e| e.flush }
       call_before_player_update
-      p_players.each { |p| p.scene.update }
-      p_entities.each { |e| e.update }
+      players.each do |p|
+        p.performed nil
+        next unless p.scene
+        p.last_input = p.queue.last
+        p.last_prompt = p.scene.prompt
+        p.scene.update
+        if p.scene.is_a?(Scene::Conclusion)
+          player_conclude_procs.each do |proc|
+            proc.call p
+          end
+        end
+      end
       call_player_update
       call_update
-      p_subplots.each { |s| s.update unless s.concluded? }
-      p_subplots.delete_if { |s| s.concluded? }
+      subplots.delete_if(&:concluded?)
+      subplots.each(&:update)
     end
 
-    def tell entities, message, refresh = false
+    # Send a message to a group of entities.
+    #
+    # @param entities [Array<Entity>]
+    # @param message [String]
+    def tell entities, message
       entities.each { |entity|
-        entity.tell message, refresh
+        entity.tell message
       }
     end
-
-    # Load a script into the current Plot.
-    # This method is similar to Kernel#require, except that the script is
-    # evaluated within the Plot's context via #stage.
-    #
-    # @param path [String] The path to the script being evaluated
-    # @return [Boolean] true if the script was loaded by this call or false if it was already loaded.
-    def script path
-      imported_script = source.export(path)
-      if imported_script.nil?
-        raise LoadError.new("cannot load script -- #{path}")
-      end
-      if !@working_scripts.include?(imported_script) and !imported_scripts.include?(imported_script)
-        @working_scripts.push imported_script
-        # @hack Arguments need to be in different order if source returns proc
-        if imported_script.read.kind_of?(Proc)
-          stage &imported_script.read
-        else
-          stage imported_script.read, imported_script.absolute_path
-        end
-        @working_scripts.pop
-        imported_scripts.push imported_script
-        true
-      else
-        false
-      end
-    end    
   end
+end
 
+module Gamefic
+  # @yieldself [Gamefic::Plot]
+  def self.script &block
+    Gamefic::Plot.script &block
+  end
 end

data/lib/gamefic/plot/darkroom.rb

@@ -0,0 +1,80 @@
+module Gamefic
+  # Create and restore plot snapshots.
+  #
+  class Plot
+    class Darkroom
+      # @return [Gamefic::Plot]
+      attr_reader :plot
+
+      def initialize plot
+        @plot = plot
+      end
+
+      # Create a snapshot of the plot.
+      #
+      # @return [Hash]
+      def save
+        index = plot.static + plot.players
+        plot.to_serial(index)
+        {
+          'program' => {}, # @todo Metadata for version control, etc.
+          'index' => index.map do |i|
+            if i.is_a?(Gamefic::Serialize)
+              {
+                'class' => i.class.to_s,
+                'ivars' => i.serialize_instance_variables(index)
+              }
+            else
+              i.to_serial(index)
+            end
+          end
+        }
+      end
+
+      # Restore a snapshot.
+      #
+      # @param snapshot [Hash]
+      def restore snapshot
+        # @todo Use `program` for verification
+
+        plot.subplots.each(&:conclude)
+        plot.subplots.clear
+
+        index = plot.static + plot.players
+        snapshot['index'].each_with_index do |obj, idx|
+          next if index[idx]
+          elematch = obj['class'].match(/^#<ELE_([\d]+)>$/)
+          if elematch
+            klass = index[elematch[1].to_i]
+          else
+            klass = Gamefic::Serialize.string_to_constant(obj['class'])
+          end
+          index.push klass.allocate
+        end
+
+        snapshot['index'].each_with_index do |obj, idx|
+          if index[idx].class.to_s != obj['class']
+            STDERR.puts "MISMATCH: #{index[idx].class} is not #{obj['class']}"
+            STDERR.puts obj.inspect
+          end
+          obj['ivars'].each_pair do |k, v|
+            next if k == '@subplots'
+            uns = v.from_serial(index)
+            next if uns == "#<UNKNOWN>"
+            index[idx].instance_variable_set(k, uns)
+          end
+          if index[idx].is_a?(Gamefic::Subplot)
+            index[idx].extend Gamefic::Scriptable
+            index[idx].instance_variable_set(:@theater, nil)
+            index[idx].send(:run_scripts)
+            index[idx].players.each do |pl|
+              pl.playbooks.push index[idx].playbook unless pl.playbooks.include?(index[idx].playbook)
+            end
+            index[idx].instance_variable_set(:@static, [index[idx]] + index[idx].scene_classes + index[idx].entities)
+            plot.subplots.push index[idx]
+          end
+        end
+      end
+    end
+  end
+end