gamefic-standard 3.3.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83db9094673ea86b25db1d51bf9c06c62be6fadc7ed938f39c71b9c16cba9566
-  data.tar.gz: 579a371ef1c031b2b7bb2bf9d66831e7ce92ad04d3f7ec450dd183b1265e4f80
+  metadata.gz: ca3a0186e345a9afcd439decd174e1e0d25af882a3c12a4fae8c93ce7dc148a9
+  data.tar.gz: 983d0edf810abcade4ccca1ebcdb45d9052968cea7e614f4dd478d79d4fdc94b
 SHA512:
-  metadata.gz: beffd2638efbb5a61fe6f0605a59e7807045aa67705c1cf5a042c28cd279e8efe8b9146690a9e742a9ebc369db035b4ecefcf0b2ea2cdca288b9a68426f253d9
-  data.tar.gz: 324c51c2f6eeec341ee26d81449949521f0cb51063f739fa319faf072abd090b18b31c92ed16e2855934cffadb088f98e6ba3a8a4f05b13e66fbc90b43601b15
+  metadata.gz: 10f9e483b14180248220dec5dfb2d99a331ef54f06f3e2cedd869a2577fdd6bc968457e0675bbc6af16f48f79a4585b5c0215d247053ee089f742a3d5ebe3dc7
+  data.tar.gz: 5afbf188e3dde7b5850aedc9e7f45bc5dc9b0c46f0cd913a16f60142e8d2d2ddcf184507b4f7c2cb68b72671d2ec1df1307a1171f421428bf68d387961d84c2d

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 4.0.1 - May 26, 2025
+- Fix lock/unlock actions
+
+## 4.0.0 - January 25, 2025
+- Updates for Gamefic 4.0
+
 ## 3.3.0 - October 5, 2024
 - Include Pronoun and Give in Standard
 - Add gamefic-what

data/Rakefile

@@ -1,10 +1,13 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 require 'opal/rspec/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec
 
 Opal::RSpec::RakeTask.new(:opal) do |_, config|
   Opal.append_path File.join(__dir__, 'lib')

data/gamefic-standard.gemspec

@@ -1,6 +1,6 @@
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'gamefic-standard/version'
+require 'gamefic/standard/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'gamefic-standard'
@@ -37,9 +37,9 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.7.0'
 
-  spec.add_dependency 'gamefic', '~> 3.3'
-  spec.add_dependency 'gamefic-grammar', '~> 1.0'
-  spec.add_dependency 'gamefic-what', '~> 1.0'
+  spec.add_dependency 'gamefic', '~> 4.0'
+  spec.add_dependency 'gamefic-grammar', '~> 1.1'
+  spec.add_dependency 'gamefic-what', '~> 2.0'
 
   spec.add_development_dependency 'opal', '~> 1.7'
   spec.add_development_dependency 'opal-rspec', '~> 1.0'

data/lib/{gamefic-standard → gamefic/standard}/actions/drop.rb

@@ -10,7 +10,7 @@ module Gamefic
           actor.tell "You're not carrying #{the thing}."
         end
 
-        respond :drop, children do |actor, thing|
+        respond :drop, descendants do |actor, thing|
           actor.execute :take, thing
           next unless thing.parent == actor
 
@@ -18,7 +18,7 @@ module Gamefic
           actor.tell "You drop #{the thing}."
         end
 
-        respond :drop, children do |actor, thing|
+        respond :drop, descendants do |actor, thing|
           thing.parent = actor.parent
           actor.tell "You drop #{the thing}."
         end

data/lib/{gamefic-standard → gamefic/standard}/actions/enter.rb

@@ -19,22 +19,14 @@ module Gamefic
           actor.tell "You're already in #{the container}."
         end
 
-        respond :enter, parent(Supporter) do |actor, supporter|
-          actor.tell "You're inside #{the supporter} already."
-        end
-
         respond :enter, siblings(Container, proc(&:enterable?), proc(&:closed?)) do |actor, container|
           actor.tell "#{The container} is closed."
         end
 
-        interpret 'get on :thing', 'enter :thing'
         interpret 'get in :thing', 'enter :thing'
         interpret 'get inside :thing', 'enter :thing'
-        interpret 'sit on :thing', 'enter :thing'
         interpret 'sit in :thing', 'enter :thing'
-        interpret 'lie on :thing', 'enter :thing'
         interpret 'lie in :thing', 'enter :thing'
-        interpret 'stand on :thing', 'enter :thing'
         interpret 'stand in :thing', 'enter :thing'
       end
     end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Give
+        extend Gamefic::Scriptable
+        include Gamefic::What
+
+        respond :give, available, children do |actor, _character, _gift|
+          actor.tell 'Nothing happens.'
+        end
+
+        respond :give, available(Character), available do |actor, character, gift|
+          actor.tell "#{The character} has no use for #{the gift}."
+        end
+
+        respond :give, available(Character), available do |actor, _character, gift|
+          actor.execute :take, gift if gift.parent != actor
+
+          actor.proceed if gift.parent == actor
+        end
+
+        respond :give, Thing do |actor, thing|
+          actor.tell "Who do you want to give #{the thing} to?"
+          actor.cue AskForWhat, template: "give #{the thing} to __what__"
+        end
+
+        respond :give, Character do |actor, character|
+          actor.tell "What do you want to give to #{the character}?"
+          actor.cue AskForWhat, template: "give __what__ to #{the character}"
+        end
+
+        interpret 'give :gift to :character', 'give :character :gift'
+      end
+    end
+  end
+end

data/lib/{gamefic-standard → gamefic/standard}/actions/lock.rb

@@ -10,10 +10,22 @@ module Gamefic
           actor.tell "You can't lock #{the thing}."
         end
 
+        respond :lock, available(Lockable) do |actor, thing|
+          if thing.has_lock_key? && actor.children.include?(thing.lock_key)
+            actor.execute :lock, thing, thing.lock_key
+          else
+            actor.tell "You can't lock #{the thing}."
+          end
+        end
+
         respond :lock, available(Lockable, proc(&:has_lock_key?)), children do |actor, thing, key|
           if thing.lock_key == key
-            thing.locked = true
-            actor.tell "You lock ##{the thing} with #{the key}."
+            if thing.locked?
+              actor.tell "It's already locked."
+            else
+              thing.locked = true
+              actor.tell "You lock #{the thing} with #{the key}."
+            end
           else
             actor.tell "You can't lock #{the thing} with #{the key}."
           end
@@ -24,7 +36,7 @@ module Gamefic
           actor.proceed if key.parent == actor
         end
 
-        interpret "lock :container with :key", "lock :container :key"  
+        interpret "lock :container with :key", "lock :container :key"
       end
     end
   end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Look
+        RELATION_PHRASES = {
+          in: 'inside',
+          on: 'on top of'
+        }.freeze
+
+        extend Gamefic::Scriptable
+
+        def itemize_room(actor)
+          return unless (room = actor.room)
+
+          siblings = room.children.select(&:itemized?).that_are_not(actor)
+
+          siblings.that_are(Character)
+                  .reject(&:locale_description)
+                  .tap do |list|
+                    list.empty? or actor.tell "#{list.join_and.cap_first} #{list.one? ? 'is' : 'are'} here."
+                  end
+
+          siblings.that_are_not(Character, Portal)
+                  .reject(&:locale_description)
+                  .tap do |list|
+                    list.empty? or actor.tell "You see #{list.join_and}."
+                  end
+
+          siblings.select(&:locale_description)
+                  .each { |thing| actor.tell thing.locale_description }
+
+          itemize_explicit_portals(actor)
+          itemize_parent(actor) unless actor.parent == actor.room
+        end
+
+        def itemize_explicit_portals(actor)
+          return unless actor.room&.explicit_exits?
+
+          siblings = actor.room.children.select(&:itemized?).that_are_not(actor)
+          earlier = siblings.select(&:locale_description).that_are(Portal).any?
+          siblings.that_are(Portal)
+                  .reject(&:locale_description)
+                  .tap do |portals|
+                    next if portals.empty?
+
+                    if portals.one?
+                      actor.tell "There is#{earlier ? ' also ' : ' '}an exit #{portals.first.instruction}."
+                    else
+                      order = %w[north northeast east southeast south southwest west northwest up down]
+                      dirs = portals.map(&:instruction)
+                                    .map(&:to_s)
+                                    .sort { |a, b| order.index(a) || 0 <=> order.index(b) || 1 }
+                      actor.tell "There are#{earlier ? ' also ' : ' '}exits #{dirs.join_and}."
+                    end
+                  end
+        end
+
+        def itemize_parent(actor)
+          return unless (parent = actor.parent)
+
+          siblings = parent.children.that_are_not(actor)
+          if siblings.empty?
+            actor.tell "You're #{RELATION_PHRASES[actor.relation]} #{the parent}."
+          else
+            actor.tell "You're #{RELATION_PHRASES[actor.relation]} #{the parent}, along with #{siblings.join_and}."
+          end
+        end
+
+        respond :look do |actor|
+          if actor.room
+            actor.execute :look, actor.room
+          else
+            actor.tell "You're in a featureless void."
+          end
+        end
+
+        respond :look, myself do |actor, _|
+          actor.tell actor.description
+          actor.execute :inventory
+        end
+
+        respond :look, available(Thing) do |actor, thing|
+          actor.tell thing.description
+          thing.children.that_are(proc(&:attached?)).that_are(proc(&:itemized?)).each do |item|
+            actor.tell "#{An item} is attached to #{the thing}."
+          end
+        end
+
+        respond :look, available(Supporter) do |actor, thing|
+          itemized = thing.children.that_are_not(proc(&:attached?)).that_are(proc(&:itemized?))
+          # If the supporter does not have a description but it does contain
+          # itemized things, avoid saying there's nothing special about it.
+          actor.proceed if thing.has_description? || itemized.empty?
+          actor.tell "You see #{itemized.join_and} on #{the thing}." unless itemized.empty?
+        end
+
+        respond :look, available(Receptacle) do |actor, thing|
+          actor.proceed
+          actor.tell "You're currently in #{the thing}." if actor.parent == thing
+          next unless actor.parent == thing
+
+          itemized = thing.accessible.that_are_not(actor, proc(&:attached?)).that_are(proc(&:itemized?))
+          next if itemized.empty?
+
+          if actor.parent == thing
+            actor.tell "You see #{itemized.join_and} here." unless itemized.empty?
+          else
+            actor.tell "You see #{itemized.join_and} in #{the thing}." unless itemized.empty?
+          end
+        end
+
+        respond :look, parent(Supporter, proc(&:enterable?)) do |actor, supporter|
+          actor.proceed
+          actor.tell "You are currently on #{the supporter}."
+        end
+
+        respond :look, available(Thing, Openable) do |actor, thing|
+          actor.tell thing.description if thing.has_description?
+          actor.tell "#{The thing} is #{thing.open? ? 'open' : 'closed'}."
+          next if thing.closed? || thing.children.empty?
+
+          actor.tell "You see #{thing.children.join_and}."
+        end
+
+        respond :look, room do |actor, room|
+          actor.tell "<strong>#{room.name.cap_first}</strong>"
+          actor.tell room.description if room.described?
+          itemize_room(actor)
+        end
+
+        interpret 'look around', 'look'
+        interpret 'look here', 'look'
+        interpret 'l', 'look'
+
+        interpret 'look at :thing', 'look :thing'
+        interpret 'look on :thing', 'look :thing'
+        interpret 'look under :thing', 'look :thing'
+        interpret 'look beneath :thing', 'look :thing'
+        interpret 'look around :thing', 'look :thing'
+        interpret 'l :thing', 'look :thing'
+        interpret 'examine :thing', 'look :thing'
+        interpret 'x :thing', 'look :thing'
+        interpret 'inspect :thing', 'look :thing'
+      end
+    end
+  end
+end

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/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 → gamefic/standard}/actions/place.rb

@@ -14,12 +14,12 @@ module Gamefic
           actor.execute :take, thing unless thing.parent == actor
           next unless thing.parent == actor
 
-          thing.parent = supporter
+          thing.put supporter, :on
           actor.tell "You put #{the thing} on #{the supporter}."
         end
 
         respond :place, children, available(Supporter) do |actor, thing, supporter|
-          thing.parent = supporter
+          thing.put supporter, :on
           actor.tell "You put #{the thing} on #{the supporter}."
         end
 

data/lib/{gamefic-standard → gamefic/standard}/actions/pronouns.rb

@@ -10,16 +10,15 @@ module Gamefic
           actor[:standard_pronoun_targets] = []
         end
 
-        after_action do |action|
-          next unless action.verb
+        after_command do |actor, command|
+          next unless command.verb
 
-          action.actor[:standard_pronoun_targets].replace action.arguments.that_are(Thing)
+          actor[:standard_pronoun_targets].replace command.arguments.that_are(Thing)
         end
 
         meta nil, plaintext do |actor, string|
           keywords = string.keywords
-          list = actor.epic.synonyms
-          next actor.proceed unless list.include?(keywords.first&.to_sym)
+          next actor.proceed unless actor.can?(keywords.first)
 
           xlation = keywords[1..].map do |word|
             next word unless %w[him her it them].include?(word)
@@ -27,8 +26,7 @@ module Gamefic
             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(' ')}"
+          actor.perform "#{keywords[0]} #{xlation.join(' ')}"
         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 → gamefic/standard}/actions/search.rb

@@ -11,21 +11,21 @@ module Gamefic
         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
+          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 can't see inside #{the thing}."
+            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
-          actor.proceed if container.open?
+          if container.open?
+            actor.proceed
+          else
+            actor.tell "You can't see inside #{the container}."
+          end
         end
 
         interpret 'look inside :thing', 'search :thing'

data/lib/{gamefic-standard → gamefic/standard}/actions/take.rb

@@ -30,7 +30,8 @@ module Gamefic
         end
 
         respond :take, plaintext(/^(all|everything)$/) do |actor, _all|
-          items = Gamefic::Scope::Family.matches(actor)
+          items = Gamefic::Query::Family.new
+                                        .span(actor)
                                         .select(&:portable?)
                                         .reject { |item| actor.flatten.include?(item) }
           if items.empty?

data/lib/{gamefic-standard → gamefic/standard}/actions/talk.rb

@@ -7,11 +7,11 @@ module Gamefic
         extend Gamefic::Scriptable
 
         respond :talk do |actor|
-          actor.tell 'You talk to yourself.'
+          actor.execute :talk, actor
         end
 
         respond :talk, myself do |actor, _yourself|
-          actor.execute :talk
+          actor.tell 'You talk to yourself.'
         end
 
         respond :talk, available do |actor, _thing|

data/lib/{gamefic-standard → gamefic/standard}/actions/unlock.rb

@@ -16,8 +16,12 @@ module Gamefic
 
         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}."
+            if thing.locked?
+              thing.locked = false
+              actor.tell "You unlock #{the thing} with #{the key}."
+            else
+              actor.tell "It's already unlocked."
+            end
           else
             actor.tell "You can't unlock #{the thing} with #{the key}."
           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 → gamefic/standard}/articles.rb

@@ -5,6 +5,8 @@ module Gamefic
     # 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).
       #

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