gamefic-standard 3.2.4 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26551eefaf59857782cfe3e3037d201d5445211ff9982308bf3dd4dcb49ce8e0
-  data.tar.gz: 372052d2f4974d266eeb48a624e6740a1f2d21d49577120f628846ece31e42f6
+  metadata.gz: 5ad2cabfd4a0d81673d3ec48454ea842e5d5f68b5bb621b7b685b9d01d20ad16
+  data.tar.gz: 32e4c483f7a04eebe5bdec3e85f37a90341f2a3afe8f2e879bcda9808956ee31
 SHA512:
-  metadata.gz: 53a2ae91603d9a4fa76f904957da22154f8570d49f4d3367d828c5d0f6e900041b0574575c8aa40fe47feb8e6bbb82a906d210df9b04ce2ee13dd96afadef6c1
-  data.tar.gz: bb11ebc79930b52e425dfab9ad6c2a145ab5b9054d927610d7ca350387d2344e66f530ef384ce0e23d05c56a3c1b4a4312d9db4480f19a6e8d68464df32b47f5
+  metadata.gz: 7c7cb2add780225ba638fba5d266abf2abdeabc4c01a5c0a55e6fdbd4c42a76d43c84f0ce20c8fc3807bb180553aa3570c448c1544b744e39ca06fbf392e8225
+  data.tar.gz: fe1479675ff888e72be337f5eb6f206b677a7fe5442cd343ed1442a48ef6079dcff3ddafce156e6e69c595282241133ccb7d6de3c99d1c2aed375144ebc177cf

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 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
+- Standard::Actions namespace
+- Room#connect accepts additional portal attributes
+- Add gamefic-grammar
+
 ## 3.2.4 - September 10, 2024
 - Include Articles in Standard
 

data/Rakefile

@@ -1,14 +1,20 @@
-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.expand_path('../lib', __FILE__)
+  Opal.append_path File.join(__dir__, 'lib')
   Opal.use_gem('gamefic')
+  Opal.use_gem('gamefic-grammar')
+  Opal.use_gem('gamefic-what')
+  config.default_path = 'spec'
   config.pattern = 'spec/**/*_spec.rb'
-  config.requires = ['spec_helper']
+  config.requires = ['opal_helper']
 end

data/gamefic-standard.gemspec

@@ -1,17 +1,17 @@
-lib = File.expand_path("../lib", __FILE__)
+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"
+  spec.name          = 'gamefic-standard'
   spec.version       = Gamefic::Standard::VERSION
-  spec.authors       = ["Fred Snyder"]
-  spec.email         = ["fsnyder@castwide.com"]
+  spec.authors       = ['Fred Snyder']
+  spec.email         = ['fsnyder@castwide.com']
 
-  spec.summary       = %q{The Gamefic standard script library.}
-  spec.description   = %q{A collection of components for building games and interactive fiction in Gamefic.}
-  spec.homepage      = "http://gamefic.com"
-  spec.license       = "MIT"
+  spec.summary       = 'The Gamefic standard script library.'
+  spec.description   = 'A collection of components for building games and interactive fiction in Gamefic.'
+  spec.homepage      = 'https://gamefic.com'
+  spec.license       = 'MIT'
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
@@ -28,16 +28,18 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.required_ruby_version = '>= 2.7.0'
 
-  spec.add_dependency 'gamefic', '~> 3.3'
+  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/actions/attack.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Attack
+        extend Gamefic::Scriptable
+
+        respond :attack do |actor|
+          actor.tell 'Violence is not the answer here.'
+        end
+
+        respond :attack, Thing do |actor, _thing|
+          actor.execute :attack
+        end
+
+        interpret 'fight', 'attack'
+        interpret 'battle', 'attack'
+        interpret 'kill', 'attack'
+        interpret 'punch', 'attack'
+        interpret 'kick', 'attack'
+        interpret 'hit', 'attack'
+        interpret 'fight :thing', 'attack :thing'
+        interpret 'battle :thing', 'attack :thing'
+        interpret 'kill :thing', 'attack :thing'
+        interpret 'punch :thing', 'attack :thing'
+        interpret 'kick :thing', 'attack :thing'
+        interpret 'hit :thing', 'attack :thing'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Close
+        extend Gamefic::Scriptable
+
+        respond :close, available do |actor, thing|
+          actor.tell "You can't close #{the thing}."
+        end
+
+        respond :close, available(Openable) do |actor, thing|
+          if thing.open?
+            actor.tell "You close #{the thing}."
+            thing.open = false
+          else
+            actor.tell "#{The thing} is already closed."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Drop
+        extend Gamefic::Scriptable
+
+        respond :drop, available do |actor, thing|
+          actor.tell "You're not carrying #{the thing}."
+        end
+
+        respond :drop, descendants do |actor, thing|
+          actor.execute :take, thing
+          next unless thing.parent == actor
+
+          thing.parent = actor.parent
+          actor.tell "You drop #{the thing}."
+        end
+
+        respond :drop, descendants do |actor, thing|
+          thing.parent = actor.parent
+          actor.tell "You drop #{the thing}."
+        end
+
+        respond :drop, plaintext(/^(all|everything)$/) do |actor, _all|
+          if actor.children.empty?
+            actor.tell "You're not carrying anything."
+          else
+            actor.children.each { |item| actor.execute :drop, item }
+          end
+        end
+
+        interpret 'put down :thing', 'drop :thing'
+        interpret 'put :thing down', 'drop :thing'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Enter
+        extend Gamefic::Scriptable
+
+        respond :enter, siblings do |actor, thing|
+          actor.tell "#{The thing} can't accommodate you."
+        end
+
+        respond :enter, siblings(Enterable, proc(&:enterable?)) do |actor, supporter|
+          actor.parent = supporter
+          actor.tell "You get in #{the supporter}."
+        end
+
+        respond :enter, parent do |actor, container|
+          actor.tell "You're already in #{the container}."
+        end
+
+        respond :enter, siblings(Container, proc(&:enterable?), proc(&:closed?)) do |actor, container|
+          actor.tell "#{The container} is closed."
+        end
+
+        interpret 'get in :thing', 'enter :thing'
+        interpret 'get inside :thing', 'enter :thing'
+        interpret 'sit in :thing', 'enter :thing'
+        interpret 'lie in :thing', 'enter :thing'
+        interpret 'stand in :thing', 'enter :thing'
+      end
+    end
+  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/actions/go.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Go
+        extend Gamefic::Scriptable
+
+        respond :go, siblings(Portal) do |actor, portal|
+          if portal.destination.nil?
+            actor.tell 'That portal leads nowhere.'
+          else
+            actor.parent = portal.destination
+            actor.tell "You go #{portal.direction}." unless portal.direction.nil?
+            actor.execute :look
+          end
+        end
+
+        respond :go, plaintext do |actor, text|
+          if actor.parent == actor.room
+            actor.tell "I don't see any way to go \"#{text}\" from here."
+          else
+            actor.execute :leave
+            if actor.parent == actor.room
+              actor.perform "go #{text}"
+            else
+              actor.proceed
+            end
+          end
+        end
+
+        respond :go, available(Door) do |actor, door|
+          actor.execute :open, door unless door.open?
+          actor.proceed if door.open?
+        end
+
+        interpret 'north', 'go north'
+        interpret 'south', 'go south'
+        interpret 'west', 'go west'
+        interpret 'east', 'go east'
+        interpret 'up', 'go up'
+        interpret 'down', 'go down'
+        interpret 'northwest', 'go northwest'
+        interpret 'northeast', 'go northeast'
+        interpret 'southwest', 'go southwest'
+        interpret 'southeast', 'go southeast'
+
+        interpret 'n', 'go north'
+        interpret 's', 'go south'
+        interpret 'w', 'go west'
+        interpret 'e', 'go east'
+        interpret 'u', 'go up'
+        interpret 'd', 'go down'
+        interpret 'nw', 'go northwest'
+        interpret 'ne', 'go northeast'
+        interpret 'sw', 'go southwest'
+        interpret 'se', 'go southeast'
+
+        interpret 'go to :place', 'go :place'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Insert
+        extend Gamefic::Scriptable
+
+        respond :insert, available, available do |actor, thing, target|
+          actor.tell "You can't put #{the thing} inside #{the target}."
+        end
+
+        respond :insert, available, available(Receptacle) do |actor, thing, receptacle|
+          actor.execute :take, thing unless thing.parent == actor
+          next unless thing.parent == actor
+
+          thing.parent = receptacle
+          actor.tell "You put #{the thing} in #{the receptacle}."
+        end
+
+        respond :insert, available, available(Container) do |actor, _thing, container|
+          if container.open?
+            actor.proceed
+          else
+            actor.tell "#{The container} is closed."
+          end
+        end
+
+        respond :insert, children, room do |actor, thing|
+          actor.execute :drop, thing
+        end
+
+        interpret 'drop :item in :container', 'insert :item :container'
+        interpret 'put :item in :container', 'insert :item :container'
+        interpret 'place :item in :container', 'insert :item :container'
+        interpret 'set :item in :container', 'insert :item :container'
+        interpret 'insert :item in :container', 'insert :item :container'
+
+        interpret 'drop :item inside :container', 'insert :item :container'
+        interpret 'put :item inside :container', 'insert :item :container'
+        interpret 'place :item inside :container', 'insert :item :container'
+        interpret 'set :item inside :container', 'insert :item :container'
+        interpret 'insert :item inside :container', 'insert :item :container'
+
+        interpret 'drop :item into :container', 'insert :item :container'
+        interpret 'put :item into :container', 'insert :item :container'
+        interpret 'place :item into :container', 'insert :item :container'
+        interpret 'set :item into :container', 'insert :item :container'
+        interpret 'insert :item into :container', 'insert :item :container'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Inventory
+        extend Gamefic::Scriptable
+
+        respond :inventory do |actor|
+          if actor.children.length > 0
+            actor.tell "You are carrying #{actor.children.join_and}."
+          else
+            actor.tell "You aren't carrying anything."
+          end
+        end
+        interpret 'i', 'inventory'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Leave
+        extend Gamefic::Scriptable
+
+        respond :leave, parent do |actor, thing|
+          actor.tell "There's no way out of #{the thing}."
+        end
+
+        respond :leave, parent(Enterable, proc(&:enterable?)) do |actor, thing|
+          actor.tell "You leave #{the thing}."
+          actor.parent = thing.parent
+        end
+
+        respond :leave, parent(Supporter, proc(&:enterable?)) do |actor, thing|
+          actor.tell "You get off #{the thing}."
+          actor.parent = thing.parent
+        end
+
+        respond :leave, room do |actor, room|
+          portals = room.children.that_are(Portal)
+          if portals.length == 0
+            actor.tell "You don't see any obvious exits."
+          elsif portals.length == 1
+            actor.execute :go, portals[0]
+          else
+            actor.tell "I don't know which way you want to go: #{portals.map(&:instruction).join_or}."
+          end
+        end
+
+        respond :leave do |actor|
+          if actor.parent
+            actor.execute :leave, actor.parent
+          else
+            actor.tell "You don't see any obvious exits."
+          end
+        end
+
+        respond :leave, parent(Container, proc(&:enterable?), proc(&:closed?)) do |actor, container|
+          actor.execute :open, container
+          actor.proceed if container.open?
+        end
+
+        interpret 'exit', 'leave'
+        interpret 'exit :supporter', 'leave :supporter'
+        interpret 'get on :supporter', 'enter :supporter'
+        interpret 'get off :supporter', 'leave :supporter'
+        interpret 'get out :container', 'leave :container'
+        interpret 'get out of :container', 'leave :container'
+        interpret 'out', 'leave'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    module Actions
+      module Lock
+        extend Gamefic::Scriptable
+
+        respond :lock, available do |actor, thing|
+          actor.tell "You can't lock #{the thing}."
+        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}."
+          else
+            actor.tell "You can't lock #{the thing} with #{the key}."
+          end
+        end
+
+        respond :lock, 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 "lock :container with :key", "lock :container :key"  
+      end
+    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