fable 0.5.0

data/lib/fable/choice.rb

@@ -0,0 +1,31 @@
+module Fable
+  class Choice < RuntimeObject
+    # The main text presented to the player for this choice
+    attr_accessor :text
+
+
+    # Get the path to the original choice point - where was this choice
+    # defined in the story?
+    attr_accessor :source_path
+
+    # The original index into current_choices list on the Story when
+    # this choice was generated, for convenience
+    attr_accessor :index
+
+    attr_accessor :target_path, :thread_at_generation, :original_thread_index,
+      :invisible_default
+
+    alias_method :invisible_default?, :invisible_default
+
+    # The target path that the story should be diverted to
+    # if the choice is chosen
+    def path_string_on_choice
+      return self.target_path.to_s
+    end
+
+    def path_string_on_choice=(value)
+      self.target_path = Path.new(value)
+      value
+    end
+  end
+end

data/lib/fable/choice_point.rb

@@ -0,0 +1,65 @@
+module Fable
+  class ChoicePoint < RuntimeObject
+    attr_accessor :has_condition,
+      :has_start_content, :has_choice_only_content,
+      :invisible_default,
+      :once_only, :path_on_choice
+
+      alias_method :invisible_default?, :invisible_default
+      alias_method :has_start_content?, :has_start_content
+      alias_method :has_condition?, :has_condition
+      alias_method :has_choice_only_content?, :has_choice_only_content
+      alias_method :once_only?, :once_only
+
+    # The ChoicePoint represents the point within the Story
+    # where a Choice instance gets generated. The distinction
+    # is made because the text of the choice can be dynamically
+    # generated
+    def path_on_choice
+      # Resolve any relative pahts to global ones as we come across them
+      if !@path_on_choice.nil? && @path_on_choice.relative?
+        choice_target_object = choice_target
+        if !choice_target_object.nil?
+          @path_on_choice = choice_target_object.path
+        end
+      end
+
+      return @path_on_choice
+    end
+
+    def path_on_choice=(value)
+      @path_on_choice = value
+    end
+
+    def choice_target
+      self.resolve_path(@path_on_choice).container
+    end
+
+    def path_string_on_choice
+      compact_path_string(path_on_choice)
+    end
+
+    def path_string_on_choice=(value)
+      self.path_on_choice = Path.new(value)
+    end
+
+    def flags=(flag)
+      self.has_condition = (flag & 1) > 0
+      self.has_start_content = (flag & 2) > 0
+      self.has_choice_only_content = (flag & 4) > 0
+      self.invisible_default = (flag & 8) > 0
+      self.once_only = (flag & 16) > 0
+    end
+
+    def to_s
+      target_line_number = debug_line_number_of_path(path_on_choice)
+      target_string = path_on_choice.to_s
+
+      if !target_line_number.nil?
+        target_string = " line #{target_line_number} (#{target_string})"
+      end
+
+      return "Choice: -> #{target_string}"
+    end
+  end
+end

data/lib/fable/container.rb

@@ -0,0 +1,218 @@
+module Fable
+  class Container < RuntimeObject
+    attr_accessor :bit_flags, :name, :content, :named_content,
+    :visits_should_be_counted, :turn_index_should_be_counted,
+    :counting_at_start_only, :path_to_first_leaf_content
+
+    def initialize(flags)
+      super()
+      self.bit_flags = flags
+      self.content = []
+      self.named_content = {}
+      self.process_bit_flags
+    end
+
+    def add_content(content_to_add)
+      if content_to_add.is_a?(Enumerable)
+        content_to_add.each{|individual_items| add_content(individual_items) }
+        return
+      end
+
+      debugger if content_to_add.nil?
+
+      if !content_to_add.parent.nil?
+        raise Error, "content is already in #{content_to_add.parent}"
+      end
+
+      content_to_add.parent = self
+      content << content_to_add
+
+      try_adding_to_named_content(content_to_add)
+    end
+
+    def insert_content_at(content_to_add, index)
+      if !content_to_add.parent.nil?
+        raise Error, "content is already in #{content_to_add.parent}"
+      end
+
+      content_to_add.parent = self
+      content.insert(index, content_to_add)
+      try_adding_to_named_content(content_to_add)
+    end
+
+    def try_adding_to_named_content(content_to_add)
+      if content_to_add.respond_to?(:valid_name?) && content_to_add.valid_name?
+        add_to_named_content(content_to_add)
+      end
+    end
+
+    def add_to_named_content(content_to_add)
+      content_to_add.parent = self
+      named_content[content_to_add.name] = content_to_add
+    end
+
+    def add_contents_of_container(other_container)
+      content += other_container.content
+      other_container.content.each do |content_to_add|
+        content_to_add.parent = self
+        try_adding_to_named_content(content_to_add)
+      end
+    end
+
+    def content_with_path_component(component)
+      if component.is_index?
+        return content[component.index]
+      elsif component.is_parent?
+        return self.parent
+      else
+        return named_content[component.name]
+      end
+    end
+
+    def content_at_path(path, options= { partial_path_start: 0, partial_path_length: -1 })
+      partial_path_length = options[:partial_path_length]
+      partial_path_start = options[:partial_path_start]
+
+      if partial_path_length == -1
+        partial_path_length = path.length
+      end
+
+      result = SearchResult.new
+      result.approximate = false
+
+      current_container = self
+      current_object = self
+
+      partial_path_end = (partial_path_length - 1)
+
+      (partial_path_start..partial_path_end).each do |i|
+        component = path.components[i]
+
+        # Path component was wrong type
+        if current_container.nil?
+          result.approximate = true
+          break
+        end
+
+        found_object = current_container.content_with_path_component(component)
+
+        # Couldn't resolve entire path?
+        if found_object.nil?
+          result.approximate = true
+          break
+        end
+
+        current_object = found_object
+        if found_object.is_a?(Container)
+          current_container = found_object
+        else
+          current_container = nil
+        end
+      end
+
+      result.object = current_object
+      return result
+    end
+
+    def build_string_of_hierarchy(io, indentation, pointed_object)
+      io << indentation_string(indentation)
+      io << "["
+
+      if self.valid_name?
+        io << " (#{self.name})"
+      end
+
+      if self == pointed_object
+        io << " <---"
+      end
+
+      io << "\n"
+
+      indentation += 1
+
+
+      content.each_with_index do |object, index|
+        if object.is_a?(Container)
+          object.build_string_of_hierarchy(io, indentation, pointed_object)
+        else
+          io << indentation_string(indentation)
+          if object.is_a?(StringValue)
+            io << "\"#{object.to_s.gsub("\n", "\\n")}\""
+          else
+            io << object.to_s
+          end
+        end
+
+        if index != (content.size - 1)
+          io << ","
+        end
+
+        if !object.is_a?(Container) && object == pointed_object
+          io << " <---"
+        end
+
+        io << "\n"
+      end
+
+      only_named_content = named_content.reject{|name, item| content.include?(item) }
+
+      if only_named_content.any?
+        io << indentation_string(indentation)
+        io << "-- named: --\n"
+
+        only_named_content.each do |key, container|
+          container.build_string_of_hierarchy(io, indentation, pointed_object)
+          io << "\n"
+        end
+      end
+
+      indentation -= 1
+
+      io << indentation_string(indentation)
+      io << "]"
+    end
+
+    def path_to_first_leaf_content
+      @path_to_first_leaf_content ||= path.path_by_appending_path(internal_path_to_first_lead_content)
+    end
+
+    def valid_name?
+      !name.to_s.empty?
+    end
+
+    alias_method :visits_should_be_counted?, :visits_should_be_counted
+    alias_method :turn_index_should_be_counted?, :turn_index_should_be_counted
+    alias_method :counting_at_start_only?, :counting_at_start_only
+
+    def process_bit_flags
+      if has_bit_flags?
+        self.visits_should_be_counted = (bit_flags & 1) > 0
+        self.turn_index_should_be_counted = (bit_flags & 2) > 0
+        self.counting_at_start_only = (bit_flags & 4) > 0
+      else
+        self.visits_should_be_counted = false
+        self.turn_index_should_be_counted = false
+        self.counting_at_start_only = false
+      end
+    end
+
+    def has_bit_flags?
+      !self.bit_flags.nil?
+    end
+
+    protected
+
+    def internal_path_to_first_lead_content
+      components = []
+      container = self
+      while !container.nil?
+        if container.content.size > 0
+          components << Path::Component.new(0)
+          container = container.content.first
+        end
+      end
+
+      return Path.new(components)
+    end
+  end
+end

data/lib/fable/control_command.rb

@@ -0,0 +1,156 @@
+module Fable
+  class ControlCommand < RuntimeObject
+    COMMANDS = {
+      NOT_SET: -1,
+      EVALUATION_START: "ev",
+      EVALUATION_OUTPUT: "out",
+      EVALUATION_END: "/ev",
+      DUPLICATE_TOPMOST: "du",
+      POP_EVALUATED_VALUE: "pop",
+      POP_FUNCTION: "~ret",
+      POP_TUNNEL: "->->",
+      BEGIN_STRING_EVALUATION_MODE: "str",
+      END_STRING_EVALUATION_MODE: "/str",
+      NOOP: "nop",
+      PUSH_CHOICE_COUNT: "choiceCnt",
+      TURNS: "turn",
+      TURNS_SINCE: "turns",
+      READ_COUNT: "readc",
+      RANDOM: "rnd",
+      SEED_RANDOM: "srnd",
+      VISIT_INDEX: "visit",
+      SEQUENCE_SHUFFLE_INDEX: "seq",
+      START_THREAD: "thread",
+      DONE: "done",
+      STORY_END: "end",
+      LIST_FROM_INT: "listInt",
+      LIST_RANGE: "range",
+      LIST_RANDOM: "lrnd",
+
+      GLUE: "<>",
+    }.freeze
+
+    LOOKUP = COMMANDS.invert.freeze
+
+    attr_accessor :command_type
+
+    def self.is_control_command?(value)
+      LOOKUP.has_key?(value)
+    end
+
+    def self.get_control_command(value)
+      raise ArgumentError if !is_control_command?(value)
+      self.new(value)
+    end
+
+    def initialize(command_symbol)
+      super()
+      self.command_type = LOOKUP[command_symbol]
+    end
+
+    def self.is_instance_of?(object, command_type)
+      object.is_a?(self) && object.command_type == command_type
+    end
+
+    def to_s
+      command_type.to_s
+    end
+
+    def self.evaluation_start
+      self.new(COMMANDS[:EVALUATION_START])
+    end
+
+    def self.evaluation_output
+      self.new(COMMANDS[:EVALUATION_OUTPUT])
+    end
+
+    def self.evaluation_end
+      self.new(COMMANDS[:EVALUATION_END])
+    end
+
+    def self.duplicate_topmost
+      self.new(COMMANDS[:DUPLICATE_TOPMOST])
+    end
+
+    def self.pop_evaluated_value
+      self.new(COMMANDS[:POP_EVALUATED_VALUE])
+    end
+
+    def self.pop_function
+      self.new(COMMANDS[:POP_FUNCTION])
+    end
+
+    def self.pop_tunnel
+      self.new(COMMANDS[:POP_TUNNEL])
+    end
+
+    def self.begin_string_evaluation_mode
+      self.new(COMMANDS[:BEGIN_STRING_EVALUATION_MODE])
+    end
+
+    def self.end_string_evaluation_mode
+      self.new(COMMANDS[:END_STRING_EVALUATION_MODE])
+    end
+
+    def self.noop
+      self.new(COMMANDS[:NOOP])
+    end
+
+    def self.push_choice_count
+      self.new(COMMANDS[:PUSH_CHOICE_COUNT])
+    end
+
+    def self.turns
+      self.new(COMMANDS[:TURNS])
+    end
+
+    def self.turns_since
+      self.new(COMMANDS[:TURNS_SINCE])
+    end
+
+    def self.read_count
+      self.new(COMMANDS[:READ_COUNT])
+    end
+
+    def self.random
+      self.new(COMMANDS[:RANDOM])
+    end
+
+    def self.seed_random
+      self.new(COMMANDS[:SEED_RANDOM])
+    end
+
+    def self.visit_index
+      self.new(COMMANDS[:VISIT_INDEX])
+    end
+
+    def self.sequence_shuffle_index
+      self.new(COMMANDS[:SEQUENCE_SHUFFLE_INDEX])
+    end
+
+    def self.start_thread
+      self.new(COMMANDS[:START_THREAD])
+    end
+
+    def self.done
+      self.new(COMMANDS[:DONE])
+    end
+
+    def self.story_end
+      self.new(COMMANDS[:STORY_END])
+    end
+
+    def self.list_from_int
+      self.new(COMMANDS[:LIST_FROM_INT])
+    end
+
+    def self.list_range
+      self.new(COMMANDS[:LIST_RANGE])
+    end
+
+    def self.list_random
+      self.new(COMMANDS[:LIST_RANDOM])
+    end
+
+  end
+end