TADS Programming - doors

As usual I have removed comment lines from the start of this
article ... Sue
                    doors.t version 1.0
           by Kevin Forchione ( Lysseus@msn.com )
          Copyright (c) 1999. All Rights Reserved.

sense.t provides an enhancement of the "visibility" and
"reachability" concepts established in ADV.T. The scope() function
will return a list of all objects which are valid for a vantage
for a particular filter.

This file requires HTML TADS 2.5.0 or later.

You may modify and use this file in any way you want, provided
that if you redistribute modified copies of this file in source
form, the copies must include the original copyright notice
(including this paragraph), and must be clearly marked as modified
from the original version.

------------------------------------------------------------------
Revision History
------------------------------------------------------------------
23-Oct-99: Creation.

#pragma C+

door: floatingItem, fixeditem, obstacle

A door is an obstacle that impedes progress when it is closed.
Unlike the doorway, a door is a floatingItem and should not have
its location attribute coded. Instead, use the foundin list to
indicate the rooms in which the door is to be found.

To make a simple two-sided door you need only code both room
objects in the foundin list of the door:

       foundin = [ hallway, kitchen ]

To make a one-sided door, code the foundin list with the room
object in which the door is to be found, and the doorto list with
the room object to which the door leads:

       foundin = hallway
       doorto = kitchen

If you want a door that returns rooms different from those it is
found in, simply code both the foundin list and doorto list
accordingly, each element of the doorto list must have a
corresponding foundin element:

       foundin = [ hallway, kitchen ]
       doorto = [ foyer, hallway ]

From the hallway the door leads to the foyer, but from the kitchen
it leads to the hallway.

class door: doorway, floatingItem
    foundin = []
    doorto = nil
    location =
    {
        local f, actor, loc, dloc, foundList;

        if (self.foundin == nil)
            return nil;

        actor = parserGetObj(PO_ACTOR);
        if (actor == nil)
            actor = parserGetMe();

        loc = actor;
        while(loc)
        {
            dloc = loc;
            loc = loc.location;
        }


        //
        //  convert self.foundin into a list
        //
        switch(proptype(self, &foundin))
        {
            case DTY_NIL:
                foundList = [];
                break;
            case DTY_OBJECT:
                foundList = [ self.foundin ];
                break;
            case DTY_LIST:
                foundList = self.foundin;
                break;
            default:
                return nil;
        }

        if (find(foundList, dloc))
            return dloc;
        else
            return nil;
    }
    findDest(actor) =
    {
        local f, loc, foundList, destList;

        loc = self.location;

        //
        //  convert self.foundin into a list
        //
        switch(proptype(self, &foundin))
        {
            case DTY_NIL:
                foundList = [];
                break;
            case DTY_OBJECT:
                foundList = [ self.foundin ];
                break;
            case DTY_LIST:
                foundList = self.foundin;
                break;
            default:
                return nil;
        }

        //
        //  convert self.doorto into a list
        //
        switch(proptype(self, &doorto))
        {
            case DTY_NIL:
                destList = [];
                break;
            case DTY_OBJECT:
                destList = [ self.doorto ];
                break;
            case DTY_LIST:
                destList = self.doorto;
                break;
            default:
                return nil;
        }

        //
        //  door is linked to room directions, but no foundin
        //  list exists. Simply return the noexit message.
        //
        if (length(foundList) == 0)
        {
            return self.noexit;
        }

        //
        //  We don't have a doorto list. Use the foundin list,
        //  which must have 2 elements.
        //
        if (length(destList) == 0)
        {
            if (length(foundList) != 2)
            {
                "\n[TADS-DOORS-001] When omitting the
                doorto list, the foundin list should
                contain 2 elements.\n";
                return nil;
            }
            if (loc == foundList[1])
                return foundList[2];
            else
                return foundList[1];
        }

     //
     // We have a doorto list, each element should correspond to
     // an element in the foundin list.
     //
        if (length(foundList) != length(destList))
        {
            "\n[TADS-DOORS-002] <<self.thedesc>> requires a
            corresponding doorto element for each foundin
            element.\n";
            return nil;
        }

        //
        //  Search for the actor location in the foundin list.
        //
        f = find(foundList, loc);

        //
        //  Door isn't in the actor location. return noexit.
        //
        if (f == nil)
        {
            return self.noexit;
        }

        //
        //  return the corresponding doorto element
        //
        return destList[f];
    }
    destination =
    {
        local actor = parserGetObj(PO_ACTOR);

        if (actor == nil)
            actor = parserGetMe();

      //
      //  The door location is nil or the actor's location doesn't
      //  match any object in the foundin list
      //
        if (self.location == nil)
            return self.noexit;

        if (self.isopen)
            return self.findDest(actor);
        else if (!self.islocked
            && !self.noAutoOpen)
        {
            self.setIsopen(true);
            "(Opening << self.thedesc >>)\n";
            return self.findDest(actor);
        }
        else
        {
            "%You%'ll have to open << self.thedesc >> first. ";
            setit(self);
            return nil;
        }
    }
    setIsopen(setting) =
    {
        / update my status /
        self.isopen = setting;
    }
    setIslocked(setting) =
    {
        / update my status /
        self.islocked = setting;
    }
    noexit = { "%You% can't go that way. "; return nil; }
;
/
   lockableDoor: door

   This is just a normal door with the islockable and
   islocked properties set to true.  Fill in the other
   properties (foundin and doorto) as usual.  If
   the door has a key, set property mykey to the key object.
 /
class lockableDoor: door
    islockable = true
    islocked = true
;

#pragma C-
                              - o -