gamefic-sdk 1.6.0 → 1.7.0

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

@@ -1,25 +0,0 @@
-respond :use, Use.family do |actor, tool|
-  actor.tell "I don't know how to use #{the tool}. (A more specific command might work.)"
-end
-
-respond :use, Gamefic::Query::Text.new do |actor, thing|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any '#{thing}' #{you.pronoun.subj} can use here."
-end
-
-respond :use, Use.family, Use.family do |actor, tool, object|
-  actor.tell "#{you.contract you.pronoun.Subj + ' ' + you.verb.be} not carrying the #{tool}."
-end
-
-respond :use, Gamefic::Query::Children.new, Gamefic::Query::Text.new do |actor, tool, object|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any '#{object}' here."
-end
-
-respond :use, Query::Text.new, Use.family do |actor, tool, object|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} have anything called '#{tool}.'"
-end
-
-respond :use, Query::Children.new, Use.family do |actor, tool, object|
-  actor.tell "I don't know how to use #{the tool} on #{the object}. (A more specific command might work.)"
-end
-
-xlate "use :tool on :object", "use :tool :object"

data/scripts/standard/entities/container.plot.rb

@@ -1,8 +0,0 @@
-script 'standard/entities/receptacle'
-
-class Container < Receptacle
-  include Enterable
-  include Openable
-  include Lockable
-  include Transparent
-end

data/scripts/standard/entities/door.plot.rb

@@ -1,51 +0,0 @@
-script 'standard/entities/portal'
-
-class Door < Portal
-  include Openable
-  include Lockable
-  
-  def post_initialize
-    super
-    if @name.nil? and !@direction.nil?
-      proper_named = false
-      rev = @direction.reverse
-      self.name = "the #{@direction.adjective} door"
-    end
-  end
-  def open=(bool)
-    super
-    rev = find_reverse
-    if !rev.nil? and rev.open? != bool
-      rev.open = bool
-    end
-  end
-  def locked=(bool)
-    super
-    rev = find_reverse
-    if !rev.nil? and rev.locked? != bool
-      rev.locked = bool
-    end
-  end
-  def automatic=(bool)
-    @automatic = bool
-    rev = find_reverse
-    if !rev.nil? and rev.automatic? != bool
-      rev.automatic = bool
-    end
-  end
-  # HACK Even though Door includes Lockable, we need
-  # to add the lock_key definitions here for Opal.
-  def lock_key
-    @lock_key
-  end
-  def lock_key=(entity)
-    @lock_key = entity
-    rev = find_reverse
-    if !rev.nil? and rev.lock_key != entity
-      rev.lock_key = entity
-    end
-  end
-  def automatic?
-    @automatic ||= true
-  end
-end

data/scripts/standard/entities/entity.plot.rb

@@ -1,12 +0,0 @@
-class Gamefic::Entity
-  include Portable
-  include Itemizable
-  include ParentRoom
-  include Attachable
-
-  attr_writer :locale_description
-  
-  def locale_description
-    @locale_description ||= ""
-  end
-end

data/scripts/standard/entities/exterior.plot.rb

@@ -1,5 +0,0 @@
-script 'standard/entities/room'
-
-class Exterior < Room
-  
-end

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

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

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

@@ -1,25 +0,0 @@
-script 'standard/modules/openable'
-
-module 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

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

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

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

data/scripts/standard/plural.plot.rb

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

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

@@ -1,4 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

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

@@ -1,37 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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