gamefic 0.2.0 → 0.6.0

data/lib/gamefic/shell.rb

@@ -1,23 +1,8 @@
-require 'rubygems'
-require 'rubygems/package'
-require 'zlib'
+require 'zip'
 require 'tmpdir'
 require 'getoptlong'
 require 'gamefic/engine/tty'
 
-# Crazy hack to set file mtimes in tar file
-class Gem::Package::TarHeader
-  @@mtime = Time.now
-  def self.set_mtime(time)
-    @@mtime = time
-  end
-  alias :initialize_orig :initialize
-  def initialize(vals)
-    initialize_orig(vals)
-    @mtime = @@mtime
-  end
-end
-
 module Gamefic
 
   class Shell
@@ -33,14 +18,6 @@ module Gamefic
       case cmd
         when 'play'
           play ARGV.shift
-        when 'test'
-          test ARGV.shift
-        when 'init'
-          init ARGV.shift
-        when 'build'
-          build ARGV.shift
-        when 'fetch'
-          fetch ARGV.shift
         when 'help'
           help ARGV.shift
         else
@@ -59,177 +36,20 @@ module Gamefic
         end
         Dir.mktmpdir 'gamefic_' do |dir|
           puts "Loading..."
-          story = Story.new
+          story = Plot.new(Source.new(dir + '/scripts'))
           begin
             decompress file, dir
           rescue Exception => e
             puts "'#{file}' does not appear to be a valid Gamefic file."
-            puts "#{e}"
+            puts e.backtrace
             exit 1
           end
-          story.load dir + '/main.rb'
+          story.load dir + '/main'
           engine = Tty::Engine.new story
           puts "\n"
           engine.run
         end
       end
-      def test path
-        puts "Loading..."
-        story = Story.new
-        #begin
-          if File.directory?(path)
-            if !File.file?(path + '/main.rb')
-              raise "#{path}/main.rb does not exist"
-            end
-            story.load path + '/main.rb', true
-          else
-            story.load path
-          end
-        #rescue Exception => e
-        #  puts "An error occurred in #{path}:"
-        #  puts "#{e.inspect}"
-        #  exit 1
-        #end
-        engine = Tty::Engine.new story
-        puts "\n"
-        engine.run
-      end
-      def init directory
-        if directory.to_s == ''
-          puts "No directory specified."
-          exit 1
-        elsif File.exist?(directory)
-          if !File.directory?(directory)
-            files = Dir[directory + '/*']
-            if files.length > 0
-              puts "'#{directory}' is not an empty directory."
-              exit 1
-            end
-          else
-            puts "'#{directory}' is not an empty directory."
-            exit 1
-          end
-        else
-          Dir.mkdir(directory)
-        end
-        Dir.mkdir(directory + '/import')
-        main_rb = File.new(directory + '/main.rb', 'w')
-        main_rb.write <<EOS
-import 'standard'
-
-room = make Room, :name => 'room'
-
-introduction do |player|
-  player.parent = room
-  player.perform "look"
-end
-EOS
-        main_rb.close
-        #fetch directory
-        puts "Game directory '#{directory}' initialized."
-      end
-      def fetch directory
-        if directory.to_s == ''
-          puts "No source directory was specified."
-          exit 1
-        end
-        if !File.directory?(directory)
-          puts "#{directory} is not a directory."
-          exit 1
-        end
-        puts "Loading game data..."
-        story = Story.new
-        begin
-          story.load directory + '/main.rb', true
-        rescue Exception => e
-          puts "'#{directory}' has errors or is not a valid source directory."
-          puts "#{e}"
-          exit 1
-        end
-        puts "Checking for external script references..."
-        fetched = 0
-        story.imported_scripts.each { |script|
-          if !script.filename.start_with?(directory)
-            base = script.filename[(script.filename.rindex('import/') + 7)..-1]
-            puts "Fetching #{base}"
-            FileUtils.mkdir_p directory + '/import/' + File.dirname(base)
-            FileUtils.copy script.filename, directory + '/import/' + base
-            fetched += 1
-          end
-        }
-        if fetched == 0
-          puts "Nothing to fetch."
-        else
-          puts "Done."
-        end
-      end
-      def build directory
-        if directory.to_s == ''
-          puts "No source directory was specified."
-          exit 1
-        end
-        if !File.directory?(directory)
-          puts "#{directory} is not a directory."
-          exit 1
-        end
-        filename = File.basename(directory) + '.gfic'
-        opts = GetoptLong.new(
-          [ '-o', '--output', GetoptLong::REQUIRED_ARGUMENT ]
-        )
-        opts.quiet = true
-        begin
-          opts.each { |opt, arg|
-            case opt
-              when '-o'
-                filename = arg
-            end
-          }
-        rescue Exception => e
-          puts "#{e}"
-          exit 1
-        end
-        if File.exist?(filename)
-          puts "The file #{filename} already exists."
-          exit 1
-        end
-        story = Story.new
-        puts "Loading game data..."
-        begin
-          story.load directory + '/main.rb', true
-        rescue Exception => e
-          puts "'#{directory}' has errors or is not a valid source directory."
-          puts "#{e}"
-          exit 1
-        end
-        puts "Building file..."
-        stream = StringIO.new("")
-        Gem::Package::TarWriter.new(stream) do |tar|
-          Gem::Package::TarHeader.set_mtime Time.now
-          tar.add_file('main.rb', 0600) do |io|
-            File.open(directory + '/main.rb', "rb") { |f| io.write f.read }
-          end
-          if story.imported_scripts.length > 0
-            Gem::Package::TarHeader.set_mtime Time.now
-            tar.mkdir('import', 0700)
-            story.imported_scripts.each { |script|
-              base = script.filename[script.filename.rindex('import/') + 7..-1]
-              Gem::Package::TarHeader.set_mtime Time.now
-              tar.add_file('import/' + base, 0700) do |io|
-                io.write script.code
-              end
-            }
-          end
-        end
-        gz = StringIO.new("")
-        z = Zlib::GzipWriter.new(gz)
-        z.mtime = Time.now
-        z.write stream.string
-        z.close
-        file = File.new(filename, "w")
-        file.write gz.string
-        file.close
-        puts "Gamefic file '#{filename}' complete."
-      end
       def help command
         shell_script = File.basename($0)
         case command
@@ -237,40 +57,10 @@ EOS
             puts <<EOS
 #{shell_script} play [file]
 Play a Gamefic file on the command line.
-EOS
-          when "test"
-            puts <<EOS
-#{shell_script} test [path]
-Test a Gamefic source directory or script.
-EOS
-          when "init"
-            puts <<EOS
-#{shell_script} init [directory]
-Initialize a Gamefic source directory. The resulting directory will contain
-source files ready to build into a Gamefic file.
-EOS
-          when "fetch"
-            puts <<EOS
-#{shell_script} fetch [directory]
-Copy shared scripts to the source directory.
-If the specified game directory imnports external scripts, such as the ones
-that are distributed with the Gamefic gem, this command will copy them into
-the game's import directory. Fetching can be useful if you want to customize
-common features.
-EOS
-          when "build"
-            puts <<EOS
-#{shell_script} build [directory] [-o | --output filename]
-Build a distributable Gamefic file from the source directory. The default
-filename is [directory].gfic. You can change the filename with the -o option.
 EOS
           when nil, "help"
           puts <<EOS
 #{shell_script} play [file] - play a Gamefic file
-#{shell_script} init [dir] - initialize a Gamefic source directory
-#{shell_script} test [path] - test a Gamefic source directory or script
-#{shell_script} fetch [directory] - copy shared scripts into directory
-#{shell_script} build [directory] - build a Gamefic file
 #{shell_script} help - display this message
 #{shell_script} help [command] - display info about command
 EOS
@@ -279,39 +69,11 @@ EOS
           exit 1
         end
       end
-      def decompress(tarfile, destination)
-        tar_longlink = '././@LongLink'
-        Gem::Package::TarReader.new( Zlib::GzipReader.open tarfile ) do |tar|
-          dest = nil
-          tar.each do |entry|
-            if entry.full_name == tar_longlink
-              dest = File.join destination, entry.read.strip
-              next
-            end
-            dest ||= File.join destination, entry.full_name
-            if entry.directory?
-              FileUtils.rm_rf dest unless File.directory? dest
-              FileUtils.mkdir_p dest, :mode => entry.header.mode, :verbose => false
-            elsif entry.file?
-              cur_stack = dest.split('/')
-              cur_stack.pop
-              cur_dir = ''
-              while cur_stack.length > 0
-                cur_dir += '/' + cur_stack.shift              
-                if !File.exist?(destination + cur_dir)
-                  FileUtils.mkdir_p dest, :mode => 0700, :verbose => false
-                end
-              end
-              FileUtils.mkdir_p dest, :mode => entry.header.mode, :verbose => false
-              FileUtils.rm_rf dest unless File.file? dest
-              File.open dest, "wb" do |f|
-                f.print entry.read
-              end
-              FileUtils.chmod entry.header.mode, dest, :verbose => false
-            elsif entry.header.typeflag == '2' #Symlink!
-              File.symlink entry.header.linkname, dest
-            end
-            dest = nil
+      def decompress(zipfile, destination)
+        Zip::File.open(zipfile) do |z|
+          z.each do |entry|
+            FileUtils.mkdir_p "#{destination}/#{File.dirname(entry.name)}"
+            entry.extract "#{destination}/#{entry.name}"
           end
         end
       end

data/lib/gamefic/snapshots.rb

@@ -0,0 +1,134 @@
+require 'json'
+
+module Gamefic
+  class Snapshots
+    attr_accessor :history
+    def initialize entities
+      @history = []
+      @entities = entities
+    end
+    def save entities
+      store = []
+      index = 0
+      entities.each { |e|
+        hash = {}
+        e.serialized_attributes.each {|m|
+          con = m.to_s
+          if con.end_with?("?")
+            con = con[0..-2]
+          end
+          if e.respond_to?(m) == true
+            begin
+              xxx = e.send(m)
+              if xxx == false
+                hash[con] = false
+              elsif xxx
+                hash[con] = serialize_obj(xxx)
+              else
+                hash[con] = nil
+              end
+            rescue Exception => error
+              hash[con] = nil
+            end
+          end
+        }
+        hash[:session] = {}
+        e.session.each_pair { |k, v|
+          hash[:session][k] = serialize_obj(v)
+        }
+        store.push hash
+        index += 1
+      }
+      if @history.length > 10
+        @history.shift
+      end
+      json = JSON.generate(store)
+      #puts json
+      json
+    end
+    def restore snapshot
+      data = JSON.parse(snapshot)
+      index = 0
+      data.each { |hash|
+        hash.each_pair { |k, v|
+          @entities[index].send("#{k}=", unserialize(v)) if k.to_s != "session"
+        }
+        #unser = unserialize(hash["session"])
+        hash["session"].each_pair { |k, v|
+            @entities[index].session[k.to_sym] = unserialize(v)
+        }
+        index += 1
+      }
+    end
+    def blacklist
+      [:children, :session, :scene, :object_of_pronoun, :test_queue, :test_queue_scene, :test_queue_length, :testing]
+    end
+    private
+    def can_serialize? obj
+      return true if (obj == true or obj == false or obj.nil?)
+      allowed = [String, Fixnum, Float, Numeric, Entity, Direction, Hash, Array, Symbol]
+      allowed.each { |a|
+        return true if obj.kind_of?(a)
+      }
+      false
+    end
+    def serialize_obj obj
+      return nil if obj.nil?
+      return false if obj == false
+      if obj.kind_of?(Hash)
+        hash = {}
+        obj.each_pair { |k, v|
+          if can_serialize?(k) and can_serialize?(v)
+            hash[serialize_obj(k)] = serialize_obj(v)
+          end
+        }
+        return hash
+      elsif obj.kind_of?(Array)
+        arr = []
+        obj.each_index { |i|
+          if can_serialize?(obj[i])
+            arr[i] = serialize_obj(obj[i])
+          else
+            raise "Bad array in snapshot"
+          end
+        }
+        return arr
+      else
+        if obj.kind_of?(Entity)
+          return "#<EIN_#{@entities.index(obj)}>"
+        elsif obj.kind_of?(Direction)
+          return "#<DIR_#{obj.name}>"
+        #elsif obj.kind_of?(Symbol)
+        #  return "#<SYM_#{obj.to_s}>"
+        end
+      end
+      return obj
+    end
+    def unserialize obj
+      if obj.kind_of?(Hash)
+        hash = {}
+        obj.each_pair { |k, v|
+          hash[unserialize(k)] = unserialize(v)
+        }
+        hash
+      elsif obj.kind_of?(Array)
+        arr = []
+        obj.each_index { |i|
+          arr[i] = unserialize(obj[i])
+        }
+        arr
+      else
+        if obj.to_s.match(/^#<EIN_[0-9]+>$/)
+          i = obj[6..-2].to_i
+          @entities[i]
+        elsif obj.to_s.match(/^#<DIR_[a-z]+>$/)
+          Direction.find(obj[6..-2])
+        #elsif obj.to_s.match(/^#<SYM_[a-z]+>$/)
+        #  Direction.find(obj[6..-2].to_sym)
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/source/base.rb

@@ -0,0 +1,12 @@
+module Gamefic
+
+  class Source::Base
+    def initialize
+      raise "#initialize must be defined in subclasses"
+    end
+    def export path
+      raise "#export must be defined in subclasses"
+    end
+  end
+
+end

data/lib/gamefic/source/file.rb

@@ -0,0 +1,23 @@
+module Gamefic
+
+  class Source::File < Source::Base
+    @@extensions = ['.plot.rb', '.plot', '.rb']
+    attr_reader :directories
+    attr_accessor :main_dir
+    def initialize(*directories)
+      @directories = directories || []
+    end
+    def export path
+      @directories.each { |directory|
+        @@extensions.each { |ext|
+          abs_file = directory + '/' + path + ext
+          if File.file?(abs_file)
+            return Script::File.new(abs_file, path)
+          end
+        }
+      }
+      raise "Script #{path} not found"
+    end
+  end
+
+end

data/lib/gamefic/source/text.rb

@@ -0,0 +1,16 @@
+module Gamefic
+
+  class Source::Text < Source::Base
+    def initialize scripts = {}
+      @scripts = scripts
+    end
+    def export path
+      if @scripts.has_key?(path)
+        Script::Text.new(path, @scripts[path])
+      else
+        raise "Script #{path} not found"
+      end
+    end
+  end
+
+end

data/lib/gamefic/source.rb

@@ -0,0 +1,9 @@
+module Gamefic
+
+  module Source
+    autoload :Base, 'gamefic/source/base'
+    autoload :File, 'gamefic/source/file'
+    autoload :Text, 'gamefic/source/text'
+  end
+  
+end

data/lib/gamefic/stage.rb

@@ -0,0 +1,75 @@
+module Gamefic
+
+  module Stage
+    def stage *args, &block
+      s = generate_stage
+      
+      if block.nil?
+        s.module_eval(*args)
+      else
+        s.module_exec(*args, &block)
+      end
+    end
+    private
+    def generate_stage
+      return @stage if !@stage.nil?
+      
+      exposed = self.class.exposed_methods.keys
+      mounted = self.class.mounted_modules.keys
+      instance = self
+      
+      @stage = Module.new do
+        define_singleton_method(:__instance__) do
+          unless caller.length == 0 or caller[0].include?(__FILE__)
+            raise NoMethodError.new("Method __instance__ is not available from the stage.")
+          end
+          instance
+        end
+        exposed.each do |exposed_method|
+          define_singleton_method(exposed_method) do |*args, &block|
+            __instance__.public_send(exposed_method, *args, &block)
+          end
+        end
+        mounted.each { |dsl|
+          dsl.public_instance_methods.each { |method|
+            define_singleton_method(method) do |*args, &block|
+              #puts "Calling a mounted method"
+              result = __instance__.public_send(method, *args, &block)
+              #puts "Done"
+              result
+            end
+          }
+        }
+      end
+      
+      return @stage 
+    end
+    module ClassMethods
+      def mount *args
+        args.each { |a|
+          include a
+          mounted_modules[a] = nil
+        }
+      end
+      def expose *args
+        args.each { |a|
+          exposed_methods[a] = nil
+        }
+      end
+      def exposed_methods
+        @@exposed_methods ||= from_superclass(:exposed_methods, {}).dup
+      end
+      def mounted_modules
+        @@mounted_modules ||= from_superclass(:mounted_modules, {}).dup
+      end
+      private
+      def from_superclass(m, default = nil)
+        superclass.respond_to?(m) ? superclass.send(m) : default
+      end
+    end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+  
+end