mux/src/move.cpp File Reference

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

Include dependency graph for move.cpp:

Go to the source code of this file.

Functions
static void	process_leave_loc (dbref thing, dbref dest, dbref cause, bool canhear, int hush)
static void	process_enter_loc (dbref thing, dbref src, dbref cause, bool canhear, int hush)
void	move_object (dbref thing, dbref dest)
static void	move_the_exit (dbref thing, dbref dest)
static void	send_dropto (dbref thing, dbref player)
static void	process_sticky_dropto (dbref loc, dbref player)
static void	process_dropped_dropto (dbref thing, dbref player)
void	move_via_generic (dbref thing, dbref dest, dbref cause, int hush)
static void	move_via_exit (dbref thing, dbref dest, dbref cause, dbref exit, int hush)
bool	move_via_teleport (dbref thing, dbref dest, dbref cause, int hush)
static dbref	get_exit_dest (dbref executor, dbref exit)
void	move_exit (dbref player, dbref exit, bool divest, const char *failmsg, int hush)
void	do_move (dbref executor, dbref caller, dbref enactor, int key, char *direction)
void	do_get (dbref executor, dbref caller, dbref enactor, int key, char *what)
void	do_drop (dbref executor, dbref caller, dbref enactor, int key, char *name)
void	do_enter_internal (dbref player, dbref thing, bool quiet)
void	do_enter (dbref executor, dbref caller, dbref enactor, int key, char *what)
void	do_leave (dbref executor, dbref caller, dbref enactor, int key)

---

Function Documentation

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

Definition at line 800 of file move.cpp.

References A_ADFAIL, A_ADROP, A_DFAIL, A_DROP, A_LDROP, A_ODFAIL, A_ODROP, alloc_lbuf, AMBIGUOUS, Controls, could_doit(), did_it(), DROP_QUIET, Exits, free_lbuf, Good_obj, init_match(), insert_first(), Location, match_carried_exit(), match_possession(), match_result(), move_via_generic(), Name, NOPERM_MESSAGE, NOTHING, notify, process_dropped_dropto(), Quiet, remove_first(), s_Exits, safe_tprintf_str(), TYPE_EXIT, TYPE_PLAYER, TYPE_THING, Typeof, UNUSED_PARAMETER, and Wizard.

{
    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.");
    }
}

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

Definition at line 930 of file move.cpp.

References Controls, do_enter_internal(), init_match(), Long_Fingers, match_absolute(), match_neighbor(), MOVE_QUIET, noisy_match_result(), NOPERM_MESSAGE, NOTHING, notify, TYPE_PLAYER, TYPE_THING, Typeof, and UNUSED_PARAMETER.

{
    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_enter_internal	(	dbref	player,
		dbref	thing,
		bool	quiet
	)

Definition at line 898 of file move.cpp.

References A_AEFAIL, A_EFAIL, A_LENTER, A_OEFAIL, Controls, could_doit(), did_it(), divest_object(), Enter_ok, HUSH_ENTER, Location, move_via_generic(), NOPERM_MESSAGE, NOTHING, notify, and process_sticky_dropto().

Referenced by do_enter(), and process_command().

{
    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_get	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	what
	)

Definition at line 642 of file move.cpp.

References A_AFAIL, A_ASUCC, A_FAIL, A_LGET, A_LOCK, A_OFAIL, A_OSUCC, A_SUCC, Controls, could_doit(), did_it(), Enter_ok, Exits, GET_QUIET, Good_obj, Has_location, init_match_check_keys(), insert_first(), isRoom, Location, Long_Fingers, match_absolute(), match_exit(), match_neighbor(), match_possessed(), match_result(), match_status(), move_via_generic(), Name, NOPERM_MESSAGE, notify, Quiet, remove_first(), s_Exits, tprintf(), TYPE_EXIT, TYPE_PLAYER, TYPE_THING, Typeof, and UNUSED_PARAMETER.

{
    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;
    }
}

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

Definition at line 960 of file move.cpp.

References A_ALFAIL, A_LFAIL, A_LLEAVE, A_OLFAIL, Controls, could_doit(), did_it(), Going, Good_obj, Has_location, HUSH_LEAVE, Location, MOVE_QUIET, move_via_generic(), NOTHING, notify, and UNUSED_PARAMETER.

Referenced by process_command().

{
    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);
    }
}

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

Definition at line 580 of file move.cpp.

References AMBIGUOUS, Controls, Dark, divest_object(), Fixed, confdata::fixed_home_msg, HOME, HUSH_EXIT, init_match_check_keys(), Location, match_exit(), match_result(), move_exit(), MOVE_QUIET, move_via_generic(), mudconf, Name, NOTHING, notify, notify_except(), Owner, process_sticky_dropto(), string_compare(), tprintf(), TYPE_EXIT, UNUSED_PARAMETER, and WizRoy.

Referenced by process_command().

{
    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);
    }
}

static dbref get_exit_dest	(	dbref	executor,
		dbref	exit
	)			[static]

Definition at line 444 of file move.cpp.

References A_EXITVARDEST, alloc_lbuf, atr_pget, EV_EVAL, EV_FCHECK, EV_TOP, free_lbuf, mux_atol(), mux_exec(), NOTHING, and NUMBER_TOKEN.

Referenced by move_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
	)

Definition at line 468 of file move.cpp.

References A_AFAIL, A_EXITVARDEST, A_FAIL, A_LOCK, A_OFAIL, atr_get_raw(), atr_pget, could_doit(), Dark, did_it(), divest_object(), free_lbuf, get_atr(), get_exit_dest(), Going, Good_obj, Home, HOME, HUSH_EXIT, Location, move_via_exit(), NOTHING, notify, TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, Typeof, and Wizard.

Referenced by do_move(), do_teleport_single(), and process_command().

{
    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);
    }
}

void move_object	(	dbref	thing,
		dbref	dest
	)

Definition at line 180 of file move.cpp.

References Contents, Controls, giveto(), Home, HOME, insert_first(), isPlayer, LK_OBEYTERSE, LK_SHOWEXIT, Location, look_in(), mudconf, NOTHING, notify, confdata::one_coin, confdata::payfind, confdata::paylimit, Pennies(), RandomINT32(), remove_first(), s_Contents, s_Location, s_Next, and tprintf().

Referenced by check_connect(), check_dead_refs(), CGuests::Create(), do_pcreate(), CGuests::MakeGuestChar(), move_via_exit(), move_via_generic(), and move_via_teleport().

{
    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));
    }
}

static void move_the_exit	(	dbref	thing,
		dbref	dest
	)			[static]

Definition at line 226 of file move.cpp.

References Exits, insert_first(), remove_first(), and s_Exits.

Referenced by move_via_teleport().

{
    dbref exitloc = Exits(thing);
    s_Exits(exitloc, remove_first(Exits(exitloc), thing));
    s_Exits(dest, insert_first(Exits(dest), thing));
    s_Exits(thing, dest);
}

static void move_via_exit	(	dbref	thing,
		dbref	dest,
		dbref	cause,
		dbref	exit,
		int	hush
	)			[static]

Definition at line 334 of file move.cpp.

References A_ADROP, A_AMOVE, A_ASUCC, A_DROP, A_MOVE, A_ODROP, A_OMOVE, A_OSUCC, A_SUCC, Dark, did_it(), Hearer(), Home, HOME, HUSH_EXIT, Location, move_object(), mudconf, process_enter_loc(), process_leave_loc(), process_sticky_dropto(), Terse, confdata::terse_movemsg, and Wizard.

Referenced by move_exit().

{
    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);
}

void move_via_generic	(	dbref	thing,
		dbref	dest,
		dbref	cause,
		int	hush
	)

Definition at line 314 of file move.cpp.

References A_AMOVE, A_MOVE, A_OMOVE, did_it(), Hearer(), Home, HOME, Location, move_object(), process_enter_loc(), and process_leave_loc().

Referenced by check_contents_chains(), destroy_player(), destroy_thing(), divest_object(), do_clone(), do_create(), do_drop(), do_enter_internal(), do_get(), do_kill(), do_leave(), do_move(), empty_obj(), FUNCTION(), give_thing(), process_dropped_dropto(), and send_dropto().

{
    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);
}

bool move_via_teleport	(	dbref	thing,
		dbref	dest,
		dbref	cause,
		int	hush
	)

Definition at line 372 of file move.cpp.

References A_AMOVE, A_ATOFAIL, A_ATPORT, A_LTELOUT, A_MOVE, A_OMOVE, A_OTOFAIL, A_OTPORT, A_OXTPORT, A_TOFAIL, A_TPORT, could_doit(), did_it(), divest_object(), Good_obj, Hearer(), Home, HOME, HUSH_ENTER, HUSH_LEAVE, isExit, isRoom, Location, move_object(), move_the_exit(), mudconf, NOTHING, notify_quiet, confdata::ntfy_nest_lim, process_enter_loc(), process_leave_loc(), and process_sticky_dropto().

Referenced by do_dig(), and do_teleport_single().

{
    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;
}

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

Definition at line 291 of file move.cpp.

References divest_object(), Dropto, Has_dropto, HOME, Location, move_via_generic(), NOTHING, send_dropto(), and Sticky.

Referenced by do_drop().

{
    // 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);
}

static void process_enter_loc	(	dbref	thing,
		dbref	src,
		dbref	cause,
		bool	canhear,
		int	hush
	)			[static]

Definition at line 107 of file move.cpp.

References A_AENTER, A_ENTER, A_OENTER, A_OXLEAVE, Blind, Dark, did_it(), HUSH_ENTER, IsReal, Location, mudconf, Name, NOTHING, notify_except2(), notify_except2_rlevel(), show_vrml_url(), Terse, confdata::terse_movemsg, tprintf(), and Wizard.

Referenced by move_via_exit(), move_via_generic(), and move_via_teleport().

{
    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)));
    }
}

static void process_leave_loc	(	dbref	thing,
		dbref	dest,
		dbref	cause,
		bool	canhear,
		int	hush
	)			[static]

Definition at line 24 of file move.cpp.

References A_ALEAVE, A_LEAVE, A_OLEAVE, A_OXENTER, Blind, Dark, did_it(), Home, HOME, Html, HUSH_LEAVE, IsReal, Location, mudconf, Name, NOTHING, notify_except2(), notify_except2_rlevel(), notify_html, Terse, confdata::terse_movemsg, tprintf(), and Wizard.

Referenced by move_via_exit(), move_via_generic(), and move_via_teleport().

{
    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)));
        }
    }
}

static void process_sticky_dropto	(	dbref	loc,
		dbref	player
	)			[static]

Definition at line 257 of file move.cpp.

References Connected, Contents, DOLIST, Dropto, Good_obj, Has_dropto, Hearer(), next, NOTHING, Owner, reverse_list(), s_Contents, SAFE_DOLIST, send_dropto(), and Sticky.

Referenced by do_enter_internal(), do_move(), move_via_exit(), and move_via_teleport().

{
    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);
    }
}

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

Definition at line 241 of file move.cpp.

References divest_object(), Dropto, HOME, Location, move_via_generic(), and Sticky.

Referenced by process_dropped_dropto(), and process_sticky_dropto().

{
    if (!Sticky(thing))
    {
        move_via_generic(thing, Dropto(Location(thing)), player, 0);
    }
    else
    {
        move_via_generic(thing, HOME, player, 0);
    }
    divest_object(thing);
}

---