gamefic 3.6.0 → 4.0.0

data/lib/gamefic/props/output.rb

@@ -59,13 +59,13 @@ module Gamefic
       #   @return [String, nil]
 
       # @param key [Symbol]
-      def [] key
+      def [](key)
         raw_data[key]
       end
 
       # @param key [Symbol]
       # @param value [Object]
-      def []= key, value
+      def []=(key, value)
         raw_data[key] = value
       end
 
@@ -74,15 +74,15 @@ module Gamefic
         raw_data.dup
       end
 
-      def to_json _ = nil
+      def to_json(_ = nil)
         raw_data.to_json
       end
 
-      def merge! data
+      def merge!(data)
         data.each { |key, val| self[key] = val }
       end
 
-      def replace data
+      def replace(data)
         raw_data.replace data
       end
 
@@ -102,6 +102,8 @@ module Gamefic
       def respond_to_missing?(method, _with_private = false)
         READER_METHODS.include?(method) || WRITER_METHODS.include?(method)
       end
+
+      EMPTY = new.freeze
     end
   end
 end

data/lib/gamefic/props/yes_or_no.rb

@@ -4,7 +4,7 @@ module Gamefic
   module Props
     # A MultipleChoice variant that only allows Yes or No.
     #
-    class YesOrNo < MultipleChoice
+    class YesOrNo < MultiplePartial
       def yes?
         selection == 'Yes'
       end
@@ -14,7 +14,7 @@ module Gamefic
       end
 
       def options
-        @options ||= %w[Yes No].freeze
+        @options ||= %w[Yes No]
       end
     end
   end

data/lib/gamefic/props.rb

@@ -4,6 +4,7 @@ module Gamefic
   module Props
     require 'gamefic/props/default'
     require 'gamefic/props/multiple_choice'
+    require 'gamefic/props/multiple_partial'
     require 'gamefic/props/pause'
     require 'gamefic/props/yes_or_no'
     require 'gamefic/props/output'

data/lib/gamefic/proxy/attr.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Proxy
+    class Attr < Base
+      def fetch(narrative)
+        args.inject(narrative) { |object, key| object.send(key) }
+      end
+    end
+  end
+end

data/lib/gamefic/proxy/base.rb

@@ -1,27 +1,15 @@
 # frozen_string_literal: true
 
 module Gamefic
-  class Proxy
+  module Proxy
     class Base
       attr_reader :args
 
-      def initialize *args, raise: false
+      def initialize *args
         @args = args
-        @raise = raise
       end
 
-      def raise?
-        @raise
-      end
-
-      def fetch narrative
-        result = select(narrative)
-        return result if result
-        raise "#{self.class} failed for #{args.inspect}" if raise?
-      end
-
-      def select narrative
-      end
+      def fetch(narrative); end
     end
   end
 end

data/lib/gamefic/proxy/config.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Gamefic
-  class Proxy
+  module Proxy
     class Config < Base
-      def select narrative
+      def fetch(narrative)
         args.inject(narrative.config) { |hash, key| hash[key] }
       end
 

data/lib/gamefic/proxy/pick.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module Gamefic
-  class Proxy
+  module Proxy
     class Pick < Base
-      def select narrative
-        raise? ? narrative.pick!(*args) : narrative.pick(*args)
+      def fetch(narrative)
+        narrative.pick(*args)
       end
     end
   end

data/lib/gamefic/proxy/pick_ex.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Proxy
+    class PickEx < Base
+      def fetch(narrative)
+        narrative.pick!(*args)
+      end
+    end
+  end
+end

data/lib/gamefic/proxy.rb

@@ -1,79 +1,11 @@
 # frozen_string_literal: true
 
 module Gamefic
-  # @todo Turn this into a module after the old proxies are completely deprecated
-  #
-  class Proxy
+  module Proxy
     require 'gamefic/proxy/base'
+    require 'gamefic/proxy/attr'
     require 'gamefic/proxy/config'
     require 'gamefic/proxy/pick'
-    require 'gamefic/proxy/plot_pick'
-
-    TYPES = %i[attr ivar pick pick! plot_pick plot_pick! config].freeze
-
-    # @return [Symbol]
-    attr_reader :type
-
-    # @return [Symbol, Array<Symbol>, String, Integer]
-    attr_reader :key
-
-    # @param type [Symbol]
-    # @param key [Symbol, String, Array]
-    def initialize type, key
-      Gamefic.logger.debug "Using deprecated #{type} proxy"
-      @type = type
-      validate_type
-      @key = type == :config ? [key].compact : key
-    end
-
-    def fetch narrative
-      send(type, narrative) ||
-        raise(ArgumentError, "Unable to fetch entity from proxy agent symbol `#{key}`")
-    end
-
-    def [](key)
-      raise ArgumentError, 'Invalid []' unless type == :config
-
-      @key.push key
-      self
-    end
-
-    private
-
-    def attr narrative
-      Stage.run(narrative, [key].flatten) { |keys| keys.inject(self) { |obj, key| obj.send key } }
-    rescue NoMethodError
-      nil
-    end
-
-    def ivar narrative
-      narrative.instance_variable_get key
-    end
-
-    def pick narrative
-      narrative.pick *key
-    end
-
-    def pick! narrative
-      narrative.pick! *key
-    end
-
-    def plot_pick narrative
-      narrative.plot.pick *key
-    end
-
-    def plot_pick! narrative
-      narrative.plot.pick! *key
-    end
-
-    def config narrative
-      key.inject(narrative.config) { |hash, key| hash[key] }
-    end
-
-    def validate_type
-      return if TYPES.include?(type)
-
-      raise ArgumentError, "Invalid proxy type `#{type}` (must be #{TYPES.join_or})"
-    end
+    require 'gamefic/proxy/pick_ex'
   end
 end

data/lib/gamefic/query/ascendants.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query the subject's parent and accessible grandparents.
+    #
+    class Ascendants < Base
+      include Subqueries
+
+      def span(subject)
+        [subject.parent].tap { |result| result.push result.last.parent while result.last&.parent&.accessible&.include?(result.last) }
+                        .compact
+      end
+    end
+  end
+end

data/lib/gamefic/query/base.rb

@@ -3,61 +3,46 @@
 module Gamefic
   module Query
     # A base class for entity-based queries that can be applied to responses.
-    # Each query represents an attempt to match an argument in a command to a
-    # game entity.
+    # Each query matches a command token to an object that can be passed into
+    # a response callback.
+    #
+    # Most queries return entities, but there are also queries for plain text
+    # and integers.
     #
     class Base
       # @return [Array<Object>]
       attr_reader :arguments
 
-      # @return [Boolean]
-      attr_reader :ambiguous
-
-      attr_accessor :narrative
-
       # @raise [ArgumentError] if any of the arguments are nil
       #
       # @param arguments [Array<Object>]
-      # @param ambiguous [Boolean]
       # @param name [String]
-      def initialize *arguments, ambiguous: false, name: self.class.to_s
+      def initialize *arguments, name: self.class.to_s
         raise ArgumentError, "nil argument in query" if arguments.any?(&:nil?)
 
         @arguments = arguments
-        @ambiguous = ambiguous
         @name = name
       end
 
       # Get a query result for a given subject and token.
       #
-      # @example
-      #   respond :reds do |actor|
-      #     reds = available(ambiguous: true).query(actor, 'red').match
-      #     actor.tell "The red things you can see here are #{reds.join_and}."
-      #   end
-      #
       # @param subject [Gamefic::Entity]
       # @param token [String]
       # @return [Result]
-      def query(subject, token)
-        first_pass = Scanner.scan(span(subject), token)
-        if ambiguous?
-          ambiguous_result(first_pass.filter(*normalized_arguments))
-        elsif first_pass.match.one?
-          unambiguous_result(first_pass.filter(*normalized_arguments))
-        else
-          unambiguous_result(first_pass)
-        end
+      def filter(subject, token)
+        scan = Scanner.scan(select(subject), token)
+        return Result.new(nil, scan.token) unless scan.matched.one?
+
+        Result.new(scan.matched.first, scan.remainder, scan.strictness)
       end
-      alias filter query
 
       # Get an array of entities that match the arguments from the context of
       # the subject.
       #
       # @param subject [Entity]
       # @return [Array<Entity>]
-      def select subject
-        span(subject).that_are(*normalized_arguments)
+      def select(subject)
+        span(subject).that_are(*arguments)
       end
 
       # Get an array of entities that are candidates for selection from the
@@ -68,47 +53,65 @@ module Gamefic
       #
       # @param subject [Entity]
       # @return [Array<Entity>]
-      def span _subject
+      def span(_subject)
         []
       end
 
       # True if the object is selectable by the subject.
       #
       # @param subject [Entity]
-      # @param object [Array<Entity>, Entity]
+      # @param object [Entity]
       # @return [Boolean]
       def accept?(subject, object)
-        available = select(subject)
-        if ambiguous?
-          object & available == object
-        else
-          available.include?(object)
-        end
+        select(subject).include?(object)
       end
 
+      # The query's precision. The higher the number, the more specific the
+      # query is.
+      #
+      # In general terms, a query's precision is highest if its arguments
+      # select for a specific instance of an entity instead of a class of
+      # entity.
+      #
+      # When a command gets parsed, the resulting list of available actions
+      # gets sorted in descending order of their responses' overall precision,
+      # so the action with the highest precision gets attempted first.
+      #
       # @return [Integer]
       def precision
         @precision ||= calculate_precision
       end
 
-      def ambiguous?
-        @ambiguous
-      end
-
       def name
         @name || self.class.to_s
       end
 
       def inspect
-        "##{ambiguous? ? '*' : ''}#{name}(#{normalized_arguments.map(&:inspect).join(', ')})"
+        "#{name}(#{arguments.map(&:inspect).join(', ')})"
+      end
+
+      def bind(narrative)
+        clone.tap do |query|
+          query.instance_exec do
+            @arguments = narrative.unproxy(@arguments)
+          end
+        end
+      end
+
+      def self.plain
+        @plain ||= new
+      end
+
+      def self.span(subject)
+        plain.span(subject)
       end
 
       private
 
       def calculate_precision
-        normalized_arguments.sum(@ambiguous ? -1000 : 0) do |arg|
+        arguments.sum(0) do |arg|
           case arg
-          when Entity, Proxy, Proxy::Base
+          when Entity, Proxy::Base
             1000
           when Class, Module
             class_depth(arg) * 100
@@ -118,7 +121,7 @@ module Gamefic
         end
       end
 
-      def class_depth klass
+      def class_depth(klass)
         return 1 unless klass.is_a?(Class)
 
         depth = 1
@@ -126,35 +129,6 @@ module Gamefic
         depth += 1 while (sup = sup.superclass)
         depth
       end
-
-      # @param scan [Scanner::Result]
-      def ambiguous_result scan
-        return Result.new(nil, scan.token) if scan.matched.empty?
-
-        Result.new(scan.matched, scan.remainder)
-      end
-
-      # @param scan [Scanner::Result]
-      def unambiguous_result scan
-        return Result.new(nil, scan.token) unless scan.matched.one?
-
-        Result.new(scan.matched.first, scan.remainder, scan.strictness)
-      end
-
-      def normalized_arguments
-        @normalized_arguments ||= arguments.map do |arg|
-          case arg
-          when Proxy, Proxy::Base
-            arg.fetch(narrative)
-          when String
-            proc do |entity|
-              arg.keywords.all? { |word| entity.keywords.include?(word) }
-            end
-          else
-            arg
-          end
-        end
-      end
     end
   end
 end

data/lib/gamefic/query/children.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query the subject's children.
+    #
+    class Children < Base
+      include Subqueries
+
+      def span(subject)
+        subject.children
+      end
+    end
+  end
+end

data/lib/gamefic/query/descendants.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query the subject's children and accessible grandchildren.
+    #
+    class Descendants < Base
+      include Subqueries
+
+      def span(subject)
+        subject.children.flat_map do |child|
+          [child] + subquery_accessible(child)
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/query/extended.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query the subject's siblings and their descendants. Unlike `Family`, the
+    # subject's descendants are excluded from results.
+    #
+    # Descendants need to be `accessible` to be included in the query.
+    #
+    class Extended < Base
+      include Subqueries
+
+      def span(subject)
+        Siblings.span(subject).flat_map do |child|
+          [child] + subquery_accessible(child)
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/query/family.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query the subject's ascendants, descendants, siblings, and siblings'
+    # descendants.
+    #
+    # Entities other than the subject's parent and immediate children need to
+    # be `accessible` to be included in the query.
+    #
+    class Family < Base
+      include Subqueries
+
+      def span(subject)
+        Ascendants.span(subject) + Descendants.span(subject) + match_sibling_branches(subject)
+      end
+
+      private
+
+      def match_sibling_branches(subject)
+        Siblings.span(subject).flat_map do |child|
+          [child] + subquery_accessible(child)
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/query/global.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query all the entities in the subject's epic.
+    #
+    # If the subject is not an actor, this query will always return an empty
+    # result.
+    #
+    class Global < Base
+      def span(subject)
+        return [] unless subject.is_a?(Active)
+
+        subject.narratives.entities
+      end
+
+      def precision
+        @precision ||= super - 2000
+      end
+    end
+  end
+end

data/lib/gamefic/query/integer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # A special query that handles integers instead of entities.
+    #
+    class Integer < Base
+      # @param name [String, nil]
+      def initialize(name: self.class.name)
+        super(name: name)
+      end
+
+      def filter(_subject, token)
+        return Result.new(token, '') if token.is_a?(::Integer)
+
+        words = token.keywords
+        number = words.shift
+        return Result.new(nil, token) unless number =~ /\d+/
+
+        Result.new(number.to_i, words.join(' '))
+      end
+
+      def precision
+        -10_000
+      end
+
+      def accept?(_subject, token)
+        token.is_a?(::Integer)
+      end
+    end
+  end
+end

data/lib/gamefic/query/myself.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query the subject itself.
+    #
+    class Myself < Base
+      def span(subject)
+        [subject]
+      end
+    end
+  end
+end

data/lib/gamefic/query/parent.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query the subject's parent.
+    #
+    class Parent < Base
+      def span(subject)
+        [subject.parent].compact
+      end
+    end
+  end
+end

data/lib/gamefic/query/result.rb

@@ -13,7 +13,7 @@ module Gamefic
 
       attr_reader :strictness
 
-      def initialize match, remainder, strictness = 0
+      def initialize(match, remainder, strictness = 0)
         @match = match
         @remainder = remainder
         @strictness = strictness

data/lib/gamefic/query/siblings.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # Query the subject's siblings (i.e., entities with the same parent).
+    class Siblings < Base
+      def span(subject)
+        (subject.parent&.children || []) - [subject]
+      end
+    end
+  end
+end

data/lib/gamefic/query/subqueries.rb

@@ -0,0 +1,17 @@
+module Gamefic
+  module Query
+    module Subqueries
+      module_function
+
+      # Return an array of the entity's accessible descendants.
+      #
+      # @param entity [Entity]
+      # @return [Array<Entity>]
+      def subquery_accessible(entity)
+        entity.accessible.flat_map do |child|
+          [child] + subquery_accessible(child)
+        end
+      end
+    end
+  end
+end