gamefic 1.6.0 → 2.0.3

data/lib/gamefic/plot/host.rb

@@ -1,46 +1,42 @@
-require 'gamefic/subplot'
-
-module Gamefic
-
-  module Plot::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 subplot_class [Class] The class of the subplot to be created (Subplot by default)
-    # @return [Subplot]
-    def branch subplot_class = Gamefic::Subplot, introduce: nil, next_cue: nil, busy_cue: nil
-      subplot = subplot_class.new(self, introduce: introduce, next_cue: next_cue, busy_cue: busy_cue)
-      p_subplots.push subplot
-      subplot
-    end
-
-    # Get the player's current subplot or nil if none exists.
-    #
-    # @return [Subplot]
-    def subplot_for player
-      subplots.each { |s|
-        return s if s.players.include?(player)
-      }
-      nil
-    end
-
-    # Determine whether the player is involved in a subplot.
-    #
-    # @return [Boolean]
-    def in_subplot? player
-      !subplot_for(player).nil?
-    end
-
-    private
-    def p_subplots
-      @p_subplots ||= []
-    end
-  end
-
-end
+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

@@ -2,226 +2,26 @@ require 'json'
 
 module Gamefic
   module Plot::Snapshot
-  
-    # Take a snapshot of the plot's current state.
-    # The snapshot is a hash with two keys: entities and subplots.
+    # Save the current game state as a data hash.
+    # See Gamefic::Plot::Darkroom for more information about
+    # the data format.
     #
     # @return [Hash]
     def save
-      store = get_entity_hash
-      if @initial_state.nil?
-        @initial_state = store
-        store = []
-        @initial_state.length.times do
-          store.push {}
-        end
-      else
-        store = reduce(store)
-      end
-      return {
-        entities: store,
-        subplots: save_subplots,
-        metadata: metadata
-      }
+      Gamefic::Plot::Darkroom.new(self).save
     end
-    
-    # Restore the plot to the state of the provided snapshot.
+
+    # Restore the game state from a snapshot.
     #
-    # @param snapshot [Hash]
-    def restore snapshot
-      restore_initial_state
-      internal_restore snapshot[:entities]
-      restore_subplots snapshot[:subplots]
-    end
-    
-    private
-    
-    # Restore the plot to the state of its first snapshot.
+    # If `snapshot` is a string, parse it as a JSON object.
     #
-    def restore_initial_state
-        p_entities[@initial_state.length..-1].each { |e|
-          e.parent = nil
-        }
-        p_entities.slice! @initial_state.length..-1
-        internal_restore @initial_state
-    end
-    
-    def get_entity_hash
-      store = []
-      entities.each { |e|
-        hash = {}
-        e.instance_variables.each { |k|
-          next if k == :@children
-          v = e.instance_variable_get(k)
-          hash[k] = v
-        }
-        hash[:class] = e.class.to_s
-        store.push serialize_object(hash)
-      }
-      store
-    end
-    
-    def internal_restore snapshot
-      index = 0
-      snapshot.each { |hash|
-        if entities[index].nil?
-          cls = Kernel.const_get(hash[:class])
-          p_entities[index] = make cls
-        end 
-        internal_restore_hash hash, index
-        index += 1
-      }
-      nil
-    end
-
-    def internal_restore_hash hash, index
-      hash.each { |k, v|
-        if k == :scene
-          entities[index].cue v.to_sym
-        elsif (k != :class)
-          entities[index].instance_variable_set(k, unserialize(v))
-        end
-      }
-      nil
-    end
-
-    def reduce entities
-      reduced = []
-      index = 0
-      entities.each { |e|
-        r = {}
-        e.each_pair { |k, v|
-          if index >= @initial_state.length or @initial_state[index][k] != v
-            r[k] = v
-          end
-        }
-        reduced.push r
-        index += 1
-      }
-      reduced
-    end
-
-    def can_serialize? obj
-      return true if (obj == true or obj == false or obj.nil?)
-      allowed = [String, Fixnum, Float, Numeric, Entity, Direction, Hash, Array, Symbol]
-      allowed.each { |a|
-        return true if obj.kind_of?(a)
-      }
-      false
-    end
-
-    def serialize_object obj
-      return nil if obj.nil?
-      return false if obj == false
-      if obj.kind_of?(Hash)
-        return serialize_hash obj
-      elsif obj.kind_of?(Array)
-        return serialize_array obj
-      else
-        if obj.kind_of?(Entity)
-          return "#<EIN_#{p_entities.index(obj)}>"
-        elsif obj.kind_of?(Direction)
-          return "#<DIR_#{obj.name}>"
-        end
-      end
-      return obj
-    end
-
-    def serialize_hash obj
-      hash = {}
-      obj.each_pair { |k, v|
-        if can_serialize?(k) and can_serialize?(v)
-          hash[serialize_object(k)] = serialize_object(v)
-        end
-      }
-      return hash
-    end
-
-    def serialize_array obj
-      arr = []
-      obj.each_index { |i|
-        if can_serialize?(obj[i])
-          arr[i] = serialize_object(obj[i])
-        else
-          raise "Bad array in snapshot"
-        end
-      }
-      return arr
-    end
-
-    def unserialize obj
-      if obj.kind_of?(Hash)
-        unserialize_hash obj
-      elsif obj.kind_of?(Array)
-        unserialize_array obj
-      elsif obj.to_s.match(/^#<EIN_[0-9]+>$/)
-        i = obj[6..-2].to_i
-        p_entities[i]
-      elsif obj.to_s.match(/^#<DIR_[a-z]+>$/)
-        Direction.find(obj[6..-2])
-      else
-        obj
-      end
-    end
-
-    def unserialize_hash obj
-      hash = {}
-      obj.each_pair { |k, v|
-        hash[unserialize(k)] = unserialize(v)
-      }
-      hash
-    end
-
-    def unserialize_array obj
-      arr = []
-      obj.each_index { |i|
-        arr[i] = unserialize(obj[i])
-      }
-      arr
-    end
-
-    def save_subplots
-      # TODO: Subplot snapshots are temporarily disabled.
-      return []
-      arr = []
-      subplots.each { |s|
-        hash = {}
-        hash[:class] = s.class.to_s
-        s.instance_variables.each { |k|
-          v = s.instance_variable_get(k)
-          if can_serialize?(v)
-            hash[k] = serialize_object(v)
-          end
-        }
-        arr.push hash
-      }
-      arr
-    end
-    
-    def restore_subplots arr
-      # TODO: Subplot snapshots are temporarily disabled.
-      return
-      players.each { |p|
-        p.send(:p_subplots).clear
-      }
-      p_subplots.clear
-      arr.each { |hash|
-        cls = Kernel.const_get(hash[:class])
-        subplot = cls.new self
-        hash.each { |k, v|
-          if k != :class
-            subplot.instance_variable_set(k, unserialize(v))
-          end
-        }
-        subplot.players.each { |p|
-          p.send(:p_subplots).push subplot
-        }
-        subplot.entities.each { |e|
-          e.extend Subplot::Element
-          e.instance_variable_set(:@subplot, subplot)
-        }
-        p_subplots.push subplot
-      }
+    # @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.rb

@@ -1,17 +1,15 @@
-#require 'gamefic/keywords'
-
-module Gamefic
-
-  module Query
-    autoload :Base, 'gamefic/query/base'
-    autoload :Children, 'gamefic/query/children'
-    autoload :Descendants, 'gamefic/query/descendants'
-    autoload :Family, 'gamefic/query/family'
-    autoload :Itself, 'gamefic/query/itself'
-    autoload :Matches, 'gamefic/query/matches'
-    autoload :Parent, 'gamefic/query/parent'
-    autoload :Siblings, 'gamefic/query/siblings'
-    autoload :Text, 'gamefic/query/text'
-  end
-
-end
+module Gamefic
+  module Query
+    autoload :Base, 'gamefic/query/base'
+    autoload :Children, 'gamefic/query/children'
+    autoload :Descendants, 'gamefic/query/descendants'
+    autoload :External, 'gamefic/query/external'
+    autoload :Family, 'gamefic/query/family'
+    autoload :Tree, 'gamefic/query/tree'
+    autoload :Itself, 'gamefic/query/itself'
+    autoload :Matches, 'gamefic/query/matches'
+    autoload :Parent, 'gamefic/query/parent'
+    autoload :Siblings, 'gamefic/query/siblings'
+    autoload :Text, 'gamefic/query/text'
+  end
+end

data/lib/gamefic/query/base.rb

@@ -9,6 +9,13 @@ module Gamefic
         @arguments = args
       end
 
+      # Determine whether the query allows ambiguous entity references.
+      # If false, actions that use this query will only be valid if the token
+      # passed into it resolves to a single entity. If true, actions will
+      # accept an array of matching entities instead.
+      # Queries are not ambiguous by default (ambiguous? == false).
+      #
+      # @return [Boolean]
       def ambiguous?
         false
       end
@@ -21,9 +28,10 @@ module Gamefic
         []
       end
 
-      # Get an array of objects that exist in the subject's context and match
-      # the provided token.
+      # Get a collection of objects that exist in the subject's context and
+      # match the provided token. The result is provided as a Matches object.
       #
+      # @return [Gamefic::Query::Matches]
       def resolve(subject, token, continued: false)
         available = context_from(subject)
         return Matches.new([], '', token) if available.empty?
@@ -35,8 +43,8 @@ module Gamefic
           return Matches.new(drill, token, '') unless drill.length != 1
           return Matches.new([], '', token)
         end
-        result = available.select{ |e| e.match?(token) }
-        result = available.select{ |e| e.match?(token, fuzzy: true) } if result.empty?
+        result = available.select{ |e| e.specified?(token) }
+        result = available.select{ |e| e.specified?(token, fuzzy: true) } if result.empty?
         result.keep_if{ |e| accept? e }
         Matches.new(result, (result.empty? ? '' : token), (result.empty? ? token : ''))
       end
@@ -47,17 +55,18 @@ module Gamefic
         result.include?(object)
       end
 
+      # A ranking of how precise the query's arguments are.
+      #
+      # Query precision is a factor in calculating Action#rank.
+      #
+      # @return [Integer]
       def precision
         if @precision.nil?
           @precision = 1
           arguments.each { |a|
-            if a.kind_of?(Symbol) or a.kind_of?(Regexp)
-              @precision += 1
-            elsif a.kind_of?(Class)
-              @precision += (count_superclasses(a) * 100)
-            elsif a.kind_of?(Module)
-              @precision += 10
-            elsif a.kind_of?(Object)
+            if a.is_a?(Class)
+              @precision += 100
+            elsif a.is_a?(Gamefic::Entity)
               @precision += 1000
             end
           }
@@ -65,60 +74,61 @@ module Gamefic
         end
         @precision
       end
-
-      def rank
-        precision
-      end
+      alias rank precision
 
       def signature
-        "#{self.class.to_s.downcase}(#{@arguments.join(',')})"
+        "#{self.class.to_s.split('::').last.downcase}(#{simplify_arguments.join(', ')})"
       end
 
+      # Determine whether the specified entity passes the query's arguments.
+      #
+      # @return [Boolean]
       def accept?(entity)
         result = true
-        arguments.each { |a|
-          if a.kind_of?(Symbol)
-            result = (entity.send(a) != false)
-          elsif a.kind_of?(Regexp)
-            result = (!entity.to_s.match(a).nil?)
-          elsif a.is_a?(Module) or a.is_a?(Class)
-            result = (entity.is_a?(a))
+        arguments.each do |a|
+          result = if a.is_a?(Symbol)
+            (entity.send(a) != false)
+          elsif a.is_a?(Regexp)
+            !entity.to_s.match(a).nil?
+          elsif a.is_a?(Module) || a.is_a?(Class)
+            entity.is_a?(a)
           else
-            result = (entity == a)
+            (entity == a)
           end
           break if result == false
-        }
+        end
         result
       end
 
       protected
-      
-      # Return an array of the entity's children. If the child is neighborly,
+
+      # Return an array of the entity's children. If the child is accessible,
       # recursively append its children.
       # The result will NOT include the original entity itself.
       #
       # @return [Array<Object>]
       def subquery_accessible entity
+        return [] if entity.nil?
         result = []
         if entity.accessible?
-          entity.children.each { |c|
+          entity.children.each do |c|
             result.push c
             result.concat subquery_accessible(c)
-          }
+          end
         end
         result
       end
 
       private
 
-      def count_superclasses cls
-        s = cls.superclass
-        c = 1
-        until s.nil? or s == Object or s == BasicObject
-          c += 1
-          s = s.superclass
+      def simplify_arguments
+        arguments.map do |a|
+          if a.is_a?(Class) || a.is_a?(Object)
+            a.to_s.split('::').last.downcase
+          else
+            a.to_s.downcase
+          end
         end
-        c
       end
 
       def nested?(token)
@@ -128,13 +138,12 @@ module Gamefic
       def denest(objects, token)
         parts = token.split(NEST_REGEXP)
         current = parts.pop
-        last_result = objects.select{ |e| e.match?(current) }
-        last_result = objects.select{ |e| e.match?(current, fuzzy: true) } if last_result.empty?
-        result = last_result
-        while parts.length > 0
+        last_result = objects.select { |e| e.specified?(current) }
+        last_result = objects.select { |e| e.specified?(current, fuzzy: true) } if last_result.empty?
+        until parts.empty?
           current = "#{parts.last} #{current}"
-          result = last_result.select{ |e| e.match?(current) }
-          result = last_result.select{ |e| e.match?(current, fuzzy: true) } if result.empty?
+          result = last_result.select { |e| e.specified?(current) }
+          result = last_result.select { |e| e.specified?(current, fuzzy: true) } if result.empty?
           break if result.empty?
           parts.pop
           last_result = result