gamefic 3.6.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5c61efc096ecbacdd43431dd3f0b755120650258a4a3e5d724692957ee45f53
-  data.tar.gz: 499d740594a35e767c86fae7610a51dafa9ba647658af7b3ab46c61de4335501
+  metadata.gz: ab6b04620f4d61106e3d7a3321dfc1833f0a7cce7eeb0e509ca77bdc5388d7c0
+  data.tar.gz: d8d37b580f71e20870cbe4124a8af41a953448b4bd5296e8f6f73d5e8a0e5092
 SHA512:
-  metadata.gz: dd430f5dfa970cacfe12915ff09284ef286b1116aa701ce5484472fdf880b68a5de91953182189c647e90c527653bde92db26016045ac5ea5304e660082979fe
-  data.tar.gz: 1726fc542b40c55443bc9b452df85d94fe0831fa19bc73e40076cd6768e92bc71e504fd2da7998ef65b913c21f8b3ccb7bd4f04329186b88e71eb9dc675b0b69
+  metadata.gz: ac226d280d8e1a07ad2bc154ae1cbc49a4496a847986f4d8919aef89999386432122673b568c64e2012ef3b910652aa67a31545e59eb65633105854fd0228d4b
+  data.tar.gz: 2b271b4061e74ab43d4cd11e080261b595404f7add90ea017934e49c4d1beda47a44c3ed88b53d4ba57cc6a6602fabf5e330a18544e783b09c56129642f6f82a

data/.rubocop.yml

@@ -11,6 +11,3 @@ Style/StringLiterals:
 Style/Documentation:
   Description: 'Document classes and non-namespace modules.'
   Enabled: false
-
-Style/MethodDefParentheses:
-  Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 4.0.0
+- Nuanced scans
+- Command hooks
+- Refactored queries
+- Cue scenes by class or name
+- Deprecate underscore verbs
+- Move rules to Scriptable
+- JIT Scriptable binding
+- Sunset Rulebook
+- Separate Scriptable and Scripting modules
+- ActiveChoice scenes
+- Narrator class runs narratives
+- Use construct for static entities
+- Parent relations
+- Consolidate Syntax and Template
+- Remove Snapshot module
+- Track command activity
+- MultiplePartial props
+
 ## 3.6.0 - October 6, 2024
 - Normalized arguments accept strings
 - Smarter picks and proxies

data/Rakefile

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'bundler/setup'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'opal/rspec/rake_task'

data/gamefic.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'opal', '~> 1.7'
   s.add_development_dependency 'opal-rspec', '~> 1.0'
   s.add_development_dependency 'opal-sprockets', '~> 1.0'
-  s.add_development_dependency 'rake', '~> 12.3', '>= 12.3'
+  s.add_development_dependency 'rake', '~> 13.2'
   s.add_development_dependency 'rspec', '~> 3.5', '>= 3.5.0'
   s.add_development_dependency 'simplecov', '~> 0.14'
 end

data/lib/gamefic/action.rb

@@ -1,91 +1,105 @@
 # frozen_string_literal: true
 
 module Gamefic
-  # The handler for executing responses for a provided actor and array of
-  # arguments. It's also responsible for executing before_action and
-  # after_action hooks if necessary.
+  # The handler for executing a command response.
   #
   class Action
-    include Logging
+    include Scriptable::Queries
 
-    # Hooks are blocks of code that get executed before or after an actor
-    # performs an action. A before action hook is capable of cancelling the
-    # action's performance.
-    #
-    class Hook
-      # @param [Array<Symbol>]
-      attr_reader :verbs
-
-      # @param [Callback]
-      attr_reader :callback
-
-      def initialize verbs, callback
-        @verbs = verbs
-        @callback = callback
-      end
-
-      def match?(input)
-        verbs.empty? || verbs.include?(input)
-      end
-    end
-
-    # @return [Active]
+    # @return [Actor]
     attr_reader :actor
 
-    # @return [Array]
-    attr_reader :arguments
-
     # @return [Response]
     attr_reader :response
 
-    # @param actor [Active]
-    # @param arguments [Array]
+    # @return [Array<Match>]
+    attr_reader :matches
+
+    # @return [String, nil]
+    attr_reader :input
+
+    # @param actor [Actor]
     # @param response [Response]
-    def initialize actor, arguments, response
+    # @param matches [Array<Match>]
+    # @param input [String, nil]
+    def initialize(actor, response, matches, input = nil)
       @actor = actor
-      @arguments = arguments
       @response = response
+      @matches = matches
+      @input = input
     end
 
-    # @return [self]
-    def execute
-      return self if cancelled? || executed?
+    def verb
+      response.verb
+    end
 
-      Gamefic.logger.info "Executing #{([verb] + [arguments]).flatten.map(&:inspect).join(', ')}"
-      @executed = true
-      response.execute actor, *arguments
+    def command
+      @command ||= Command.new(response.verb, matches.map(&:argument), response.meta?, input)
+    end
+
+    def queries
+      response.queries
+    end
+
+    def arguments
+      matches.map(&:argument)
+    end
+
+    def execute
+      response.execute(actor, *arguments)
       self
     end
 
-    # True if the response has been executed. False typically means that the
-    # #execute method has not been called or the action was cancelled in a
-    # before_action hook.
+    # The total substantiality of the action, based on how many of the
+    # arguments are concrete entities and whether the action has a verb.
     #
-    def executed?
-      @executed ||= false
+    def substantiality
+      arguments.that_are(Entity).length + (verb ? 1 : 0)
     end
 
-    # Cancel an action. This method can be called in an action hook to
-    # prevent subsequent hooks and/or the action itself from being executed.
+    # The total strictness of all the matches.
     #
-    def cancel
-      @cancelled = true
+    # The higher the strictness, the more precisely the tokens from the user
+    # input match the arguments. For example, if the user is interacting with a
+    # pencil, the command TAKE PENCIL is stricter than TAKE PEN.
+    #
+    # @return [Integer]
+    def strictness
+      matches.sum(0, &:strictness)
     end
 
-    def cancelled?
-      @cancelled ||= false
+    # The precision of the response.
+    #
+    # @return [Integer]
+    def precision
+      response.precision
     end
 
-    def verb
-      response.verb
+    def valid?
+      response.accept?(actor, command)
     end
 
-    def narrative
-      response.narrative
+    def invalid?
+      !valid?
     end
 
     def meta?
       response.meta?
     end
+
+    # Sort an array of actions in the order in which a Dispatcher should
+    # attempt to execute them.
+    #
+    # Order is determined by the actions' substantiality, strictness, and
+    # precision. In the event of a tie, the most recently defined action has
+    # higher priority.
+    #
+    # @param actions [Array<Action>]
+    # @return [Array<Action>]
+    def self.sort(actions)
+      actions.sort_by.with_index do |action, idx|
+        [-action.substantiality, -action.strictness, -action.precision, idx]
+      end
+    end
   end
 end

data/lib/gamefic/active/cue.rb

@@ -2,24 +2,102 @@
 
 module Gamefic
   module Active
-    # The data that actors use to configure a Take.
+    # The object that actors use to perform a scene.
     #
     class Cue
-      # @return [Symbol]
-      attr_reader :scene
+      # @return [Actor]
+      attr_reader :actor
+
+      # @return [Class<Scene::Base>, Symbol]
+      attr_reader :key
+
+      # @return [Narrative]
+      attr_reader :narrative
 
       # @return [Hash]
       attr_reader :context
 
-      # @param scene [Symbol]
-      def initialize scene, **context
-        @scene = scene
+      # @return [Props::Default, nil]
+      attr_reader :props
+
+      # @param actor [Actor]
+      # @param key [Class<Scene::Base>, Symbol]
+      # @param narrative [Narrative]
+      def initialize actor, key, narrative, **context
+        @actor = actor
+        @key = key
+        @narrative = narrative
         @context = context
       end
 
+      # @return [void]
+      def start
+        @props = scene.start
+        prepare_output
+        actor.rotate_cue
+      end
+
+      # @return [void]
+      def finish
+        props&.enter(actor.queue.shift&.strip)
+        scene.finish
+      end
+
+      # @return [Props::Output]
+      def output
+        props&.output.clone.freeze || Props::Output::EMPTY
+      end
+
+      # @return [Cue]
+      def restart
+        Cue.new(actor, key, narrative, **context)
+      end
+
+      def type
+        scene&.type
+      end
+
       def to_s
         scene.to_s
       end
+
+      # @return [void]
+      def prepare
+        props.output.merge!({
+                              scene: scene.to_hash,
+                              prompt: props.prompt,
+                              messages: actor.messages,
+                              queue: actor.queue
+                            })
+        actor.narratives.player_output_blocks.each { |block| block.call actor, props.output }
+      end
+
+      # @return [Scene::Base]
+      def scene
+        # @note This method always returns a new instance. Scenes identified
+        #   by symbolic keys can be instances of anonymous classes that cannot
+        #   be serialized, so memoizing them breaks snapshots.
+        narrative&.prepare(key, actor, props, **context) ||
+          try_unblocked_class ||
+          raise("Failed to cue #{key.inspect} in #{narrative.inspect}")
+      end
+
+      private
+
+      # @return [Scene::Base]
+      def try_unblocked_class
+        return unless key.is_a?(Class) && key <= Scene::Base
+
+        Gamefic.logger.warn "Cueing scene #{key} without narrative" unless narrative
+        key.new(actor, narrative, props, **context)
+      end
+
+      # @return [void]
+      def prepare_output
+        scene
+        props.output.last_input = actor.last_cue&.props&.input
+        props.output.last_prompt = actor.last_cue&.props&.prompt
+      end
     end
   end
 end

data/lib/gamefic/active/messaging.rb

@@ -30,14 +30,22 @@ module Gamefic
         messenger.stream message
       end
 
+      # @return [String]
       def messages
         messenger.messages
       end
 
+      # Create a temporary buffer while yielding the given block and return the
+      # buffered text.
+      #
+      # @return [String]
       def buffer &block
         messenger.buffer(&block)
       end
 
+      # Clear the current buffer.
+      #
+      # @return [String] The buffer's messages
       def flush
         messenger.flush
       end

data/lib/gamefic/active/narratives.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Active
+    # A narrative container for active entities.
+    #
+    class Narratives
+      include Enumerable
+
+      # @param narrative [Narrative]
+      # @return [self]
+      def add(narrative)
+        narrative_set.add(narrative)
+        self
+      end
+
+      # @param narrative [Narrative]
+      # @return [self]
+      def delete(narrative)
+        narrative_set.delete(narrative)
+        self
+      end
+
+      def empty?
+        narrative_set.empty?
+      end
+
+      # @return [Integer]
+      def length
+        narrative_set.length
+      end
+
+      def one?
+        narrative_set.one?
+      end
+
+      # @return [Array<Response>]
+      def responses
+        narrative_set.flat_map(&:responses)
+      end
+
+      # @return [Array<Response>]
+      def responses_for(*verbs)
+        narrative_set.flat_map { |narr| narr.responses_for(*verbs) }
+      end
+
+      # @return [Array<Syntax>]
+      def syntaxes
+        narrative_set.flat_map(&:syntaxes)
+      end
+
+      # True if the specified verb is understood by any of the narratives.
+      #
+      # @param verb [String, Symbol]
+      def understand?(verb)
+        verb ? narrative_set.flat_map(&:synonyms).include?(verb.to_sym) : false
+      end
+
+      # @return [Array<Binding>]
+      def before_commands
+        narrative_set.flat_map(&:before_commands)
+      end
+
+      # @return [Array<Binding>]
+      def after_commands
+        narrative_set.flat_map(&:after_commands)
+      end
+
+      def each(&block)
+        narrative_set.each(&block)
+      end
+
+      # @return [Array<Narrative>]
+      def that_are(*args)
+        narrative_set.to_a.that_are(*args)
+      end
+
+      # @return [Array<Narrative>]
+      def that_are_not(*args)
+        narrative_set.to_a.that_are_not(*args)
+      end
+
+      # @return [Array<Entity>]
+      def entities
+        narrative_set.flat_map(&:entities)
+      end
+
+      # @return [Array<Binding>]
+      def player_output_blocks
+        narrative_set.flat_map(&:player_output_blocks).uniq(&:code)
+      end
+
+      private
+
+      # @return [Set<Narrative>]
+      def narrative_set
+        @narrative_set ||= Set.new
+      end
+    end
+  end
+end