void
do_mcpedit(int descr, dbref player, const char *name)
{
dbref i;
struct match_data md;
McpFrame *mfr;
if (!(mfr = descr_mcpframe(descr))) {
do_edit(descr, player, name);
return;
} else if (Typeof(player) != TYPE_PLAYER) {
anotify_nolisten2(player, CFAIL "Only players can edit programs.");
return;
} else if (!Mucker(player)) {
anotify_nolisten2(player, CFAIL NOMBIT_MESG);
return;
} else if (tp_db_readonly) {
anotify_nolisten2(player, CFAIL DBRO_MESG);
return;
} else if (!*name) {
anotify_nolisten2(player, CINFO "No program name given.");
return;
}
init_match(descr, player, name, TYPE_PROGRAM, &md);
match_possession(&md);
match_neighbor(&md);
match_registered(&md);
match_absolute(&md);
if ((i = noisy_match_result(&md)) == NOTHING || i == AMBIGUOUS)
return;
mcpedit_program(descr, player, i, name, mfr);
}
/*
Use this to create a program.
First, find a program that matches that name. If there's one,
then we put him into edit mode and do it.
Otherwise, we create a new object for him, and call it a program.
*/
void
do_prog(int descr, dbref player, const char *name)
{
dbref i;
struct match_data md;
if (Typeof(player) != TYPE_PLAYER) {
anotify_nolisten2(player, CFAIL "Only players can edit programs.");
return;
} else if (!Mucker(player)) {
anotify_nolisten2(player, CFAIL NOMBIT_MESG);
return;
} else if (!tp_building || tp_db_readonly) {
anotify_nolisten2(player, CFAIL NOBUILD_MESG);
return;
} else if (!*name) {
anotify_nolisten2(player, CINFO "No program name given.");
return;
}
init_match(descr, player, name, TYPE_PROGRAM, &md);
match_possession(&md);
match_neighbor(&md);
match_registered(&md);
match_absolute(&md);
if ((i = match_result(&md)) == NOTHING) {
i = new_program(OWNER(player), name);
FLAGS(i) |= INTERNAL;
DBFETCH(player)->sp.player.curr_prog = i;
anotify_fmt(player, CSUCC "Program %s created with number %d.", name,
i);
anotify_nolisten2(player, CINFO "Entering editor.");
} else if (i == AMBIGUOUS) {
anotify_nolisten2(player, CINFO "I don't know which one you mean!");
return;
} else {
if ((Typeof(i) != TYPE_PROGRAM) || !controls(player, i)) {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
return;
} else if (FLAGS(i) & INTERNAL) {
anotify_nolisten2(player, CFAIL NOEDIT_MESG);
return;
}
DBFETCH(i)->sp.program.first = read_program(i);
FLAGS(i) |= INTERNAL;
DBFETCH(player)->sp.player.curr_prog = i;
anotify_fmt(player, CINFO "Entering editor for %s.",
unparse_object(player, i));
/* list current line */
do_list(player, i, 0, 0, 0);
DBDIRTY(i);
}
FLAGS(player) |= INTERACTIVE;
DBDIRTY(player);
}
/*
* do_attach()
*
* This routine attaches a previously existing action to a source object.
* The action will not do anything unless it is LINKed.
*
*/
void
do_attach(int descr, dbref player, const char *action_name,
const char *source_name)
{
dbref action, source;
dbref loc; /* player's current location */
struct match_data md;
char buf[BUFFER_LEN];
if ((loc = DBFETCH(player)->location) == NOTHING)
return;
if (tp_db_readonly) {
anotify_nolisten2(player, CFAIL DBRO_MESG);
return;
}
if (!*action_name || !*source_name) {
anotify_nolisten2(player,
CINFO
"You must specify an action name and a source object.");
return;
}
init_match(descr, player, action_name, TYPE_EXIT, &md);
match_all_exits(&md);
match_registered(&md);
match_absolute(&md);
if ((action = noisy_match_result(&md)) == NOTHING)
return;
if (Typeof(action) != TYPE_EXIT) {
anotify_nolisten2(player, CINFO "That's not an action.");
return;
} else if (!controls(player, action)) {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
return;
}
if (((source = parse_source(descr, player, source_name)) == NOTHING)
|| Typeof(source) == TYPE_PROGRAM)
return;
if (!unset_source(player, loc, action)) {
return;
}
set_source(player, action, source);
sprintf(buf, CSUCC "Action %s re-attached to %s.",
unparse_object(player, action), NAME(source));
anotify_nolisten2(player, buf);
if (MLevel(action)) {
SetMLevel(action, 0);
anotify_nolisten2(player, CINFO "Action priority Level reset to zero.");
}
}
dbref
mesg_dbref_raw(int descr, dbref player, dbref what, dbref perms, const char *buf)
{
struct match_data md;
dbref obj = UNKNOWN;
if (buf && *buf) {
if (!string_compare(buf, "this")) {
obj = what;
} else if (!string_compare(buf, "me")) {
obj = player;
} else if (!string_compare(buf, "here")) {
obj = getloc(player);
} else if (!string_compare(buf, "home")) {
obj = HOME;
} else {
init_match(descr, player, buf, NOTYPE, &md);
match_absolute(&md);
match_all_exits(&md);
match_neighbor(&md);
match_possession(&md);
match_registered(&md);
obj = match_result(&md);
if (obj == NOTHING) {
init_match_remote(descr, player, what, buf, NOTYPE, &md);
match_player(&md);
match_all_exits(&md);
match_neighbor(&md);
match_possession(&md);
match_registered(&md);
obj = match_result(&md);
}
}
}
if (obj < 0 || obj >= db_top || Typeof(obj) == TYPE_GARBAGE)
obj = UNKNOWN;
return obj;
}
void
do_edit(int descr, dbref player, const char *name)
{
dbref i;
struct match_data md;
if (Typeof(player) != TYPE_PLAYER) {
anotify_nolisten2(player, CFAIL "Only players can edit programs.");
return;
} else if (!Mucker(player)) {
anotify_nolisten2(player, CFAIL NOMBIT_MESG);
return;
} else if (tp_db_readonly) {
anotify_nolisten2(player, CFAIL DBRO_MESG);
return;
} else if (!*name) {
anotify_nolisten2(player, CINFO "No program name given.");
return;
}
init_match(descr, player, name, TYPE_PROGRAM, &md);
match_possession(&md);
match_neighbor(&md);
match_registered(&md);
match_absolute(&md);
if ((i = noisy_match_result(&md)) == NOTHING || i == AMBIGUOUS)
return;
if ((Typeof(i) != TYPE_PROGRAM) || !controls(player, i)) {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
return;
} else if (FLAGS(i) & INTERNAL) {
anotify_nolisten2(player, CFAIL NOEDIT_MESG);
return;
}
FLAGS(i) |= INTERNAL;
DBFETCH(i)->sp.program.first = read_program(i);
DBFETCH(player)->sp.player.curr_prog = i;
anotify_fmt(player, CINFO "Entering editor for %s.",
unparse_object(player, i));
/* list current line */
do_list(player, i, 0, 0, 0);
FLAGS(player) |= INTERACTIVE;
DBDIRTY(i);
DBDIRTY(player);
}
/*
* parse_source()
*
* This is a utility used by do_action and do_attach. It parses
* the source string into a dbref, and checks to see that it
* exists.
*
* The return value is the dbref of the source, or NOTHING if an
* error occurs.
*
*/
dbref
parse_source(int descr, dbref player, const char *source_name)
{
dbref source;
struct match_data md;
init_match(descr, player, source_name, NOTYPE, &md); /* source type can be
* any */
match_neighbor(&md);
match_me(&md);
match_here(&md);
match_possession(&md);
match_registered(&md);
match_absolute(&md);
source = noisy_match_result(&md);
if (source == NOTHING)
return NOTHING;
/* You can only attach actions to things you control */
if (!controls(player, source)) {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
return NOTHING;
}
if (Typeof(source) == TYPE_EXIT) {
anotify_nolisten2(player,
CFAIL "You can't attach an action to an action.");
return NOTHING;
}
if (Typeof(source) == TYPE_PROGRAM) {
anotify_nolisten2(player,
CFAIL "You can't attach an action to a program.");
return NOTHING;
}
return source;
}
void
match_and_list(int descr, dbref player, const char *name, char *linespec)
{
dbref thing;
char *p;
char *q;
int range[2];
int argc;
struct match_data md;
struct line *tmpline;
init_match(descr, player, name, TYPE_PROGRAM, &md);
match_neighbor(&md);
match_possession(&md);
match_registered(&md);
match_absolute(&md);
if ((thing = noisy_match_result(&md)) == NOTHING)
return;
if (Typeof(thing) != TYPE_PROGRAM) {
notify(player, "You can't list anything but a program.");
return;
}
/* if (!(controls(player, thing) || Linkable(thing))) { */
if (!(controls(player, thing) || (FLAGS(thing) & VEHICLE))) {
notify(player, "Permission denied. (You don't control the program, and it's not set Viewable)");
return;
}
if (!*linespec) {
range[0] = 1;
range[1] = -1;
argc = 2;
} else {
q = p = linespec;
while (*p) {
while (*p && !isspace(*p))
*q++ = *p++;
while (*p && isspace(*++p)) ;
}
*q = '\0';
argc = 1;
if (isdigit(*linespec)) {
range[0] = atoi(linespec);
while (*linespec && isdigit(*linespec))
linespec++;
} else {
range[0] = 1;
}
if (*linespec) {
argc = 2;
while (*linespec && !isdigit(*linespec))
linespec++;
if (*linespec)
range[1] = atoi(linespec);
else
range[1] = -1;
}
}
tmpline = PROGRAM_FIRST(thing);
PROGRAM_SET_FIRST(thing, read_program(thing));
do_list(player, thing, range, argc);
free_prog_text(PROGRAM_FIRST(thing));
PROGRAM_SET_FIRST(thing, tmpline);
return;
}
/*
* do_dig
*
* Use this to create a room.
*/
void
do_dig(int descr, dbref player, const char *name, const char *pname)
{
char *rname, *qname;
dbref newparent;
char rbuf[BUFFER_LEN];
char qbuf[BUFFER_LEN];
char buf[BUFFER_LEN];
dbref room;
struct match_data md;
dbref parent;
if (!Builder(player) && !tp_all_can_build_rooms) {
anotify_nolisten2(player, CFAIL NOBBIT_MESG);
return;
}
if (!tp_building || tp_db_readonly) {
anotify_nolisten2(player, CFAIL NOBUILD_MESG);
return;
}
if (*name == '\0') {
anotify_nolisten2(player, CINFO "You need name for the room.");
return;
}
if (!ok_name(name)) {
anotify_nolisten2(player, CINFO "That's a silly name for a room!");
return;
}
if (!payfor(player, tp_room_cost)) {
anotify_fmt(player, CFAIL "You don't have enough %s to dig a room.",
tp_pennies);
return;
}
room = new_object(player);
/* Initialize everything */
newparent = DBFETCH(DBFETCH(player)->location)->location;
while ((OkObj(newparent)) && !(FLAGS(newparent) & ABODE)
&& !(FLAG2(newparent) & F2PARENT))
newparent = DBFETCH(newparent)->location;
if (!OkObj(newparent)) {
if (OkObj(tp_default_parent))
newparent = tp_default_parent;
else
newparent = GLOBAL_ENVIRONMENT;
}
NAME(room) = alloc_string(name);
DBFETCH(room)->location = newparent;
OWNER(room) = OWNER(player);
DBFETCH(room)->exits = NOTHING;
DBFETCH(room)->sp.room.dropto = NOTHING;
FLAGS(room) = TYPE_ROOM | (FLAGS(player) & JUMP_OK);
PUSH(room, DBFETCH(newparent)->contents);
DBDIRTY(room);
DBDIRTY(newparent);
sprintf(buf, CSUCC "Room %s created.", unparse_object(player, room));
anotify_nolisten2(player, buf);
strcpy(buf, pname);
for (rname = buf; (*rname && (*rname != '=')); rname++) ;
qname = rname;
if (*rname)
*(rname++) = '\0';
while ((qname > buf) && (isspace(*qname)))
*(qname--) = '\0';
qname = buf;
for (; *rname && isspace(*rname); rname++) ;
rname = strcpy(rbuf, rname);
qname = strcpy(qbuf, qname);
if (*qname) {
anotify_nolisten2(player, CNOTE "Trying to set parent...");
init_match(descr, player, qname, TYPE_ROOM, &md);
match_absolute(&md);
match_registered(&md);
match_here(&md);
if ((parent = noisy_match_result(&md)) == NOTHING
|| parent == AMBIGUOUS) {
anotify_nolisten2(player, CINFO "Parent set to default.");
} else {
if ((!can_link_to(player, Typeof(room), parent)
&& !(FLAG2(parent) & F2PARENT)) || room == parent) {
anotify_nolisten2(player,
CFAIL
"Permission denied. Parent set to default.");
} else {
moveto(room, parent);
sprintf(buf, CSUCC "Parent set to %s.",
unparse_object(player, parent));
anotify_nolisten2(player, buf);
}
}
}
if (*rname) {
PData pdat;
sprintf(buf, "_reg/%s", rname);
pdat.flags = PROP_REFTYP;
pdat.data.ref = room;
set_property(player, buf, &pdat);
sprintf(buf, CINFO "Room registered as $%s", rname);
anotify_nolisten2(player, buf);
}
}
/* do_link
*
* Use this to link to a room that you own. It also sets home for
* objects and things, and drop-to's for rooms.
* It seizes ownership of an unlinked exit, and costs 1 penny
* plus a penny transferred to the exit owner if they aren't you
*
* All destinations must either be owned by you, or be LINK_OK.
*/
void
do_link(int descr, dbref player, const char *thing_name, const char *dest_name)
{
dbref good_dest[MAX_LINKS];
int ndest, i;
struct match_data md;
char buf[BUFFER_LEN];
dbref thing, dest;
if (tp_db_readonly) {
anotify_nolisten2(player, CFAIL DBRO_MESG);
return;
}
if (Guest(player)) {
anotify_fmt(player, CFAIL "%s", tp_noguest_mesg);
return;
}
init_match(descr, player, thing_name, TYPE_EXIT, &md);
match_all_exits(&md);
match_neighbor(&md);
match_possession(&md);
match_me(&md);
match_here(&md);
match_absolute(&md);
match_registered(&md);
if (Mage(OWNER(player)))
match_player(&md);
if ((thing = noisy_match_result(&md)) == NOTHING)
return;
switch (Typeof(thing)) {
case TYPE_EXIT:
/* we're ok, check the usual stuff */
if (DBFETCH(thing)->sp.exit.ndest != 0) {
if (controls(player, thing)) {
if ((DBFETCH(thing)->sp.exit.dest)[0] != NIL) {
anotify_nolisten2(player,
CINFO "That exit is already linked.");
return;
}
} else {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
return;
}
}
/* handle costs */
if (OWNER(thing) == OWNER(player)) {
if (!payfor(player, tp_link_cost)) {
anotify_fmt(player,
CFAIL "It costs %d %s to link this exit.",
tp_link_cost,
(tp_link_cost == 1) ? tp_penny : tp_pennies);
return;
}
} else {
if (!payfor(player, tp_link_cost + tp_exit_cost)) {
anotify_fmt(player,
CFAIL "It costs %d %s to link this exit.",
(tp_link_cost + tp_exit_cost),
(tp_link_cost + tp_exit_cost ==
1) ? tp_penny : tp_pennies);
return;
} else if (!Builder(player)) {
anotify_nolisten2(player, CFAIL NOBBIT_MESG);
return;
} else {
/* pay the owner for his loss */
dbref owner = OWNER(thing);
DBFETCH(owner)->sp.player.pennies += tp_exit_cost;
DBDIRTY(owner);
}
}
/* link has been validated and paid for; do it */
OWNER(thing) = OWNER(player);
if (!
(ndest =
link_exit(descr, player, thing, (char *) dest_name,
good_dest))) {
anotify_nolisten2(player, CFAIL "No destinations linked.");
DBFETCH(player)->sp.player.pennies += tp_link_cost; /* Refund! */
DBDIRTY(player);
break;
}
DBFETCH(thing)->sp.exit.ndest = ndest;
if (DBFETCH(thing)->sp.exit.dest)
free(DBFETCH(thing)->sp.exit.dest);
DBFETCH(thing)->sp.exit.dest =
(dbref *) malloc(sizeof(dbref) * ndest);
for (i = 0; i < ndest; i++)
(DBFETCH(thing)->sp.exit.dest)[i] = good_dest[i];
break;
case TYPE_THING:
case TYPE_PLAYER:
init_match(descr, player, dest_name, TYPE_ROOM, &md);
match_neighbor(&md);
match_absolute(&md);
match_registered(&md);
match_me(&md);
match_here(&md);
match_null(&md);
if (Typeof(thing) == TYPE_THING)
match_possession(&md);
if ((dest = noisy_match_result(&md)) == NOTHING)
return;
if (Typeof(thing) == TYPE_THING && dest == NIL) {
anotify_fmt(player, CFAIL "%s", "You cannot HOME a THING to NIL.");
return;
}
if (!controls(player, thing)
|| !can_link_to(player, Typeof(thing), dest)) {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
return;
}
if (parent_loop_check(thing, dest)) {
anotify_nolisten2(player,
CFAIL "That would cause a parent paradox.");
return;
}
/* do the link */
if (Typeof(thing) == TYPE_THING) {
DBFETCH(thing)->sp.thing.home = dest;
} else
DBFETCH(thing)->sp.player.home = dest;
sprintf(buf, CSUCC "%s's home set to %s.",
NAME(thing), unparse_object(player, dest));
anotify_nolisten2(player, buf);
break;
case TYPE_ROOM: /* room dropto's */
init_match(descr, player, dest_name, TYPE_ROOM, &md);
match_neighbor(&md);
match_possession(&md);
match_registered(&md);
match_absolute(&md);
match_home(&md);
match_null(&md);
if ((dest = noisy_match_result(&md)) == NOTHING)
break;
if (!controls(player, thing)
|| !can_link_to(player, Typeof(thing), dest)
|| (thing == dest)) {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
} else {
DBFETCH(thing)->sp.room.dropto = dest; /* dropto */
sprintf(buf, CSUCC "%s's dropto set to %s.",
NAME(thing), unparse_object(player, dest));
anotify_nolisten2(player, buf);
}
break;
case TYPE_PROGRAM:
anotify_nolisten2(player,
CFAIL "You can't link programs to things!");
break;
default:
anotify_nolisten2(player, CFAIL "Weird object type.");
log_status("*BUG: weird object: Typeof(%d) = %d\n",
thing, Typeof(thing));
break;
}
DBDIRTY(thing);
return;
}
void
do_force(int descr, dbref player, const char *what, char *command)
{
dbref victim, loc;
struct match_data md;
assert(what != NULL);
assert(command != NULL);
assert(player > 0);
if (force_level > (tp_max_force_level - 1)) {
notify(player, "Can't force recursively.");
return;
}
if (!tp_zombies && (!Wizard(player) || Typeof(player) != TYPE_PLAYER)) {
notify(player, "Zombies are not enabled here.");
return;
#ifdef DEBUG
} else {
notify(player, "[debug] Zombies are not enabled for nonwizards -- force succeeded.");
#endif
}
/* get victim */
init_match(descr, player, what, NOTYPE, &md);
match_neighbor(&md);
match_possession(&md);
match_me(&md);
match_here(&md);
match_absolute(&md);
match_registered(&md);
match_player(&md);
if ((victim = noisy_match_result(&md)) == NOTHING) {
#ifdef DEBUG
notify(player, "[debug] do_force: unable to find your target!");
#endif /* DEBUG */
return;
}
if (Typeof(victim) != TYPE_PLAYER && Typeof(victim) != TYPE_THING) {
notify(player, "Permission Denied -- Target not a player or thing.");
return;
}
#ifdef GOD_PRIV
if (God(victim)) {
notify(player, "You cannot force God to do anything.");
return;
}
#endif /* GOD_PRIV */
/* if (!controls(player, victim)) {
* notify(player, "Permission denied. (you're not a wizard!)");
* return;
* }
*/
if (!Wizard(player) && !(FLAGS(victim) & XFORCIBLE)) {
notify(player, "Permission denied: forced object not @set Xforcible.");
return;
}
if (!Wizard(player) && !test_lock_false_default(descr, player, victim, MESGPROP_FLOCK)) {
notify(player, "Permission denied: Object not force-locked to you.");
return;
}
loc = getloc(victim);
if (!Wizard(player) && Typeof(victim) == TYPE_THING && loc != NOTHING &&
(FLAGS(loc) & ZOMBIE) && Typeof(loc) == TYPE_ROOM) {
notify(player, "Sorry, but that's in a no-puppet zone.");
return;
}
if (!Wizard(OWNER(player)) && Typeof(victim) == TYPE_THING) {
const char *ptr = NAME(victim);
char objname[BUFFER_LEN], *ptr2;
if ((FLAGS(player) & ZOMBIE)) {
notify(player, "Permission denied -- you cannot use zombies.");
return;
}
if (FLAGS(victim) & DARK) {
notify(player, "Permission denied -- you cannot force dark zombies.");
return;
}
for (ptr2 = objname; *ptr && !isspace(*ptr);)
*(ptr2++) = *(ptr++);
*ptr2 = '\0';
if (lookup_player(objname) != NOTHING) {
notify(player, "Puppet cannot share the name of a player.");
return;
}
}
log_status("FORCED: %s(%d) by %s(%d): %s", NAME(victim),
victim, NAME(player), player, command);
/* force victim to do command */
force_prog=NOTHING;
force_level++;
process_command(dbref_first_descr(victim), victim, command);
force_level--;
force_prog=NOTHING;
}
void
do_teleport(int descr, dbref player, const char *arg1, const char *arg2)
{
dbref victim;
dbref destination;
const char *to;
struct match_data md;
/* get victim, destination */
if (*arg2 == '\0') {
victim = player;
to = arg1;
} else {
init_match(descr, player, arg1, NOTYPE, &md);
match_neighbor(&md);
match_possession(&md);
match_me(&md);
match_here(&md);
match_absolute(&md);
match_registered(&md);
match_player(&md);
if ((victim = noisy_match_result(&md)) == NOTHING) {
return;
}
to = arg2;
}
#ifdef GOD_PRIV
if(tp_strict_god_priv && !God(player) && God(OWNER(victim))) {
notify(player, "God has already set that where He wants it to be.");
return;
}
#endif
/* get destination */
init_match(descr, player, to, TYPE_PLAYER, &md);
match_possession(&md);
match_me(&md);
match_here(&md);
match_home(&md);
match_absolute(&md);
match_registered(&md);
if (Wizard(OWNER(player))) {
match_neighbor(&md);
match_player(&md);
}
switch (destination = match_result(&md)) {
case NOTHING:
notify(player, "Send it where?");
break;
case AMBIGUOUS:
notify(player, "I don't know which destination you mean!");
break;
case HOME:
switch (Typeof(victim)) {
case TYPE_PLAYER:
destination = PLAYER_HOME(victim);
if (parent_loop_check(victim, destination))
destination = PLAYER_HOME(OWNER(victim));
break;
case TYPE_THING:
destination = THING_HOME(victim);
if (parent_loop_check(victim, destination)) {
destination = PLAYER_HOME(OWNER(victim));
if (parent_loop_check(victim, destination)) {
destination = (dbref) 0;
}
}
break;
case TYPE_ROOM:
destination = GLOBAL_ENVIRONMENT;
break;
case TYPE_PROGRAM:
destination = OWNER(victim);
break;
default:
destination = tp_player_start; /* caught in the next
* switch anyway */
break;
}
default:
switch (Typeof(victim)) {
case TYPE_PLAYER:
if (!controls(player, victim) ||
!controls(player, destination) ||
!controls(player, getloc(victim)) ||
(Typeof(destination) == TYPE_THING && !controls(player, getloc(destination)))) {
notify(player, "Permission denied. (must control victim, dest, victim's loc, and dest's loc)");
break;
}
if (Typeof(destination) != TYPE_ROOM && Typeof(destination) != TYPE_THING) {
notify(player, "Bad destination.");
break;
}
if (!Wizard(victim) &&
(Typeof(destination) == TYPE_THING && !(FLAGS(destination) & VEHICLE))) {
notify(player, "Destination object is not a vehicle.");
break;
}
if (parent_loop_check(victim, destination)) {
notify(player, "Objects can't contain themselves.");
break;
}
notify(victim, "You feel a wrenching sensation...");
enter_room(descr, victim, destination, DBFETCH(victim)->location);
notify(player, "Teleported.");
break;
case TYPE_THING:
if (parent_loop_check(victim, destination)) {
notify(player, "You can't make a container contain itself!");
break;
}
case TYPE_PROGRAM:
if (Typeof(destination) != TYPE_ROOM
&& Typeof(destination) != TYPE_PLAYER && Typeof(destination) != TYPE_THING) {
notify(player, "Bad destination.");
break;
}
if (!((controls(player, destination) ||
can_link_to(player, NOTYPE, destination)) &&
(controls(player, victim) || controls(player, DBFETCH(victim)->location)))) {
notify(player, "Permission denied. (must control dest and be able to link to it, or control dest's loc)");
break;
}
/* check for non-sticky dropto */
if (Typeof(destination) == TYPE_ROOM
&& DBFETCH(destination)->sp.room.dropto != NOTHING
&& !(FLAGS(destination) & STICKY))
destination = DBFETCH(destination)->sp.room.dropto;
if (tp_thing_movement && (Typeof(victim) == TYPE_THING)) {
enter_room(descr, victim, destination, DBFETCH(victim)->location);
} else {
moveto(victim, destination);
}
notify(player, "Teleported.");
break;
case TYPE_ROOM:
if (Typeof(destination) != TYPE_ROOM) {
notify(player, "Bad destination.");
break;
}
if (!controls(player, victim)
|| !can_link_to(player, NOTYPE, destination)
|| victim == GLOBAL_ENVIRONMENT) {
notify(player, "Permission denied. (Can't move #0, dest must be linkable, and must control victim)");
break;
}
if (parent_loop_check(victim, destination)) {
notify(player, "Parent would create a loop.");
break;
}
moveto(victim, destination);
notify(player, "Parent set.");
break;
case TYPE_GARBAGE:
notify(player, "That object is in a place where magic cannot reach it.");
break;
default:
notify(player, "You can't teleport that.");
break;
}
break;
}
return;
}
