gamefic 0.2.0 → 0.6.0

data/lib/gamefic/engine/cgi.rb

@@ -0,0 +1,221 @@
+require 'rubygems'
+require 'json'
+
+module Gamefic
+
+  class Entity
+    attr_reader :cgi_key
+    @@cgi_key_index = 0
+    alias_method :orig_post_initialize, :post_initialize
+    def post_initialize
+      orig_post_initialize
+      @cgi_key = "entity_#{@@cgi_key_index}"
+      @@cgi_key_index += 1
+    end
+  end
+
+  module Cgi
+
+    class Key
+      def initialize(key_value)
+        @value = key_value
+      end
+      def value
+        @value
+      end
+    end
+
+    class Engine < Gamefic::Engine
+      attr_reader :user
+      def initialize(plot, args = {})
+        super(plot)
+        @session_file = args[:session_file] || 'save.dat'
+        @message_format = args[:message_format] || :html
+        @response_format = args[:response_format] || :json
+        @new_game = args[:new_game] || false
+        @entity_keys = Hash.new
+        @introducing = true
+      end
+      def post_initialize
+        @user = Cgi::User.new @plot
+      end
+      def begin_session
+        # Initialize keys for all entities
+        @plot.entities.each { |e|
+          @entity_keys[e.cgi_key] = e
+        }
+        @entity_keys['yourself'] = @user.character
+        if !@new_game and @session_file != nil
+          if File.exist?(@session_file)
+            load @session_file
+            @introducing = false
+          end
+        end
+      end
+      def run
+        if @introducing == true
+          @plot.introduce @user.character
+        else
+          @plot.instance_variable_get(:@players).push @user.character
+          tick
+        end
+        response = Hash.new
+        response[:output] = @user.stream.flush
+        response[:prompt] = @user.character.state.prompt
+        response[:state] = @user.character.state.class.to_s.split('::').last
+        return JSON.generate(response)
+      end
+      def end_session
+        save @session_file
+      end
+      private
+      def load(filename)
+        x = File.open(filename, "r")
+        ser = x.read
+        x.close
+        data = Marshal.restore(ser)
+        data.each { |k, h|
+          if k == 'yourself'
+            entity = @entity_keys['yourself']
+          else
+            entity = @entity_keys[k]
+          end
+          h.each { |s, v|
+            if s == :session
+              entity.instance_variable_set(:@session, v)
+            elsif s == :state
+              entity.state = v
+            elsif s == :options
+              v.each { |opt|
+                entity.is opt
+              }
+            else
+              writer = "#{s.to_s[1..-1]}="
+              writer.untaint
+              if entity.respond_to?(writer)
+                if v.kind_of?(Key)
+                  entity.send(writer, @entity_keys[v.value])
+                elsif v.kind_of?(CharacterState::Base)
+                  v.instance_variable_set(:@character, entity)
+                  entity.instance_variable_set(s, v)
+                elsif v.kind_of?(Array)
+                  entity.send(writer, decode_array(v))
+                else
+                  entity.send(writer, v)
+                end
+              end
+            end
+          }
+        }
+        @restored = true
+      end
+      def save(filename)
+        data = Hash.new
+        @plot.entities.each { |e|
+          data[e.cgi_key] = entity_hash(e)
+        }
+        f = File.new(filename, "w")
+        f.write Marshal.dump data
+        f.close
+      end
+      def entity_hash(e)
+        hash = Hash.new
+        e.instance_variables.each { |v|
+          next if v == :@state or v == :@option_array or v == :@update_procs
+          writer = "#{v.to_s[1..-1]}="
+          if e.respond_to?(writer)
+            value = e.instance_variable_get(v)
+            if value.kind_of?(String) or value.kind_of?(Numeric) or value.kind_of?(TrueClass) or value.kind_of?(FalseClass) or value.kind_of?(Entity) or value.kind_of?(Character) or value == nil or value.kind_of?(Array)
+              if value.kind_of?(Entity)
+                if value == @user.character
+                  hash[v] = Key.new('yourself')
+                else
+                  hash[v] = Key.new(value.cgi_key)
+                end
+              elsif value.kind_of?(CharacterState::Base)
+                value.instance_variable_set(:@character, nil)
+                hash[v] = value
+              elsif value.kind_of?(Array)
+                hash[v] = encode_array(value)
+              else
+                hash[v] = value
+              end
+            end
+          end
+        }
+        if e.respond_to?("state")
+          hash[:state] = e.state_name
+        end
+        if e.respond_to?("option_array")
+          hash[:options] = e.option_array
+        end
+        hash[:session] = Hash.new
+        e.session.each { |k, v|
+          if v.kind_of?(Entity)
+            hash[:session][k] = Key.new(v.cgi_key)
+          elsif v.kind_of?(Array)
+            hash[:session][k] = encode_array(v)
+          else
+            hash[:session][k] = v
+          end
+        }
+        hash
+      end
+      def encode_array(array)
+        result = Array.new
+        array.each { |item|
+          if item.kind_of?(Entity)
+            result.push Key.new(item.cgi_key)
+          else
+            result.push item
+          end
+        }
+        result
+      end
+      def decode_array(array)
+        result = Array.new
+        array.each { |item|
+          if item.kind_of?(Key)
+            result.push @entity_keys[item.value]
+          else
+            result.push item
+          end
+        }
+        result    
+      end
+    end
+    
+    class User < Gamefic::User
+      def post_initialize
+        @stream = Cgi::UserStream.new
+        @state = UserState.new self
+        #@character = @plot.make Character, :name => 'pWlayer'
+      end
+    end
+    
+    class UserStream < Gamefic::UserStream
+      def initialize
+        super
+        @output = ''
+      end
+      def flush
+        buffer = "#{@output}"
+        @output.clear
+        buffer
+      end
+      def send(data)
+        #if data.start_with?(Ansi::NEL)
+        #  data = "<p>#{data[Ansi::NEL.length..-1].rstrip}</p>"
+        #end
+        @output = "#{@output}#{data}"
+      end
+      def select(prompt)
+        # TODO: non-blocking read
+        line = STDIN.gets
+        @queue.push line
+      end
+    end
+
+  end
+
+end

data/lib/gamefic/engine/tty.rb

@@ -0,0 +1,237 @@
+require 'gamefic/engine'
+require 'rexml/document'
+require 'gamefic/ansi'
+require 'gamefic/html'
+
+begin
+  require 'io/console'
+rescue LoadError
+  puts "This version of Ruby does not support io/console. Text may not wrap correctly."
+  if RUBY_VERSION.split('.')[0].to_i < 2
+    puts "It is recommended that you upgrade to Ruby 2.0.0 or higher."
+  end
+end
+
+module Gamefic
+
+  module Tty
+    class Engine < Gamefic::Engine
+      def post_initialize
+        @user = Tty::User.new @plot
+      end
+    end
+    class User < Gamefic::User
+      def post_initialize
+        @stream = Tty::UserStream.new
+        @state = UserState.new self
+      end
+      def ansi=(val)
+        @stream.ansi = val
+      end
+      def ansi
+        @stream.ansi
+      end
+      def save filename, json
+        if json.nil?
+          @character.tell "Nothing to save."
+        end
+        if filename.nil?
+          stream.select "Enter the filename to save:"
+          filename = stream.queue.pop
+        end
+        if filename != ''
+          File.open(filename, 'w') do |f|
+            f.write json
+          end
+          @character.tell "Game saved."
+        end
+      end
+      def restore filename
+        if filename.nil?
+          stream.select "Enter the filename to restore:"
+          filename = stream.queue.pop
+        end
+        if filename != ''
+          if File.exists?(filename)
+            return File.read(filename)
+          else
+            @character.tell "File \"#{filename}\" not found."
+          end
+        end
+      end
+    end
+    class UserStream < Gamefic::UserStream
+      include Ansi
+      include Ansi::Code
+      def initialize
+        super
+      end
+      def size
+        begin
+          return STDOUT.winsize.reverse
+        rescue
+          return [nil,nil]
+        end
+      end
+      def flush
+        data = @buffer.clone
+        @buffer.clear
+        return if data.strip == ''
+        output = ''
+        begin
+          doc = Html.parse("<body>#{data}</body>")
+          format_recursively doc
+          texts = REXML::XPath.match(doc, './/text()')
+          output = texts.join('').gsub(/&apos;/, "'").gsub(/&quot;/, '"').gsub(/&lt;/, '<').gsub(/&gt;/, '>')
+          output += Ansi.graphics_mode(Attribute::NORMAL)
+          output = Html::decode(output)
+        rescue REXML::ParseException => e
+          puts e.inspect
+          output = Html.encode(data) + "\n\n"
+        end
+        output.gsub!(/(\n\n)+/, "\n\n")
+        width = size[0]
+        if width.nil?
+          output
+        else
+          "#{terminalize(output, width - 1)}"
+        end
+      end
+      def select(prompt)
+        super
+        print "\n"
+      end
+      def has_code?(fmt, code)
+        if fmt.kind_of?(Array)
+          return fmt.flatten.include?(code)
+        end
+        return fmt == code
+      end
+      
+      private
+      
+      def format_recursively(top, stack = nil)
+        ol_index = 1
+        stack ||= [Attribute::NORMAL]
+        top.elements.each { |element|
+          formats = [Attribute::NORMAL]
+          classes = element.attribute('class').to_s.split(' ')
+          if classes.include?('hint')
+            formats.push Foreground::YELLOW
+          end
+          case element.name
+            when 'strong', 'b'
+              formats.push Attribute::BOLD
+            when 'em', 'i', 'u'
+              formats.push Attribute::UNDERSCORE
+            when 'a'
+              if element.attributes['rel'].to_s == 'gamefic'
+                element.attributes['href'] = element.attributes['href'][5..-1]
+                formats.push [Attribute::UNDERSCORE, Extra::COMMAND]
+              else
+                formats.push [Attribute::UNDERSCORE, Extra::HREF]
+              end
+            when 'li'
+              if top.name == 'ol'
+                element.text = "#{ol_index}. #{element.text}"
+                ol_index += 1
+              else
+                element.text = "* #{element.text}"
+              end
+              formats.push [Extra::LINE]
+            when 'img'
+              formats.push [Extra::IGNORED]
+            when 'p', 'ol', 'ul'
+              formats.push Extra::BLOCK
+            when 'nav'
+              formats.push Extra::BLOCK
+            when 'h1', 'h2', 'h3', 'h4', 'h5'
+              formats.push [Attribute::BOLD, Extra::BLOCK, Extra::UPPERCASE]
+            when 'kbd'
+              formats.push [Foreground::GREEN]
+          end
+          if has_code?(stack, Extra::IGNORED)
+            element.parent.delete_element(element)
+          end
+          stack.push formats
+          if has_code?(stack, Extra::UPPERCASE)
+            element.texts.each { |text|
+              text.value.upcase!
+            }
+          end
+          element.texts.each { |text|
+            text.value = "#{Ansi.graphics_mode(*stack)}#{text.value}"
+          }
+          if has_code?(stack.last, Extra::IMAGE)
+            element.text = "#{element.attribute('alt') ? element.attribute('alt') : '[Image]'}"
+          end
+          format_recursively element, stack
+          if has_code?(stack.last, Extra::COMMAND)
+            if element.attribute('data-command').to_s != ''
+              tmp = stack.pop
+              element.add_text "#{Ansi.graphics_mode(*stack)}"
+              element.add_text " [#{element.attribute('data-command')}]"
+              stack.push tmp
+              element.add_text "#{Ansi.graphics_mode(*stack)}"
+            end
+          end
+          if has_code?(stack.last, Extra::BLOCK)
+            element.add_text("\n\n")
+          elsif has_code?(stack.last, Extra::LINE)
+            if !has_code?(stack[-2], Extra::BLOCK) || element != top.elements.to_a.last
+              element.add_text("\n")
+            end
+          end
+          if has_code?(stack.last, Extra::HREF)
+            if element.attribute('href').to_s != "#"
+              tmp = stack.pop
+              element.add_text "#{Ansi.graphics_mode(*stack)}"
+              element.add_text(" [#{element.attribute('href')}]")
+              stack.push tmp
+              element.add_text "#{Ansi.graphics_mode(*stack)}"
+            end
+          end
+          if has_code?(stack.last, Extra::IMAGE)
+            element.add_text(" [#{element.attribute('src')}]")
+            if !has_code?(stack, Extra::BLOCK)
+              element.add_text("\n\n")
+            end
+          end
+          stack.pop
+        }
+      end
+      def terminalize string, max_length
+        i = 0
+        output = ''
+        line_length = 0
+        while i < string.length
+          line_length += 1
+          char = string[i,1]
+          if char == "\e"
+            # Right now, graphics modes are the only supported ANSI sequences.
+            end_of_seq = string.index("m", i)
+            output += string[i..end_of_seq]
+            i = end_of_seq + 1
+          elsif char == " "
+            next_space = string.index(/[\s]/, i + 1)
+            if !next_space.nil? and line_length + (next_space - i) > max_length
+              output += "\n"
+              line_length = 0
+            else
+              output += char
+            end
+            i += 1
+          else
+            if char == "\n"
+              line_length = 0
+            end
+            output += char
+            i += 1
+          end
+        end
+        output #output.strip
+      end
+    end
+  end
+
+end

data/lib/gamefic/engine.rb

@@ -1,86 +1,107 @@
 module Gamefic
 
-	class Engine
-		def initialize(plot)
-			@plot = plot
+  class Engine
+    def initialize(plot)
+      @plot = plot
       post_initialize
-		end
+    end
     def post_initialize
       @user = User.new @plot
     end
-		def run
+    def run
       @plot.introduce @user.character
-			while @user.character.state.kind_of?(GameOverState) == false
-        tick
-			end
-		end
-    def tick
-      proc {
-        $SAFE = Gamefic.safe_level
-        @user.stream.select @user.character.state.prompt
-        @user.state.update
-        @plot.update
-      }.call    
-    end
-	end
+      print @user.state.output
+      while @user.character.scene.state != "Concluded"
+        turn
+      end
+      print @user.state.output
+    end
+    def turn
+      @plot.ready
+      print @user.state.output
+      # HACK Exception for test scenes
+      if @user.character.scene.key != :test
+        if @user.character.scene.state != "Concluded"
+          @user.stream.select @user.character.scene.data.prompt
+          @user.state.input
+        end
+      end
+      @plot.update
+      print @user.state.output
+    end
+  end
 
-	class User
-		attr_reader :state, :character, :story
-		def initialize(plot)
-			@plot = plot
-      @character = Character.new @plot, :name => 'yourself', :synonyms => 'self myself you me'
+  class User
+    attr_reader :state, :character, :story
+    def initialize(plot)
+      @plot = plot
+      @character = Character.new @plot, :name => 'yourself', :synonyms => 'self myself you me', :proper_named => true
       @character.connect self
       post_initialize
-		end
+    end
     def post_initialize
-			@stream = UserStream.new
-			@state = UserState.new self
+      @stream = UserStream.new
+      @state = UserState.new self
+    end
+    def stream
+      @stream ||= UserStream.new
     end
-		def stream
-			@stream ||= UserStream.new
-		end
     def state
       @state ||= UserState.new(self)
     end
-		def state=(state_class)
-			@state = state_class.new self
-		end
-		def refresh
-			# Nothing to do
-		end
-		def quit
-			#exit
-		end
-	end
-	
-	class UserStream
-		def initialize
-			@queue = Array.new
-		end
-		def send(data)
-      puts data
-		end
-		def select(prompt)
-			print prompt
-			line = STDIN.gets
+    def state=(state_class)
+      @state = state_class.new self
+    end
+    def refresh
+      # Nothing to do
+    end
+    def quit
+      #exit
+    end
+  end
+  
+  class UserStream
+    def initialize
+      @queue = Array.new
+      @buffer = ''
+    end
+    def flush
+      tmp = @buffer.clone
+      #@buffer.clear
+      @buffer = ''
+      tmp
+    end
+    def send(data)
+      # Quick and dirty HTML sanitization
+      #data.gsub!(/<[a-z]+[^>]*>/i, "")
+      #data.gsub!(/<\/[^>]*>/, "")
+      @buffer += data
+    end
+    def select(prompt)
+      print "#{prompt} "
+      STDOUT.flush
+      line = STDIN.gets
       @queue.push line.strip
-		end
-		def recv
-			@queue.shift
-		end
-	end
-	
-	class UserState
-		attr_reader :user
-		def initialize(user)
-			@user = user
-		end
-		def update
-			line = @user.stream.recv
-			if line != nil
+    end
+    def recv
+      @queue.shift
+    end
+  end
+  
+  class UserState
+    attr_reader :user
+    def initialize(user)
+      @user = user
+    end
+    def input
+      line = @user.stream.recv
+      if line != nil
         @user.character.queue.push line
-			end
-		end
-	end
+      end
+    end
+    def output
+      @user.stream.flush
+    end
+  end
 
 end