bool
can_see(dbref player, dbref thing, bool can_see_loc)
{
if (!OkObj(player) || !OkObj(thing))
return 0;
if (player == thing || Typeof(thing) == TYPE_EXIT
|| Typeof(thing) == TYPE_ROOM)
return 0;
if (Light(thing))
return 1;
if (can_see_loc) {
switch (Typeof(thing)) {
case TYPE_PROGRAM:
return ((FLAGS(thing) & LINK_OK) || controls(player, thing)
|| (POWERS(player) & POW_SEE_ALL));
case TYPE_PLAYER:
if (tp_dark_sleepers) {
return (!Dark(thing) || online(thing)
|| (POWERS(player) & POW_SEE_ALL));
}
default:
return (!Dark(thing) || (POWERS(player) & POW_SEE_ALL) ||
(controls(player, thing) && !(FLAGS(player) & STICKY)));
}
} else {
/* can't see loc */
return (controls(player, thing) && !(FLAGS(player) & STICKY));
}
}
bool
can_doit(int descr, dbref player, dbref thing,
const char *default_fail_msg)
{
dbref loc;
if ((loc = getloc(player)) == NOTHING)
return 0;
if (OkObj(thing)) {
dbref dest = Typeof(thing) == TYPE_EXIT ? (DBFETCH(thing)->sp.exit.ndest ? DBFETCH(thing)->sp.exit.dest[0] : NOTHING) : NOTHING;
if (((FLAG2(player) & F2IMMOBILE) && !(FLAG2(thing) & F2IMMOBILE)) &&
(!OkObj(dest) || Typeof(dest) != TYPE_PROGRAM)
) {
envpropqueue(descr, player, OkObj(player) ? getloc(player) : -1,
thing, thing, NOTHING, "@immobile", "Immobile", 1, 1);
return 0;
}
}
if (!TMage(OWNER(player)) && Typeof(player) == TYPE_THING &&
(FLAGS(thing) & ZOMBIE)) {
notify(player, "Sorry, but zombies can't do that.");
return 0;
}
if (!could_doit(descr, player, thing)) {
/* can't do it */
if (GETFAIL(thing)) {
exec_or_notify(descr, player, thing, GETFAIL(thing), "(@Fail)");
} else if (default_fail_msg) {
notify(player, default_fail_msg);
}
if (GETOFAIL(thing) && !Dark(player)) {
parse_omessage(descr, player, loc, thing, GETOFAIL(thing),
PNAME(player), "(@Ofail)");
}
return 0;
} else {
/* can do it */
/* I moved these to the 'trigger()' function. -Akari */
/* if (GETSUCC(thing)) {
exec_or_notify(descr, player, thing, GETSUCC(thing), "(@Succ)");
}
if (GETOSUCC(thing) && !Dark(player)) {
parse_omessage(descr, player, loc, thing, GETOSUCC(thing),
NAME(player), "(@Osucc)");
}
*/
return 1;
}
}
bool
can_link_to(dbref who, object_flag_type what_type,
dbref where)
{
if (where == HOME)
return 1;
if (where == NIL)
return 1;
if (!OkObj(who) || !OkObj(where))
return 0;
switch (what_type) {
case TYPE_EXIT:
return (controls(who, where) || (FLAGS(where) & LINK_OK)
|| (POWERS(who) & POW_LINK_ANYWHERE));
/* NOTREACHED */
break;
case TYPE_PLAYER:
return (Typeof(where) == TYPE_ROOM && (controls(who, where)
|| Linkable(where)
|| (POWERS(who) &
POW_LINK_ANYWHERE)));
/* NOTREACHED */
break;
case TYPE_ROOM:
return ((Typeof(where) == TYPE_ROOM || Typeof(where) == TYPE_THING)
&& (controls(who, where) || Linkable(where)
|| (POWERS(who) & POW_LINK_ANYWHERE)));
/* NOTREACHED */
break;
case TYPE_THING:
return ((Typeof(where) == TYPE_ROOM || Typeof(where) == TYPE_PLAYER
|| Typeof(where) == TYPE_THING)
&& (controls(who, where) || Linkable(where)
|| (POWERS(who) & POW_LINK_ANYWHERE)));
/* NOTREACHED */
break;
case NOTYPE:
return (controls(who, where) || (FLAGS(where) & LINK_OK)
|| (POWERS(who) & POW_LINK_ANYWHERE)
|| (Typeof(where) != TYPE_THING && (FLAGS(where) & ABODE)));
/* NOTREACHED */
break;
}
return 0;
}
/* exit_loop_check()
*
* Recursive check for loops in destinations of exits. Checks to see
* if any circular references are present in the destination chain.
* Returns 1 if circular reference found, 0 if not.
*/
bool
exit_loop_check(dbref source, dbref dest)
{
int i;
if (source == dest)
return 1; /* That's an easy one! */
if (dest == NIL) /* NIL itself cant HAVE loops */
return 0;
if (Typeof(dest) != TYPE_EXIT)
return 0;
for (i = 0; i < DBFETCH(dest)->sp.exit.ndest; i++) {
if ((DBFETCH(dest)->sp.exit.dest)[i] == source) {
return 1; /* Found a loop! */
}
if (OkObj((DBFETCH(dest)->sp.exit.dest)[i])) {
if (Typeof((DBFETCH(dest)->sp.exit.dest)[i]) == TYPE_EXIT) {
if (exit_loop_check(source, (DBFETCH(dest)->sp.exit.dest)[i])) {
return 1; /* Found one recursively */
}
}
} else {
return 0;
}
}
return 0; /* No loops found */
}
void
prim_armageddon(PRIM_PROTOTYPE)
{
char buf[BUFFER_LEN];
/* ( s<message> -- ) */
CHECKOP(1);
oper1 = POP();
if (mlev < LBOY)
abort_interp("W4 primitive.");
if (oper1->type != PROG_STRING)
abort_interp("String expected.");
sprintf(buf, "\r\nImmediate shutdown by %s.\r\n", NAME(PSafe));
if (oper1->data.string) {
strcat(buf, SYSWHITE MARK SYSNORMAL);
strcat(buf, oper1->data.string->data);
strcat(buf, "\r\n");
}
CLEAR(oper1);
log_status("DDAY(MUF: %d): by %s(%d)\n", program,
OkObj(player) ? NAME(player) : "(login)", player);
fprintf(stderr, "DDAY(MUF: %d): by %s(%d)\n", program,
OkObj(player) ? NAME(player) : "(login)", player);
close_sockets(buf);
#ifdef SPAWN_HOST_RESOLVER
kill_resolver();
#endif
#ifdef USE_RESLVD
reslvd_close();
#endif
exit(1);
}
const char *
unparse_object(dbref player, dbref loc)
{
char tbuf[BUFFER_LEN];
if (Typeof(player) != TYPE_PLAYER)
player = OWNER(player);
switch (loc) {
case NOTHING:
return "*NOTHING*";
case AMBIGUOUS:
return "*AMBIGUOUS*";
case HOME:
return "*HOME*";
default:
if (!OkObj(loc))
#ifdef SANITY
{
sprintf(upb, "*INVALID*(#%d)", loc);
return upb;
}
#else
return "*INVALID*";
#endif
#ifndef SANITY
if (!(FLAGS(player) & STICKY) &&
(TMage(player) ||
can_link_to(player, NOTYPE, loc) ||
controls_link(player, loc) ||
((Typeof(loc) != TYPE_PLAYER) &&
(FLAGS(loc) & CHOWN_OK))
)) {
/* show everything */
#endif
sprintf(upb, "%s(#%d%s)", NAME(loc), loc, unparse_flags(loc, tbuf));
return upb;
#ifndef SANITY
} else {
/* show only the name */
return NAME(loc);
}
#endif
}
}
dbref
connect_player(const char *name, const char *password)
{
dbref player, i;
if (*name == '#' && number(name+1) && atoi(name+1)) {
player = (dbref) atoi(name + 1);
if ((!OkObj(player)) || (Typeof(player) != TYPE_PLAYER))
player = NOTHING;
} else {
player = lookup_player(name);
}
if (player == NOTHING) {
/* Check for a player not in the hashtable */
for(i = (db_top - 1); i > NOTHING; i--) {
if(Typeof(i) == TYPE_PLAYER) {
if(!string_compare(name, NAME(i))) {
/* Oooga, found a player that lookup didn't! */
log_status(HASH1_MSG);
wall_wizards(MARK HASH1_MSG);
refresh_players();
player = lookup_player(name);
if(player == NOTHING) {
log_status(HASH2_MSG);
wall_wizards(MARK HASH2_MSG);
}
break;
}
}
}
if(player == NOTHING)
return NOTHING;
}
if (DBFETCH(player)->sp.player.password
&& *DBFETCH(player)->sp.player.password
&& strcmp(DBFETCH(player)->sp.player.password, password))
return NOTHING;
return player;
}
void
prim_setsysparm(PRIM_PROTOTYPE)
{
CHECKOP(2);
oper1 = POP(); /* string: new parameter value */
oper2 = POP(); /* string: parameter to tune */
if (mlev < 6)
abort_interp("Archwizards or higher only.");
if (oper2->type != PROG_STRING)
abort_interp("Invalid argument. (1)");
if (!oper2->data.string)
abort_interp("Null string argument. (1)");
if (oper1->type != PROG_STRING)
abort_interp("Invalid argument. (2)");
if (!oper1->data.string)
abort_interp("Null string argument. (2)");
result = tune_setparm(program, oper2->data.string->data,
oper1->data.string->data);
switch (result) {
case 0: /* TUNESET_SUCCESS */
log_status("TUNED (MUF): %s(%d) tuned %s to %s\n",
OkObj(player) ? NAME(player) : "(Login)", player,
oper2->data.string->data, oper1->data.string->data);
break;
case 1: /* TUNESET_UNKNOWN */
abort_interp("Unknown parameter. (1)");
break;
case 2: /* TUNESET_SYNTAX */
abort_interp("Bad parameter syntax. (2)");
break;
case 3: /* TUNESET_BADVAL */
abort_interp("Bad parameter value. (2)");
break;
}
CLEAR(oper1);
CLEAR(oper2);
}
dbref
lookup_player_noalias(const char *name)
{
hash_data *hd;
if (*name == '#') {
name++;
if (!OkObj(atoi(name)) || Typeof(atoi(name)) != TYPE_PLAYER)
return NOTHING;
else
return atoi(name);
} else {
if (*name == '*')
name++;
if ((hd = find_hash(name, player_list, PLAYER_HASH_SIZE)) == NULL) {
return NOTHING;
} else {
return (hd->dbval);
}
}
}
const char *
ansi_unparse_object(dbref player, dbref loc)
{
char tbuf[BUFFER_LEN], tbuf2[BUFFER_LEN];
if (Typeof(player) != TYPE_PLAYER)
player = OWNER(player);
switch (loc) {
case NOTHING:
return CGLOOM "*NOTHING*";
case AMBIGUOUS:
return CPURPLE "*AMBIGUOUS*";
case HOME:
return CWHITE "*HOME*";
default:
if (!OkObj(loc))
return CRED "*INVALID*";
#ifndef SANITY
if (!(FLAGS(player) & STICKY) &&
(TMage(player) ||
can_link_to(player, NOTYPE, loc) ||
controls_link(player, loc) ||
((Typeof(loc) != TYPE_PLAYER) &&
(FLAGS(loc) & CHOWN_OK))
)) {
#endif
/* show everything */
sprintf(upb, "%s" CYELLOW "(#%d%s)",
ansiname(loc, tbuf), loc, unparse_flags(loc, tbuf2));
return upb;
#ifndef SANITY
} else {
/* show only the name */
return ansiname(loc, upb);
}
#endif
}
}
dbref
lookup_player(const char *name)
{
hash_data *hd;
if (*name == '#') {
name++;
if (!OkObj(atoi(name)) || Typeof(atoi(name)) != TYPE_PLAYER)
return NOTHING;
else
return atoi(name);
} else {
if (*name == '*')
name++;
if ((hd = find_hash(name, player_list, PLAYER_HASH_SIZE)) == NULL) {
/* secondary check - is there an exact @alias? this will return
* NOTHING if no alias was found. */
return lookup_alias(name, 0);
} else {
return (hd->dbval);
}
}
}
void
prim_restart(PRIM_PROTOTYPE)
{
/* (s<message> -- ) */
CHECKOP(1);
oper1 = POP();
if (mlev < LBOY)
abort_interp("W4 primitive.");
if (oper1->type != PROG_STRING)
abort_interp("String expected.");
log_status("RESTART(MUF: %d): by %s(%d)\n", program,
OkObj(player) ? NAME(player) : "(login)", player);
shutdown_flag = 1;
restart_flag = 1;
if (oper1->data.string) {
strcat(restart_message, SYSWHITE MARK SYSNORMAL);
strcat(restart_message, oper1->data.string->data);
strcat(restart_message, "\r\n");
}
CLEAR(oper1);
}
dbref
create_player(dbref creator, const char *name, const char *password)
{
char buf[BUFFER_LEN];
struct object *newp;
dbref player;
if (!ok_player_name(name) || !ok_password(password) || tp_db_readonly)
return NOTHING;
/* remove any existing alias with this name */
clear_alias(0, name);
/* else he doesn't already exist, create him */
player = new_object(creator);
newp = DBFETCH(player);
/* initialize everything */
NAME(player) = alloc_string(name);
FLAGS(player) = TYPE_PLAYER;
if (OkObj(tp_player_prototype)
&& (Typeof(tp_player_prototype) == TYPE_PLAYER)) {
FLAGS(player) = FLAGS(tp_player_prototype);
FLAG2(player) = FLAG2(tp_player_prototype);
if (tp_pcreate_copy_props) {
newp->properties = copy_prop(tp_player_prototype);
#ifdef DISKBASE
newp->propsfpos = 0;
newp->propsmode = PROPS_UNLOADED;
newp->propstime = 0;
newp->nextold = NOTHING;
newp->prevold = NOTHING;
dirtyprops(player);
#endif
}
}
if (OkObj(tp_player_start)) {
DBFETCH(player)->location = tp_player_start;
DBFETCH(player)->sp.player.home = tp_player_start;
} else {
DBFETCH(player)->location = GLOBAL_ENVIRONMENT;
DBFETCH(player)->sp.player.home = GLOBAL_ENVIRONMENT;
}
OWNER(player) = player;
newp->exits = NOTHING;
newp->sp.player.pennies = tp_start_pennies;
newp->sp.player.password = NULL; /* this has to stay here. -hinoserm */
newp->sp.player.curr_prog = NOTHING;
newp->sp.player.insert_mode = 0;
#ifdef IGNORE_SUPPORT
newp->sp.player.ignoretime = 0;
#endif /* IGNORE_SUPPORT */
/* set password */
set_password(player, password);
/* link him to tp_player_start */
PUSH(player, DBFETCH(tp_player_start)->contents);
add_player(player);
DBDIRTY(player);
DBDIRTY(tp_player_start);
sprintf(buf, CNOTE "%s is born!", NAME(player));
anotify_except(DBFETCH(tp_player_start)->contents, NOTHING, buf, player);
return player;
}
/*
* 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);
}
}
bool
newcontrols(dbref who, dbref what, bool true_c)
{
dbref index;
/* No one controls invalid objects */
/* if (what < 0 || what >= db_top) -- not good enough */
if (!OkObj(what) || !OkObj(who))
return 0;
/* Garbage controls nothing. */
if (Typeof(who) == TYPE_GARBAGE)
return 0;
/* No one controls garbage */
if (Typeof(what) == TYPE_GARBAGE)
return 0;
/* Puppets are based on owner */
if (Typeof(who) != TYPE_PLAYER)
who = OWNER(who);
/* owners control their own stuff */
/* Makes stuff faster here. -Hinoserm */
if (who == OWNER(what))
return 1;
/* CONTROL_ALL controls all objects */
if ((POWERS(who) & POW_CONTROL_ALL) && !Protect(what))
return 1;
/* CONTROL_MUF power controls all MUF objects */
if ((POWERS(who) & POW_CONTROL_MUF) && (Typeof(what) == TYPE_PROGRAM)
&& (!(Protect(what))))
return 1;
/* Wizard controls (most) everything else */
if (Wiz(who) && (!(Protect(what) && MLevel(OWNER(what)) >= LBOY)
|| MLevel(who) >= LBOY))
if (tp_fb_controls ? (MLevel(who) >= LWIZ)
: (MLevel(who) >= MLevel(OWNER(what))))
return 1;
/* If realms control is enabled, the player will Control anything
* contained in a parent room he owns with at W1 bit or higher on it.
* This gives him power to affect any object in his w-bitted parent room.
*/
/*
* Read the manual (help CONTROLS) about this new stuff.
*/
#ifdef CONTROLS_SUPPORT
if (!true_c) {
if (controlsEx(who, what))
return 1;
if (tp_realms_control) {
if (!tp_wiz_realms) {
if (Typeof(what) != TYPE_PLAYER)
for (index = what; index != NOTHING; index = getloc(index))
if ((controlsEx(who, index))
&& (Typeof(index) == TYPE_ROOM
&& ((FLAGS(index) & BUILDER) || Mage(index))))
return 1;
} else {
if (Typeof(what) != TYPE_PLAYER)
for (index = what; index != NOTHING; index = getloc(index))
if ((controlsEx(who, index))
&& (Typeof(index) == TYPE_ROOM && (Mage(index))))
return 1;
}
}
} else {
#endif
if (tp_realms_control && (Typeof(what) != TYPE_PLAYER))
for (index = what; index != NOTHING; index = getloc(index))
if ((OWNER(index) == who) && (Typeof(index) == TYPE_ROOM
&& Mage(index)))
return 1;
#ifdef CONTROLS_SUPPORT
}
#endif
return 0;
}
