gamefic 0.1.1 → 0.2.0

data/lib/gamefic/import/basics/actions/drop.rb

@@ -0,0 +1,30 @@
+respond :drop, Query::Visible.new() do |actor, thing|
+  actor.tell "You're not carrying #{the thing}."
+end
+
+respond :drop, Query::Children.new() do |actor, thing|
+  thing.parent = actor.parent
+  actor.tell "You drop #{the thing}.", true
+end
+
+xlate "put down :thing", :drop, :thing
+xlate "put :thing down", :drop, :thing
+
+#respond :drop, Query::Family.new(Thing), Query::Reachable.new(Thing) do |actor, thing, supporter|
+#  actor.tell "You're not carrying #{thing}."
+#end
+#respond :drop, Query::Text.new(), Query::Text.new() do |actor, thing, supporter|
+#  actor.tell "You don't see anything called '#{thing}.'"
+#end
+#respond :drop, Query::Children.new(Thing), Query::Visible.new(Thing) do |actor, thing, target|
+#  if actor.parent != target.parent
+#    if actor.is?(:supported) or actor.is?(:container)
+#      actor.tell "You can't reach #{the target} from #{the actor.parent}."
+#      next
+#    end
+#  end
+#  passthru
+#end
+#respond :drop, Query::Children.new(Thing), Query::Text.new() do |actor, thing, supporter|
+#  actor.tell "You don't see anything called '#{supporter}.'"
+#end

data/lib/gamefic/import/basics/actions/enter.rb

@@ -0,0 +1,16 @@
+respond :enter, Query::Siblings.new(Supporter, :enterable) do |actor, supporter|
+  actor.parent = supporter
+  actor.tell "You get on #{the supporter}."
+end
+respond :enter, Query::Siblings.new(Container, :enterable) do |actor, container|
+  actor.parent = container
+  actor.tell "You get in #{the container}."
+end
+respond :enter, Query::Siblings.new(Thing) do |actor, thing|
+  actor.tell "#{The thing} can't accommodate you."
+end
+xlate "sit :thing", :enter, :thing
+xlate "sit on :thing", :enter, :thing
+xlate "get on :thing", :enter, :thing
+xlate "get in :thing", :enter, :thing
+xlate "stand on :thing", :enter, :thing

data/lib/gamefic/import/basics/actions/{traversal.rb → go.rb}

@@ -1,35 +1,35 @@
-respond :go, Query.new(:siblings, Portal) do |actor, portal|
-  actor.parent = portal.destination
-  actor.tell "You go #{portal.name}."
-  actor.perform "itemize room"
-end
-
-respond :go, String do |actor, string|
-  actor.tell "You don't see any exit \"#{string}\" from here."
-end
-
-respond :go do |actor|
-  actor.tell "Where do you want to go?"
-end
-
-xlate "north", :go, "north"
-xlate "south", :go, "south"
-xlate "west", :go, "west"
-xlate "east", :go, "east"
-xlate "up", :go, "up"
-xlate "down", :go, "down"
-xlate "northwest", :go, "northwest"
-xlate "northeast", :go, "northeast"
-xlate "southwest", :go, "southwest"
-xlate "southeast", :go, "southeast"
-
-xlate "n", :go, "north"
-xlate "s", :go, "south"
-xlate "w", :go, "west"
-xlate "e", :go, "east"
-xlate "u", :go, "up"
-xlate "d", :go, "down"
-xlate "nw", :go, "northwest"
-xlate "ne", :go, "northeast"
-xlate "sw", :go, "southwest"
-xlate "se", :go, "southeast"
+respond :go, Query::Siblings.new(Portal) do |actor, portal|
+  actor.parent = portal.destination
+  actor.tell "You go #{portal.name}."
+  actor.perform "look"
+end
+
+respond :go, Query::Text.new() do |actor, string|
+  actor.tell "You don't see any exit \"#{string}\" from here."
+end
+
+respond :go do |actor|
+  actor.tell "Where do you want to go?"
+end
+
+xlate "north", :go, "north"
+xlate "south", :go, "south"
+xlate "west", :go, "west"
+xlate "east", :go, "east"
+xlate "up", :go, "up"
+xlate "down", :go, "down"
+xlate "northwest", :go, "northwest"
+xlate "northeast", :go, "northeast"
+xlate "southwest", :go, "southwest"
+xlate "southeast", :go, "southeast"
+
+xlate "n", :go, "north"
+xlate "s", :go, "south"
+xlate "w", :go, "west"
+xlate "e", :go, "east"
+xlate "u", :go, "up"
+xlate "d", :go, "down"
+xlate "nw", :go, "northwest"
+xlate "ne", :go, "northeast"
+xlate "sw", :go, "southwest"
+xlate "se", :go, "southeast"

data/lib/gamefic/import/basics/actions/inventory.rb

@@ -1,49 +1,8 @@
-respond :inventory do |actor|
-  if actor.children.length > 0
-    actor.tell actor.children.join(', ')
-  else
-    actor.tell "You aren't carrying anything."
-  end
-end
-xlate "i", :inventory
-
-respond :take, Query.new(:siblings, Portable) do |actor, thing|
-  thing.parent = actor
-  actor.tell "You take #{thing.longname.specify}.", true
-end
-
-respond :take, Query.new(:siblings) do |actor, thing|
-  actor.tell "You can't carry #{thing.longname.specify}."
-end
-
-respond :take, Query.new(:string) do |actor, thing|
-  containers = actor.children.that_are(Container)
-  containers = containers + actor.parent.children.that_are(Container)
-  found = false
-  containers.each { |container|
-    if container.closed? == false
-      query = Query.new(:children, Portable)
-      result = query.execute(container, thing)
-      if result.objects.length == 1
-        found = true
-        actor.perform "take #{result.objects[0].longname} from #{container.longname}"
-        break
-      end
-    end
-  }
-  if found == false
-    actor.tell "You don't see any \"#{thing}\" here."
-  end
-end
-
-respond :drop, Query.new(:children) do |actor, thing|
-  thing.parent = actor.parent
-  actor.tell "You drop #{thing.longname.specify}.", true
-end
-
-xlate "get :thing", :take, :thing
-xlate "pick :thing up", :take, :thing
-xlate "pick up :thing", :take, :thing
-
-xlate "put down :thing", :drop, :thing
-xlate "put :thing down", :drop, :thing
+respond :inventory do |actor|
+  if actor.children.length > 0
+    actor.tell actor.children.join(', ')
+  else
+    actor.tell "You aren't carrying anything."
+  end
+end
+xlate "i", :inventory

data/lib/gamefic/import/basics/actions/leave.rb

@@ -0,0 +1,29 @@
+respond :leave, Query::Parent.new(Supporter) do |actor, supporter|
+  actor.parent = supporter.parent
+  actor.tell "You get off #{the supporter}."
+end
+respond :leave, Query::Parent.new(Container) do |actor, supporter|
+  actor.parent = supporter.parent
+  actor.tell "You get out of #{the supporter}."
+end
+respond :leave, Query::Parent.new(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.perform "go #{portals[0]}"
+  else
+    actor.tell "I don't know which way you want to go: #{portals.join_and(', ', ' or ')}."
+  end
+end
+respond :leave do |actor|
+  actor.perform "leave #{actor.parent}"
+end
+xlate "exit :supporter", :leave, :supporter
+xlate "get off :supporter", :leave, :supporter
+xlate "get up from :supporter", :leave, :supporter
+xlate "get up", :leave
+xlate "stand", :leave
+xlate "get off", :leave
+xlate "get out :container", :leave, :container
+xlate "get out of :container", :leave, :container

data/lib/gamefic/import/basics/actions/look-in-at.rb

@@ -0,0 +1,27 @@
+respond :look_in_at, Query::Text.new(), Query::Text.new() do |actor, container, thing|
+  actor.tell "You don't see any '#{container}' here."
+end
+
+respond :look_in_at, Query::Reachable.new(), Query::Text.new() do |actor, container, thing|
+  actor.tell "You don't see any '#{thing}' in #{the container}."
+end
+
+respond :look_in_at, Query::Reachable.new(), Query::Subquery.new() do |actor, container, thing|
+  if thing.is?(:supported) or thing.is?(:attached) or ( thing.is?(:contained) and (container.is?(:open) or container.is?(:transparent)) )
+    actor.perform "look #{thing}"
+  elsif container.is?(:closed)
+    actor.tell "#{The container} is closed."
+  else
+    passthru
+  end
+end
+
+xlate "look in :container at :thing", :look_in_at, :container, :thing
+xlate "l in :container at :thing", :look_in_at, :container, :thing
+
+xlate "look :thing in :container", :look_in_at, :container, :thing
+xlate "look at :thing in :container", :look_in_at, :container, :thing
+xlate "l :thing in :container", :look_in_at, :container, :thing
+xlate "examine :thing in :container", :look_in_at, :container, :thing
+xlate "exam :thing in :container", :look_in_at, :container, :thing
+xlate "x :thing in :container", :look_in_at, :container, :thing

data/lib/gamefic/import/basics/actions/look-under.rb

@@ -0,0 +1,3 @@
+respond :look_under, Query::Reachable.new() do |actor, thing|
+  actor.tell "There's nothing to see under #{the thing}."
+end

data/lib/gamefic/import/basics/actions/look.rb

@@ -1,67 +1,71 @@
-respond :look do |actor|
-  actor.perform "itemize room full"
-end
-
-respond :look_around do |actor|
-  actor.perform "look"
-end
-
-respond :itemize_room, Query.new(:string) do |actor, option|
-  actor.tell "## #{actor.parent.longname.cap_first}"
-  if option == "full"
-    actor.tell actor.parent.description
-  end
-  chars = actor.parent.children.that_are(Character) - [actor]
-  if chars.length > 0
-    actor.tell "Others here: #{chars.join(", ")}"
-  end
-  #items = actor.parent.children.that_are(Itemized) - [chars] - [actor] - actor.parent.children.that_are(Portal)
-  items = actor.parent.children.that_are(Itemized)
-  if items.length > 0
-    actor.tell "Visible items: #{items.join(", ")}"
-  end
-  portals = actor.parent.children.that_are(Portal)
-  if portals.length > 0
-    actor.tell "Obvious exits: #{portals.join(', ')}"
-  else
-    actor.tell "Obvious exits: none"	
-  end
-end
-xlate "itemize room", :itemize_room, "short"
-xlate "itemize room :option", :itemize_room, :option
-
-respond :look, Query.new(:family) do |actor, thing|
-  actor.tell thing.description
-end
-
-respond :look, Query.new(:parent) do |actor, thing|
-  actor.perform "look"
-end
-
-respond :look, String do |actor, string|
-  containers = actor.children.that_are(Container)
-  containers = containers + actor.parent.children.that_are(Container)
-  found = false
-  containers.each { |container|
-    if container.closed? == false
-      query = Query.new(:children, Portable)
-      result = query.execute(container, string)
-      if result.objects.length == 1
-        found = true
-        actor.tell "You look at #{result.objects[0].longname.specify} in #{container.longname.specify}."
-        actor.perform "look #{result.objects[0].longname} in #{container.longname}"
-        break
-      end
-    end
-  }
-  if found == false
-    actor.tell "You don't see any \"#{string}\" here."
-  end
-end
-
-xlate "look at :thing", :look, :thing
-xlate "l", :look
-xlate "l :thing", :look, :thing
-xlate "examine :thing", :look, :thing
-xlate "exam :thing", :look, :thing
-xlate "x :thing", :look, :thing
+respond :look, Query::Parent.new(Supporter) do |actor, supporter|
+  actor.tell supporter.description
+  actor.tell "You are currently on #{the supporter}."
+end
+
+respond :look, Query::Room.new(Room) do |actor, room|
+  actor.tell room.name.cap_first
+  actor.tell room.description
+  chars = room.children.that_are(Character) - [actor]
+  if chars.length > 0
+    actor.tell "Others here: #{chars.join(", ")}"
+  end
+  items = room.children.that_are(:itemized) - [actor]
+  if items.length > 0
+    actor.tell "You see #{items.join_and}."
+  end
+  portals = room.children.that_are(Portal)
+  if portals.length > 0
+    if portals.length == 1
+      actor.tell "There is an exit #{portals[0]}."
+    else
+      actor.tell "There are exits #{portals.join_and(', ')}."
+    end
+  end
+  if actor.is? :supported
+    actor.tell "You are on #{the actor.parent}."
+    actor.parent.children.that_are(:supported).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, Query::Text.new() do |actor, string|
+  actor.tell "You don't see any \"#{string}\" here."
+end
+
+respond :look, Query::Reachable.new(Container) do |actor, container|
+  passthru
+  if container.is? :openable
+    actor.tell "#{The container} is #{container.is?(:open) ? 'open' : 'closed'}."
+  end
+  if container.is? :open
+    contents = container.children.that_are(:contained)
+    contents.each { |thing|
+      actor.tell "You see #{a thing} inside #{the container}."
+    }
+  end
+end
+
+respond :look, Query::Siblings.new(Supporter) do |actor, supporter|
+  passthru
+  supported = supporter.children.that_are(:supported)
+  supported.each { |thing|
+    actor.tell "You see #{a thing} sitting there."
+  }
+end
+
+xlate "look at :thing", :look, :thing
+xlate "l :thing", :look, :thing
+xlate "examine :thing", :look, :thing
+xlate "x :thing", :look, :thing
+xlate "search :thing", :look, :thing

data/lib/gamefic/import/basics/actions/nil.rb

@@ -0,0 +1,25 @@
+respond 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|
+      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
+      actor.tell "I'm not sure if #{words[0]} means #{found.join_and(', ', ' or ')}."
+    else
+      actor.tell "I don't know what you mean by '#{string}.'"
+    end
+  end
+end

data/lib/gamefic/import/basics/actions/open.rb

@@ -0,0 +1,23 @@
+respond :open, Query::Text.new() do |actor, string|
+  actor.tell "You don't see any \"#{string}\" here."
+end
+
+respond :open, Query::Reachable.new(Entity) do |actor, thing|
+  actor.tell "You can't open #{the thing}."
+end
+
+respond :open, Query::Reachable.new(Container, :openable) do |actor, container|
+  # Portable containers need to be picked up before they are opened.
+  if container.is? :portable
+    actor.perform "take #{container}"
+    if container.parent != actor
+      break
+    end
+  end
+  if container.is? :closed
+    actor.tell "You open #{the container}."
+    container.is :open
+  else
+    actor.tell "It's already open."
+  end
+end

data/lib/gamefic/import/basics/actions/quit.rb

@@ -0,0 +1,3 @@
+meta :quit do |actor|
+  actor.state = GameOverState.new(actor)
+end

data/lib/gamefic/import/basics/actions/take.rb

@@ -0,0 +1,107 @@
+respond :take, Query::Text.new() do |actor, thing|
+  actor.tell "I don't see anything called '#{thing}' here."
+end
+
+respond :take, Query::Reachable.new(:not_portable) do |actor, thing|
+  actor.tell "You can't take #{the thing}."
+end
+
+respond :take, Query::Siblings.new(:portable) do |actor, thing|
+  thing.parent = actor
+  actor.tell "You take #{the thing}."
+end
+
+respond :take, Query::Siblings.new() do |actor, thing|
+  actor.tell "You can't carry #{the thing}."
+end
+
+respond :take, Query::Visible.new() do |actor, thing|
+  if thing.parent == actor.parent
+    passthru
+  elsif thing.parent.is?(:closed)
+    actor.tell "#{The thing} is inside #{the thing.parent}, which is closed."
+  end
+end
+
+respond :take, Query::Visible.new() do |actor, thing|
+  if actor.is? :supported
+    if actor.parent != thing.parent and actor.parent != thing.parent.parent
+      actor.tell "You can't reach it from #{the actor.parent}."
+    end
+  else
+    passthru
+  end
+end
+
+respond :take, Query::Reachable.new(:attached) do |actor, thing|
+  actor.tell "#{The thing} is attached to #{the thing.parent}."
+end
+
+respond :take, Query::Reachable.new(:portable, :contained) do |actor, thing|
+  if thing.parent != actor.parent
+    if thing.parent.is?(:open) == false
+      if thing.parent.is?(:transparent)
+        actor.tell "#{The thing} is closed."
+      else
+        passthru
+      end
+      break
+    end
+    actor.tell "You take #{the thing} from #{the thing.parent}."
+    thing.parent = actor
+  else
+    passthru
+  end
+end
+
+respond :take, Query::Reachable.new(:portable, :supported) do |actor, thing|
+  actor.tell "You take #{the thing} from #{the thing.parent}."
+  thing.parent = actor
+end
+
+respond :take, Query::Children.new() do |actor, thing|
+  actor.tell "You're already carrying #{the thing}."
+end
+
+xlate "get :thing", :take, :thing
+xlate "pick up :thing", :take, :thing
+xlate "pick :thing up", :take, :thing
+
+# The :take_from actions make it a little easier to disambiguate things. For
+# example, if there's a green key in the room and a red key in a box, any of
+# the following will understand which key you mean:
+#   * take green key
+#   * take red key
+#   * take key from room
+#   * take key from box
+respond :take_from, Query::Room.new(), Query::Siblings.new() do |actor, container, thing|
+  actor.perform "take #{thing}"
+end
+respond :take_from, Query::Reachable.new(Container, :closed), Query::Text.new() do |actor, container, thing|
+  actor.tell "#{The container} is closed."
+end
+respond :take_from, Query::Reachable.new(Container, :open), Query::Subquery.new(:contained) do |actor, container, thing|
+  actor.perform "take #{thing}"
+end
+respond :take_from, Query::Reachable.new(Container, :open), Query::Subquery.new(:attached) do |actor, container, thing|
+  actor.tell "#{The thing} is attached to #{the container}."
+end
+respond :take_from, Query::Reachable.new(Supporter), Query::Subquery.new(:supported) do |actor, container, thing|
+  actor.perform "take #{thing}"
+end
+xlate "take :thing from :container", :take_from, :container, :thing
+xlate "get :thing from :container", :take_from, :container, :thing
+xlate "pick :thing up from :container", :take_from, :container, :thing
+xlate "pick up :thing from :container", :take_from, :container, :thing
+xlate "take :thing in :container", :take_from, :container, :thing
+xlate "get :thing in :container", :take_from, :container, :thing
+xlate "pick :thing up in :container", :take_from, :container, :thing
+xlate "pick up :thing in :container", :take_from, :container, :thing
+xlate "take :thing on :container", :take_from, :container, :thing
+xlate "get :thing on :container", :take_from, :container, :thing
+xlate "pick :thing up on :container", :take_from, :container, :thing
+xlate "pick up :thing on :container", :take_from, :container, :thing
+xlate "take :thing inside :container", :take_from, :container, :thing
+xlate "get :thing inside :container", :take_from, :container, :thing
+xlate "pick :thing up inside :container", :take_from, :container, :thing
+xlate "pick up :thing inside :container", :take_from, :container, :thing

data/lib/gamefic/import/basics/entities/container.rb

@@ -1,24 +1,8 @@
-import 'basics/entities/itemized'
-
-class Container < Entity
-  include Itemized
-  def closeable=(bool)
-    @closeable = bool
-  end
-  def closeable?
-    @closeable ||= false
-    if (@closeable == true && @closed == nil)
-      @closed = false
-    end
-    @closeable
-  end
-  def closed?
-    (@closed == true)
-  end
-  def closed=(bool)
-    if bool == true
-      @closeable = true
-    end
-    @closed = bool
-  end
-end
+class Container < Thing
+
+end
+
+options(Container, :not_enterable, :enterable)
+options(Container, :opaque, :transparent)
+options(Container, :open, :closed).default = :open
+options(Container, :openable, :unopenable).default = :unopenable

data/lib/gamefic/import/basics/entities/entity.rb

@@ -0,0 +1,11 @@
+class Entity
+  def room
+    p = parent
+    while !p.kind_of?(Room) and !p.nil?
+      p = p.parent
+    end
+    p
+  end
+end
+
+options(Entity, :not_portable, :portable)

data/lib/gamefic/import/basics/entities/fixture.rb

@@ -1,5 +1,5 @@
-import 'basics/entities/itemized'
-
-class Fixture < Entity
-  include Itemized
-end
+class Fixture < Thing
+
+end
+
+set_default_for(Fixture, :not_portable)

data/lib/gamefic/import/basics/entities/item.rb

@@ -1,7 +1,5 @@
-import 'basics/entities/itemized'
-import 'basics/entities/portable'
-
-class Item < Entity
-  include Itemized
-  include Portable
-end
+class Item < Thing
+
+end
+
+set_default_for(Item, :portable)