gamefic-standard 2.4.0 → 3.1.0

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

@@ -1,35 +1,39 @@
-Gamefic.script do
-  respond :insert, Use.available, Use.available do |actor, thing, target|
-    actor.tell "You can't put #{the thing} inside #{the target}."
-  end
+module Gamefic
+  module Standard
+    script do
+      respond :insert, available, available do |actor, thing, target|
+        actor.tell "You can't put #{the thing} inside #{the target}."
+      end
 
-  respond :insert, Use.available, Use.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(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, Use.available, Use.available(Container) do |actor, _thing, container|
-    if container.open?
-      actor.proceed
-    else
-      actor.tell "#{The container} is closed."
-    end
-  end
+      respond :insert, available, available(Container) do |actor, _thing, container|
+        if container.open?
+          actor.proceed
+        else
+          actor.tell "#{The container} is closed."
+        end
+      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 "insert :item in :container", "insert :item :container"
+      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 "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 "insert :item inside :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 "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 "insert :item into :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 "insert :item into :container", "insert :item :container"
+    end
+  end
 end

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

@@ -1,11 +1,15 @@
-Gamefic.script do
-  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."
+module Gamefic
+  module Standard
+    script do
+      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
-
-  interpret "i", "inventory"
 end

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

@@ -1,46 +1,50 @@
-Gamefic.script do
-  respond :leave, Use.parent do |actor, thing|
-    actor.tell "There's no way out of #{the thing}."
-  end
+module Gamefic
+  module Standard
+    script do
+      respond :leave, parent do |actor, thing|
+        actor.tell "There's no way out of #{the thing}."
+      end
 
-  respond :leave, Use.parent(Enterable, :enterable?) do |actor, thing|
-    actor.tell "You leave #{the thing}."
-    actor.parent = thing.parent
-  end
+      respond :leave, parent(Enterable, proc(&:enterable?)) do |actor, thing|
+        actor.tell "You leave #{the thing}."
+        actor.parent = thing.parent
+      end
 
-  respond :leave, Use.parent(Supporter, :enterable?) do |actor, thing|
-    actor.tell "You get off #{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, Use.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.join_or}."
-    end
-  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.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 do |actor|
+        if actor.parent
+          actor.execute :leave, actor.parent
+        else
+          actor.tell "You don't see any obvious exits."
+        end
+      end
 
-  respond :leave, Use.parent(Container, :enterable?, :closed?) do |actor, container|
-    actor.execute :open, container
-    actor.proceed if container.open?
-  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 "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"
+    end
+  end
 end

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

@@ -1,21 +1,25 @@
-Gamefic.script do
-  respond :lock, Use.available do |actor, thing|
-    actor.tell "You can't lock #{the thing}."
-  end
+module Gamefic
+  module Standard
+    script do
+      respond :lock, available do |actor, thing|
+        actor.tell "You can't lock #{the thing}."
+      end
 
-  respond :lock, Use.available(Lockable, :has_lock_key?), Use.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?)), 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, Use.available(Lockable, :has_lock_key?), Use.available do |actor, thing, key|
-    actor.execute :take, key if key.parent != actor
-    actor.proceed if key.parent == actor
-  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"
+      interpret "lock :container with :key", "lock :container :key"
+    end
+  end
 end

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

@@ -1,112 +1,133 @@
-Gamefic.script do
-  respond :look, Use.text(/^here$/i) do |actor, _|
-    actor.execute :look, actor.room
-  end
+module Gamefic
+  module Standard
+    script do
+      respond :look do |actor|
+        actor.execute :look, actor.room
+      end
 
-  respond :look, Use.itself do |actor, _|
-    actor.tell actor.description
-    actor.execute :inventory
-  end
+      respond :look, myself do |actor, _|
+        actor.tell actor.description
+        actor.execute :inventory
+      end
 
-  respond :look, Use.available(Thing) do |actor, thing|
-    actor.tell thing.description
-    thing.children.that_are(:attached?).that_are(:itemized?).each do |item|
-      actor.tell "#{An item} is attached to #{the thing}."
-    end
-  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, Use.available(Supporter) do |actor, thing|
-    itemized = thing.children.that_are_not(:attached?).that_are(: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(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, Use.available(Receptacle) do |actor, thing|
-    actor.proceed
-    if thing.accessible?
-      itemized = thing.children.that_are_not(:attached?).that_are(:itemized?)
-      actor.tell "You see #{itemized.join_and} in #{the thing}." unless itemized.empty?
-    end
-  end
+      respond :look, available(Receptacle) do |actor, thing|
+        actor.proceed
+        if thing.accessible?
+          itemized = thing.children.that_are_not(proc(&:attached?)).that_are(proc(&:itemized?))
+          actor.tell "You see #{itemized.join_and} in #{the thing}." unless itemized.empty?
+        end
+      end
 
-  respond :look, Use.parent(Supporter, :enterable?) do |actor, supporter|
-    actor.proceed
-    actor.tell "You are currently on #{the supporter}."
-  end
+      respond :look, parent(Supporter, proc(&:enterable?)) do |actor, supporter|
+        actor.proceed
+        actor.tell "You are currently on #{the supporter}."
+      end
 
-  respond :look, Use.available(Thing, Openable) do |actor, thing|
-    actor.proceed
-    actor.tell "#{The thing} is #{thing.open? ? 'open' : 'closed'}."
-  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?
 
-  respond :look, Use.room do |actor, room|
-    actor.tell "<strong>#{room.name.cap_first}</strong>"
-    actor.tell room.description if room.has_description?
-    actor.execute :_itemize_room
-  end
+        actor.tell "You see #{thing.children.join_and}."
+      end
 
-  meta :_itemize_room do |actor|
-    room = actor.room
-    next if room.nil?
-    with_locales = []
-    chars = room.children.that_are(Character).that_are(:itemized?) - [actor]
-    charsum = []
-    chars.each do |char|
-      if char.locale_description.nil?
-        charsum.push char
-      else
-        with_locales.push char
+      respond :look, room do |actor, room|
+        actor.execute :_describe_room
       end
-    end
-    if charsum.length > 0
-      actor.tell "#{charsum.join_and.cap_first} #{charsum.length == 1 ? 'is' : 'are'} here."
-    end
-    items = room.children.that_are(:itemized?) - [actor] - room.children.that_are(Character) - room.children.that_are(Portal)
-    itemsum = []
-    items.each do |item|
-      if item.locale_description.nil?
-        itemsum.push item
-      else
-        with_locales.push item
+
+      meta :_describe_room do |actor|
+        next unless actor.room
+
+        actor.tell "<strong>#{actor.room.name.cap_first}</strong>"
+        actor.tell actor.room.description if actor.room.has_description?
+        actor.execute :_itemize_room
       end
-    end
-    if itemsum.length > 0
-      actor.tell "You see #{itemsum.join_and}."
-    end
-    with_locales.each { |entity|
-      actor.tell entity.locale_description
-    }
-    if room.explicit_exits?
-      portals = room.children.that_are(Portal).that_are(:itemized?)
-      if portals.length > 0
-        if portals.length == 1
-          p = portals[0]
-          actor.tell "There is an exit #{p.instruction}."
-        else
-          dirs = []
-          portals.each do |p|
-            dirs.push p.instruction
+
+      meta :_itemize_room do |actor|
+        room = actor.room
+        next unless room
+
+        with_locales = []
+        chars = room.children.that_are(Character).that_are(proc(&:itemized?)) - [actor]
+        charsum = []
+        chars.each do |char|
+          if char.locale_description.nil?
+            charsum.push char
+          else
+            with_locales.push char
+          end
+        end
+        if charsum.length > 0
+          actor.tell "#{charsum.join_and.cap_first} #{charsum.length == 1 ? 'is' : 'are'} here."
+        end
+        items = room.children.that_are(proc(&:itemized?)) - [actor] - room.children.that_are(Character) - room.children.that_are(Portal)
+        itemsum = []
+        items.each do |item|
+          if item.locale_description.nil?
+            itemsum.push item
+          else
+            with_locales.push item
           end
-          actor.tell "There are exits #{dirs.join_and(', ')}."
+        end
+        if itemsum.length > 0
+          actor.tell "You see #{itemsum.join_and}."
+        end
+        with_locales.each { |entity|
+          actor.tell entity.locale_description
+        }
+        if room.explicit_exits?
+          portals = room.children.that_are(Portal).that_are(proc(&:itemized?))
+          if portals.length > 0
+            if portals.length == 1
+              p = portals[0]
+              actor.tell "There is an exit #{p.instruction}."
+            else
+              dirs = []
+              portals.each do |p|
+                dirs.push p.instruction
+              end
+              order = ['north', 'northeast', 'east', 'southeast', 'south', 'southwest', 'west', 'northwest', 'up', 'down']
+              dirs.sort! { |a, b| (order.index(a.to_s) || order.length) <=> (order.index(b.to_s) || order.length) }
+              actor.tell "There are exits #{dirs.join_and(', ')}."
+            end
+          end
+        end
+        if actor.parent.is_a?(Supporter)
+          actor.tell "You are on #{the actor.parent}."
+          actor.parent.children.that_are_not(actor).each { |s|
+            actor.tell "#{A s} is on #{the actor.parent}."
+          }
         end
       end
-    end
-    if actor.parent.is_a?(Supporter)
-      actor.tell "You are on #{the actor.parent}."
-      actor.parent.children.that_are_not(actor).each { |s|
-        actor.tell "#{A s} is on #{the actor.parent}."
-      }
-    end
-  end
 
-  interpret 'look around', 'look here'
-  interpret 'look', 'look here'
-  interpret 'l', 'look here'
+      interpret 'look around', 'look'
+      interpret 'look here', 'look'
+      interpret 'l', 'look'
 
-  interpret 'look at :thing', 'look :thing'
-  interpret 'l :thing', 'look :thing'
-  interpret 'examine :thing', 'look :thing'
-  interpret 'x :thing', 'look :thing'
+      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

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    script do
+      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

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

@@ -1,23 +1,24 @@
-Gamefic.script do
-  meta nil, Gamefic::Query::Text.new do |actor, string|
-    words = string.split_words
-    # @todo There should probably be an Active#verbs or Active#command_words method
-    list = actor.playbooks.flat_map(&:syntaxes).flat_map(&:first_word)
-    if list.include?(words[0])
+Gamefic::Standard.script do
+  meta nil, plaintext do |actor, string|
+    words = string.keywords
+    list = actor.epic.synonyms
+    if list.include?(words[0]&.to_sym)
       if words.length > 1
-        found = Gamefic::Query::Available.new.resolve(actor, words[1..-1].join(' ')).objects
+        found = []
+        avail = available(ambiguous: true)
+        result = avail.query(actor, words[1..-1].join(' '))
+        until result.match.nil?
+          found.concat result.match
+          result = avail.query(actor, result.remainder)
+        end
         if found.empty?
-          actions = []
-          actor.playbooks.reverse.each { |p| actions.concat p.actions_for(words[0].to_sym) }
-          if actions.any? { |a| a.queries.one? && !a.queries.first.is_a?(Gamefic::Query::Text) }
-            actor.tell %(I recognize "#{words[0]}" as a verb but don't know what you mean by "#{words[1..-1].join(' ')}.")
-          else
-            actor.tell %(I recognize "#{words[0]}" as a verb but could not understand the rest of your sentence.)
-          end
+          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 "#{words[0]}" as a verb but was confused by "#{result.remainder}.")
         elsif found.one?
           actor.tell %(I recognize "#{words[0]}" and "#{found.first.name}" but could not understand them together.)
         else
-          actor.tell %(I'm not sure if "#{words[1..-1].join(' ')}" means #{found.map(&:definitely).join_or}.)
+          actor.tell %(I recognize "#{words[0]}" but I'm not sure if "#{words[1..-1].join(' ')}" means #{found.map(&:definitely).join_or}.)
         end
       else
         actor.tell %(I recognize "#{words[0]}" as a verb but could not understand it in this context.)

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

@@ -1,9 +1,9 @@
-Gamefic.script do
-  respond :open, Use.available do |actor, thing|
+Gamefic::Standard.script do
+  respond :open, available do |actor, thing|
     actor.tell "You can't open #{the thing}."
   end
 
-  respond :open, Use.available(Openable) do |actor, thing|
+  respond :open, available(Openable) do |actor, thing|
     if thing.open?
       actor.tell "#{The thing} is already open."
     else
@@ -12,7 +12,7 @@ Gamefic.script do
     end
   end
 
-  respond :open, Use.available(Lockable) do |actor, thing|
+  respond :open, available(Lockable) do |actor, thing|
     if thing.locked?
       actor.tell "#{The thing} is locked."
     else
@@ -20,7 +20,7 @@ Gamefic.script do
     end
   end
 
-  respond :open, Use.available(Lockable, :has_lock_key?), Use.available do |actor, thing, key|
+  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

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

@@ -1,16 +1,16 @@
-Gamefic.script do
-  respond :place, Use.children, Use.reachable do |actor, thing, supporter|
+Gamefic::Standard.script do
+  respond :place, children, available do |actor, thing, supporter|
     actor.tell "You can't put #{the thing} on #{the supporter}."
   end
 
-  respond :place, Use.available, Use.available(Supporter) do |actor, thing, supporter|
+  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
 
-  respond :place, Use.children, Use.reachable(Supporter) do |actor, thing, supporter|
+  respond :place, children, available(Supporter) do |actor, thing, supporter|
     thing.parent = supporter
     actor.tell "You put #{the thing} on #{the supporter}."
   end

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

@@ -1,14 +1,10 @@
-Gamefic.script do
-  confirm_quit = yes_or_no do |actor, data|
-    if data.yes?
-      actor.cue default_conclusion
-    else
-      actor.cue default_scene
-    end
+Gamefic::Standard.script do
+  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 confirm_quit
+    actor.cue :standard_confirm_quit
   end
 end

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

@@ -0,0 +1,14 @@
+# 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."
+    end
+  end
+
+  interpret 'again', 'repeat'
+end

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

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