src/look.c

Go to the documentation of this file.

/*
 * look.c -- commands which look at things 
 */

#include "copyright.h"
#include "config.h"

#include "mudconf.h"
#include "config.h"
#include "db.h"
#include "interface.h"
#include "match.h"
#include "externs.h"
#include "flags.h"
#include "powers.h"
#include "attrs.h"
#include "command.h"
#include "alloc.h"
#include "ansi.h"

extern void ufun(char *, char *, int, int, int, dbref, dbref);

static void look_exits(dbref player, dbref loc, const char *exit_name)
{
        dbref thing, parent;
        char *buff, *e, *s, *buff1, *e1;
        int foundany, lev, key;

        /*
         * make sure location has exits 
         */

        if(!Good_obj(loc) || !Has_exits(loc))
                return;

        /*
         * make sure there is at least one visible exit 
         */

        foundany = 0;
        key = 0;
        if(Dark(loc))
                key |= VE_BASE_DARK;
        ITER_PARENTS(loc, parent, lev) {
                key &= ~VE_LOC_DARK;
                if(Dark(parent))
                        key |= VE_LOC_DARK;
                DOLIST(thing, Exits(parent)) {
                        if(exit_displayable(thing, player, key)) {
                                foundany = 1;
                                break;
                        }
                }
                if(foundany)
                        break;
        }

        if(!foundany)
                return;
        /*
         * Display the list of exit names 
         */

        notify(player, exit_name);
        e = buff = alloc_lbuf("look_exits");
        e1 = buff1 = alloc_lbuf("look_exits2");
        ITER_PARENTS(loc, parent, lev) {
                key &= ~VE_LOC_DARK;
                if(Dark(parent))
                        key |= VE_LOC_DARK;
                if(Transparent(loc)) {
                        DOLIST(thing, Exits(parent)) {
                                if(exit_displayable(thing, player, key)) {
                                        StringCopy(buff, Name(thing));
                                        for(e = buff; *e && (*e != ';'); e++);
                                        *e = '\0';
                                        notify_printf(player, "%s leads to %s.", buff,
                                                                  Name(Location(thing)));
                                }
                        }
                } else {
                        DOLIST(thing, Exits(parent)) {
                                if(exit_displayable(thing, player, key)) {
                                        e1 = buff1;
                                        /* Put the exit name in buff1 */
                                        /*
                                         * chop off first * * 
                                         * 
                                         * * exit alias to *
                                         * * * display 
                                         */

                                        if(buff != e)
                                                safe_str((char *) "  ", buff, &e);
                                        for(s = Name(thing); *s && (*s != ';'); s++)
                                                safe_chr(*s, buff1, &e1);
                                        *e1 = 0;
                                        /* Copy the exit name into 'buff' */
                                        /* Append this exit to the list */
                                        safe_str(buff1, buff, &e);

                                }
                        }
                }
        }

        if(!(Transparent(loc))) {
                safe_str((char *) "\r\n", buff, &e);
                *e = 0;
                notify(player, buff);
        }
        free_lbuf(buff);
        free_lbuf(buff1);
}

#define CONTENTS_LOCAL  0
#define CONTENTS_NESTED 1
#define CONTENTS_REMOTE 2

static void look_contents(dbref player, dbref loc, const char *contents_name,
                                                  int style)
{
        dbref thing;
        dbref can_see_loc;
        char *buff;
        char remote_num[32];

        /*
         * check to see if he can see the location 
         */

        can_see_loc = (!Dark(loc) || (mudconf.see_own_dark &&
                                                                  Examinable(player, loc)));

        /*
         * check to see if there is anything there 
         */

        DOLIST(thing, Contents(loc)) {
                if(can_see(player, thing, can_see_loc)) {

                        /*
                         * something exists!  show him everything 
                         */

                        notify(player, contents_name);
                        DOLIST(thing, Contents(loc)) {
                                if(can_see(player, thing, can_see_loc)) {
                                        buff = unparse_object(player, thing, 1);
                                        notify(player, buff);
                                        free_lbuf(buff);

                                }
                        }
                        break;                          /*
                                                                 * we're done 
                                                                 */
                }
        }
}

static void view_atr(dbref player, dbref thing, ATTR * ap, char *text,
                                         dbref aowner, int aflags, int skip_tag)
{
        char *buf;
        char xbuf[6];
        char *xbufp;
        BOOLEXP *bool;

        if(ap->flags & AF_IS_LOCK) {
                bool = parse_boolexp(player, text, 1);
                text = unparse_boolexp(player, bool);
                free_boolexp(bool);
        }
        /*
         * If we don't control the object or own the attribute, hide the * *
         * * * attr owner and flag info. 
         */

        if(!Controls(player, thing) && (Owner(player) != aowner)) {
                if(skip_tag && (ap->number == A_DESC))
                        notify_printf(player, "%s", text);
                else
                        notify_printf(player, "\033[1m%s:\033[0m %s", ap->name, text);
                return;
        }
        /*
         * Generate flags 
         */

        xbufp = xbuf;
        if(aflags & AF_LOCK)
                *xbufp++ = '+';
        if(aflags & AF_NOPROG)
                *xbufp++ = '$';
        if(aflags & AF_PRIVATE)
                *xbufp++ = 'I';
        if(aflags & AF_REGEXP)
                *xbufp++ = 'R';
        if(aflags & AF_VISUAL)
                *xbufp++ = 'V';
        if(aflags & AF_MDARK)
                *xbufp++ = 'M';
        if(aflags & AF_WIZARD)
                *xbufp++ = 'W';

        *xbufp = '\0';

        if((aowner != Owner(thing)) && (aowner != NOTHING)) {
                notify_printf(player, "\033[1m%s [#%d%s]:\033[0m %s", ap->name, aowner, xbuf, text);
        } else if(*xbuf) {
                notify_printf(player, "\033[1m%s [%s]:\033[0m %s", ap->name, xbuf, text);
        } else if(!skip_tag || (ap->number != A_DESC)) {
                notify_printf(player, "\033[1m%s:\033[0m %s", ap->name, text);
        } else {
            notify_printf(player, "%s", text);
    }
}

static void look_atrs1(dbref player, dbref thing, dbref othing,
                                           int check_exclude, int hash_insert)
{
        dbref aowner;
        int ca, aflags;
        ATTR *attr, *cattr;
        char *as, *buf;

        cattr = (ATTR *) malloc(sizeof(ATTR));
        for(ca = atr_head(thing, &as); ca; ca = atr_next(&as)) {
                if((ca == A_DESC) || (ca == A_LOCK))
                        continue;
                attr = atr_num(ca);
                if(!attr)
                        continue;

                bcopy((char *) attr, (char *) cattr, sizeof(ATTR));

                /*
                 * Should we exclude this attr? 
                 */

                if(check_exclude && ((attr->flags & AF_PRIVATE) ||
                                                         nhashfind(ca, &mudstate.parent_htab)))
                        continue;

                buf = atr_get(thing, ca, &aowner, &aflags);
                if(Read_attr(player, othing, attr, aowner, aflags)) {
                        /* check_zone/atr_num overwrites attr!! */

                        if(attr->number != cattr->number)
                                bcopy((char *) cattr, (char *) attr, sizeof(ATTR));

                        if(!(check_exclude && (aflags & AF_PRIVATE))) {
                                if(hash_insert)
                                        nhashadd(ca, (int *) attr, &mudstate.parent_htab);
                                view_atr(player, thing, attr, buf, aowner, aflags, 0);
                        }
                }
                free_lbuf(buf);
        }
        free(cattr);
}

static void look_atrs(dbref player, dbref thing, int check_parents)
{
        dbref parent;
        int lev, check_exclude, hash_insert;

        if(!check_parents) {
                look_atrs1(player, thing, thing, 0, 0);
        } else {
                hash_insert = 1;
                check_exclude = 0;
                nhashflush(&mudstate.parent_htab, 0);
                ITER_PARENTS(thing, parent, lev) {
                        if(!Good_obj(Parent(parent)))
                                hash_insert = 0;
                        look_atrs1(player, parent, thing, check_exclude, hash_insert);
                        check_exclude = 1;
                }
        }
}

static void look_simple(dbref player, dbref thing, int obey_terse)
{
        int pattr;
        char *buff;

        /*
         * Only makes sense for things that can hear 
         */

        if(!Hearer(player))
                return;

        /*
         * Get the name and db-number if we can examine it. 
         */

        if(Examinable(player, thing)) {
                buff = unparse_object(player, thing, 1);
                notify(player, buff);
                free_lbuf(buff);

        }
        pattr = (obey_terse && Terse(player)) ? 0 : A_DESC;
        did_it(player, thing, pattr, "You see nothing special.", A_ODESC, NULL,
                   A_ADESC, (char **) NULL, 0);

        if(!mudconf.quiet_look && (!Terse(player) || mudconf.terse_look)) {
                look_atrs(player, thing, 0);
        }
}

static void show_a_desc(dbref player, dbref loc)
{
        char *got2;
        dbref aowner;
        int aflags, indent = 0;

        indent = (isRoom(loc) && mudconf.indent_desc && atr_get_raw(loc, A_DESC));

        if(indent)
                raw_notify_newline(player);
        did_it(player, loc, A_DESC, NULL, A_ODESC, NULL, A_ADESC,
                   (char **) NULL, 0);
        if(indent)
                raw_notify_newline(player);
        
}

static void show_desc(dbref player, dbref loc, int key)
{
        char *got;
        dbref aowner;
        int aflags;

        if((key & LK_OBEYTERSE) && Terse(player))
                did_it(player, loc, 0, NULL, A_ODESC, NULL, A_ADESC,
                           (char **) NULL, 0);
        else if((Typeof(loc) != TYPE_ROOM) && (key & LK_IDESC)) {
                if(*(got = atr_pget(loc, A_IDESC, &aowner, &aflags)))
                        did_it(player, loc, A_IDESC, NULL, A_ODESC, NULL, A_ADESC,
                                   (char **) NULL, 0);
                else
                        show_a_desc(player, loc);
                free_lbuf(got);
        } else {
                show_a_desc(player, loc);
        }
}

void look_in(dbref player, dbref loc, int key)
{
        int pattr, oattr, aattr, is_terse, showkey;
        char *buff;

        is_terse = (key & LK_OBEYTERSE) ? Terse(player) : 0;

        /*
         * Only makes sense for things that can hear 
         */

        if(!Hearer(player))
                return;

        /*
         * tell him the name, and the number if he can link to it 
         */

        buff = unparse_object(player, loc, 1);
        notify(player, buff);
        free_lbuf(buff);

        if(!Good_obj(loc))
                return;                                 /*
                                                                 * If we went to NOTHING et al,  skip the * * 
                                                                 * 
                                                                 * * rest 
                                                                 */

        /*
         * tell him the description 
         */

        showkey = 0;
        if(loc == Location(player))
                showkey |= LK_IDESC;
        if(key & LK_OBEYTERSE)
                showkey |= LK_OBEYTERSE;
        show_desc(player, loc, showkey);

        /*
         * tell him the appropriate messages if he has the key 
         */

        if(Typeof(loc) == TYPE_ROOM) {
                if(could_doit(player, loc, A_LOCK)) {
                        pattr = A_SUCC;
                        oattr = A_OSUCC;
                        aattr = A_ASUCC;
                } else {
                        pattr = A_FAIL;
                        oattr = A_OFAIL;
                        aattr = A_AFAIL;
                }
                if(is_terse)
                        pattr = 0;
                did_it(player, loc, pattr, NULL, oattr, NULL, aattr,
                           (char **) NULL, 0);
        }
        /*
         * tell him the attributes, contents and exits 
         */

        if((key & LK_SHOWATTR) && !mudconf.quiet_look && !is_terse)
                look_atrs(player, loc, 0);
        if(!is_terse || mudconf.terse_contents)
                look_contents(player, loc, "Contents:", CONTENTS_LOCAL);
        if((key & LK_SHOWEXIT) && (!is_terse || mudconf.terse_exits))
                look_exits(player, loc, "Obvious exits:");
}

void do_look(dbref player, dbref cause, int key, char *name)
{
        dbref thing, loc, look_key;

        look_key = LK_SHOWATTR | LK_SHOWEXIT;
        if(!mudconf.terse_look)
                look_key |= LK_OBEYTERSE;

        loc = Location(player);
        if(!name || !*name) {
                thing = loc;
                if(Good_obj(thing)) {
                        if(key & LOOK_OUTSIDE) {
                                if((Typeof(thing) == TYPE_ROOM) || Opaque(thing)) {
                                        notify_quiet(player, "You can't look outside.");
                                        return;
                                }
                                thing = Location(thing);
                        }
                        look_in(player, thing, look_key);
                }
                return;
        }
        /*
         * Look for the target locally 
         */

        thing = (key & LOOK_OUTSIDE) ? loc : player;
        init_match(thing, name, NOTYPE);
        match_exit_with_parents();
        match_neighbor();
        match_possession();
        if(Long_Fingers(player)) {
                match_absolute();
                match_player();
        }
        match_here();
        match_me();
        match_master_exit();
        thing = match_result();

        /*
         * Not found locally, check possessive 
         */

        if(!Good_obj(thing)) {
                thing =
                        match_status(player, match_possessed(player,
                                                                                                 ((key & LOOK_OUTSIDE) ? loc :
                                                                                                  player), (char *) name,
                                                                                                 thing, 0));
        }
        /*
         * If we found something, go handle it 
         */

        if(Good_obj(thing)) {
                switch (Typeof(thing)) {
                case TYPE_ROOM:
                        look_in(player, thing, look_key);
                        break;
                case TYPE_THING:
                case TYPE_PLAYER:
                        look_simple(player, thing, !mudconf.terse_look);
                        if(!Opaque(thing) && (!Terse(player) || mudconf.terse_contents)) {
                                look_contents(player, thing, "Carrying:", CONTENTS_NESTED);
                        }
                        break;
                case TYPE_EXIT:
                        look_simple(player, thing, !mudconf.terse_look);
                        if(Transparent(thing) && (Location(thing) != NOTHING)) {
                                look_key &= ~LK_SHOWATTR;
                                look_in(player, Location(thing), look_key);
                        }
                        break;
                default:
                        look_simple(player, thing, !mudconf.terse_look);
                }
        }
}

static void debug_examine(dbref player, dbref thing)
{
        dbref aowner;
        char *buf;
        int aflags, ca;
        BOOLEXP *bool;
        ATTR *attr;
        char *as, *cp;

        notify_printf(player, "Number  = %d", thing);
        if(!Good_obj(thing))
                return;

        notify_printf(player, "Name    = %s", Name(thing));
        notify_printf(player, "Location= %d", Location(thing));
        notify_printf(player, "Contents= %d", Contents(thing));
        notify_printf(player, "Exits   = %d", Exits(thing));
        notify_printf(player, "Link    = %d", Link(thing));
        notify_printf(player, "Next    = %d", Next(thing));
        notify_printf(player, "Owner   = %d", Owner(thing));
        notify_printf(player, "Pennies = %d", Pennies(thing));
        notify_printf(player, "Zone    = %d", Zone(thing));
        buf = flag_description(player, thing);
        notify_printf(player, "Flags   = %s", buf);
        free_mbuf(buf);
        buf = power_description(player, thing);
        notify_printf(player, "Powers  = %s", buf);
        free_mbuf(buf);
        buf = atr_get(thing, A_LOCK, &aowner, &aflags);
        bool = parse_boolexp(player, buf, 1);
        free_lbuf(buf);
        notify_printf(player, "Lock    = %s", unparse_boolexp(player, bool));
        free_boolexp(bool);

        buf = alloc_lbuf("debug_dexamine");
        cp = buf;
        safe_str((char *) "Attr list: ", buf, &cp);

        for(ca = atr_head(thing, &as); ca; ca = atr_next(&as)) {
                attr = atr_num(ca);
                if(!attr)
                        continue;

                atr_get_info(thing, ca, &aowner, &aflags);
                if(Read_attr(player, thing, attr, aowner, aflags)) {
                        if(attr) {                      /*
                                                                 * Valid attr. 
                                                                 */
                                safe_str((char *) attr->name, buf, &cp);
                                safe_chr(' ', buf, &cp);
                        } else {
                                safe_str(tprintf("%d ", ca), buf, &cp);
                        }
                }
        }
        *cp = '\0';
        notify(player, buf);
        free_lbuf(buf);

        for(ca = atr_head(thing, &as); ca; ca = atr_next(&as)) {
                attr = atr_num(ca);
                if(!attr)
                        continue;

                buf = atr_get(thing, ca, &aowner, &aflags);
                if(Read_attr(player, thing, attr, aowner, aflags))
                        view_atr(player, thing, attr, buf, aowner, aflags, 0);
                free_lbuf(buf);
        }
}

static void exam_wildattrs(dbref player, dbref thing, int do_parent)
{
        int atr, aflags, got_any;
        char *buf;
        dbref aowner;
        ATTR *ap;

        got_any = 0;
        for(atr = olist_first(); atr != NOTHING; atr = olist_next()) {
                ap = atr_num(atr);
                if(!ap)
                        continue;

                if(do_parent && !(ap->flags & AF_PRIVATE))
                        buf = atr_pget(thing, atr, &aowner, &aflags);
                else
                        buf = atr_get(thing, atr, &aowner, &aflags);

                /*
                 * Decide if the player should see the attr: * If obj is * *
                 * * Examinable and has rights to see, yes. * If a player and 
                 * *  *  * * has rights to see, yes... *   except if faraway, 
                 * * * * attr=DESC, and *   remote DESC-reading is not turned 
                 * on. *  *  * *  * * If I own the attrib and have rights to
                 * see, yes... * * * * except if faraway, attr=DESC, and *
                 * remote * DESC-reading * * is not turned on. 
                 */

                if(Examinable(player, thing) &&
                   Read_attr(player, thing, ap, aowner, aflags)) {
                        got_any = 1;
                        view_atr(player, thing, ap, buf, aowner, aflags, 0);
                } else if((Typeof(thing) == TYPE_PLAYER) &&
                                  Read_attr(player, thing, ap, aowner, aflags)) {
                        got_any = 1;
                        if(aowner == Owner(player)) {
                                view_atr(player, thing, ap, buf, aowner, aflags, 0);
                        } else if((atr == A_DESC) && (mudconf.read_rem_desc ||
                                                                                  nearby(player, thing))) {
                                show_desc(player, thing, 0);
                        } else if(atr != A_DESC) {
                                view_atr(player, thing, ap, buf, aowner, aflags, 0);
                        } else {
                                notify(player, "<Too far away to get a good look>");
                        }
                } else if(Read_attr(player, thing, ap, aowner, aflags)) {
                        got_any = 1;
                        if(aowner == Owner(player)) {
                                view_atr(player, thing, ap, buf, aowner, aflags, 0);
                        } else if((atr == A_DESC) && (mudconf.read_rem_desc ||
                                                                                  nearby(player, thing))) {
                                show_desc(player, thing, 0);
                        } else if(nearby(player, thing)) {
                                view_atr(player, thing, ap, buf, aowner, aflags, 0);
                        } else {
                                notify(player, "<Too far away to get a good look>");
                        }
                }
                free_lbuf(buf);
        }
        if(!got_any)
                notify_quiet(player, "No matching attributes found.");

}

void do_examine(dbref player, dbref cause, int key, char *name)
{
        dbref thing, content, exit, aowner, loc;
        char savec;
        char *temp, *buf, *buf2;
        BOOLEXP *bool;
        int control, aflags, do_parent;

        /*
         * This command is pointless if the player can't hear. 
         */

        if(!Hearer(player))
                return;

        do_parent = key & EXAM_PARENT;
        thing = NOTHING;
        if(!name || !*name) {
                if((thing = Location(player)) == NOTHING)
                        return;
        } else {

                /* Check for obj/attr first */

                olist_push();
                if(parse_attrib_wild(player, name, &thing, do_parent, 1, 0)) {
                        exam_wildattrs(player, thing, do_parent);
                        olist_pop();
                        return;
                }
                olist_pop();

                /* Look it up */

                init_match(player, name, NOTYPE);
                match_everything(MAT_EXIT_PARENTS);
                thing = noisy_match_result();
                if(!Good_obj(thing))
                        return;
        }

        /*
         * Check for the /debug switch 
         */

        if(key == EXAM_DEBUG) {
                if(!Examinable(player, thing)) {
                        notify_quiet(player, "Permission denied.");
                } else {
                        debug_examine(player, thing);
                }
                return;
        }
        control = (Examinable(player, thing) || Link_exit(player, thing));

        if(control) {
                buf2 = unparse_object(player, thing, 0);
                notify(player, buf2);
                free_lbuf(buf2);
                if(mudconf.ex_flags) {
                        buf2 = flag_description(player, thing);
                        notify(player, buf2);
                        free_mbuf(buf2);
                }
        } else {
                if((key == EXAM_DEFAULT) && !mudconf.exam_public) {
                        if(mudconf.read_rem_name) {
                                buf2 = alloc_lbuf("do_examine.pub_name");
                                StringCopy(buf2, Name(thing));
                                notify_printf(player, "%s is owned by %s", buf2,
                                                          Name(Owner(thing)));
                                free_lbuf(buf2);
                        } else {
                                notify_printf(player, "Owned by %s", Name(Owner(thing)));
                        }
                        return;
                }
        }

        temp = alloc_lbuf("do_examine.info");

        if(control || mudconf.read_rem_desc || nearby(player, thing)) {
                temp = atr_get_str(temp, thing, A_DESC, &aowner, &aflags);
                if(*temp) {
                        if(Examinable(player, thing) || (aowner == Owner(player))) {
                                view_atr(player, thing, atr_num(A_DESC), temp, aowner,
                                                 aflags, 1);
                        } else {
                                show_desc(player, thing, 0);
                        }
                }
        } else {
                notify(player, "<Too far away to get a good look>");
        }

        if(control) {

                /*
                 * print owner, key, and value 
                 */

                savec = mudconf.many_coins[0];
                mudconf.many_coins[0] = (islower(savec) ? toupper(savec) : savec);
                buf2 = atr_get(thing, A_LOCK, &aowner, &aflags);
                bool = parse_boolexp(player, buf2, 1);
                buf = unparse_boolexp(player, bool);
                free_boolexp(bool);
                StringCopy(buf2, Name(Owner(thing)));
                notify_printf(player, "Owner: %s  Key: %s %s: %d", buf2, buf,
                                          mudconf.many_coins, Pennies(thing));
                free_lbuf(buf2);
                mudconf.many_coins[0] = savec;

                if(mudconf.have_zones) {
                        buf2 = unparse_object(player, Zone(thing), 0);
                        notify_printf(player, "Zone: %s", buf2);
                        free_lbuf(buf2);
                }
                /*
                 * print parent 
                 */

                loc = Parent(thing);
                if(loc != NOTHING) {
                        buf2 = unparse_object(player, loc, 0);
                        notify_printf(player, "Parent: %s", buf2);
                        free_lbuf(buf2);
                }
                buf2 = power_description(player, thing);
                notify(player, buf2);
                free_mbuf(buf2);

        }
        if(key != EXAM_BRIEF)
                look_atrs(player, thing, do_parent);

        /*
         * show him interesting stuff 
         */

        if(control) {

                /*
                 * Contents 
                 */

                if(Contents(thing) != NOTHING) {
                        notify(player, "Contents:");
                        DOLIST(content, Contents(thing)) {
                                buf2 = unparse_object(player, content, 0);
                                notify(player, buf2);
                                free_lbuf(buf2);
                        }
                }
                /*
                 * Show stuff that depends on the object type 
                 */

                switch (Typeof(thing)) {
                case TYPE_ROOM:

                        /*
                         * tell him about exits 
                         */

                        if(Exits(thing) != NOTHING) {
                                notify(player, "Exits:");
                                DOLIST(exit, Exits(thing)) {
                                        buf2 = unparse_object(player, exit, 0);
                                        notify(player, buf2);
                                        free_lbuf(buf2);
                                }
                        } else {
                                notify(player, "No exits.");
                        }

                        /*
                         * print dropto if present 
                         */

                        if(Dropto(thing) != NOTHING) {
                                buf2 = unparse_object(player, Dropto(thing), 0);
                                notify_printf(player, "Dropped objects go to: %s", buf2);
                                free_lbuf(buf2);
                        }
                        break;
                case TYPE_THING:
                case TYPE_PLAYER:

                        /*
                         * tell him about exits 
                         */

                        if(Exits(thing) != NOTHING) {
                                notify(player, "Exits:");
                                DOLIST(exit, Exits(thing)) {
                                        buf2 = unparse_object(player, exit, 0);
                                        notify(player, buf2);
                                        free_lbuf(buf2);
                                }
                        } else {
                                notify(player, "No exits.");
                        }

                        /*
                         * print home 
                         */

                        loc = Home(thing);
                        buf2 = unparse_object(player, loc, 0);
                        notify_printf(player, "Home: %s", buf2);
                        free_lbuf(buf2);

                        /*
                         * print location if player can link to it 
                         */

                        loc = Location(thing);
                        if((Location(thing) != NOTHING) && (Examinable(player, loc) ||
                                                                                                Examinable(player, thing)
                                                                                                || Linkable(player, loc))) {
                                buf2 = unparse_object(player, loc, 0);
                                notify_printf(player, "Location: %s", buf2);
                                free_lbuf(buf2);
                        }
                        break;
                case TYPE_EXIT:
                        buf2 = unparse_object(player, Exits(thing), 0);
                        notify_printf(player, "Source: %s", buf2);
                        free_lbuf(buf2);

                        /*
                         * print destination 
                         */

                        switch (Location(thing)) {
                        case NOTHING:
                                break;
                        case HOME:
                                notify(player, "Destination: *HOME*");
                                break;
                        default:
                                buf2 = unparse_object(player, Location(thing), 0);
                                notify_printf(player, "Destination: %s", buf2);
                                free_lbuf(buf2);
                                break;
                        }
                        break;
                default:
                        break;
                }
        } else if(!Opaque(thing) && nearby(player, thing)) {
                if(Has_contents(thing))
                        look_contents(player, thing, "Contents:", CONTENTS_REMOTE);
                if(Typeof(thing) != TYPE_EXIT)
                        look_exits(player, thing, "Obvious exits:");
        }
        free_lbuf(temp);

        if(!control) {
                if(mudconf.read_rem_name) {
                        buf2 = alloc_lbuf("do_examine.pub_name");
                        StringCopy(buf2, Name(thing));
                        notify_printf(player, "%s is owned by %s", buf2,
                                                  Name(Owner(thing)));
                        free_lbuf(buf2);
                } else {
                        notify_printf(player, "Owned by %s", Name(Owner(thing)));
                }
        }
}

void do_score(dbref player, dbref cause, int key)
{
        notify_printf(player, "You have %d %s.", Pennies(player),
                                  (Pennies(player) ==
                                   1) ? mudconf.one_coin : mudconf.many_coins);
}

void do_inventory(dbref player, dbref cause, int key)
{
        dbref thing;
        char *buff, *s, *e;

        thing = Contents(player);
        if(thing == NOTHING) {
                notify(player, "You aren't carrying anything.");
        } else {
                notify(player, "You are carrying:");
                DOLIST(thing, thing) {
                        buff = unparse_object(player, thing, 1);
                        notify(player, buff);
                        free_lbuf(buff);
                }
        }

        thing = Exits(player);
        if(thing != NOTHING) {
                notify(player, "Exits:");
                e = buff = alloc_lbuf("look_exits");
                DOLIST(thing, thing) {
                        /*
                         * chop off first exit alias to display 
                         */
                        for(s = Name(thing); *s && (*s != ';'); s++)
                                safe_chr(*s, buff, &e);
                        safe_str((char *) "  ", buff, &e);
                }
                *e = 0;
                notify(player, buff);
                free_lbuf(buff);
        }
        do_score(player, player, 0);
}

void do_entrances(dbref player, dbref cause, int key, char *name)
{
        dbref thing, i, j;
        char *exit, *message;
        int control_thing, count, low_bound, high_bound;
        FWDLIST *fp;

        parse_range(&name, &low_bound, &high_bound);
        if(!name || !*name) {
                if(Has_location(player))
                        thing = Location(player);
                else
                        thing = player;
                if(!Good_obj(thing))
                        return;
        } else {
                init_match(player, name, NOTYPE);
                match_everything(MAT_EXIT_PARENTS);
                thing = noisy_match_result();
                if(!Good_obj(thing))
                        return;
        }

        if(!payfor(player, mudconf.searchcost)) {
                notify_printf(player, "You don't have enough %s.",
                                          mudconf.many_coins);
                return;
        }
        message = alloc_lbuf("do_entrances");
        control_thing = Examinable(player, thing);
        count = 0;
        for(i = low_bound; i <= high_bound; i++) {
                if(control_thing || Examinable(player, i)) {
                        switch (Typeof(i)) {
                        case TYPE_EXIT:
                                if(Location(i) == thing) {
                                        exit = unparse_object(player, Exits(i), 0);
                                        notify_printf(player, "%s (%s)", exit, Name(i));
                                        free_lbuf(exit);
                                        count++;
                                }
                                break;
                        case TYPE_ROOM:
                                if(Dropto(i) == thing) {
                                        exit = unparse_object(player, i, 0);
                                        notify_printf(player, "%s [dropto]", exit);
                                        free_lbuf(exit);
                                        count++;
                                }
                                break;
                        case TYPE_THING:
                        case TYPE_PLAYER:
                                if(Home(i) == thing) {
                                        exit = unparse_object(player, i, 0);
                                        notify_printf(player, "%s [home]", exit);
                                        free_lbuf(exit);
                                        count++;
                                }
                                break;
                        }

                        /*
                         * Check for parents 
                         */

                        if(Parent(i) == thing) {
                                exit = unparse_object(player, i, 0);
                                notify_printf(player, "%s [parent]", exit);
                                free_lbuf(exit);
                                count++;
                        }
                        /*
                         * Check for forwarding 
                         */

                        if(H_Fwdlist(i)) {
                                fp = fwdlist_get(i);
                                if(!fp)
                                        continue;
                                for(j = 0; j < fp->count; j++) {
                                        if(fp->data[j] != thing)
                                                continue;
                                        exit = unparse_object(player, i, 0);
                                        notify_printf(player, "%s [forward]", exit);
                                        free_lbuf(exit);
                                        count++;
                                }
                        }
                }
        }
        free_lbuf(message);
        notify_printf(player, "%d entrance%s found.", count,
                                  (count == 1) ? "" : "s");
}

/*
 * check the current location for bugs 
 */

static void sweep_check(dbref player, dbref what, int key, int is_loc)
{
        dbref aowner, parent;
        int canhear, cancom, isplayer, ispuppet, isconnected, attr, aflags;
        int is_parent, lev;
        char *buf, *buf2, *bp, *as, *buff, *s;
        ATTR *ap;

        if(Dark(what) && !WizRoy(player) && !mudconf.sweep_dark)
                return;
        canhear = 0;
        cancom = 0;
        isplayer = 0;
        ispuppet = 0;
        isconnected = 0;
        is_parent = 0;

        if((key & SWEEP_LISTEN) && (((Typeof(what) == TYPE_EXIT) || is_loc) &&
                                                                Audible(what))) {
                canhear = 1;
        } else if(key & SWEEP_LISTEN) {
                if(Monitor(what))
                        buff = alloc_lbuf("Hearer");
                else
                        buff = NULL;

                for(attr = atr_head(what, &as); attr; attr = atr_next(&as)) {
                        if(attr == A_LISTEN) {
                                canhear = 1;
                                break;
                        }
                        if(Monitor(what)) {
                                ap = atr_num(attr);
                                if(!ap || (ap->flags & AF_NOPROG))
                                        continue;

                                atr_get_str(buff, what, attr, &aowner, &aflags);

                                /*
                                 * Make sure we can execute it 
                                 */

                                if((buff[0] != AMATCH_LISTEN) || (aflags & AF_NOPROG))
                                        continue;

                                /*
                                 * Make sure there's a : in it 
                                 */

                                for(s = buff + 1; *s && (*s != ':'); s++);
                                if(s) {
                                        canhear = 1;
                                        break;
                                }
                        }
                }
                if(buff)
                        free_lbuf(buff);
        }
        if((key & SWEEP_COMMANDS) && (Typeof(what) != TYPE_EXIT)) {

                /*
                 * Look for commands on the object and parents too 
                 */

                ITER_PARENTS(what, parent, lev) {
                        if(Commer(parent)) {
                                cancom = 1;
                                if(lev) {
                                        is_parent = 1;
                                        break;
                                }
                        }
                }
        }
        if(key & SWEEP_CONNECT) {
                if(Connected(what) || (Puppet(what) && Connected(Owner(what))) ||
                   (mudconf.player_listen && (Typeof(what) == TYPE_PLAYER) &&
                        canhear && Connected(Owner(what))))
                        isconnected = 1;
        }
        if(key & SWEEP_PLAYER || isconnected) {
                if(Typeof(what) == TYPE_PLAYER)
                        isplayer = 1;
                if(Puppet(what))
                        ispuppet = 1;
        }
        if(canhear || cancom || isplayer || ispuppet || isconnected) {
                buf = alloc_lbuf("sweep_check.types");
                bp = buf;

                if(cancom)
                        safe_str((char *) "commands ", buf, &bp);
                if(canhear)
                        safe_str((char *) "messages ", buf, &bp);
                if(isplayer)
                        safe_str((char *) "player ", buf, &bp);
                if(ispuppet) {
                        safe_str((char *) "puppet(", buf, &bp);
                        safe_str(Name(Owner(what)), buf, &bp);
                        safe_str((char *) ") ", buf, &bp);
                }
                if(isconnected)
                        safe_str((char *) "connected ", buf, &bp);
                if(is_parent)
                        safe_str((char *) "parent ", buf, &bp);
                bp[-1] = '\0';
                if(Typeof(what) != TYPE_EXIT) {
                        notify_printf(player, "  %s is listening. [%s]", Name(what), buf);
                } else {
                        buf2 = alloc_lbuf("sweep_check.name");
                        StringCopy(buf2, Name(what));
                        for(bp = buf2; *bp && (*bp != ';'); bp++);
                        *bp = '\0';
                        notify_printf(player, "  %s is listening. [%s]", buf2, buf);
                        free_lbuf(buf2);
                }
                free_lbuf(buf);
        }
}

void do_sweep(dbref player, dbref cause, int key, char *where)
{
        dbref here, sweeploc;
        int where_key, what_key;

        where_key = key & (SWEEP_ME | SWEEP_HERE | SWEEP_EXITS);
        what_key =
                key & (SWEEP_COMMANDS | SWEEP_LISTEN | SWEEP_PLAYER | SWEEP_CONNECT);

        if(where && *where) {
                sweeploc = match_controlled(player, where);
                if(!Good_obj(sweeploc))
                        return;
        } else {
                sweeploc = player;
        }

        if(!where_key)
                where_key = -1;
        if(!what_key)
                what_key = -1;
        else if(what_key == SWEEP_VERBOSE)
                what_key = SWEEP_VERBOSE | SWEEP_COMMANDS;

        /*
         * Check my location.  If I have none or it is dark, check just me. 
         */

        if(where_key & SWEEP_HERE) {
                notify(player, "Sweeping location...");
                if(Has_location(sweeploc)) {
                        here = Location(sweeploc);
                        if((here == NOTHING) || (Dark(here) && !mudconf.sweep_dark &&
                                                                         !Examinable(player, here))) {
                                notify_quiet(player,
                                                         "Sorry, it is dark here and you can't search for bugs");
                                sweep_check(player, sweeploc, what_key, 0);
                        } else {
                                sweep_check(player, here, what_key, 1);
                                for(here = Contents(here); here != NOTHING; here = Next(here))
                                        sweep_check(player, here, what_key, 0);
                        }
                } else {
                        sweep_check(player, sweeploc, what_key, 0);
                }
        }
        /*
         * Check exits in my location 
         */

        if((where_key & SWEEP_EXITS) && Has_location(sweeploc)) {
                notify(player, "Sweeping exits...");
                for(here = Exits(Location(sweeploc)); here != NOTHING;
                        here = Next(here))
                        sweep_check(player, here, what_key, 0);
        }
        /*
         * Check my inventory 
         */

        if((where_key & SWEEP_ME) && Has_contents(sweeploc)) {
                notify(player, "Sweeping inventory...");
                for(here = Contents(sweeploc); here != NOTHING; here = Next(here))
                        sweep_check(player, here, what_key, 0);
        }
        /*
         * Check carried exits 
         */

        if((where_key & SWEEP_EXITS) && Has_exits(sweeploc)) {
                notify(player, "Sweeping carried exits...");
                for(here = Exits(sweeploc); here != NOTHING; here = Next(here))
                        sweep_check(player, here, what_key, 0);
        }
        notify(player, "Sweep complete.");
}

/*
 * Output the sequence of commands needed to duplicate the specified
 * * object.  If you're moving things to another system, your milage
 * * will almost certainly vary.  (i.e. different flags, etc.)
 */

extern NAMETAB indiv_attraccess_nametab[];

void do_decomp(dbref player, dbref cause, int key, char *name, char *qual)
{
        BOOLEXP *bool;
        char *got, *thingname, *as, *ltext, *buff, *s;
        dbref aowner, thing;
        int val, aflags, ca, atr;
        ATTR *attr;
        NAMETAB *np;
        char new[LBUF_SIZE];

        /* Check for obj/attr first */

        olist_push();
        if(parse_attrib_wild(player, name, &thing, 0, 1, 0)) {
                buff = alloc_mbuf("do_decomp.attr_name");
                thingname = alloc_lbuf("do_decomp");
                if(key & DECOMP_DBREF) {
                        sprintf(thingname, "%d", (int) thing);
                } else {
                        StringCopy(thingname, Name(thing));
                }
                strncpy(new, thingname, LBUF_SIZE-1);
                for(atr = olist_first(); atr != NOTHING; atr = olist_next()) {
                        if((atr == A_NAME || atr == A_LOCK))
                                continue;
                        attr = atr_num(atr);
                        if(!attr)
                                continue;

                        got = atr_get(thing, atr, &aowner, &aflags);
                        if(Read_attr(player, thing, attr, aowner, aflags)) {
                                if(attr->flags & AF_IS_LOCK) {
                                        bool = parse_boolexp(player, got, 1);
                                        ltext = unparse_boolexp_decompile(player, bool);
                                        free_boolexp(bool);
                                        notify_printf(player, "@lock/%s %s=%s", attr->name,
                                                                  strip_ansi_r(new,thingname,strlen(thingname)), ltext);
                                } else {
                                        StringCopy(buff, attr->name);
                                        for(s = thingname; *s; s++) {
                                                if(*s == EXIT_DELIMITER) {
                                                        *s = '\0';
                                                        break;
                                                }
                                        }
                                        notify_printf(player, "%c%s %s=%s",
                                                                  ((atr < A_USER_START) ? '@' : '&'), buff,
                                                                  strip_ansi_r(new,thingname,strlen(thingname)), got);

                                        if(aflags & AF_LOCK) {
                                                notify_printf(player, "@lock %s/%s",
                                                                          strip_ansi_r(new,thingname,strlen(thingname)), buff);
                                        }

                                        for(np = indiv_attraccess_nametab; np->name; np++) {

                                                if((aflags & np->flag) &&
                                                   check_access(player, np->perm) &&
                                                   (!(np->perm & CA_NO_DECOMP))) {

                                                        notify_printf(player, "@set %s/%s = %s",
                                                                                  strip_ansi_r(new,thingname,strlen(thingname)), buff,
                                                                                  np->name);
                                                }
                                        }
                                }
                        }
                        free_lbuf(got);
                }
                free_mbuf(buff);
                free_lbuf(thingname);
                olist_pop();
                return;
        }
        olist_pop();

        init_match(player, name, TYPE_THING);
        match_everything(MAT_EXIT_PARENTS);
        thing = noisy_match_result();

        /*
         * get result 
         */
        if(thing == NOTHING)
                return;

        if(!Examinable(player, thing)) {
                notify_quiet(player,
                                         "You can only decompile things you can examine.");
                return;
        }
        thingname = atr_get(thing, A_LOCK, &aowner, &aflags);
        bool = parse_boolexp(player, thingname, 1);

        /*
         * Determine the name of the thing to use in reporting and then
         * report the command to make the thing. 
         */

        if(qual && *qual) {
                StringCopy(thingname, qual);
        } else {
                switch (Typeof(thing)) {
                case TYPE_THING:
                        StringCopy(thingname, Name(thing));
                        val = OBJECT_DEPOSIT(Pennies(thing));
                        notify_printf(player, "@create %s=%d",
                                                  translate_string(thingname, 1), val);
                        break;
                case TYPE_ROOM:
                        StringCopy(thingname, "here");
                        notify_printf(player, "@dig/teleport %s",
                                                  translate_string(Name(thing), 1));
                        break;
                case TYPE_EXIT:
                        StringCopy(thingname, Name(thing));
                        notify_printf(player, "@open %s",
                                                  translate_string(Name(thing), 1));
                        for(got = thingname; *got; got++) {
                                if(*got == EXIT_DELIMITER) {
                                        *got = '\0';
                                        break;
                                }
                        }
                        break;
                case TYPE_PLAYER:
                        StringCopy(thingname, "me");
                        break;
                }
        }

        /*
         * Report the lock (if any) 
         */

        strncpy(new, thingname, LBUF_SIZE-1);
        if(bool != TRUE_BOOLEXP) {
                notify_printf(player, "@lock %s=%s", strip_ansi_r(new,thingname,strlen(thingname)),
                                          unparse_boolexp_decompile(player, bool));
        }
        free_boolexp(bool);

        /*
         * Report attributes 
         */

        buff = alloc_mbuf("do_decomp.attr_name");
        for(ca = atr_head(thing, &as); ca; ca = atr_next(&as)) {
                if((ca == A_NAME) || (ca == A_LOCK))
                        continue;
                attr = atr_num(ca);
                if(!attr)
                        continue;
                if((attr->flags & AF_NOCMD) && !(attr->flags & AF_IS_LOCK))
                        continue;

                got = atr_get(thing, ca, &aowner, &aflags);
                if(Read_attr(player, thing, attr, aowner, aflags)) {
                        if(attr->flags & AF_IS_LOCK) {
                                bool = parse_boolexp(player, got, 1);
                                ltext = unparse_boolexp_decompile(player, bool);
                                free_boolexp(bool);
                                notify_printf(player, "@lock/%s %s=%s", attr->name,
                                                          thingname, ltext);
                        } else {
                                StringCopy(buff, attr->name);
                                notify_printf(player, "%c%s %s=%s",
                                                          ((ca < A_USER_START) ? '@' : '&'), buff,
                                                          strip_ansi_r(new,thingname,strlen(thingname)), got);

                                if(aflags & AF_LOCK) {
                                        notify_printf(player, "@lock %s/%s",
                                                                  strip_ansi_r(new,thingname,strlen(thingname)), buff);
                                }
                                for(np = indiv_attraccess_nametab; np->name; np++) {

                                        if((aflags & np->flag) &&
                                           check_access(player, np->perm) &&
                                           (!(np->perm & CA_NO_DECOMP))) {

                                                notify_printf(player, "@set %s/%s = %s",
                                                                          strip_ansi_r(new,thingname,strlen(thingname)), buff, np->name);
                                        }
                                }
                        }
                }
                free_lbuf(got);
        }
        free_mbuf(buff);

        decompile_flags(player, thing, thingname);
        decompile_powers(player, thing, thingname);

        /*
         * If the object has a parent, report it 
         */

        if(Parent(thing) != NOTHING)
                notify_printf(player, "@parent %s=#%d", strip_ansi_r(new,thingname,strlen(thingname)),
                                          Parent(thing));

        /*
         * If the object has a zone, report it 
         */
        if(Zone(thing) != NOTHING)
                notify_printf(player, "@chzone %s=#%d", strip_ansi_r(new,thingname,strlen(thingname)),
                                          Zone(thing));

        free_lbuf(thingname);
}

---