gamefic 3.6.0 → 4.0.0

data/lib/gamefic/entity.rb

@@ -52,7 +52,7 @@ module Gamefic
     end
 
     def inspect
-      "#<#{self.class} #{name}>"
+      "#<#{self.class} '#{name}'>"
     end
 
     # Move this entity to its parent entity.
@@ -75,10 +75,11 @@ module Gamefic
     #
     # @param message [String]
     # @return [void]
-    def broadcast message
-      Query::Scoped.new(Scope::Descendants).select(self)
-                                           .that_are(Active, proc(&:acting?))
-                                           .each { |actor| actor.tell message }
+    def broadcast(message)
+      Query::Descendants.new
+                        .select(self)
+                        .that_are(Active, proc(&:participating?))
+                        .each { |actor| actor.tell message }
     end
 
     class << self

data/lib/gamefic/expression.rb

@@ -12,7 +12,7 @@ module Gamefic
 
     # @param verb [Symbol, nil]
     # @param tokens [Array<String>]
-    def initialize verb, tokens
+    def initialize(verb, tokens)
       @verb = verb
       @tokens = tokens
     end
@@ -20,15 +20,5 @@ module Gamefic
     def inspect
       "#<#{self.class} #{([verb] + tokens).map(&:inspect).join(', ')}>"
     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/logging.rb

@@ -16,17 +16,10 @@ module Gamefic
 
   class << self
     def logger
-      @logger ||= select_logger.tap do |l|
-        l.formatter = proc { |sev, _dt, _prog, msg| "[#{sev}] #{msg}\n" }
+      @logger ||= Logger.new($stderr).tap do |lggr|
+        lggr.level = Logger::WARN
+        lggr.formatter = proc { |sev, _dt, _prog, msg| "[#{sev}] #{msg}\n" }
       end
     end
-
-    private
-
-    def select_logger
-      # We use #tap here because `Logger.new(STDERR, level: Logger::WARN)`
-      # fails in Opal
-      Logger.new($stderr).tap { |log| log.level = Logger::WARN }
-    end
   end
 end

data/lib/gamefic/match.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Gamefic
+  class Match
+    # @return [Object]
+    attr_reader :argument
+
+    # @return [Object]
+    attr_reader :token
+
+    # @return [Integer]
+    attr_reader :strictness
+
+    # @param argument [Object]
+    # @param token [Object]
+    # @param strictness [Integer]
+    def initialize(argument, token, strictness)
+      @argument = argument
+      @token = token
+      @strictness = strictness
+    end
+  end
+end

data/lib/gamefic/messenger.rb

@@ -48,7 +48,7 @@ module Gamefic
       @buffers.last
     end
 
-    # Clear the buffered messages.
+    # Clear the current buffer.
     #
     # @return [String] The flushed message
     def flush

data/lib/gamefic/narrative.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'set'
+require 'corelib/marshal' if RUBY_ENGINE == 'opal' # Required in browser
 
 module Gamefic
   # A base class for building and managing the resources that compose a story.
@@ -8,48 +8,14 @@ module Gamefic
   # functionality.
   #
   class Narrative
-    extend Scriptable
+    include Scripting
+    # @!parse extend Gamefic::Scriptable
 
-    include Logging
-    include Scriptable::Actions
-    include Scriptable::Entities
-    include Scriptable::Events
-    include Scriptable::Proxies
-    include Scriptable::Queries
-    include Scriptable::Scenes
+    select_default_scene Scene::Activity
+    select_default_conclusion Scene::Conclusion
 
-    attr_reader :rulebook
-
-    def initialize(hydrate: true)
-      return unless hydrate
-
-      seed
-      script
-      post_script
-    end
-
-    def seed
-      included_blocks.select(&:seed?).each { |blk| Stage.run self, &blk.code }
-    end
-
-    def script
-      @rulebook = Rulebook.new
-      included_blocks.select(&:script?).each { |blk| Stage.run self, &blk.code }
-    end
-
-    # @return [Array<Module>]
-    def included_blocks
-      self.class.included_blocks
-    end
-
-    def post_script
-      entity_vault.lock
-      rulebook.freeze
-    end
-
-    # @return [Array<Symbol>]
-    def scenes
-      rulebook.scenes.names
+    def initialize
+      seeds.each { |blk| instance_exec(&blk) }
     end
 
     # Introduce an actor to the story.
@@ -58,9 +24,7 @@ module Gamefic
     # @return [Gamefic::Actor]
     def introduce(player = Gamefic::Actor.new)
       cast player
-      rulebook.scenes.introductions.each do |scene|
-        scene.run_start_blocks player, nil
-      end
+      introductions.each { |blk| blk[player] }
       player
     end
 
@@ -74,53 +38,53 @@ module Gamefic
 
     # Add an active entity to the narrative.
     #
-    # @param [Gamefic::Active]
+    # @param active [Gamefic::Active]
     # @return [Gamefic::Active]
-    def cast active
-      active.epic.add self
-      player_vault.add active
-      entity_vault.add active
+    def cast(active)
+      active.narratives.add self
+      player_set.add active
+      entity_set.add active
       active
     end
 
     # Remove an active entity from the narrative.
     #
-    # @param [Gamefic::Active]
+    # @param active [Gamefic::Active]
     # @return [Gamefic::Active]
-    def uncast active
-      active.epic.delete self
-      player_vault.delete active
-      entity_vault.delete active
+    def uncast(active)
+      active.narratives.delete self
+      player_set.delete active
+      entity_set.delete active
       active
     end
 
-    def ready
-      rulebook.run_ready_blocks
-    end
-
-    def update
-      rulebook.run_update_blocks
-    end
-
-    # @return [Object]
-    def detach
-      cache = @rulebook
-      @rulebook = nil
-      cache
+    # Complete a game turn.
+    #
+    # In the base Narrative class, this method runs all applicable player
+    # conclude blocks and the narrative's own conclude blocks.
+    # 
+    # @return [void]
+    def turn
+      players.select(&:concluding?).each { |plyr| player_conclude_blocks.each { |blk| blk[plyr] } }
+      conclude_blocks.each(&:call) if concluding?
     end
 
-    def attach cache
-      @rulebook = cache
+    # @return [String]
+    def save
+      Marshal.dump(self)
     end
 
-    def hydrate
-      script
-      post_script
+    # @param snapshot [String]
+    # @return [self]
+    def self.restore(snapshot)
+      Marshal.load(snapshot)
     end
 
-    def self.inherited klass
+    def self.inherited(klass)
       super
-      klass.blocks.concat blocks
+      klass.seeds.concat seeds
+      klass.select_default_scene default_scene
+      klass.select_default_conclusion default_conclusion
     end
   end
 end

data/lib/gamefic/narrator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Gamefic
+  # A narrative controller.
+  #
+  class Narrator
+    # @return [Plot]
+    attr_reader :plot
+
+    def initialize(plot)
+      @plot = plot
+      last_cues
+    end
+
+    # Cast a player character in the plot.
+    #
+    # @param character [Actor]
+    # @return [Actor]
+    def cast(character = plot.introduce)
+      plot.cast character
+    end
+
+    # Uncast a player character from the plot.
+    #
+    # @param character [Actor]
+    # @return [Actor]
+    def uncast(character)
+      plot.uncast character
+    end
+
+    def players
+      plot.players
+    end
+
+    # Start a turn.
+    #
+    # @return [void]
+    def start
+      next_cues
+      plot.ready_blocks.each(&:call)
+      plot.turn
+      cues.each(&:prepare)
+    end
+
+    # Finish a turn.
+    #
+    # @return [void]
+    def finish
+      cues.each(&:finish)
+      cues.clear
+      plot.update_blocks.each(&:call)
+    end
+
+    def concluding?
+      plot.concluding?
+    end
+
+    private
+
+    # @return [Array<Active::Cue>]
+    def cues
+      @cues ||= []
+    end
+
+    # @return [void]
+    def last_cues
+      cues.replace(plot.players.map(&:last_cue))
+          .compact
+    end
+
+    # @return [void]
+    def next_cues
+      cues.replace(plot.players.map { |player| player.next_cue || player.cue(plot.default_scene) })
+          .each(&:start)
+    end
+  end
+end

data/lib/gamefic/node.rb

@@ -39,25 +39,54 @@ module Gamefic
 
       parent&.rem_child self
       @parent = node
+      @relation = nil
       parent&.add_child self
     end
 
+    # The node's relation to its parent.
+    #
+    # The inherently supported relations are `:in` and `:on`, but authors are
+    # free to define their own.
+    #
+    # @return [Symbol, nil]
+    def relation
+      @relation ||= (parent ? :in : nil)
+    end
+
+    # @param symbol [Symbol, nil]
+    def relation=(symbol)
+      raise NodeError, "Invalid relation #{symbol.inspect} on #{inspect} without parent" unless parent || !symbol
+
+      @relation = symbol
+    end
+
     # Add children to the node. Return all the node's children.
     #
     # @param children [Array<Node, Array<Node>>]
+    # @param relation [Symbol, nil]
     # @return [Array<Node>]
-    def take *children
-      children.flatten.each { |child| child.parent = self }
+    def take *children, relation: nil
+      children.flatten.each { |child| child.put self, relation }
       children
     end
 
-    # Determine if external objects can interact with this object's children.
-    # For example, a game can designate that the contents of a bowl are
-    # accessible, while the contents of a locked safe are not.
+    def put(parent, relation = nil)
+      self.parent = parent
+      @relation = relation
+    end
+    alias place put
+
+    # Get an array of children that are accessible to external entities.
+    #
+    # A child is considered accessible if external entities can interact with
+    # it. For Example, an author can designate that the contents of a bowl are
+    # accessible, while the contents of a locked safe are not. All of an
+    # entity's children are accessible by default. Authors should override this
+    # method if they need custom behavior.
     #
-    # @return [Boolean]
-    def accessible?
-      true
+    # @return [Array<Entity>]
+    def accessible
+      children
     end
 
     # True if this node is the other's parent.
@@ -67,6 +96,9 @@ module Gamefic
       other.parent == self
     end
 
+    # True if this node and the other node have the same parent.
+    #
+    # @param other [Node]
     def adjacent?(other)
       other.parent == parent
     end

data/lib/gamefic/order.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Gamefic
+  # Build actions from explicit verbs and arguments.
+  #
+  # The Active#execute method uses Order to bypass the parser while
+  # generating actions to be executed in the Dispatcher.
+  #
+  class Order
+    # @param actor [Actor]
+    # @param verb [Symbol]
+    # @param arguments [Array<Object>]
+    def initialize(actor, verb, arguments)
+      @actor = actor
+      @verb = verb
+      @arguments = arguments
+    end
+
+    # @return [Array<Action>]
+    def to_actions
+      Action.sort(
+        actor.narratives
+            .responses_for(verb)
+            .map { |response| match_arguments(response) }
+            .compact
+      )
+    end
+
+    private
+
+    # @return [Actor]
+    attr_reader :actor
+
+    # @return [Symbol]
+    attr_reader :verb
+
+    # @return [Array<Object>]
+    attr_reader :arguments
+
+    def match_arguments(response)
+      return nil if response.queries.length != arguments.length
+
+      matches = response.queries.zip(arguments).each_with_object([]) do |zipped, result|
+        query, param = zipped
+        return nil unless query.accept?(actor, param)
+
+        result.push Match.new(param, param, 1000)
+      end
+
+      Action.new(actor, response, matches, nil)
+    end
+  end
+end

data/lib/gamefic/plot.rb

@@ -5,49 +5,15 @@ module Gamefic
   # methods for creating entities, actions, scenes, and hooks.
   #
   class Plot < Narrative
-    def seed
-      super
-      chapters.each(&:seed)
-    end
-
-    def script
-      super
-      chapters.each(&:script)
-      rulebook.scenes.with_defaults self
-    end
-
-    def post_script
-      super
-      chapters.freeze
-    end
+    # @return [Array<Chapter>]
+    attr_reader :chapters
 
-    def chapters
-      @chapters ||= self.class.appended_chapters.map { |klass| klass.new(self) }
-    end
-
-    def ready
-      super
-      subplots.each(&:ready)
-      players.each(&:start_take)
-      subplots.each(&:conclude) if concluding?
-      players.select(&:concluding?).each { |plyr| rulebook.run_player_conclude_blocks plyr }
-      subplots.delete_if(&:concluding?)
-    end
-
-    def update
-      players.each(&:finish_take)
+    def initialize
       super
-      subplots.each(&:update)
+      @chapters = self.class.appended_chapter_map.map { |chap, config| chap.new(self, **unproxy(config)) }
     end
 
-    # Remove an actor from the game.
-    #
-    # Calling `uncast` on the plot will also remove the actor from its
-    # subplots.
-    #
-    # @param actor [Actor]
-    # @return [Actor]
-    def uncast actor
+    def uncast(actor)
       subplots.each { |sp| sp.uncast actor }
       super
     end
@@ -70,41 +36,57 @@ module Gamefic
                    .tap { |sub| subplots.push sub }
     end
 
-    def save
-      Snapshot.save self
-    end
-
     def inspect
       "#<#{self.class}>"
     end
 
-    def detach
-      cache = [@rulebook]
-      @rulebook = nil
-      cache.concat subplots.map(&:detach)
-      cache
+    def self.append(chapter, **config)
+      appended_chapter_map[chapter] = config
     end
 
-    def attach(cache)
-      super(cache.shift)
-      subplots.each { |subplot| subplot.attach cache.shift }
+    def self.appended_chapter_map
+      @appended_chapter_map ||= {}
     end
 
-    def hydrate
+    # Complete a game turn.
+    #
+    # In addition to running its own applicable conclude blocks, the Plot class
+    # will also handle conclude blocks for its chapters and subplots.
+    #
+    # @return [void]
+    def turn
       super
-      subplots.each(&:hydrate)
+      subplots.each(&:conclude) if concluding?
+      chapters.delete_if(&:concluding?)
+      subplots.delete_if(&:concluding?)
+    end
+
+    def ready_blocks
+      super + subplots.flat_map(&:ready_blocks)
+    end
+
+    def update_blocks
+      super + subplots.flat_map(&:update_blocks)
+    end
+
+    def player_output_blocks
+      super + subplots.flat_map(&:player_output_blocks)
+    end
+
+    def responses
+      super + chapters.flat_map(&:responses)
     end
 
-    def self.append chapter
-      appended_chapters.add chapter
+    def responses_for(*verbs)
+      super + chapters.flat_map { |chap| chap.responses_for(*verbs) }
     end
 
-    def self.appended_chapters
-      @appended_chapters ||= Set.new
+    def syntaxes
+      super + chapters.flat_map(&:syntaxes)
     end
 
-    def self.restore data
-      Snapshot.restore data
+    def find_and_bind(symbol)
+      super + chapters.flat_map { |chap| chap.find_and_bind(symbol) }
     end
   end
 end

data/lib/gamefic/props/default.rb

@@ -18,23 +18,6 @@ module Gamefic
       # @return [String]
       attr_accessor :input
 
-      # A freeform dictionary of objects related to the scene. Plots can pass
-      # opts to be included in the context when they cue scenes.
-      #
-      # @return [Hash]
-      attr_reader :context
-      alias data context
-
-      # @return [Hash]
-      attr_reader :scene
-
-      # @param scene [Scene]
-      # @param context [Hash]
-      def initialize scene, **context
-        @scene = { name: scene.name, type: scene.type }
-        @context = context
-      end
-
       def prompt
         @prompt ||= '>'
       end
@@ -42,6 +25,11 @@ module Gamefic
       def output
         @output ||= Props::Output.new
       end
+
+      # @param text [String]
+      def enter(text)
+        @input = text
+      end
     end
   end
 end

data/lib/gamefic/props/multiple_choice.rb

@@ -49,6 +49,10 @@ module Gamefic
         options[index]
       end
 
+      def selected?
+        !!index
+      end
+
       private
 
       def index_by_number
@@ -58,8 +62,7 @@ module Gamefic
       end
 
       def index_by_text
-        matches = options.map.with_index { |text, idx| next idx if text.downcase.start_with?(input.downcase) }.compact
-        matches.first if matches.one?
+        options.find_index { |opt| opt.casecmp?(input) }
       end
     end
   end

data/lib/gamefic/props/multiple_partial.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Props
+    # A subclass of MultipleChoice props that matches partial input.
+    #
+    class MultiplePartial < MultipleChoice
+      private
+
+      def index_by_text
+        matches = options.map.with_index { |text, idx| next idx if text.downcase.start_with?(input.downcase) }.compact
+        matches.first if matches.one?
+      end
+    end
+  end
+end