gamefic 1.3.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c35f010532ce719b33633e584eed9bfa532928d7
-  data.tar.gz: ef440164cce6a34a1098d634116e3a1092e7fa6c
+  metadata.gz: c183cbc357d79a7ad5537c2dbd12b798e383d209
+  data.tar.gz: 91055b2773aa8d6ee095a8da1be6209c67e8d4bd
 SHA512:
-  metadata.gz: f6a8aa67a07346933d103cb74ddaa809e9df3b086a45ae6b29374ddfdc64e1c5ff6c5f61185d3e6da52612e28f196b61be5167837deed5eeed634716ce90eec5
-  data.tar.gz: a526186ab3953e8a2848e74c8d4616a4cb946d7927c8e674dd306f9a8aa827f975d9d92fe98628720dc32f4283aae4ca4dfa791a80acd5c6b41e703c6575d780
+  metadata.gz: aaea9c46d01e5f0683c9a96148c2695be6094133369acf9dd5f8eb7c09f78f6071cdf36059463f9d354af7ed3662505ab4c09c6c098f70b2b2b1c10d16fe13f5
+  data.tar.gz: dea0c09003fb3a1c06bbfadc9a19522287b72bca2fc3a3cf309e8af31119f1c98f42cc5ae121d853b7396f135e84840a6e33b40cfe7127e4a920272180f840e5

data/lib/gamefic.rb

@@ -14,6 +14,7 @@ require "gamefic/rule"
 require "gamefic/director"
 require "gamefic/plot"
 require "gamefic/engine"
+require "gamefic/user"
 require "gamefic/direction"
 
 require 'gamefic/version'

data/lib/gamefic/character.rb

@@ -28,25 +28,30 @@ module Gamefic
     # Disconnect the current User.
     #
     def disconnect
-      # TODO: We might need some cleanup here. Like, move the character out of the game, or set a timeout to allow dropped users to reconnect... figure it out.
       @user = nil
     end
     
     # Perform a command.
     # The command can be specified as a String or a set of tokens. Either form
     # should yield the same result, but using tokens can yield better
-    # performance since it doesn't need to parse the command first.
+    # performance since it bypasses the parser.
     #
     # The command will be executed immediately regardless of game state.
     #
+    # If the from_user argument is true, the command is assumed to have come
+    # directly from user input. The character's last_order and last_object
+    # will be updated with the result.
+    #
     # @example Send a command as a string
     #   character.perform "take the key"
     #
     # @example Send a command as a set of tokens
     #   character.perform :take, @key
     #
-    def perform(*command)
-      Director.dispatch(self, *command)
+    def perform(*command, from_user: false)
+      o = Director.dispatch(self, *command)
+      last_order = o if from_user
+      o
     end
     
     # Quietly perform a command.
@@ -79,7 +84,7 @@ module Gamefic
           # compatibility with Opal.
           message = message.gsub(/[ \t\r]*\n[ \t\r]*\n[ \t\r]*/, '</p><p>')
           message = message.gsub(/[ \t]*\n[ \t]*/, ' ')
-          user.stream.send message
+          user.send message
         end
       end
     end
@@ -89,15 +94,16 @@ module Gamefic
     #
     # @param message [String]
     def stream(message)
-      user.stream.send message.strip if !user.nil?
-    end
-    
-    def destroy
-      if @user != nil
-        @user.quit
-      end
-      super
+      user.send message.strip unless user.nil?
     end
+
+    # TODO This might not be necessary. The User#quit method was a noop anyway.
+    #def destroy
+    #  if @user != nil
+    #    @user.quit
+    #  end
+    #  super
+    #end
     
     # Proceed to the next Action in the current stack.
     # This method is typically used in Action blocks to cascade through

data/lib/gamefic/engine.rb

@@ -1,108 +1,7 @@
 module Gamefic
 
-  class Engine
-    def initialize(plot)
-      @plot = plot
-      post_initialize
-    end
-    def post_initialize
-      @user = User.new @plot
-    end
-    def run
-      @plot.introduce @user.character
-      print @user.state.output
-      while !@plot.concluded?(@user.character)
-        turn
-      end
-      print @user.state.output
-    end
-    def turn
-      @plot.ready
-      print @user.state.output
-      if !@user.character[:test_queue].nil? and @user.character[:test_queue].length > 0
-        test_command = @user.character[:test_queue].shift
-        @user.character.tell "[TESTING] #{@plot.scenes[@user.character.scene].prompt} #{test_command}"
-        @user.character.queue.push test_command 
-      else
-        @user.stream.select @plot.scenes[@user.character.scene].prompt
-        @user.state.input
-      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', :proper_named => true
-      @character.connect self
-      post_initialize
-    end
-    def post_initialize
-      @stream = UserStream.new
-      @state = UserState.new self
-    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
-      @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 input
-      line = @user.stream.recv
-      if line != nil
-        @user.character.queue.push line
-      end
-    end
-    def output
-      @user.stream.flush
-    end
+  module Engine
+    autoload :Base, 'gamefic/engine/base'
   end
 
 end

data/lib/gamefic/engine/base.rb

@@ -0,0 +1,55 @@
+module Gamefic
+
+  # Basic functionality for running a single-player game from a console.
+  #
+  class Engine::Base
+    attr_writer :user_class
+    attr_reader :plot
+
+    def initialize(plot)
+      @plot = plot
+      post_initialize
+    end
+
+    def post_initialize
+      # Override in subclasses
+    end
+
+    def user_class
+      @user_class ||= Gamefic::User::Base
+    end
+
+    def connect
+      @character = @plot.make Character, name: 'yourself', synonyms: 'self myself you me', proper_named: true
+      @user = user_class.new
+      @character.connect @user
+      @character
+    end
+
+    def run
+      connect
+      @plot.introduce @character
+      print @user.flush
+      turn until @plot.concluded?(@character)
+      print @user.flush
+    end
+
+    def turn
+      @plot.ready
+      print @user.flush
+      if @character.queue.empty?
+        receive
+      end
+      @plot.update
+      print @user.flush
+    end
+
+    def receive
+      print @plot.scenes[@character.scene].prompt_for(@character) + ' '
+      input = STDIN.gets
+      @character.queue.push input unless input.nil?
+      puts ''
+    end
+  end
+
+end

data/lib/gamefic/engine/tty.rb

@@ -1,254 +1,20 @@
-require 'gamefic/engine'
-require 'rexml/document'
-require 'gamefic/ansi'
-require 'gamefic/html'
-require 'json'
-
-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, snapshot
-        data = snapshot.merge(:metadata => @character.plot.metadata)
-        json = JSON.generate data
-        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)
-            data = JSON.parse File.read(filename), symbolize_names: true
-            if (data[:metadata] != @character.plot.metadata)
-              @character.tell "The save file is not compatible with this version of the game."
-            else
-              return data
-            end
-          else
-            @character.tell "File \"#{filename}\" not found."
-          end
-        end
-        nil
-      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.strip}</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
-          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 'body', 'p', 'ol', 'ul'
-              formats.push Extra::BLOCK
-            when 'pre'
-              formats.push [Extra::BLOCK, Extra::PRE]
-            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) and !has_code?(stack.last, Extra::PRE)
-            element.texts.first.value.lstrip! unless element.texts.first.nil?
-            element.texts.last.value.rstrip! unless element.texts.last.nil?
-            element.texts.each { |t|
-              t.value = t.value.gsub(/ +/, ' ').strip
-            }
-          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
+require 'gamefic/user/tty'
+
+module Gamefic
+
+  # Extend Engine::Base to connect with User::Tty, which provides ANSI
+  # formatting for HTML.
+  #
+  class Engine::Tty < Engine::Base
+    def post_initialize
+      self.user_class = Gamefic::User::Tty
+    end
+
+    def self.start plot
+      engine = self.new(plot)
+      engine.connect
+      engine.run
+    end
+  end
+
+end