gamefic 1.7.0 → 2.1.0

data/lib/gamefic/scriptable.rb

@@ -0,0 +1,88 @@
+module Gamefic
+  # The Scriptable module provides a clean room (aka "theater") for scripts.
+  #
+  # @!method stage(*args, &block)
+  #   Execute a block of code in a subset of the owner's scope.
+  #
+  #   The provided code is evaluated inside a clean room object that has its
+  #   own instance variables and access to the owner's public methods. The proc
+  #   can accept the method call's arguments.
+  #
+  #   @example Execute a block of code
+  #     stage {
+  #       puts 'Hello'
+  #     }
+  #
+  #   @example Execute a block of code with arguments
+  #     stage 'hello' { |message|
+  #       puts message # <- prints 'hello'
+  #     }
+  #
+  #   @example Use an instance variable
+  #     stage { @message = 'hello'" }
+  #     stage { puts @message } # <- prints 'hello'
+  #
+  #   @yieldpublic [Gamefic::Plot]
+  #   @return [Object] The value returned by the executed code
+  #
+  # @!method theater
+  #   The object that acts as an isolated namespace for staged code.
+  #   @return [Object]
+  #
+  # @!parse alias cleanroom theater
+  module Scriptable
+    module ClassMethods
+      # An array of blocks that were added by the `script` class method.
+      #
+      # @return [Array<Proc>]
+      def blocks
+        @blocks ||= []
+      end
+
+      # Add a block to be executed by the instance's `stage` method.
+      #
+      # Note that `script` does not execute the block instantly, but stores
+      # it in the `blocks` array to be executed later.
+      #
+      # @yieldpublic [Gamefic::Plot]
+      def script &block
+        blocks.push block
+      end
+    end
+
+    def self.included klass
+      klass.extend ClassMethods
+    end
+
+    private
+
+    # Execute all the scripts that were added by the `script` class method.
+    #
+    def run_scripts
+      self.class.blocks.each { |blk| stage &blk }
+    end
+  end
+end
+
+# @note #stage and #theater are implemented this way so the clean room object
+#   defines its classes and modules in the root namespace.
+Gamefic::Scriptable.module_exec do
+  define_method :stage do |*args, &block|
+    theater.instance_exec *args, &block
+  end
+
+  define_method :theater do
+    @theater ||= begin
+      instance = self
+      theater ||= Object.new
+      theater.instance_exec do
+        define_singleton_method :method_missing do |symbol, *args, &block|
+          instance.public_send :public_send, symbol, *args, &block
+        end
+      end
+      theater.extend Gamefic::Serialize
+      theater
+    end
+  end
+  alias cleanroom theater
+end

data/lib/gamefic/serialize.rb

@@ -0,0 +1,223 @@
+require 'set'
+
+module Gamefic
+  module Serialize
+    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
+  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.
+    # STDERR.puts "Unable to convert #{self} to element"
+    "#<UNKNOWN>"
+  end
+
+  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|
+      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(_index = [])
+    "#<SYM:#{self}>"
+  end
+end
+
+class String
+  def to_serial(_index = [])
+    self
+  end
+end
+
+class Numeric
+  def to_serial(_index = [])
+    self
+  end
+end
+
+class Array
+  def to_serial(index = [])
+    map do |e|
+      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(index = [])
+    result = {'class' => 'Hash', 'data' => []}
+    each_pair do |key, value|
+      k2 = key.to_serial(index)
+      v2 = value.to_serial(index)
+      return "#<UNKNOWN>" if k2 == "#<UNKNOWN>" || v2 == "#<UNKNOWN>"
+      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

data/lib/gamefic/subplot.rb

@@ -1,39 +1,37 @@
 require 'gamefic/plot'
 
 module Gamefic
-
-  class Subplot
-    include Plot::Theater
-    include Plot::Entities
-    include Plot::Commands
-    include Plot::Callbacks
-    include Plot::Scenes
-    include Plot::Articles
+  class Subplot #< Container
+    include World
+    include Scriptable
+    include Gamefic::Serialize
+    # @!parse extend Scriptable::ClassMethods
 
     # @return [Gamefic::Plot]
     attr_reader :plot
 
-    class << self
-      attr_reader :start_proc
-
-      protected
-
-      def on_start &block
-        @start_proc = block
-      end
-    end
-
-    def initialize plot, introduce: nil, next_cue: nil
+    # @param plot [Gamefic::Plot]
+    # @param introduce [Gamefic::Actor, nil]
+    # @param next_cue [Class<Gamefic::Scene::Base>, nil]
+    # @param more [Hash]
+    def initialize plot, introduce: nil, next_cue: nil, **more
       @plot = plot
       @next_cue = next_cue
       @concluded = false
-      stage &self.class.start_proc unless self.class.start_proc.nil?
+      @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 add_entity e
-      @p_entities.push e
+    def players
+      @players ||= []
     end
 
     def subplot
@@ -58,25 +56,22 @@ module Gamefic
       ent
     end
 
-    # HACK: Always assume subplots are running for the sake of entity destruction
-    def running?
-      true
-    end
-
     def exeunt player
+      player_conclude_procs.each { |block| block.call player }
       player.playbooks.delete playbook
       player.cue (@next_cue || default_scene)
-      p_players.delete player
+      players.delete player
     end
 
     def conclude
       @concluded = true
-      entities.each { |e|
-        destroy e
-      }
-      players.each { |p|
-        exeunt p
-      }
+      # Players needed to exit first in case any player_conclude procs need to
+      # interact with the subplot's entities.
+      players.each { |p| exeunt p }
+      # @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?
@@ -84,6 +79,9 @@ module Gamefic
     end
 
     def ready
+      # @todo We might not want to conclude subplots without players. There
+      #   might be cases where a subplot gets created with the intention of
+      #   introducing players in a later turn.
       conclude if players.empty?
       return if concluded?
       playbook.freeze
@@ -95,6 +93,11 @@ module Gamefic
       call_player_update
       call_update
     end
-  end
 
+    # Subclasses can override this method to handle additional configuration
+    # options.
+    #
+    def configure more
+    end
+  end
 end

data/lib/gamefic/syntax.rb

@@ -1,11 +1,9 @@
 require 'gamefic/command'
 
 module Gamefic
-
   class Syntax
     attr_reader :token_count, :first_word, :verb, :template, :command
-    @@phrase = '([\w\W\s\S]*?)'
-    
+
     def initialize template, command
       words = template.split_words
       @token_count = words.length
@@ -15,8 +13,8 @@ module Gamefic
         @token_count -= 1
         @first_word = ''
       else
-        @verb = command_words[0].to_sym if !command_words[0].nil?
         @first_word = words[0].to_s
+        @verb = command_words[0].to_sym
       end
       @command = command_words.join(' ')
       @template = words.join(' ')
@@ -29,7 +27,7 @@ module Gamefic
           if last_token_is_reg
             next
           else
-            tokens.push @@phrase
+            tokens.push '([\w\W\s\S]*?)'
             last_token_is_reg = true
           end
         else
@@ -50,11 +48,11 @@ module Gamefic
       @replace = subs.join(' ')
       @regexp = Regexp.new("^#{tokens.join(' ')}$", Regexp::IGNORECASE)
     end
-    
+
     # Convert a String into a Command.
     #
     # @param text [String]
-    # @return [Command]
+    # @return [Gamefic::Command]
     def tokenize text
       m = text.match(@regexp)
       return nil if m.nil?
@@ -71,7 +69,11 @@ module Gamefic
       }
       Command.new @verb, arguments
     end
-    
+
+    # Determine if the specified text matches the syntax's expected pattern.
+    #
+    # @param text [String]
+    # @return [Boolean]
     def accept? text
       !text.match(@regexp).nil?
     end
@@ -82,16 +84,17 @@ module Gamefic
     def signature
       [@regexp, @replace]
     end
-    
+
     def ==(other)
+      return false unless other.is_a?(Syntax)
       signature == other.signature
     end
-    
+
     # Tokenize an Array of Commands from the specified text.
     #
     # @param text [String] The text to tokenize.
-    # @param syntaxes [Array<Syntax>] The Syntaxes to use.
-    # @return [Array<Command>] The tokenized commands.
+    # @param syntaxes [Array<Gamefic::Syntax>] The Syntaxes to use.
+    # @return [Array<Gamefic::Command>] The tokenized commands.
     def self.tokenize text, syntaxes
       matches = []
       syntaxes.each { |syntax|
@@ -108,5 +111,4 @@ module Gamefic
       matches
     end
   end
-
 end