gamefic 2.3.0 → 3.0.0

data/lib/gamefic/plot/darkroom.rb

@@ -1,120 +0,0 @@
-module Gamefic
-  # Create and restore plot snapshots.
-  #
-  class Plot
-    class Darkroom
-      # @return [Plot]
-      attr_reader :plot
-
-      # @param plot [Plot]
-      def initialize plot
-        @plot = plot
-      end
-
-      # Create a snapshot of the plot.
-      #
-      # @return [Hash]
-      def save
-        {
-          'program' => {}, # @todo Metadata for version control, etc.
-          'index' => index.map { |obj| serialize_indexed(obj) }
-        }
-      end
-
-      # Restore a snapshot.
-      #
-      # @param snapshot [Hash]
-      def restore snapshot
-        # @todo Use `program` for verification
-
-        plot.subplots.each(&:conclude)
-        plot.subplots.clear
-
-        index = plot.static + plot.players
-        snapshot['index'].each_with_index do |obj, idx|
-          next if index[idx]
-          elematch = obj['class'].match(/^#<ELE_([\d]+)>$/)
-          if elematch
-            klass = index[elematch[1].to_i]
-          else
-            klass = Gamefic::Serialize.string_to_constant(obj['class'])
-          end
-          index.push klass.allocate
-        end
-
-        snapshot['index'].each_with_index do |obj, idx|
-          if index[idx].class.to_s != obj['class']
-            STDERR.puts "MISMATCH: #{index[idx].class} is not #{obj['class']}"
-            STDERR.puts obj.inspect
-          end
-          obj['ivars'].each_pair do |k, v|
-            next if k == '@subplots'
-            uns = v.from_serial(index)
-            next if uns == "#<UNKNOWN>"
-            index[idx].instance_variable_set(k, uns)
-          end
-          if index[idx].is_a?(Gamefic::Subplot)
-            index[idx].extend Gamefic::Scriptable
-            index[idx].instance_variable_set(:@theater, nil)
-            index[idx].send(:run_scripts)
-            index[idx].players.each do |pl|
-              pl.playbooks.push index[idx].playbook unless pl.playbooks.include?(index[idx].playbook)
-            end
-            index[idx].instance_variable_set(:@static, [index[idx]] + index[idx].scene_classes + index[idx].entities)
-            plot.subplots.push index[idx]
-          end
-        end
-      end
-
-      private
-
-      def index
-        @index ||= begin
-          populate_full_index_from(plot)
-          Set.new(plot.static + plot.players).merge(full_index).to_a
-        end
-      end
-
-      def full_index
-        @full_index ||= Set.new
-      end
-
-      def populate_full_index_from(object)
-        return if full_index.include?(object)
-        if object.is_a?(Array) || object.is_a?(Set)
-          object.each { |ele| populate_full_index_from(ele) }
-        elsif object.is_a?(Hash)
-          object.each_pair do |k, v|
-            populate_full_index_from(k)
-            populate_full_index_from(v)
-          end
-        else
-          if object.is_a?(Gamefic::Serialize)
-            full_index.add object unless object.is_a?(Module) && object.name
-            object.instance_variables.each do |v|
-              next if object.class.excluded_from_serial.include?(v)
-              populate_full_index_from(object.instance_variable_get(v))
-            end
-          else
-            object.instance_variables.each do |v|
-              populate_full_index_from(object.instance_variable_get(v))
-            end
-          end
-        end
-      end
-
-      def serialize_indexed object
-        if object.is_a?(Gamefic::Serialize)
-          # Serialized objects in the index should be a full serialization.
-          # Serialize#to_serial rturns a reference to the indexed object.
-          {
-            'class' => object.class.to_s,
-            'ivars' => object.serialize_instance_variables(index)
-          }
-        else
-          object.to_serial(index)
-        end
-      end
-    end
-  end
-end

data/lib/gamefic/plot/host.rb

@@ -1,42 +0,0 @@
-require 'gamefic/subplot'
-
-module Gamefic
-  # Methods for hosting and managing subplots.
-  #
-  module Plot::Host
-    # Get an array of all the current subplots.
-    #
-    # @return [Array<Subplot>]
-    def subplots
-      @subplots ||= []
-    end
-
-    # Start a new subplot based on the provided class.
-    #
-    # @param subplot_class [Class<Gamefic::Subplot>] The class of the subplot to be created (Subplot by default)
-    # @return [Gamefic::Subplot]
-    def branch subplot_class = Gamefic::Subplot, introduce: nil, next_cue: nil, **more
-      subplot = subplot_class.new(self, introduce: introduce, next_cue: next_cue, **more)
-      subplots.push subplot
-      subplot
-    end
-
-    # Get the player's current subplots.
-    #
-    # @return [Array<Subplot>]
-    def subplots_featuring player
-      result = []
-      subplots.each { |s|
-        result.push s if s.players.include?(player)
-      }
-      result
-    end
-
-    # Determine whether the player is involved in a subplot.
-    #
-    # @return [Boolean]
-    def in_subplot? player
-      !subplots_featuring(player).empty?
-    end
-  end
-end

data/lib/gamefic/plot/snapshot.rb

@@ -1,27 +0,0 @@
-require 'json'
-
-module Gamefic
-  module Plot::Snapshot
-    # Save the current game state as a data hash.
-    # See Gamefic::Plot::Darkroom for more information about
-    # the data format.
-    #
-    # @return [Hash]
-    def save
-      Gamefic::Plot::Darkroom.new(self).save
-    end
-
-    # Restore the game state from a snapshot.
-    #
-    # If `snapshot` is a string, parse it as a JSON object.
-    #
-    # @note The string conversion is performed as a convenience for web apps.
-    #
-    # @param snapshot [Hash, String]
-    # @return [void]
-    def restore snapshot
-      snapshot = JSON.parse(snapshot) if snapshot.is_a?(String)
-      Gamefic::Plot::Darkroom.new(self).restore(snapshot)
-    end
-  end
-end

data/lib/gamefic/query/children.rb

@@ -1,9 +0,0 @@
-module Gamefic
-  module Query
-    class Children < Base
-      def context_from(subject)
-        subject.children
-      end
-    end
-  end
-end

data/lib/gamefic/query/descendants.rb

@@ -1,15 +0,0 @@
-module Gamefic
-  module Query
-    class Descendants < Children
-      def context_from(subject)
-        result = []
-        children = super
-        result.concat children
-        children.each do |c|
-          result.concat subquery_accessible(c)
-        end
-        result
-      end
-    end
-  end
-end

data/lib/gamefic/query/external.rb

@@ -1,39 +0,0 @@
-module Gamefic
-  module Query
-    class External < Base
-      # @param container [Plot, Subplot, Array]
-      def initialize container, *args
-        super(*args)
-        @container = container
-      end
-
-      def context_from subject
-        Set.new
-           .merge(container_entities)
-           .merge(container_subplots_for(@container, subject))
-           .to_a
-      end
-
-      private
-
-      # @return [Array<Entity>]
-      def container_entities
-        if @container.is_a?(World::Entities)
-          @container.entities
-        elsif @container.is_a?(Enumerable)
-          @container
-        else
-          raise ArgumentError, "Unable to derive entities from #{@container}"
-        end
-      end
-
-      # @return [Array<Entity>]
-      def container_subplots_for container, subject
-        return [] unless container.is_a?(Plot::Host)
-        container.subplots_featuring(subject).flat_map do |subplot|
-          subplot.entities + container_subplots_for(subplot, subject)
-        end
-      end
-    end
-  end
-end

data/lib/gamefic/query/family.rb

@@ -1,18 +0,0 @@
-module Gamefic
-  module Query
-    # Query to retrieve the subject's siblings and all accessible descendants.
-    #
-    class Family < Base
-      def context_from(subject)
-        result = []
-        result.concat subquery_accessible(subject.parent)
-        result.delete subject
-        subject.children.each { |c|
-          result.push c
-          result.concat subquery_accessible(c)
-        }
-        result
-      end
-    end
-  end
-end

data/lib/gamefic/query/itself.rb

@@ -1,13 +0,0 @@
-module Gamefic
-  module Query
-    class Itself < Base
-      def context_from(subject)
-        [subject]
-      end
-
-      def include?(subject, object)
-        return false unless accept?(object) and subject == object
-      end
-    end
-  end
-end

data/lib/gamefic/query/matches.rb

@@ -1,75 +0,0 @@
-module Gamefic
-  module Query
-    class Matches
-      # The resolved tokens
-      # @return [Array<Object>]
-      attr_reader :objects
-
-      # The matching string
-      # @return [String]
-      attr_reader :matching
-
-      # The remaining (unmatched) string
-      # @return [String]
-      attr_reader :remaining
-
-      def initialize objects, matching, remaining
-        @objects = objects
-        @matching = matching
-        @remaining = remaining
-      end
-
-      def self.execute objects, description, continued: false
-        if continued
-          match_with_remainder objects, description
-        else
-          match_without_remainder objects, description
-        end
-      end
-
-      class << self
-        private
-
-        def match_without_remainder objects, description
-          matches = objects.select{ |e| e.specified?(description) }
-          if matches.empty?
-            matching = ''
-            remaining = description
-          else
-            matching = description
-            remaining = ''
-          end
-          Matches.new(matches, matching, remaining)
-        end
-
-        def match_with_remainder objects, description
-          matching_objects = objects
-          matching_text = []
-          words = description.split(Keywords::SPLIT_REGEXP)
-          i = 0
-          words.each { |w|
-            cursor = inner_match matching_objects, words, matching_text, i, w
-            break if cursor.empty? or (cursor & matching_objects).empty?
-            matching_objects = (cursor & matching_objects)
-            i += 1
-          }
-          objects = matching_objects
-          matching = matching_text.uniq.join(' ')
-          remaining = words[i..-1].join(' ')
-          Matches.new(objects, matching, remaining)
-        end
-
-        def inner_match matching_objects, words, matching_text, i, w
-          cursor = []
-          matching_objects.each { |o|
-            if o.specified?(words[0..i].join(' '), fuzzy: true)
-              cursor.push o
-              matching_text.push w
-            end
-          }
-          cursor
-        end
-      end
-    end
-  end
-end

data/lib/gamefic/query/parent.rb

@@ -1,9 +0,0 @@
-module Gamefic
-  module Query
-    class Parent < Base
-      def context_from(subject)
-        subject.parent.nil? ? [] : [subject.parent]
-      end
-    end
-  end
-end

data/lib/gamefic/query/siblings.rb

@@ -1,13 +0,0 @@
-module Gamefic
-  module Query
-    class Siblings < Base
-      def context_from(subject)
-        result = []
-        unless subject.parent.nil?
-          result.concat(subject.parent.children - [subject])
-        end
-        result
-      end
-    end
-  end
-end

data/lib/gamefic/query/tree.rb

@@ -1,17 +0,0 @@
-module Gamefic
-  module Query
-    # Query to retrieve all of the subject's ancestors, siblings, and descendants.
-    #
-    class Tree < Family
-      def context_from(subject)
-        result = super
-        parent = subject.parent
-        until parent.nil?
-          result.unshift parent
-          parent = parent.parent
-        end
-        result
-      end
-    end
-  end
-end

data/lib/gamefic/scene/base.rb

@@ -1,142 +0,0 @@
-module Gamefic
-  # An abstract class for building different types of scenes. It can be
-  # extended either through concrete subclasses or by creating anonymous
-  # subclasses through a scene helper method like
-  # `Gamefic::World::Scenes#custom`.
-  #
-  class Scene::Base
-    include Gamefic::Serialize
-    extend Gamefic::Serialize
-
-    # The scene's primary actor.
-    #
-    # @return [Gamefic::Actor]
-    attr_reader :actor
-
-    # A human-readable string identifying the type of scene.
-    #
-    # @return [String]
-    attr_writer :type
-
-    # The text to display when requesting input.
-    #
-    # @return [String]
-    attr_writer :prompt
-
-    # The input received from the actor.
-    #
-    # @return [String]
-    attr_reader :input
-
-    # @return [Hash{Symbol => Object}]
-    attr_reader :data
-
-    def initialize actor, **data
-      @actor = actor
-      @data = data
-      post_initialize
-    end
-
-    # A shortcut for the #data hash.
-    #
-    # @param key [Symbol]
-    # @return [Object]
-    def [] key
-      data[key]
-    end
-
-    def post_initialize
-    end
-
-    # Set a proc to be executed at the end of the scene.
-    #
-    def on_finish &block
-      @finish_block = block
-    end
-
-    # Update the scene.
-    #
-    def update
-      @input = actor.queue.shift
-      finish
-    end
-
-    # Start the scene.
-    #
-    def start
-      self.class.start_block.call @actor, self unless self.class.start_block.nil?
-      @actor.entered self if tracked?
-    end
-
-    # Finish the scene.
-    #
-    def finish
-      @finish_block.call @actor, self unless @finish_block.nil?
-      @finished = true
-    end
-
-    # Determine whether the scene's execution is finished.
-    #
-    # @return [Boolean]
-    def finished?
-      @finished ||= false
-    end
-
-    # Get a hash that describes the current state of the scene.
-    #
-    # @return [Hash]
-    def state
-      {
-        scene: type, prompt: prompt
-      }
-    end
-
-    # @yieldparam [Class<Gamefic::Actor>]
-    # @return [Class<Gamefic::Scene::Base>]
-    def self.subclass &block
-      c = Class.new(self) do
-        on_start &block
-      end
-      c
-    end
-
-    # Get the prompt to be displayed to the user when accepting input.
-    #
-    # @return [String] The text to be displayed.
-    def prompt
-      @prompt ||= '>'
-    end
-
-    # Get a String that describes the type of scene.
-    #
-    # @return [String]
-    def type
-      @type ||= 'Scene'
-    end
-
-    # @yieldparam [Class<Gamefic::Scene::Base>]
-    def self.on_start &block
-      @start_block = block
-    end
-
-    def tracked?
-      self.class.tracked?
-    end
-
-    def tracked= bool
-      self.class.tracked = bool
-    end
-
-    class << self
-      attr_writer :tracked
-
-      def start_block
-        @start_block
-      end
-
-      def tracked?
-        @tracked ||= false
-      end
-    end
-  end
-end

data/lib/gamefic/scene/multiple_scene.rb

@@ -1,29 +0,0 @@
-module Gamefic
-  class Scene::MultipleScene < Scene::MultipleChoice
-    def option_map
-      @option_map ||= {}
-    end
-
-    # @param option [String]
-    # @param scene [Class<Gamefic::Scene::Base>]
-    def map option, scene
-      options.push option
-      option_map[option] = scene
-    end
-
-    def finish
-      get_choice
-      unless selection.nil?
-        actor.prepare option_map[selection]
-      end
-    end
-
-    def state
-      entered = {}
-      option_map.each_pair do |k, v|
-        entered[k] = actor.entered?(v)
-      end
-      super.merge entered: entered
-    end
-  end
-end