gamefic 3.6.0 → 4.0.0

data/lib/gamefic/active/epic.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  module Active
-    # A collection of narratives.
-    #
-    class Epic
-      include Logging
-
-      # @return [Set<Narrative>]
-      attr_reader :narratives
-
-      def initialize
-        @narratives = Set.new
-      end
-
-      # @param narrative [Narrative]
-      def add narrative
-        narratives.add narrative
-      end
-
-      # @param narrative [Narrative]
-      def delete narrative
-        narratives.delete narrative
-      end
-
-      # @return [Array<Rulebook>]
-      def rulebooks
-        narratives.map(&:rulebook)
-      end
-
-      # @return [Array<Symbol>]
-      def verbs
-        rulebooks.flat_map(&:verbs).uniq
-      end
-
-      # @return [Array<Symbol>]
-      def synonyms
-        rulebooks.flat_map(&:synonyms).uniq
-      end
-
-      def empty?
-        narratives.empty?
-      end
-
-      def one?
-        narratives.one?
-      end
-
-      def syntaxes
-        rulebooks.flat_map(&:syntaxes)
-      end
-
-      # @return [Array<Response>]
-      def responses_for(*verbs)
-        rulebooks.to_a
-                 .reverse
-                 .flat_map { |rb| rb.responses_for(*verbs) }
-      end
-
-      # @param name [Symbol]
-      # @return [Scene]
-      def select_scene name
-        scenes = rulebooks.map { |rlbk| rlbk.scenes[name] }
-                          .compact
-        raise ArgumentError, "Scene named `#{name}` does not exist" if scenes.empty?
-
-        logger.warn "Found #{scenes.length} scenes named `#{name}`" unless scenes.one?
-
-        scenes.last
-      end
-    end
-  end
-end

data/lib/gamefic/active/take.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  module Active
-    # The combination of an actor and a scene to be performed in a plot turn.
-    #
-    class Take
-      # @return [Active]
-      attr_reader :actor
-
-      # @return [Active::Cue]
-      attr_reader :cue
-
-      # @return [Scene::Default]
-      attr_reader :scene
-
-      # @param actor [Active]
-      # @param cue [Active::Cue]
-      # @param props [Props::Default, nil]
-      def initialize actor, cue, props = nil
-        @actor = actor
-        @cue = cue
-        @scene = actor.epic.select_scene(cue.scene)
-        @props = props
-      end
-
-      # @return [Props::Default]
-      def props
-        @props ||= @scene.new_props(**cue.context)
-      end
-
-      # @return [Props::Default]
-      def start
-        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, props.output }
-        props.output.merge!({
-                              messages: actor.messages,
-                              queue: actor.queue
-                            })
-        props
-      end
-
-      # @return [void]
-      def finish
-        actor.flush
-        scene.finish(actor, props)
-        scene.run_finish_blocks actor, props
-      end
-
-      # @param actor [Active]
-      # @param cue [Active::Cue]
-      # @return [Props::Default]
-      def self.start actor, cue
-        Take.new(actor, cue).start
-      end
-
-      # @param actor [Active]
-      # @param cue [Active::Cue]
-      # @return [void]
-      def self.finish actor, cue, props
-        Take.new(actor, cue, props).finish
-      end
-    end
-  end
-end

data/lib/gamefic/block.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  # A code container for seeds and scripts.
-  #
-  class Block
-    # @return [Symbol]
-    attr_reader :type
-
-    # @return [Proc]
-    attr_reader :code
-
-    # @param type [Symbol]
-    # @param code [Proc]
-    def initialize type, code
-      @type = type
-      @code = code
-    end
-
-    def script?
-      type == :script
-    end
-
-    def seed?
-      type == :seed
-    end
-  end
-end

data/lib/gamefic/callback.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  class Callback
-    # @param narrative [Narrative]
-    # @param code [Proc]
-    def initialize narrative, code
-      @narrative = narrative
-      @code = code
-    end
-
-    def run *args
-      Stage.run @narrative, *args, &@code
-    end
-  end
-end

data/lib/gamefic/proxy/plot_pick.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  class Proxy
-    class PlotPick < Base
-      def select narrative
-        raise? ? narrative.plot.pick!(*args) : narrative.plot.pick(*args)
-      end
-    end
-  end
-end

data/lib/gamefic/query/abstract.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  module Query
-    class Abstract < General
-      def span subject
-        available_entities(subject).that_are(Describable)
-                                   .that_are_not(Entity)
-      end
-    end
-  end
-end

data/lib/gamefic/query/general.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  module Query
-    # A General query accepts an array of entities to filter. Unlike Scoped
-    # queries, the resulting entities will not necessarily be in the actor's
-    # immediate vicinity.
-    #
-    # General queries can also be passed a Proc that returns an array of
-    # entities. If the Proc accepts an argument, it will be given the subject
-    # of the query.
-    #
-    class General < Base
-      # @param entities [Array, Proc]
-      # @param arguments [Array<Object>]
-      # @param ambiguous [Boolean]
-      def initialize entities, *arguments, ambiguous: false, name: nil
-        super(*arguments, ambiguous: ambiguous, name: name)
-        @entities = entities
-      end
-
-      def span subject
-        available_entities(subject)
-      end
-
-      private
-
-      def available_entities(subject)
-        if @entities.is_a?(Proc)
-          if @entities.arity.zero?
-            Stage.run narrative, &@entities
-          else
-            Stage.run narrative, subject, &@entities
-          end
-        else
-          @entities
-        end
-      end
-    end
-  end
-end

data/lib/gamefic/query/scoped.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  module Query
-    # A Scoped query uses a Scope to select entities to filter based on their
-    # relationship to the entity performing the query. For example,
-    # Scope::Children would filter from an array of the entity's descendants.
-    #
-    class Scoped < Base
-      attr_reader :scope
-
-      # @param scope [Class<Gamefic::Scope::Base>]
-      def initialize scope, *arguments, ambiguous: false, name: nil
-        super(*arguments, ambiguous: ambiguous, name: name)
-        @scope = scope
-      end
-
-      def span(subject)
-        @scope.matches(subject)
-      end
-
-      def precision
-        @precision ||= @scope.precision + calculate_precision
-      end
-    end
-  end
-end

data/lib/gamefic/rulebook/calls.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  class Rulebook
-    # A collection of responses and syntaxes that constitute the actions
-    # available to actors.
-    #
-    class Calls
-      def initialize
-        @verb_response_map = Hash.new { |hash, key| hash[key] = [] }
-        @synonym_syntax_map = Hash.new { |hash, key| hash[key] = [] }
-      end
-
-      def freeze
-        super
-        @verb_response_map.freeze
-        @verb_response_map.values.map(&:freeze)
-        @synonym_syntax_map.freeze
-        @synonym_syntax_map.values.map(&:freeze)
-        self
-      end
-
-      def syntaxes
-        synonym_syntax_map.values.flatten
-      end
-
-      def synonyms
-        synonym_syntax_map.keys.compact.sort
-      end
-
-      def responses
-        verb_response_map.values.flatten
-      end
-
-      def verbs
-        verb_response_map.keys.compact.sort
-      end
-
-      def responses_for *verbs
-        verbs.flat_map { |verb| verb_response_map.fetch(verb, []) }
-      end
-
-      def syntaxes_for *synonyms
-        synonyms.flat_map { |syn| synonym_syntax_map.fetch(syn, []) }
-      end
-
-      def add_response response
-        verb_response_map[response.verb].unshift response
-        sort_responses_for response.verb
-        add_syntax response.syntax unless response.verb.to_s.start_with?('_')
-        response
-      end
-
-      # @param syntax [Syntax]
-      # @return [Syntax]
-      def add_syntax syntax
-        raise "No responses exist for \"#{syntax.verb}\"" unless verb_response_map.key?(syntax.verb)
-
-        return if synonym_syntax_map[syntax.synonym].include?(syntax)
-
-        synonym_syntax_map[syntax.synonym].unshift syntax
-        sort_syntaxes_for syntax.synonym
-        syntax
-      end
-
-      def empty?
-        verb_response_map.empty? && synonym_syntax_map.empty?
-      end
-
-      private
-
-      attr_reader :verb_response_map
-
-      attr_reader :synonym_syntax_map
-
-      # @param responses [Array<Response>]
-      def sort_responses_for verb
-        verb_response_map[verb].sort_by!.with_index { |a, i| [a.precision, -i] }.reverse!
-      end
-
-      def sort_syntaxes_for synonym
-        synonym_syntax_map[synonym].sort! { |a, b| a.compare b }
-      end
-    end
-  end
-end

data/lib/gamefic/rulebook/events.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  class Rulebook
-    # Blocks of code to be executed for various narrative events, such as
-    # on_ready and on_update.
-    #
-    class Events
-      attr_reader :player_output_blocks
-
-      attr_reader :player_conclude_blocks
-
-      attr_reader :ready_blocks
-
-      attr_reader :update_blocks
-
-      attr_reader :conclude_blocks
-
-      def initialize
-        @ready_blocks = []
-        @update_blocks = []
-        @conclude_blocks = []
-        @player_conclude_blocks = []
-        @player_output_blocks = []
-      end
-
-      def empty?
-        [player_output_blocks, player_conclude_blocks, ready_blocks, update_blocks, conclude_blocks].all?(&:empty?)
-      end
-
-      def freeze
-        super
-        instance_variables.each { |k| instance_variable_get(k).freeze }
-        self
-      end
-
-      # @return [void]
-      def on_ready callback
-        @ready_blocks.push callback
-      end
-
-      def on_update callback
-        @update_blocks.push callback
-      end
-
-      # @return [void]
-      def on_conclude callback
-        @conclude_blocks.push callback
-      end
-
-      # @yieldparam [Actor]
-      # @return [void]
-      def on_player_conclude callback
-        @player_conclude_blocks.push callback
-      end
-
-      # @yieldparam [Actor]
-      # @yieldparam [Hash]
-      # @return [void]
-      def on_player_output callback
-        @player_output_blocks.push callback
-      end
-    end
-  end
-end

data/lib/gamefic/rulebook/hooks.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  class Rulebook
-    # A collection of hooks that can be executed before and after an action.
-    #
-    class Hooks
-      attr_reader :before_actions
-
-      attr_reader :after_actions
-
-      def initialize
-        @before_actions = []
-        @after_actions = []
-      end
-
-      def freeze
-        super
-        @before_actions.freeze
-        @after_actions.freeze
-        self
-      end
-
-      def before_action narrative, *verbs, &block
-        before_actions.push Action::Hook.new(verbs, Callback.new(narrative, block))
-      end
-
-      def after_action narrative, *verbs, &block
-        after_actions.push Action::Hook.new(verbs, Callback.new(narrative, block))
-      end
-
-      def empty?
-        before_actions.empty? && after_actions.empty?
-      end
-
-      def run_before action
-        run_action_hooks action, before_actions
-      end
-
-      def run_after action
-        run_action_hooks action, after_actions
-      end
-
-      private
-
-      def run_action_hooks action, hooks
-        hooks.each do |hook|
-          break if action.cancelled?
-
-          next unless hook.match?(action.verb)
-
-          hook.callback.run action
-        end
-      end
-    end
-  end
-end

data/lib/gamefic/rulebook/scenes.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Gamefic
-  class Rulebook
-    # The scene manager for rulebooks.
-    #
-    class Scenes
-      attr_reader :introductions
-
-      def initialize
-        @scene_map = {}
-        @introductions = []
-      end
-
-      def freeze
-        super
-        @scene_map.freeze
-        @introductions.freeze
-        self
-      end
-
-      # Add a scene to the scenebook.
-      #
-      # @param [Scene]
-      def add scene
-        raise ArgumentError, "A scene named `#{scene.name} already exists" if @scene_map.key?(scene.name)
-
-        @scene_map[scene.name] = scene
-      end
-
-      def scene? name
-        @scene_map.key? name
-      end
-
-      # @return [Scene, nil]
-      def [](name)
-        @scene_map[name]
-      end
-
-      # @return [Array<Symbol>]
-      def names
-        @scene_map.keys
-      end
-
-      # @return [Array<Scene>]
-      def all
-        @scene_map.values
-      end
-
-      def introduction scene
-        introductions.push scene
-      end
-
-      def with_defaults narrative
-        maybe_add :default_scene, Scene::Activity, narrative
-        maybe_add :default_conclusion, Scene::Conclusion, narrative
-      end
-
-      def maybe_add name, klass, narrative
-        add klass.new(name, narrative) unless names.include?(name)
-      end
-
-      def empty?
-        @scene_map.empty? && introductions.empty?
-      end
-    end
-  end
-end

data/lib/gamefic/rulebook.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require 'gamefic/rulebook/calls'
-require 'gamefic/rulebook/events'
-require 'gamefic/rulebook/hooks'
-require 'gamefic/rulebook/scenes'
-
-module Gamefic
-  # A collection of rules that define the behavior of a narrative.
-  #
-  # Rulebooks provide a way to separate narrative data from code. This
-  # separation is necessary to ensure that the game state can be serialized in
-  # snapshots.
-  #
-  class Rulebook
-    # @return [Calls]
-    attr_reader :calls
-
-    # @return [Events]
-    attr_reader :events
-
-    # @return [Hooks]
-    attr_reader :hooks
-
-    # @return [Scenes]
-    attr_reader :scenes
-
-    def initialize
-      @calls = Calls.new
-      @events = Events.new
-      @hooks = Hooks.new
-      @scenes = Scenes.new
-    end
-
-    def freeze
-      super
-      [@calls, @events, @hooks, @scenes].each(&:freeze)
-      self
-    end
-
-    # @return [Array<Response>]
-    def responses
-      @calls.responses
-    end
-
-    # @return [Array<Syntax>]
-    def syntaxes
-      @calls.syntaxes
-    end
-
-    # An array of all the verbs available in the rulebook. This list only
-    # includes verbs that are explicitly defined in reponses. It excludes
-    # synonyms that might be defined in syntaxes (see #synonyms).
-    #
-    # @example
-    #   rulebook.respond :verb { |_| nil }
-    #   rulebook.interpret 'synonym', 'verb'
-    #   rulebook.verbs #=> [:verb]
-    #
-    # @return [Array<Symbol>]
-    def verbs
-      @calls.verbs
-    end
-
-    # An array of all the verbs defined in responses and any synonyms defined
-    # in syntaxes.
-    #
-    # @example
-    #   rulebook.respond :verb { |_| nil }
-    #   rulebook.interpret 'synonym', 'verb'
-    #   rulebook.synonyms #=> [:synonym, :verb]
-    #
-    def synonyms
-      @calls.synonyms
-    end
-
-    # Get an array of all the responses that match a list of verbs.
-    #
-    # @param verbs [Array<Symbol>]
-    # @return [Array<Response>]
-    def responses_for *verbs
-      @calls.responses_for *verbs
-    end
-
-    # Get an array of all the syntaxes that match a lit of verbs.
-    #
-    # @param words [Array<Symbol>]
-    # @return [Array<Syntax>]
-    def syntaxes_for *synonyms
-      @calls.syntaxes_for *synonyms
-    end
-
-    def run_ready_blocks
-      events.ready_blocks.each(&:run)
-    end
-
-    def run_update_blocks
-      events.update_blocks.each(&:run)
-    end
-
-    def run_before_actions action
-      hooks.run_before action
-    end
-
-    def run_after_actions action
-      hooks.run_after action
-    end
-
-    def run_conclude_blocks
-      events.conclude_blocks.each(&:run)
-    end
-
-    def run_player_conclude_blocks player
-      events.player_conclude_blocks.each { |blk| blk.run(player) }
-    end
-
-    def run_player_output_blocks player, output
-      events.player_output_blocks.each { |blk| blk.run(player, output) }
-    end
-
-    def empty?
-      calls.empty? && hooks.empty? && scenes.empty? && events.empty?
-    end
-  end
-end