gamefic-standard 3.2.3 → 3.3.0

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

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

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

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

@@ -1,133 +1,152 @@
+# frozen_string_literal: true
+
 module Gamefic
   module Standard
-    script do
-      respond :look do |actor|
-        actor.execute :look, actor.room
-      end
+    module Actions
+      module Look
+        extend Gamefic::Scriptable
 
-      respond :look, myself do |actor, _|
-        actor.tell actor.description
-        actor.execute :inventory
-      end
+        respond :look do |actor|
+          actor.execute :look, actor.room
+        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}."
+        respond :look, myself do |actor, _|
+          actor.tell actor.description
+          actor.execute :inventory
         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(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(Receptacle) do |actor, thing|
-        actor.proceed
-        if thing.accessible?
+        respond :look, available(Supporter) do |actor, thing|
           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?
+          # 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
-      end
 
-      respond :look, parent(Supporter, proc(&:enterable?)) do |actor, supporter|
-        actor.proceed
-        actor.tell "You are currently on #{the supporter}."
-      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 || thing.accessible?
 
-      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?
+          itemized = thing.children.that_are_not(actor, proc(&:attached?)).that_are(proc(&:itemized?))
+          next if itemized.empty?
 
-        actor.tell "You see #{thing.children.join_and}."
-      end
-
-      respond :look, room do |actor, room|
-        actor.execute :_describe_room
-      end
+          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
 
-      meta :_describe_room do |actor|
-        next unless actor.room
+        respond :look, parent(Supporter, proc(&:enterable?)) do |actor, supporter|
+          actor.proceed
+          actor.tell "You are currently on #{the supporter}."
+        end
 
-        actor.tell "<strong>#{actor.room.name.cap_first}</strong>"
-        actor.tell actor.room.description if actor.room.has_description?
-        actor.execute :_itemize_room
-      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?
 
-      meta :_itemize_room do |actor|
-        room = actor.room
-        next unless room
+          actor.tell "You see #{thing.children.join_and}."
+        end
 
-        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
+        respond :look, room do |actor, _room|
+          actor.execute :_describe_room
         end
-        if charsum.length > 0
-          actor.tell "#{charsum.join_and.cap_first} #{charsum.length == 1 ? 'is' : 'are'} here."
+
+        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
-        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
+
+        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
-        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}."
+          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
-              dirs = []
-              portals.each do |p|
-                dirs.push p.instruction
+              with_locales.push item
+            end
+          end
+          actor.tell "You see #{itemsum.join_and}." if itemsum.length > 0
+          with_locales.each do |entity|
+            actor.tell entity.locale_description
+          end
+          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 = %w[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
-              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
+          actor.execute :_look_parent_from_room
         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}."
-          }
+
+        meta :_look_parent_from_room do |actor|
+          next unless actor.parent.is_a?(Supporter) || actor.parent.is_a?(Receptacle)
+
+          preposition = actor.parent.is_a?(Supporter) ? 'on' : 'in'
+          siblings = actor.parent.children.that_are_not(actor)
+          if siblings.empty?
+            actor.tell "You're #{preposition} #{the actor.parent}."
+          else
+            actor.tell "You're #{preposition} #{the actor.parent}, along with #{siblings.join_and}."
+          end
         end
-      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'
+        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/move.rb

@@ -2,23 +2,27 @@
 
 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}."
+    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
-      end
 
-      respond :move, children(Thing) do |actor, thing|
-        actor.tell "You're already carrying #{the thing}."
-      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"
+        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

@@ -1,60 +1,70 @@
-Gamefic::Standard.script do
-  meta nil, plaintext do |actor, string|
-    next if string.strip.empty?
+# frozen_string_literal: true
 
-    words = string.keywords
-    list = actor.epic.synonyms
-    if list.include?(words[0]&.to_sym)
-      if words.length > 1
-        result = myself.query(actor, words[1..-1].join(' '))
-        found = [result.match].compact
-        avail = available(ambiguous: true)
-        result = avail.query(actor, result.remainder)
-        until result.match.nil?
-          found.concat result.match
-          result = avail.query(actor, result.remainder)
-        end
-        if found.empty?
-          verbs = actor.epic
-                       .syntaxes
-                       .select { |syn| syn.synonym == words[0].to_sym }
-                       .map(&:verb)
-          resps = actor.epic.responses_for(*verbs)
-          if resps.any? { |resp| !resp.queries.empty? }
-            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]}" but not with the rest of your sentence. (Maybe it's a one-word command?)]
-          end
-        elsif result.remainder != ''
-          actor.tell %(I recognize "#{words[0]}" as a verb but was confused by "#{result.remainder}.")
-        elsif found.one?
-          verbs = actor.epic
-                       .syntaxes
-                       .select { |syn| syn.synonym == words[0].to_sym }
-                       .map(&:verb)
-          resps = actor.epic.responses_for(*verbs)
-          if resps.any? { |resp| !resp.queries.empty? }
-            actor.tell %(I recognize "#{words[0]}" and "#{found.first.name}" but could not understand them together.)
-          else
-            actor.tell %[I recognize "#{words[0]}" and "#{found.first.name}" but could not understand them together. (Maybe "#{words[0]}" is a one-word command?)]
-          end
-        else
-          verbs = actor.epic
-                       .syntaxes
-                       .select { |syn| syn.synonym == words[0].to_sym }
-                       .map(&:verb)
-          resps = actor.epic.responses_for(*verbs)
-          if resps.any? { |resp| !resp.queries.empty? }
-            actor.tell %(I recognize "#{words[0]}" but I'm not sure if "#{words[1..-1].join(' ')}" means #{found.map(&:definitely).join_or}.)
+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
+          list = actor.epic.synonyms
+          if list.include?(words[0]&.to_sym)
+            if words.length > 1
+              result = myself.query(actor, words[1..-1].join(' '))
+              found = [result.match].compact
+              avail = available(ambiguous: true)
+              result = avail.query(actor, result.remainder)
+              until result.match.nil?
+                found.concat result.match
+                result = avail.query(actor, result.remainder)
+              end
+              if found.empty?
+                verbs = actor.epic
+                            .syntaxes
+                            .select { |syn| syn.synonym == words[0].to_sym }
+                            .map(&:verb)
+                resps = actor.epic.responses_for(*verbs)
+                if resps.any? { |resp| !resp.queries.empty? }
+                  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]}" but not with the rest of your sentence. (Maybe it's a one-word command?)]
+                end
+              elsif result.remainder != ''
+                actor.tell %(I recognize "#{string.sub(/#{result.remainder}$/, '').strip}" as a command but was confused by "#{result.remainder}.")
+              elsif found.one?
+                verbs = actor.epic
+                            .syntaxes
+                            .select { |syn| syn.synonym == words[0].to_sym }
+                            .map(&:verb)
+                resps = actor.epic.responses_for(*verbs)
+                if resps.any? { |resp| !resp.queries.empty? }
+                  actor.tell %(I recognize "#{words[0]}" and "#{found.first.name}" but could not understand them together.)
+                else
+                  actor.tell %[I recognize "#{words[0]}" and "#{found.first.name}" but could not understand them together. (Maybe "#{words[0]}" is a one-word command?)]
+                end
+              else
+                verbs = actor.epic
+                            .syntaxes
+                            .select { |syn| syn.synonym == words[0].to_sym }
+                            .map(&:verb)
+                resps = actor.epic.responses_for(*verbs)
+                if resps.any? { |resp| !resp.queries.empty? }
+                  actor.tell %(I recognize "#{words[0]}" but I'm not sure if "#{words[1..-1].join(' ')}" means #{found.map(&:definitely).join_or}.)
+                else
+                  actor.tell %[I recognize "#{words[0]}" but not with the rest of your sentence. (Maybe it's a one-word command?)]
+                end
+              end
+            else
+              actor.tell %(I recognize "#{words[0]}" as a verb but could not understand it in this context.)
+            end
           else
-            actor.tell %[I recognize "#{words[0]}" but not with the rest of your sentence. (Maybe it's a one-word command?)]
+            actor.tell %(I don't recognize "#{words[0]}" as a verb.)
           end
         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

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

@@ -1,29 +1,39 @@
-Gamefic::Standard.script do
-  respond :open, available do |actor, thing|
-    actor.tell "You can't open #{the thing}."
-  end
+# frozen_string_literal: true
 
-  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
+module Gamefic
+  module Standard
+    module Actions
+      module Open
+        extend Gamefic::Scriptable
 
-  respond :open, available(Lockable) do |actor, thing|
-    if thing.locked?
-      actor.tell "#{The thing} is locked."
-    else
-      actor.proceed
-    end
-  end
+        respond :open, available do |actor, thing|
+          actor.tell "You can't open #{the thing}."
+        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
+        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'
+        interpret 'open :thing with :key', 'open :thing :key'
+      end
+    end
+  end
 end