gamefic 1.7.0 → 2.1.0

data/lib/gamefic/plot/darkroom.rb

@@ -1,264 +1,80 @@
-module Gamefic
-  # Create and restore plot snapshots.
-  #
-  class Plot::Darkroom
-    attr_reader :plot
-
-    def initialize plot
-      @plot = plot
-    end
-
-    # Create a snapshot of the plot.
-    #
-    # @return [Hash]
-    def save
-      result = { entities: [], players: [], subplots: [], instance_variables: {} }
-      entity_store.clear
-      player_store.clear
-      entity_store.concat plot.entities
-      player_store.concat plot.players
-      plot.subplots.each { |s| entity_store.concat s.entities }
-      entity_store.uniq!
-      entity_store.each do |e|
-        result[:entities].push hash_entity(e)
-      end
-      player_store.each do |p|
-        result[:players].push hash_entity(p)
-      end
-      plot.theater.instance_variables.each { |i|
-        v = plot.theater.instance_variable_get(i)
-        result[:instance_variables][i] = serialize(v) if can_serialize?(v)
-      }
-      plot.subplots.each { |s|
-        result[:subplots].push hash_subplot(s)
-      }
-      result
-    end
-
-    # Restore a snapshot.
-    #
-    def restore snapshot
-      entity_store.clear
-      player_store.clear
-      plot.subplots.each { |s| s.conclude }
-      plot.entities[plot.initial_state[:entities].length..-1].each { |e| plot.destroy e }
-      entity_store.concat plot.entities[0..plot.initial_state[:entities].length-1]
-      entity_store.uniq!
-      player_store.concat plot.players
-      i = 0
-      snapshot[:entities].each { |h|
-        if entity_store[i].nil?
-          e = plot.stage do
-            cls = self.const_get(h[:class])
-            make cls
-          end
-          entity_store.push e
-        end
-        i += 1
-      }
-      snapshot[:subplots].each { |s|
-        sp = plot.stage do
-          cls = const_get(s[:class])
-          branch cls
-        end
-        # @todo Assuming one player
-        sp.introduce player_store[0] unless player_store.empty?
-        rebuild_subplot sp, s
-      }
-      i = 0
-      snapshot[:entities].each { |h|
-        rebuild1 entity_store[i], h
-        i += 1
-      }
-      i = 0
-      snapshot[:players].each { |p|
-        rebuild1 player_store[i], p
-        i += 1
-      }
-      i = 0
-      snapshot[:entities].each { |h|
-        rebuild2 entity_store[i], h
-        i += 1
-      }
-      i = 0
-      snapshot[:players].each { |h|
-        rebuild2 player_store[i], h
-        i += 1
-      }
-      snapshot[:instance_variables].each_pair { |k, v|
-        plot.theater.instance_variable_set(k, unserialize(v))
-      }
-    end
-
-    private
-
-    def hash_blacklist
-      [:@parent, :@children, :@last_action, :@scene, :@next_scene, :@playbook, :@performance_stack, :@buffer_stack, :@messages, :@state]
-    end
-
-    def can_serialize? v
-      return true if v.kind_of?(String) or v.kind_of?(Numeric) or v.kind_of?(Symbol) or v.kind_of?(Gamefic::Entity) or is_scene_class?(v) or v == true or v == false or v.nil?
-      if v.kind_of?(Array)
-        v.each do |e|
-          result = can_serialize?(e)
-          return false if result == false
-        end
-        true
-      elsif v.kind_of?(Hash)
-        v.each_pair do |k, v|
-          result = can_serialize?(k)
-          return false if result == false
-          result = can_serialize?(v)
-          return false if result == false
-        end
-        true
-      else
-        false
-      end
-    end
-
-    def is_scene_class?(v)
-      if v.kind_of?(Class)
-        s = v
-        until s.nil?
-          return true if s == Gamefic::Scene::Base
-          s = s.superclass
-        end
-        false
-      else
-        false
-      end
-    end
-
-    def serialize v
-      if v.kind_of?(Array)
-        result = []
-        v.each do |e|
-          result.push serialize(e)
-        end
-        result
-      elsif v.kind_of?(Hash)
-        result = {}
-        v.each_pair do |k, v|
-          result[serialize(k)] = serialize(v)
-        end
-        result
-      elsif is_scene_class?(v)
-        i = plot.scene_classes.index(v)
-        "#<SIN_#{i}>"
-      elsif v.kind_of?(Gamefic::Entity)
-        i = entity_store.index(v)
-        if i.nil?
-          i = player_store.index(v)
-          if i.nil?
-            raise "#{v} not found in plot"
-            nil
-          else
-            "#<PIN_#{i}>"
-          end
-        else
-          "#<EIN_#{i}>"
-        end
-      else
-        v
-      end
-    end
-
-    def unserialize v
-      if v.kind_of?(Array)
-        result = []
-        v.each do |e|
-          result.push unserialize(e)
-        end
-        result
-      elsif v.kind_of?(Hash)
-        result = {}
-        v.each_pair do |k, v|
-          result[unserialize(k)] = unserialize(v)
-        end
-        result
-      elsif v.kind_of?(String)
-        if m = v.match(/#<SIN_([0-9]+)>/)
-          plot.scene_classes[m[1].to_i]
-        elsif m = v.match(/#<EIN_([0-9]+)>/)
-          entity_store[m[1].to_i]
-        elsif m = v.match(/#<PIN_([0-9]+)>/)
-          player_store[m[1].to_i]
-        else
-          v
-        end
-      else
-        v
-      end
-    end
-
-    def rebuild1 e, h
-      h.each_pair do |k, v|
-        if k.to_s.start_with?('@')
-          e.instance_variable_set(k, unserialize(v))
-        end
-      end
-    end
-
-    def rebuild2 e, h
-      h.each_pair do |k, v|
-        if k.to_s != 'class' and !k.to_s.start_with?('@')
-          e.send("#{k}=", unserialize(v))
-        end
-      end
-    end
-
-    def hash_subplot s
-      result = { entities: [], instance_variables: {}, theater_instance_variables: {} }
-      s.instance_variables.each { |i|
-        v = s.instance_variable_get(i)
-        result[:instance_variables][i] = serialize(v) if can_serialize?(v)
-      }
-      s.theater.instance_variables.each { |i|
-        v = s.theater.instance_variable_get(i)
-        result[:theater_instance_variables][i] = serialize(v) if can_serialize?(v)
-      }
-      s.entities.each { |s|
-        result[:entities].push serialize(s)
-      }
-      result[:class] = s.class.to_s.split('::').last
-      result
-    end
-
-    def rebuild_subplot s, h
-      s.entities.each { |e|
-        s.destroy e
-      }
-      h[:instance_variables].each_pair { |k, v|
-        s.instance_variable_set(k, unserialize(v))
-      }
-      h[:theater_instance_variables].each_pair { |k, v|
-        s.theater.instance_variable_set(k, unserialize(v))
-      }
-      i = 0
-      h[:entities].each { |e|
-        s.add_entity unserialize(e)
-        i += 1
-      }
-    end
-
-    def entity_store
-      @entity_store ||= []
-    end
-
-    def player_store
-      @player_store ||= []
-    end
-
-    def hash_entity e
-      h = {}
-      e.instance_variables.each { |i|
-        v = e.instance_variable_get(i)
-        h[i] = serialize(v) unless hash_blacklist.include?(i) or !can_serialize?(v)
-      }
-      h[:class] = e.class.to_s.split('::').last
-      h[:parent] = serialize(e.parent)
-      h
-    end
-  end
-end
+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

data/lib/gamefic/plot/host.rb

@@ -1,48 +1,42 @@
-require 'gamefic/subplot'
-
-module Gamefic
-
-  module Plot::Host
-    # Get an array of all the current subplots.
-    #
-    # @return [Array<Subplot>]
-    def subplots
-      p_subplots.clone
-    end
-    
-    # Start a new subplot based on the provided class.
-    #
-    # @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, next_cue: nil
-      subplot = subplot_class.new(self, introduce: introduce, next_cue: next_cue)
-      p_subplots.push subplot
-      subplot
-    end
-
-    # Get the player's current subplots.
-    #
-    # @return [Array<Subplot>]
-    def subplots_featuring player
-      result = []
-      subplots.each { |s|
-        result.push s if s.players.include?(player)
-      }
-      result
-    end
-
-    # Determine whether the player is involved in a subplot.
-    #
-    # @return [Boolean]
-    def in_subplot? player
-      !subplots_featuring(player).empty?
-    end
-
-    private
-
-    def p_subplots
-      @p_subplots ||= []
-    end
-  end
-
-end
+require 'gamefic/subplot'
+
+module Gamefic
+  # Methods for hosting and managing subplots.
+  #
+  module Plot::Host
+    # Get an array of all the current subplots.
+    #
+    # @return [Array<Subplot>]
+    def subplots
+      @subplots ||= []
+    end
+
+    # Start a new subplot based on the provided class.
+    #
+    # @param subplot_class [Class<Gamefic::Subplot>] The class of the subplot to be created (Subplot by default)
+    # @return [Gamefic::Subplot]
+    def branch subplot_class = Gamefic::Subplot, introduce: nil, next_cue: nil, **more
+      subplot = subplot_class.new(self, introduce: introduce, next_cue: next_cue, **more)
+      subplots.push subplot
+      subplot
+    end
+
+    # Get the player's current subplots.
+    #
+    # @return [Array<Subplot>]
+    def subplots_featuring player
+      result = []
+      subplots.each { |s|
+        result.push s if s.players.include?(player)
+      }
+      result
+    end
+
+    # Determine whether the player is involved in a subplot.
+    #
+    # @return [Boolean]
+    def in_subplot? player
+      !subplots_featuring(player).empty?
+    end
+  end
+end

data/lib/gamefic/plot/snapshot.rb

@@ -2,31 +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
-      initial_state
-      internal_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
-      # HACK Force conclusion of current subplots
-      p_subplots.each { |s| s.conclude }
-      p_subplots.clear
+      snapshot = JSON.parse(snapshot) if snapshot.is_a?(String)
       Gamefic::Plot::Darkroom.new(self).restore(snapshot)
-      entities.each { |e| e.flush }
-    end
-
-    def initial_state
-      if @initial_state.nil?
-        @initial_state = internal_save
-      end
-      @initial_state
-    end
-
-    private
-
-    def internal_save
-      Gamefic::Plot::Darkroom.new(self).save
     end
   end
 end