mux/src/move.cpp

Go to the documentation of this file.

// move.cpp -- Routines for moving about.
//
// $Id: move.cpp,v 1.8 2007/04/14 04:57:05 sdennis Exp $
//

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"

#include "attrs.h"
#include "command.h"
#include "interface.h"
#include "powers.h"
#ifdef REALITY_LVLS
#include "levels.h"
#endif /* REALITY_LVLS */

/* ---------------------------------------------------------------------------
 * process_leave_loc: Generate messages and actions resulting from leaving a
 * place.
 */

static void process_leave_loc(dbref thing, dbref dest, dbref cause, bool canhear, int hush)
{
    dbref loc = Location(thing);
    if ((loc == NOTHING) || (loc == dest))
    {
        return;
    }

    if (dest == HOME)
    {
        dest = Home(thing);
    }

    if (Html(thing))
    {
        notify_html(thing, "<xch_page clear=links>");
    }

    // Run the LEAVE attributes in the current room if we meet any of
    // following criteria:
    //
    //   - The current room has wizard privs.
    //   - Neither the current room nor the moving object are dark.
    //   - The moving object can hear and does not hav wizard privs.
    //
    // EXCEPT if we were called with the HUSH_LEAVE key.
    //

#ifdef REALITY_LVLS
    bool quiet = (  (hush & HUSH_LEAVE) || !IsReal(loc, thing)
#else
    bool quiet = (  (hush & HUSH_LEAVE)
#endif /* REALITY_LVLS */
                 || (  !Wizard(loc)
                    && (  Dark(thing)
                       || Dark(loc))
                    && (  !canhear
                       || (  Wizard(thing)
                          && Dark(thing)))));

    int oattr = quiet ? 0 : A_OLEAVE;
    int aattr = quiet ? 0 : A_ALEAVE;
    int pattr = (!mudconf.terse_movemsg && Terse(thing)) ? 0 : A_LEAVE;
    did_it(thing, loc, pattr, NULL, oattr, NULL, aattr,
           (char **)NULL, 0);

    // Do OXENTER for receiving room
    //
    if ((dest != NOTHING) && !quiet)
    {
        did_it(thing, dest, 0, NULL, A_OXENTER, NULL, 0, (char **)NULL, 0);
    }

    // Display the 'has left' message if we meet any of the following
    // criteria:
    //
    //   - Neither the current room nor the moving object are dark.
    //   - The object can hear and is not a dark wizard.
    //
    if (  !quiet
       && !Blind(thing)
       && !Blind(loc))
    {
        if (  (  !Dark(thing)
              && !Dark(loc))
           || (  canhear
              && !(Wizard(thing) && Dark(thing))))
        {
#ifdef REALITY_LVLS
            notify_except2_rlevel(loc, thing, thing, cause,
#else
            notify_except2(loc, thing, thing, cause,
#endif /* REALITY_LVLS */
                       tprintf("%s has left.", Name(thing)));
        }
    }
}

/*---------------------------------------------------------------------------
 * process_enter_loc: Generate messages and actions resulting from entering
 * a place.
 */

static void process_enter_loc(dbref thing, dbref src, dbref cause, bool canhear, int hush)
{
    dbref loc = Location(thing);
    if (  loc == NOTHING
       || loc == src)
    {
        return;
    }

    show_vrml_url(thing, loc);

    // Run the ENTER attributes in the current room if we meet any of following
    // criteria:
    //
    //  - The current room has wizard privs.
    //  - Neither the current room nor the moving object are dark.
    //  - The moving object can hear and does not have wizard privs.
    //
    // EXCEPT if we were called with the HUSH_ENTER key.
    //
#ifdef REALITY_LVLS
    bool quiet = (  (hush & HUSH_ENTER) || !IsReal(loc, thing)
#else
    bool quiet = (  (hush & HUSH_ENTER)
#endif /* REALITY_LVLS */
                 || (  !Wizard(loc)
                    && (  Dark(thing)
                       || Dark(loc))
                    && (  !canhear
                       || (  Wizard(thing)
                          && Dark(thing)))));

    int oattr = quiet ? 0 : A_OENTER;
    int aattr = quiet ? 0 : A_AENTER;
    int pattr = (!mudconf.terse_movemsg && Terse(thing)) ? 0 : A_ENTER;

    did_it(thing, loc, pattr, NULL, oattr, NULL, aattr,
           (char **)NULL, 0);

    // Do OXLEAVE for sending room.
    //
    if (  src != NOTHING
       && !quiet)
    {
        did_it(thing, src, 0, NULL, A_OXLEAVE, NULL, 0, (char **)NULL, 0);
    }

    // Display the 'has arrived' message if we meet all of the following
    // criteria:
    //
    //  - The moving object can hear.
    //  - The object is not a dark wizard.
    //
    if (  !quiet
       && canhear
       && !Blind(thing)
       && !Blind(loc)
       && !(Dark(thing) && Wizard(thing)))
    {
#ifdef REALITY_LVLS
        notify_except2_rlevel(loc, thing, thing, cause,
#else
        notify_except2(loc, thing, thing, cause,
#endif /* REALITY_LVLS */
                   tprintf("%s has arrived.", Name(thing)));
    }
}

/* ---------------------------------------------------------------------------
 * move_object: Physically move an object from one place to another.
 * Does not generate any messages or actions.
 */

void move_object(dbref thing, dbref dest)
{
    dbref src = Location(thing);

    // Remove from the source location
    //
    if (src != NOTHING)
    {
        s_Contents(src, remove_first(Contents(src), thing));
    }

    // Special check for HOME
    //
    if (dest == HOME)
    {
        dest = Home(thing);
    }

    // Add to destination location
    //
    if (dest != NOTHING)
    {
        s_Contents(dest, insert_first(Contents(dest), thing));
    }
    else
    {
        s_Next(thing, NOTHING);
    }
    s_Location(thing, dest);

    // Look around and do the penny check
    //
    look_in(thing, dest, (LK_SHOWEXIT | LK_OBEYTERSE));
    if (  isPlayer(thing)
       && mudconf.payfind > 0
       && Pennies(thing) < mudconf.paylimit
       && !Controls(thing, dest)
       && RandomINT32(0, mudconf.payfind-1) == 0)
    {
        giveto(thing, 1);
        notify(thing, tprintf("You found a %s!", mudconf.one_coin));
    }
}

// move_the_exit: Move an exit silently from its location to its destination
//
static void move_the_exit(dbref thing, dbref dest)
{
    dbref exitloc = Exits(thing);
    s_Exits(exitloc, remove_first(Exits(exitloc), thing));
    s_Exits(dest, insert_first(Exits(dest), thing));
    s_Exits(thing, dest);
}

/* ---------------------------------------------------------------------------
 * send_dropto, process_sticky_dropto, process_dropped_dropto,
 * process_sacrifice_dropto: Check for and process droptos.
 */

// send_dropto: Send an object through the dropto of a room
//
static void send_dropto(dbref thing, dbref player)
{
    if (!Sticky(thing))
    {
        move_via_generic(thing, Dropto(Location(thing)), player, 0);
    }
    else
    {
        move_via_generic(thing, HOME, player, 0);
    }
    divest_object(thing);
}

// process_sticky_dropto: Call when an object leaves the room to see if
// we should empty the room
//
static void process_sticky_dropto(dbref loc, dbref player)
{
    dbref dropto, thing, next;

    // Do nothing if checking anything but a sticky room
    //
    if (!Good_obj(loc) || !Has_dropto(loc) || !Sticky(loc))
        return;

    // Make sure dropto loc is valid
    //
    dropto = Dropto(loc);
    if ((dropto == NOTHING) || (dropto == loc))
        return;

    // Make sure no players hanging out
    //
    DOLIST(thing, Contents(loc))
    {
        if ((Connected(Owner(thing)) && Hearer(thing)))
            return;
    }

    // Send everything through the dropto
    //
    s_Contents(loc, reverse_list(Contents(loc)));
    SAFE_DOLIST(thing, next, Contents(loc))
    {
        send_dropto(thing, player);
    }
}

// process_dropped_dropto: Check what to do when someone drops an object.
//
static void process_dropped_dropto(dbref thing, dbref player)
{
    // If STICKY, send home
    //
    if (Sticky(thing))
    {
        move_via_generic(thing, HOME, player, 0);
        divest_object(thing);
        return;
    }

    // Process the dropto if location is a room and is not STICKY
    //
    dbref loc = Location(thing);
    if (Has_dropto(loc) && (Dropto(loc) != NOTHING) && !Sticky(loc))
        send_dropto(thing, player);
}

/* ---------------------------------------------------------------------------
 * move_via_generic: Generic move routine, generates standard messages and
 * actions.
 */

void move_via_generic(dbref thing, dbref dest, dbref cause, int hush)
{
    if (dest == HOME)
    {
        dest = Home(thing);
    }

    dbref src = Location(thing);
    bool canhear = Hearer(thing);
    process_leave_loc(thing, dest, cause, canhear, hush);
    move_object(thing, dest);
    did_it(thing, thing, A_MOVE, NULL, A_OMOVE, NULL, A_AMOVE,
           (char **)NULL, 0);
    process_enter_loc(thing, src, cause, canhear, hush);
}

/* ---------------------------------------------------------------------------
 * move_via_exit: Exit move routine, generic + exit messages + dropto check.
 */

static void move_via_exit(dbref thing, dbref dest, dbref cause, dbref exit, int hush)
{
    if (dest == HOME)
    {
        dest = Home(thing);
    }
    dbref src = Location(thing);
    bool canhear = Hearer(thing);
    bool quiet = (  (Wizard(thing) && Dark(thing)) // Dark wizards don't trigger OSUCC/ASUCC
                 || (hush & HUSH_EXIT));

    int oattr = quiet ? 0 : A_OSUCC;
    int aattr = quiet ? 0 : A_ASUCC;
    int pattr = (!mudconf.terse_movemsg && Terse(thing)) ? 0 : A_SUCC;
    did_it(thing, exit, pattr, NULL, oattr, NULL, aattr,
           (char **)NULL, 0);
    process_leave_loc(thing, dest, cause, canhear, hush);
    move_object(thing, dest);

    // Dark wizards don't trigger ODROP/ADROP
    //
    oattr = quiet ? 0 : A_ODROP;
    aattr = quiet ? 0 : A_ADROP;
    pattr = (!mudconf.terse_movemsg && Terse(thing)) ? 0 : A_DROP;
    did_it(thing, exit, pattr, NULL, oattr, NULL, aattr,
           (char **)NULL, 0);

    did_it(thing, thing, A_MOVE, NULL, A_OMOVE, NULL, A_AMOVE,
           (char **)NULL, 0);
    process_enter_loc(thing, src, cause, canhear, hush);
    process_sticky_dropto(src, thing);
}

/* ---------------------------------------------------------------------------
 * move_via_teleport: Teleport move routine, generic + teleport messages +
 * divestiture + dropto check.
 */

bool move_via_teleport(dbref thing, dbref dest, dbref cause, int hush)
{
    dbref curr;
    int count;
    char *failmsg;

    dbref src = Location(thing);
    if ((dest != HOME) && Good_obj(src))
    {
        curr = src;
        for (count = mudconf.ntfy_nest_lim; count > 0; count--)
        {
            if (!could_doit(thing, curr, A_LTELOUT))
            {
                if ((thing == cause) || (cause == NOTHING))
                {
                    failmsg = "You can't teleport out!";
                }
                else
                {
                    failmsg = "You can't be teleported out!";
                    notify_quiet(cause, "You can't teleport that out!");
                }
                did_it(thing, src,
                       A_TOFAIL, failmsg, A_OTOFAIL, NULL,
                       A_ATOFAIL, (char **)NULL, 0);
                return false;
            }
            if (isRoom(curr))
            {
                break;
            }
            curr = Location(curr);
        }
    }

    if (isExit(thing))
    {
        move_the_exit(thing, dest);
        return true;
    }
    if (dest == HOME)
    {
        dest = Home(thing);
    }
    bool canhear = Hearer(thing);
    if (!(hush & HUSH_LEAVE))
    {
        did_it(thing, thing, 0, NULL, A_OXTPORT, NULL, 0,
            (char **)NULL, 0);
    }
    process_leave_loc(thing, dest, NOTHING, canhear, hush);

    move_object(thing, dest);

    if (!(hush & HUSH_ENTER))
    {
        did_it(thing, thing, A_TPORT, NULL, A_OTPORT, NULL, A_ATPORT,
            (char **)NULL, 0);
    }
    did_it(thing, thing, A_MOVE, NULL, A_OMOVE, NULL, A_AMOVE,
        (char **)NULL, 0);
    process_enter_loc(thing, src, NOTHING, canhear, hush);
    divest_object(thing);
    process_sticky_dropto(src, thing);
    return true;
}

/* ---------------------------------------------------------------------------
 * move_exit: Try to move a player through an exit.
 */

static dbref get_exit_dest(dbref executor, dbref exit)
{
    dbref aowner;
    int   aflags;
    char *atr_gotten = atr_pget(exit, A_EXITVARDEST, &aowner, &aflags);

    char *result = alloc_lbuf("get_exit_dest");
    char *ref = result;
    char *str = atr_gotten;
    mux_exec(result, &ref, exit, executor, executor, EV_TOP | EV_FCHECK | EV_EVAL,
                &str, (char **)NULL, 0);
    free_lbuf(atr_gotten);
    *ref = '\0';

    dbref dest = NOTHING;
    if (*result == NUMBER_TOKEN)
    {
        dest = mux_atol(result + 1);
    }

    free_lbuf(result);
    return dest;
}

void move_exit(dbref player, dbref exit, bool divest, const char *failmsg, int hush)
{
    int oattr, aattr;
    bool bDoit = false;

    dbref loc = Location(exit);
    if (atr_get_raw(exit, A_EXITVARDEST) != NULL)
    {
        loc = get_exit_dest(player, exit);
    }

    if (loc == HOME)
    {
        loc = Home(player);
    }

#ifdef WOD_REALMS
    if (Good_obj(loc) && (REALM_DO_HIDDEN_FROM_YOU != DoThingToThingVisibility(player, exit, ACTION_IS_MOVING)))
    {
        if (isShroud(player))
        {
            bDoit = true;
            int iShroudWarded = get_atr("SHROUD_WARDED");
            if (iShroudWarded > 0)
            {
                int owner, flags;
                char *buff = atr_pget(exit, iShroudWarded, &owner, &flags);
                if (buff)
                {
                    if (*buff)
                    {
                        bDoit = false;
                    }
                    free_lbuf(buff);
                }
            }
        }

        if (!bDoit && isUmbra(player))
        {
            bDoit = true;
            int iUmbraWarded = get_atr("UMBRA_WARDED");
            if (iUmbraWarded > 0)
            {
                int owner, flags;
                char *buff = atr_pget(exit, iUmbraWarded, &owner, &flags);
                if (buff)
                {
                    if (*buff)
                    {
                        bDoit = false;
                    }
                    free_lbuf(buff);
                }
            }
        }

        if (!bDoit && could_doit(player, exit, A_LOCK))
        {
            bDoit = true;
        }
    }
#else
    if (Good_obj(loc) && could_doit(player, exit, A_LOCK))
    {
        bDoit = true;
    }
#endif
    if (bDoit)
    {
        switch (Typeof(loc))
        {
        case TYPE_ROOM:
            move_via_exit(player, loc, NOTHING, exit, hush);
            if (divest)
                divest_object(player);
            break;
        case TYPE_PLAYER:
        case TYPE_THING:
            if (Going(loc))
            {
                notify(player, "You can't go that way.");
                return;
            }
            move_via_exit(player, loc, NOTHING, exit, hush);
            divest_object(player);
            break;
        case TYPE_EXIT:
            notify(player, "You can't go that way.");
            return;
        }
    }
    else
    {
        if ((Wizard(player) && Dark(player)) || (hush & HUSH_EXIT))
        {
            oattr = 0;
            aattr = 0;
        }
        else
        {
            oattr = A_OFAIL;
            aattr = A_AFAIL;
        }
        did_it(player, exit, A_FAIL, failmsg, oattr, NULL, aattr, (char **)NULL, 0);
    }
}

/* ---------------------------------------------------------------------------
 * do_move: Move from one place to another via exits or 'home'.
 */

void do_move(dbref executor, dbref caller, dbref enactor, int key, char *direction)
{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    dbref exit, loc;
    int i, quiet;

    if (!string_compare(direction, "home"))
    {
        // Go home w/o stuff.
        //
        if (  (  Fixed(executor)
              || Fixed(Owner(executor)))
           && !(WizRoy(executor)))
        {
            notify(executor, mudconf.fixed_home_msg);
            return;
        }

        if (  (loc = Location(executor)) != NOTHING
           && !Dark(executor)
           && !Dark(loc))
        {
            // Tell all
            //
            notify_except(loc, executor, executor, tprintf("%s goes home.", Name(executor)), 0);
        }
        // Give the player the messages
        //
        for (i = 0; i < 3; i++)
            notify(executor, "There's no place like home...");
        move_via_generic(executor, HOME, NOTHING, 0);
        divest_object(executor);
        process_sticky_dropto(loc, executor);
        return;
    }
    // Find the exit.
    //
    init_match_check_keys(executor, direction, TYPE_EXIT);
    match_exit();
    exit = match_result();
    switch (exit)
    {
    case NOTHING:       // Try to force the object
        notify(executor, "You can't go that way.");
        break;
    case AMBIGUOUS:
        notify(executor, "I don't know which way you mean!");
        break;
    default:
        quiet = 0;
        if ((key & MOVE_QUIET) && Controls(executor, exit))
            quiet = HUSH_EXIT;
        move_exit(executor, exit, false, "You can't go that way.", quiet);
    }
}

/* ---------------------------------------------------------------------------
 * do_get: Get an object.
 */

void do_get(dbref executor, dbref caller, dbref enactor, int key, char *what)
{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    dbref playerloc;
    if (  !Has_location(executor)
       || !Good_obj(playerloc = Location(executor)))
    {
        return;
    }

    // You can only pick up things in rooms and ENTER_OK objects/players.
    //
    if (  !isRoom(playerloc)
       && !Enter_ok(playerloc)
       && !Controls(executor, playerloc))
    {
        notify(executor, NOPERM_MESSAGE);
        return;
    }

    // Look for the thing locally.
    //
    init_match_check_keys(executor, what, TYPE_THING);
    match_neighbor();
    match_exit();
    if (Long_Fingers(executor))
    {
        match_absolute();
    }
    dbref thing = match_result();

    // Look for the thing in other people's inventories.
    //
    if (!Good_obj(thing))
    {
        thing = match_status(executor, match_possessed(executor, executor, what,
            thing, true));

        if (!Good_obj(thing))
        {
            return;
        }
    }

    // If we found it, check to see if we can get it.
    //
    dbref thingloc = Location(thing);
    if (Good_obj(thingloc))
    {
        if (!could_doit(executor, thingloc, A_LGET))
        {
            notify(executor, NOPERM_MESSAGE);
            return;
        }
    }

    // If we can get it, get it.
    //
    const char *failmsg;
    int oattr, aattr;
    bool quiet = false;
    switch (Typeof(thing))
    {
    case TYPE_PLAYER:
    case TYPE_THING:

        // You can't take what you already have.
        //
        if (thingloc == executor)
        {
            notify(executor, "You already have that!");
            break;
        }
        if (  (key & GET_QUIET)
           && Controls(executor, thing))
        {
            quiet = true;
        }

        if (thing == executor)
        {
            notify(executor, "You cannot get yourself!");
        }
        else if (could_doit(executor, thing, A_LOCK))
        {
            if (thingloc != playerloc)
            {
                notify(thingloc, tprintf("%s was taken from you.",
                    Name(thing)));
            }
            move_via_generic(thing, executor, executor, 0);
            notify(thing, "Taken.");
            oattr = quiet ? 0 : A_OSUCC;
            aattr = quiet ? 0 : A_ASUCC;
            did_it(executor, thing, A_SUCC, "Taken.", oattr, NULL,
                   aattr, (char **)NULL, 0);
        }
        else
        {
            oattr = quiet ? 0 : A_OFAIL;
            aattr = quiet ? 0 : A_AFAIL;
            if (thingloc != playerloc)
            {
                failmsg = "You can't take that from there.";
            }
            else
            {
                failmsg = "You can't pick that up.";
            }
            did_it(executor, thing, A_FAIL, failmsg, oattr, NULL, aattr,
                (char **)NULL, 0);
        }
        break;

    case TYPE_EXIT:

        // You can't take what you already have.
        //
        thingloc = Exits(thing);
        if (thingloc == executor)
        {
            notify(executor, "You already have that!");
            break;
        }

        // You must control either the exit or the location.
        //
        if (  !Controls(executor, thing)
           && !Controls(executor, playerloc))
        {
            notify(executor, NOPERM_MESSAGE);
            break;
        }

        // Do it.
        //
        s_Exits(thingloc, remove_first(Exits(thingloc), thing));
        s_Exits(executor, insert_first(Exits(executor), thing));
        s_Exits(thing, executor);
        if (!Quiet(executor))
        {
            notify(executor, "Exit taken.");
        }
        break;

    default:

        notify(executor, "You can't take that!");
        break;
    }
}

/* ---------------------------------------------------------------------------
 * do_drop: Drop an object.
 */

void do_drop(dbref executor, dbref caller, dbref enactor, int key, char *name)
{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    dbref loc = Location(executor);
    if (!Good_obj(loc))
        return;

    dbref exitloc, thing;
    char *buf, *bp;
    int oattr, aattr;
    bool quiet;

    init_match(executor, name, TYPE_THING);
    match_possession();
    match_carried_exit();

    switch (thing = match_result())
    {
    case NOTHING:
        notify(executor, "You don't have that!");
        return;
    case AMBIGUOUS:
        notify(executor, "I don't know which you mean!");
        return;
    }

    switch (Typeof(thing))
    {
    case TYPE_THING:
    case TYPE_PLAYER:

        // You have to be carrying it.
        //
        if (  (  Location(thing) != executor
              && !Wizard(executor))
           || !could_doit(executor, thing, A_LDROP))
        {
            did_it(executor, thing, A_DFAIL, "You can't drop that.",
                   A_ODFAIL, NULL, A_ADFAIL, (char **)NULL, 0);
            return;
        }

        // Move it
        //
        move_via_generic(thing, Location(executor), executor, 0);
        notify(thing, "Dropped.");
        quiet = false;
        if ((key & DROP_QUIET) && Controls(executor, thing))
            quiet = true;
        bp = buf = alloc_lbuf("do_drop.did_it");
        safe_tprintf_str(buf, &bp, "dropped %s.", Name(thing));
        oattr = quiet ? 0 : A_ODROP;
        aattr = quiet ? 0 : A_ADROP;
        did_it(executor, thing, A_DROP, "Dropped.", oattr, buf,
               aattr, (char **)NULL, 0);
        free_lbuf(buf);

        // Process droptos
        //
        process_dropped_dropto(thing, executor);

        break;
    case TYPE_EXIT:

        // You have to be carrying it.
        //
        if ((Exits(thing) != executor) && !Wizard(executor))
        {
            notify(executor, "You can't drop that.");
            return;
        }
        if (!Controls(executor, loc))
        {
            notify(executor, NOPERM_MESSAGE);
            return;
        }

        // Do it
        //
        exitloc = Exits(thing);
        s_Exits(exitloc, remove_first(Exits(exitloc), thing));
        s_Exits(loc, insert_first(Exits(loc), thing));
        s_Exits(thing, loc);

        if (!Quiet(executor))
            notify(executor, "Exit dropped.");
        break;
    default:
        notify(executor, "You can't drop that.");
    }
}

/* ---------------------------------------------------------------------------
 * do_enter, do_leave: The enter and leave commands.
 */

void do_enter_internal(dbref player, dbref thing, bool quiet)
{
    int oattr, aattr;

    if (!Enter_ok(thing) && !Controls(player, thing))
    {
        oattr = quiet ? 0 : A_OEFAIL;
        aattr = quiet ? 0 : A_AEFAIL;
        did_it(player, thing, A_EFAIL, NOPERM_MESSAGE,
               oattr, NULL, aattr, (char **)NULL, 0);
    }
    else if (player == thing)
    {
        notify(player, "You can't enter yourself!");
    }
    else if (could_doit(player, thing, A_LENTER))
    {
        dbref loc = Location(player);
        oattr = quiet ? HUSH_ENTER : 0;
        move_via_generic(player, thing, NOTHING, oattr);
        divest_object(player);
        process_sticky_dropto(loc, player);
    }
    else
    {
        oattr = quiet ? 0 : A_OEFAIL;
        aattr = quiet ? 0 : A_AEFAIL;
        did_it(player, thing, A_EFAIL, "You can't enter that.",
               oattr, NULL, aattr, (char **)NULL, 0);
    }
}

void do_enter(dbref executor, dbref caller, dbref enactor, int key, char *what)
{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    init_match(executor, what, TYPE_THING);
    match_neighbor();
    if (Long_Fingers(executor))
        match_absolute();   // the wizard has long fingers

    dbref thing = noisy_match_result();
    bool bQuiet = false;

    if (thing == NOTHING)
        return;

    switch (Typeof(thing))
    {
    case TYPE_PLAYER:
    case TYPE_THING:
        if ((key & MOVE_QUIET) && Controls(executor, thing))
            bQuiet = true;
        do_enter_internal(executor, thing, bQuiet);
        break;
    default:
        notify(executor, NOPERM_MESSAGE);
    }
    return;
}

void do_leave(dbref executor, dbref caller, dbref enactor, int key)
{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    dbref loc = Location(executor);
    dbref newLoc = loc;

    if (  !Good_obj(loc)
       || Going(loc)
       || !Has_location(loc)
       || !Good_obj(newLoc = Location(loc))
       || Going(newLoc))
    {
        notify(executor, "You can't leave.");
        return;
    }
    int quiet = 0;
    if (  (key & MOVE_QUIET)
       && Controls(executor, loc))
    {
        quiet = HUSH_LEAVE;
    }
    if (could_doit(executor, loc, A_LLEAVE))
    {
        move_via_generic(executor, newLoc, NOTHING, quiet);
    }
    else
    {
        int oattr = quiet ? 0 : A_OLFAIL;
        int aattr = quiet ? 0 : A_ALFAIL;
        did_it(executor, loc, A_LFAIL, "You can't leave.",
               oattr, NULL, aattr, (char **)NULL, 0);
    }
}

---