gamefic 1.6.0 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ce1dd2ec32bb2872b9c18a40cfdf92ac745506a4
-  data.tar.gz: 264aa06dc79054f22d07fe4552b6341c05a4c82e
+SHA256:
+  metadata.gz: 1ac7da649347939f4c5baadc676151b8a8c73714552c48a290de75bd072bb801
+  data.tar.gz: 6d83150ed62df24a4056e3e54ff5b499bc5f7a69ebe8d5cfaddb261f64573af4
 SHA512:
-  metadata.gz: ad1365b02676307134c0a141dbe9003989093b2e78f590affd2c5bbaa237758ae1357e3c156551e36f65b22c44bd0f81a06b940e655075bf529dcea59b75fc6a
-  data.tar.gz: fc741d054f2d4e187d6e51fc96ef4a59354dfc6bea21c39adfcf7a45a5e48195fcae2017c3543bd56d9e4dfbd89bfb584e4a3e8349145bb869878cbd178eb12b
+  metadata.gz: e068317caa9fbfb1f8a73bde4725f5df3f3bcad95ba87d44c8f973759cdc991e0fbbcea874fd451eacbd6ffd2ea2ade9144e61f2d358f31fec6a7f1e97ca3a10
+  data.tar.gz: 1ab813a5cb14307bc844c42424c9503bae6f73a48d12979a5369812619e5a2e80dfab2ac6181401045511286743fc20f35968bd46e5071cf24f296e3c1c20e36

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,6 @@
+# 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,17 +1,20 @@
-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/character'
+require 'gamefic/active'
+require 'gamefic/actor'
 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,23 +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
 
-      def executor
-        @executor
-      end
-
-      def order_key
-        @order_key ||= 0
+      # 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
 
+      # @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
@@ -112,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

@@ -0,0 +1,331 @@
+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