mux/src/look.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "ansi.h"
#include "attrs.h"
#include "command.h"
#include "interface.h"
#include "powers.h"

Include dependency graph for look.cpp:

Go to the source code of this file.

Data Structures
struct	ATTR_DECODE_ENTRY
Defines
#define	CONTENTS_LOCAL   0
#define	CONTENTS_NESTED   1
#define	CONTENTS_REMOTE   2
Typedefs
typedef struct ATTR_DECODE_ENTRY *	PATTR_DECODE_ENTRY
Functions
static void	look_exits (dbref player, dbref loc, const char *exit_name)
static void	look_contents (dbref player, dbref loc, const char *contents_name, int style)
size_t	decode_attr_flags (int aflags, char *buff)
static void	view_atr (dbref player, dbref thing, ATTR *ap, char *text, dbref aowner, int aflags, bool skip_tag)
static void	look_atrs1 (dbref player, dbref thing, dbref othing, bool check_exclude, bool hash_insert)
static void	look_atrs (dbref player, dbref thing, bool check_parents)
static bool	show_a_desc (dbref player, dbref loc)
static void	look_simple (dbref player, dbref thing, bool obey_terse)
static void	show_desc (dbref player, dbref loc, int key)
void	look_in (dbref player, dbref loc, int key)
void	do_look (dbref executor, dbref caller, dbref enactor, int key, char *name)
static void	debug_examine (dbref player, dbref thing)
static void	exam_wildattrs (dbref player, dbref thing, bool do_parent)
void	do_examine (dbref executor, dbref caller, dbref enactor, int key, char *name)
void	do_score (dbref executor, dbref caller, dbref enactor, int key)
void	do_inventory (dbref executor, dbref caller, dbref enactor, int key)
void	do_entrances (dbref executor, dbref caller, dbref enactor, int key, char *name)
static void	sweep_check (dbref player, dbref what, int key, bool is_loc)
void	do_sweep (dbref executor, dbref caller, dbref enactor, int key, char *where)
void	do_decomp (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *name, char *qual)
void	show_vrml_url (dbref thing, dbref loc)
Variables
static ATTR_DECODE_ENTRY	attr_decode_table []

---

Define Documentation

#define CONTENTS_LOCAL   0

Definition at line 593 of file look.cpp.

Referenced by look_contents(), and look_in().

#define CONTENTS_NESTED   1

Definition at line 594 of file look.cpp.

Referenced by do_look(), and look_contents().

#define CONTENTS_REMOTE   2

Definition at line 595 of file look.cpp.

Referenced by do_examine(), and look_contents().

---

Typedef Documentation

typedef struct ATTR_DECODE_ENTRY * PATTR_DECODE_ENTRY

---

Function Documentation

static void debug_examine	(	dbref	player,
		dbref	thing
	)			[static]

Definition at line 1434 of file look.cpp.

References A_LOCK, alloc_lbuf, atr_get, atr_get_info(), atr_head(), atr_next(), atr_num(), bCanReadAttr(), Contents, Exits, flag_description(), free_boolexp(), free_lbuf, free_mbuf, Good_obj, Link, Location, Name, Next, notify, Owner, parse_boolexp(), Pennies(), powers_list(), rxlevel_description(), safe_chr, safe_str, tprintf(), txlevel_description(), unparse_boolexp(), view_atr(), and Zone.

Referenced by do_examine().

{
    dbref aowner;
    char *buf;
    int aflags, ca;
    BOOLEXP *pBoolExp;
    ATTR *pattr;
    char *as, *cp;

    notify(player, tprintf("Number  = %d", thing));
    if (!Good_obj(thing))
    {
        return;
    }

    notify(player, tprintf("Name    = %s", Name(thing)));
    notify(player, tprintf("Location= %d", Location(thing)));
    notify(player, tprintf("Contents= %d", Contents(thing)));
    notify(player, tprintf("Exits   = %d", Exits(thing)));
    notify(player, tprintf("Link    = %d", Link(thing)));
    notify(player, tprintf("Next    = %d", Next(thing)));
    notify(player, tprintf("Owner   = %d", Owner(thing)));
    notify(player, tprintf("Pennies = %d", Pennies(thing)));
    notify(player, tprintf("Zone    = %d", Zone(thing)));
    buf = flag_description(player, thing);
    notify(player, tprintf("Flags   = %s", buf));
    free_mbuf(buf);
    buf = powers_list(player, thing);
    notify(player, tprintf("Powers  = %s", buf));
    free_lbuf(buf);
#ifdef REALITY_LVLS
    buf = rxlevel_description(player, thing);
    notify(player, tprintf("RxLevel = %s", buf));
    free_lbuf(buf);
    buf = txlevel_description(player, thing);
    notify(player, tprintf("TxLevel = %s", buf));
    free_lbuf(buf);
#endif /* REALITY_LVLS */
    buf = atr_get(thing, A_LOCK, &aowner, &aflags);
    pBoolExp = parse_boolexp(player, buf, true);
    free_lbuf(buf);
    notify(player, tprintf("Lock    = %s", unparse_boolexp(player, pBoolExp)));
    free_boolexp(pBoolExp);

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

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

        atr_get_info(thing, ca, &aowner, &aflags);
        if (bCanReadAttr(player, thing, pattr, false))
        {
            if (pattr)
            {
                // Valid attr.
                //
                safe_str(pattr->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))
    {
        pattr = atr_num(ca);
        if (!pattr)
        {
            continue;
        }

        buf = atr_get(thing, ca, &aowner, &aflags);
        if (bCanReadAttr(player, thing, pattr, false))
        {
            view_atr(player, thing, pattr, buf, aowner, aflags, 0);
        }
        free_lbuf(buf);
    }
}

size_t decode_attr_flags	(	int	aflags,
		char *	buff
	)

Definition at line 774 of file look.cpp.

References attr_decode_table, ATTR_DECODE_ENTRY::letter, and ATTR_DECODE_ENTRY::mask.

Referenced by FUNCTION(), and view_atr().

{
    char *p = buff;
    PATTR_DECODE_ENTRY pEntry;
    for (pEntry = attr_decode_table; pEntry->mask; pEntry++)
    {
        if (aflags & pEntry->mask)
        {
            *p++ = pEntry->letter;
        }
    }
    *p = '\0';
    return p - buff;
}

void do_decomp	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	name,
		char *	qual
	)

Definition at line 2437 of file look.cpp.

References A_LOCK, A_NAME, A_USER_START, AF_IS_LOCK, AF_LOCK, AF_NOCMD, alloc_mbuf, atr_get, atr_head(), atr_next(), atr_num(), bCanReadAttr(), CA_NO_DECOMP, check_access(), DECOMP_DBREF, Examinable, EXIT_DELIMITER, name_table::flag, attr::flags, free_boolexp(), free_lbuf, indiv_attraccess_nametab, init_match(), MAT_EXIT_PARENTS, match_everything(), name_table::name, attr::name, Name, noisy_match_result(), NOTHING, notify, notify_quiet, OBJECT_DEPOSIT, olist_first(), olist_next(), olist_pop(), olist_push(), parse_attrib_wild(), parse_boolexp(), Pennies(), name_table::perm, strip_ansi(), tprintf(), translate_string(), TRUE_BOOLEXP, TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, Typeof, unparse_boolexp_decompile(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(nargs);

    BOOLEXP *pBoolExp;
    char *got, *thingname, *as, *ltext, *buff;
    dbref aowner, thing;
    int val, aflags, ca;
    ATTR *pattr;
    NAMETAB *np;
    bool wild_decomp;

    // Check for obj/attr first.
    //
    olist_push();
    if (parse_attrib_wild(executor, name, &thing, false, true, false))
    {
        wild_decomp = true;
    }
    else
    {
        wild_decomp = false;
        init_match(executor, name, TYPE_THING);
        match_everything(MAT_EXIT_PARENTS);
        thing = noisy_match_result();
    }

    // get result
    //
    if (thing == NOTHING)
    {
        olist_pop();
        return;
    }

    if (!Examinable(executor, thing))
    {
        notify_quiet(executor,
              "You can only decompile things you can examine.");
        olist_pop();
        return;
    }

    thingname = atr_get(thing, A_LOCK, &aowner, &aflags);
    pBoolExp = parse_boolexp(executor, thingname, true);

    // Determine the name of the thing to use in reporting and then
    // report the command to make the thing.
    //
    if (qual && *qual)
    {
        strcpy(thingname, qual);
    }
    else
    {
        if (key == DECOMP_DBREF)
        {
            strcpy(thingname, tprintf("#%d",thing));
        }
        else
        {
            switch (Typeof(thing))
            {
            case TYPE_THING:
                strcpy(thingname, Name(thing));
                val = OBJECT_DEPOSIT(Pennies(thing));
                notify(executor,
                    tprintf("@create %s=%d", translate_string(thingname, true),
                    val));
                break;

            case TYPE_ROOM:
                strcpy(thingname, "here");
                notify(executor, tprintf("@dig/teleport %s",
                    translate_string(Name(thing), true)));
                break;

            case TYPE_EXIT:
                strcpy(thingname, Name(thing));
                notify(executor,
                    tprintf("@open %s", translate_string(thingname, true)));
                for (got = thingname; *got; got++)
                {
                    if (*got == EXIT_DELIMITER)
                    {
                        *got = '\0';
                        break;
                    }
                }
                break;

            case TYPE_PLAYER:
                if (executor == thing)
                {
                    strcpy(thingname, "me");
                }
                else
                {
                    strcpy(thingname, Name(thing));
                }
                break;
            }
        }
    }

    // Strip out ANSI in one place rather than have it done in
    // several places.
    //
    size_t len;
    char *p = strip_ansi(thingname, &len);
    memcpy(thingname, p, len+1);

    // Report the lock (if any).
    //
    if (  !wild_decomp
       && pBoolExp != TRUE_BOOLEXP)
    {
        notify(executor, tprintf("@lock %s=%s", thingname,
            unparse_boolexp_decompile(executor, pBoolExp)));
    }
    free_boolexp(pBoolExp);

    // Report attributes.
    //
    buff = alloc_mbuf("do_decomp.attr_name");
    for (ca = (wild_decomp ? olist_first() : atr_head(thing, &as));
        (wild_decomp) ? (ca != NOTHING) : (ca != 0);
        ca = (wild_decomp ? olist_next() : atr_next(&as)))
    {
        if (  ca == A_NAME
           || ca == A_LOCK)
        {
            continue;
        }
        pattr = atr_num(ca);
        if (!pattr)
        {
            continue;
        }
        if (  (pattr->flags & AF_NOCMD)
           && !(pattr->flags & AF_IS_LOCK))
        {
            continue;
        }

        got = atr_get(thing, ca, &aowner, &aflags);
        if (bCanReadAttr(executor, thing, pattr, false))
        {
            if (pattr->flags & AF_IS_LOCK)
            {
                pBoolExp = parse_boolexp(executor, got, true);
                ltext = unparse_boolexp_decompile(executor, pBoolExp);
                free_boolexp(pBoolExp);
                notify(executor, tprintf("@lock/%s %s=%s", pattr->name,
                    thingname, ltext));
            }
            else
            {
                strcpy(buff, pattr->name);
                notify(executor, tprintf("%c%s %s=%s", ((ca < A_USER_START) ?
                    '@' : '&'), buff, thingname, got));
                for (np = indiv_attraccess_nametab; np->name; np++)
                {
                    if (  (aflags & np->flag)
                       && check_access(executor, np->perm)
                       && (!(np->perm & CA_NO_DECOMP)))
                    {
                        notify(executor, tprintf("@set %s/%s = %s", thingname,
                            buff, np->name));
                    }
                }

                if (aflags & AF_LOCK)
                {
                    notify(executor, tprintf("@lock %s/%s", thingname, buff));
                }
            }
        }
        free_lbuf(got);
    }
    free_mbuf(buff);

    if (!wild_decomp)
    {
        decompile_flags(executor, thing, thingname);
        decompile_powers(executor, thing, thingname);
#ifdef REALITY_LVLS
        decompile_rlevels(executor, thing, thingname);
#endif /* REALITY_LVLS */
    }

    // If the object has a parent, report it.
    //
    if (  !wild_decomp
       && (Parent(thing) != NOTHING))
    {
        notify(executor, tprintf("@parent %s=#%d", thingname, Parent(thing)));
    }

    // If the object has a zone, report it.
    //
    int zone;
    if (  !wild_decomp
       && Good_obj(zone = Zone(thing)))
    {
        notify(executor, tprintf("@chzone %s=#%d", thingname, zone));
    }

    free_lbuf(thingname);
    olist_pop();
}

void do_entrances	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	name
	)

Definition at line 1995 of file look.cpp.

References alloc_lbuf, forward_list::count, forward_list::data, Dropto, Examinable, Exits, free_lbuf, fwdlist_get(), Good_obj, H_Fwdlist, Has_location, Home, init_match(), Location, confdata::many_coins, MAT_EXIT_PARENTS, match_everything(), mudconf, Name, noisy_match_result(), notify, NOTYPE, Parent, parse_range(), payfor(), confdata::searchcost, tprintf(), TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, Typeof, unparse_object(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(key);

    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(executor))
        {
            thing = Location(executor);
        }
        else
        {
            thing = executor;
        }
        if (!Good_obj(thing))
        {
            return;
        }
    }
    else
    {
        init_match(executor, name, NOTYPE);
        match_everything(MAT_EXIT_PARENTS);
        thing = noisy_match_result();
        if (!Good_obj(thing))
        {
            return;
        }
    }

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

            // Check for parents.
            //
            if (Parent(i) == thing)
            {
                exit = unparse_object(executor, i, false);
                notify(executor, tprintf("%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(executor, i, false);
                    notify(executor, tprintf("%s [forward]", exit));
                    free_lbuf(exit);
                    count++;
                }
            }
        }
    }
    free_lbuf(message);
    notify(executor, tprintf("%d entrance%s found.", count,
        (count == 1) ? "" : "s"));
}

void do_examine	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	name
	)

Definition at line 1599 of file look.cpp.

References A_DESC, A_LOCK, alloc_lbuf, atr_get, atr_get_str(), atr_num(), Contents, CONTENTS_REMOTE, debug_examine(), DOLIST, Dropto, confdata::ex_flags, EXAM_BRIEF, EXAM_DEBUG, EXAM_DEFAULT, EXAM_PARENT, confdata::exam_public, exam_wildattrs(), Examinable, Exits, flag_description(), free_boolexp(), free_lbuf, free_mbuf, Good_obj, Has_contents, confdata::have_zones, Hearer(), Home, init_match(), isExit, Link_exit, Linkable, Location, look_atrs(), look_contents(), look_exits(), confdata::many_coins, MAT_EXIT_PARENTS, match_everything(), mudconf, mux_toupper, Name, nearby(), noisy_match_result(), NOMATCH_MESSAGE, NOPERM_MESSAGE, NOTHING, notify, notify_quiet, NOTYPE, olist_pop(), olist_push(), Opaque, Owner, Parent, parse_attrib_wild(), parse_boolexp(), Pennies(), powers_list(), confdata::read_rem_desc, confdata::read_rem_name, rxlevel_description(), show_desc(), tprintf(), txlevel_description(), TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, Typeof, unparse_boolexp(), unparse_object(), UNUSED_PARAMETER, view_atr(), and Zone.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    // This command is pointless if the player can't hear.
    //
    if (!Hearer(executor))
    {
        return;
    }

    dbref content, exit, aowner, loc;
    char savec;
    char *temp, *buf, *buf2;
    BOOLEXP *pBoolExp;
    int aflags;
    bool control;
    bool do_parent = ((key & EXAM_PARENT) ? true : false);

    dbref thing = NOTHING;
    if (  !name
       || !*name)
    {
        thing = Location(executor);
        if (thing == NOTHING)
        {
            return;
        }
    }
    else
    {
        // Check for obj/attr first.
        //
        olist_push();
        if (parse_attrib_wild(executor, name, &thing, do_parent, true, false))
        {
            exam_wildattrs(executor, thing, do_parent);
            olist_pop();
            return;
        }
        olist_pop();

        // Look it up.
        //
        init_match(executor, name, NOTYPE);
        match_everything(MAT_EXIT_PARENTS);
        thing = noisy_match_result();
        if (!Good_obj(thing))
        {
            return;
        }
    }

#if defined(WOD_REALMS) || defined(REALITY_LVLS)
    if (REALM_DO_HIDDEN_FROM_YOU == DoThingToThingVisibility(executor, thing, ACTION_IS_STATIONARY))
    {
        notify(executor, NOMATCH_MESSAGE);
        return;
    }
#endif

    // Check for the /debug switch.
    //
    if (key & EXAM_DEBUG)
    {
        if (!Examinable(executor, thing))
        {
            notify_quiet(executor, NOPERM_MESSAGE);
        }
        else
        {
            debug_examine(executor, thing);
        }
        return;
    }
    control = (  Examinable(executor, thing)
              || Link_exit(executor, thing));

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

    temp = alloc_lbuf("do_examine.info");

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

    if (control)
    {
        // Print owner, key, and value.
        //
        savec = mudconf.many_coins[0];
        mudconf.many_coins[0] = mux_toupper(mudconf.many_coins[0]);
        buf2 = atr_get(thing, A_LOCK, &aowner, &aflags);
        pBoolExp = parse_boolexp(executor, buf2, true);
        buf = unparse_boolexp(executor, pBoolExp);
        free_boolexp(pBoolExp);
        strcpy(buf2, Name(Owner(thing)));
        notify(executor, tprintf("Owner: %s  Key: %s %s: %d", buf2, buf, mudconf.many_coins, Pennies(thing)));
        free_lbuf(buf2);
        mudconf.many_coins[0] = savec;

        // Print the zone
        //
        if (mudconf.have_zones)
        {
            buf2 = unparse_object(executor, Zone(thing), false);
            notify(executor, tprintf("Zone: %s", buf2));
            free_lbuf(buf2);
        }

        // Print parent
        //
        loc = Parent(thing);
        if (loc != NOTHING)
        {
            buf2 = unparse_object(executor, loc, false);
            notify(executor, tprintf("Parent: %s", buf2));
            free_lbuf(buf2);
        }
        buf2 = powers_list(executor, thing);
        notify(executor, tprintf("Powers: %s", buf2));
        free_lbuf(buf2);
#ifdef REALITY_LVLS
        /* Show Rx and Tx levels */

        buf2 = rxlevel_description(executor, thing);
        notify(executor, tprintf("RxLevel: %s", buf2));
        free_mbuf(buf2);
        buf2 = txlevel_description(executor, thing);
        notify(executor, tprintf("TxLevel: %s", buf2));
        free_mbuf(buf2);
#endif /* REALITY_LVLS */
    }
    if (!(key & EXAM_BRIEF))
    {
        look_atrs(executor, thing, do_parent);
    }

    // Show him interesting stuff
    //
    if (control)
    {
        // Contents
        //
        if (Contents(thing) != NOTHING)
        {
            notify(executor, "Contents:");
            DOLIST(content, Contents(thing))
            {
                buf2 = unparse_object(executor, content, false);
                notify(executor, 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(executor, "Exits:");
                DOLIST(exit, Exits(thing))
                {
                    buf2 = unparse_object(executor, exit, false);
                    notify(executor, buf2);
                    free_lbuf(buf2);
                }
            }
            else
            {
                notify(executor, "No exits.");
            }

            // print dropto if present
            //
            if (Dropto(thing) != NOTHING)
            {
                buf2 = unparse_object(executor, Dropto(thing), false);
                notify(executor, tprintf("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(executor, "Exits:");
                DOLIST(exit, Exits(thing))
                {
                    buf2 = unparse_object(executor, exit, false);
                    notify(executor, buf2);
                    free_lbuf(buf2);
                }
            }
            else
            {
                notify(executor, "No exits.");
            }

            // Print home
            //
            loc = Home(thing);
            buf2 = unparse_object(executor, loc, false);
            notify(executor, tprintf("Home: %s", buf2));
            free_lbuf(buf2);

            // print location if player can link to it
            //
            loc = Location(thing);
            if (  Location(thing) != NOTHING
               && (  Examinable(executor, loc)
                  || Examinable(executor, thing)
                  || Linkable(executor, loc)))
            {
                buf2 = unparse_object(executor, loc, false);
                notify(executor, tprintf("Location: %s", buf2));
                free_lbuf(buf2);
            }
            break;

        case TYPE_EXIT:
            buf2 = unparse_object(executor, Exits(thing), false);
            notify(executor, tprintf("Source: %s", buf2));
            free_lbuf(buf2);

            // print destination.
            //
            switch (Location(thing))
            {
            case NOTHING:
                // Special case. unparse_object() normally returns -1 as '*NOTHING*'.
                //
                notify(executor, "Destination: *UNLINKED*");
                break;

            default:
                buf2 = unparse_object(executor, Location(thing), false);
                notify(executor, tprintf("Destination: %s", buf2));
                free_lbuf(buf2);
                break;
            }
            break;

        default:
            break;
        }
    }
    else if (  !Opaque(thing)
            && nearby(executor, thing))
    {
        if (Has_contents(thing))
        {
            look_contents(executor, thing, "Contents:", CONTENTS_REMOTE);
        }
        if (!isExit(thing))
        {
            look_exits(executor, thing, "Obvious exits:");
        }
    }
    free_lbuf(temp);

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

void do_inventory	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key
	)

Definition at line 1948 of file look.cpp.

References alloc_lbuf, Contents, do_score(), DOLIST, Exits, free_lbuf, Name, NOTHING, notify, safe_chr, safe_str, unparse_object(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(key);

    dbref thing;
    char *buff, *e;
    const char *s;

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

    thing = Exits(executor);
    if (thing != NOTHING)
    {
        notify(executor, "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("  ", buff, &e);
        }
        *e = 0;
        notify(executor, buff);
        free_lbuf(buff);
    }
    do_score(executor, caller, executor, 0);
}

void do_look	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	name
	)

Definition at line 1330 of file look.cpp.

References CONTENTS_NESTED, Good_obj, init_match(), IsReal, isRoom, LK_OBEYTERSE, LK_SHOWATTR, LK_SHOWEXIT, Location, Long_Fingers, look_contents(), look_in(), LOOK_OUTSIDE, look_simple(), match_absolute(), match_exit_with_parents(), match_here(), match_master_exit(), match_me(), match_neighbor(), match_player(), match_possessed(), match_possession(), match_result(), match_status(), mudconf, NOTHING, notify_quiet, NOTYPE, Opaque, Terse, confdata::terse_contents, confdata::terse_look, Transparent, TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, Typeof, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

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

    dbref loc = Location(executor);
    dbref thing;
    if (!name || !*name)
    {
        thing = loc;
        if (Good_obj(thing))
        {
            if (key & LOOK_OUTSIDE)
            {
                if (  isRoom(thing)
                   || Opaque(thing))
                {
                    notify_quiet(executor, "You can't look outside.");
                    return;
                }
                thing = Location(thing);
            }
            look_in(executor, thing, look_key);
        }
        return;
    }

    // Look for the target locally.
    //
    thing = (key & LOOK_OUTSIDE) ? loc : executor;
    init_match(thing, name, NOTYPE);
    match_exit_with_parents();
    match_neighbor();
    match_possession();
    if (Long_Fingers(executor))
    {
        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(executor, match_possessed(executor,
            ((key & LOOK_OUTSIDE) ? loc : executor), name, thing, false));
    }

    // If we found something, go handle it.
    //
    if (Good_obj(thing))
    {
#ifdef REALITY_LVLS
        if (!IsReal(executor, thing))
            return;
#endif /* REALITY_LVLS */
        switch (Typeof(thing))
        {
        case TYPE_ROOM:

            look_in(executor, thing, look_key);
            break;

        case TYPE_THING:
        case TYPE_PLAYER:

            look_simple(executor, thing, !mudconf.terse_look);
            if (  !Opaque(thing)
               && (  mudconf.terse_contents
                  || !Terse(executor)))
            {
                look_contents(executor, thing, "Carrying:", CONTENTS_NESTED);
            }
            break;

        case TYPE_EXIT:

            look_simple(executor, thing, !mudconf.terse_look);
            if (  Transparent(thing)
               && Location(thing) != NOTHING)
            {
                look_key &= ~LK_SHOWATTR;
                look_in(executor, Location(thing), look_key);
            }
            break;

        default:

            look_simple(executor, thing, !mudconf.terse_look);
            break;
        }
    }
}

void do_score	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key
	)

Definition at line 1937 of file look.cpp.

References confdata::many_coins, mudconf, notify, confdata::one_coin, Pennies(), tprintf(), and UNUSED_PARAMETER.

Referenced by do_inventory().

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(key);

    int nPennies = Pennies(executor);
    notify(executor, tprintf("You have %d %s.", nPennies,
        (1 == nPennies) ?  mudconf.one_coin : mudconf.many_coins));
}

void do_sweep	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	where
	)

Definition at line 2324 of file look.cpp.

References Contents, Dark, Examinable, Exits, Good_obj, Has_contents, Has_exits, Has_location, Location, match_controlled, mudconf, Next, NOTHING, notify, notify_quiet, sweep_check(), SWEEP_COMMANDS, SWEEP_CONNECT, confdata::sweep_dark, SWEEP_EXITS, SWEEP_HERE, SWEEP_LISTEN, SWEEP_ME, SWEEP_PLAYER, SWEEP_VERBOSE, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    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(executor, where);
        if (!Good_obj(sweeploc))
        {
            return;
        }
    }
    else
    {
        sweeploc = executor;
    }

    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(executor, "Sweeping location...");
        if (Has_location(sweeploc))
        {
            here = Location(sweeploc);
            if (  here == NOTHING
               || (  Dark(here)
                  && !mudconf.sweep_dark
                  && !Examinable(executor, here)))
            {
                notify_quiet(executor,
                    "Sorry, it is dark here and you can't search for bugs");
                sweep_check(executor, sweeploc, what_key, false);
            }
            else
            {
                sweep_check(executor, here, what_key, true);
                for (here = Contents(here); here != NOTHING; here = Next(here))
                {
                    sweep_check(executor, here, what_key, false);
                }
            }
        }
        else
        {
            sweep_check(executor, sweeploc, what_key, false);
        }
    }

    // Check exits in my location
    //
    if (  (where_key & SWEEP_EXITS)
       && Has_location(sweeploc))
    {
        notify(executor, "Sweeping exits...");
        for (here = Exits(Location(sweeploc)); here != NOTHING; here = Next(here))
        {
            sweep_check(executor, here, what_key, false);
        }
    }

    // Check my inventory
    //
    if (  (where_key & SWEEP_ME)
       && Has_contents(sweeploc))
    {
        notify(executor, "Sweeping inventory...");
        for (here = Contents(sweeploc); here != NOTHING; here = Next(here))
        {
            sweep_check(executor, here, what_key, false);
        }
    }

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

static void exam_wildattrs	(	dbref	player,
		dbref	thing,
		bool	do_parent
	)			[static]

Definition at line 1528 of file look.cpp.

References A_DESC, AF_PRIVATE, atr_get, atr_num(), atr_pget, bCanReadAttr(), Examinable, attr::flags, free_lbuf, isPlayer, mudconf, nearby(), NOTHING, notify, notify_quiet, olist_first(), olist_next(), Owner, confdata::read_rem_desc, show_desc(), and view_atr().

Referenced by do_examine().

{
    int atr;
    bool got_any = false;
    for (atr = olist_first(); atr != NOTHING; atr = olist_next())
    {
        ATTR *ap = atr_num(atr);
        if (!ap)
        {
            continue;
        }
        int   aflags;
        dbref aowner;
        char *buf;
        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)
           && bCanReadAttr(player, thing, ap, do_parent))
        {
            got_any = true;
            view_atr(player, thing, ap, buf, aowner, aflags, 0);
        }
        else if (bCanReadAttr(player, thing, ap, isPlayer(thing) ? do_parent : false))
        {
            got_any = true;
            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>");
            }
        }
        free_lbuf(buf);
    }
    if (!got_any)
    {
        notify_quiet(player, "No matching attributes found.");
    }
}

static void look_atrs	(	dbref	player,
		dbref	thing,
		bool	check_parents
	)			[static]

Definition at line 956 of file look.cpp.

References Good_obj, hashflush(), ITER_PARENTS, look_atrs1(), mudstate, Parent, and statedata::parent_htab.

Referenced by do_examine(), look_in(), and look_simple().

{
    dbref parent;
    int lev;
    bool check_exclude, hash_insert;

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

static void look_atrs1	(	dbref	player,
		dbref	thing,
		dbref	othing,
		bool	check_exclude,
		bool	hash_insert
	)			[static]

Definition at line 857 of file look.cpp.

References A_DESC, A_LOCK, AF_NOPROG, AF_PRIVATE, AMATCH_CMD, AMATCH_LISTEN, atr_get, atr_head(), atr_next(), atr_num(), bCanReadAttr(), statedata::bfCommands, statedata::bfListens, statedata::bfNoCommands, statedata::bfNoListens, CBitField::Clear(), attr::flags, free_lbuf, hashaddLEN(), hashfindLEN(), mudstate, statedata::parent_htab, CBitField::Set(), and view_atr().

Referenced by look_atrs().

{
    bool bFoundCommands = false;
    bool bFoundListens  = false;

    char *as;
    for (int ca = atr_head(thing, &as); ca; ca = atr_next(&as))
    {
        if (  ca == A_DESC
           || ca == A_LOCK)
        {
            continue;
        }

        ATTR *pattr = atr_num(ca);
        if (!pattr)
        {
            continue;
        }

        ATTR cattr;
        memcpy(&cattr, pattr, sizeof(ATTR));

        // Should we exclude this attr?
        //
        if (  check_exclude
           && (  (pattr->flags & AF_PRIVATE)
              || hashfindLEN(&ca, sizeof(ca), &mudstate.parent_htab)))
        {
            continue;
        }

        int   aflags;
        dbref aowner;
        char *buf = atr_get(thing, ca, &aowner, &aflags);

        if (!(aflags & AF_NOPROG))
        {
            if (  AMATCH_CMD    == buf[0]
               || AMATCH_LISTEN == buf[0])
            {
                char *s = strchr(buf+1, ':');
                if (s)
                {
                    if (AMATCH_CMD == buf[0])
                    {
                        bFoundCommands = true;
                    }
                    else
                    {
                        bFoundListens = true;
                    }
                }
            }
        }

        if (bCanReadAttr(player, othing, &cattr, false))
        {
            if (!(check_exclude && (aflags & AF_PRIVATE)))
            {
                if (hash_insert)
                {
                    hashaddLEN(&ca, sizeof(ca), pattr, &mudstate.parent_htab);
                }
                view_atr(player, thing, &cattr, buf, aowner, aflags, false);
            }
        }
        free_lbuf(buf);
    }

    if (bFoundCommands)
    {
        mudstate.bfNoCommands.Clear(thing);
        mudstate.bfCommands.Set(thing);
    }
    else
    {
        mudstate.bfCommands.Clear(thing);
        mudstate.bfNoCommands.Set(thing);
    }

    if (bFoundListens)
    {
        mudstate.bfNoListens.Clear(thing);
        mudstate.bfListens.Set(thing);
    }
    else
    {
        mudstate.bfListens.Clear(thing);
        mudstate.bfNoListens.Set(thing);
    }
}

static void look_contents	(	dbref	player,
		dbref	loc,
		const char *	contents_name,
		int	style
	)			[static]

Definition at line 597 of file look.cpp.

References A_CONFORMAT, alloc_lbuf, atr_pget, can_see(), Contents, CONTENTS_LOCAL, CONTENTS_NESTED, CONTENTS_REMOTE, Dark, DOLIST, EV_EVAL, EV_FCHECK, EV_TOP, Examinable, free_lbuf, Html, html_escape(), IsReal, ItemToList_AddInteger(), ItemToList_Final(), ItemToList_Init(), Location, MAX_GLOBAL_REGS, mudconf, mux_exec(), mux_ltoa(), Name, notify, notify_html, restore_global_regs(), safe_str, save_and_clear_global_regs(), confdata::see_own_dark, and unparse_object().

Referenced by do_examine(), do_look(), and look_in().

{
    dbref thing;
    char *buff;
    char *html_buff, *html_cp;
    char remote_num[32];

    // Check to see if he can see the location.
    //
#ifdef REALITY_LVLS
     bool can_see_loc = ( !Dark(loc) && IsReal(player, loc)
#else
     bool can_see_loc = (  !Dark(loc)
#endif /* REALITY_LVLS */
                       || (mudconf.see_own_dark && Examinable(player, loc)));

    dbref aowner;
    int aflags;
    char *ContentsFormatBuffer = atr_pget(loc, A_CONFORMAT, &aowner, &aflags);
    char *ContentsFormat = ContentsFormatBuffer;

    bool bDisplayContents = true;
    if (*ContentsFormat)
    {
        char *VisibleObjectList = alloc_lbuf("look_contents.VOL");
        char *tPtr = VisibleObjectList;

        ITL pContext;
        ItemToList_Init(&pContext, VisibleObjectList, &tPtr, '#');

        DOLIST(thing, Contents(loc))
        {
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
            if (  can_see(player, thing, can_see_loc)
               && (REALM_DO_HIDDEN_FROM_YOU != DoThingToThingVisibility(player,
                                                thing, ACTION_IS_STATIONARY)) )
#else
            if (can_see(player, thing, can_see_loc))
#endif
            {
                if (!ItemToList_AddInteger(&pContext, thing))
                {
                    break;
                }
            }
        }
        ItemToList_Final(&pContext);

        char *ContentsNameScratch = alloc_lbuf("look_contents.CNS");
        tPtr = ContentsNameScratch;

        safe_str(contents_name, ContentsNameScratch, &tPtr);
        *tPtr = '\0';

        char *FormatOutput = alloc_lbuf("look_contents.FO");
        tPtr = FormatOutput;

        char* ParameterList[] =
            { VisibleObjectList, ContentsNameScratch };

        char *preserve[MAX_GLOBAL_REGS];
        int preserve_len[MAX_GLOBAL_REGS];
        save_and_clear_global_regs("look_contents_save", preserve, preserve_len);

        mux_exec(FormatOutput, &tPtr, loc, player, player,
                EV_FCHECK | EV_EVAL | EV_TOP,
                &ContentsFormat, ParameterList, 2);
        *tPtr = '\0';

        restore_global_regs("look_contents_restore", preserve, preserve_len);
        notify(player, FormatOutput);

        free_lbuf(FormatOutput);
        free_lbuf(ContentsNameScratch);
        free_lbuf(VisibleObjectList);

        bDisplayContents = false;
    }
    free_lbuf(ContentsFormatBuffer);

    if (!bDisplayContents)
    {
        return;
    }

    html_buff = html_cp = alloc_lbuf("look_contents");

    // Check to see if there is anything there.
    //
    DOLIST(thing, Contents(loc))
    {
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
        if (  can_see(player, thing, can_see_loc)
           && (REALM_DO_HIDDEN_FROM_YOU != DoThingToThingVisibility(player, thing, ACTION_IS_STATIONARY)))
#else
        if (can_see(player, thing, can_see_loc))
#endif
        {
            // Something exists! Show him everything.
            //
            notify(player, contents_name);
            DOLIST(thing, Contents(loc))
            {
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
                if (  can_see(player, thing, can_see_loc)
                   && (REALM_DO_HIDDEN_FROM_YOU != DoThingToThingVisibility(player, thing, ACTION_IS_STATIONARY)))
#else
                if (can_see(player, thing, can_see_loc))
#endif
                {
                    buff = unparse_object(player, thing, true);
                    html_cp = html_buff;
                    if (Html(player))
                    {
                        safe_str("<a xch_cmd=\"look ", html_buff, &html_cp);
                        switch (style)
                        {
                        case CONTENTS_LOCAL:
                            safe_str(Name(thing), html_buff, &html_cp);
                            break;
                        case CONTENTS_NESTED:
                            safe_str(Name(Location(thing)), html_buff, &html_cp);
                            safe_str("'s ", html_buff, &html_cp);
                            safe_str(Name(thing), html_buff, &html_cp);
                            break;

                        case CONTENTS_REMOTE:

                            remote_num[0] = '#';
                            mux_ltoa(thing, remote_num+1);
                            safe_str(remote_num, html_buff, &html_cp);
                            break;

                        default:

                            break;
                        }
                        safe_str("\">", html_buff, &html_cp);
                        html_escape(buff, html_buff, &html_cp);
                        safe_str("</a>\r\n", html_buff, &html_cp);
                        *html_cp = 0;
                        notify_html(player, html_buff);
                    }
                    else
                    {
                        notify(player, buff);
                    }
                    free_lbuf(buff);
                }
            }
            break;  // we're done.
        }
    }
    free_lbuf(html_buff);
}

static void look_exits	(	dbref	player,
		dbref	loc,
		const char *	exit_name
	)			[static]

Definition at line 383 of file look.cpp.

References A_EXITFORMAT, alloc_lbuf, atr_pget, Dark, DOLIST, EV_EVAL, EV_FCHECK, EV_TOP, exit_displayable(), Exits, free_lbuf, Good_obj, Has_exits, Html, html_escape(), IsReal, ItemToList_AddInteger(), ItemToList_Final(), ItemToList_Init(), ITER_PARENTS, Location, MAX_GLOBAL_REGS, mux_exec(), Name, notify, notify_html, restore_global_regs(), safe_chr, safe_str, save_and_clear_global_regs(), tprintf(), Transparent, VE_BASE_DARK, and VE_LOC_DARK.

Referenced by do_examine(), and look_in().

{
    // Make sure location has exits.
    //
    if (  !Good_obj(loc)
       || !Has_exits(loc))
    {
        return;
    }

    dbref thing, parent;
    char *buff, *e, *buff1, *e1;
    const char *s;

    // make sure there is at least one visible exit.
    //
    bool bFoundAnyDisplayable = false;
    bool bFoundAny = false;
    int key = 0;
    int lev;
#ifdef REALITY_LVLS
    if (Dark(loc) || !IsReal(player, loc))
#else
    if (Dark(loc))
#endif /* REALITY_LVLS */
    {
        key |= VE_BASE_DARK;
    }
    ITER_PARENTS(loc, parent, lev)
    {
        key &= ~VE_LOC_DARK;
        if (Dark(parent))
        {
            key |= VE_LOC_DARK;
        }
        DOLIST(thing, Exits(parent))
        {
            bFoundAny = true;
            if (exit_displayable(thing, player, key))
            {
                bFoundAnyDisplayable = true;
                break;
            }
        }
        if (bFoundAnyDisplayable)
        {
            break;
        }
    }

    if (!bFoundAny)
    {
        return;
    }

    // Retrieve the ExitFormat attribute from the location, evaluate and display
    // the results in lieu of the traditional exits list if it exists.
    //
    dbref aowner;
    int aflags;
    char *ExitFormatBuffer = atr_pget(loc, A_EXITFORMAT, &aowner, &aflags);
    char *ExitFormat = ExitFormatBuffer;

    bool bDisplayExits = bFoundAnyDisplayable;
    if (*ExitFormat)
    {
        char *VisibleObjectList = alloc_lbuf("look_exits.VOL");
        char *tPtr = VisibleObjectList;

        ITL pContext;
        ItemToList_Init(&pContext, VisibleObjectList, &tPtr, '#');

        ITER_PARENTS(loc, parent, lev)
        {
            key &= ~VE_LOC_DARK;
            if (Dark(parent))
            {
                key |= VE_LOC_DARK;
            }

            bool bShortCircuit = false;
            DOLIST(thing, Exits(parent))
            {
                if (  exit_displayable(thing, player, key)
                   && !ItemToList_AddInteger(&pContext, thing))
                {
                    bShortCircuit = true;
                    break;
                }
            }
            if (bShortCircuit) break;
        }
        ItemToList_Final(&pContext);

        char *FormatOutput = alloc_lbuf("look_exits.FO");
        tPtr = FormatOutput;

        char *preserve[MAX_GLOBAL_REGS];
        int preserve_len[MAX_GLOBAL_REGS];
        save_and_clear_global_regs("look_exits_save", preserve, preserve_len);

        mux_exec(FormatOutput, &tPtr, loc, player, player,
                EV_FCHECK | EV_EVAL | EV_TOP,
                &ExitFormat, &VisibleObjectList, 1);
        *tPtr = '\0';

        restore_global_regs("look_exits_restore", preserve, preserve_len);
        notify(player, FormatOutput);

        free_lbuf(FormatOutput);
        free_lbuf(VisibleObjectList);

        bDisplayExits = 0;
    }
    free_lbuf(ExitFormatBuffer);

    if (!bDisplayExits)
    {
        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))
                {
                    strcpy(buff, Name(thing));
                    for (e = buff; *e && *e != ';'; e++)
                    {
                        ; // Nothing.
                    }
                    *e = '\0';
                    notify(player, tprintf("%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("  ", buff, &e);
                    }

                    for (s = Name(thing); *s && (*s != ';'); s++)
                    {
                        safe_chr(*s, buff1, &e1);
                    }

                    *e1 = 0;
                    /* Copy the exit name into 'buff' */
                    if (Html(player))
                    {
                        /* XXX The exit name needs to be HTML escaped. */
                        safe_str("<a xch_cmd=\"", buff, &e);
                        safe_str(buff1, buff, &e);
                        safe_str("\"> ", buff, &e);
                        html_escape(buff1, buff, &e);
                        safe_str(" </a>", buff, &e);
                    }
                    else
                    {
                        /* Append this exit to the list */
                        safe_str(buff1, buff, &e);
                    }
                }
            }
        }
    }

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

void look_in	(	dbref	player,
		dbref	loc,
		int	key
	)

Definition at line 1201 of file look.cpp.

References A_AFAIL, A_ASUCC, A_FAIL, A_LOCK, A_NAMEFORMAT, A_OFAIL, A_OSUCC, A_SUCC, alloc_lbuf, atr_pget, CONTENTS_LOCAL, could_doit(), did_it(), EV_EVAL, EV_FCHECK, EV_TOP, free_lbuf, Good_obj, Hearer(), Html, isRoom, LK_IDESC, LK_OBEYTERSE, LK_SHOWATTR, LK_SHOWEXIT, LK_SHOWVRML, Location, look_atrs(), look_contents(), look_exits(), MAX_GLOBAL_REGS, mudconf, mux_exec(), notify, notify_html, confdata::quiet_look, restore_global_regs(), save_and_clear_global_regs(), show_desc(), show_vrml_url(), Terse, confdata::terse_contents, confdata::terse_exits, and unparse_object().

Referenced by announce_connect(), do_look(), and move_object().

{
    // Only makes sense for things that can hear.
    //
    if (!Hearer(player))
    {
        return;
    }

    // If he needs the VMRL URL, send it:
    //
    if (key & LK_SHOWVRML)
    {
        show_vrml_url(player, loc);
    }

    // Use @nameformat (by Marlek) if it's present, otherwise, use the
    // name and if the player can link to it, it's dbref as well.
    //
    dbref aowner;
    int aflags;
    char *NameFormatBuffer = atr_pget(loc, A_NAMEFORMAT, &aowner, &aflags);
    char *NameFormat = NameFormatBuffer;

    if (*NameFormat)
    {
        char *FormatOutput = alloc_lbuf("look_name.FO");
        char *tPtr = FormatOutput;

        char *preserve[MAX_GLOBAL_REGS];
        int preserve_len[MAX_GLOBAL_REGS];
        save_and_clear_global_regs("look_in_save", preserve, preserve_len);

        mux_exec(FormatOutput, &tPtr, loc, player, player,
                EV_FCHECK | EV_EVAL | EV_TOP,
                &NameFormat, 0, 0);
        *tPtr = '\0';

        restore_global_regs("look_in_restore", preserve, preserve_len);
        notify(player, FormatOutput);

        free_lbuf(FormatOutput);
    }
    else
    {
        // Okay, no @NameFormat.  Show the normal name.
        //
        char *buff = unparse_object(player, loc, true);
        if (Html(player))
        {
            notify_html(player, "<center><h3>");
            notify(player, buff);
            notify_html(player, "</h3></center>");
        }
        else
        {
            notify(player, buff);
        }
        free_lbuf(buff);
    }
    free_lbuf(NameFormatBuffer);

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

    // Tell him the description.
    //
    int showkey = 0;
    if (loc == Location(player))
    {
        showkey |= LK_IDESC;
    }
    if (key & LK_OBEYTERSE)
    {
        showkey |= LK_OBEYTERSE;
    }
    show_desc(player, loc, showkey);

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

    // Tell him the appropriate messages if he has the key.
    //
    if (isRoom(loc))
    {
        int pattr, oattr, aattr;
        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, false);
    }
    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:");
    }
}

static void look_simple	(	dbref	player,
		dbref	thing,
		bool	obey_terse
	)			[static]

Definition at line 1108 of file look.cpp.

References A_ADESC, A_DESC, A_ODESC, did_it(), did_it_rlevel(), Examinable, free_lbuf, Hearer(), look_atrs(), mudconf, NOMATCH_MESSAGE, notify, confdata::quiet_look, show_a_desc(), Terse, confdata::terse_look, and unparse_object().

Referenced by do_look().

{
    // Only makes sense for things that can hear.
    //
    if (!Hearer(player))
    {
        return;
    }

#if defined(WOD_REALMS) || defined(REALITY_LVLS)
    int iRealmDirective = DoThingToThingVisibility(player, thing, ACTION_IS_STATIONARY);
    if (REALM_DO_HIDDEN_FROM_YOU == iRealmDirective)
    {
        notify(player, NOMATCH_MESSAGE);
        return;
    }
#endif

    // Get the name and db-number if we can examine it.
    //
    int can_see_thing = Examinable(player, thing);
    if (can_see_thing)
    {
        char *buff = unparse_object(player, thing, true);
        notify(player, buff);
        free_lbuf(buff);
    }
    int iDescDefault = A_DESC;
    int iADescDefault = A_ADESC;

#if defined(WOD_REALMS) || defined(REALITY_LVLS)
    LetDescriptionsDefault(thing, &iDescDefault, &iADescDefault, iRealmDirective);
#endif

    int pattr = (obey_terse && Terse(player)) ? 0 : iDescDefault;
    if (!show_a_desc(player, thing))
    {
        notify(player, "You see nothing special.");
#ifdef REALITY_LVLS
        did_it_rlevel(player, thing, 0, NULL, A_ODESC, NULL, iADescDefault,
            (char **)NULL, 0);
#else
        did_it(player, thing, pattr, NULL, A_ODESC, NULL, iADescDefault,
            (char **)NULL, 0);
#endif /* REALITY_LVLS */
    }

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

static bool show_a_desc	(	dbref	player,
		dbref	loc
	)			[static]

Definition at line 983 of file look.cpp.

References A_ADESC, A_DESC, A_DESCFORMAT, A_HTDESC, A_ODESC, alloc_lbuf, atr_get_raw(), atr_num(), atr_pget, did_it(), did_it_rlevel(), EV_EVAL, EV_FCHECK, EV_TOP, free_lbuf, Html, confdata::indent_desc, isRoom, mudconf, mux_exec(), attr::name, notify, raw_notify_newline(), and safe_str.

Referenced by look_simple(), and show_desc().

{
    int iDescDefault = A_DESC;
    int iADescDefault = A_ADESC;
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
    int iRealmDirective = DoThingToThingVisibility(player, loc, ACTION_IS_STATIONARY);
    if (REALM_DO_HIDDEN_FROM_YOU == iRealmDirective)
    {
        return true;
    }
    LetDescriptionsDefault(loc, &iDescDefault, &iADescDefault, iRealmDirective);
#endif

    bool ret = false;

    dbref aowner;
    int aflags;
    bool indent = (isRoom(loc) && mudconf.indent_desc && atr_get_raw(loc, A_DESC));

    char *DescFormatBuffer = atr_pget(loc, A_DESCFORMAT, &aowner, &aflags);
    char *DescFormat = DescFormatBuffer;
    if (*DescFormat)
    {
        char *FormatOutput = alloc_lbuf("look_description.FO");
        char *tPtr = FormatOutput;

        ATTR *cattr = atr_num(iDescDefault);

        char *tbuf1 = atr_pget(loc, iDescDefault, &aowner, &aflags);
        char *str = tbuf1;
        char *temp = alloc_lbuf("look_description.ET");
        char *bp = temp;
        mux_exec(temp, &bp, loc, player, player,
               EV_FCHECK | EV_EVAL | EV_TOP,
               &str, (char **)NULL, 0);
        *bp = '\0';

        char *attrname = alloc_lbuf("look_description.AN");
        char *cp = attrname;

        safe_str(cattr->name, attrname, &cp);
        *cp = '\0';
        char* ParameterList[] =
            { temp, attrname };

        mux_exec(FormatOutput, &tPtr, loc, player, player,
                EV_FCHECK | EV_EVAL | EV_TOP,
                &DescFormat, ParameterList, 2);
        *tPtr = '\0';

        notify(player, FormatOutput);
#ifdef REALITY_LVLS
        did_it_rlevel(player, loc, 0, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#else
        did_it(player, loc, 0, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#endif /* REALITY_LVLS */

        free_lbuf(tbuf1);
        free_lbuf(attrname);
        free_lbuf(FormatOutput);
        free_lbuf(temp);

        ret = true;
    }
    else
    {
        char *got;
        if (Html(player))
        {
            got = atr_pget(loc, A_HTDESC, &aowner, &aflags);
            if (*got)
            {
#ifdef REALITY_LVLS
                did_it_rlevel(player, loc, A_HTDESC, NULL, A_ODESC, NULL, A_ADESC, (char **) NULL, 0);
#else
                did_it(player, loc, A_HTDESC, NULL, A_ODESC, NULL, A_ADESC, (char **) NULL, 0);
#endif /* REALITY_LVLS */
                ret = true;
            }
            else
            {
                free_lbuf(got);
                got = atr_pget(loc, iDescDefault, &aowner, &aflags);
                if (*got)
                {
                    if (indent)
                    {
                        raw_notify_newline(player);
                    }
#ifdef REALITY_LVLS
                    did_it_rlevel(player, loc, iDescDefault, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#else
                    did_it(player, loc, iDescDefault, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#endif /* REALITY_LVLS */
                    if (indent)
                    {
                        raw_notify_newline(player);
                    }
                    ret = true;
                }
            }
        }
        else if (*(got = atr_pget(loc, iDescDefault, &aowner, &aflags)))
        {
            if (indent)
            {
                raw_notify_newline(player);
            }
#ifdef REALITY_LVLS
            did_it_rlevel(player, loc, iDescDefault, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#else
            did_it(player, loc, iDescDefault, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#endif /* REALITY_LVLS */
            if (indent)
            {
                raw_notify_newline(player);
            }
            ret = true;
        }
        free_lbuf(got);
    }
    free_lbuf(DescFormatBuffer);
    return ret;
}

static void show_desc	(	dbref	player,
		dbref	loc,
		int	key
	)			[static]

Definition at line 1163 of file look.cpp.

References A_ADESC, A_IDESC, A_ODESC, atr_pget, did_it(), did_it_rlevel(), free_lbuf, isRoom, LK_IDESC, LK_OBEYTERSE, show_a_desc(), and Terse.

Referenced by do_examine(), exam_wildattrs(), and look_in().

{
    char *got;
    dbref aowner;
    int aflags;

    if (  (key & LK_OBEYTERSE)
       && Terse(player))
    {
#ifdef REALITY_LVLS
        did_it_rlevel(player, loc, 0, NULL, A_ODESC, NULL, A_ADESC, (char **)NULL, 0);
#else
        did_it(player, loc, 0, NULL, A_ODESC, NULL, A_ADESC, (char **)NULL, 0);
#endif /* REALITY_LVLS */
    }
    else if (  !isRoom(loc)
            && (key & LK_IDESC))
    {
        if (*(got = atr_pget(loc, A_IDESC, &aowner, &aflags)))
        {
#ifdef REALITY_LVLS
           did_it_rlevel(player, loc, A_IDESC, NULL, A_ODESC, NULL, A_ADESC, (char **)NULL, 0);
#else
            did_it(player, loc, A_IDESC, NULL, A_ODESC, NULL, A_ADESC, (char **)NULL, 0);
#endif /* REALITY_LVLS */
        }
        else
        {
            show_a_desc(player, loc);
        }
        free_lbuf(got);
    }
    else
    {
        show_a_desc(player, loc);
    }
}

void show_vrml_url	(	dbref	thing,
		dbref	loc
	)

Definition at line 2661 of file look.cpp.

References A_VRML_URL, alloc_lbuf, atr_pget, free_lbuf, Html, notify_html, and safe_str.

Referenced by look_in(), and process_enter_loc().

{
    char *vrml_url;
    dbref aowner;
    int aflags;

    // If they don't care about HTML, just return.
    //
    if (!Html(thing))
    {
        return;
    }

    vrml_url = atr_pget(loc, A_VRML_URL, &aowner, &aflags);
    if (*vrml_url)
    {
        char *vrml_message, *vrml_cp;

        vrml_message = vrml_cp = alloc_lbuf("show_vrml_url");
        safe_str("<img xch_graph=load href=\"", vrml_message, &vrml_cp);
        safe_str(vrml_url, vrml_message, &vrml_cp);
        safe_str("\">", vrml_message, &vrml_cp);
        *vrml_cp = 0;
        notify_html(thing, vrml_message);
        free_lbuf(vrml_message);
    }
    else
    {
        notify_html(thing, "<img xch_graph=hide>");
    }
    free_lbuf(vrml_url);
}

static void sweep_check	(	dbref	player,
		dbref	what,
		int	key,
		bool	is_loc
	)			[static]

Definition at line 2119 of file look.cpp.

References AF_NOPROG, alloc_lbuf, AMATCH_CMD, AMATCH_LISTEN, atr_get_str(), atr_head(), atr_next(), atr_num(), Audible, statedata::bfCommands, statedata::bfListens, statedata::bfNoCommands, statedata::bfNoListens, Can_Hide, CBitField::Clear(), Commer(), Connected, attr::flags, free_lbuf, H_Listen, Hidden, isExit, isPlayer, CBitField::IsSet(), ITER_PARENTS, Monitor, mudconf, mudstate, Name, notify, Owner, confdata::player_listen, Puppet, safe_str, See_Hidden, CBitField::Set(), SWEEP_COMMANDS, SWEEP_CONNECT, SWEEP_LISTEN, SWEEP_PLAYER, and tprintf().

Referenced by do_sweep().

{
    if (  Can_Hide(what)
       && Hidden(what)
       && !See_Hidden(player))
    {
        return;
    }

    bool canhear    = false;
    bool cancom     = false;
    bool isplayer   = false;
    bool ispuppet   = false;
    bool isconnected = false;
    bool is_parent  = false;

    if (key & SWEEP_LISTEN)
    {
        if (  (  (  isExit(what)
                 || is_loc)
              && Audible(what))
           || H_Listen(what)
           || mudstate.bfListens.IsSet(what))
        {
            canhear = true;
        }
        else if (  !mudstate.bfNoListens.IsSet(what)
                && Monitor(what))
        {
            bool bFoundCommands = false;

            char *as;
            char *buff = alloc_lbuf("sweep_check.Hearer");
            for (int atr = atr_head(what, &as); atr; atr = atr_next(&as))
            {
                ATTR *ap = atr_num(atr);
                if (  !ap
                   || (ap->flags & AF_NOPROG))
                {
                    continue;
                }

                int   aflags;
                dbref aowner;
                atr_get_str(buff, what, atr, &aowner, &aflags);

                if (aflags & AF_NOPROG)
                {
                    continue;
                }

                char *s = NULL;
                if (  AMATCH_CMD    == buff[0]
                   || AMATCH_LISTEN == buff[0])
                {
                    s = strchr(buff+1, ':');
                    if (s)
                    {
                        if (AMATCH_CMD == buff[0])
                        {
                            bFoundCommands = true;
                        }
                        else
                        {
                            canhear = true;
                            break;
                        }
                    }
                }
            }
            free_lbuf(buff);

            if (canhear)
            {
                mudstate.bfListens.Set(what);
            }
            else
            {
                mudstate.bfNoListens.Set(what);
            }

            if (bFoundCommands)
            {
                mudstate.bfNoCommands.Clear(what);
                mudstate.bfCommands.Set(what);
            }
            else
            {
                mudstate.bfCommands.Clear(what);
                mudstate.bfNoCommands.Set(what);
            }
        }
    }

    if (  (key & SWEEP_COMMANDS)
       && !isExit(what))
    {
        // Look for commands on the object and parents too.
        //
        dbref parent;
        int lev;
        ITER_PARENTS(what, parent, lev)
        {
            if (Commer(parent))
            {
                cancom = true;
                if (lev)
                {
                    is_parent = true;
                    break;
                }
            }
        }
    }

    if (key & SWEEP_CONNECT)
    {
        if (  Connected(what)
           || (  Puppet(what)
              && Connected(Owner(what)))
           || (  mudconf.player_listen
              && isPlayer(what)
              && canhear
              && Connected(Owner(what))))
        {
            isconnected = true;
        }
    }

    if (  (key & SWEEP_PLAYER)
       || isconnected)
    {
        if (isPlayer(what))
        {
            isplayer = true;
        }
        if (Puppet(what))
        {
            ispuppet = true;
        }
    }

    if (  canhear
       || cancom
       || isplayer
       || ispuppet
       || isconnected)
    {
        char *buf = alloc_lbuf("sweep_check.types");
        char *bp = buf;

        if (cancom)
        {
            safe_str("commands ", buf, &bp);
        }

        if (canhear)
        {
            safe_str("messages ", buf, &bp);
        }

        if (isplayer)
        {
            safe_str("player ", buf, &bp);
        }

        if (ispuppet)
        {
            safe_str("puppet(", buf, &bp);
            safe_str(Name(Owner(what)), buf, &bp);
            safe_str(") ", buf, &bp);
        }

        if (isconnected)
        {
            safe_str("connected ", buf, &bp);
        }

        if (is_parent)
        {
            safe_str("parent ", buf, &bp);
        }
        bp[-1] = '\0';

        if (!isExit(what))
        {
            notify(player, tprintf("  %s is listening. [%s]",
                Name(what), buf));
        }
        else
        {
            char *buf2 = alloc_lbuf("sweep_check.name");
            strcpy(buf2, Name(what));
            for (bp = buf2; *bp && (*bp != ';'); bp++)
            {
                ; // Nothing.
            }
            *bp = '\0';
            notify(player, tprintf("  %s is listening. [%s]", buf2, buf));
            free_lbuf(buf2);
        }
        free_lbuf(buf);
    }
}

static void view_atr	(	dbref	player,
		dbref	thing,
		ATTR *	ap,
		char *	text,
		dbref	aowner,
		int	aflags,
		bool	skip_tag
	)			[static]

Definition at line 790 of file look.cpp.

References A_DESC, AF_IS_LOCK, ANSI_HILITE, ANSI_NORMAL, Controls, decode_attr_flags(), attr::flags, free_boolexp(), attr::name, NOTHING, notify, attr::number, Owner, parse_boolexp(), tprintf(), and unparse_boolexp().

Referenced by debug_examine(), do_examine(), exam_wildattrs(), and look_atrs1().

{
    char *buf;

    if (ap->flags & AF_IS_LOCK)
    {
        BOOLEXP *pBoolExp = parse_boolexp(player, text, true);
        text = unparse_boolexp(player, pBoolExp);
        free_boolexp(pBoolExp);
    }

    // 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)
        {
            buf = text;
        }
        else
        {
            buf = tprintf("%s%s:%s %s", ANSI_HILITE, ap->name, ANSI_NORMAL, text);
        }
        notify(player, buf);
        return;
    }

    // Generate flags.
    //
    char xbuf[11];
    decode_attr_flags(aflags, xbuf);

    if (  aowner != Owner(thing)
       && aowner != NOTHING)
    {
        buf = tprintf("%s%s [#%d%s]:%s %s", ANSI_HILITE,
            ap->name, aowner, xbuf, ANSI_NORMAL, text);
    }
    else if (*xbuf)
    {
        buf = tprintf("%s%s [%s]:%s %s", ANSI_HILITE, ap->name,
            xbuf, ANSI_NORMAL, text);
    }
    else if (  !skip_tag
            || ap->number != A_DESC)
    {
        buf = tprintf("%s%s:%s %s", ANSI_HILITE, ap->name, ANSI_NORMAL, text);
    }
    else
    {
        buf = text;
    }
    notify(player, buf);
}

---

Variable Documentation

ATTR_DECODE_ENTRY attr_decode_table[] [static]

Initial value:

{
    { AF_LOCK,    '+' },
    { AF_NOPROG,  '$' },
    { AF_CASE,    'C' },
    { AF_HTML,    'H' },
    { AF_PRIVATE, 'I' },
    { AF_NOPARSE, 'P' },
    { AF_REGEXP,  'R' },
    { AF_VISUAL,  'V' },
    { AF_MDARK,   'M' },
    { AF_WIZARD,  'W' },
    { 0, 0 }
}

Definition at line 759 of file look.cpp.

Referenced by decode_attr_flags().

---