gamefic-sdk 1.0.0 → 1.0.1

data/scripts/standard/modules/darkenable.plot.rb

@@ -0,0 +1,6 @@
+module Gamefic::Darkenable
+  attr_writer :dark
+  def dark?
+    @dark ||= false
+  end
+end

data/scripts/standard/modules/enterable.plot.rb

@@ -0,0 +1,15 @@
+module Gamefic::Enterable
+  attr_writer :enterable, :leave_verb, :enter_verb, :inside_verb
+  def enterable?
+    @enterable ||= false
+  end
+  def inside_verb
+    @inside_verb ||= "be in"
+  end
+  def enter_verb
+    @enter_verb ||= "enter"
+  end
+  def leave_verb
+    @leave_verb ||= "leave"
+  end
+end

data/scripts/standard/modules/explicit_exits.plot.rb

@@ -0,0 +1,15 @@
+module Gamefic::ExplicitExits
+  attr_writer :explicit_exits
+  def explicit_exits?
+    @explicit_exits ||= ExplicitExits.default
+  end
+  def self.default
+    if @default.nil?
+      @default = true
+    end
+    @default
+  end
+  def self.default=(bool)
+    @default = bool
+  end
+end

data/scripts/standard/modules/itemizable.plot.rb

@@ -0,0 +1,18 @@
+module Gamefic::Itemizable
+  attr_writer :itemized
+  def itemized?
+    if @itemized.nil?
+      @itemized = Itemizable.default
+    end
+    @itemized
+  end
+  def self.default
+    if @default.nil?
+      @default = true
+    end
+    @default
+  end
+  def self.default=(bool)
+    @default = bool
+  end
+end

data/scripts/standard/modules/lockable.plot.rb

@@ -0,0 +1,25 @@
+script 'standard/modules/openable'
+
+module Gamefic::Lockable
+  include Openable
+  attr_reader :lock_key
+  def locked=(bool)
+    @locked = bool
+    if @locked == true
+      self.open = false
+    end
+  end
+  def open=(bool)
+    @open = bool
+    @locked = false if @open == true
+  end
+  def locked?
+    @locked ||= false
+  end
+  def has_lock_key?
+    !@lock_key.nil?
+  end
+  def lock_key=(entity)
+    @lock_key = entity
+  end
+end

data/scripts/standard/modules/openable.plot.rb

@@ -0,0 +1,9 @@
+module Gamefic::Openable
+  attr_writer :open, :openable
+  def open?
+    @open ||= false
+  end
+  def closed?
+    !open?
+  end
+end

data/scripts/standard/modules/parent-room.plot.rb

@@ -0,0 +1,9 @@
+module Gamefic::ParentRoom
+  def room
+    p = parent
+    while !p.kind_of?(Room) and !p.nil?
+      p = p.parent
+    end
+    p
+  end
+end

data/scripts/standard/modules/portable.plot.rb

@@ -0,0 +1,6 @@
+module Gamefic::Portable
+  attr_writer :portable
+  def portable?
+    @portable ||= false
+  end
+end

data/scripts/standard/modules/transparent.plot.rb

@@ -0,0 +1,6 @@
+module Gamefic::Transparent
+  attr_writer :transparent
+  def transparent?
+    @transparent ||= false
+  end
+end

data/scripts/standard/pathfinder.plot.rb

@@ -0,0 +1,60 @@
+# Pathfinders provide the shortest route between two locations. The
+# destination needs to be accessible from the origin through portals. Note
+# that Pathfinders do not take into account portals that characters cannot
+# traverse, such as locked doors.
+#
+class Gamefic::Pathfinder
+  # @return [Room]
+  attr_reader :origin
+  # @return [Room]
+  attr_reader :destination
+  
+  def initialize origin, destination
+    @origin = origin
+    @destination = destination
+    @path = nil
+    @paths = [[@origin]]
+    @visited = []
+    if @origin == @destination
+      @path = []
+    else
+      while @path.nil? and @paths.length > 0
+        embark
+      end
+    end
+  end
+  # @return [Array<Room>]
+  def path
+    # @path is nil if the path is invalid, but #path should return an empty
+    # array instead.
+    @path || []
+  end
+  # @return [Boolean]
+  def valid?
+    path.length > 0 or origin == destination
+  end
+  private
+  def embark
+    new_paths = []
+    @paths.each { |path|
+      last = path.last
+      portals = last.children.that_are(Portal)
+      portals.each { |portal|
+        new_path = path.clone
+        if !@visited.include?(portal.destination)
+          new_path.push portal.destination
+          @visited.push portal.destination
+          if portal.destination == @destination
+            @path = new_path
+            @path.shift
+            break
+          end
+          new_paths.push new_path
+        end
+      }
+      path.push nil
+    }
+    @paths += new_paths
+    @paths.delete_if{|path| path.last.nil?}
+  end
+end

data/scripts/standard/plural.plot.rb

@@ -0,0 +1,2 @@
+script 'standard/plural/queries'
+script 'standard/plural/actions'

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

@@ -0,0 +1,4 @@
+script 'standard/plural/actions/drop'
+script 'standard/plural/actions/insert'
+script 'standard/plural/actions/place'
+script 'standard/plural/actions/take'

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

@@ -0,0 +1,126 @@
+respond :drop, Use.many_children do |actor, things|
+  dropped = []
+  things.each { |thing|
+    buffer = actor.quietly :drop, thing
+    if thing.parent == actor
+      actor.tell buffer
+    else
+      dropped.push thing
+    end
+  }
+  if dropped.length > 0
+    actor.tell "#{you.pronoun.Subj} drop #{dropped.join_and}."
+  end
+end
+
+respond :drop, Use.text("all", "everything") do |actor, text|
+  children = actor.children.that_are_not(:attached?)
+  if children.length == 0
+    actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} have anything to drop."
+  else
+    dropped = []
+    children.each { |child|
+      buffer = actor.quietly :drop, child
+      if child.parent != actor
+        dropped.push child
+      else
+        actor.tell buffer
+      end
+    }
+    if dropped.length > 0
+      actor.tell "#{you.pronoun.Subj} drop #{dropped.join_and}."
+    end
+  end
+end
+
+respond :drop, Use.text("all", "everything"), Use.text("but", "except"), Use.children do |actor, text1, text2, exception|
+  children = actor.children.that_are_not(:attached?)
+  if children.length == 0
+    actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} have anything to drop."
+  else
+    dropped = []
+    children.each { |child|
+      next if exception == child
+      buffer = actor.quietly :drop, child
+      if child.parent != actor
+        dropped.push child
+      else
+        actor.tell buffer
+      end
+    }
+    if dropped.length > 0
+      actor.tell "#{you.pronoun.Subj} drop #{dropped.join_and}."
+    end
+  end
+end
+
+respond :drop, Use.text("all", "everything"), Use.text("but", "except"), Use.text do |actor, text1, text2, text3|
+  actor.tell "I understand you want to drop #{text1} but don't know what you're trying to exclude with \"#{text3}.\""
+end
+
+respond :drop, Use.text("all", "everything"), Use.text("but", "except"), Use.many_children do |actor, text1, text2, exceptions|
+  children = actor.children.that_are_not(:attached?)
+  if children.length == 0
+    actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} have anything to drop."
+  else
+    dropped = []
+    children.each { |child|
+      next if exceptions.include?(child)
+      buffer = actor.quietly :drop, child
+      if child.parent != actor
+        dropped.push child
+      else
+        actor.tell buffer
+      end
+    }
+    if dropped.length > 0
+      actor.tell "#{you.pronoun.Subj} drop #{dropped.join_and}."
+    end
+  end
+end
+
+respond :drop, Use.text("all", "everything"), Use.text("but", "except"), Use.plural_children do |actor, text1, text2, exceptions|
+  children = actor.children.that_are_not(:attached?)
+  actor.perform :drop, children - exceptions
+end
+
+respond :drop, Use.text("all", "everything"), Use.text("but", "except"), Use.any_expression, Use.ambiguous_children do |actor, text1, text2, text3, exceptions|
+  children = actor.children.that_are_not(:attached?)
+  actor.perform :drop, children - exceptions
+end
+
+respond :drop, Use.any_expression, Use.ambiguous_children do |actor, text1, things|
+  filtered = things.clone
+  filtered.delete_if{|t| t.parent != actor}
+  if filtered.length == 0
+    actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.be + ' not')} carrying anything that matches your terms."
+  else
+    dropped = []
+    things.each { |thing|
+      if thing.parent == actor
+        buffer = actor.quietly :drop, thing
+        if thing.parent == actor
+          actor.tell buffer
+        else
+          dropped.push thing
+        end
+      end
+    }
+    if dropped.length > 0
+      actor.tell "#{you.pronoun.Subj} #{you.verb.drop} #{dropped.join_and}."
+    end
+  end
+end
+
+respond :drop, Use.any_expression, Use.ambiguous_children, Use.text("except", "but"), Use.any_expression, Use.ambiguous_children do |actor, _, things, _, exceptions|
+  actor.perform :drop, things - exceptions
+end
+
+respond :drop, Use.not_expression, Use.ambiguous_children do |actor, _, exceptions|
+  children = actor.children
+  actor.perform :drop, children - exceptions
+end
+
+respond :drop, Use.plural_children do |actor, things|
+  actor.perform "drop #{things.join(' and ')}"
+end

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

@@ -0,0 +1,68 @@
+respond :insert, Use.text("all", "everything"), Use.reachable(Receptacle) do |actor, text, receptacle|
+  children = actor.children.that_are_not(:attached?)
+  if children.length == 0
+    actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.be + ' not'} carrying anything to put in #{the receptacle}."
+  else
+    inserted = []
+    children.each { |child|
+      buffer = actor.quietly :insert, child, receptacle
+      if child.parent != receptacle
+        actor.tell buffer
+      else
+        inserted.push child
+      end
+    }
+    if inserted.length > 0
+      actor.tell "#{you.pronoun.Subj} put #{inserted.join_and} in #{the receptacle}."
+    end
+  end
+end
+
+respond :insert, Use.many_children, Use.reachable(Receptacle) do |actor, children, receptacle|
+  inserted = []
+  children.each { |child|
+    buffer = actor.quietly :insert, child, receptacle
+    if child.parent != receptacle
+      actor.tell buffer
+    else
+      inserted.push child
+    end
+  }
+  if inserted.length > 0
+    actor.tell "#{you.pronoun.Subj} put #{inserted.join_and} in #{the receptacle}."
+  end
+end
+
+respond :insert, Use.many_children, Use.reachable(Container) do |actor, children, container|
+  if container.open?
+    actor.proceed
+  else
+    actor.tell "#{The container} is closed."
+  end
+end
+
+respond :insert, Use.any_expression, Use.ambiguous_children, Use.reachable(Receptacle) do |actor, _, children, _, receptacle|
+  actor.perform :insert, children, receptacle
+end
+
+respond :insert, Use.any_expression, Use.ambiguous_children, Use.reachable(Receptacle) do |actor, _, children, _, receptacle|
+  actor.perform :insert, children, receptacle
+end
+
+respond :insert, Use.text("everything", "all"), Use.text("except", "but"), Use.ambiguous_children, Use.reachable(Receptacle) do |actor, _, _, exceptions, receptacle|
+  children = Use.children.context_from(actor).that_are_not(:attached?)
+  actor.perform :insert, children - exceptions, receptacle
+end
+
+respond :insert, Use.any_expression, Use.ambiguous_children, Use.reachable(Receptacle) do |actor, _, children, receptacle|
+  actor.perform :insert, children, receptacle
+end
+
+respond :insert, Use.not_expression, Use.ambiguous_children, Use.reachable(Receptacle) do |actor, _, exceptions, receptacle|
+  children = Use.children.context_from(actor).that_are_not(:attached?)
+  actor.perform :insert, children - exceptions, receptacle
+end
+
+respond :insert, Use.plural_children, Use.reachable(Receptacle) do |actor, children, receptacle|
+  actor.perform :insert, children, receptacle
+end

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

@@ -0,0 +1,37 @@
+respond :place, Use.many_children, Use.reachable(Supporter) do |actor, children, supporter|
+  placed = []
+  children.each { |child|
+    buffer = actor.quietly :place, child, supporter
+    if child.parent != supporter
+      actor.tell buffer
+    else
+      placed.push child
+    end
+  }
+  if placed.length > 0
+    actor.tell "You put #{placed.join_and} on #{the supporter}."
+  end
+end
+
+respond :place, Use.any_expression, Use.ambiguous_children, Use.reachable(Supporter) do |actor, _, children, supporter|
+  actor.perform :place, children, supporter
+end
+
+respond :place, Use.text("all", "everything"), Use.reachable(Supporter) do |actor, _, supporter|
+  children = Use.children.context_from(actor).that_are_not(:attached?)
+  actor.perform :place, children, supporter
+end
+
+respond :place, Use.text("all", "everything"), Use.text("except", "but"), Use.ambiguous_children, Use.reachable(Supporter) do |actor, _, _, exceptions, supporter|
+  children = Use.children.context_from(actor).that_are_not(:attached?)
+  actor.perform :place, children - exceptions, supporter
+end
+
+respond :place, Use.not_expression, Use.ambiguous_children, Use.reachable(Supporter) do |actor, _, exceptions, supporter|
+  children = Use.children.context_from(actor).that_are_not(:attached?)
+  actor.perform :place, children - exceptions, supporter
+end
+
+respond :place, Use.plural_children, Use.reachable(Supporter) do |actor, children, supporter|
+  actor.perform :place, children, supporter
+end

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

@@ -0,0 +1,175 @@
+respond :take, Use.many_visible do |actor, things|
+  filtered = things.clone
+  filtered.delete_if{ |t| t.parent == actor }
+  if filtered.length == 0
+    output = "There's nothing to take that matches your terms." + (things.length > 0 ? "(You're already carrying #{things.join_and}.)" : '')
+    actor.tell output
+  else
+    taken = []
+    filtered.each { |thing|
+      buffer = actor.quietly :take, thing
+      if thing.parent != actor
+        actor.tell buffer
+      else
+        taken.push thing
+      end
+    }
+    if taken.length > 0
+      actor.tell "#{you.pronoun.Subj} #{you.verb.take} #{taken.join_and}."
+    end
+  end
+end
+
+respond :take, Use.text("all", "everything") do |actor, text|
+  children = actor.parent.children.that_are_not(:attached?).that_are(:portable?)
+  if actor.parent != actor.room and actor.parent.kind_of?(Supporter)
+    children += actor.room.children.that_are_not(:attached?).that_are(:portable?)
+  end
+  if children.length == 0
+    actor.tell "There's nothing obvious to take."
+  else
+    taken = []
+    children.each { |child|
+      buffer = actor.quietly :take, child
+      if child.parent == actor
+        taken.push child
+      else
+        actor.tell buffer
+      end
+    }
+    if taken.length > 0
+      actor.tell "#{you.pronoun.Subj} #{you.verb.take} #{taken.join_and}."
+    end
+  end
+end
+
+respond :take, Use.text("all", "everything"), Use.text do |actor, text1, text2|
+  actor.tell "I understand that you want to take #{text1} but did not understand \"#{text2}.\""
+end
+
+respond :take, Use.text("all", "everything"), Use.text("but", "except"), Use.visible do |actor, text1, text2, exception|
+  children = actor.parent.children.that_are_not(:attached?).that_are(:portable?)
+  if actor.parent != actor.room and actor.parent.kind_of?(Supporter)
+    children += actor.room.children.that_are_not(:attached?).that_are(:portable?)
+  end
+  if children.length == 0
+    actor.tell "There's nothing obvious to take."
+  else
+    taken = []
+    children.each { |child|
+      next if exception == child
+      buffer = actor.quietly :take, child
+      if child.parent == actor
+        taken.push child
+      else
+        actor.tell buffer
+      end
+    }
+    if taken.length > 0
+      actor.tell "#{you.pronoun.Subj} #{you.verb.take} #{taken.join_and}."
+    end
+  end
+end
+
+respond :take, Use.any_expression, Use.ambiguous_visible(:portable?) do |actor, text, things|
+  filtered = things.clone
+  filtered.delete_if{|t| t.parent == actor}
+  if filtered.length == 0
+    actor.tell "There's nothing to take that matches your terms. (#{you.contract you.pronoun.Subj + ' are'} already carrying #{things.join_and}.)"
+  #elsif filtered.length == 1
+  #  actor.proceed
+  else
+    taken = []
+    filtered.each { |thing|
+      buffer = actor.quietly :take, thing
+      if thing.parent != actor
+        actor.tell buffer
+      else
+        taken.push thing
+      end
+    }
+    if taken.length > 0
+      actor.tell "#{you.pronoun.Subj} #{you.verb.take} #{taken.join_and}."
+    end
+  end
+end
+
+respond :take, Use.any_expression, Use.ambiguous_visible, Use.text("except", "but"), Use.any_expression, Use.ambiguous_visible do |actor, _, things, _, _, exceptions|
+  actor.perform :take, things - exceptions
+end
+
+respond :take, Use.text("all", "everything"), Use.text("but", "except"), Use.many_visible do |actor, text1, text2, exceptions|
+  visible = Use.many_visible.context_from(actor)
+  actor.perform :take, visible - exceptions
+end
+
+respond :take, Use.text("all", "everything"), Use.text("but", "except"), Use.any_expression, Use.ambiguous_visible do |actor, _, _, _, exceptions|
+  visible = Use.many_visible.context_from(actor)
+  actor.perform :take, visible - exceptions
+end
+
+respond :take, Use.text("all", "everything"), Use.text("but", "except"), Use.text do |actor, _, _, exceptions|
+  actor.tell "I don't understand what you're trying to exclude with \"#{exceptions}.\""
+end
+
+respond :take, Use.text("all", "everything"), Use.text("but", "except"), Use.plural_visible do |actor, _, _, exceptions|
+  visible = Use.visible.context_from(actor)
+  actor.perform :take, visible - exceptions
+end
+
+respond :take, Use.any_expression, Use.ambiguous_visible, Use.text("except", "but"), Use.visible do |actor, text1, things, text2, exception|
+  actor.perform :take, things - [exception]
+end
+
+respond :take, Use.any_expression, Use.ambiguous_visible, Use.text("except", "but"), Use.ambiguous_visible do |actor, text1, things, text2, exceptions|
+  actor.perform :take, things - exceptions
+end
+
+respond :take, Use.any_expression, Use.ambiguous_visible, Use.text("except", "but"), Use.plural_visible do |actor, text1, things, text2, exceptions|
+  actor.perform :take, things - exceptions
+end
+
+respond :take, Use.any_expression, Use.ambiguous_visible, Use.text("except", "but"), Use.any_expression, Use.ambiguous_visible do |actor, _, things, _, _, exceptions|
+  actor.perform :take, things - exceptions
+end
+
+respond :take, Use.ambiguous_visible, Use.text("things", "items", "stuff") do |actor, things, _|
+  actor.perform :take, things
+end
+
+respond :take, Use.plural_visible do |actor, things|
+  actor.perform :take, things
+end
+
+respond :take, Use.not_expression, Use.ambiguous_visible do |actor, _, exceptions|
+  visible = Use.visible.context_from(actor)
+  actor.perform :take, visible - exceptions
+end
+
+respond :take, Use.text("all", "everything"), Use.from_expression, Use.reachable(Receptacle) do |actor, _, _, receptacle|
+  children = receptacle.children.that_are_not(:attached?)
+  if children.length == 0
+    actor.tell "There's nothing inside #{the receptacle}."
+  else
+    taken = []
+    children.each { |child|
+      buffer = actor.quietly :take, child
+      if child.parent != actor
+        actor.tell buffer
+      else
+        taken.push child
+      end
+    }
+    if taken.length > 0
+      actor.tell "#{you.pronoun.Subj} #{you.verb.take} #{taken.join_and} from #{the receptacle}."
+    end
+  end
+end
+
+respond :take, Use.text("all","everything"), Use.reachable(Container) do |actor, text, container|
+  if container.open?
+    actor.proceed
+  else
+    actor.tell "#{The container} is closed."
+  end  
+end