gamefic 0.1.1 → 0.2.0

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

@@ -1,43 +1,40 @@
-class Portal < Entity
-  attr_accessor :destination
-  #def initialize
-  #	super
-  #	@destination = nil
-  #end
-  def find_reverse
-    rev = Portal.reverse(self.name)
-    if rev != nil
-      destination.children.that_are(Portal).each { |c|
-        if c.name == rev
-          return c
-        end
-      }
-    end
-  end
-  def self.reverse(direction)
-    case direction.downcase
-      when "north"
-        "south"
-      when "south"
-        "north"
-      when "west"
-        "east"
-      when "east"
-        "west"
-      when "northwest"
-        "southeast"
-      when "southeast"
-        "northwest"
-      when "northeast"
-        "southwest"
-      when "southwest"
-        "northeast"
-      when "up"
-        "down"
-      when "down"
-        "up"
-      else
-        nil
-    end
-  end
-end
+class Portal < Entity
+  attr_accessor :destination
+  def find_reverse
+    rev = Portal.reverse(self.name)
+    if rev != nil
+      destination.children.that_are(Portal).each { |c|
+        if c.name == rev
+          return c
+        end
+      }
+    end
+    nil
+  end
+  def self.reverse(direction)
+    case direction.downcase
+      when "north"
+        "south"
+      when "south"
+        "north"
+      when "west"
+        "east"
+      when "east"
+        "west"
+      when "northwest"
+        "southeast"
+      when "southeast"
+        "northwest"
+      when "northeast"
+        "southwest"
+      when "southwest"
+        "northeast"
+      when "up"
+        "down"
+      when "down"
+        "up"
+      else
+        nil
+    end
+  end
+end

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

@@ -1,24 +1,30 @@
-import 'basics/entities/portal'
-
-class Room < Entity
-  def connect(destination, direction, type = Portal, two_way = true)
-    portal = type.new self.plot, :name => direction, :parent => self, :destination => destination
-    if two_way == true
-      reverse = Portal.reverse(direction)
-      if reverse == nil
-        raise "\"#{direction.cap_first}\" does not have an opposite direction"
-      end
-      portal2 = type.new(self.plot, {
-        :name => reverse,
-        :parent => destination,
-        :destination => self
-      })
-    end
-    portal
-  end
-  def tell(message, refresh = false)
-    children.each { |c|
-      c.tell message, refresh
-    }
-  end
-end
+class Room < Entity
+  def connect(destination, direction, type = Portal, two_way = true)
+    portal = type.new self.plot, :name => direction, :parent => self, :destination => destination
+    portal.proper_named = true
+    if two_way == true
+      reverse = Portal.reverse(direction)
+      if reverse == nil
+        raise "\"#{direction.cap_first}\" does not have an opposite direction"
+      end
+      portal2 = type.new(self.plot, {
+        :name => reverse,
+        :parent => destination,
+        :destination => self
+      })
+      portal2.proper_named = true
+    end
+    portal
+  end
+  def synonyms
+    super.to_s + " around here room"
+  end
+  def tell(message, refresh = false)
+    children.each { |c|
+      c.tell message, refresh
+    }
+  end
+end
+
+options(Room, :lighted, :dark).default = :lighted
+options(Room, :enterable, :not_enterable)

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

@@ -1,3 +1,5 @@
-class Scenery < Entity
-
-end
+class Scenery < Thing
+
+end
+set_default_for(Scenery, :not_portable)
+set_default_for(Scenery, :not_itemized)

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

@@ -0,0 +1,6 @@
+class Supporter < Thing
+
+end
+
+options(Supporter, :not_enterable, :enterable)
+set_default_for(Supporter, :not_portable)

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

@@ -0,0 +1,16 @@
+options(Thing, :located, :contained, :supported, :attached).default = :located
+options(Thing, :itemized, :not_itemized)
+set_default_for(Thing, :portable)
+
+class Thing
+  def parent=(entity)
+    super
+    if parent.kind_of?(Supporter)
+      is :supported
+    elsif parent.kind_of?(Container)
+      is :contained
+    else
+      is :located
+    end
+  end
+end

data/lib/gamefic/import/basics/queries/reachable.rb

@@ -0,0 +1,38 @@
+# This query filters for objects that the player might be able to handle or
+# manipulate, including the following:
+#
+#   * Siblings (other entities with the same parent)
+#   * The subject's children
+#   * Entities on reachable supporters
+#   * Entities in reachable open containers
+#   * Entities attached to reachable entities
+#
+# It excludes anything that may be visible but are not reachable:
+#   * Entities inside closed transparent containers
+#   * Entities that share the same room as the subject, but not the same parent.
+
+class Query::Reachable < Query::Family
+  def context_from(subject)
+    array = super
+    if subject.is?(:supported) or subject.is?(:contained)
+      array.push subject.parent
+    end
+    array.each { |thing|
+      if thing.kind_of?(Container)
+        if thing.is? :open
+          array += thing.children.that_are(:contained)
+        end
+      elsif thing.kind_of?(Supporter)
+        array += thing.children.that_are(:supported)
+      end
+      thing.children.that_are(:attached).each { |att|
+        array.push att
+        if att.kind_of?(Supporter) or att.is?(:open)
+          array += att.children.that_are(:contained)
+          array += att.children.that_are(:supported)
+        end
+      }
+    }
+    array.uniq
+  end
+end

data/lib/gamefic/import/basics/queries/room.rb

@@ -0,0 +1,8 @@
+# This query resolves to the subject's room, as opposed to the parent. It's
+# useful for making sure you target the room instead of a container or a
+# supporter.
+class Query::Room < Query::Parent
+  def context_from(subject)
+    [subject.room]
+  end
+end

data/lib/gamefic/import/basics/queries/visible.rb

@@ -0,0 +1,32 @@
+# This query filters for objects that the player can see, regardless of
+# whether they are reachable. It includes the following:
+#
+#   * Siblings (other entities with the same parent)
+#   * The subject's children
+#   * Children of the subject's room (if room is not parent)
+#   * Entities on reachable supporters
+#   * Entities inside reachable open containers
+#   * Entities inside reachable transparent containers
+#   * Entities attached to reachable entities
+
+class Query::Visible < Query::Family
+  def base_specificity
+    40
+  end
+  def context_from(subject)
+    array = super
+    array += subject.room.children
+    array.uniq!
+    array.each { |thing|
+      if thing.kind_of?(Container)
+        if thing.is? :open or thing.is? :transparent
+          array += thing.children.that_are(:contained)
+        end
+      elsif thing.kind_of?(Supporter)
+        array += thing.children.that_are(:supported)
+      end
+      array += thing.children.that_are(:attached)
+    }
+    array
+  end
+end

data/lib/gamefic/import/basics/rules/has-enough-light.rb

@@ -0,0 +1,14 @@
+assert :has_enough_light do |actor|
+  if actor.room.is? :lighted
+    true
+  else
+    actor.tell "It's too dark in here."
+    false
+  end
+end
+
+# Allow the go command in dark rooms
+before :go, Query::Siblings.new(Portal) do |actor, portal|
+  pass :has_enough_light
+  passthru
+end

data/lib/gamefic/import/{basics → basics.old}/actions/container.rb

@@ -1,11 +1,11 @@
-respond :look, Query.new(:family, Container) do |actor, thing|
+respond :look, Query::Family.new(Container) do |actor, thing|
   passthru
   if thing.closeable?
     actor.tell "#{thing.longname.specify.cap_first} is #{thing.closed? ? 'closed' : 'open'}."
   end
 end
 
-respond :look_inside, Query.new(:family, Container) do |actor, container|
+respond :look_inside, Query::Family.new(Container) do |actor, container|
   if container.closed?
     actor.tell "#{container.longname.cap_first.specify} is closed."
   else
@@ -24,7 +24,7 @@ xlate "look inside :container", :look_inside, :container
 xlate "search :container", :look_inside, :container
 xlate "look in :container", :look_inside, :container
 
-respond :look_in_at, Query.new(:family, Container), Subquery.new(:children, Entity) do |actor, container, item|
+respond :look_in_at, Query::Family.new(Container), Query::Subquery.new(Entity) do |actor, container, item|
   if container.closed?
     actor.tell "#{container.longname.cap_first.specify} is closed."
   else
@@ -32,7 +32,7 @@ respond :look_in_at, Query.new(:family, Container), Subquery.new(:children, Enti
   end
 end
 
-respond :look_in_at, Query.new(:family, Container), Query.new(:string) do |actor, container, item|
+respond :look_in_at, Query::Family.new(Container), Query::Text.new() do |actor, container, item|
   if container.closed?
     actor.tell "#{container.longname.cap_first.specify} is closed."
   else
@@ -43,7 +43,8 @@ end
 xlate "look at :item in :container", :look_in_at, :container, :item
 xlate "look :item in :container", :look_in_at, :container, :item
 
-respond :take_from, Query.new(:family, Container), Subquery.new(:children, Portable) do |actor, container, item|
+respond :take_from, Query::Family.new(Container), Query::Subquery.new(Thing) do |actor, container, item|
+  # TODO: Make sure thing is portable
   if container.closed?
     actor.tell "#{container.longname.cap_first.specify} is closed."
   else
@@ -55,7 +56,7 @@ xlate "take :item from :container", :take_from, :container, :item
 xlate "get :item from :container", :take_from, :container, :item
 xlate "remove :item from :container", :take_from, :container, :item
 
-respond :drop_in, Query.new(:family, Container), Query.new(:children) do |actor, container, item|
+respond :drop_in, Query::Family.new(Container), Query::Children.new() do |actor, container, item|
   if container.closed?
     actor.tell "#{container.longname.cap_first.specify} is closed."
   else
@@ -67,15 +68,15 @@ xlate "drop :item in :container", :drop_in, :container, :item
 xlate "put :item in :container", :drop_in, :container, :item
 xlate "place :item in :container", :drop_in, :container, :item
 
-respond :open, Query.new(:string) do |actor, string|
+respond :open, Query::Text.new() do |actor, string|
   actor.tell "You don't see any \"#{string}\" here."
 end
 
-respond :open, Query.new(:family, Entity) do |actor, thing|
+respond :open, Query::Family.new(Entity) do |actor, thing|
   actor.tell "You can't open #{thing.longname.specify}."
 end
 
-respond :open, Query.new(:family, Container) do |actor, container|
+respond :open, Query::Family.new(Container) do |actor, container|
   if container.closeable?
     if container.closed?
       actor.tell "You open #{container.longname.specify}."
@@ -89,15 +90,15 @@ respond :open, Query.new(:family, Container) do |actor, container|
   end
 end
 
-respond :close, Query.new(:string) do |actor, string|
+respond :close, Query::Text.new() do |actor, string|
   actor.tell "You don't see any \"#{string}\" here."
 end
 
-respond :close, Query.new(:family, Entity) do |actor, thing|
+respond :close, Query::Family.new(Entity) do |actor, thing|
   actor.tell "You can't close #{thing.longname.specify}."
 end
 
-respond :close, Query.new(:family, Container) do |actor, container|
+respond :close, Query::Family.new(Container) do |actor, container|
   if container.closeable?
     if container.closed?
       actor.tell "It's already closed."

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

@@ -0,0 +1,50 @@
+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::Siblings.new(Thing) do |actor, thing|
+  # TODO: Make sure the thing is portable or whatever
+  thing.parent = actor
+  actor.tell "You take #{the thing}.", true
+end
+
+respond :take, Query::Siblings.new() do |actor, thing|
+  actor.tell "You can't carry #{the thing}."
+end
+
+respond :take, Query::Text.new() 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::Children.new(Portable)
+      result = query.execute(container, thing)
+      if result.objects.length == 1
+        found = true
+        actor.perform "take #{result.objects[0].name} from #{container.name}"
+        break
+      end
+    end
+  }
+  if found == false
+    actor.tell "You don't see any \"#{thing}\" here."
+  end
+end
+
+respond :drop, Query::Children.new() do |actor, thing|
+  thing.parent = actor.parent
+  actor.tell "You drop #{the thing}.", 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

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

@@ -0,0 +1,53 @@
+OptionSet.new(Thing, :itemized)
+
+respond :look, Query::Parent.new() do |actor, room|
+  actor.tell actor.parent.name.cap_first
+  actor.tell actor.parent.description
+  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) - [actor]
+  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 "look", :look, "around"
+
+respond :look, Query::Family.new() do |actor, thing|
+  actor.tell thing.description
+end
+
+respond :look, Query::Text.new() 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::Children.new(Portable)
+      result = query.execute(container, string)
+      if result.objects.length == 1
+        found = true
+        actor.tell "You look at #{result.objects[0].name.specify} in #{container.name.specify}."
+        actor.perform "look #{result.objects[0].name} in #{container.name}"
+        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

data/lib/gamefic/import/basics.old/actions/meta.rb

@@ -0,0 +1,6 @@
+meta :quit do |actor|
+  actor.state = GameOverState.new(actor)
+end
+meta :commands do |actor|
+  actor.tell actor.plot.commandwords.sort.join(", ")
+end

data/lib/gamefic/import/basics.old/actions/traversal.rb

@@ -0,0 +1,35 @@
+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.old/entities/container.rb

@@ -0,0 +1,3 @@
+class Container < Thing
+
+end

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

@@ -0,0 +1,3 @@
+class Fixture < Entity
+
+end

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

@@ -0,0 +1,3 @@
+class Item < Thing
+
+end

data/lib/gamefic/import/basics.old/entities/portal.rb

@@ -0,0 +1,43 @@
+class Portal < Entity
+  attr_accessor :destination
+  #def initialize
+  #	super
+  #	@destination = nil
+  #end
+  def find_reverse
+    rev = Portal.reverse(self.name)
+    if rev != nil
+      destination.children.that_are(Portal).each { |c|
+        if c.name == rev
+          return c
+        end
+      }
+    end
+  end
+  def self.reverse(direction)
+    case direction.downcase
+      when "north"
+        "south"
+      when "south"
+        "north"
+      when "west"
+        "east"
+      when "east"
+        "west"
+      when "northwest"
+        "southeast"
+      when "southeast"
+        "northwest"
+      when "northeast"
+        "southwest"
+      when "southwest"
+        "northeast"
+      when "up"
+        "down"
+      when "down"
+        "up"
+      else
+        nil
+    end
+  end
+end

data/lib/gamefic/import/basics.old/entities/room.rb

@@ -0,0 +1,27 @@
+import 'basics/entities/portal'
+
+class Room < Entity
+  def connect(destination, direction, type = Portal, two_way = true)
+    portal = type.new self.plot, :name => direction, :parent => self, :destination => destination
+    if two_way == true
+      reverse = Portal.reverse(direction)
+      if reverse == nil
+        raise "\"#{direction.cap_first}\" does not have an opposite direction"
+      end
+      portal2 = type.new(self.plot, {
+        :name => reverse,
+        :parent => destination,
+        :destination => self
+      })
+    end
+    portal
+  end
+  def synonyms
+    super.to_s + " around"
+  end
+  def tell(message, refresh = false)
+    children.each { |c|
+      c.tell message, refresh
+    }
+  end
+end

data/lib/gamefic/import/basics.old/entities/scenery.rb

@@ -0,0 +1,3 @@
+class Scenery < Entity
+
+end

data/lib/gamefic/import/basics.old/entities/supporter.rb

@@ -0,0 +1,3 @@
+class Supporter < Thing
+
+end

data/lib/gamefic/import/basics.old/room_modes.rb

@@ -0,0 +1,48 @@
+module RoomModes
+  attr_writer :description_mode
+  def description_seen
+    @description_seen ||= Array.new
+  end
+  def description_seen=(value)
+    if value.kind_of?(Array)
+      @description_seen = value
+    else
+      raise "Character#description_seen must be an Array"
+    end
+  end
+  def description_mode
+    @description_mode ||= "verbose"
+  end
+end
+
+class Character
+  include RoomModes
+end
+
+respond :go, Query::Siblings.new(Portal) do |actor, portal|
+  actor.tell "You go #{portal.name}."
+  actor.parent = portal.destination
+  if actor.description_mode == "superbrief" or (actor.description_mode == "brief" and actor.description_seen.include?(actor.parent))
+    actor.tell actor.parent.longname.cap_first
+  else
+    actor.perform "look"
+  end
+  if actor.description_seen.include?(actor.parent) == false
+    actor.description_seen.push actor.parent
+  end
+end
+
+respond :brief do |actor|
+  actor.description_mode = "brief"
+  actor.tell "You are now in BRIEF mode. Detailed descriptions of rooms will only be displayed the first time you visit them. Other options are SUPERBRIEF and VERBOSE."
+end
+
+respond :verbose do |actor|
+  actor.description_mode = "verbose"
+  actor.tell "You are now in VERBOSE mode. Detailed descriptions will be displayed every time you enter a room. Other options are BRIEF and SUPERBRIEF."
+end
+
+respond :superbrief do |actor|
+  actor.description_mode = "superbrief"
+  actor.tell "You are now in SUPERBRIEF mode. Detailed room descriptions will never be displayed unless you LOOK AROUND. Other options are BRIEF and VERBOSE."
+end

data/lib/gamefic/import/basics.rb

@@ -1,2 +1,6 @@
-import 'basics/entities'
-import 'basics/*'
+import 'basics/entities/entity'
+import 'basics/entities/thing'
+import 'basics/entities/*'
+import 'basics/queries/*'
+import 'basics/actions/*'
+import 'basics/rules/*'