gamefic 1.7.0 → 2.0.0

data/lib/gamefic/index.rb

@@ -0,0 +1,121 @@
+require 'json'
+
+module Gamefic
+  module Index
+    @@elements = []
+    @@stuck_length = 0
+
+    def initialize **data
+      data.each_pair do |k, v|
+        public_send "#{k}=", v
+      end
+      @@elements.push self
+    end
+
+    def to_serial
+      index = @@elements.index(self)
+      raise RuntimeError, "#{self} is not an indexed element" unless index
+      "#<ELE_#{index}>"
+    end
+
+    def destroy
+      @@elements.delete self unless Index.stuck?(self)
+    end
+
+    def self.elements
+      @@elements
+    end
+
+    def self.serials
+      result = []
+      @@elements.each do |e|
+        d = {}
+        d['class'] = e.class.to_s
+        e.instance_variables.each do |k|
+          v = e.instance_variable_get(k)
+          d[k] = v.to_serial
+        end
+        result.push d
+      end
+      result
+    end
+
+    def self.from_serial serial
+      if serial.is_a?(Hash) && serial['class']
+        klass = eval(serial['class'])
+        object = klass.allocate
+        serial.each_pair do |k, v|
+          next unless k.to_s.start_with?('@')
+          object.instance_variable_set(k, from_serial(v))
+        end
+        object
+      elsif serial.is_a?(Numeric)
+        serial
+      elsif serial.is_a?(String)
+        match = serial.match(/#<ELE_([0-9]+)>/)
+        return Gamefic::Index.elements[match[1].to_i] if match
+        match = serial.match(/#<SYM:([a-z0-9_\?\!]+)>/i)
+        return match[1].to_sym if match
+        serial
+      elsif serial.is_a?(Array)
+        result = serial.map { |e| from_serial(e) }
+        result = "#<UNKNOWN>" if result.any? { |e| e == "#<UNKNOWN>" }
+        result
+      elsif serial.is_a?(Hash)
+        result = {}
+        unknown = false
+        serial.each_pair do |k, v|
+          k2 = from_serial(k)
+          v2 = from_serial(v)
+          if k2 == "#<UNKNOWN>" || v2 == "#<UNKNOWN>"
+            unknown = true
+            break
+          end
+          result[k2] = v2
+        end
+        result = "#<UNKNOWN>" if unknown
+        result
+      elsif serial && serial != true
+        STDERR.puts "Unable to unserialize #{serial.class}"
+        nil
+      else
+        # true, false, or nil
+        serial
+      end
+    end
+
+    def self.unserialize serials
+      serials.each_with_index do |s, i|
+        next if elements[i]
+        klass = eval(s['class'])
+        klass.new
+      end
+      serials.each_with_index do |s, i|
+        s.each_pair do |k, v|
+          next unless k.to_s.start_with?('@')
+          next if v == "#<UNKNOWN>"
+          elements[i].instance_variable_set(k, from_serial(v))
+        end
+      end
+      elements
+    end
+
+    def self.stick
+      @@stuck_length = @@elements.length
+    end
+
+    def self.stuck
+      @@stuck_length
+    end
+
+    def self.clear
+      @@stuck_length = 0
+      @@elements.clear
+    end
+
+    def self.stuck? thing
+      index = @@elements.index(thing)
+      index && index <= @@stuck_length - 1
+    end
+  end
+end

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,44 +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]*/, ' ')
-      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,133 +1,113 @@
-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
+    # @return [Hash]
+    attr_reader :metadata
 
-    # TODO: Metadata could use better protection
-    attr_accessor :metadata
-    include Theater
-    include Gamefic, Tester, Players, Scenes, Commands, Entities
-    include Articles, YouMount, Snapshot, Host, Callbacks
+    include World
+    include Scriptable
+    # @!parse extend Scriptable::ClassMethods
+    include Snapshot
+    include Host
 
-    # @param source [Source::Base]
-    def initialize(source = nil)
-      @source = source || Source::Text.new({})
-      @working_scripts = []
-      @imported_scripts = []
-      @running = false
-      post_initialize
+    # @param structure [Gamefic::Structure]
+    # @param metadata [Hash]
+    def initialize metadata: {}
+      Gamefic::Index.clear
+      @metadata = metadata
+      run_scripts
+      mark_static_entities
+      Gamefic::Index.stick
     end
 
     def player_class cls = nil
       @player_class = cls unless cls.nil?
-      @player_class
-    end
-
-    # @return [Gamefic::Plot::Playbook]
-    def playbook
-      @playbook ||= Gamefic::Plot::Playbook.new
+      @player_class ||= Gamefic::Actor
     end
 
-    def running?
-      @running
-    end
-
-    # 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?
-    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 the initial state to make sure it's set
-      initial_state
       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
+          })
+          .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|
+      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
-      }
-      p_entities.each { |e| e.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.each { |s| s.update unless s.concluded? }
+      subplots.delete_if { |s| s.concluded? }
     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