gamefic 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04c82a67567327c04056889b9f2b18e8756c917449cad5c5b0fbee780a5086fe
-  data.tar.gz: 552ca9a8bf3a8d9816158a5472399f0425eb4e5afb918cd41a4f6d72b3501f6b
+  metadata.gz: 6ac3f26cc5dcb62f6b4af8f0a365a316a4324605efecac8fd852f9980f00e336
+  data.tar.gz: 11348faf9a1c471c11ca4da93f419167db25a92ec7617fd73fb592fdf0ec7d7f
 SHA512:
-  metadata.gz: 269912641fca497c003d815918fc7da4797500bdf62367fe21a1630ddcb9b7ad3e7157f8440d0de4e9ffb6107d268b70756e5dd7d0caeda9097f9ca602f2e0f2
-  data.tar.gz: 4b4a1179eff5209df4204976107b5da6d40368eda34f787fea421891f1d4047f70a78be58f3e07b424ca453220314e0e241142262ae524536125405070af0295
+  metadata.gz: 1bd78b541afec9fd2129d785442ddc811dacbc42c41f9c683329776f90ada2e105578324ef73fa7dedd7fc26ed828917f1a796765f0f1b74ade334b54c94d5ab
+  data.tar.gz: d3a982efcb6bdd0c306ebdab70ee722fcd1040d6cf51501b738b8bca65e955689dcfe2d77aa5e8684e1f0e18d27b71579410f51a6189d23014da47156bbbe3cf

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# 2.0.2 - April 25, 2020
+- Improved snapshot serialization

data/lib/gamefic.rb

@@ -5,7 +5,7 @@ require 'gamefic/core_ext/array'
 require 'gamefic/core_ext/string'
 
 require 'gamefic/describable'
-require 'gamefic/index'
+# require 'gamefic/index'
 require 'gamefic/serialize'
 require 'gamefic/element'
 require 'gamefic/entity'
@@ -17,5 +17,6 @@ require "gamefic/action"
 require "gamefic/syntax"
 require 'gamefic/world'
 require 'gamefic/scriptable'
-require "gamefic/plot"
+require 'gamefic/plot'
+require 'gamefic/plot/index'
 require 'gamefic/subplot'

data/lib/gamefic/element.rb

@@ -7,13 +7,17 @@ module Gamefic
   #
   class Element
     include Gamefic::Describable
-    include Gamefic::Index
+    # include Gamefic::Index
+    include Gamefic::Serialize
 
     # @todo It would be nice if this initialization wasn't necessary.
     def initialize(args = {})
-      super self.class.default_attributes.merge(args)
-      post_initialize
-      yield self if block_given?
+    # super self.class.default_attributes.merge(args)
+    self.class.default_attributes.merge(args).each_pair do |k, v|
+      public_send "#{k}=", v
+    end
+    post_initialize
+    yield self if block_given?
     end
 
     def post_initialize

data/lib/gamefic/plot.rb

@@ -16,20 +16,23 @@ module Gamefic
     # @return [Hash]
     attr_reader :metadata
 
+    attr_reader :static
+
     include World
     include Scriptable
     # @!parse extend Scriptable::ClassMethods
     include Snapshot
     include Host
+    include Serialize
+
+    exclude_from_serial [:@static]
 
     # @param structure [Gamefic::Structure]
     # @param metadata [Hash]
     def initialize metadata: {}
-      Gamefic::Index.clear
       @metadata = metadata
       run_scripts
-      mark_static_entities
-      Gamefic::Index.stick
+      @static = [self] + scene_classes + entities
     end
 
     def player_class cls = nil

data/lib/gamefic/plot/darkroom.rb

@@ -13,14 +13,21 @@ module Gamefic
       # Create a snapshot of the plot.
       #
       # @return [Hash]
-      def save reduce: false
-        result = {
-          'elements' => Gamefic::Index.serials,
-          'entities' => plot.entities.map(&:to_serial),
-          'players' => plot.players.map(&:to_serial),
-          'theater_instance_variables' => plot.theater.serialize_instance_variables,
-          'subplots' => plot.subplots.reject(&:concluded?).map { |s| serialize_subplot(s) },
-          'metadata' => plot.metadata
+      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
 
@@ -28,64 +35,45 @@ module Gamefic
       #
       # @param snapshot [Hash]
       def restore snapshot
-        Gamefic::Index.elements.map(&:destroy)
-        Gamefic::Index.unserialize snapshot['elements']
-        plot.entities.clear
-        snapshot['entities'].each do |ser|
-          plot.entities.push Index.from_serial(ser)
-        end
+        # @todo Use `program` for verification
 
-        snapshot['theater_instance_variables'].each_pair do |k, s|
-          v = Gamefic::Index.from_serial(s)
-          next if v == "#<UNKNOWN>"
-          plot.theater.instance_variable_set(k, v)
-        end
+        plot.subplots.each(&:conclude)
+        plot.subplots.clear
 
-        snapshot['subplots'].each { |s| unserialize_subplot(s) }
-      end
-
-      private
-
-      def namespace_to_constant string
-        space = Object
-        string.split('::').each do |part|
-          space = space.const_get(part)
+        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
-        space
-      end
 
-      def serialize_subplot s
-        {
-          'class' => s.class.to_s,
-          'entities' => s.entities.map(&:to_serial),
-          'instance_variables' => s.serialize_instance_variables,
-          'theater_instance_variables' => s.theater.serialize_instance_variables
-        }
-      end
-
-      def unserialize_subplot s
-        cls = namespace_to_constant(s['class'])
-        sp = cls.allocate
-        sp.instance_variable_set(:@plot, plot)
-        s['entities'].each do |e|
-          sp.entities.push Gamefic::Index.from_serial(e)
-        end
-        s['instance_variables'].each_pair do |k, v|
-          next if v == "#<UNKNOWN>"
-          sp.instance_variable_set(k, Gamefic::Index.from_serial(v))
-        end
-        s['theater_instance_variables'].each_pair do |k, v|
-          next if v == "#<UNKNOWN>"
-          sp.theater.instance_variable_set(k, Gamefic::Index.from_serial(v))
-        end
-        plot.subplots.push sp
-        sp.send(:run_scripts)
-        # @todo Assuming one player
-        if plot.players.first
-          sp.players.push plot.players.first
-          plot.players.first.playbooks.push sp.playbook unless plot.players.first.playbooks.include?(sp.playbook)
+        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
-        sp
       end
     end
   end

data/lib/gamefic/plot/index.rb

@@ -0,0 +1,92 @@
+module Gamefic
+  class Plot
+    # A fixed index of plot elements. Plots and subplots use an index to track
+    # objects created in scripts.
+    #
+    class Index
+      # @param elements [Array]
+      def initialize elements
+        @elements = elements.uniq.freeze
+      end
+
+      # @return [Boolean]
+      def include? element
+        @elements.include?(element)
+      end
+
+      def all
+        @elements
+      end
+
+      def concat elements
+        @elements = (@elements + elements).uniq.freeze
+      end
+
+      def remove elements
+        @elements = (@elements - elements).uniq.freeze
+      end
+
+      # @return [Object]
+      def element index
+        @elements[index]
+      end
+
+      def id_for(element)
+        include?(element) ? "#<ELE_#{@elements.index(element)}>" : nil
+      end
+
+      # def self.from_serial serial, static
+      #   if serial.is_a?(Hash) && (serial['class'] || serial['element'])
+      #     if serial['class']
+      #       elematch = serial['class'].match(/^#<ELE_([\d]+)>$/)
+      #       if elematch
+      #         klass = static.element(elematch[1].to_i)
+      #       else
+      #         klass = eval(serial['class'])
+      #       end
+      #       object = klass.allocate
+      #     elsif serial['element']
+      #       object = static.element(serial['element'])
+      #     end
+      #     serial.each_pair do |k, v|
+      #       next unless k.to_s.start_with?('@')
+      #       object.instance_variable_set(k, from_serial(v, static))
+      #     end
+      #     object
+      #   elsif serial.is_a?(Numeric)
+      #     serial
+      #   elsif serial.is_a?(String)
+      #     match = serial.match(/#<ELE_([0-9]+)>/)
+      #     return static.element(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, static) }
+      #     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, static)
+      #       v2 = from_serial(v, static)
+      #       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
+    end
+  end
+end

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/scene/base.rb

@@ -3,6 +3,9 @@ module Gamefic
   # should inherit from it.
   #
   class Scene::Base
+    include Gamefic::Serialize
+    extend Gamefic::Serialize
+
     # The scene's primary actor.
     #
     # @return [Gamefic::Actor]

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,66 @@
 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,51 +68,142 @@ 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'])
+        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

data/lib/gamefic/subplot.rb

@@ -4,6 +4,7 @@ module Gamefic
   class Subplot #< Container
     include World
     include Scriptable
+    include Gamefic::Serialize
     # @!parse extend Scriptable::ClassMethods
 
     # @return [Gamefic::Plot]
@@ -16,10 +17,16 @@ module Gamefic
       @plot = plot
       @next_cue = next_cue
       @concluded = false
+      @more = more
       configure more
       run_scripts
       playbook.freeze
       self.introduce introduce unless introduce.nil?
+      @static = [self] + scene_classes + entities
+    end
+
+    def static
+      plot.static
     end
 
     def players
@@ -63,6 +70,7 @@ module Gamefic
       # @todo I'm not sure why rejecting nils is necessary here. It's only an
       #   issue in Opal.
       entities.reject(&:nil?).each { |e| destroy e }
+      # plot.static.remove(scene_classes + entities)
     end
 
     def concluded?
@@ -90,5 +98,15 @@ module Gamefic
     #
     def configure more
     end
+
+    # def to_serial(index)
+    #   puts "Serializing #{self}"
+    #   super
+    # end
+
+    # def from_serial index = []
+    #   # @todo Customize subplot unserialization
+    #   super
+    # end
   end
 end

data/lib/gamefic/version.rb

@@ -1,3 +1,3 @@
 module Gamefic
-  VERSION = '2.0.1'
+  VERSION = '2.0.2'
 end

data/lib/gamefic/world/entities.rb

@@ -43,11 +43,18 @@ module Gamefic
       # @param [Gamefic::Entity] The entity to remove
       def destroy entity
         entity.parent = nil
-        index = entities.index(entity)
-        return if index.nil? || index < static_entity_length - 1
-        entities.delete_at index
+        # index = entities.index(entity)
+        # return if index.nil? || index < static_entity_length - 1
+        # entities.delete_at index
+        # players.delete entity
+        # entity.destroy
+
+        # @todo It might make sense to destroy the entity completely now. It
+        #   will still have a reference in the index, but that shouldn't impact
+        #   the current state of the plot.
+        return if static.include?(entity)
+        entities.delete entity
         players.delete entity
-        entity.destroy
       end
 
       # Pick an entity based on its description.
@@ -87,15 +94,15 @@ module Gamefic
         @players ||= []
       end
 
-      private
+      # private
 
-      def mark_static_entities
-        @static_entity_length ||= entities.length
-      end
+      # def mark_static_entities
+      #   @static_entity_length ||= entities.length
+      # end
 
-      def static_entity_length
-        @static_entity_length || 0
-      end
+      # def static_entity_length
+      #   @static_entity_length || 0
+      # end
     end
   end
 end

data/lib/gamefic/world/scenes.rb

@@ -35,7 +35,7 @@ module Gamefic
         players.push player
         @introduction.call(player) unless @introduction.nil?
         # @todo Find a better way to persist player characters
-        Gamefic::Index.stick
+        # Gamefic::Index.stick
       end
 
       # Create a multiple-choice scene.
@@ -144,7 +144,7 @@ module Gamefic
         scene_classes.push s
         s
       end
-      
+
       # Create a custom scene.
       #
       # Custom scenes should always specify the next scene to be cued or

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gamefic
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Fred Snyder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-26 00:00:00.000000000 Z
+date: 2020-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -74,6 +74,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".solargraph.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -89,13 +90,13 @@ files:
 - lib/gamefic/describable.rb
 - lib/gamefic/element.rb
 - lib/gamefic/entity.rb
-- lib/gamefic/index.rb
 - lib/gamefic/keywords.rb
 - lib/gamefic/messaging.rb
 - lib/gamefic/node.rb
 - lib/gamefic/plot.rb
 - lib/gamefic/plot/darkroom.rb
 - lib/gamefic/plot/host.rb
+- lib/gamefic/plot/index.rb
 - lib/gamefic/plot/snapshot.rb
 - lib/gamefic/query.rb
 - lib/gamefic/query/base.rb

data/lib/gamefic/index.rb

@@ -1,121 +0,0 @@
-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