gamefic 2.4.0 → 3.0.0

data/lib/gamefic/query/general.rb

@@ -0,0 +1,46 @@
+# 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
+        super(*arguments, ambiguous: ambiguous)
+        @entities = entities
+      end
+
+      def query subject, token
+        filtered = available_entities(subject).that_are(*@arguments)
+        return Result.new(token, nil) if filtered.include?(token)
+
+        scan = Scanner.scan(filtered, token)
+
+        ambiguous? ? ambiguous_result(scan) : unambiguous_result(scan)
+      end
+
+      private
+
+      def available_entities(subject)
+        if @entities.is_a?(Proc)
+          if @entities.arity.zero?
+            @entities.call
+          else
+            @entities.call(subject)
+          end
+        else
+          @entities
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/query/result.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Query
+    # The result of a query.
+    #
+    class Result
+      # @return [Entity, Array<Entity>, String, nil]
+      attr_reader :match
+
+      # @return [String]
+      attr_reader :remainder
+
+      def initialize match, remainder
+        @match = match
+        @remainder = remainder
+      end
+    end
+  end
+end

data/lib/gamefic/query/scoped.rb

@@ -0,0 +1,41 @@
+# 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.
+    #
+    # @return [Class<Gamefic::Scope::Base>]
+    class Scoped < Base
+      attr_reader :scope
+
+      # @param scope [Class<Gamefic::Scope::Base>]
+      def initialize scope, *arguments, ambiguous: false
+        super(*arguments, ambiguous: ambiguous)
+        @scope = scope
+      end
+
+      # @return [Result]
+      def query(subject, token)
+        available = @scope.matches(subject)
+                          .that_are(*@arguments)
+        return Result.new(token, nil) if available.include?(token)
+
+        scan = Scanner.scan(available, token)
+
+        return ambiguous_result(scan) if ambiguous?
+
+        unambiguous_result(scan)
+      end
+
+      def precision
+        @precision ||= @scope.precision + calculate_precision
+      end
+
+      def ambiguous?
+        @ambiguous
+      end
+    end
+  end
+end

data/lib/gamefic/query/text.rb

@@ -1,46 +1,45 @@
+# frozen_string_literal: true
+
 module Gamefic
   module Query
-    class Text < Base
-      def initialize *arguments
-        arguments.each do |a|
-          if (a.kind_of?(Symbol) || a.kind_of?(String)) && !a.to_s.end_with?('?')
-            raise ArgumentError.new("Text query arguments can only be boolean method names (:method?) or regular expressions")
-          end
-        end
-        super
+    # A special query that handles text instead of entities.
+    #
+    class Text
+      # @param argument [String, Regexp, nil]
+      def initialize argument = nil
+        @argument = argument
+        validate
       end
 
-      def resolve _subject, token, continued: false
-        return Matches.new([], '', token) unless accept?(token)
-        parts = token.split(Keywords::SPLIT_REGEXP)
-        cursor = []
-        matches = []
-        i = 0
-        parts.each { |w|
-          cursor.push w
-          matches = cursor if accept?(cursor.join(' '))
-          i += 1
-        }
-        if continued
-          Matches.new([matches.join(' ')], matches.join(' '), parts[i..-1].join(' '))
-        elsif matches.length == parts.length
-          Matches.new([matches.join(' ')], matches.join(' '), '')
+      def query _subject, token
+        if match? token
+          Result.new(token, '')
         else
-          Matches.new([], '', parts.join(' '))
+          Result.new(nil, token)
         end
       end
 
-      def include? _subject, token
-        accept?(token)
+      def precision
+        0
       end
 
-      def accept? entity
-        return false unless entity.kind_of?(String) and !entity.empty?
-        super
+      private
+
+      def match? token
+        return true if @argument.nil?
+
+        case @argument
+        when Regexp
+          token =~ @argument
+        else
+          token == @argument
+        end
       end
 
-      def precision
-        0
+      def validate
+        return if @argument.nil? || @argument.is_a?(String) || @argument.is_a?(Regexp)
+
+        raise ArgumentError, 'Invalid text query argument'
       end
     end
   end

data/lib/gamefic/query.rb

@@ -1,15 +1,7 @@
-module Gamefic
-  module Query
-    autoload :Base, 'gamefic/query/base'
-    autoload :Children, 'gamefic/query/children'
-    autoload :Descendants, 'gamefic/query/descendants'
-    autoload :External, 'gamefic/query/external'
-    autoload :Family, 'gamefic/query/family'
-    autoload :Tree, 'gamefic/query/tree'
-    autoload :Itself, 'gamefic/query/itself'
-    autoload :Matches, 'gamefic/query/matches'
-    autoload :Parent, 'gamefic/query/parent'
-    autoload :Siblings, 'gamefic/query/siblings'
-    autoload :Text, 'gamefic/query/text'
-  end
-end
+# frozen_string_literal: true
+
+require 'gamefic/query/base'
+require 'gamefic/query/general'
+require 'gamefic/query/scoped'
+require 'gamefic/query/text'
+require 'gamefic/query/result'

data/lib/gamefic/response.rb

@@ -0,0 +1,118 @@
+# frozen_literal_string: true
+
+module Gamefic
+  # A proc to be executed in response to a command that matches its verb and
+  # queries.
+  #
+  class Response
+    # @return [Symbol]
+    attr_reader :verb
+
+    # @return [Array<Query::Base>]
+    attr_reader :queries
+
+    # @return [Proc]
+    # attr_reader :block
+
+    # @param verb [Symbol]
+    # @param stage [Object]
+    # @param queries [Array<Query::Base>]
+    # @param meta [Boolean]
+    # @param block [Proc]
+    def initialize verb, stage, *queries, meta: false, &block
+      @verb = verb
+      @stage = stage
+      @queries = map_queryable_objects(queries)
+      @meta = meta
+      @block = block
+    end
+
+    # The `meta?` flag is just a way for authors to identify responses that
+    # serve a purpose other than performing in-game actions. Out-of-game
+    # responses can include features like displaying help documentation or
+    # listing credits.
+    #
+    def meta?
+      @meta
+    end
+
+    def hidden?
+      @hidden ||= verb.to_s.start_with?('_')
+    end
+
+    def syntax
+      @syntax ||= generate_default_syntax
+    end
+
+    # Return an Action if the Response can accept the actor's command.
+    #
+    # @param actor [Entity]
+    # @param command [Command]
+    # @param with_hooks [Boolean]
+    # @return [Action, nil]
+    def attempt actor, command
+      return nil if command.verb != verb
+
+      tokens = command.arguments.clone
+      result = []
+      remainder = ''
+
+      queries.each do |qd|
+        token = tokens.shift
+        txt = "#{remainder} #{token}".strip
+        return nil if txt.empty?
+
+        response = qd.query(actor, txt)
+        return nil if response.match.nil?
+
+        result.push response.match
+
+        remainder = response.remainder
+      end
+
+      return nil unless tokens.empty? && remainder.empty?
+
+      Action.new(actor, result, self)
+    end
+
+    def execute *args
+      Stage.run(@stage, *args, &@block)
+    end
+
+    def precision
+      @precision ||= calculate_precision
+    end
+
+    private
+
+    def generate_default_syntax
+      user_friendly = verb.to_s.gsub(/_/, ' ')
+      args = []
+      used_names = []
+      queries.each do |_c|
+        num = 1
+        new_name = ":var"
+        while used_names.include? new_name
+          num += 1
+          new_name = ":var#{num}"
+        end
+        used_names.push new_name
+        user_friendly += " #{new_name}"
+        args.push new_name
+      end
+      Syntax.new(user_friendly.strip, "#{verb} #{args.join(' ')}".strip)
+    end
+
+    def calculate_precision
+      total = 0
+      queries.each { |q| total += q.precision }
+      total -= 1000 if verb.nil?
+      total
+    end
+
+    def map_queryable_objects queries
+      # @todo Considering moving mapping from Actions to here
+      queries
+    end
+  end
+end

data/lib/gamefic/rulebook/calls.rb

@@ -0,0 +1,90 @@
+# 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
+
+      def self.new_array_map
+        Hash.new { |hash, key| hash[key] = [] }
+      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

@@ -0,0 +1,79 @@
+# 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 [Proc]
+      def on_ready &block
+        @ready_blocks.push block
+      end
+
+      # @yieldparam [Actor]
+      # @return [Proc]
+      def on_player_ready &block
+        @ready_blocks.push(proc do
+          players.each { |plyr| block.call plyr }
+        end)
+      end
+
+      def on_update &block
+        @update_blocks.push block
+      end
+
+      def on_player_update &block
+        @update_blocks.push(proc do
+          players.each { |plyr| block.call plyr }
+        end)
+      end
+
+      # @return [Proc]
+      def on_conclude &block
+        @conclude_blocks.push block
+      end
+
+      # @yieldparam [Actor]
+      # @return [Proc]
+      def on_player_conclude &block
+        @player_conclude_blocks.push block
+      end
+
+      # @yieldparam [Actor]
+      # @yieldparam [Hash]
+      # @return [Proc]
+      def on_player_output &block
+        @player_output_blocks.push block
+      end
+    end
+  end
+end

data/lib/gamefic/rulebook/hooks.rb

@@ -0,0 +1,57 @@
+# 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 *verbs, &block
+        before_actions.push Action::Hook.new(*verbs, &block)
+      end
+
+      def after_action *verbs, &block
+        after_actions.push Action::Hook.new(*verbs, &block)
+      end
+
+      def empty?
+        before_actions.empty? && after_actions.empty?
+      end
+
+      def run_before action, narrative
+        run_action_hooks action, narrative, before_actions
+      end
+
+      def run_after action, narrative
+        run_action_hooks action, narrative, after_actions
+      end
+
+      private
+
+      def run_action_hooks action, narrative, hooks
+        hooks.each do |hook|
+          break if action.cancelled?
+
+          next unless hook.match?(action.verb)
+
+          Stage.run(narrative) { instance_exec(action, &hook.block) }
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/rulebook/scenes.rb

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