gamefic 1.7.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f3811a2f448c91712eaa8eec46000577c7d38f7a
-  data.tar.gz: 6cb83cb93b14fd5c94401367e51828bad90a8960
+SHA256:
+  metadata.gz: ad70329086d7b1e9dd06a8459c5b1ee95952ab5453f63afd4e7a87df6ba90e69
+  data.tar.gz: 443a8642312dd1da33612a78ce1598723a9336b46e55b840636c2f41804eb8c5
 SHA512:
-  metadata.gz: 12f2199a4d803e7a179b49e1d50f6e83571f21d601e67828546de918c65b3da0ee97790e66ee5f73f34b1a901d515284e3c8bd030ff0dc5d816678b7c9a0ba48
-  data.tar.gz: 31118c91be341821662fe8624b85924b196c52f9b2bcd0c758f5af13fc9d1dceaa76f204d6f6f3d2e274ef049153b416dcd2648a207e4ad07ea02ea4b9b440c4
+  metadata.gz: 6c207722b0d00906579e9a221d0f8fad831a8f35694ac2252569d427d2846e113beda49c3e160083013284e6f5c85354f9959b49fceb4383100c451de61dc882
+  data.tar.gz: 899b4605d74e236a6904d80a6218c6c607c78594357124bb2b36ea12557bee1c485e76bde2eb8ed1f29359f7d6a6f32ca1d7c2294b0d56f9d1109ad195f7c890

data/.gitignore

@@ -0,0 +1,12 @@
+Gemfile.lock
+.buildpath
+.project
+.settings
+.DS_Store
+coverage
+examples/*/build
+examples/*/release
+.yardoc
+doc
+.vscode
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,16 @@
+Metrics/LineLength:
+  Description: 'Limit lines to 80 characters.'
+  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#80-character-limits'
+  Enabled: false
+
+Style/StringLiterals:
+  Description: 'Checks if uses of quotes match the configured preference.'
+  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#consistent-string-literals'
+  Enabled: false
+
+Style/Documentation:
+  Description: 'Document classes and non-namespace modules.'
+  Enabled: false
+
+Style/MethodDefParentheses:
+  Enabled: false

data/.solargraph.yml

@@ -0,0 +1,5 @@
+include:
+  - lib/**/*.rb
+exclude:
+  - spec/**/*
+  - test/**/*

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# 2.1.0 - June 21, 2021
+- Remove redundant MultipleChoice prompt
+- Deprecate Scene::Custom
+
+# 2.0.3 - December 14, 2020
+- Remove unused Index class
+- Active#conclude accepts data argument
+
+# 2.0.2 - April 25, 2020
+- Improved snapshot serialization

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem "simplecov"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Gamefic
+Copyright (c) 2013 by Fred Snyder for Castwide Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Gamefic
+
+**A Ruby Interactive Fiction Framework**
+
+Gamefic is a system for developing and playing adventure games and interactive
+fiction. This gem provides the core library for running game narratives.
+
+Developers should refer to the [Gamefic SDK](https://github.com/castwide/gamefic-sdk)
+for information about writing, building, and distributing Gamefic apps.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/castwide/gamefic-sdk.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## More Information
+
+Go to [the official Gamefic website](http://gamefic.com) for games, news, and
+more documentation.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = Dir.glob('spec/**/*_spec.rb')
+  t.rspec_opts = '--format documentation'
+  # t.rspec_opts << ' more options'
+  #t.rcov = true
+end
+task :default => :spec

data/gamefic.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gamefic/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name          = 'gamefic'
+  s.version       = Gamefic::VERSION
+  s.date          = Date.today.strftime("%Y-%m-%d")
+  s.summary       = "Gamefic"
+  s.description   = "An adventure game and interactive fiction framework"
+  s.authors       = ["Fred Snyder"]
+  s.email         = 'fsnyder@gamefic.com'
+  s.homepage      = 'http://gamefic.com'
+  s.license       = 'MIT'
+
+  s.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.1.0'
+
+  s.add_development_dependency 'rake', '~> 12.3', '>= 12.3'
+  s.add_development_dependency 'rspec', '~> 3.5', '>= 3.5.0'
+  s.add_development_dependency 'simplecov', '~> 0.14'
+end

data/lib/gamefic.rb

@@ -1,9 +1,11 @@
-require 'gamefic/matchable'
+require 'gamefic/version'
+
+require 'gamefic/keywords'
 require 'gamefic/core_ext/array'
 require 'gamefic/core_ext/string'
 
-require 'gamefic/grammar'
 require 'gamefic/describable'
+require 'gamefic/serialize'
 require 'gamefic/element'
 require 'gamefic/entity'
 require 'gamefic/active'
@@ -12,9 +14,7 @@ require "gamefic/scene"
 require "gamefic/query"
 require "gamefic/action"
 require "gamefic/syntax"
-require "gamefic/plot"
+require 'gamefic/world'
+require 'gamefic/scriptable'
+require 'gamefic/plot'
 require 'gamefic/subplot'
-require "gamefic/engine"
-require "gamefic/user"
-
-require 'gamefic/version'

data/lib/gamefic/action.rb

@@ -1,32 +1,35 @@
 module Gamefic
-  # Exception raised when the Action's proc arity is not compatible with the
-  # number of queries
-  class ActionArgumentError < ArgumentError
-  end
-
   class Action
-    attr_reader :parameters
-
-    def initialize actor, parameters
+    # An array of objects on which the action will operate, e.g., an entity
+    # that is a direct object of a command.
+    #
+    # @return [Array<Object>]
+    attr_reader :arguments
+    alias parameters arguments
+
+    def initialize actor, arguments
       @actor = actor
-      @parameters = parameters
+      @arguments = arguments
       @executed = false
     end
 
-    # @todo Determine whether to call them parameters, arguments, or both.
-    def arguments
-      parameters
-    end
-
+    # Perform the action.
+    #
     def execute
       @executed = true
-      self.class.executor.call(@actor, *@parameters) unless self.class.executor.nil?
+      self.class.executor.call(@actor, *arguments) unless self.class.executor.nil?
     end
 
+    # True if the #execute method has been called for this action.
+    #
+    # @return [Boolean]
     def executed?
       @executed
     end
 
+    # The verb associated with this action.
+    #
+    # @return [Symbol] The symbol representing the verb
     def verb
       self.class.verb
     end
@@ -39,34 +42,39 @@ module Gamefic
       self.class.rank
     end
 
+    # True if the action is flagged as meta.
+    #
+    # @return [Boolean]
     def meta?
       self.class.meta?
     end
 
-    def order_key
-      self.class.order_key
-    end
-
-    def self.subclass verb, *q, meta: false, order_key: 0, &block
+    # @param verb [Symbol]
+    # @param queries [Array<Gamefic::Query::Base>]
+    # @param meta [Boolean]
+    # @return [Class<Action>]
+    def self.subclass verb, *queries, meta: false, &block
       act = Class.new(self) do
         self.verb = verb
         self.meta = meta
-        self.order_key = order_key
-        q.each { |q|
+        queries.each do |q|
           add_query q
-        }
+        end
         on_execute &block
       end
-      if !block.nil? and act.queries.length + 1 != block.arity and block.arity > 0
-        raise ActionArgumentError.new("Number of parameters is not compatible with proc arguments")
+      if !block.nil? && act.queries.length + 1 != block.arity && block.arity > 0
+        raise ArgumentError.new("Number of parameters is not compatible with proc arguments")
       end
       act
     end
 
     class << self
-      def verb
-        @verb
-      end
+      attr_reader :verb
+
+      # The proc to call when the action is executed
+      #
+      # @return [Proc]
+      attr_reader :executor
 
       def meta?
         @meta ||= false
@@ -87,27 +95,27 @@ module Gamefic
 
       def signature
         # @todo This is clearly unfinished
-        "#{verb} #{queries.map{|m| m.signature}.join(',')}"
+        "#{verb} #{queries.map {|m| m.signature}.join(', ')}"
       end
 
+      # True if this action is not intended to be performed directly by a
+      # character.
+      # If the action is hidden, users should not be able to perform it with a
+      # direct command. By default, any action whose verb starts with an
+      # underscore is hidden.
+      #
+      # @return [Boolean]
       def hidden?
         verb.to_s.start_with?('_')
       end
 
-      def executor
-        @executor
-      end
-
-      def order_key
-        @order_key ||= 0
-      end
-
+      # @return [Integer]
       def rank
         if @rank.nil?
           @rank = 0
-          queries.each { |q|
+          queries.each do |q|
             @rank += (q.rank + 1)
-          }
+          end
           @rank -= 1000 if verb.nil?
         end
         @rank
@@ -116,45 +124,43 @@ module Gamefic
       def valid? actor, objects
         return false if objects.length != queries.length
         i = 0
-        queries.each { |p|
+        queries.each do |p|
           return false unless p.include?(actor, objects[i])
           i += 1
-        }
+        end
         true
       end
 
+      # Return an instance of this Action if the actor can execute it with the
+      # provided tokens, or nil if the tokens are invalid.
+      #
+      # @param action [Gamefic::Entity]
+      # @param tokens [Array<String>]
+      # @return [self, nil]
       def attempt actor, tokens
-        i = 0
         result = []
         matches = Gamefic::Query::Matches.new([], '', '')
-        queries.each { |p|
-          return nil if tokens[i].nil? and matches.remaining == ''
+        queries.each_with_index do |p, i|
+          return nil if tokens[i].nil? && matches.remaining == ''
           matches = p.resolve(actor, "#{matches.remaining} #{tokens[i]}".strip, continued: (i < queries.length - 1))
           return nil if matches.objects.empty?
+          accepted = matches.objects.select { |o| p.accept?(o) }
+          return nil if accepted.empty?
           if p.ambiguous?
-            result.push matches.objects
+            result.push accepted
           else
-            return nil if matches.objects.length > 1
-            result.push matches.objects[0]
+            return nil if accepted.length != 1
+            result.push accepted.first
           end
-          i += 1
-        }
-        self.new(actor, result)
+        end
+        new(actor, result)
       end
 
       protected
 
-      def verb= sym
-        @verb = sym
-      end
+      attr_writer :verb
 
-      def meta= bool
-        @meta = bool
-      end
-
-      def order_key= num
-        @order_key = num
-      end
+      attr_writer :meta
     end
   end
 end

data/lib/gamefic/active.rb

@@ -1,280 +1,331 @@
-module Gamefic
-  class NotConclusionError < Exception
-  end
-
-  # The Active module gives entities the ability to perform actions and
-  # participate in scenes.
-  #
-  module Active
-    # @return [Gamefic::Action]
-    attr_reader :last_action
-
-    # @return [Gamefic::User::Base]
-    attr_reader :user
-
-    # @return [Gamefic::Scene::Base]
-    attr_reader :scene
-
-    attr_reader :next_scene
-
-    # @return [Gamefic::Plot::Playbook]
-    #attr_accessor :playbook
-
-    # @return [Array<Gamefic::Plot::Playbook>]
-    def playbooks
-      @playbooks ||= []
-    end
-
-    def connect user
-      @user = user
-    end
-
-    # An array of actions waiting to be performed.
-    #
-    # @return [Array<String>]
-    def queue
-      @queue ||= []
-    end
-
-    # A hash of values representing the state of a performing entity.
-    #
-    # @return [Hash]
-    def state
-      @state = {}
-      @state.merge! scene.state unless scene.nil?
-      @state[:output] = messages
-      @state
-    end
-
-    # Send a message to the entity.
-    # This method will automatically wrap the message in HTML paragraphs.
-    # To send a message without paragraph formatting, use #stream instead.
-    #
-    # @param message [String]
-    def tell(message)
-      if buffer_stack > 0
-        append_buffer message
-      else
-        super
-      end
-    end
-
-    # Send a message to the Character as raw text.
-    # Unlike #tell, this method will not wrap the message in HTML paragraphs.
-    #
-    # @param message [String]
-    def stream(message)
-      if buffer_stack > 0
-        append_buffer message
-      else
-        super
-      end
-    end
-
-    # Perform a command.
-    # The command can be specified as a String or a verb with a list of
-    # parameters. Either form should yield the same result, but the
-    # verb/parameter form can yield better performance since it bypasses the
-    # parser.
-    #
-    # The command will be executed immediately regardless of the entity's
-    # state.
-    #
-    # @example Send a command as a string
-    #   character.perform "take the key"
-    #
-    # @example Send a command as a verb with parameters
-    #   character.perform :take, @key
-    #
-    # @return [Gamefic::Action]
-    def perform(*command)
-      actions = []
-      playbooks.reverse.each { |p| actions.concat p.dispatch(self, *command) }
-      execute_stack actions
-    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.
-    #
-    # @return [String] The output that resulted from performing the command.
-    def quietly(*command)
-      if buffer_stack == 0
-        clear_buffer
-      end
-      set_buffer_stack buffer_stack + 1
-      self.perform *command
-      set_buffer_stack buffer_stack - 1
-      buffer
-    end
-
-    # Perform an action.
-    # This is functionally identical to the `perform` method, except the
-    # action must be declared as a verb with a list of parameters. Use
-    # `perform` if you need to parse a string as a command.
-    #
-    # The command will be executed immediately regardless of the entity's
-    # state.
-    #
-    # @example
-    #   character.execute :take, @key
-    #
-    # @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
-    end
-
-    # Proceed to the next Action in the current stack.
-    # This method is typically used in Action blocks to cascade through
-    # multiple implementations of the same verb.
-    #
-    # @example Proceed through two implementations of a verb
-    #   introduction do |actor|
-    #     actor[:has_eaten] = false # Initial value
-    #   end
-    #   respond :eat do |actor|
-    #     actor.tell "You eat something."
-    #     actor[:has_eaten] = true
-    #   end
-    #   respond :eat do |actor|
-    #     # This version will be executed first because it was implemented last
-    #     if actor[:has_eaten]
-    #       actor.tell "You already ate."
-    #     else
-    #       actor.proceed # Execute the previous implementation
-    #     end
-    #   end
-    #
-    def proceed quietly: false
-      #Director::Delegate.proceed_for self
-      return if performance_stack.empty?
-      a = performance_stack.last.shift
-      unless a.nil?
-        if quietly
-          if @buffer_stack == 0
-            @buffer = ""
-          end
-          @buffer_stack += 1
-        end
-        a.execute
-        if quietly
-          @buffer_stack -= 1
-          @buffer
-        end
-      end
-    end
-
-    # Immediately start a new scene for the character.
-    # Use #prepare if you want to declare a scene to be started at the
-    # beginning of the next turn.
-    #
-    def cue new_scene
-      @next_scene = nil
-      if new_scene.nil?
-        @scene = nil
-      else
-        @scene = new_scene.new(self)
-        @scene.start
-      end
-    end
-
-    # Prepare a scene to be started for this character at the beginning of the
-    # next turn.
-    #
-    def prepare s
-      @next_scene = s
-    end
-
-    # Return true if the character is expected to be in the specified scene on
-    # the next turn.
-    #
-    # @return [Boolean]
-    def will_cue? scene
-      (@scene.class == scene and @next_scene.nil?) or @next_scene == scene
-    end
-
-    # Cue a conclusion. This method works like #cue, except it will raise a
-    # NotConclusionError if the scene is not a Scene::Conclusion.
-    #
-    def conclude scene
-      raise NotConclusionError unless scene <= Scene::Conclusion
-      cue scene
-    end
-
-    # True if the character is in a conclusion.
-    #
-    # @return [Boolean]
-    def concluded?
-      !scene.nil? and scene.kind_of?(Scene::Conclusion)
-    end
-
-    def performed order
-      order.freeze
-      @last_action = order
-    end
-
-    def accessible?
-      false
-    end
-
-    def inspect
-      to_s
-    end
-
-    private
-
-    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
-    end
-
-    def buffer_stack
-      @buffer_stack ||= 0
-    end
-
-    def set_buffer_stack num
-      @buffer_stack = num
-    end
-
-    def buffer
-      @buffer ||= ''
-    end
-
-    def append_buffer str
-      @buffer += str
-    end
-
-    def clear_buffer
-      @buffer = '' unless @buffer.empty?
-    end
-
-    def performance_stack
-      @performance_stack ||= []
-    end
-  end
-end
+module Gamefic
+  class NotConclusionError < RuntimeError; end
+
+  # The Active module gives entities the ability to perform actions and
+  # participate in scenes. The Actor class, for example, is an Entity
+  # 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]
+    attr_reader :scene
+
+    # The scene class that will be cued for this entity on the next turn.
+    # Usually set with the #prepare method.
+    #
+    # @return [Class<Gamefic::Scene::Base>]
+    attr_reader :next_scene
+
+    attr_reader :next_options
+
+    # The prompt for the previous scene.
+    #
+    # @return [String]
+    attr_accessor :last_prompt
+
+    # The input for the previous scene.
+    #
+    # @return [String]
+    attr_accessor :last_input
+
+    # The playbooks that will be used to perform commands.
+    #
+    # @return [Array<Gamefic::World::Playbook>]
+    def playbooks
+      @playbooks ||= []
+    end
+
+    def syntaxes
+      playbooks.map(&:syntaxes).flatten
+    end
+
+    # An array of actions waiting to be performed.
+    #
+    # @return [Array<String>]
+    def queue
+      @queue ||= []
+    end
+
+    # A hash of values representing the state of a performing entity.
+    #
+    # @return [Hash{Symbol => Object}]
+    def state
+      @state ||= {}
+    end
+
+    def output
+      @output ||= {}
+    end
+
+    # Send a message to the entity.
+    # This method will automatically wrap the message in HTML paragraphs.
+    # To send a message without paragraph formatting, use #stream instead.
+    #
+    # @param message [String]
+    def tell(message)
+      if buffer_stack > 0
+        append_buffer format(message)
+      else
+        super
+      end
+    end
+
+    # Send a message to the Character as raw text.
+    # Unlike #tell, this method will not wrap the message in HTML paragraphs.
+    #
+    # @param message [String]
+    def stream(message)
+      if buffer_stack > 0
+        append_buffer message
+      else
+        super
+      end
+    end
+
+    # Perform a command.
+    # The command can be specified as a String or a verb with a list of
+    # parameters. Either form should yield the same result, but the
+    # verb/parameter form can yield better performance since it bypasses the
+    # parser.
+    #
+    # The command will be executed immediately regardless of the entity's
+    # state.
+    #
+    # @example Send a command as a string
+    #   character.perform "take the key"
+    #
+    # @example Send a command as a verb with parameters
+    #   character.perform :take, @key
+    #
+    # @return [Gamefic::Action]
+    def perform(*command)
+      actions = []
+      playbooks.reverse.each { |p| actions.concat p.dispatch(self, *command) }
+      execute_stack actions
+    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.
+    #
+    # @return [String] The output that resulted from performing the command.
+    def quietly(*command)
+      clear_buffer if buffer_stack == 0
+      set_buffer_stack buffer_stack + 1
+      self.perform *command
+      set_buffer_stack buffer_stack - 1
+      buffer
+    end
+
+    # Perform an action.
+    # This is functionally identical to the `perform` method, except the
+    # action must be declared as a verb with a list of parameters. Use
+    # `perform` if you need to parse a string as a command.
+    #
+    # The command will be executed immediately regardless of the entity's
+    # state.
+    #
+    # @example
+    #   character.execute :take, @key
+    #
+    # @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
+    end
+
+    # Proceed to the next Action in the current stack.
+    # This method is typically used in Action blocks to cascade through
+    # multiple implementations of the same verb.
+    #
+    # @example Proceed through two implementations of a verb
+    #   introduction do |actor|
+    #     actor[:has_eaten] = false # Initial value
+    #   end
+    #
+    #   respond :eat do |actor|
+    #     actor.tell "You eat something."
+    #     actor[:has_eaten] = true
+    #   end
+    #
+    #   respond :eat do |actor|
+    #     # This version will be executed first because it was implemented last
+    #     if actor[:has_eaten]
+    #       actor.tell "You already ate."
+    #     else
+    #       actor.proceed # Execute the previous implementation
+    #     end
+    #   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
+        end
+      end
+    end
+
+    # Immediately start a new scene for the character.
+    # Use #prepare if you want to declare a scene to be started at the
+    # beginning of the next turn.
+    #
+    # @param new_scene [Class<Scene::Base>]
+    # @param data [Hash] Additional scene data
+    def cue new_scene, **data
+      @next_scene = nil
+      if new_scene.nil?
+        @scene = nil
+      else
+        @scene = new_scene.new(self, **data)
+        @scene.start
+      end
+    end
+
+    # Prepare a scene to be started for this character at the beginning of the
+    # next turn. As opposed to #cue, a prepared scene will not start until the
+    # current scene finishes.
+    #
+    # @param new_scene [Class<Scene::Base>]
+    # @oaram data [Hash] Additional scene data
+    def prepare new_scene, **data
+      @next_scene = new_scene
+      @next_options = data
+    end
+
+    # Return true if the character is expected to be in the specified scene on
+    # the next turn.
+    #
+    # @return [Boolean]
+    def will_cue? scene
+      (@scene.class == scene and @next_scene.nil?) || @next_scene == scene
+    end
+
+    # Cue a conclusion. This method works like #cue, except it will raise a
+    # NotConclusionError if the scene is not a Scene::Conclusion.
+    #
+    # @param new_scene [Class<Scene::Base>]
+    # @oaram data [Hash] Additional scene data
+    def conclude new_scene, **data
+      raise NotConclusionError unless new_scene <= Scene::Conclusion
+      cue new_scene, **data
+    end
+
+    # True if the character is in a conclusion.
+    #
+    # @return [Boolean]
+    def concluded?
+      !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
+
+    def inspect
+      to_s
+    end
+
+    # Track the entity's performance of a scene.
+    #
+    def entered scene
+      klass = (scene.kind_of?(Gamefic::Scene::Base) ? scene.class : scene)
+      entered_scenes.push klass unless entered_scenes.include?(klass)
+    end
+
+    # Determine whether the entity has performed the specified scene.
+    #
+    # @return [Boolean]
+    def entered? scene
+      klass = (scene.kind_of?(Gamefic::Scene::Base) ? scene.class : scene)
+      entered_scenes.include?(klass)
+    end
+
+    private
+
+    # @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
+    end
+
+    def buffer_stack
+      @buffer_stack ||= 0
+    end
+
+    def set_buffer_stack num
+      @buffer_stack = num
+    end
+
+    # @return [String]
+    def buffer
+      @buffer ||= ''
+    end
+
+    def append_buffer str
+      @buffer += str
+    end
+
+    def clear_buffer
+      @buffer = ''
+    end
+
+    def performance_stack
+      @performance_stack ||= []
+    end
+  end
+end