gamefic-standard 3.2.3 → 3.3.0

data/lib/gamefic-standard/actions/place.rb

@@ -1,24 +1,39 @@
-Gamefic::Standard.script do
-  respond :place, children, available do |actor, thing, supporter|
-    actor.tell "You can't put #{the thing} on #{the supporter}."
-  end
+# frozen_string_literal: true
 
-  respond :place, available, available(Supporter) do |actor, thing, supporter|
-    actor.execute :take, thing unless thing.parent == actor
-    next unless thing.parent == actor
-    thing.parent = supporter
-    actor.tell "You put #{the thing} on #{the supporter}."
-  end
+module Gamefic
+  module Standard
+    module Actions
+      module Place
+        extend Gamefic::Scriptable
 
-  respond :place, children, available(Supporter) do |actor, thing, supporter|
-    thing.parent = supporter
-    actor.tell "You put #{the thing} on #{the supporter}."
-  end
+        respond :place, children, available do |actor, thing, supporter|
+          actor.tell "You can't put #{the thing} on #{the supporter}."
+        end
+
+        respond :place, available, available(Supporter) do |actor, thing, supporter|
+          actor.execute :take, thing unless thing.parent == actor
+          next unless thing.parent == actor
 
-  interpret 'put :thing on :supporter', 'place :thing :supporter'
-  interpret 'put :thing down on :supporter', 'place :thing :supporter'
-  interpret 'set :thing on :supporter', 'place :thing :supporter'
-  interpret 'set :thing down on :supporter', 'place :thing :supporter'
-  interpret 'drop :thing on :supporter', 'place :thing :supporter'
-  interpret 'place :thing on :supporter', 'place :thing :supporter'
+          thing.parent = supporter
+          actor.tell "You put #{the thing} on #{the supporter}."
+        end
+
+        respond :place, children, available(Supporter) do |actor, thing, supporter|
+          thing.parent = supporter
+          actor.tell "You put #{the thing} on #{the supporter}."
+        end
+
+        respond :place, children, room do |actor, thing|
+          actor.execute :drop, thing
+        end
+
+        interpret 'put :thing on :supporter', 'place :thing :supporter'
+        interpret 'put :thing down on :supporter', 'place :thing :supporter'
+        interpret 'set :thing on :supporter', 'place :thing :supporter'
+        interpret 'set :thing down on :supporter', 'place :thing :supporter'
+        interpret 'drop :thing on :supporter', 'place :thing :supporter'
+        interpret 'place :thing on :supporter', 'place :thing :supporter'
+      end
+    end
+  end
 end

data/lib/gamefic-standard/actions/pronouns.rb

@@ -1,28 +1,36 @@
 # frozen_string_literal: true
 
-Gamefic::Standard.script do
-  introduction do |actor|
-    actor[:standard_pronoun_targets] = []
-  end
+module Gamefic
+  module Standard
+    module Actions
+      module Pronouns
+        extend Gamefic::Scriptable
 
-  after_action do |action|
-    next unless action.verb
+        introduction do |actor|
+          actor[:standard_pronoun_targets] = []
+        end
 
-    action.actor[:standard_pronoun_targets].replace action.arguments.that_are(Thing)
-  end
+        after_action do |action|
+          next unless action.verb
 
-  meta nil, plaintext do |actor, string|
-    keywords = string.keywords
-    list = actor.epic.synonyms
-    next actor.proceed unless list.include?(keywords.first&.to_sym)
+          action.actor[:standard_pronoun_targets].replace action.arguments.that_are(Thing)
+        end
 
-    xlation = keywords[1..].map do |word|
-      next word unless %w[him her it them].include?(word)
+        meta nil, plaintext do |actor, string|
+          keywords = string.keywords
+          list = actor.epic.synonyms
+          next actor.proceed unless list.include?(keywords.first&.to_sym)
 
-      actor[:standard_pronoun_targets].find { |obj| Grammar::Pronoun.objective(obj) == word }
-    end
-    next actor.proceed if xlation.any?(&:nil?) || xlation.that_are(Thing).empty?
+          xlation = keywords[1..].map do |word|
+            next word unless %w[him her it them].include?(word)
 
-    actor.perform "#{keywords[0].to_sym} #{xlation.join(' ')}"
+            actor[:standard_pronoun_targets].find { |obj| obj.objective == word }
+          end
+          next actor.proceed if xlation.any?(&:nil?) || xlation.that_are(Thing).empty?
+
+          actor.perform "#{keywords[0].to_sym} #{xlation.join(' ')}"
+        end
+      end
+    end
   end
 end

data/lib/gamefic-standard/actions/quit.rb

@@ -1,10 +1,20 @@
-Gamefic::Standard.script do
-  yes_or_no :standard_confirm_quit do |actor, props|
-    actor.cue :default_conclusion if props.yes?
-  end
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Quit
+        extend Gamefic::Scriptable
+
+        yes_or_no :standard_confirm_quit do |actor, props|
+          actor.cue :default_conclusion if props.yes?
+        end
 
-  meta :quit do |actor|
-    actor.tell "Are you sure you want to quit?"
-    actor.cue :standard_confirm_quit
+        meta :quit do |actor|
+          actor.tell 'Are you sure you want to quit?'
+          actor.cue :standard_confirm_quit
+        end
+      end
+    end
   end
 end

data/lib/gamefic-standard/actions/repeat.rb

@@ -1,14 +1,22 @@
 # frozen_string_literal: true
 
-Gamefic::Standard.script do
-  meta :repeat do |actor|
-    if actor.last_input && !actor.last_input.empty?
-      actor.tell "Repeating <kbd>\"#{actor.last_input}\"</kbd>..."
-      actor.queue.push actor.last_input
-    else
-      actor.tell "You don't have a previous command to repeat right now."
+module Gamefic
+  module Standard
+    module Actions
+      module Repeat
+        extend Gamefic::Scriptable
+
+        meta :repeat do |actor|
+          if actor.last_input && !actor.last_input.empty?
+            actor.tell "Repeating <kbd>\"#{actor.last_input}\"</kbd>..."
+            actor.queue.push actor.last_input
+          else
+            actor.tell "You don't have a previous command to repeat right now."
+          end
+        end
+
+        interpret 'again', 'repeat'
+      end
     end
   end
-
-  interpret 'again', 'repeat'
 end

data/lib/gamefic-standard/actions/save-restore-undo.rb

@@ -1,18 +1,26 @@
 # frozen_string_literal: true
 
-Gamefic::Standard.script do
-  # Save, Restore, and Undo need to be handled by the game client. They have
-  # default implementations here to make them available in help.
+module Gamefic
+  module Standard
+    module Actions
+      module SaveRestoreUndo
+        extend Gamefic::Scriptable
 
-  meta :save do |actor|
-    actor.tell "<kbd>Save</kbd> is not available."
-  end
+        # Save, Restore, and Undo need to be handled by the game client. They have
+        # default implementations here to make them available in help.
 
-  meta :restore do |actor|
-    actor.tell "<kbd>Restore</kbd> is not available."
-  end
+        meta :save do |actor|
+          actor.tell '<kbd>Save</kbd> is not available.'
+        end
+
+        meta :restore do |actor|
+          actor.tell '<kbd>Restore</kbd> is not available.'
+        end
 
-  meta :undo do |actor|
-    actor.tell "<kbd>Undo</kbd> is not available."
+        meta :undo do |actor|
+          actor.tell '<kbd>Undo</kbd> is not available.'
+        end
+      end
+    end
   end
 end

data/lib/gamefic-standard/actions/search.rb

@@ -1,26 +1,36 @@
-Gamefic::Standard.script do
-  respond :search, available(Thing) do |actor, thing|
-    actor.execute :look, thing
-  end
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Search
+        extend Gamefic::Scriptable
+
+        respond :search, available(Thing) do |actor, thing|
+          actor.execute :look, thing
+        end
+
+        respond :search, available(Receptacle) do |actor, thing|
+          if thing.accessible?
+            itemized = thing.children.that_are_not(proc(&:attached?)).that_are(proc(&:itemized?))
+            if itemized.empty?
+              actor.tell "There's nothing inside #{the thing}."
+            else
+              actor.tell "You see #{itemized.join_and} in #{the thing}." unless itemized.empty?
+            end
+          else
+            actor.tell "You can't see inside #{the thing}."
+          end
+        end
 
-  respond :search, available(Receptacle) do |actor, thing|
-    if thing.accessible?
-      itemized = thing.children.that_are_not(proc(&:attached?)).that_are(proc(&:itemized?))
-      if itemized.empty?
-        actor.tell "There's nothing inside #{the thing}."
-      else
-        actor.tell "You see #{itemized.join_and} in #{the thing}." unless itemized.empty?
+        respond :search, available(Container, proc(&:closed?)) do |actor, container|
+          actor.execute :open, container
+          actor.proceed if container.open?
+        end
+
+        interpret 'look inside :thing', 'search :thing'
+        interpret 'look in :thing', 'search :thing'
       end
-    else
-      actor.tell "You can't see inside #{the thing}."
     end
   end
-
-  respond :search, available(Container, proc(&:closed?)) do |actor, container|
-    actor.execute :open, container
-    actor.proceed if container.open?
-  end
-
-  interpret 'look inside :thing', 'search :thing'
-  interpret 'look in :thing', 'search :thing'
 end

data/lib/gamefic-standard/actions/take.rb

@@ -1,40 +1,53 @@
-Gamefic::Standard.script do
-  respond :take, available do |actor, thing|
-    if thing.parent == actor
-      actor.tell "You're already carrying #{the thing}."
-    elsif thing.portable?
-      if actor.parent != thing.parent
-        actor.tell "You take #{the thing} from #{the thing.parent}."
-      else
-        actor.tell "You take #{the thing}."
-      end
-      thing.parent = actor
-    else
-      actor.tell "You can't take #{the thing}."
-    end
-  end
+# frozen_string_literal: true
 
-  respond :take, available(proc(&:attached?)) do |actor, thing|
-    actor.tell "#{The thing} is attached to #{the thing.parent}."
-  end
+module Gamefic
+  module Standard
+    module Actions
+      module Take
+        extend Gamefic::Scriptable
 
-  respond :take, available(Rubble) do |actor, rubble|
-    actor.tell "You don't have any use for #{the rubble}."
-  end
+        respond :take, available do |actor, thing|
+          if thing.parent == actor
+            actor.tell "You're already carrying #{the thing}."
+          elsif thing.portable?
+            if actor.parent != thing.parent
+              actor.tell "You take #{the thing} from #{the thing.parent}."
+            else
+              actor.tell "You take #{the thing}."
+            end
+            thing.parent = actor
+          else
+            actor.tell "You can't take #{the thing}."
+          end
+        end
 
-  respond :take, plaintext(/^(all|everything)$/) do |actor, _all|
-    items = Gamefic::Scope::Family.matches(actor)
-                                  .select(&:portable?)
-                                  .reject { |item| actor.flatten.include?(item) }
-    if items.empty?
-      actor.tell "You don't see anything you can carry."
-    else
-      items.each { |item| actor.execute :take, item }
+        respond :take, available(proc(&:attached?)) do |actor, thing|
+          actor.tell "#{The thing} is attached to #{the thing.parent}."
+        end
+
+        respond :take, available(Rubble) do |actor, rubble|
+          actor.tell "You don't have any use for #{the rubble}."
+        end
+
+        respond :take, plaintext(/^(all|everything)$/) do |actor, _all|
+          items = Gamefic::Scope::Family.matches(actor)
+                                        .select(&:portable?)
+                                        .reject { |item| actor.flatten.include?(item) }
+          if items.empty?
+            actor.tell "You don't see anything you can carry."
+          else
+            items.each { |item| actor.execute :take, item }
+          end
+        end
+
+        interpret 'get :thing', 'take :thing'
+        interpret 'pick up :thing', 'take :thing'
+        interpret 'pick :thing up', 'take :thing'
+        interpret 'carry :thing', 'take :thing'
+        interpret 'gather :thing', 'take :thing'
+        interpret 'hold :thing', 'take :thing'
+        interpret 'collect :thing', 'take :thing'
+      end
     end
   end
-
-  interpret "get :thing", "take :thing"
-  interpret "pick up :thing", "take :thing"
-  interpret "pick :thing up", "take :thing"
-  interpret "carry :thing", "take :thing"
 end

data/lib/gamefic-standard/actions/talk.rb

@@ -1,37 +1,51 @@
-Gamefic::Standard.script do
-  respond :talk do |actor|
-    actor.tell "You talk to yourself."
-  end
+# frozen_string_literal: true
 
-  respond :talk, myself do |actor, yourself|
-    actor.execute :talk
-  end
+module Gamefic
+  module Standard
+    module Actions
+      module Talk
+        extend Gamefic::Scriptable
 
-  respond :talk, available do |actor, thing|
-    actor.tell "Nothing happens."
-  end
+        respond :talk do |actor|
+          actor.tell 'You talk to yourself.'
+        end
 
-  respond :talk, Character do |actor, character|
-    actor.tell "#{The character} has nothing to say."
-  end
+        respond :talk, myself do |actor, _yourself|
+          actor.execute :talk
+        end
 
-  respond :talk, Character, plaintext do |actor, character, text|
-    actor.tell "#{The character} has nothing to say about #{text}."
-  end
+        respond :talk, available do |actor, _thing|
+          actor.tell 'Nothing happens.'
+        end
 
-  interpret "talk to :character", "talk :character"
-  interpret "talk to :character about :subject", "talk :character :subject"
-  interpret "ask :character :subject", "talk :character :subject"
-  interpret "ask :character about :subject", "talk :character :subject"
-  interpret "tell :character :subject", "talk :character :subject"
-  interpret "tell :character about :subject", "talk :character :subject"
-  interpret "ask :character for :subject", "talk :character :subject"
-  interpret "speak :character", "talk :character"
-  interpret "speak to :character", "talk :character"
-  interpret "speak :character :subject", "talk :character :subject"
-  interpret "speak :character about :subject", "talk :character :subject"
-  interpret "speak to :character about :subject", "talk :character :subject"
-  interpret "speak to :character :subject", "talk :character :subject"
-  interpret "discuss :subject :character", "talk :character :subject"
-  interpret "discuss :subject with :character", "talk :character :subject"
+        respond :talk, Character do |actor, character|
+          actor.tell "#{The character} has nothing to say."
+        end
+
+        respond :talk, available, plaintext do |actor, thing, _text|
+          actor.execute :talk, thing
+        end
+
+        respond :talk, Character, plaintext do |actor, character, _text|
+          actor.execute :talk, character
+        end
+
+        interpret 'talk to :character', 'talk :character'
+        interpret 'talk to :character about :subject', 'talk :character :subject'
+        interpret 'ask :character :subject', 'talk :character :subject'
+        interpret 'ask :character about :subject', 'talk :character :subject'
+        interpret 'tell :character :subject', 'talk :character :subject'
+        interpret 'tell :character about :subject', 'talk :character :subject'
+        interpret 'ask :character for :subject', 'talk :character :subject'
+        interpret 'speak :character', 'talk :character'
+        interpret 'speak to :character', 'talk :character'
+        interpret 'speak :character :subject', 'talk :character :subject'
+        interpret 'speak :character about :subject', 'talk :character :subject'
+        interpret 'speak to :character about :subject', 'talk :character :subject'
+        interpret 'speak to :character :subject', 'talk :character :subject'
+        interpret 'discuss :subject :character', 'talk :character :subject'
+        interpret 'discuss :subject with :character', 'talk :character :subject'
+      end
+    end
+  end
 end

data/lib/gamefic-standard/actions/unlock.rb

@@ -1,25 +1,35 @@
-Gamefic::Standard.script do
-  respond :unlock, available(Lockable) do |actor, thing|
-    if thing.has_lock_key? && actor.children.include?(thing.lock_key)
-      actor.execute :unlock, thing, thing.lock_key
-    else
-      actor.tell "You can't unlock #{the thing}."
-    end
-  end
+# frozen_string_literal: true
 
-  respond :unlock, available(Lockable, proc(&:has_lock_key?)), children do |actor, thing, key|
-    if thing.lock_key == key
-      thing.locked = false
-      actor.tell "You unlock #{the thing} with #{the key}."
-    else
-      actor.tell "You can't unlock #{the thing} with #{the key}."
-    end
-  end
+module Gamefic
+  module Standard
+    module Actions
+      module Unlock
+        extend Gamefic::Scriptable
 
-  respond :unlock, available(Lockable, proc(&:has_lock_key?)), available do |actor, _thing, key|
-    actor.execute :take, key if key.parent != actor
-    actor.proceed if key.parent == actor
-  end
+        respond :unlock, available(Lockable) do |actor, thing|
+          if thing.has_lock_key? && actor.children.include?(thing.lock_key)
+            actor.execute :unlock, thing, thing.lock_key
+          else
+            actor.tell "You can't unlock #{the thing}."
+          end
+        end
 
-  interpret "unlock :container with :key", "unlock :container :key"
+        respond :unlock, available(Lockable, proc(&:has_lock_key?)), children do |actor, thing, key|
+          if thing.lock_key == key
+            thing.locked = false
+            actor.tell "You unlock #{the thing} with #{the key}."
+          else
+            actor.tell "You can't unlock #{the thing} with #{the key}."
+          end
+        end
+
+        respond :unlock, available(Lockable, proc(&:has_lock_key?)), available do |actor, _thing, key|
+          actor.execute :take, key if key.parent != actor
+          actor.proceed if key.parent == actor
+        end
+
+        interpret 'unlock :container with :key', 'unlock :container :key'
+      end
+    end
+  end
 end

data/lib/gamefic-standard/actions/wait.rb

@@ -1,7 +1,17 @@
-Gamefic::Standard.script do
-  respond :wait do |actor|
-    actor.tell "Time passes."
-  end
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Wait
+        extend Gamefic::Scriptable
 
-  interpret 'z', 'wait'
+        respond :wait do |actor|
+          actor.tell 'Time passes.'
+        end
+
+        interpret 'z', 'wait'
+      end
+    end
+  end
 end

data/lib/gamefic-standard/actions.rb

@@ -18,6 +18,39 @@ require 'gamefic-standard/actions/take'
 require 'gamefic-standard/actions/move'
 require 'gamefic-standard/actions/talk'
 require 'gamefic-standard/actions/wait'
+require 'gamefic-standard/actions/give'
 require 'gamefic-standard/actions/repeat'
 require 'gamefic-standard/actions/save-restore-undo'
 require 'gamefic-standard/actions/pronouns'
+
+module Gamefic
+  module Standard
+    module Actions
+      include Nil
+      include Attack
+      include Drop
+      include Enter
+      include Open
+      include Close
+      include Lock
+      include Unlock
+      include Go
+      include Insert
+      include Inventory
+      include Leave
+      include Look
+      include Search
+      include Place
+      include Quit
+      include Take
+      include Move
+      include Talk
+      include Wait
+      include Give
+      include Repeat
+      include SaveRestoreUndo
+      include Pronouns
+      include Gamefic::What
+    end
+  end
+end

data/lib/gamefic-standard/articles.rb

@@ -1,45 +1,50 @@
-module Articles
-  # Get a name for the entity with an indefinite article (unless the entity
-  # has a proper name).
-  #
-  # @param entity [Gamefic::Entity]
-  # @return [String]
-  def a(entity)
-    entity.indefinitely
-  end
-  alias an a
+# frozen_string_literal: true
 
-  # Get a name for the entity with a definite article (unless the entity has
-  # a proper name).
-  #
-  # @param entity [Gamefic::Entity]
-  # @return [String]
-  def the(entity)
-    entity.definitely
-  end
+module Gamefic
+  module Standard
+    # Methods for adding definite and indefinite articles to entity names.
+    #
+    module Articles
+      # Get a name for the entity with an indefinite article (unless the entity
+      # has a proper name).
+      #
+      # @param entity [Gamefic::Entity]
+      # @return [String]
+      def a(entity)
+        entity.indefinitely
+      end
+      alias an a
 
-  # Get a capitalized name for the entity with an indefinite article (unless
-  # the entity has a proper name).
-  #
-  # @param entity [Gamefic::Entity]
-  # @return [String]
-  def a_(entity)
-    entity.indefinitely.cap_first
-  end
-  alias an_ a_
-  alias A a_
-  alias An a_
+      # Get a name for the entity with a definite article (unless the entity has
+      # a proper name).
+      #
+      # @param entity [Gamefic::Entity]
+      # @return [String]
+      def the(entity)
+        entity.definitely
+      end
 
-  # Get a capitalized name for the entity with a definite article (unless
-  # the entity has a proper name).
-  #
-  # @param entity [Gamefic::Entity]
-  # @return [String]
-  def the_(entity)
-    entity.definitely.cap_first
+      # Get a capitalized name for the entity with an indefinite article (unless
+      # the entity has a proper name).
+      #
+      # @param entity [Gamefic::Entity]
+      # @return [String]
+      def a_(entity)
+        entity.indefinitely.cap_first
+      end
+      alias an_ a_
+      alias A a_
+      alias An a_
+
+      # Get a capitalized name for the entity with a definite article (unless
+      # the entity has a proper name).
+      #
+      # @param entity [Gamefic::Entity]
+      # @return [String]
+      def the_(entity)
+        entity.definitely.cap_first
+      end
+      alias The the_
+    end
   end
-  alias The the_
 end
-
-# @todo Monkey patch
-Gamefic::Narrative.include Articles