gamefic 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d4af1f6add0c467fce62acde7d4903e2165a0007312720ac0a43fb324e2a594
-  data.tar.gz: fe6adad9a8c85fd9eac1b9b6921e13f356da73489e9d82c95b63974f94f45df0
+  metadata.gz: 361eaf767babb3c8b5d7e47616d326a85e1b42269da33c518de33f16f9568451
+  data.tar.gz: 96f4d79e833f93c41714c5781cf863d7e0b8832e90c746f6bafe6164e10095b5
 SHA512:
-  metadata.gz: b2b0fda9b69825c655f6dfa90fa4c1bca78a6a53ea625946d54f9981d11104660f1e4f312bc53086559345f0c211edf979f237e18fd4bf95d83a2755e7b1cc9b
-  data.tar.gz: b1c85ff6f5c103354af38588bc129c989929c259ef4062abd8e9a0e5f92100fcf2134e1d16f3d8e3180bbcacd672d85b3cf5d1f162a8ff19217a64dc419e9bd7
+  metadata.gz: b9ad845f6f0271da17b64268b911f5d3fe40fbfd7fd563b411f6ef02e15b8a117abcd924d3586072040f428aafc0a92827458639f9f2c0ba9fa4883af7f33e05
+  data.tar.gz: 6f65996ac0ee16805763dd25fa89b1809a89acd0e44cb5d55f83ce22636aeadb6e43b733a15d44e6a397a636d5abde899c332d3601af60bcc4322a0c0ad1fb72

data/CHANGELOG.md

@@ -1,13 +1,16 @@
-# 2.1.1 - July 23, 2021
+## 2.2.0 - September 4, 2021
+- Dynamically inherit default attributes
+
+## 2.1.1 - July 23, 2021
 - Remove gamefic/scene/custom autoload
 
-# 2.1.0 - June 21, 2021
+## 2.1.0 - June 21, 2021
 - Remove redundant MultipleChoice prompt
 - Deprecate Scene::Custom
 
-# 2.0.3 - December 14, 2020
+## 2.0.3 - December 14, 2020
 - Remove unused Index class
 - Active#conclude accepts data argument
 
-# 2.0.2 - April 25, 2020
+## 2.0.2 - April 25, 2020
 - Improved snapshot serialization

data/lib/gamefic/action.rb

@@ -123,10 +123,8 @@ module Gamefic
 
       def valid? actor, objects
         return false if objects.length != queries.length
-        i = 0
-        queries.each do |p|
+        queries.each_with_index do |p, i|
           return false unless p.include?(actor, objects[i])
-          i += 1
         end
         true
       end
@@ -135,9 +133,11 @@ module Gamefic
       # provided tokens, or nil if the tokens are invalid.
       #
       # @param action [Gamefic::Entity]
-      # @param tokens [Array<String>]
+      # @param command [Command]
       # @return [self, nil]
-      def attempt actor, tokens
+      def attempt actor, command
+        return nil if command.verb != verb
+        tokens = command.arguments
         result = []
         matches = Gamefic::Query::Matches.new([], '', '')
         queries.each_with_index do |p, i|

data/lib/gamefic/active.rb

@@ -6,12 +6,6 @@ module Gamefic
   # subclass that includes this module.
   #
   module Active
-    # The last action executed by the entity, as reported by the
-    # Active#performed method.
-    #
-    # @return [Gamefic::Action]
-    attr_reader :last_action
-
     # The scene in which the entity is currently participating.
     #
     # @return [Gamefic::Scene::Base]
@@ -104,17 +98,29 @@ module Gamefic
     # @example Send a command as a verb with parameters
     #   character.perform :take, @key
     #
+    # @todo Modify this method so it only accepts a single command.
+    #   Verbs with parameters should use Active#execute instead.
+    #   It might be necessary to support command splats with a deprecation
+    #   warning until version 3.
+    #
     # @return [Gamefic::Action]
     def perform(*command)
-      actions = []
-      playbooks.reverse.each { |p| actions.concat p.dispatch(self, *command) }
-      execute_stack actions
+      if command.length > 1
+        execute command.first, *command[1..-1]
+      else
+        dispatchers.push Dispatcher.dispatch(self, command.first.to_s)
+        proceed
+        dispatchers.pop
+      end
     end
 
     # Quietly perform a command.
     # This method executes the command exactly as #perform does, except it
     # buffers the resulting output instead of sending it to the user.
     #
+    # @todo Modify this method so it only accepts a single command.
+    #   See Active#perform for more information.
+    #
     # @return [String] The output that resulted from performing the command.
     def quietly(*command)
       clear_buffer if buffer_stack == 0
@@ -137,9 +143,9 @@ module Gamefic
     #
     # @return [Gamefic::Action]
     def execute(verb, *params, quietly: false)
-      actions = []
-      playbooks.reverse.each { |p| actions.concat p.dispatch_from_params(self, verb, params) }
-      execute_stack actions, quietly: quietly
+      dispatchers.push Dispatcher.dispatch_from_params(self, verb, params)
+      proceed quietly: quietly
+      dispatchers.pop
     end
 
     # Proceed to the next Action in the current stack.
@@ -166,20 +172,19 @@ module Gamefic
     #   end
     #
     def proceed quietly: false
-      return if performance_stack.empty?
-      a = performance_stack.last.shift
-      unless a.nil?
-        if quietly
-          if buffer_stack == 0
-            @buffer = ""
-          end
-          set_buffer_stack(buffer_stack + 1)
-        end
-        a.execute
-        if quietly
-          set_buffer_stack(buffer_stack - 1)
-          @buffer
+      return if dispatchers.empty?
+      a = dispatchers.last.next
+      return if a.nil?
+      if quietly
+        if buffer_stack == 0
+          @buffer = ""
         end
+        set_buffer_stack(buffer_stack + 1)
+      end
+      a.execute
+      if quietly
+        set_buffer_stack(buffer_stack - 1)
+        @buffer
       end
     end
 
@@ -235,14 +240,6 @@ module Gamefic
       !scene.nil? && scene.kind_of?(Scene::Conclusion)
     end
 
-    # Record the last action the entity executed. This method is typically
-    # called when the entity performs an action in response to user input.
-    #
-    def performed action
-      action.freeze
-      @last_action = action
-    end
-
     def accessible?
       false
     end
@@ -270,37 +267,7 @@ module Gamefic
 
     # @return [Array<Gamefic::Scene::Base>]
     def entered_scenes
-      @entered_scenes ||= []    
-    end
-
-    # @param actions [Array<Gamefic::Action>]
-    # @param quietly [Boolean]
-    def execute_stack actions, quietly: false
-      return nil if actions.empty?
-      a = actions.first
-      okay = true
-      unless a.meta?
-        playbooks.reverse.each do |playbook|
-          okay = validate_playbook playbook, a
-          break unless okay
-        end
-      end
-      if okay
-        performance_stack.push actions
-        proceed quietly: quietly
-        performance_stack.pop
-      end
-      a
-    end
-
-    def validate_playbook playbook, action
-      okay = true
-      playbook.validators.each { |v|
-        result = v.call(self, action.verb, action.parameters)
-        okay = (result != false)
-        break unless okay
-      }
-      okay
+      @entered_scenes ||= []
     end
 
     def buffer_stack
@@ -324,8 +291,8 @@ module Gamefic
       @buffer = ''
     end
 
-    def performance_stack
-      @performance_stack ||= []
+    def dispatchers
+      @dispatchers ||= []
     end
   end
 end

data/lib/gamefic/core_ext/array.rb

@@ -64,7 +64,7 @@ class Array
     join_and(sep, orSep, serial)
   end
 
-  # private
+  private
 
   def _keep(arr, cls, bool)
     if (cls.kind_of?(Class) or cls.kind_of?(Module))

data/lib/gamefic/core_ext/string.rb

@@ -6,15 +6,9 @@ class String
   #
   # @return [String] The capitalized text
   def capitalize_first
-    "#{self[0,1].upcase}#{self[1,self.length]}"
-  end
-
-  # An alias for #capitalize_first.
-  #
-  # @return [String]
-  def cap_first
-    self.capitalize_first
+    "#{self[0, 1].upcase}#{self[1, self.length]}"
   end
+  alias cap_first capitalize_first
 
   # Get an array of words split by any whitespace.
   #

data/lib/gamefic/dispatcher.rb

@@ -0,0 +1,76 @@
+module Gamefic
+  # The action selector for character commands.
+  #
+  class Dispatcher
+    # @param actor [Actor]
+    # @param commands [Array<Command>]
+    # @param actions [Array<Action>]
+    def initialize actor, commands = [], actions = []
+      @actor = actor
+      @commands = commands
+      @actions = actions
+    end
+
+    def merge dispatcher
+      commands.concat dispatcher.commands
+      actions.concat dispatcher.actions
+    end
+
+    def next
+      instance = nil
+      while instance.nil? && !@actions.empty?
+        action = actions.shift
+        commands.each do |cmd|
+          instance = action.attempt(actor, cmd)
+          if instance
+            unless instance.meta?
+              actor.playbooks.reverse.each do |playbook|
+                return nil unless validate_playbook(playbook, instance)
+              end
+            end
+            break
+          end
+        end
+      end
+      instance
+    end
+
+    # @param actor [Active]
+    # @param command [String]
+    # @return [Dispatcher]
+    def self.dispatch actor, command
+      group = actor.playbooks.reverse.map { |p| p.dispatch(actor, command) }
+      dispatcher = Dispatcher.new(actor)
+      group.each { |d| dispatcher.merge d }
+      dispatcher
+    end
+
+    # @param actor [Active]
+    # @param verb [Symbol]
+    # @param params [Array<Object>]
+    # @return [Dispatcher]
+    def self.dispatch_from_params actor, verb, params
+      group = actor.playbooks.reverse.map { |p| p.dispatch_from_params(actor, verb, params) }
+      dispatcher = Dispatcher.new(actor)
+      group.each { |d| dispatcher.merge d }
+      dispatcher
+    end
+
+    protected
+
+    # @return [Actor]
+    attr_reader :actor
+
+    # @return [Array<Command>]
+    attr_reader :commands
+
+    # @return [Array<Action>]
+    attr_reader :actions
+
+    private
+
+    def validate_playbook playbook, action
+      playbook.validators.all? { |v| v.call(actor, action.verb, action.parameters) != false }
+    end
+  end
+end

data/lib/gamefic/element.rb

@@ -7,13 +7,16 @@ module Gamefic
   #
   class Element
     include Gamefic::Describable
-    # include Gamefic::Index
     include Gamefic::Serialize
 
-    # @todo It would be nice if this initialization wasn't necessary.
     def initialize(args = {})
-      # super self.class.default_attributes.merge(args)
-      self.class.default_attributes.merge(args).each_pair do |k, v|
+      klass = self.class
+      defaults = {}
+      while klass <= Element
+        defaults = klass.default_attributes.merge(defaults)
+        klass = klass.superclass
+      end
+      defaults.merge(args).each_pair do |k, v|
         public_send "#{k}=", v
       end
       post_initialize
@@ -38,10 +41,6 @@ module Gamefic
       def default_attributes
         @default_attributes ||= {}
       end
-
-      def inherited subclass
-        subclass.set_default default_attributes
-      end
     end
   end
 end

data/lib/gamefic/entity.rb

@@ -13,10 +13,10 @@ module Gamefic
 
     # Set the Entity's parent.
     #
-    # @param node [Gamefic::Entity] The new parent.
+    # @param node [Gamefic::Entity, nil] The new parent.
     def parent=(node)
-      if node != nil and node.kind_of?(Entity) == false
-        raise "Entity's parent must be an Entity"
+      if node && node.is_a?(Entity) == false
+        raise ArgumentError, "Entity's parent must be an Entity"
       end
       super
     end

data/lib/gamefic/plot.rb

@@ -74,7 +74,6 @@ module Gamefic
       entities.each { |e| e.flush }
       call_before_player_update
       players.each do |p|
-        p.performed nil
         next unless p.scene
         p.last_input = p.queue.last
         p.last_prompt = p.scene.prompt

data/lib/gamefic/scene/activity.rb

@@ -10,9 +10,7 @@ module Gamefic
 
     def finish
       super
-      o = nil
-      o = actor.perform input.strip unless input.to_s.strip.empty?
-      actor.performed o
+      actor.perform input.strip unless input.to_s.strip.empty?
     end
 
     class << self

data/lib/gamefic/serialize.rb

@@ -32,13 +32,6 @@ module Gamefic
       end
     end
 
-    def self.instances
-      GC.start
-      result = []
-      ObjectSpace.each_object(Gamefic::Serialize) { |obj| result.push obj }
-      result
-    end
-
     # @param string [String]
     # @return [Object]
     def self.string_to_constant string
@@ -71,7 +64,7 @@ class Object
   end
 
   def from_serial(index = [])
-    if self.is_a?(Hash) && (self['class'] || self['instance'])
+    if self.is_a?(Hash)
       if self['instance']
         elematch = self['instance'].match(/^#<ELE_([\d]+)>$/)
         object = index[elematch[1].to_i]
@@ -110,25 +103,8 @@ class Object
       return index.index(match[1].to_i) if match
       match = self.match(/#<SYM:([a-z0-9_\?\!]+)>/i)
       return match[1].to_sym if match
-      # return nil if self == '#<UNKNOWN>'
+      return nil if self == '#<UNKNOWN>'
       self
-    elsif self.is_a?(Hash)
-      result = {}
-      unknown = false
-      self.each_pair do |k, v|
-        k2 = k.from_serial(index)
-        v2 = v.from_serial(index)
-        if k2 == "#<UNKNOWN>" || v2 == "#<UNKNOWN>"
-          unknown = true
-          break
-        end
-        result[k2] = v2
-      end
-      result = "#<UNKNOWN>" if unknown
-      result
-    elsif self && self != true
-      STDERR.puts "Unable to unserialize #{self.class}"
-      nil
     else
       # true, false, or nil
       self

data/lib/gamefic/syntax.rb

@@ -1,5 +1,3 @@
-require 'gamefic/command'
-
 module Gamefic
   class Syntax
     attr_reader :token_count, :first_word, :verb, :template, :command
@@ -57,17 +55,18 @@ module Gamefic
       m = text.match(@regexp)
       return nil if m.nil?
       arguments = []
-      # HACK: Skip the first word if the verb is not nil.
-      # This is ugly.
       b = @verb.nil? ? 0 : 1
+      xverb = @verb
       @replace.to_s.split_words[b..-1].each { |r|
         if r.match(/^\{\$[0-9]+\}$/)
           arguments.push m[r[2..-2].to_i]
+        elsif arguments.empty? && xverb.nil?
+          xverb = r.to_sym
         else
           arguments.push r
         end
       }
-      Command.new @verb, arguments
+      Command.new xverb, arguments
     end
 
     # Determine if the specified text matches the syntax's expected pattern.
@@ -90,25 +89,32 @@ module Gamefic
       signature == other.signature
     end
 
-    # Tokenize an Array of Commands from the specified text.
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      signature.hash
+    end
+
+    # Tokenize an Array of Commands from the specified text. The resulting
+    # array is in descending order of specificity, i.e., most to least matched
+    # tokens.
     #
     # @param text [String] The text to tokenize.
     # @param syntaxes [Array<Gamefic::Syntax>] The Syntaxes to use.
     # @return [Array<Gamefic::Command>] The tokenized commands.
     def self.tokenize text, syntaxes
-      matches = []
-      syntaxes.each { |syntax|
-        result = syntax.tokenize text
-        matches.push(result) if !result.nil?
-      }
-      matches.sort! { |a,b|
-        if a.arguments.length == b.arguments.length
-          b.verb.to_s <=> a.verb.to_s
-        else
-          b.arguments.length <=> a.arguments.length
+      syntaxes
+        .map { |syn| syn.tokenize(text) }
+        .reject(&:nil?)
+        .sort do |a, b|
+          if a.arguments.length == b.arguments.length
+            b.verb.to_s <=> a.verb.to_s
+          else
+            b.arguments.length <=> a.arguments.length
+          end
         end
-      }
-      matches
     end
   end
 end

data/lib/gamefic/version.rb

@@ -1,3 +1,3 @@
 module Gamefic
-  VERSION = '2.1.1'
+  VERSION = '2.2.0'
 end

data/lib/gamefic/world/commands.rb

@@ -95,25 +95,6 @@ module Gamefic
         playbook.meta command, *queries, &proc
       end
 
-      # Declare a dismabiguation response for actions.
-      # The disambiguator is executed when an action expects an argument to
-      # reference a specific entity but its query matched more than one. For
-      # example, "red" might refer to either a red key or a red book.
-      #
-      # If a disambiguator is not defined, the playbook will use its default
-      # implementation.
-      #
-      # @example Tell the player the list of ambiguous entities.
-      #   disambiguate do |actor, entities|
-      #     actor.tell "I don't know which you mean: #{entities.join_or}."
-      #   end
-      #
-      # @yieldparam [Gamefic::Actor]
-      # @yieldparam [Array<Gamefic::Entity>]
-      def disambiguate &block
-        playbook.disambiguate &block
-      end
-
       # Validate an order before a character can execute its command.
       #
       # @yieldparam [Gamefic::Director::Order]

data/lib/gamefic/world/playbook.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Gamefic
   module World
     # A collection of rules for performing commands.
@@ -13,11 +15,14 @@ module Gamefic
       # @return [Array<Proc>]
       attr_reader :validators
 
-      def initialize commands: {}, syntaxes: [], validators: [], disambiguator: nil
+      # @param commands [Hash]
+      # @param syntaxes [Array<Syntax>, Set<Syntax>]
+      # @param validators [Array]
+      def initialize commands: {}, syntaxes: [], validators: []
         @commands = commands
-        @syntaxes = syntaxes
+        @syntax_set = syntaxes.to_set
+        sort_syntaxes
         @validators = validators
-        @disambiguator = disambiguator
       end
 
       # An array of available actions.
@@ -34,25 +39,6 @@ module Gamefic
         @commands.keys
       end
 
-      # Get the action for handling ambiguous entity references.
-      #
-      def disambiguator
-        @disambiguator ||= Action.subclass(nil, Query::Base.new) do |actor, entities|
-          definites = []
-          entities.each do |entity|
-            definites.push entity.definitely
-          end
-          actor.tell "I don't know which you mean: #{definites.join_or}."
-        end
-      end
-
-      # Set the action for handling ambiguous entity references.
-      #
-      def disambiguate &block
-        @disambiguator = Action.subclass(nil, Query::Base.new, meta: true, &block)
-        @disambiguator
-      end
-
       # Add a block that determines whether an action can be executed.
       #
       def validate &block
@@ -138,35 +124,16 @@ module Gamefic
         syn
       end
 
-      # Get an array of actions, derived from the specified command, that the
-      # actor can potentially execute.
-      # The command can either be a single string (e.g., "examine book") or a
-      # list of tokens (e.g., :examine, @book).
-      #
-      # @return [Array<Gamefic::Action>]
-      def dispatch(actor, *command)
-        result = []
-        result.concat dispatch_from_params(actor, command[0], command[1..-1]) if command.length > 1
-        result.concat dispatch_from_string(actor, command.join(' ')) if result.empty?
-        result
-      end
-
-      # Get an array of actions, derived from the specified command, that the
-      # actor can potentially execute.
-      # The command should be a plain-text string, e.g., "examine the book."
+      # Get a Dispatcher to select actions that can potentially be executed
+      # from the specified command string.
       #
-      # @return [Array<Gamefic::Action>]
-      def dispatch_from_string actor, text
-        result = []
+      # @param actor [Actor]
+      # @param text [String]
+      # @return [Dispatcher]
+      def dispatch(actor, text)
         commands = Syntax.tokenize(text, actor.syntaxes)
-        commands.each do |c|
-          actions_for(c.verb).each do |a|
-            next if a.hidden?
-            o = a.attempt(actor, c.arguments)
-            result.unshift o unless o.nil?
-          end
-        end
-        sort_and_reduce_actions result
+        actions = commands.flat_map { |cmd| actions_for(cmd.verb).reject(&:hidden?) }
+        Dispatcher.new(actor, commands, sort_and_reduce_actions(actions))
       end
 
       # Get an array of actions, derived from the specified verb and params,
@@ -174,12 +141,8 @@ module Gamefic
       #
       # @return [Array<Gamefic::Action>]
       def dispatch_from_params actor, verb, params
-        result = []
         available = actions_for(verb)
-        available.each do |a|
-          result.unshift a.new(actor, params) if a.valid?(actor, params)
-        end
-        sort_and_reduce_actions result
+        Dispatcher.new(actor, [Command.new(verb, params)], sort_and_reduce_actions(available))
       end
 
       # Duplicate the playbook.
@@ -224,22 +187,23 @@ module Gamefic
 
       def add_syntax syntax
         raise "No actions exist for \"#{syntax.verb}\"" if @commands[syntax.verb].nil?
+        sort_syntaxes if @syntax_set.add?(syntax)
+      end
 
-        @syntaxes.unshift syntax
-        @syntaxes.uniq!(&:signature)
-        @syntaxes.sort! do |a, b|
+      def sort_and_reduce_actions arr
+        arr.sort_by.with_index { |a, i| [a.rank, i] }.reverse.uniq
+      end
+
+      def sort_syntaxes
+        @syntaxes = @syntax_set.sort do |a, b|
           if a.token_count == b.token_count
-            # For syntaxes of the same length, length of action takes precedence
+            # For syntaxes of the same length, sort first word
             b.first_word <=> a.first_word
           else
             b.token_count <=> a.token_count
           end
         end
       end
-
-      def sort_and_reduce_actions arr
-        arr.sort_by.with_index { |a, i| [a.rank, -i]}.reverse.uniq(&:class)
-      end
     end
   end
 end

data/lib/gamefic.rb

@@ -14,6 +14,8 @@ require "gamefic/scene"
 require "gamefic/query"
 require "gamefic/action"
 require "gamefic/syntax"
+require "gamefic/command"
+require "gamefic/dispatcher"
 require 'gamefic/world'
 require 'gamefic/scriptable'
 require 'gamefic/plot'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gamefic
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Fred Snyder
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-03 00:00:00.000000000 Z
+date: 2021-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -88,6 +88,7 @@ files:
 - lib/gamefic/core_ext/array.rb
 - lib/gamefic/core_ext/string.rb
 - lib/gamefic/describable.rb
+- lib/gamefic/dispatcher.rb
 - lib/gamefic/element.rb
 - lib/gamefic/entity.rb
 - lib/gamefic/keywords.rb