gamefic 1.4.1 → 1.5.0

data/lib/gamefic/scene/multiple_choice.rb

@@ -14,6 +14,7 @@ module Gamefic
 
     def start actor
       data = start_data_for(actor)
+      data.options.clear
       do_start_block actor, data
       tell_options actor, data
     end

data/lib/gamefic/scene/yes_or_no.rb

@@ -15,7 +15,7 @@ module Gamefic
       if data.yes? or data.no?
         this_scene = actor.scene
         do_finish_block actor, data
-        actor.cue :active if (actor.scene == this_scene and actor.next_scene.nil?)
+        #actor.cue :active if (actor.scene == this_scene and actor.next_scene.nil?)
       else
         actor.tell data.invalid_message
       end

data/lib/gamefic/scene_data/multiple_scene.rb

@@ -1,8 +1,6 @@
 module Gamefic
 
   class SceneData::MultipleScene < SceneData::MultipleChoice
-    attr_accessor :selection
-    attr_accessor :number
     def options
       scene_map.keys
     end
@@ -15,8 +13,6 @@ module Gamefic
       scene_map[choice]
     end
 
-    private
-
     def scene_map
       @scene_map ||= {}
     end

data/lib/gamefic/shell.rb

@@ -70,7 +70,6 @@ module Gamefic
       plot = Plot.new(Source::File.new(File.join(directory, 'scripts')))
       plot.script 'main'
       plot.metadata = YAML.load_file File.join(directory, 'metadata.yaml')
-      puts ""
       Engine::Tty.start(plot)
     end
   end

data/lib/gamefic/source/file.rb

@@ -16,7 +16,7 @@ module Gamefic
           end
         }
       }
-      raise "Script #{path} not found"
+      raise LoadError.new("cannot load script -- #{path}")
     end
   end
 

data/lib/gamefic/stage.rb

@@ -3,16 +3,17 @@ 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?
+      return @stage unless @stage.nil?
       
       exposed = self.class.exposed_methods.keys
       mounted = self.class.mounted_modules.keys
@@ -44,6 +45,7 @@ module Gamefic
       
       return @stage 
     end
+
     module ClassMethods
       def mount *args
         args.each { |a|
@@ -51,22 +53,28 @@ module Gamefic
           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

data/lib/gamefic/subplot.rb

@@ -1,82 +1,99 @@
+require 'gamefic/plot'
+
 module Gamefic
 
   class Subplot
-    module Element
-      attr_reader :subplot
-    end
-    module Feature
-      def subplots
-        p_subplots.clone
-      end
-      private
-      def p_subplots
-        @p_subplots ||= []
-      end
-    end
-    module Host
-      # Get an array of all the current subplots.
-      #
-      # @return [Array<Subplot>]
-      def subplots
-        p_subplots.clone
-      end
-      
-      # Start a new subplot based on the provided class.
-      #
-      # @param [Class] The class of the subplot to be created (Subplot by default)
-      # @return [Subplot]
-      def branch subplot_class, feature:nil, &block
-        subplot = subplot_class.new(self, feature: feature, &block)
-        p_subplots.push subplot
-        subplot
+    include Stage
+    
+    attr_reader :plot
+    attr_writer :denied_message
+
+    mount Plot::Entities
+    mount Plot::CommandMount
+    mount Plot::Callbacks
+    mount Plot::SceneMount
+    expose :plot, :conclude
+
+    class << self
+      def start_proc
+        @start_proc
       end
-      
+
       private
-      def p_subplots
-        @p_subplots ||= []
+
+      def on_start &block
+        @start_proc = block
       end
     end
-    
-    attr_reader :plot, :entities, :players
-    
-    def initialize plot, feature:nil
+
+    def initialize plot, introduce: nil
       @plot = plot
-      @entities = []
-      @players = []
       @concluded = false
-      post_initialize
-      yield(self) if block_given?
-      introduce feature unless feature.nil?
+      stage &self.class.start_proc unless self.class.start_proc.nil?
+      playbook.freeze
+      self.introduce introduce unless introduce.nil?
+    end
+
+    def default_scene
+      plot.default_scene
+    end
+
+    def default_conclusion
+      plot.default_conclusion
+    end
+
+    def playbook
+      @playbook ||= plot.playbook.dup
     end
-    def post_initialize
+
+    # HACK: Always assume subplots are running for the sake of entity destruction    
+    def running?
+      true
     end
-    def make *args
-      e = plot.make(*args)
-      e.extend Gamefic::Subplot::Element
-      e.instance_variable_set(:@subplot, self)
-      entities.push e
-      e
+
+    def denied_message
+      @denied_message ||= 'You are already involved in another subplot.'
     end
+
     def introduce player
-      player.send(:p_subplots).push self
-      players.push player
+      if plot.subbed?(player)
+        player.tell denied_message
+      else
+        super
+      end
     end
+
     def exeunt player
-      player.send(:p_subplots).delete self
-      players.delete player
+      player.playbook = plot.playbook
+      p_players.delete player
     end
+
     def conclude
-      concluded = true
+      @concluded = true
       entities.each { |e|
-        e.destroy
+        destroy e
       }
       players.each { |p|
         exeunt p
       }
     end
+
     def concluded?
       @concluded
     end
+
+    def ready
+      conclude if players.empty?
+      return if concluded?
+      playbook.freeze
+      call_ready
+      call_player_ready
+    end
+
+    def update
+      call_player_update
+      call_update
+    end
   end
   
 end

data/lib/gamefic/syntax.rb

@@ -60,7 +60,10 @@ module Gamefic
       m = text.match(@regexp)
       return nil if m.nil?
       arguments = []
-      @replace.to_s.split_words.each { |r|
+      # HACK: Skip the first word if the verb is not nil.
+      # This is ugly.
+      b = @verb.nil? ? 0 : 1
+      @replace.to_s.split_words[b..-1].each { |r|
         if r.match(/^\{\$[0-9]+\}$/)
           arguments.push m[r[2..-2].to_i]
         else
@@ -70,6 +73,10 @@ module Gamefic
       Command.new @verb, arguments
     end
     
+    def accept? text
+      !text.match(@regexp).nil?
+    end
+
     # Get a signature that identifies the form of the Syntax.
     # Signatures are used to compare Syntaxes to each other.
     #
@@ -106,7 +113,7 @@ module Gamefic
         }
         cb <=> ca
       }
-      matches      
+      matches
     end
   end
 

data/lib/gamefic/tester.rb

@@ -9,7 +9,7 @@ module Gamefic
     end
     def run_test name, actor
       queue = []
-      actor.plot.stage actor, queue, &test_procs[name]
+      stage actor, queue, &test_procs[name]
       actor.queue.push *queue
       actor[:test_queue_length] = queue.length
       actor[:test_queue_scene] = actor.scene

data/lib/gamefic/text.rb

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

data/lib/gamefic/{ansi.rb → text/ansi.rb}

@@ -1,11 +1,8 @@
 module Gamefic
 
-  # Constants for ANSI codes, plus Extras for custom formatting.
-  module Ansi
+  # Constants for ANSI codes, plus ExtraCodes for custom formatting.
+  module Text::Ansi
     module Code
-      class Nonstandard < String
-      
-      end
       module Attribute
         NORMAL = 0
         BOLD = 1
@@ -35,19 +32,19 @@ module Gamefic
         WHITE = 47
       end
       module Extra
-        BLOCK = Nonstandard.new("block")
-        PRE = Nonstandard.new("pre")
-        HREF = Nonstandard.new("href")
-        IMAGE = Nonstandard.new("image")
-        SRC = Nonstandard.new("src")
-        UPPERCASE = Nonstandard.new("uppercase")
-        COMMAND = Nonstandard.new("command")
-        IGNORED = Nonstandard.new("ignored")
-        LINE = Nonstandard.new("line")
+        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_not(Code::Nonstandard)
+      ansi = settings.flatten.that_are(Fixnum)
       return '' if ansi.length == 0
       "\e[#{ansi.join(';')}m"
     end

data/lib/gamefic/text/html.rb

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

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