gamefic-sdk 1.0.0 → 1.0.1

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

@@ -0,0 +1,8 @@
+respond :inventory do |actor|
+  if actor.children.length > 0
+    actor.tell "#{you.pronoun.Subj} #{you.verb.be} carrying #{actor.children.join_and}."
+  else
+    actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.be + ' not'} carrying anything."
+  end
+end
+xlate "i", "inventory"

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

@@ -0,0 +1,41 @@
+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
+
+respond :leave, Use.parent(Enterable, :enterable?) do |actor, thing|
+  actor.tell "#{you.pronoun.Subj} #{you.verb[thing.leave_verb]} #{the thing}."
+  actor.parent = thing.parent
+end
+
+respond :leave, Query::Parent.new(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."
+  elsif portals.length == 1
+    actor.perform :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|
+  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"

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

@@ -0,0 +1,59 @@
+respond :lock, Query::Text.new() do |actor, string|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any \"#{string}\" here."
+end
+
+respond :lock, Query::Reachable.new() do |actor, thing|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} lock #{the thing}."
+end
+
+respond :lock, Query::Reachable.new(Lockable, :has_lock_key?) do |actor, container|
+  # Portable containers need to be picked up before they are locked.
+  if container.portable? and container.parent != actor
+    actor.perform :take, container
+    if container.parent != actor
+      break
+    end
+  end
+  if container.locked?
+    actor.tell "It's already locked."
+  else
+    #if container.is?(:auto_lockable)
+      key = nil
+      if container.lock_key.nil? == false
+        if container.lock_key.parent == actor
+          key = container.lock_key
+        end
+      end
+      if key.nil?
+        actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} have any way to lock #{the container}."
+      else
+        actor.tell "#{you.pronoun.Subj} #{you.verb.lock} #{the container} with #{the key}."
+        container.locked = true
+      end
+    #else
+    #  actor.tell "What do you want to lock #{the container} with?"
+    #end
+  end
+end
+
+respond :lock, Query::Reachable.new(Lockable, :has_lock_key?), Query::Children.new do |actor, container, key|
+  if container.locked == false
+    if container.lock_key == key
+      #if container.is?(:not_auto_lockable)
+      #  container.is :auto_lockable
+      #  actor.perform :lock, container
+      #  container.is :not_auto_lockable
+      #else
+      #  actor.perform :lock, container
+      #end
+      actor.tell "#{you.pronoun.Subj} #{you.verb.lock} #{the container} with #{the key}."
+      container.locked = true
+    else
+      actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} lock #{the container} with #{the key}."
+    end
+  else
+    actor.tell "It's already locked."
+  end
+end
+
+xlate "lock :container with :key", "lock :container :key"

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

@@ -0,0 +1,8 @@
+script 'standard/actions/look'
+
+respond :look_under, Query::Reachable.new() do |actor, thing|
+  actor.tell "There's nothing to see under #{the thing}."
+end
+
+interpret "look beneath :thing", "look under :thing"
+interpret "look below :thing", "look under :thing"

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

@@ -0,0 +1,102 @@
+respond :look, Use.parent(Supporter) do |actor, supporter|
+  actor.tell supporter.description
+  actor.tell "#{you.pronoun.Subj} are currently on #{the supporter}."
+end
+
+respond :look, Query::Self.new do |actor, _|
+  actor.tell actor.description
+  actor.perform :inventory
+end
+
+respond :look, Use.room do |actor, room|
+  actor.tell "<strong>#{room.name.cap_first}</strong>"
+  actor.tell room.description
+  with_locales = []
+  chars = room.children.that_are(Character).that_are(:itemized?) - [actor]
+  charsum = []
+  chars.each { |char|
+    if char.locale_description != ""
+      with_locales.push char
+    else
+      charsum.push char
+    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 { |item|
+    if item.locale_description != ""
+      with_locales.push item
+    else
+      itemsum.push item
+    end
+  }
+  if itemsum.length > 0
+    actor.tell "#{you.pronoun.Subj} #{you.verb.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
+        actor.tell "There is an exit #{portals[0].direction}."
+      else
+        dirs = []
+        portals.each { |p|
+          dirs.push (p.direction || p.name)
+        }
+        actor.tell "There are exits #{dirs.join_and(', ')}."
+      end
+    end
+  end
+  if actor.parent.kind_of?(Supporter)
+    actor.tell "#{you.pronoun.Subj} #{you.verb.be} on #{the actor.parent}."
+    actor.parent.children.that_are_not(actor).each { |s|
+      actor.tell "#{A s} is on #{the actor.parent}."
+    }
+  end
+end
+xlate "look", "look around"
+xlate "l", "look around"
+
+respond :look, Query::Visible.new() 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|
+  actor.tell "You don't see any \"#{string}\" here."
+end
+
+respond :look, Use.reachable(Receptacle) do |actor, receptacle|
+  if receptacle.has_description?
+    actor.tell receptacle.description
+  end
+  actor.perform :search, receptacle
+end
+
+respond :look, Query::Visible.new(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, Query::Reachable.new(Door) do |actor, door|
+  if door.has_description?
+    actor.proceed
+  end
+  actor.tell "#{The door} is " + (door.open? ? 'open' : 'closed') + '.'
+end
+
+interpret "look at :thing", "look :thing"
+interpret "l :thing", "look :thing"
+interpret "examine :thing", "look :thing"
+interpret "x :thing", "look :thing"

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

@@ -0,0 +1,35 @@
+meta nil, Query::Text.new() do |actor, string|
+  words = string.split_words
+  if commandwords.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."
+    else
+      actor.tell "I recognize '#{words[0]}' as a verb but could not understand it in this context."
+    end
+  else
+    found = []
+    commandwords.each { |c|
+      next if c.include?('_')
+      if c.length > words[0].length and c.start_with?(words[0])
+        found.push c
+      end
+    }
+    if found.length == 1
+      words[0] = found[0]
+      actor.perform words.join(' ')
+    elsif found.length > 1 and words[0].length > 2
+      actor.tell "I'm not sure if #{words[0]} means #{found.join_and(', ', ' or ')}."
+    else
+      actor.tell "I don't recognize '#{words[0]}' as a verb."
+    end
+  end
+end
+
+meta nil, Query::Text.new("it") do |actor, string|
+  words = string.split_words
+  if commandwords.include?(words[0])
+    actor.tell "I'm not sure what you mean by \"it.\""
+  else
+    actor.proceed
+  end
+end

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

@@ -0,0 +1,34 @@
+respond :open, Use.text do |actor, string|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any \"#{string}\" here."
+end
+
+respond :open, Use.reachable() do |actor, thing|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.can + ' not')} open #{the thing}."
+end
+
+respond :open, Use.reachable(Openable) do |actor, container|
+  # Portable containers need to be picked up before they are opened.
+  if container.portable? and container.parent != actor
+    actor.perform :take, container
+    if container.parent != actor
+      break
+    end
+  end
+  if !container.open?
+    actor.tell "#{you.pronoun.Subj} #{you.verb.open} #{the container}."
+    container.open = true
+    if container.children.that_are_not(:attached?).length > 0
+      actor.perform :search, container
+    end
+  else
+    actor.tell "It's already open."
+  end
+end
+
+respond :open, Use.reachable(Openable, Lockable) do |actor, container|
+  if container.locked?
+    actor.tell "#{The container} is locked."
+  else
+    actor.proceed
+  end
+end

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

@@ -0,0 +1,36 @@
+respond :place, Use.children, Use.reachable do |actor, thing, supporter|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.can + ' not')} put #{the thing} on #{the supporter}."
+end
+
+respond :place, Use.visible, Use.reachable(Supporter) do |actor, thing, supporter|
+  if thing.parent != actor
+    actor.perform :take, thing
+  end
+  if thing.parent == actor
+    actor.perform :place, thing
+  end
+end
+
+respond :place, Use.children, Use.reachable(Supporter) do |actor, thing, supporter|
+  thing.parent = supporter
+  actor.tell "#{you.pronoun.Subj} #{you.verb.put} #{the thing} on #{the supporter}."
+end
+
+respond :place, Use.visible, Use.text do |actor, thing, supporter|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see anything called \"#{supporter}\" here."
+end
+
+respond :place, Use.text, Use.visible do |actor, thing, supporter|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see anything called \"#{thing}\" here."
+end
+
+respond :place, Use.text, Use.text do |actor, thing, supporter|
+  actor.tell "I don't know what you mean by \"#{thing}\" or \"#{supporter}.\""
+end
+
+xlate "put :thing on :supporter", "place :thing :supporter"
+xlate "put :thing down on :supporter", "place :thing :supporter"
+xlate "set :thing on :supporter", "place :thing :supporter"
+xlate "set :thing down on :supporter", "place :thing :supporter"
+xlate "drop :thing on :supporter", "place :thing :supporter"
+xlate "place :thing on :supporter", "place :thing :supporter"

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

@@ -0,0 +1,11 @@
+yes_or_no :confirm_quit, "Are you sure you want to quit?" do |actor, input|
+  if input == "yes"
+    actor.cue :concluded
+  else
+    actor.cue :active
+  end
+end
+
+meta :quit do |actor|
+  actor.cue :confirm_quit
+end

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

@@ -0,0 +1,3 @@
+respond :read, Query::Visible.new do |actor, thing|
+  actor.perform :look, thing
+end

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

@@ -0,0 +1,39 @@
+respond :search, Use.reachable(Receptacle) do |actor, receptacle|
+  # TODO Show the contents of the receptacle
+  contents = receptacle.children.that_are_not(:attached?)
+  if contents.length > 0
+    actor.tell "Inside #{contents.length > 1 ? 'are' : 'is'} #{contents.join_and}."
+  else
+    actor.tell "#{The receptacle} #{receptacle.verb.be} empty."
+  end
+end
+
+respond :search, Use.reachable(Container) do |actor, container|
+  if container.open? or container.transparent?
+    actor.proceed
+  else
+    actor.tell "#{The container} #{container.verb.be} closed."
+  end
+end
+
+respond :search, Use.reachable do |actor, thing|
+  actor.perform :look, thing
+end
+
+respond :search, Use.room do |actor, room|
+  actor.perform :look, room
+end
+
+respond :search, Use.reachable do |actor, entity|
+  attached = entity.children.that_are(:attached?).that_are(Container)
+  if attached.length > 1
+    actor.tell "#{you.pronoun.Subj} #{you.verb.can} search #{attached.join_or}"
+  elsif attached.length == 1
+    actor.perform :search, attached[0]
+  else
+    actor.proceed
+  end
+end
+
+interpret "look in :thing", "search :thing"
+interpret "look inside :thing", "search :thing"

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

@@ -0,0 +1,13 @@
+respond :show, Use.reachable(Character), Use.children do |actor, character, thing|
+  actor.tell "#{The character} isn't interested in #{the thing}."
+end
+
+respond :show, Use.reachable, Use.children do |actor, witness, thing|
+  actor.tell "Nothing happens."
+end
+
+respond :show, Use.children, Use.text do |actor, thing, text|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any \"#{text}\" here."
+end
+
+interpret "show :thing to :character", "show :character :thing"

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

@@ -0,0 +1,49 @@
+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}."
+end
+
+respond :take, Use.reachable(Entity, :portable?) do |actor, thing|
+  if thing.parent == actor
+    actor.tell "#{you.contract(you.pronoun.subj + ' are').cap_first} already carrying #{the thing}."
+  else
+    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
+  end
+end
+
+respond :take, Use.reachable(Gamefic::Rubble) do |actor, rubble|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} have any use for #{the rubble}."
+end
+
+respond :take, Use.text do |actor, text|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any \"#{text}\" here."
+end
+
+interpret "get :thing", "take :thing"
+interpret "pick up :thing", "take :thing"
+interpret "pick :thing up", "take :thing"
+interpret "carry :thing", "take :thing"