gamefic-standard 3.2.4 → 4.0.0

data/lib/gamefic/standard/actions/mount.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Mount
+        extend Gamefic::Scriptable
+
+        respond :mount, siblings do |actor, thing|
+          actor.tell "#{The thing} can't accommodate you."
+        end
+
+        respond :mount, siblings(Supporter, proc(&:enterable?)) do |actor, supporter|
+          actor.put supporter, :on
+          actor.tell "You get on #{the supporter}."
+        end
+
+        respond :mount, parent(Supporter) do |actor, supporter|
+          actor.tell "You're already on #{the supporter}."
+        end
+
+        interpret 'get on :thing', 'mount :thing'
+        interpret 'sit on :thing', 'mount :thing'
+        interpret 'lie on :thing', 'mount :thing'
+        interpret 'stand on :thing', 'mount :thing'
+      end
+    end
+  end
+end

data/lib/gamefic/standard/actions/move.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Move
+        extend Gamefic::Scriptable
+
+        respond :move, Thing do |actor, thing|
+          if thing.portable?
+            actor.tell 'Maybe you want to <em>take</em> it?'
+          else
+            actor.tell "You can't move #{the thing}."
+          end
+        end
+
+        respond :move, children(Thing) do |actor, thing|
+          actor.tell "You're already carrying #{the thing}."
+        end
+
+        interpret 'push :thing', 'move :thing'
+        interpret 'pull :thing', 'move :thing'
+        interpret 'drag :thing', 'move :thing'
+        interpret 'lift :thing', 'move :thing'
+      end
+    end
+  end
+end

data/lib/gamefic/standard/actions/nil.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Nil
+        extend Gamefic::Scriptable
+
+        meta nil, plaintext do |actor, string|
+          next if string.strip.empty?
+
+          words = string.keywords
+          if actor.can?(words[0])
+            if words.length > 1
+              possible = [actor] + available.span(actor)
+              result = Scanner.scan(possible, words[1..-1].join(' '))
+              if result.matched.empty?
+                actor.tell %(I recognize "#{words[0]}" as a verb but don't know what you mean by "#{words[1..-1].join(' ')}.")
+              elsif result.remainder != ''
+                actor.tell %(I recognize "#{string.sub(/#{result.remainder}$/,
+                                                       '').strip}" as a command but was confused by "#{result.remainder}.")
+              elsif result.matched.one?
+                actor.tell %(I recognize "#{words[0]}" and "#{result.matched.first.name}" but could not understand them together.)
+              else
+                actor.tell %(I recognize "#{words[0]}" but I'm not sure if "#{words[1..-1].join(' ')}" means #{result.matched.map(&:definitely).join_or}.)
+              end
+            else
+              actor.tell %(I recognize "#{words[0]}" as a verb but could not understand it in this context.)
+            end
+          else
+            actor.tell %(I don't recognize "#{words[0]}" as a verb.)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/standard/actions/open.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Open
+        extend Gamefic::Scriptable
+
+        respond :open, available do |actor, thing|
+          actor.tell "You can't open #{the thing}."
+        end
+
+        respond :open, available(Openable) do |actor, thing|
+          if thing.open?
+            actor.tell "#{The thing} is already open."
+          else
+            actor.tell "You open #{the thing}."
+            thing.open = true
+          end
+        end
+
+        respond :open, available(Lockable) do |actor, thing|
+          if thing.locked?
+            actor.tell "#{The thing} is locked."
+          else
+            actor.proceed
+          end
+        end
+
+        respond :open, available(Lockable, proc(&:has_lock_key?)), available do |actor, thing, key|
+          actor.execute :unlock, thing, key
+          actor.execute :open, thing if thing.unlocked?
+        end
+
+        interpret 'open :thing with :key', 'open :thing :key'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Place
+        extend Gamefic::Scriptable
+
+        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
+
+          thing.put supporter, :on
+          actor.tell "You put #{the thing} on #{the supporter}."
+        end
+
+        respond :place, children, available(Supporter) do |actor, thing, supporter|
+          thing.put supporter, :on
+          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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Pronouns
+        extend Gamefic::Scriptable
+
+        introduction do |actor|
+          actor[:standard_pronoun_targets] = []
+        end
+
+        after_command do |actor, command|
+          next unless command.verb
+
+          actor[:standard_pronoun_targets].replace command.arguments.that_are(Thing)
+        end
+
+        meta nil, plaintext do |actor, string|
+          keywords = string.keywords
+          next actor.proceed unless actor.can?(keywords.first)
+
+          xlation = keywords[1..].map do |word|
+            next word unless %w[him her it them].include?(word)
+
+            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]} #{xlation.join(' ')}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Quit
+        extend Gamefic::Scriptable
+
+        ConfirmQuit = yes_or_no do
+          on_start do |actor|
+            actor.tell 'Are you sure you want to quit?'
+          end
+          on_finish do |actor, props|
+            actor.cue default_conclusion if props.yes?
+          end
+        end
+
+        meta :quit do |actor|
+          actor.cue ConfirmQuit
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Repeat
+        extend Gamefic::Scriptable
+
+        after_command do |actor, command|
+          next if command.verb == :repeat || command.input.nil?
+
+          actor[:standard_repeatable_command] = command.input
+        end
+
+        meta :repeat do |actor|
+          if actor[:standard_repeatable_command]
+            actor.tell "Repeating <kbd>\"#{actor[:standard_repeatable_command]}\"</kbd>..."
+            actor.perform actor[:standard_repeatable_command]
+          else
+            actor.tell "You don't have a previous command to repeat right now."
+          end
+        end
+
+        interpret 'again', 'repeat'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module SaveRestoreUndo
+        extend Gamefic::Scriptable
+
+        # Save, Restore, and Undo need to be handled by the game client. They have
+        # default implementations here to make them available in help.
+
+        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.'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# 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|
+          itemized = thing.accessible.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
+        end
+
+        respond :search, available(Container, proc(&:closed?)) do |actor, container|
+          actor.execute :open, container
+          if container.open?
+            actor.proceed
+          else
+            actor.tell "You can't see inside #{the container}."
+          end
+        end
+
+        interpret 'look inside :thing', 'search :thing'
+        interpret 'look in :thing', 'search :thing'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Take
+        extend Gamefic::Scriptable
+
+        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, 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::Query::Family.new
+                                        .span(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
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Talk
+        extend Gamefic::Scriptable
+
+        respond :talk do |actor|
+          actor.execute :talk, actor
+        end
+
+        respond :talk, myself do |actor, _yourself|
+          actor.tell 'You talk to yourself.'
+        end
+
+        respond :talk, available do |actor, _thing|
+          actor.tell 'Nothing happens.'
+        end
+
+        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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Unlock
+        extend Gamefic::Scriptable
+
+        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
+
+        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

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

data/lib/gamefic/standard/actions.rb

@@ -0,0 +1,57 @@
+require 'gamefic/standard/actions/nil'
+require 'gamefic/standard/actions/attack'
+require 'gamefic/standard/actions/drop'
+require 'gamefic/standard/actions/enter'
+require 'gamefic/standard/actions/mount'
+require 'gamefic/standard/actions/open'
+require 'gamefic/standard/actions/close'
+require 'gamefic/standard/actions/lock'
+require 'gamefic/standard/actions/unlock'
+require 'gamefic/standard/actions/go'
+require 'gamefic/standard/actions/insert'
+require 'gamefic/standard/actions/inventory'
+require 'gamefic/standard/actions/leave'
+require 'gamefic/standard/actions/look'
+require 'gamefic/standard/actions/search'
+require 'gamefic/standard/actions/place'
+require 'gamefic/standard/actions/quit'
+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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # Methods for adding definite and indefinite articles to entity names.
+    #
+    module Articles
+      extend Gamefic::Scriptable
+
+      # 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 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 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
+end

data/lib/gamefic/standard/enterable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Enterable
+      attr_writer :enterable
+
+      def enterable?
+        @enterable ||= false
+      end
+    end
+  end
+end

data/lib/gamefic/standard/entities/character.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    Character = Gamefic::Actor
+    Character.set_default gender: :other
+
+    class Character
+      def accessible
+        children.select { |child| child.is_a?(Scenery) }
+      end
+    end
+  end
+end

data/lib/gamefic/standard/entities/container.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # An openable and lockable receptacle.
+    #
+    class Container < Receptacle
+      include Gamefic::Standard::Openable
+      include Gamefic::Standard::Lockable
+
+      def accessible
+        open? ? super : []
+      end
+    end
+  end
+end