gamefic 3.6.0 → 4.0.0

data/lib/gamefic/query/text.rb

@@ -7,7 +7,7 @@ module Gamefic
     class Text < Base
       # @param argument [String, Regexp]
       # @param name [String, nil]
-      def initialize argument = /.*/, name: self.class.name
+      def initialize(argument = /.*/, name: self.class.name)
         super(argument, name: name)
         validate_argument
       end
@@ -21,33 +21,32 @@ module Gamefic
         argument
       end
 
-      def query _subject, token
+      def filter(_subject, token)
         if match? token
           Result.new(token, '')
         else
           Result.new(nil, token)
         end
       end
-      alias filter query
 
       def precision
-        0
+        -10_000
       end
 
-      def accept? _subject, argument
-        match? argument
+      def accept?(_subject, token)
+        match?(token)
       end
 
       private
 
-      def match? token
+      def match?(token)
         return false unless token.is_a?(String) && !token.empty?
 
         case argument
         when Regexp
-          token =~ argument
+          token.match?(argument)
         else
-          token == argument
+          argument == token
         end
       end
 

data/lib/gamefic/query.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
 require 'gamefic/query/base'
-require 'gamefic/query/general'
-require 'gamefic/query/abstract'
-require 'gamefic/query/scoped'
 require 'gamefic/query/text'
+require 'gamefic/query/integer'
 require 'gamefic/query/result'
+require 'gamefic/query/subqueries'
+require 'gamefic/query/global'
+require 'gamefic/query/children'
+require 'gamefic/query/myself'
+require 'gamefic/query/descendants'
+require 'gamefic/query/ascendants'
+require 'gamefic/query/parent'
+require 'gamefic/query/siblings'
+require 'gamefic/query/extended'
+require 'gamefic/query/family'

data/lib/gamefic/request.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Gamefic
+  # Build actions from text.
+  #
+  # Active#perform uses Request to parse user input into actions for execution
+  # by the Dispatcher.
+  #
+  class Request
+    # @param actor [Actor]
+    # @param input [String]
+    def initialize(actor, input)
+      @actor = actor
+      @input = input
+    end
+
+    # @return [Array<Action>]
+    def to_actions
+      Action.sort(
+        Syntax.tokenize(input, actor.narratives.syntaxes)
+              .flat_map { |expression| expression_to_actions(expression) }
+      )
+    end
+
+    private
+
+    # @return [Actor]
+    attr_reader :actor
+
+    # @return [String]
+    attr_reader :input
+
+    def expression_to_actions(expression)
+      Gamefic.logger.info "Evaluating #{expression.inspect}"
+      actor.narratives
+           .responses_for(expression.verb)
+           .map { |response| match_expression response, expression }
+           .compact
+    end
+
+    def match_expression(response, expression)
+      return nil if expression.tokens.length > response.queries.length
+
+      remainder = ''
+      matches = response.queries
+                        .zip(expression.tokens)
+                        .each_with_object([]) do |zipped, results|
+        query, token = zipped
+        result = query.filter(actor, "#{remainder} #{token}".strip)
+        return nil unless result.match
+
+        results.push Match.new(result.match, token.to_s[0..-result.remainder.length - 1], result.strictness)
+        remainder = result.remainder
+      end
+      return nil unless remainder.empty?
+
+      Action.new(actor, response, matches, input)
+    end
+  end
+end

data/lib/gamefic/response.rb

@@ -1,26 +1,31 @@
 # frozen_string_literal: true
 
+require 'gamefic/scriptable'
+
 module Gamefic
   # A proc to be executed in response to a command that matches its verb and
   # queries.
   #
   class Response
+    include Scriptable::Queries
+
     # @return [Symbol]
     attr_reader :verb
 
     # @return [Array<Query::Base, Query::Text>]
     attr_reader :queries
 
+    # @return [Proc]
+    attr_reader :block
+
     # @param verb [Symbol]
-    # @param narrative [Narrative]
-    # @param args [Array<Object>]
+    # @param queries [Array<Object>]
     # @param meta [Boolean]
-    # @param block [Proc]
-    def initialize verb, narrative, *args, meta: false, &block
-      @verb = verb
-      @queries = map_queries(args, narrative)
+    def initialize verb, *queries, meta: false, &block
+      @verb = verb&.to_sym
       @meta = meta
-      @callback = Callback.new(narrative, block)
+      @block = block
+      @queries = map_queries(queries)
     end
 
     # The `meta?` flag is just a way for authors to identify responses that
@@ -32,115 +37,84 @@ module Gamefic
       @meta
     end
 
-    def hidden?
-      @hidden ||= verb.to_s.start_with?('_')
-    end
-
     def syntax
       @syntax ||= generate_default_syntax
     end
 
-    # Return an Action if the Response can accept the actor's command.
-    #
-    # @param actor [Entity]
-    # @param command [Command]
-    # @return [Action, nil]
-    def attempt actor, command
-      return nil unless accept?(actor, command)
-
-      Action.new(actor, command.arguments, self)
-    end
-
     # True if the Response can be executed for the given actor and command.
     #
     # @param actor [Active]
     # @param command [Command]
-    def accept? actor, command
+    def accept?(actor, command)
       command.verb == verb &&
         command.arguments.length == queries.length &&
         queries.zip(command.arguments).all? { |query, argument| query.accept?(actor, argument) }
     end
 
     def execute *args
-      @callback.run(*args)
+      Gamefic.logger.warn "Executing unbound response #{inspect}" unless bound?
+      gamefic_binding.call(*args)
     end
 
+    # The total precision of all the response's queries.
+    #
+    # @note Precision is decreased if the response has a nil verb.
+    #
+    # @return [Integer]
     def precision
       @precision ||= calculate_precision
     end
 
-    # Turn an actor and an expression into a command by matching the
-    # expression's tokens to queries. Return nil if the expression
-    # could not be matched.
-    #
-    # @param actor [Actor]
-    # @param expression [Expression]
-    # @return [Command, nil]
-    def to_command actor, expression
-      return log_and_discard unless expression.verb == verb && expression.tokens.length <= queries.length
-
-      results = filter(actor, expression)
-      return log_and_discard unless results
-
-      Gamefic.logger.info "Accepted #{inspect}"
-      Command.new(
-        verb,
-        results.map(&:match),
-        results.sum(&:strictness),
-        precision
-      )
-    end
-
     def inspect
       "#<#{self.class} #{([verb] + queries).map(&:inspect).join(', ')}>"
     end
 
-    private
+    def bound?
+      !!gamefic_binding.narrative
+    end
 
-    def log_and_discard
-      Gamefic.logger.info "Discarded #{inspect}"
-      nil
+    def bind(narrative)
+      clone.inject_binding narrative
     end
 
-    def filter actor, expression
-      remainder = ''
-      result = queries.zip(expression.tokens)
-                      .map do |query, token|
-                        token = "#{remainder} #{token}".strip
-                        result = query.filter(actor, token)
-                        return nil unless result.match
-
-                        remainder = result.remainder
-                        result
-                      end
-      result if remainder.empty?
+    protected
+
+    def inject_binding(narrative)
+      @queries = map_queries(narrative.unproxy(@queries))
+      @gamefic_binding = Binding.new(narrative, @block)
+      self
+    end
+
+    private
+
+    def gamefic_binding
+      @gamefic_binding ||= Binding.new(nil, @block)
     end
 
     def generate_default_syntax
       args = queries.length.times.map { |num| num.zero? ? ':var' : ":var#{num + 1}" }
       tmpl = "#{verb} #{args.join(' ')}".strip
-      Syntax.new(tmpl.gsub('_', ' '), tmpl)
+      Syntax.new(tmpl, tmpl)
     end
 
+    # @return [Integer]
     def calculate_precision
       total = queries.sum(&:precision)
       total -= 1000 unless verb
       total
     end
 
-    def map_queries args, narrative
-      args.map do |arg|
-        select_query(arg, narrative).tap { |qry| qry.narrative = narrative }
-      end
+    def map_queries(args)
+      args.map { |arg| select_query(arg) }
     end
 
-    def select_query arg, narrative
+    def select_query(arg)
       case arg
-      when Entity, Class, Module, Proc, Proxy, Proxy::Base
-        narrative.available(arg)
+      when Entity, Class, Module, Proc, Proxy::Base
+        available(arg)
       when String, Regexp
-        narrative.plaintext(arg)
-      when Query::Base, Query::Text
+        plaintext(arg)
+      when Query::Base
         arg
       else
         raise ArgumentError, "invalid argument in response: #{arg.inspect}"

data/lib/gamefic/scanner/nesting.rb

@@ -14,14 +14,14 @@ module Gamefic
       def scan
         return unmatched_result unless token =~ NEST_REGEXP
 
-        denest selection, token
+        denest
       end
 
       private
 
-      def denest objects, token
-        near = objects
-        far = objects
+      def denest
+        near = selection
+        far = selection
         parts = token.split(NEST_REGEXP)
         until parts.empty?
           current = parts.pop
@@ -29,8 +29,8 @@ module Gamefic
           last_result = subprocessor.scan(far, current) if last_result.matched.empty? && near != far
           return unmatched_result if last_result.matched.empty? || last_result.matched.length > 1
 
-          near = last_result.matched.first.children & objects
-          far = last_result.matched.first.flatten & objects
+          near = last_result.matched.first.children & selection
+          far = last_result.matched.first.flatten & selection
         end
         last_result
       end

data/lib/gamefic/scanner/result.rb

@@ -38,6 +38,9 @@ module Gamefic
         @processor = processor
       end
 
+      # The strictness of the scanner that produced this result.
+      #
+      # @return [Integer]
       def strictness
         @strictness ||= Scanner.strictness(processor)
       end

data/lib/gamefic/scanner/strict.rb

@@ -8,23 +8,33 @@ module Gamefic
     # matches one of the entity's keywords.
     #
     class Strict < Base
+      NOISE = %w[
+        a an the of some
+      ].freeze
+
       # @return [Result]
       def scan
         words = token.keywords
         available = selection.clone
         filtered = []
         words.each_with_index do |word, idx|
-          tested = match_word(available, word)
-          return matched_result(filtered, words[idx..].join(' ')) if tested.empty?
+          # @todo This might not be the best way to filter articles, but it works for now
+          tested = %w[a an the].include?(word) ? available : match_word(available, word)
+          return matched_result(reduce_noise(filtered, words[0, idx]), words[idx..].join(' ')) if tested.empty?
 
           filtered = tested
           available = filtered
         end
-        matched_result filtered, ''
+        matched_result(reduce_noise(filtered, words), '')
       end
 
       def match_word available, word
-        available.select { |obj| obj.keywords.include?(word) }
+        available.select { |obj| (obj.keywords + obj.nuance.keywords).include?(word) }
+      end
+
+      def reduce_noise entities, keywords
+        noiseless = keywords - NOISE
+        entities.reject { |entity| (noiseless - entity.nuance.keywords).empty? }
       end
     end
   end

data/lib/gamefic/scanner.rb

@@ -17,12 +17,13 @@ module Gamefic
     #
     # @param selection [Array<Entity>]
     # @param token [String]
+    # @param use [Array<Scanner::Base>]
     # @return [Result]
-    def self.scan selection, token
+    def self.scan(selection, token, use = processors)
       result = nil
-      processors.each do |processor|
+      use.each do |processor|
         result = processor.scan(selection, token)
-        break unless result.matched.empty?
+        break result unless result.matched.empty?
       end
       result
     end
@@ -34,8 +35,8 @@ module Gamefic
     # Processor classes should be in order from most to least strict rules
     # for matching tokens to entities.
     #
-    # @param klasses [Array<Class<Base>>]
-    # @return [Array<Class<Base>>]
+    # @param klasses [Array<Class<Scanner::Base>>]
+    # @return [Array<Class<Scanner::Base>>]
     def self.use *klasses
       processors.replace klasses.flatten
     end
@@ -45,7 +46,11 @@ module Gamefic
       @processors ||= []
     end
 
-    def self.strictness processor
+    # A measure of a scan processor's strictness based on its order of use.
+    # Higher values indicate higher strictness.
+    #
+    # @return [Integer]
+    def self.strictness(processor)
       (processors.length - (processors.find_index(processor) || processors.length)) * 100
     end
 

data/lib/gamefic/scene/active_choice.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Scene
+    # A scene that presents a list of optional choices. The scene can still
+    # attempt to process input that does not match any of the options.
+    #
+    # Authors can use the `without_selection` class method to select one of
+    # three actions to take when the user does not enter one of the options:
+    # `:perform`, `:recue`, or `:continue`.
+    #
+    class ActiveChoice < MultipleChoice
+      WITHOUT_SELECTION_ACTIONS = %i[perform recue continue].freeze
+
+      use_props_class Props::MultipleChoice
+
+      def finish
+        return super if props.selected?
+
+        send(self.class.without_selection_action)
+      end
+
+      def without_selection_action
+        self.class.without_selection_action
+      end
+
+      def self.type
+        'ActiveChoice'
+      end
+
+      # Select the behavior for input that does not match a selectable option.
+      # The available settings are `:perform`, `:recue`, and `:continue`.
+      #
+      # * `:perform` - Skip the `on_finish` blocks and try to perform the input
+      #   as a command. This is the default behavior.
+      # * `:recue` - Restart the scene until the user makes a valid selection.
+      #   This is the same behavior as a `MultipleChoice` scene.
+      # * `:continue` - Execute the `on_finish` blocks regardless of whether the
+      #   input matches an option.
+      #
+      # @param action [Symbol]
+      def self.without_selection(action)
+        WITHOUT_SELECTION_ACTIONS.include?(action) ||
+          raise(ArgumentError, "without_selection_action must be one of #{WITHOUT_SELECTION_ACTIONS.map(&:inspect).join_or}")
+
+        @without_selection_action = action
+      end
+
+      # @return [Symbol]
+      def self.without_selection_action
+        @without_selection_action ||= :perform
+      end
+
+      def self.inherited(klass)
+        super
+        klass.without_selection without_selection_action
+      end
+
+      private
+
+      def perform
+        actor.perform props.input
+      end
+
+      def recue
+        actor.tell props.invalid_message
+        actor.recue
+      end
+
+      def continue
+        run_finish_blocks
+      end
+    end
+  end
+end

data/lib/gamefic/scene/activity.rb

@@ -4,10 +4,14 @@ module Gamefic
   module Scene
     # A scene that accepts player commands for actors to perform.
     #
-    class Activity < Default
-      def finish actor, props
-        super
+    class Activity < Base
+      def finish
         actor.perform props.input
+        super
+      end
+
+      def self.type
+        'Activity'
       end
     end
   end

data/lib/gamefic/scene/base.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Scene
+    # The base class for scenes. Authors can instantiate this class directly
+    # and customize it with on_start and on_finish blocks.
+    #
+    class Base
+      # @todo Code smell
+      attr_writer :name
+
+      attr_reader :actor, :narrative, :props, :context
+
+      # @param actor [Actor]
+      # @param narrative [Narrative]
+      # @param props [Props::Base]
+      def initialize(actor, narrative = nil, props = nil, **context)
+        @actor = actor
+        @narrative = narrative
+        @props = props || self.class.props_class.new
+        @context = context
+      end
+
+      def name
+        @name ||= self.class.nickname
+      end
+
+      def rename(name)
+        @name = name
+      end
+
+      # @return [String]
+      def type
+        self.class.type
+      end
+
+      # @return [Props::Default]
+      def start
+        run_start_blocks
+        props
+      end
+
+      # @return [void]
+      def finish
+        run_finish_blocks
+      end
+
+      def to_hash
+        { name: name, type: type }
+      end
+
+      def self.inherited(klass)
+        super
+        klass.use_props_class props_class
+        klass.start_blocks.concat start_blocks
+        klass.finish_blocks.concat finish_blocks
+      end
+
+      private
+
+      def execute(block)
+        Binding.new(narrative, block).call(actor, props, context)
+      end
+
+      def run_start_blocks
+        self.class.start_blocks.each { |blk| execute(blk) }
+      end
+
+      def run_finish_blocks
+        self.class.finish_blocks.each { |blk| execute(blk) }
+      end
+
+      class << self
+        attr_reader :context, :nickname
+
+        def type
+          'Base'
+        end
+
+        def props_class
+          @props_class ||= Props::Default
+        end
+
+        def rename(nickname)
+          @nickname = nickname
+        end
+
+        # @return [Array<Proc>]
+        def start_blocks
+          @start_blocks ||= []
+        end
+
+        # @return [Array<Proc>]
+        def finish_blocks
+          @finish_blocks ||= []
+        end
+
+        # @yieldparam [Actor] The scene's actor
+        # @yieldparam [Props::Base] The scene's props
+        # @yieldparam [Hash] Additional context
+        def on_start(&block)
+          start_blocks.push block
+        end
+
+        # @yieldparam [Actor] The scene's actor
+        # @yieldparam [Props::Base] The scene's props
+        # @yieldparam [Hash] Additional context
+        def on_finish(&block)
+          finish_blocks.push block
+        end
+
+        protected
+
+        attr_writer :context
+
+        # @param klass [Class<Props::Base>]
+        def use_props_class(klass)
+          @props_class = klass
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/scene/conclusion.rb

@@ -4,7 +4,10 @@ module Gamefic
   module Scene
     # A scene that ends an actor's participation in a narrative.
     #
-    class Conclusion < Default
+    class Conclusion < Base
+      def self.type
+        'Conclusion'
+      end
     end
   end
 end