/* wiz.c */ #include "os.h" #include "copyright.h" /* Wizard-only commands */ #include "config.h" #include "db.h" #include "interface.h" #include "match.h" #include "externs.h" #ifdef MEM_CHECK #include "mem_check.h" #endif #define ANY_OWNER -2 static object_flag_type convert_flags (dbref player, char *s, object_flag_type * p_mask, object_flag_type * p_type); void do_search (dbref player, const char *arg1, const char *arg3) { int flag; char *arg2; dbref thing; dbref from; dbref to; int is_wizard; int destitute = 1; dbref restrict_zone; char *restrict_name; dbref restrict_owner; object_flag_type flag_mask; object_flag_type restrict_type; char tbuf1[BUFFER_LEN]; int rcount, ecount, pcount, ocount; struct dblist *found = NULL, *ptr = NULL, *rlist = NULL, *elist = NULL, *olist = NULL, *plist = NULL; /* parse first argument into two */ if (!arg1 || *arg1 == '\0') arg1 = "me"; arg2 = strchr (arg1, ' '); if (arg2 != NULL) *arg2++ = '\0'; /* arg1, arg2, arg3 */ else { if (*arg3 == '\0') arg2 = (char *) ""; /* arg1 */ else { arg2 = (char *) arg1; /* arg2, arg3 */ arg1 = (char *) ""; } } is_wizard = Wizard (player); restrict_zone = NOTHING; /* set limits on who we search */ restrict_owner = NOTHING; if (*arg1 == '\0') restrict_owner = is_wizard ? ANY_OWNER : player; else if (arg1[0] == '#') { restrict_owner = atoi (&arg1[1]); if (restrict_owner < 0 || db_top <= restrict_owner) restrict_owner = NOTHING; else if (Typeof (restrict_owner) != TYPE_PLAYER) restrict_owner = NOTHING; } else if (strcmp (arg1, "me") == 0) restrict_owner = player; else restrict_owner = lookup_player (arg1); if (restrict_owner == NOTHING) { notify (player, tprintf ("%s: No such player.", arg1)); return; } /* set limits on what we search for */ flag = 0; flag_mask = 0; restrict_name = NULL; restrict_type = NOTYPE; switch (arg2[0]) { case '\0': /* the no class requested class :) */ break; case 'e': if (string_prefix ("exits", arg2)) { restrict_name = (char *) arg3; restrict_type = TYPE_EXIT; } else flag = 1; break; case 'f': if (string_prefix ("flags", arg2)) { /* * convert_flags ignores previous values of flag_mask and * restrict_type while setting them */ if (!convert_flags (player, (char *) arg3, &flag_mask, &restrict_type)) return; } else flag = 1; break; case 'n': if (string_prefix ("name", arg2)) restrict_name = (char *) arg3; else flag = 1; break; case 'o': if (string_prefix ("objects", arg2)) { restrict_name = (char *) arg3; restrict_type = TYPE_THING; } else flag = 1; break; case 'p': if (string_prefix ("players", arg2)) { restrict_name = (char *) arg3; if (*arg1 == '\0') restrict_owner = ANY_OWNER; restrict_type = TYPE_PLAYER; } else flag = 1; break; case 'r': if (string_prefix ("rooms", arg2)) { restrict_name = (char *) arg3; restrict_type = TYPE_ROOM; } else flag = 1; break; case 't': if (string_prefix ("type", arg2)) { if (arg3[0] == '\0') break; if (string_prefix ("room", arg3)) restrict_type = TYPE_ROOM; else if (string_prefix ("exit", arg3)) restrict_type = TYPE_EXIT; else if (string_prefix ("object", arg3)) restrict_type = TYPE_THING; else if (string_prefix ("player", arg3)) { if (*arg1 == '\0') restrict_owner = ANY_OWNER; restrict_type = TYPE_PLAYER; } else { notify (player, tprintf ("%s: unknown type.", arg3)); return; } } else flag = 1; break; case 'z': if (string_prefix ("zone", arg2)) { init_match (player, arg3, TYPE_THING); match_absolute (); restrict_zone = match_result (); } else flag = 1; break; default: flag = 1; } if (flag) { notify (player, tprintf ("%s: unknown class.", arg2)); return; } /* make sure player is authorized to do requested search */ if (!is_wizard && restrict_type != TYPE_PLAYER && (restrict_owner == ANY_OWNER || restrict_owner != player)) { notify (player, "You need a search warrant to do that!"); return; } /* make sure player has money to do the search */ if (!payfor (player, FIND_COST)) { notify (player, tprintf ("Searches cost %d %s", FIND_COST, ((FIND_COST == 1) ? MONEY : MONIES))); return; } /* the search loop here */ flag = 1; for (thing = 0; thing < db_top; thing++) { switch (Typeof (thing)) { case TYPE_PLAYER: found = plist; break; case TYPE_EXIT: found = elist; break; case TYPE_THING: found = olist; break; case TYPE_ROOM: found = rlist; break; default: continue; } if (restrict_type != NOTYPE && restrict_type != Typeof (thing)) continue; if ((db[thing].flags & flag_mask) != flag_mask) continue; #ifdef DESTROY if (db[thing].flags & GOING) continue; #endif if (Typeof (thing) == TYPE_PLAYER) { if (is_wizard) if (restrict_owner != ANY_OWNER && restrict_owner != db[thing].owner) continue; } else { if (restrict_owner != ANY_OWNER && restrict_owner != db[thing].owner) continue; } if (restrict_name != NULL) if (!string_match (db[thing].name, restrict_name)) continue; if (restrict_zone != NOTHING) if (restrict_zone != getzone (thing)) continue; if (!found) { flag = 0; destitute = 0; found = listcreate (thing); } else listadd (found, thing); switch (Typeof (thing)) { case TYPE_PLAYER: plist = found; break; case TYPE_EXIT: elist = found; break; case TYPE_THING: olist = found; break; case TYPE_ROOM: rlist = found; break; default: break; } } /* if nothing found matching search criteria */ if (destitute) { notify (player, "Nothing found."); return; } /* Walk down the list and print */ rcount = ecount = pcount = ocount = 0; if (restrict_type == TYPE_ROOM || restrict_type == NOTYPE) { notify (player, "\nROOMS:"); for (ptr = rlist; ptr; ptr = ptr->next) { notify (player, unparse_object (player, ptr->obj)); rcount++; } } if (restrict_type == TYPE_EXIT || restrict_type == NOTYPE) { notify (player, "\nEXITS:"); for (ptr = elist; ptr; ptr = ptr->next) { if (db[ptr->obj].exits == NOTHING) from = find_entrance (thing); else from = db[ptr->obj].exits; to = db[ptr->obj].location; sprintf (tbuf1, "%s [from ", unparse_object (player, ptr->obj)); strcat (tbuf1, tprintf ("%s to ", (from == NOTHING) ? "NOWHERE" : unparse_object (player, from))); strcat (tbuf1, tprintf ("%s]", (to == NOTHING) ? "NOWHERE" : unparse_object (player, to))); notify (player, tbuf1); ecount++; } } if (restrict_type == TYPE_THING || restrict_type == NOTYPE) { notify (player, "\nOBJECTS:"); for (ptr = olist; ptr; ptr = ptr->next) { sprintf (tbuf1, "%s [owner: ", unparse_object (player, ptr->obj)); strcat (tbuf1, tprintf ("%s]", unparse_object (player, db[ptr->obj].owner))); notify (player, tbuf1); ocount++; } } if (restrict_type == TYPE_PLAYER || (is_wizard && restrict_type == NOTYPE)) { notify (player, "\nPLAYERS:"); for (ptr = plist; ptr; ptr = ptr->next) { strcpy (tbuf1, unparse_object (player, ptr->obj)); if (is_wizard) { strcat (tbuf1, " [location: "); strcat (tbuf1, unparse_object (player, db[ptr->obj].location)); strcat (tbuf1, "]"); } notify (player, tbuf1); pcount++; } } notify (player, "---------- Search Done ----------"); notify (player, tprintf ("Totals: Rooms...%d Exits...%d Objects...%d Players...%d", rcount, ecount, ocount, pcount)); if (plist) listfree (plist); if (rlist) listfree (rlist); if (olist) listfree (olist); if (elist) listfree (elist); } static object_flag_type convert_flags (dbref player, char *s, object_flag_type * p_mask, object_flag_type * p_type) { static struct { int id, type; object_flag_type bits; } fdata[] = { { 'c', TYPE_PLAYER, PLAYER_CONNECT}, { 'd', TYPE_THING, THING_DEST_OK}, { 'e', NOTYPE, ENTER_OK}, { 'g', TYPE_PLAYER, PLAYER_GAGGED}, { 'h', NOTYPE, HALT}, { 'i', TYPE_THING, THING_IMMORTAL}, { 'n', TYPE_ROOM, ROOM_NO_TEL}, { 'p', TYPE_THING, THING_PUPPET}, #ifdef ROYALTY_FLAG { 'r', NOTYPE, ROYALTY}, #endif { 't', TYPE_EXIT, EXIT_TRANSPARENT}, { 'u', TYPE_PLAYER, PLAYER_SUSPECT}, { 'v', TYPE_THING, THING_VERBOSE}, { 'x', NOTYPE, TERSE}, { 'A', TYPE_ROOM, ROOM_ABODE}, #ifdef RESTRICTED_BUILDING { 'B', TYPE_PLAYER, PLAYER_BUILD}, #endif { 'C', NOTYPE, CHOWN_OK}, { 'D', NOTYPE, DARK}, { 'E', TYPE_EXIT, 0}, { 'F', TYPE_ROOM, ROOM_FLOATING}, { 'G', NOTYPE, GOING}, { 'H', NOTYPE, HAVEN}, #ifdef INHERIT_FLAG { 'I', NOTYPE, INHERIT}, #endif { 'J', TYPE_ROOM, ROOM_JUMP_OK}, { 'K', TYPE_THING, THING_KEY}, { 'K', TYPE_EXIT, EXIT_KEY}, { 'L', TYPE_ROOM, LINK_OK}, { 'N', NOTYPE, NOSPOOF}, { 'O', NOTYPE, OPAQUE}, { 'P', TYPE_PLAYER, 0}, { 'Q', NOTYPE, QUIET}, { 'R', TYPE_ROOM, 0}, { 'S', NOTYPE, STICKY}, { 'T', TYPE_ROOM, ROOM_TEMPLE}, { 'U', TYPE_PLAYER, PLAYER_DARK}, { 'V', NOTYPE, VISUAL}, { 'W', NOTYPE, WIZARD}, { 'X', TYPE_THING, THING_SAFE}, { 0, 0, 0} }; int i; char last_id = ' '; object_flag_type mask, type; mask = 0; type = NOTYPE; while (*s != '\0') { for (i = 0; fdata[i].id != 0; i++) { if (*s == fdata[i].id) { /* handle object specific flag problems */ if (fdata[i].type != NOTYPE) { /* make sure we aren't specific to a different type */ if (type != NOTYPE && type != fdata[i].type) { notify (player, tprintf ("Flag '%c' conflicts with '%c'.", last_id, fdata[i].id)); return 0; } /* make us object specific to this type */ type = fdata[i].type; /* always save last specific flag id */ last_id = *s; } /* add new flag into search mask */ mask |= fdata[i].bits; /* stop searching for *this* flag */ break; } } /* flag not found */ if (fdata[i].id == 0) { notify (player, tprintf ("%c: unknown flag.", (int) *s)); return 0; } ++s; } /* return new mask and type */ *p_mask = mask; *p_type = type; return 1; } #ifdef WCREAT void do_pcreate (dbref creator, const char *player_name, const char *player_password) { dbref player; if (!Wizard (creator)) { notify (creator, "Only wizards are allowed to create people!"); return; } player = create_player (player_name, player_password); if (player == NOTHING) { notify (creator, tprintf ("failure creating '%s'", player_name)); return; } notify (creator, tprintf ("New player '%s' created with password '%s'", player_name, player_password)); fprintf (stderr, "CREATION: %s(#%d) created %s(#%d)\n", db[creator].name, creator, player_name, player); } #endif #ifdef QUOTA void do_quota (dbref player, char *arg1, char *arg2) { dbref who, thing; ATTR *a; int owned, limit; if (!arg1 && !*arg1) who = player; else { init_match (player, arg1, TYPE_PLAYER); match_me (); match_player (); match_neighbor (); match_absolute (); if ((who = noisy_match_result ()) == NOTHING) return; } if (!Wizard (player)) { if (*arg2 != '\0') { notify (player, "Only wizards may change a quota."); return; } if (player != who) { notify (player, "Only wizards may look at someone else's quota."); return; } } /* count up all owned objects */ owned = -1; /* a player is never included in his own * quota */ for (thing = 0; thing < db_top; thing++) { if (db[thing].owner == who) if ((db[thing].flags & (TYPE_THING | GOING)) != (TYPE_THING | GOING)) ++owned; } if (Wizard (who)) notify (player, tprintf ("Objects: %d Limit: UNLIMITED", owned)); else { /* calculate and/or set new */ if (*arg2 == '\0') { a = atr_get (who, "RQUOTA"); if (a) limit = owned + atoi (uncompress (a->value)); else limit = owned; } else { limit = atoi (arg2); } /* stored as a relative value */ (void) atr_add (who, "RQUOTA", tprintf ("%d", limit - owned), GOD, NOTHING); notify (player, tprintf ("Objects: %d Limit: %d", owned, limit)); } } void do_allquota (dbref player, char *arg1) { int limit, owned, max; dbref who, thing; ATTR *a; if (!God (player)) { notify (player, "Who do you think you are, GOD?"); return; } limit = atoi (arg1); notify (player, "working...limit is %d", limit); for (who = 0; who < db_top; who++) { if (Typeof (who) != TYPE_PLAYER) continue; /* count up all owned objects */ owned = -1; /* a player is never included in his own * quota */ for (thing = 0; thing < db_top; thing++) { if (db[thing].owner == who) if ((db[thing].flags & (TYPE_THING | GOING)) != (TYPE_THING | GOING)) ++owned; } a = atr_get (who, "RQUOTA"); if (a) max = atoi (uncompress (a->value)); else max = 0; notify (player, tprintf ("%s: left(%d) owned(%d)", db[who].name, max, owned)); /* stored as a relative value */ (void) atr_add (who, "RQUOTA", tprintf ("%d", limit - owned), GOD, NOTHING); } notify (player, "done."); } #endif /* QUOTA */ void do_teleport (dbref player, const char *arg1, const char *arg2) { dbref victim; dbref destination; const char *to; dbref absroom; /* "absolute room", for NO_TEL check */ int rec = 0; /* recursion counter */ /* get victim, destination */ if (*arg2 == '\0') { victim = player; to = arg1; } else { init_match (player, arg1, NOTYPE); match_neighbor (); match_possession (); match_me (); match_absolute (); match_player (); if ((victim = noisy_match_result ()) == NOTHING) { return; } to = arg2; } /* get destination */ if (!string_compare (to, "home")) { destination = db[victim].exits; } else { init_match (player, to, TYPE_PLAYER); match_here (); match_absolute (); match_neighbor (); match_me (); match_player (); match_exit (); destination = match_result (); } switch (destination) { case NOTHING: notify (player, "No match."); break; case AMBIGUOUS: notify (player, "I don't know which destination you mean!"); break; default: /* check victim, destination types, teleport if ok */ if (recursive_member (destination, victim, 0) || (victim == destination)) { notify (player, "Bad destination."); return; } if (!Hasprivs (player) && (Typeof (victim) == TYPE_EXIT || Typeof (victim) == TYPE_ROOM || ((Typeof (victim) == TYPE_PLAYER) && (Typeof (destination) == TYPE_PLAYER)))) { notify (player, "Bad destination."); return; } /* if royal or wiz and destination is player, tel to location */ if ((Typeof (destination) == TYPE_PLAYER) && (Hasprivs (player)) && (Typeof (victim) == TYPE_PLAYER) && (destination != HOME)) { safe_tel (victim, db[destination].location); return; } /* check needed for NOTHING. Especially important for unlinked exits */ if ((absroom = db[victim].location) == NOTHING) { if (Typeof (victim) != TYPE_EXIT) { notify (victim, "You're in the Void. This is not a good thing."); do_move (victim, "home", 0); return; } /* if the thing is an unlinked exit, no need for NO_TEL check */ } else { /* valid location, perform other checks */ /* if player is inside himself, send him home */ if (absroom == victim) { notify (player, "What are you doing inside of yourself?"); do_move (victim, "home", 0); return; } /* find the "absolute" room */ while ((Typeof (absroom) != TYPE_ROOM) && (rec < 15)) { absroom = db[absroom].location; rec++; } /* if there are a lot of containers, send him home */ if (rec > 15) { notify (victim, "You're in too many containers."); do_move (victim, "home", 0); return; } /* note that we check the NO_TEL status of the victim rather than */ /* the player that issued the command. This prevents someone in a */ /* NO_TEL room from having one of his objects @tel him out. The */ /* control check, however, is detemined by command-giving player. */ /* now check to see if the absolute room is set NO_TEL */ if ((db[absroom].flags & ROOM_NO_TEL) && !controls (player, absroom) && !Hasprivs (player)) { notify (player, "Teleports are not allowed in this room."); return; } } if (Typeof (destination) != TYPE_EXIT) { if (Hasprivs (player) || (controls (player, victim) && (((Typeof (destination) == TYPE_ROOM) && (db[destination].flags & ROOM_JUMP_OK)) || controls (player, destination))) || (controls (player, db[victim].location) && (controls (player, destination) || ((Typeof (destination) == TYPE_ROOM) && (db[destination].flags & ROOM_JUMP_OK))))) { safe_tel (victim, destination); if ((victim != player) && !((Typeof (victim) == TYPE_THING) && (db[victim].flags & THING_PUPPET) && (db[victim].owner == db[player].owner))) notify (player, "Teleported."); return; } notify (player, "Permission denied."); return; } else { if (controls (player, victim) || controls (player, db[victim].location)) { do_move (victim, to, 0); } else { notify (victim, tprintf ("%s tries to impose his will on you and fails.", db[player].name)); } } } } void do_force (dbref player, const char *what, char *command) { dbref victim; if ((victim = match_controlled (player, what)) == NOTHING) { notify (player, "Sorry."); return; } if ((Typeof (victim) == TYPE_ROOM) || (Typeof (victim) == TYPE_EXIT)) { notify (player, "You can only force players and things."); return; } if (Wizard (player)) { static char pl[BUFFER_LEN], vic[BUFFER_LEN]; strcpy (pl, unparse_object (player, player)); strcpy (vic, unparse_object (player, victim)); if (db[victim].owner != db[player].owner) fprintf (stderr, "** FORCE ** [%s: %s] %s\n", pl, vic, command); else fprintf (stderr, "FORCE [%s:%s] %s\n", pl, vic, command); } if (victim == GOD) { notify (player, "You can't force God!"); return; } #ifdef INHERIT_FLAG if (!Inherit (player) && Inherit (victim)) { notify (player, "Authorization failed."); return; } #endif /* force victim to do command */ parse_que (victim, command, player); } int try_force (dbref player, const char *command) { dbref thing; char *s; char tbuf1[BUFFER_LEN]; /* first see if command prefixed by object # */ if (*command == '#') { strcpy (tbuf1, command); for (s = tbuf1; *s && *s != ' '; s++); if (!*s) return (0); *s++ = 0; } else { /* try inventory */ if (((thing = pref_match (player, db[player].contents, command)) != NOTHING) || ((db[player].location != NOTHING) && ((thing = pref_match (player, db[db[player].location].contents, command)) != NOTHING))) { strcpy (tbuf1, command); s = tbuf1 + strlen (db[thing].name); if (!*s) return (0); *s++ = 0; } else return (0); } do_force (player, tbuf1, s); return (1); } void do_stats (dbref player, const char *name) { dbref garbage; dbref rooms; dbref exits; dbref things; dbref players; dbref total; dbref i; dbref owner; /* Patched 12/9/90 */ if (*name == '\0') owner = ANY_OWNER; else if (*name == '#') { owner = atoi (&name[1]); if (owner < 0 || db_top <= owner) owner = NOTHING; else if (Typeof (owner) != TYPE_PLAYER) owner = NOTHING; } else if (strcmp (name, "me") == 0) owner = player; else owner = lookup_player (name); if (owner == NOTHING) { notify (player, tprintf ("%s: No such player.", name)); return; } if (!Wizard (player)) if (owner != ANY_OWNER && owner != player) { notify (player, "You need a search warrant to do that!"); return; } total = rooms = exits = things = players = garbage = 0; for (i = 0; i < db_top; i++) { if (owner == ANY_OWNER || owner == db[i].owner) { if (db[i].flags & GOING) { garbage++; } else { total++; switch (Typeof (i)) { case TYPE_ROOM: rooms++; break; case TYPE_EXIT: exits++; break; case TYPE_THING: things++; break; case TYPE_PLAYER: players++; break; default: break; } } } } if (owner == ANY_OWNER) { total = total + garbage; notify (player, tprintf ("%d objects = %d rooms, %d exits, %d things, %d players, %d garbage.", total, rooms, exits, things, players, garbage)); } else { notify (player, tprintf ("%d objects = %d rooms, %d exits, %d things, %d players.", total, rooms, exits, things, players)); } #ifdef MEM_CHECK if (God (player)) list_mem_check (player); #endif #if defined(DEBUG) && defined(USE_SMALLOC) if (Wizard (player)) notify (player, tprintf ("%d bytes memory used.", memused ())); if (God (player)) verify_sfltable (player); #endif } void do_toad (dbref player, const char *name) { dbref victim; char tbuf1[BUFFER_LEN]; if (!Wizard (player)) { notify (player, "Only a Wizard can toad a person."); return; } init_match (player, name, TYPE_PLAYER); match_neighbor (); match_absolute (); match_player (); if ((victim = noisy_match_result ()) == NOTHING) return; if (Typeof (victim) != TYPE_PLAYER) { notify (player, "Try @destroy instead!"); } else if (Wizard (victim)) { notify (player, "You can't toad a Wizard."); } else if (db[victim].contents != NOTHING) { notify (player, "You need to destroy their contents first."); } else { /* we're ok */ /* do it */ s_Pass (victim, NULL); db[victim].flags = TYPE_THING; db[victim].owner = player; /* you get it */ s_Pennies (victim, 1); /* notify people */ notify (victim, "You have been turned into a slimy toad."); notify (player, tprintf ("You toaded %s!", db[victim].name)); fprintf (stderr, "*** TOAD *** %s(#%d) toaded %s(#%d)\n", db[player].name, player, db[victim].name, victim); /* reset name */ delete_player (victim); boot_off (victim); sprintf (tbuf1, "A wart toad named %s", db[victim].name); SET (db[victim].name, tbuf1); do_chownall (player, name, ""); } } void do_newpassword (dbref player, const char *name, const char *password) { dbref victim; if (!Wizard (player)) { notify (player, "Your delusions of grandeur have been duly noted."); return; } else if ((victim = lookup_player (name)) == NOTHING) { notify (player, "No such player."); } else if (*password != '\0' && !ok_password (password)) { /* Wiz can set null passwords, but not bad passwords */ notify (player, "Bad password."); } else if (God (victim) && !God (player)) { notify (player, "You cannot change that player's password."); } else { /* it's ok, do it */ s_Pass (victim, crypt ((char*)password, "XX")); notify (player, "Password changed."); notify (victim, tprintf ("Your password has been changed by %s.", db[player].name)); fprintf (stderr, "***NEWPASSWORD***: %s(#%d) changed password of %s(#%d)\n", db[player].name, player, db[victim].name, victim); } } void do_boot (dbref player, const char *name) { dbref victim; if (!Wizard (player)) { notify (player, "Only a Wizard can boot another player off!"); return; } init_match (player, name, TYPE_PLAYER); match_neighbor (); match_absolute (); match_player (); if ((victim = noisy_match_result ()) == NOTHING) return; if (God (victim)) { notify (player, "Thunder booms in the distance."); return; } if (victim == player) { notify (player, "You're not that limber."); return; } if (Typeof (victim) != TYPE_PLAYER && !God (player)) { notify (player, "You can only boot off other players!"); } else { static char th[BUFFER_LEN], own[BUFFER_LEN]; strcpy (th, unparse_object (player, player)); strcpy (own, unparse_object (player, victim)); fprintf (stderr, "*** BOOT *** %s booted %s\n", th, own); /* we're ok */ /* do it */ /* notify people */ notify (player, tprintf ("You booted %s off!", db[victim].name)); notify (victim, "You are politely shown to the door."); boot_off (victim); /* reset name */ } } void do_chownall (dbref player, const char *name, const char *target) { int i; dbref victim; dbref n_target; if (!Wizard (player)) { notify (player, "Try asking them first!"); return; } init_match (player, name, TYPE_PLAYER); match_neighbor (); match_absolute (); match_player (); if ((victim = noisy_match_result ()) == NOTHING) return; if (!target || !*target) { n_target = NOTHING; } else { init_match (player, target, TYPE_PLAYER); match_neighbor (); match_absolute (); match_player (); if ((n_target = noisy_match_result ()) == NOTHING) return; } for (i = 0; i <= db_top; i++) { if ((db[i].owner == victim) && (Typeof (i) != TYPE_PLAYER)) db[i].owner = (n_target == NOTHING ? player : n_target); } notify (player, "Object ownership changed."); } void do_chzoneall (dbref player, const char *name, const char *target) { int i; dbref victim; dbref zone; if (!Wizard (player)) { notify (player, "You do not have the power to change reality."); return; } init_match (player, name, TYPE_PLAYER); match_neighbor (); match_absolute (); match_player (); if ((victim = noisy_match_result ()) == NOTHING) return; if (!target || !*target) { notify (player, "No zone specified."); return; } if (!string_compare (target, "none")) zone = NOTHING; else { init_match (player, target, TYPE_THING); match_neighbor (); match_possession (); match_absolute (); switch (zone = match_result ()) { case NOTHING: notify (player, "I can't seem to find that."); return; case AMBIGUOUS: notify (player, "I don't know which one you mean!"); return; } if (Typeof (zone) != TYPE_THING) { notify (player, "Zones may only be defined by objects."); return; } } for (i = 0; i <= db_top; i++) { if (db[i].owner == victim) db[i].zone = zone; } notify (player, "Zone changed for all objects."); } extern char cf_motd_msg[BUFFER_LEN], cf_wizmotd_msg[BUFFER_LEN], cf_nologinmotd_msg[BUFFER_LEN]; void do_motd (dbref player, int key, const char *arg1, const char *arg2) { const char *message; if (!Wizard (player) && (key != 3)) { notify (player, "You may get 15 minutes of fame and glory in life, but not right now."); return; } message = reconstruct_message (arg1, arg2); switch (key) { case 1: strcpy (cf_motd_msg, message); notify (player, "Motd set."); break; case 2: strcpy (cf_wizmotd_msg, message); notify (player, "Wizard motd set."); break; case 4: strcpy (cf_nologinmotd_msg, message); notify (player, "Nologin motd set."); break; default: notify (player, tprintf ("MOTD: %s", cf_motd_msg)); if (Wizard (player)) { notify (player, tprintf ("Wiz MOTD: %s", cf_wizmotd_msg)); notify (player, tprintf ("Nologin MOTD: %s", cf_nologinmotd_msg)); } } } void do_login (dbref player, const char *state) { extern int login_allow; time_t tt; tt = time ((time_t *) 0); if (!Wizard (player)) { notify (player, "Unable to authenticate you, sorry."); return; } if (!string_compare (state, "off")) { notify (player, "Logins disabled."); login_allow = 0; fprintf (stderr, "*** LOGINS DISABLED *** by %s(#%d) at %s", db[player].name, player, ctime (&tt)); } else if (!string_compare (state, "on")) { notify (player, "Logins enabled."); login_allow = 1; fprintf (stderr, "*** LOGINS ENABLED *** by %s(#%d) at %s", db[player].name, player, ctime (&tt)); } else { notify (player, tprintf ("Logins are currently %s.", ((login_allow) ? "enabled" : "disabled"))); } return; } void fun_lsearch (char *buff, char *args[10], dbref privs, dbref dumm1) { /* takes arguments in the form of: player, class, restriction */ int is_wiz; dbref restrict_owner; char *who; char *klass; char *rstrict; int flag; object_flag_type flag_mask; char *restrict_name; object_flag_type restrict_type; dbref restrict_zone; dbref thing; int destitute = 1; struct dblist *found = NULL, *ptr = NULL, *list = NULL; if (!payfor (privs, FIND_COST)) { strcpy (buff, "#-1 NOT ENOUGH MONEY TO DO SEARCH"); return; } is_wiz = Wizard (privs); who = args[0]; klass = args[1]; rstrict = args[2]; restrict_zone = NOTHING; /* set limits on who we search */ restrict_owner = NOTHING; if (!string_compare (who, "all")) restrict_owner = is_wiz ? ANY_OWNER : privs; else if (!string_compare (who, "me")) restrict_owner = privs; else restrict_owner = lookup_player (who); if (restrict_owner == NOTHING) { strcpy (buff, "#-1 NO SUCH PLAYER"); return; } /* set limits on what we search for */ flag = 0; flag_mask = 0; restrict_name = NULL; restrict_type = NOTYPE; switch (klass[0]) { case 'e': if (string_prefix ("exits", klass)) { restrict_name = (char *) rstrict; restrict_type = TYPE_EXIT; } else flag = 1; break; case 'f': if (string_prefix ("flags", klass)) { if (!convert_flags (privs, rstrict, &flag_mask, &restrict_type)) { strcpy (buff, "#-1 UNKNOWN FLAG"); return; } } else flag = 1; break; case 'n': if (string_prefix ("name", klass)) restrict_name = (char *) rstrict; else if (!string_prefix ("none", klass)) flag = 1; break; case 'o': if (string_prefix ("objects", klass)) { restrict_name = (char *) rstrict; restrict_type = TYPE_THING; } else flag = 1; break; case 'p': if (string_prefix ("players", klass)) { restrict_name = (char *) rstrict; restrict_type = TYPE_PLAYER; } else flag = 1; break; case 'r': if (string_prefix ("rooms", klass)) { restrict_name = (char *) rstrict; restrict_type = TYPE_ROOM; } else flag = 1; break; case 't': if (string_prefix ("type", klass)) { if (!string_compare (rstrict, "none")) break; if (string_prefix ("room", rstrict)) restrict_type = TYPE_ROOM; else if (string_prefix ("exit", rstrict)) restrict_type = TYPE_EXIT; else if (string_prefix ("object", rstrict)) restrict_type = TYPE_THING; else if (string_prefix ("player", rstrict)) restrict_type = TYPE_PLAYER; else { strcpy (buff, "#-1 UNKNOWN TYPE"); return; } } else flag = 1; break; case 'z': if (string_prefix ("zone", klass)) { init_match (privs, rstrict, TYPE_THING); match_absolute (); restrict_zone = match_result (); } else flag = 1; break; default: flag = 1; } if (flag) { strcpy (buff, "#-1 UNKNOWN TYPE"); return; } /* check privs */ if (!is_wiz && restrict_type != TYPE_PLAYER && (restrict_owner == ANY_OWNER || restrict_owner != privs)) { strcpy (buff, "#-1 PERMISSION DENIED"); return; } /* search loop */ flag = 1; for (thing = 0; thing < db_top; thing++) { found = list; if (restrict_type != NOTYPE && restrict_type != Typeof (thing)) continue; if ((db[thing].flags & flag_mask) != flag_mask) continue; #ifdef DESTROY if (db[thing].flags & GOING) continue; #endif if (Typeof (thing) == TYPE_PLAYER) { if (is_wiz) if (restrict_owner != ANY_OWNER && restrict_owner != db[thing].owner) continue; } else { if (restrict_owner != ANY_OWNER && restrict_owner != db[thing].owner) continue; } if (restrict_name != NULL) if (!string_match (db[thing].name, restrict_name)) continue; if (restrict_zone != NOTHING) if (restrict_zone != getzone (thing)) continue; if (!found) { flag = 0; destitute = 0; found = listcreate (thing); } else listadd (found, thing); list = found; } /* nothing found matching search criteria */ if (destitute) { strcpy (buff, "#-1 NOTHING FOUND"); return; } /* go down the list and print into a buffer */ strcpy (buff, ""); for (ptr = list; ptr; ptr = ptr->next) { if (strlen (buff) + 10 < BUFFER_LEN) strcat (buff, tprintf ("#%d ", ptr->obj)); else strcpy (buff, "#-1 SEARCH LIST TOO LONG"); } if (list) listfree (list); }