gamefic 3.0.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6647dc3319080277826fecd19b8466cfbe82a42f4f4c68aeb89fa74bd0de4319
-  data.tar.gz: 0dc0680cb42b981d6e93c12d03e95b4ffcce0a98acb0678595723ab2d5ae7db9
+  metadata.gz: ac4f50caef9bd101bf90447e3ab289b05a29470e8f722ad391f7f0c9d8c4a921
+  data.tar.gz: 926b7d40dc87036e3759a1a464d3db3c82187da4f829731d0d82b053ac5e52a4
 SHA512:
-  metadata.gz: 1ec19185367b63b0ebe352e620af403e0aef00bdd7afac7135801551568ef5c35c923b45092cb4d781cd8458bba71776b042efe9837a0e9d2f144141b6b8d606
-  data.tar.gz: 300d2c30b05993ee4689f14ce8daeeec3585bfdf1cd7636ec6a931bfc568e8227a97771fdf6d20ec859080f3792b914a29ba1fc6a7246c9f9ef9eb563d81920c
+  metadata.gz: 6a4b426b4703a29717dbcc59bfee2e3f5d3b1b2ceeb6121741f52111e5fe2d8165e0946f8c3a085f1a3c4094edab11e2966f751dbc3cfc1541809ebc3a9ad970
+  data.tar.gz: ba3f3e82bd772ae392ffb23b056b62de2c1b5bebb0e810fea81bd59449d3e64c8c848f748803ac36f155ad3a2891b0e42d76ca48e4e74239a776670f19fdcc0e

data/CHANGELOG.md

@@ -1,4 +1,17 @@
-## 3.0.0
+## 3.2.0 - April 9, 2024
+- Bug fix for marshal of structs in Opal
+- Add last_input and last_prompt at start of take
+
+## 3.1.0 - April 8, 2024
+- Dispatcher prioritizes strict token matches
+- Scanner builds commands
+- Tokenize expressions and execute commands
+- Delete concluded subplots last in Plot#ready
+- Fix plot conclusion check after subplots conclude
+- Correct contexts for conclude and output blocks
+- Reinstate Active#last_input
+
+## 3.0.0 - January 27, 2024
 - Instantiate subplots from snapshots
 - Split Action into Response and Action
 - Logging

data/lib/gamefic/action.rb

@@ -13,8 +13,10 @@ module Gamefic
     # action's performance.
     #
     class Hook
+      # @param [Array<Symbol>]
       attr_reader :verbs
 
+      # @param [Proc]
       attr_reader :block
 
       def initialize *verbs, &block
@@ -45,11 +47,13 @@ module Gamefic
       @response = response
     end
 
+    # @return [self]
     def execute
-      return if cancelled?
+      return self if cancelled? || executed?
 
       @executed = true
       response.execute actor, *arguments
+      self
     end
 
     # True if the response has been executed. False typically means that the
@@ -75,6 +79,10 @@ module Gamefic
       response.verb
     end
 
+    def narrative
+      response.narrative
+    end
+
     def meta?
       response.meta?
     end

data/lib/gamefic/active/epic.rb

@@ -47,9 +47,14 @@ module Gamefic
         narratives.one?
       end
 
-      # @param name [Symbol]
-      def conclusion? name
-        select_scene(name).conclusion?
+      def syntaxes
+        rulebooks.flat_map(&:syntaxes)
+      end
+
+      def responses_for(*verbs)
+        rulebooks.to_a
+                 .reverse
+                 .flat_map { |rb| rb.responses_for(*verbs) }
       end
 
       # @param name [Symbol]

data/lib/gamefic/active/messaging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Gamefic
   module Active
     # A module for active entities that provides a default Messenger with

data/lib/gamefic/active/take.rb

@@ -16,7 +16,7 @@ module Gamefic
 
       # @param actor [Active]
       # @param cue [Active::Cue]
-      # @param props [Props::Default]
+      # @param props [Props::Default, nil]
       def initialize actor, cue, props = nil
         @actor = actor
         @cue = cue
@@ -31,12 +31,11 @@ module Gamefic
 
       # @return [Props::Default]
       def start
-        actor.output[:scene] = scene.to_hash
         scene.run_start_blocks actor, props
         scene.start actor, props
         # @todo See if this can be handled better
-        actor.epic.rulebooks.each { |rlbk| rlbk.run_player_output_blocks actor, actor.output }
-        actor.output.merge!({
+        actor.epic.rulebooks.each { |rlbk| rlbk.run_player_output_blocks actor, props.output }
+        props.output.merge!({
                               messages: actor.messages,
                               queue: actor.queue
                             })
@@ -47,7 +46,6 @@ module Gamefic
       def finish
         actor.flush
         scene.finish(actor, props)
-        actor.output.replace(last_prompt: props.prompt, last_input: props.input)
         scene.run_finish_blocks actor, props
       end
 

data/lib/gamefic/active.rb

@@ -21,6 +21,9 @@ module Gamefic
     # @return [Active::Cue, nil]
     attr_reader :next_cue
 
+    # @return [String, nil]
+    attr_reader :last_input
+
     # @return [Symbol, nil]
     def next_scene
       next_cue&.scene
@@ -48,12 +51,22 @@ module Gamefic
       @queue ||= []
     end
 
-    # A hash of data that will be sent to the user. The output is typically
-    # sent after a scene has started and before the user is prompted for input.
+    # Data that will be sent to the user. The output is typically sent after a
+    # scene has started and before the user is prompted for input.
+    #
+    # The output object attached to the actor is always frozen. Authors should
+    # use on_player_output blocks to modify output to be sent to the user.
     #
-    # @return [Hash]
+    # @return [Props::Output]
     def output
-      @output ||= {}
+      @output ||= Props::Output.new.freeze
+    end
+
+    # The output from the previous turn.
+    #
+    # @return [Props::Output]
+    def last_output
+      @last_output ||= output
     end
 
     # Perform a command.
@@ -65,11 +78,10 @@ module Gamefic
     #   character.perform "take the key"
     #
     # @param command [String]
-    # @return [void]
+    # @return [Action, nil]
     def perform(command)
       dispatchers.push Dispatcher.dispatch(self, command)
-      dispatchers.last.execute
-      dispatchers.pop
+      dispatchers.last.execute.tap { dispatchers.pop }
     end
 
     # Quietly perform a command.
@@ -95,11 +107,10 @@ module Gamefic
     #
     # @param verb [Symbol]
     # @param params [Array]
-    # @return [Gamefic::Action]
+    # @return [Action, nil]
     def execute(verb, *params)
       dispatchers.push Dispatcher.dispatch_from_params(self, verb, params)
-      dispatchers.last.execute
-      dispatchers.pop
+      dispatchers.last.execute.tap { dispatchers.pop }
     end
 
     # Proceed to the next Action in the current stack.
@@ -125,9 +136,9 @@ module Gamefic
     #     end
     #   end
     #
-    # @return [void]
+    # @return [Action, nil]
     def proceed
-      dispatchers.last&.proceed&.execute
+      dispatchers.last&.proceed
     end
 
     # Cue a scene to start in the next turn.
@@ -146,17 +157,24 @@ module Gamefic
     end
     alias prepare cue
 
+    # @return [void]
     def start_take
       ensure_cue
       @last_cue = @next_cue
       cue :default_scene
       @props = Take.start(self, @last_cue)
+      @last_output = self.output
+      @props.output[:last_prompt] = @last_output.prompt
+      @props.output[:last_input] = @last_input
+      @output = @props.output.dup.freeze
     end
 
+    # @return [void]
     def finish_take
       return unless @last_cue
 
       Take.finish(self, @last_cue, @props)
+      @last_input = @props.input
     end
 
     # Restart the scene from the most recent cue.
@@ -175,6 +193,7 @@ module Gamefic
     #
     # @param new_scene [Symbol]
     # @oaram context [Hash] Additional scene data
+    # @return [Cue]
     def conclude scene, **context
       cue scene, **context
       available = epic.select_scene(scene)
@@ -186,7 +205,7 @@ module Gamefic
     # True if the actor is ready to leave the game.
     #
     def concluding?
-      epic.empty? || (@last_cue && epic.conclusion?(@last_cue.scene))
+      epic.empty? || @props&.scene&.fetch(:type) == 'Conclusion'
     end
 
     def accessible?

data/lib/gamefic/command.rb

@@ -1,31 +1,20 @@
 # frozen_string_literal: true
 
 module Gamefic
-  # A decomposition of a text-based command into its verb and arguments.
-  #
-  # Commands are typically derived from tokenization against syntaxes.
+  # A concrete representation of an input as a verb and an array of arguments.
   #
   class Command
     # @return [Symbol]
     attr_reader :verb
 
-    # @return [Array<String>]
+    # @return [Array<Array<Entity>, Entity, String>]
     attr_reader :arguments
 
+    # @param verb [Symbol]
+    # @param arguments [Array<Array<Entity>, Entity, String>]
     def initialize verb, arguments
       @verb = verb
       @arguments = arguments
     end
-
-    # Compare two syntaxes for the purpose of ordering them by relevance while
-    # dispatching.
-    #
-    def compare other
-      if verb == other.verb
-        other.arguments.compact.length <=> arguments.compact.length
-      else
-        (other.verb ? 1 : 0) <=> (verb ? 1 : 0)
-      end
-    end
   end
 end

data/lib/gamefic/composer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Gamefic
+  # A function module for creating commands from expressions.
+  #
+  module Composer
+    # Create a command from the first expression that matches a response.
+    #
+    # @param actor [Actor]
+    # @param expressions [Array<Expression>]
+    # @return [Command]
+    def self.compose actor, expressions
+      %i[strict fuzzy].each do |method|
+        result = match_expressions_to_response actor, expressions, method
+        return result if result
+      end
+      Command.new(nil, [])
+    end
+
+    class << self
+      private
+
+      def match_expressions_to_response actor, expressions, method
+        expressions.each do |expression|
+          result = match_response_arguments actor, expression, method
+          return result if result
+        end
+        nil
+      end
+
+      def match_response_arguments actor, expression, method
+        actor.epic.responses_for(expression.verb).each do |response|
+          next unless response.queries.length >= expression.tokens.length
+
+          result = match_query_arguments(actor, expression, response, method)
+          return result if result
+        end
+        nil
+      end
+
+      def match_query_arguments actor, expression, response, method
+        remainder = response.verb ? '' : expression.verb.to_s
+        arguments = []
+        response.queries.each_with_index do |query, idx|
+          result = Scanner.send(method, query.select(actor), "#{remainder} #{expression.tokens[idx]}".strip)
+          break unless validate_result_from_query(result, query)
+
+          if query.ambiguous?
+            arguments.push result.matched
+          else
+            arguments.push result.matched.first
+          end
+          remainder = result.remainder
+        end
+
+        return nil if arguments.length != response.queries.length || remainder != ''
+
+        Command.new(response.verb, arguments)
+      end
+
+      # @param result [Scanner::Result]
+      # @param query [Query::Base]
+      def validate_result_from_query result, query
+        return false if result.matched.empty?
+
+        result.matched.length == 1 || query.ambiguous?
+      end
+    end
+  end
+end

data/lib/gamefic/dispatcher.rb

@@ -1,63 +1,54 @@
 # frozen_string_literal: true
 
 module Gamefic
-  # The action selector for character commands.
+  # The action executor for character commands.
   #
   class Dispatcher
     # @param actor [Actor]
-    # @param commands [Array<Command>]
-    # @param responses [Array<Response>]
-    def initialize actor, commands = [], responses = []
+    # @param command [Command]
+    def initialize actor, command
       @actor = actor
-      @commands = commands
-      @responses = responses
+      @command = command
       @executed = false
+      @finalized = false
     end
 
     # Run the dispatcher.
     #
+    # @return [Action, nil]
     def execute
       return if @executed
 
-      action = proceed
+      @executed = true
+      action = next_action
       return unless action
 
-      @executed = action.arguments
       run_before_action_hooks action
       return if action.cancelled?
 
       action.execute
       run_after_action_hooks action
+      action
     end
 
-    # Get the next executable action.
+    # Execute the next available action.
+    #
+    # Actors should run #execute first.
     #
     # @return [Action, nil]
     def proceed
-      while (response = responses.shift)
-        commands.each do |cmd|
-          action = response.attempt(actor, cmd)
-          next unless action && arguments_match?(action.arguments)
+      return unless @executed
 
-          return action
-        end
-      end
-      nil # Without this, return value in Opal is undefined
+      next_action&.execute
     end
 
     # @param actor [Active]
     # @param input [String]
     # @return [Dispatcher]
     def self.dispatch actor, input
-      commands = Syntax.tokenize(input, actor.epic.rulebooks.flat_map(&:syntaxes))
-      verbs = commands.map(&:verb).uniq
-      responses = actor.epic
-                       .rulebooks
-                       .to_a
-                       .reverse
-                       .flat_map { |pb| pb.responses_for(*verbs) }
-                       .reject(&:hidden?)
-      new(actor, commands, responses)
+      expressions = Syntax.tokenize(input, actor.epic.syntaxes)
+      command = Composer.compose(actor, expressions)
+      new(actor, command)
     end
 
     # @param actor [Active]
@@ -66,12 +57,7 @@ module Gamefic
     # @return [Dispatcher]
     def self.dispatch_from_params actor, verb, params
       command = Command.new(verb, params)
-      responses = actor.epic
-                       .rulebooks
-                       .to_a
-                       .reverse
-                       .flat_map { |pb| pb.responses_for(verb) }
-      new(actor, [command], responses)
+      new(actor, command)
     end
 
     protected
@@ -79,27 +65,48 @@ module Gamefic
     # @return [Actor]
     attr_reader :actor
 
-    # @return [Array<Command>]
-    attr_reader :commands
+    # @return [Command]
+    attr_reader :command
 
     # @return [Array<Response>]
-    attr_reader :responses
+    def responses
+      @responses ||= actor.epic.responses_for(command.verb)
+    end
 
     private
 
-    # After the first action gets selected, subsequent actions need to use the
-    # same arguments.
-    #
-    def arguments_match? arguments
-      !@executed || arguments == @executed
+    # @return [Action, nil]
+    def next_action
+      while (response = responses.shift)
+        next if response.queries.length < @command.arguments.length
+
+        return Action.new(actor, @command.arguments, response) if response.accept?(actor, @command)
+      end
+      finalize
     end
 
+    # @return [void]
     def run_before_action_hooks action
       actor.epic.rulebooks.flat_map { |rlbk| rlbk.run_before_actions action }
     end
 
+    # @return [void]
     def run_after_action_hooks action
       actor.epic.rulebooks.flat_map { |rlbk| rlbk.run_after_actions action }
     end
+
+    # If the dispatcher proceeds through all possible responses, it can fall
+    # back to a nil response as a catchall for commands that could not be
+    # completed.
+    #
+    # @return [Action, nil]
+    def finalize
+      return nil if @finalized
+
+      @finalized = true
+      @command = Command.new(nil, ["#{command.verb} #{command.arguments.join(' ').strip}"])
+      @responses = actor.epic.responses_for(nil)
+      next_action
+    end
   end
 end

data/lib/gamefic/entity.rb

@@ -9,7 +9,6 @@ module Gamefic
   class Entity
     include Describable
     include Node
-    # include Messaging
 
     def initialize **args
       klass = self.class
@@ -57,14 +56,13 @@ module Gamefic
     end
 
     class << self
-      # Set or update the default values for new instances.
+      # Set or update the default attributes for new instances.
       #
-      # @param attrs [Hash] The attributes to be merged into the defaults.
-      def set_default attrs = {}
+      def set_default **attrs
         default_attributes.merge! attrs
       end
 
-      # A hash of default values for attributes when creating an instance.
+      # A hash of default attributes when creating an instance.
       #
       # @return [Hash]
       def default_attributes

data/lib/gamefic/expression.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Gamefic
+  # A tokenization of an input from available syntaxes.
+  #
+  class Expression
+    # @return [Symbol]
+    attr_reader :verb
+
+    # @return [Array<String>]
+    attr_reader :tokens
+
+    # @param verb [Symbol, nil]
+    # @param tokens [Array<String>]
+    def initialize verb, tokens
+      @verb = verb
+      @tokens = tokens
+    end
+
+    # Compare two syntaxes for the purpose of ordering them by relevance while
+    # dispatching.
+    #
+    def compare other
+      if verb == other.verb
+        other.tokens.compact.length <=> tokens.compact.length
+      else
+        (other.verb ? 1 : 0) <=> (verb ? 1 : 0)
+      end
+    end
+  end
+end

data/lib/gamefic/plot.rb

@@ -9,8 +9,8 @@ module Gamefic
       super
       subplots.each(&:ready)
       players.each(&:start_take)
-      subplots.delete_if(&:concluding?)
       players.select(&:concluding?).each { |plyr| rulebook.run_player_conclude_blocks plyr }
+      subplots.delete_if(&:concluding?)
     end
 
     def update

data/lib/gamefic/props/default.rb

@@ -25,17 +25,23 @@ module Gamefic
       attr_reader :context
       alias data context
 
-      # @param scene [Scene, nil]
+      # @return [Hash]
+      attr_reader :scene
+
+      # @param scene [Scene]
       # @param context [Hash]
-      def initialize name, type, **context
-        @scene_name = name
-        @scene_type = type
+      def initialize scene, **context
+        @scene = { name: scene.name, type: scene.type }
         @context = context
       end
 
       def prompt
         @prompt ||= '>'
       end
+
+      def output
+        @output ||= Props::Output.new
+      end
     end
   end
 end