gamefic 0.2.0 → 0.6.0

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

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

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

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

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

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

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

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

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

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

@@ -1,11 +0,0 @@
-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 +0,0 @@
-class Fixture < Thing
-
-end
-
-set_default_for(Fixture, :not_portable)

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

@@ -1,5 +0,0 @@
-class Item < Thing
-
-end
-
-set_default_for(Item, :portable)

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

@@ -1,40 +0,0 @@
-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,30 +0,0 @@
-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,5 +0,0 @@
-class Scenery < Thing
-
-end
-set_default_for(Scenery, :not_portable)
-set_default_for(Scenery, :not_itemized)

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

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

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

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

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

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

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

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