gamefic 1.6.0 → 2.0.3

data/lib/gamefic/scene/conclusion.rb

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

data/lib/gamefic/scene/custom.rb

@@ -1,9 +1,7 @@
 module Gamefic
-  
   # A Custom Scene allows for complete configuration of its behavior upon
   # instantiation. It is suitable for direct instantiation or subclassing.
   #
   class Scene::Custom < Scene::Base
   end
-  
 end

data/lib/gamefic/scene/multiple_choice.rb

@@ -1,5 +1,4 @@
 module Gamefic
-
   # Provide a list of options and process the selection in the scene's finish
   # block. After the scene is finished, the :active scene will be cued unless
   # some other scene has already been prepared or cued.
@@ -8,9 +7,21 @@ module Gamefic
   # instead of a String.
   #
   class Scene::MultipleChoice < Scene::Custom
+    # The zero-based index of the selected option.
+    #
+    # @return [Integer]
     attr_reader :index
+
+    # The one-based index of the selected option.
+    #
+    # @return [Integer]
     attr_reader :number
+
+    # The full text of the selected option.
+    #
+    # @return [String]
     attr_reader :selection
+
     attr_writer :invalid_message
 
     def post_initialize
@@ -18,20 +29,7 @@ module Gamefic
       self.prompt = 'Enter a choice:'
     end
 
-    #def start actor
-    #  data = start_data_for(actor)
-    #  data.clear
-    #  do_start_block actor, data
-    #  tell_options
-    #end
-    
-    def start
-      super
-      raise "MultipleChoice scene has zero options" if options.empty?
-    end
-
     def finish
-      #data = finish_data_for(actor, input)
       get_choice
       if selection.nil?
         actor.tell invalid_message
@@ -41,10 +39,16 @@ module Gamefic
       end
     end
 
+    # The array of available options.
+    #
+    # @return [Array<String>]
     def options
       @options ||= []
     end
 
+    # The text to display when an invalid selection is received.
+    #
+    # @return [String]
     def invalid_message
       @invalid_message ||= 'That is not a valid choice.'
     end
@@ -82,7 +86,5 @@ module Gamefic
       list += "</ol>"
       actor.tell list
     end
-    
   end
-
 end

data/lib/gamefic/scene/multiple_scene.rb

@@ -1,20 +1,29 @@
-module Gamefic
-
-  class Scene::MultipleScene < Scene::MultipleChoice
-    def option_map
-      @option_map ||= {}
-    end
-
-    def map option, scene
-      options.push option
-      option_map[option] = scene
-    end
-
-    def finish
-      get_choice
-      unless selection.nil?
-        actor.cue option_map[selection]
-      end
-    end
-  end
-end
+module Gamefic
+  class Scene::MultipleScene < Scene::MultipleChoice
+    def option_map
+      @option_map ||= {}
+    end
+
+    # @param option [String]
+    # @param scene [Class<Gamefic::Scene::Base>]
+    def map option, scene
+      options.push option
+      option_map[option] = scene
+    end
+
+    def finish
+      get_choice
+      unless selection.nil?
+        actor.prepare option_map[selection]
+      end
+    end
+
+    def state
+      entered = {}
+      option_map.each_pair do |k, v|
+        entered[k] = actor.entered?(v)
+      end
+      super.merge entered: entered
+    end
+  end
+end

data/lib/gamefic/scene/pause.rb

@@ -1,5 +1,4 @@
 module Gamefic
-
   # Pause for user input.
   #
   class Scene::Pause < Scene::Custom
@@ -7,6 +6,12 @@ module Gamefic
       self.type = 'Pause'
       self.prompt = 'Press enter to continue...'
     end
+
+    class << self
+      def tracked?
+        @tracked = true if @tracked.nil?
+        @tracked
+      end
+    end
   end
-  
 end

data/lib/gamefic/scene/yes_or_no.rb

@@ -1,32 +1,41 @@
 module Gamefic
-
   # Prompt the user to answer "yes" or "no". The scene will accept variations
   # like "YES" or "n" and normalize the answer to "yes" or "no" in the finish
   # 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
+    attr_writer :invalid_message
+
     def post_initialize
       self.type = 'YesOrNo'
-      self.prompt = 'Yes or No?'
+      self.prompt = 'Yes or No:'
     end
 
+    # True if the actor's answer is Yes.
+    # Any answer beginning with letter Y is considered Yes.
+    #
+    # @return [Boolean]
     def yes?
-      input.to_s[0,1].downcase == 'y'
+      input.to_s[0,1].downcase == 'y' or input.to_i == 1
     end
 
+    # True if the actor's answer is No.
+    # Any answer beginning with letter N is considered No.
+    #
+    # @return [Boolean]
     def no?
-      input.to_s[0,1].downcase == 'n'
+      input.to_s[0,1].downcase == 'n' or input.to_i == 2
     end
 
+    # The message sent to the user for an invalid answer, i.e., the input
+    # could not be resolved to either Yes or No.
+    #
+    # @return [String]
     def invalid_message
       @invalid_message ||= 'Please enter Yes or No.'
     end
 
-    def prompt
-      @prompt ||= 'Yes or No?'
-    end
-
     def finish
       if yes? or no?
         super
@@ -34,6 +43,9 @@ module Gamefic
         actor.tell invalid_message
       end
     end
-  end
 
+    def state
+      super.merge options: ['Yes', 'No']
+    end
+  end
 end

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