gamefic 1.7.0 → 2.0.0

data/lib/gamefic/script/file.rb

@@ -1,14 +0,0 @@
-module Gamefic
-
-  class Script::File < Script::Base
-    attr_reader :path, :absolute_path
-    def initialize filename, path
-      @absolute_path = filename.gsub(/\/+/, '/')
-      @path = path
-    end
-    def read
-      File.read(@absolute_path)
-    end
-  end
-
-end

data/lib/gamefic/script/text.rb

@@ -1,14 +0,0 @@
-module Gamefic
-  
-  class Script::Text < Script::Base
-    attr_reader :path, :absolute_path
-    def initialize path, code, absolute_path = nil
-      @path = path
-      @code = code
-      @absolute_path = absolute_path || path
-    end
-    def read
-      @code
-    end
-  end
-end

data/lib/gamefic/shell.rb

@@ -1,76 +0,0 @@
-require 'thor'
-require 'gamefic/engine/tty'
-require 'zip'
-require 'tmpdir'
-require 'yaml'
-
-module Gamefic
-  class Shell < Thor
-    map %w[--version -v] => :version
-
-    desc "--version, -v", "Print the version"
-    def version
-      puts "gamefic #{Gamefic::VERSION}"
-    end
-    
-    desc 'play FILE_NAME', 'Execute a compiled (.gfic) game'
-    option :verbose, type: :boolean, aliases: :v, desc: "Don't suppress Ruby exceptions"
-    def play(file)
-      Dir.mktmpdir 'gamefic_' do |dir|
-        puts 'Loading...'
-        decompress file, dir
-        run_game(dir)
-      end
-    rescue Zip::Error => e
-      puts "'#{file}' does not appear to be a valid Gamefic file."
-      show_exception(e) if options[:verbose]
-    rescue StandardError => e
-      puts "An error occurred: #{e.message}"
-      show_exception(e) if options[:verbose]
-    end
-
-    desc 'info FILE_NAME', 'Print information about a (.gfic) game'
-    option :verbose, type: :boolean, aliases: :v, desc: "Don't suppress Ruby exceptions"
-    def info(file)
-      Dir.mktmpdir 'gamefic_' do |dir|
-        decompress file, dir
-        metadata = YAML.load_file File.join(dir, 'metadata.yaml')
-        metadata.each { |k, v|
-          puts "#{k}: #{v}"
-        }
-      end
-    rescue StandardError, Zip::Error => e
-      puts "'#{file}' does not appear to be a valid Gamefic file."
-      show_exception(e) if options[:verbose]
-    end
-    
-    # Custom error message for invalid command or filename
-    def method_missing(symbol, *args)
-      raise UndefinedCommandError, "Could not find command or file named \"#{symbol}\"."
-    end
-    
-    private
-
-    def show_exception(exception)
-      puts exception.inspect
-      puts exception.backtrace.join("\n")
-    end
-
-    def decompress(zipfile, destination)
-      Zip::File.open(zipfile) do |z|
-        z.each do |entry|
-          FileUtils.mkdir_p File.join(destination, File.dirname(entry.name))
-          full_path = File.join(destination, entry.name)
-          entry.extract full_path unless File.exist?(full_path)
-        end
-      end
-    end
-
-    def run_game(directory)
-      plot = Plot.new(Source::File.new(File.join(directory, 'scripts')))
-      plot.script 'main'
-      plot.metadata = YAML.load_file File.join(directory, 'metadata.yaml')
-      Engine::Tty.start(plot)
-    end
-  end
-end

data/lib/gamefic/source.rb

@@ -1,14 +0,0 @@
-module Gamefic
-
-  # Plots use Source classes to fetch scripts to be executed. The most common
-  # type of Source class is Source::File, which searches for scripts in
-  # a predefined list of directories on the filesystem, similar to the way
-  # that Kernel#require works.
-  #
-  module Source
-    autoload :Base, 'gamefic/source/base'
-    autoload :File, 'gamefic/source/file'
-    autoload :Text, 'gamefic/source/text'
-  end
-  
-end

data/lib/gamefic/source/base.rb

@@ -1,12 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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 = File.join(directory, path + ext)
-          if File.file?(abs_file)
-            return Script::File.new(abs_file, path)
-          end
-        }
-      }
-      raise LoadError.new("cannot load script -- #{path}")
-    end
-  end
-
-end

data/lib/gamefic/source/text.rb

@@ -1,16 +0,0 @@
-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/tester.rb

@@ -1,19 +0,0 @@
-module Gamefic
-
-  module Tester
-    def test_procs
-      @test_procs ||= Hash.new
-    end
-    def on_test name = :me, &block
-      test_procs[name] = block
-    end
-    def run_test name, actor
-      queue = []
-      stage actor, queue, &test_procs[name]
-      actor.queue.push *queue
-      actor[:test_queue_length] = queue.length
-      actor[:test_queue_scene] = actor.scene
-    end
-  end
-
-end

data/lib/gamefic/text.rb

@@ -1,8 +0,0 @@
-module Gamefic
-
-  module Text
-    autoload :Ansi, 'gamefic/text/ansi'
-    autoload :Html, 'gamefic/text/html'
-  end
-
-end

data/lib/gamefic/text/ansi.rb

@@ -1,53 +0,0 @@
-module Gamefic
-
-  # Constants for ANSI codes, plus ExtraCodes for custom formatting.
-  module Text::Ansi
-    module Code
-      module Attribute
-        NORMAL = 0
-        BOLD = 1
-        UNDERSCORE = 4
-        BLINK = 5
-        REVERSE = 7
-        CONCEALED = 8
-      end
-      module Foreground
-        BLACK = 30
-        RED = 31
-        GREEN = 32
-        YELLOW = 33
-        BLUE = 34
-        MAGENTA = 35
-        CYAN = 36
-        WHITE = 37
-      end
-      module Background
-        BLACK = 40
-        RED = 41
-        GREEN = 42
-        YELLOW = 43
-        BLUE = 44
-        MAGENTA = 45
-        CYAN = 46
-        WHITE = 47
-      end
-      module Extra
-        BLOCK = :block
-        PRE = :pre
-        HREF = :href
-        IMAGE = :image
-        SRC = :src
-        UPPERCASE = :uppercase
-        COMMAND = :command
-        IGNORED = :ignored
-        LINE = :line
-      end
-    end  
-    def self.graphics_mode(*settings)
-      ansi = settings.flatten.that_are(Fixnum)
-      return '' if ansi.length == 0
-      "\e[#{ansi.join(';')}m"
-    end
-  end
-
-end

data/lib/gamefic/text/html.rb

@@ -1,68 +0,0 @@
-require 'rexml/document'
-require 'gamefic/text/html/entities'
-
-module Gamefic
-  module Text
-    module Html
-      autoload :Conversions, 'gamefic/text/html/conversions'
-
-      # Convert ampersands to &
-      #
-      # @param text [String]
-      # @return [String]
-      def self.fix_ampersands(text)
-        codes = []
-        ENTITIES.keys.each { |e|
-          codes.push e[1..-1]
-        }
-        piped = codes.join('|')
-        re = Regexp.new("&(?!(#{piped}))")
-        text.gsub(re, '&\1')
-      end
-      
-      # Encode a String with HTML entities
-      #
-      # @param text [String]
-      # @return [String]
-      def self.encode(text)
-        encoded = text
-        ENTITIES.each { |k, v|
-          encoded = encoded.gsub(v, k)
-        }
-        encoded
-      end
-      
-      # Decode a String's HTML entities
-      #
-      # @param text [String]
-      # @return [String]
-      def self.decode(text)
-        ENTITIES.each { |k, v|
-          text = text.gsub(k, v)
-        }
-        text
-      end
-      
-      # Parse a String into an XML document
-      #
-      # @param code [String]
-      # @return [REXML::Document]
-      def self.parse(code)
-        code = fix_ampersands(code).strip
-        last = nil
-        begin
-          doc = REXML::Document.new code
-        rescue REXML::ParseException => e
-          # Convert invalid < characters to &lt;
-          if e.source.buffer != last and e.source.buffer[0,1] == '<'
-            code = code[0,(code.length - e.source.buffer.length)] + '&lt;' + e.source.buffer[1..-1]
-            last = e.source.buffer
-            retry
-          end
-          raise e
-        end
-      end
-    end
-  end
-
-end

data/lib/gamefic/text/html/conversions.rb

@@ -1,250 +0,0 @@
-require 'gamefic/text/ansi'
-require 'gamefic/text/html'
-require 'io/console'
-
-module Gamefic
-
-  module Text::Html::Conversions
-    include Gamefic::Text
-
-    def self.html_to_ansi text, wrap: true, width: nil
-      return '' if text.strip == ''
-      output = ''
-      begin
-        doc = Html.parse("<body>#{text.gsub(/\r/, '').strip}</body>")
-        output = AnsiFormatter.new.format(doc) + Ansi.graphics_mode(Ansi::Code::Attribute::NORMAL)
-        output = Html.decode(output)
-      rescue REXML::ParseException => e
-        output = text.strip
-      end
-      calc_width = width || size[0]
-      if calc_width.nil? or !wrap
-        output
-      else
-        terminalize(output, calc_width - 1)
-      end
-    end
-
-    def self.html_to_text text, wrap: true, width: nil
-      text = html_to_ansi text, wrap: wrap, width: width
-      text.gsub(/\e\[([;\d]+)?m/, '').gsub(/\n +\n/, "\n\n")
-    end
-
-    class AnsiNode
-      include Gamefic::Text::Ansi::Code
-      attr_accessor :parent
-      
-      def render
-      end
-
-      def in_block?
-        p = parent
-        while !p.nil?
-          return true if p.kind_of?(BlockNode)
-          p = p.parent
-        end
-        false
-      end
-    end
-    private_constant :AnsiNode
-
-    class TextNode < AnsiNode
-      @@prev_format = nil
-      attr_reader :text, :format
-      def initialize text, format
-        @text = text
-        @format = format
-      end
-      def render
-        return @text if format.include?(Extra::PRE)
-        index = parent.children.index(self)
-        if index > 0
-          prev = parent.children[index - 1]
-          if prev.kind_of?(TextNode) and prev.format == format
-            if prev.text.match(/ $/)
-              return @text.lstrip
-            else
-              return @text
-            end
-          end
-        end
-        if @@prev_format == format
-          @text
-        else
-          @prev_format = format
-          Gamefic::Text::Ansi.graphics_mode(*format) + @text
-        end
-      end
-    end
-    private_constant :TextNode
-
-    class ElementNode < AnsiNode
-      def children
-        @children ||= []
-      end
-      def append child
-        children.push child
-        child.parent = self
-      end
-    end
-    private_constant :ElementNode
-
-    class BlockNode < ElementNode
-      def render
-        output = ''
-        children.each { |c|
-          output += c.render
-        }
-        output = "\n" + output.strip unless in_block?
-        output
-      end
-    end
-    private_constant :BlockNode
-
-    class InlineNode < ElementNode
-      def render
-        output = ''
-        children.each { |c|
-          output += c.render
-          output += "\n" if c.kind_of?(BlockNode)
-        }
-        output
-      end
-    end
-    private_constant :InlineNode
-
-    class BreakNode < ElementNode
-      def render
-        output = ''
-        children.each { |c|
-          output += c.render
-        }
-        output + "\n"
-      end
-    end
-    private_constant :BreakNode
-
-    class AnsiFormatter
-      include Gamefic::Text::Ansi::Code
-      def format document
-        @document = document
-        @ansi_root = InlineNode.new
-        @list_index = []
-        format_recursively @document.root, @ansi_root, [Attribute::NORMAL]
-        output = @ansi_root.render
-        output += (@ansi_root.children.last.kind_of?(BlockNode) ? "\n" : "")
-      end
-
-      def format_recursively element, ansi_node, stack
-        if element.is_a?(REXML::Text)
-          append_text element, ansi_node, stack
-        else
-          current = []
-          case element.name
-          when 'b', 'strong', 'em'
-            current.push Attribute::BOLD
-            format_children element, ansi_node, stack + current
-          when 'i', 'u'
-            current.push Attribute::UNDERSCORE
-            format_children element, ansi_node, stack + current
-          when 'h1', 'h2', 'h3', 'h4', 'h5'
-            current.push Attribute::BOLD, Extra::UPPERCASE
-            format_paragraph element, ansi_node, stack + current
-          when 'p'
-            format_paragraph element, ansi_node, stack
-          when 'ol', 'ul'
-            @list_index.push 0
-            format_paragraph element, ansi_node, stack
-            @list_index.pop
-          when 'li'
-            format_list_item element, ansi_node, stack
-          when 'pre'
-            current.push Extra::PRE
-            format_children element, ansi_node, stack + current
-          when 'br'
-            ansi_node.append TextNode.new("\n", stack + [Extra::PRE])
-          else
-            format_children element, ansi_node, stack
-          end
-        end
-      end
-
-      def append_text element, ansi_node, stack
-        text = element.to_s
-        text.gsub!(/[\s]+/, ' ') unless stack.include?(Extra::PRE)
-        text.upcase! if stack.include?(Extra::UPPERCASE)
-        ansi_node.append TextNode.new(text, stack)
-      end
-
-      def format_children element, node, stack
-        element.each { |e|
-          format_recursively e, node, stack
-        }
-      end
-
-      def format_paragraph element, node, stack
-        paragraph = BlockNode.new
-        node.append paragraph
-        format_children element, paragraph, stack
-      end
-
-      def format_list_item element, node, stack
-        i = 0
-        unless @list_index.empty?
-          @list_index[-1] = @list_index[-1] + 1
-          i = @list_index[-1] 
-        end
-        b = BreakNode.new
-        node.append b
-        if element.parent.name == 'ol'
-          b.append TextNode.new("#{i}. ", stack)
-        else
-          b.append TextNode.new("* ", stack)
-        end
-        format_children element, b, stack
-      end
-    end
-    private_constant :AnsiFormatter
-
-    def self.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
-    end
-
-    def self.size
-      begin
-        return STDOUT.winsize.reverse
-      rescue
-        return [nil,nil]
-      end
-    end
-  end
-
-end