gamefic 2.0.0 → 2.1.1

data/lib/gamefic/plot/snapshot.rb

@@ -2,18 +2,26 @@ require 'json'
 
 module Gamefic
   module Plot::Snapshot
+    # Save the current game state as a data hash.
+    # See Gamefic::Plot::Darkroom for more information about
+    # the data format.
+    #
     # @return [Hash]
     def save
       Gamefic::Plot::Darkroom.new(self).save
     end
 
+    # Restore the game state from a snapshot.
+    #
+    # If `snapshot` is a string, parse it as a JSON object.
+    #
+    # @note The string conversion is performed as a convenience for web apps.
+    #
+    # @param snapshot [Hash, String]
+    # @return [void]
     def restore snapshot
-      snapshot = JSON.parse(snapshot, symbolize_names: false) if snapshot.is_a?(String)
-      # HACK: Force conclusion of current subplots
-      subplots.each { |s| s.conclude }
-      subplots.clear
+      snapshot = JSON.parse(snapshot) if snapshot.is_a?(String)
       Gamefic::Plot::Darkroom.new(self).restore(snapshot)
-      entities.each { |e| e.flush }
     end
   end
 end

data/lib/gamefic/query.rb

@@ -5,6 +5,7 @@ module Gamefic
     autoload :Descendants, 'gamefic/query/descendants'
     autoload :External, 'gamefic/query/external'
     autoload :Family, 'gamefic/query/family'
+    autoload :Tree, 'gamefic/query/tree'
     autoload :Itself, 'gamefic/query/itself'
     autoload :Matches, 'gamefic/query/matches'
     autoload :Parent, 'gamefic/query/parent'

data/lib/gamefic/query/base.rb

@@ -55,13 +55,18 @@ module Gamefic
         result.include?(object)
       end
 
+      # A ranking of how precise the query's arguments are.
+      #
+      # Query precision is a factor in calculating Action#rank.
+      #
+      # @return [Integer]
       def precision
         if @precision.nil?
           @precision = 1
           arguments.each { |a|
-            if a.kind_of?(Class)
+            if a.is_a?(Class)
               @precision += 100
-            elsif a.kind_of?(Gamefic::Entity)
+            elsif a.is_a?(Gamefic::Entity)
               @precision += 1000
             end
           }
@@ -69,10 +74,7 @@ module Gamefic
         end
         @precision
       end
-
-      def rank
-        precision
-      end
+      alias rank precision
 
       def signature
         "#{self.class.to_s.split('::').last.downcase}(#{simplify_arguments.join(', ')})"
@@ -83,18 +85,18 @@ module Gamefic
       # @return [Boolean]
       def accept?(entity)
         result = true
-        arguments.each { |a|
-          if a.kind_of?(Symbol)
-            result = (entity.send(a) != false)
-          elsif a.kind_of?(Regexp)
-            result = (!entity.to_s.match(a).nil?)
-          elsif a.is_a?(Module) or a.is_a?(Class)
-            result = (entity.is_a?(a))
+        arguments.each do |a|
+          result = if a.is_a?(Symbol)
+            (entity.send(a) != false)
+          elsif a.is_a?(Regexp)
+            !entity.to_s.match(a).nil?
+          elsif a.is_a?(Module) || a.is_a?(Class)
+            entity.is_a?(a)
           else
-            result = (entity == a)
+            (entity == a)
           end
           break if result == false
-        }
+        end
         result
       end
 
@@ -109,10 +111,10 @@ module Gamefic
         return [] if entity.nil?
         result = []
         if entity.accessible?
-          entity.children.each { |c|
+          entity.children.each do |c|
             result.push c
             result.concat subquery_accessible(c)
-          }
+          end
         end
         result
       end
@@ -121,7 +123,7 @@ module Gamefic
 
       def simplify_arguments
         arguments.map do |a|
-          if a.kind_of?(Class) or a.kind_of?(Object)
+          if a.is_a?(Class) || a.is_a?(Object)
             a.to_s.split('::').last.downcase
           else
             a.to_s.downcase
@@ -136,13 +138,12 @@ module Gamefic
       def denest(objects, token)
         parts = token.split(NEST_REGEXP)
         current = parts.pop
-        last_result = objects.select{ |e| e.specified?(current) }
-        last_result = objects.select{ |e| e.specified?(current, fuzzy: true) } if last_result.empty?
-        result = last_result
-        while parts.length > 0
+        last_result = objects.select { |e| e.specified?(current) }
+        last_result = objects.select { |e| e.specified?(current, fuzzy: true) } if last_result.empty?
+        until parts.empty?
           current = "#{parts.last} #{current}"
-          result = last_result.select{ |e| e.specified?(current) }
-          result = last_result.select{ |e| e.specified?(current, fuzzy: true) } if result.empty?
+          result = last_result.select { |e| e.specified?(current) }
+          result = last_result.select { |e| e.specified?(current, fuzzy: true) } if result.empty?
           break if result.empty?
           parts.pop
           last_result = result

data/lib/gamefic/query/descendants.rb

@@ -5,9 +5,9 @@ module Gamefic
         result = []
         children = super
         result.concat children
-        children.each { |c|
+        children.each do |c|
           result.concat subquery_accessible(c)
-        }
+        end
         result
       end
     end

data/lib/gamefic/query/family.rb

@@ -1,5 +1,7 @@
 module Gamefic
   module Query
+    # Query to retrieve the subject's siblings and all accessible descendants.
+    #
     class Family < Base
       def context_from(subject)
         result = []

data/lib/gamefic/query/text.rb

@@ -2,14 +2,15 @@ module Gamefic
   module Query
     class Text < Base
       def initialize *arguments
-        arguments.each { |a|
-          if (a.kind_of?(Symbol) or a.kind_of?(String)) and !a.to_s.end_with?('?')
+        arguments.each do |a|
+          if (a.kind_of?(Symbol) || a.kind_of?(String)) && !a.to_s.end_with?('?')
             raise ArgumentError.new("Text query arguments can only be boolean method names (:method?) or regular expressions")
           end
-        }
+        end
         super
       end
-      def resolve(subject, token, continued: false)
+
+      def resolve _subject, token, continued: false
         return Matches.new([], '', token) unless accept?(token)
         parts = token.split(Keywords::SPLIT_REGEXP)
         cursor = []
@@ -22,20 +23,18 @@ module Gamefic
         }
         if continued
           Matches.new([matches.join(' ')], matches.join(' '), parts[i..-1].join(' '))
+        elsif matches.length == parts.length
+          Matches.new([matches.join(' ')], matches.join(' '), '')
         else
-          if matches.length == parts.length
-            Matches.new([matches.join(' ')], matches.join(' '), '')
-          else
-            Matches.new([], '', parts.join(' '))
-          end
+          Matches.new([], '', parts.join(' '))
         end
       end
 
-      def include?(subject, token)
+      def include? _subject, token
         accept?(token)
       end
 
-      def accept?(entity)
+      def accept? entity
         return false unless entity.kind_of?(String) and !entity.empty?
         super
       end

data/lib/gamefic/query/tree.rb

@@ -0,0 +1,17 @@
+module Gamefic
+  module Query
+    # Query to retrieve all of the subject's ancestors, siblings, and descendants.
+    #
+    class Tree < Family
+      def context_from(subject)
+        result = super
+        parent = subject.parent
+        until parent.nil?
+          result.unshift parent
+          parent = parent.parent
+        end
+        result
+      end
+    end
+  end
+end

data/lib/gamefic/scene.rb

@@ -1,7 +1,6 @@
 module Gamefic
   module Scene
     autoload :Base, 'gamefic/scene/base'
-    autoload :Custom, 'gamefic/scene/custom'
     autoload :Activity, 'gamefic/scene/activity'
     autoload :Pause, 'gamefic/scene/pause'
     autoload :Conclusion, 'gamefic/scene/conclusion'

data/lib/gamefic/scene/base.rb

@@ -1,8 +1,13 @@
 module Gamefic
-  # The Base Scene is not intended for instantiation. Other Scene classes
-  # should inherit from it.
+  # An abstract class for building different types of scenes. It can be
+  # extended either through concrete subclasses or by creating anonymous
+  # subclasses through a scene helper method like
+  # `Gamefic::World::Scenes#custom`.
   #
   class Scene::Base
+    include Gamefic::Serialize
+    extend Gamefic::Serialize
+
     # The scene's primary actor.
     #
     # @return [Gamefic::Actor]

data/lib/gamefic/scene/conclusion.rb

@@ -1,7 +1,7 @@
 module Gamefic
   # A Conclusion ends the Plot (or the character's participation in it).
   #
-  class Scene::Conclusion < Scene::Custom
+  class Scene::Conclusion < Scene::Base
     def type
       @type ||= 'Conclusion'
     end

data/lib/gamefic/scene/multiple_choice.rb

@@ -6,7 +6,7 @@ module Gamefic
   # The finish block's input parameter receives a MultipleChoice::Input object
   # instead of a String.
   #
-  class Scene::MultipleChoice < Scene::Custom
+  class Scene::MultipleChoice < Scene::Base
     # The zero-based index of the selected option.
     #
     # @return [Integer]
@@ -14,7 +14,7 @@ module Gamefic
 
     # The one-based index of the selected option.
     #
-    # @return [Number]
+    # @return [Integer]
     attr_reader :number
 
     # The full text of the selected option.
@@ -33,7 +33,6 @@ module Gamefic
       get_choice
       if selection.nil?
         actor.tell invalid_message
-        tell_options
       else
         super
       end
@@ -77,14 +76,5 @@ module Gamefic
         }
       end
     end
-
-    def tell_options
-      list = '<ol class="multiple_choice">'
-      options.each { |o|
-        list += "<li><a href=\"#\" rel=\"gamefic\" data-command=\"#{o}\">#{o}</a></li>"
-      }
-      list += "</ol>"
-      actor.tell list
-    end
   end
 end

data/lib/gamefic/scene/pause.rb

@@ -1,7 +1,7 @@
 module Gamefic
   # Pause for user input.
   #
-  class Scene::Pause < Scene::Custom
+  class Scene::Pause < Scene::Base
     def post_initialize
       self.type = 'Pause'
       self.prompt = 'Press enter to continue...'

data/lib/gamefic/scene/yes_or_no.rb

@@ -4,7 +4,7 @@ module Gamefic
   # block. After the scene is finished, the :active scene will be cued if no
   # other scene has been prepared or cued.
   #
-  class Scene::YesOrNo < Scene::Custom
+  class Scene::YesOrNo < Scene::Base
     attr_writer :invalid_message
 
     def post_initialize

data/lib/gamefic/scriptable.rb

@@ -80,6 +80,7 @@ Gamefic::Scriptable.module_exec do
           instance.public_send :public_send, symbol, *args, &block
         end
       end
+      theater.extend Gamefic::Serialize
       theater
     end
   end

data/lib/gamefic/serialize.rb

@@ -1,15 +1,68 @@
+require 'set'
+
 module Gamefic
   module Serialize
-    def to_serial
-      {
-        'class' => self.class.to_s
-      }.merge serialize_instance_variables
+    def to_serial(index = [])
+      if index.include?(self)
+        {
+          'instance' => "#<ELE_#{index.index(self)}>",
+          'ivars' => {}
+        }
+      else
+        if self.class == Class && self.name
+          {
+            'class' => 'Class',
+            'name' => name
+          }
+        else
+          index.push self if self.is_a?(Gamefic::Serialize)
+          {
+            'class' => serialized_class(index),
+            'ivars' => serialize_instance_variables(index)
+          }
+        end
+      end
+    end
+
+    def serialized_class index
+      if index.include?(self.class)
+        "#<ELE_#{index.index(self.class)}>"
+      else
+        self.class.to_s
+      end
+    end
+
+    def self.instances
+      GC.start
+      result = []
+      ObjectSpace.each_object(Gamefic::Serialize) { |obj| result.push obj }
+      result
+    end
+
+    # @param string [String]
+    # @return [Object]
+    def self.string_to_constant string
+      space = Object
+      string.split('::').each do |part|
+        space = space.const_get(part)
+      end
+      space
     end
   end
 end
 
 class Object
-  def to_serial
+  class << self
+    def exclude_from_serial ary
+      @excluded_from_serial = ary
+    end
+
+    def excluded_from_serial
+      @excluded_from_serial ||= []
+    end
+  end
+
+  def to_serial(_index)
     return self if [true, false, nil].include?(self)
     # @todo This warning is a little too spammy. Set up a logger so it can be
     # limited to an info or debug level.
@@ -17,52 +70,154 @@ class Object
     "#<UNKNOWN>"
   end
 
-  def serialize_instance_variables
+  def from_serial(index = [])
+    if self.is_a?(Hash) && (self['class'] || self['instance'])
+      if self['instance']
+        elematch = self['instance'].match(/^#<ELE_([\d]+)>$/)
+        object = index[elematch[1].to_i]
+        raise "Unable to load indexed element ##{elematch[1]} #{self}" if object.nil?
+      elsif self['class']
+        if self['class'] == 'Hash'
+          object = {}
+          self['data'].each do |arr|
+            object[arr[0].from_serial(index)] = arr[1].from_serial(index)
+          end
+          return object
+        elsif self['class'] == 'Class'
+          return Gamefic::Serialize.string_to_constant(self['name'])
+        elsif self['class'] == 'Set'
+          return Set.new(self['data'].map { |el| el.from_serial(index) })
+        else
+          elematch = self['class'].match(/^#<ELE_([\d]+)>$/)
+          if elematch
+            klass = index[elematch[1].to_i]
+          else
+            klass = Gamefic::Serialize.string_to_constant(self['class'])
+          end
+          raise "Unable to find class #{self['class']} #{self}" if klass.nil?
+          object = klass.allocate
+          index.push object if object.is_a?(Gamefic::Serialize)
+        end
+      end
+      self['ivars'].each_pair do |k, v|
+        object.instance_variable_set(k, v.from_serial(index))
+      end
+      object
+    elsif self.is_a?(Numeric)
+      self
+    elsif self.is_a?(String)
+      match = self.match(/#<ELE_([0-9]+)>/)
+      return index.index(match[1].to_i) if match
+      match = self.match(/#<SYM:([a-z0-9_\?\!]+)>/i)
+      return match[1].to_sym if match
+      # return nil if self == '#<UNKNOWN>'
+      self
+    elsif self.is_a?(Hash)
+      result = {}
+      unknown = false
+      self.each_pair do |k, v|
+        k2 = k.from_serial(index)
+        v2 = v.from_serial(index)
+        if k2 == "#<UNKNOWN>" || v2 == "#<UNKNOWN>"
+          unknown = true
+          break
+        end
+        result[k2] = v2
+      end
+      result = "#<UNKNOWN>" if unknown
+      result
+    elsif self && self != true
+      STDERR.puts "Unable to unserialize #{self.class}"
+      nil
+    else
+      # true, false, or nil
+      self
+    end
+  end
+
+  def serialize_instance_variables(index)
     result = {}
     instance_variables.each do |k|
-      result[k.to_s] = instance_variable_get(k).to_serial
+      next if self.class.excluded_from_serial.include?(k)
+      val = instance_variable_get(k)
+      if index.include?(val)
+        result[k.to_s] = {
+          'instance' => "#<ELE_#{index.index(val)}>",
+          'ivars' => {}
+        }
+      else
+        result[k.to_s] = val.to_serial(index)
+      end
     end
     result
   end
 end
 
+class Class
+  def to_serial(index = [])
+    if name.nil?
+      super
+    else
+      {
+        'class' => 'Class',
+        'name' => name
+      }
+    end
+  end
+end
+
 class Symbol
-  def to_serial
+  def to_serial(_index = [])
     "#<SYM:#{self}>"
   end
 end
 
 class String
-  def to_serial
+  def to_serial(_index = [])
     self
   end
 end
 
 class Numeric
-  def to_serial
+  def to_serial(_index = [])
     self
   end
 end
 
 class Array
-  def to_serial
+  def to_serial(index = [])
     map do |e|
-      s = e.to_serial
+      s = e.to_serial(index)
       return "#<UNKNOWN>" if s == "#<UNKNOWN>"
       s
     end
   end
+
+  def from_serial(index = [])
+    result = map { |e| e.from_serial(index) }
+    result = "#<UNKNOWN>" if result.any? { |e| e == "#<UNKNOWN>" }
+    result
+  end
 end
 
 class Hash
-  def to_serial
-    result = {}
+  def to_serial(index = [])
+    result = {'class' => 'Hash', 'data' => []}
     each_pair do |key, value|
-      k2 = key.to_serial
-      v2 = value.to_serial
+      k2 = key.to_serial(index)
+      v2 = value.to_serial(index)
       return "#<UNKNOWN>" if k2 == "#<UNKNOWN>" || v2 == "#<UNKNOWN>"
-      result[k2] = v2
+      result['data'].push [k2, v2]
     end
     result
   end
 end
+
+class Set
+  def to_serial(index = [])
+    {
+      'class' => 'Set',
+      'data' => to_a.map { |el| el.to_serial(index) }
+    }
+  end
+end