gamefic-sdk 1.6.0 → 1.7.0

data/scripts/snapshots.plot.rb

@@ -1,14 +1,16 @@
-module Snapshots
-  def self.history
-    @history ||= []
-  end
-end
-
-last_snapshot = nil
-
-on_player_ready do |actor|
-  if (actor.last_action.nil? or !actor.last_action.meta?) and !last_snapshot.nil?
-    Snapshots.history.push last_snapshot
-  end
-  last_snapshot = save
-end
+# @gamefic.script snapshots
+
+module Snapshots
+  def self.history
+    @history ||= []
+  end
+end
+
+last_snapshot = nil
+
+on_player_ready do |actor|
+  if (actor.last_action.nil? or !actor.last_action.meta?) and !last_snapshot.nil?
+    Snapshots.history.push last_snapshot
+  end
+  last_snapshot = save
+end

data/scripts/standard.plot.rb

@@ -1,12 +1,10 @@
 # @gamefic.script standard
-# A general-purpose library that provides common actions and entities for
-# interactive fiction. Designed to be suitable for parser-based text
-# adventures, but easily extensible for other formats.
+#   A general-purpose library that provides common actions and entities for
+#   interactive fiction. Designed to be suitable for parser-based text
+#   adventures, but easily extensible for other formats.
 
 script 'standard/queries'
-script 'standard/use'
 script 'standard/modules'
 script 'standard/direction'
 script 'standard/entities'
 script 'standard/actions'
-script 'standard/pathfinder'

data/scripts/standard/actions.plot.rb

@@ -1,23 +1,13 @@
-script 'standard/actions/close'
+script 'standard/actions/nil'
 script 'standard/actions/drop'
 script 'standard/actions/enter'
-script 'standard/actions/give'
 script 'standard/actions/go'
 script 'standard/actions/insert'
 script 'standard/actions/inventory'
 script 'standard/actions/leave'
-script 'standard/actions/lock'
-script 'standard/actions/look-under'
 script 'standard/actions/look'
-script 'standard/actions/nil'
-script 'standard/actions/open'
 script 'standard/actions/place'
 script 'standard/actions/quit'
-script 'standard/actions/read'
-script 'standard/actions/search'
-script 'standard/actions/show'
 script 'standard/actions/take'
 script 'standard/actions/talk'
-script 'standard/actions/unlock'
-script 'standard/actions/use'
 script 'standard/actions/wait'

data/scripts/standard/actions/drop.plot.rb

@@ -6,7 +6,7 @@ respond :drop, Use.family() do |actor, thing|
   end
 end
 
-respond :drop, Query::Children.new() do |actor, thing|
+respond :drop, Use.children do |actor, thing|
   if thing.sticky?
     actor.tell thing.sticky_message || "#{you.pronoun.Subj} #{you.verb.need} to keep #{the thing} for now."
   else

data/scripts/standard/actions/enter.plot.rb

@@ -1,20 +1,12 @@
+respond :enter, Use.siblings do |actor, thing|
+  actor.tell "#{The thing} #{you.contract "can not"} accommodate #{you.pronoun.obj}."
+end
+
 respond :enter, Use.siblings(Enterable, :enterable?) do |actor, supporter|
   actor.parent = supporter
   actor.tell "#{you.pronoun.Subj} #{you.verb[supporter.enter_verb]} #{the supporter}."
 end
 
-respond :enter, Use.siblings(Enterable, Openable, :enterable?) do |actor, container|
-  if container.open?
-    actor.proceed
-  else
-    actor.tell "#{The container} is closed."
-  end
-end
-
-respond :enter, Use.siblings do |actor, thing|
-  actor.tell "#{The thing} #{you.contract "can not"} accommodate #{you.pronoun.obj}."
-end
-
 respond :enter, Use.parent do |actor, container|
   actor.tell "#{you.contract(you.pronoun.subj + ' ' + you.verb.be).cap_first} already in #{the container}."
 end
@@ -23,9 +15,5 @@ respond :enter, Use.parent(Supporter) do |actor, supporter|
   actor.tell "#{you.pronoun.Subj} #{you.verb[supporter.enter_verb]} #{the supporter} already."
 end
 
-respond :enter, Use.text do |actor, text|
-  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any \"#{text}\" here."
-end
-
 interpret "get on :thing", "enter :thing"
 interpret "get in :thing", "enter :thing"

data/scripts/standard/actions/go.plot.rb

@@ -1,4 +1,4 @@
-respond :go, Use.family(Portal) do |actor, portal|
+respond :go, Use.siblings(Portal) do |actor, portal|
   if actor.parent != actor.room
     actor.perform :leave
   end
@@ -15,44 +15,10 @@ respond :go, Use.family(Portal) do |actor, portal|
   end
 end
 
-respond :go, Use.family(Door, :locked?) do |actor, door|
-  actor.tell "#{The door} is locked."
-end
-
-respond :go, Use.family(Door, :closed?) do |actor, door|
-  if door.automatic?
-    actor.perform :open, door
-    if door.open?
-      actor.proceed
-    end
-  else
-    actor.tell "#{The door} is closed."
-  end
-end
-
-respond :go, Query::Text.new() do |actor, string|
+respond :go, Use.text do |actor, string|
   actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any exit \"#{string}\" from here."
 end
 
-respond :go, Use.text do |actor, text|
-  # This version of the Go action identifies portals by their destinations.
-  portals = actor.room.children.that_are(Portal)
-  destinations = []
-  d_map = {}
-  portals.each { |portal|
-    next if portal.destination.nil?
-    destinations.push portal.destination
-    d_map[portal.destination] = portal
-  }
-  matches = destinations.select{|o| o.match? text }
-  matches = destinations.select{|o| o.match? text, fuzzy: true } if matches.empty?
-  if matches.length == 1
-    actor.perform :go, d_map[matches[0]]
-  else
-    actor.proceed
-  end
-end
-
 respond :go do |actor|
   actor.tell "Where do you want to go?"
 end

data/scripts/standard/actions/insert.plot.rb

@@ -1,40 +1,26 @@
 script 'standard'
 
-respond :insert, Use.visible, Use.reachable do |actor, thing, target|
+respond :insert, Use.available, Use.available do |actor, thing, target|
   actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} put #{the thing} inside #{the target}."
 end
 
-respond :insert, Use.visible, Use.reachable(Receptacle) do |actor, thing, receptacle|
+respond :insert, Use.children, Use.available(Receptacle) do |actor, thing, receptacle|
   if thing.sticky?
     actor.tell thing.sticky_message || "#{you.pronoun.Subj} #{you.verb.need} to keep #{the thing} for now."
   else
-    if actor.auto_takes?(thing)
-      actor.tell "#{you.pronoun.Subj} put #{the thing} in #{the receptacle}."
-      thing.parent = receptacle
-    end
+    actor.tell "#{you.pronoun.Subj} put #{the thing} in #{the receptacle}."
+    thing.parent = receptacle
   end
 end
 
-respond :insert, Use.visible, Use.reachable(Container) do |actor, thing, container|
-  if container.open?
+respond :insert, Use.available, Use.available(Receptacle) do |actor, thing, receptacle|
+  if thing.parent == actor
     actor.proceed
   else
-    actor.tell "#{The container} is closed."
+    actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} have #{the thing}."
   end
 end
 
-respond :insert, Use.visible, Use.text do |actor, thing, container|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see anything called \"#{container}\" here."
-end
-
-respond :insert, Use.text, Use.visible do |actor, thing, container|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see anything called \"#{thing}\" here."
-end
-
-respond :insert, Use.text, Use.text do |actor, thing, container|
-  actor.tell "I don't know what you mean by \"#{thing}\" or \"#{container}.\""
-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"

data/scripts/standard/actions/inventory.plot.rb

@@ -5,4 +5,5 @@ respond :inventory do |actor|
     actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.be + ' not'} carrying anything."
   end
 end
-xlate "i", "inventory"
+
+interpret "i", "inventory"

data/scripts/standard/actions/leave.plot.rb

@@ -1,11 +1,3 @@
-respond :leave, Use.parent(Container, :enterable?) do |actor, container|
-  if container.open?
-    actor.proceed
-  else
-    actor.tell "#{The container} is closed."
-  end
-end
-
 respond :leave, Use.parent do |actor, thing|
   actor.tell "There's no way out of #{the thing}."
 end
@@ -15,7 +7,7 @@ respond :leave, Use.parent(Enterable, :enterable?) do |actor, thing|
   actor.parent = thing.parent
 end
 
-respond :leave, Query::Parent.new(Room) do |actor, room|
+respond :leave, Use.room do |actor, room|
   portals = room.children.that_are(Portal)
   if portals.length == 0
     actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any obvious exits."
@@ -30,12 +22,9 @@ respond :leave do |actor|
   actor.perform :leave, actor.parent
 end
 
-xlate "exit", "leave"
-xlate "exit :supporter", "leave :supporter"
-xlate "get off :supporter", "leave :supporter"
-xlate "get up from :supporter", "leave :supporter"
-xlate "get up", "leave"
-xlate "get off", "leave"
-xlate "get out :container", "leave :container"
-xlate "get out of :container", "leave :container"
-#xlate "out", "leave"
+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"

data/scripts/standard/actions/look.plot.rb

@@ -1,16 +1,53 @@
-respond :look, Use.parent(Supporter) do |actor, supporter|
-  actor.tell supporter.description
-  actor.tell "#{you.pronoun.Subj} are currently on #{the supporter}."
+respond :look, Use.text do |actor, string|
+  if string == 'around'
+    actor.perform :look, actor.room
+  else
+    actor.tell "You don't see any \"#{string}\" here."
+  end
 end
 
-respond :look, Use.itself do |actor, _|
+respond :look, Use.itself do |actor, thing|
   actor.tell actor.description
   actor.perform :inventory
 end
 
+respond :look, Use.available do |actor, thing|
+  actor.tell thing.description
+  thing.children.that_are(:attached?).that_are(:itemized?).each { |item|
+    actor.tell "#{An item} is attached to #{the thing}."
+  }
+end
+
+respond :look, Use.available(Supporter) 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} on #{the thing}." unless itemized.empty?
+  end
+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, Use.parent(Supporter, :enterable?) do |actor, supporter|
+  actor.proceed
+  actor.tell "#{you.pronoun.Subj} are currently on #{the supporter}."
+end
+
 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
+
+respond :_itemize_room do |actor|
+  room = actor.room
+  next if room.nil?
   with_locales = []
   chars = room.children.that_are(Character).that_are(:itemized?) - [actor]
   charsum = []
@@ -44,11 +81,11 @@ respond :look, Use.room do |actor, room|
     if portals.length > 0
       if portals.length == 1
         p = portals[0]
-        actor.tell "There is an exit #{p.direction || p.name || "to #{the p.destination}"}."
+        actor.tell "There is an exit #{p.instruction}."
       else
         dirs = []
         portals.each { |p|
-          dirs.push (p.direction || p.name || "to #{the p.destination}")
+          dirs.push p.instruction
         }
         actor.tell "There are exits #{dirs.join_and(', ')}."
       end
@@ -61,45 +98,9 @@ respond :look, Use.room do |actor, room|
     }
   end
 end
-xlate "look", "look around"
-xlate "l", "look around"
-
-respond :look, Use.available() do |actor, thing|
-  actor.tell thing.description
-  thing.children.that_are(:attached?).that_are(:itemized?).each { |item|
-    actor.tell "#{An item} is attached to #{the thing}."
-  }
-end
-
-respond :look, Use.text do |actor, string|
-  if string == 'around'
-    actor.perform :look, actor.parent
-  else
-    actor.tell "You don't see any \"#{string}\" here."
-  end
-end
-
-respond :look, Use.available(Receptacle) do |actor, receptacle|
-  if receptacle.has_description?
-    actor.tell receptacle.description
-  end
-  actor.perform :search, receptacle
-end
 
-respond :look, Use.available(Supporter) do |actor, supporter|
-  actor.proceed
-  supported = supporter.children.that_are_not(:attached?)
-  if supported.length > 0
-    actor.tell "You see #{supported.join_and} sitting there."
-  end
-end
-
-respond :look, Use.available(Door) do |actor, door|
-  if door.has_description?
-    actor.proceed
-  end
-  actor.tell "#{The door} is " + (door.open? ? 'open' : 'closed') + '.'
-end
+interpret "look", "look around"
+interpret "l", "look around"
 
 interpret "look at :thing", "look :thing"
 interpret "l :thing", "look :thing"

data/scripts/standard/actions/nil.plot.rb

@@ -1,6 +1,6 @@
 meta nil, Query::Text.new() do |actor, string|
   words = string.split_words
-  list = verbs(to_s: true)
+  list = verbs
   if list.include?(words[0])
     if words.length > 1
       actor.tell "I recognize '#{words[0]}' as a verb but could not understand the rest of your sentence."

data/scripts/standard/actions/take.plot.rb

@@ -1,46 +1,28 @@
-respond :take, Use.reachable do |actor, thing|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} take #{the thing}."
-end
-
-respond :take, Use.visible do |actor, thing|
-  if thing.parent == actor.parent
-    actor.proceed
-  elsif thing.parent.kind_of?(Container) and !thing.parent.open?
-    actor.tell "#{The thing} is inside #{the thing.parent}, which is closed."
-  end
-end
-
-respond :take, Use.visible do |actor, thing|
-  if actor.parent.kind_of?(Supporter) and actor.parent != thing.parent and actor.parent != thing.parent.parent
-    actor.tell "#{you.pronoun.Subj} can't reach it from #{the actor.parent}."
-  else
-    actor.proceed
-  end
-end
-
-respond :take, Use.reachable(:attached?) do |actor, thing|
-  actor.tell "#{The thing} is attached to #{the thing.parent}."
+respond :take, Use.text do |actor, text|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any \"#{text}\" here."
 end
 
-respond :take, Use.reachable(Entity, :portable?) do |actor, thing|
+respond :take, Use.available do |actor, thing|
   if thing.parent == actor
     actor.tell "#{you.contract(you.pronoun.subj + ' are').cap_first} already carrying #{the thing}."
-  else
+  elsif thing.portable?
     if actor.parent != thing.parent
       actor.tell "#{you.pronoun.Subj} #{you.verb.take} #{the thing} from #{the thing.parent}."
     else
       actor.tell "#{you.pronoun.Subj} #{you.verb.take} #{the thing}."
     end
     thing.parent = actor
+  else
+    actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} take #{the thing}."
   end
 end
 
-respond :take, Use.reachable(Rubble) do |actor, rubble|
-  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} have any use for #{the rubble}."
+respond :take, Use.available(:attached?) do |actor, thing|
+  actor.tell "#{The thing} is attached to #{the thing.parent}."
 end
 
-respond :take, Use.text do |actor, text|
-  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any \"#{text}\" here."
+respond :take, Use.available(Rubble) do |actor, rubble|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} have any use for #{the rubble}."
 end
 
 interpret "get :thing", "take :thing"