#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "emlen.h"

int FORCE_LEVEL;
extern bool noibm;
extern bool kk;
extern bool mb;
extern bool dbs;


ROOM_DATA *find_location (CHAR_DATA * ch, char *arg);

void 
show_questflags (CHAR_DATA * ch, char *argy)
{
  CHAR_DATA *vict;
  int col = 0;
  int i;
  DEFINE_COMMAND ("show_questflags", show_questflags, POSITION_DEAD, 110, LOG_NORMAL, "Shows questflags on a given player.")
    hugebuf_o[0] = '\0';
  if ((vict = get_player_world (ch, argy, FALSE)) == NULL)
    {
      send_to_char ("That player was not found or is not online.\n\r", ch);
      return;
    }
  for (i = 0; i < 3000; i++)
    {
      if (!vict->pcdata->script_flags[i] || vict->pcdata->script_flags[i][0] == '\0')
	continue;
      col++;
      if (col == 8)
	{
	  strcat (hugebuf_o, "\n\r");
	  col = 1;
	}
      sprintf (hugebuf_o + strlen (hugebuf_o), "%-8s ", vict->pcdata->script_flags[i]);
    }
  strcat (hugebuf_o, "\n\r");
  page_to_char (hugebuf_o, ch);
  return;
}

int 
lookup_questname (char *txt)
{
  int i;
  for (i = 0; i < 1000; i++)
    {
      if (questname[i] == NULL)
	continue;
      if (!str_cmp (questname[i], txt))
	return i;
    }
  return -1;
}

void 
do_unlearn (CHAR_DATA * ch, char *argy)
{
  int i;
  SPELL_DATA *spell;
  char general_use[2500];
  DEFINE_COMMAND ("unlearn", do_unlearn, POSITION_DEAD, 110, LOG_ALWAYS, "Allows you to unlearn a specific spell or skill.")

    if (!argy || argy == "" || argy[0] == '\0')
    {
      send_to_char ("Syntax is: Unlearn skill/spellname.\n\r", ch);
      send_to_char ("Please note you do not get your practices or learns back.\n\r", ch);
      send_to_char ("For a full reset (getting pracs and learns back), type preset.\n\r", ch);
      return;
    }
  spell = skill_lookup (argy, -1);
  if (spell == NULL)
    {
      send_to_char ("That isn't a valid skill or spell, sorry.\n\r", ch);
      return;
    }
  if (ch->pcdata->learned[spell->gsn] == -100)
    {
      send_to_char ("You haven't learned that skill/spell anyway!\n\r", ch);
      send_to_char ("If it registers as a skill, you probably are wearing some +bonus equip.\n\r", ch);
      return;
    }
  for (i = 0; i < SKILL_COUNT; i++)
    {
      SPELL_DATA *spl;
      if ((spl = skill_lookup (NULL, i)) == NULL)
	continue;
      if (ch->pcdata->learned[i] < 0)
	continue;
      if (spl->prereq_1 == NULL)
	continue;
      if (skill_lookup (spl->prereq_1, -1) == spell)
	{
	  send_to_char ("You can not unlearn a prerequisite to a spell/skill you already know!\n\r", ch);
	  return;
	}
      if (spl->prereq_2 == NULL)
	continue;
      if (skill_lookup (spl->prereq_2, -1) == spell)
	{
	  send_to_char ("You can not unlearn a prerequisite to a spell/skill you already know!\n\r", ch);
	  return;
	}
    }
  ch->pcdata->learned[spell->gsn] = -100;
  sprintf (general_use, "You have successfully unlearned %s.\n\r",
	   capitalize (spell->spell_funky_name));
  send_to_char (general_use, ch);
  return;
}

void 
player_preset (CHAR_DATA * ch, char *argy)
{
  int i;

  if (argy == "" || argy[0] == '\0')
    {
      send_to_char ("This command wipes all of your skills, and gives you learns and\n\r", ch);
      send_to_char ("practices as if you leveled each level from level 1 again.\n\r", ch);
      send_to_char ("To go ahead with the reset, type preset YES.\n\r", ch);
      return;
    }
  if (IS_MOB (ch))
    {
      send_to_char ("Not on NPC's.\n\r", ch);
      return;
    }
/*clear all skills/spells */
  for (i = 0; i < SKILL_COUNT; i++)
    {
      ch->pcdata->learned[i] = -100;
    }
  ch->pcdata->practice = 1 + ((LEVEL (ch) - 1) *
			      (wis_app[get_curr_wis (ch)].practice));
  if (LEVEL (ch) < 4)
    ch->pcdata->learn = (LEVEL (ch) * 2);
  else
    ch->pcdata->learn = 6 + (LEVEL (ch) - 3);
  send_to_char ("Your practices and learns have been reset.\n\r", ch);
  return;
}

void 
do_preset (CHAR_DATA * ch, char *argy)	/*BY Owen Emlen */
{
  CHAR_DATA *victim;
  char arg1[500];
  int i;
  DEFINE_COMMAND ("preset", do_preset, POSITION_DEAD, 110, LOG_ALWAYS, "This command resets all skills and practices of a target character.")

    if (!IS_REAL_GOD (ch))
    {
      player_preset (ch, argy);
      return;
    }
  if (argy == "" || argy[0] == '\0')
    {
      send_to_char ("Format is PRESET <player>\n\r", ch);
      return;
    }
  argy = one_argy (argy, arg1);
  if ((victim = get_char_world (ch, arg1)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }

/*clear all skills/spells */
  for (i = 0; i < SKILL_COUNT; i++)
    {
      victim->pcdata->learned[i] = -100;
    }
  victim->pcdata->practice = 10 + ((LEVEL (victim) - 1) *
				 (wis_app[get_curr_wis (victim)].practice));
  victim->pcdata->practice = 1 + ((LEVEL (victim) - 1) *
				  (wis_app[get_curr_wis (victim)].practice));
  if (LEVEL (victim) < 4)
    victim->pcdata->learn = (LEVEL (victim) * 2);
  else
    victim->pcdata->learn = 6 + (LEVEL (victim) - 3);
  send_to_char ("Practices and learns reset.\n\r", ch);
  send_to_char ("Your practices have been reset! :)\n\r", victim);
  return;
}


/* notify stuff partially lifted, so it probalby doens't work 100% - piece o crap */
void 
do_notify (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char buf[SML_LENGTH];
  DEFINE_COMMAND ("notify", do_notify, POSITION_DEAD, 110, LOG_NORMAL, "Notify HELP for help.  This toggles god/immort notification.")

    if (IS_MOB (ch))
    return;
  smash_tilde (argy);
  argy = one_argy (argy, arg1);
  if (arg1[0] == '\0')
    {
      if (IS_SET (ch->act, WIZ_NOTIFY))
	{
	  send_to_char ("Godinfo/Notification is now OFF.\n\r", ch);
	  REMOVE_BIT (ch->act, WIZ_NOTIFY);
	  return;
	}
      else
	{
	  send_to_char ("Godinfo/Notification is now ON.\n\r", ch);
	  SET_BIT (ch->act, WIZ_NOTIFY);
	  return;
	}
    }
  else if (!str_cmp (arg1, "death")
	   || !str_cmp (arg1, "deaths"))
    {
      if (IS_SET (ch->act, WIZ_NOTIFY_DEATH))
	{
	  send_to_char ("Death notification is now OFF.\n\r", ch);
	  REMOVE_BIT (ch->act, WIZ_NOTIFY_DEATH);
	  return;
	}
      else
	{
	  send_to_char ("Death notification is now ON.\n\r", ch);
	  SET_BIT (ch->act, WIZ_NOTIFY_DEATH);
	  return;
	}
    }
  else if (!str_cmp (arg1, "bug")
	   || !str_cmp (arg1, "bugs"))
    {
      if (IS_SET (ch->act, WIZ_NOTIFY_BUG))
	{
	  send_to_char ("Bug notification is now OFF.\n\r", ch);
	  REMOVE_BIT (ch->act, WIZ_NOTIFY_BUG);
	  return;
	}
      else
	{
	  send_to_char ("Bug notification is now ON.\n\r", ch);
	  SET_BIT (ch->act, WIZ_NOTIFY_BUG);
	  return;
	}
    }
  else if (!str_cmp (arg1, "log")
	   || !str_cmp (arg1, "logs"))
    {
      if (IS_SET (ch->act, WIZ_NOTIFY_LOG))
	{
	  send_to_char ("Log notification is now OFF.\n\r", ch);
	  REMOVE_BIT (ch->act, WIZ_NOTIFY_LOG);
	  return;
	}
      else
	{
	  send_to_char ("Log notification is now ON.\n\r", ch);
	  SET_BIT (ch->act, WIZ_NOTIFY_LOG);
	  if (IS_SET (ch->act, WIZ_NOTIFY_BUG))
	    do_notify (ch, "bug");
	  return;
	}
    }
  else if (!str_cmp (arg1, "login")
	   || !str_cmp (arg1, "logins"))
    {
      if (IS_SET (ch->act, WIZ_NOTIFY_LOGIN))
	{
	  send_to_char ("Login notify is now OFF.\n\r", ch);
	  REMOVE_BIT (ch->act, WIZ_NOTIFY_LOGIN);
	  return;
	}
      else
	{
	  send_to_char ("Login notify is now ON.\n\r", ch);
	  SET_BIT (ch->act, WIZ_NOTIFY_LOGIN);
	  return;
	}
    }
  else if (!str_cmp (arg1, "?")
	   || !str_cmp (arg1, "help")
	   || !str_cmp (arg1, "list"))
    {
      send_to_char ("Typing NOTIFY <option> toggles the notification on and off.\n\r", ch);
      send_to_char ("NOTIFY alone toggles notification off/on.\n\r", ch);
      send_to_char ("NOTIFY LIST and NOTIFY HELP all list this display.\n\r", ch);
      sprintf (buf, "Login notify : %s\n\r",
	       IS_SET (ch->act, WIZ_NOTIFY_LOGIN) ? "ON" : "OFF");
      send_to_char (buf, ch);
      sprintf (buf, "Bugs notify : %s\n\r",
	       IS_SET (ch->act, WIZ_NOTIFY_BUG) ? "ON" : "OFF");
      send_to_char (buf, ch);
      sprintf (buf, "Logs notify : %s\n\r",
	       IS_SET (ch->act, WIZ_NOTIFY_LOG) ? "ON" : "OFF");
      send_to_char (buf, ch);
      sprintf (buf, "Death notify : %s\n\r",
	       IS_SET (ch->act, WIZ_NOTIFY_DEATH) ? "ON" : "OFF");
      send_to_char (buf, ch);
      sprintf (buf, "The notify command is currently %s.\n\r",
	       IS_SET (ch->act, WIZ_NOTIFY) ? "active" : "inactive");
      send_to_char (buf, ch);
      return;
    }
  else
    {
      send_to_char ("Huh?\n\r", ch);
      return;
    }
  return;
}

void 
do_beamin (CHAR_DATA * ch, char *argy)
{
  DEFINE_COMMAND ("beamin", do_beamin, POSITION_DEAD, 100, LOG_NORMAL, "This command changes what people see when you trans into the room.")

    if (IS_PLAYER (ch))
    {
      smash_tilde (argy);
      free_string (ch->pcdata->beamin);
      ch->pcdata->beamin = str_dup (argy);
      send_to_char ("Set.\n\r", ch);
    }
  return;
}

void 
do_beamout (CHAR_DATA * ch, char *argy)
{
  DEFINE_COMMAND ("beamout", do_beamout, POSITION_DEAD, 100, LOG_NORMAL, "This command changes what people see when you trans out of the room.")
    if (IS_PLAYER (ch))
    {
      smash_tilde (argy);
      free_string (ch->pcdata->beamout);
      ch->pcdata->beamout = str_dup (argy);
      send_to_char ("Set.\n\r", ch);
    }
  return;
}


void 
do_disconnect (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  DESCRIPTOR_DATA *d;
  CHAR_DATA *victim;
  DEFINE_COMMAND ("disconnect", do_disconnect, POSITION_DEAD, 110, LOG_ALWAYS, "This will cause the person to 'drop link'.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Disconnect who?\n\r", ch);
      return;
    }
  if ((victim = get_char_world (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  for (d = descriptor_list; d != NULL; d = d->next)
    {
      if (d == victim->desc)
	{
	  close_socket (d);
	  send_to_char ("Ok.\n\r", ch);
	  return;
	}
    }
  return;
}

void 
do_echo (CHAR_DATA * ch, char *argy)
{
  DESCRIPTOR_DATA *d;
  DEFINE_COMMAND ("echo", do_echo, POSITION_DEAD, 110, LOG_ALWAYS, "This command prints a message to the entire mud.")

    if (argy[0] == '\0')
    {
      send_to_char ("Echo what?\n\r", ch);
      return;
    }
  for (d = descriptor_list; d; d = d->next)
    {
      if ((d->connected == CON_PLAYING || d->connected == CON_MEDITOR ||
	   d->connected == CON_OEDITOR || d->connected == CON_REDITOR)
	  && d->character)
	{
	  send_to_char (anseval (argy, d->character), d->character);
	  send_to_char ("\e[0m\n\r", d->character);
	}
    }
  return;
}

void 
do_arenaecho (CHAR_DATA * ch, char *argy, bool batspam)
{
  DESCRIPTOR_DATA *d;
  if (argy[0] == '\0')
    {
      send_to_char ("Echo what?\n\r", ch);
      return;
    }
  for (d = descriptor_list; d; d = d->next)
    {
      if (!d->character)
	continue;
      if (IS_MOB (d->character))
	continue;
      if (CHALLENGE (d->character) == 10)
	continue;
      if (d->character && d->character->pcdata->arena_msg == 0)
	continue;
      if (d->character && d->character->pcdata->arena_msg == 2 && batspam == TRUE)
	continue;
      if (d->character->position == POSITION_FIGHTING && number_range (1, 2) == 1)
	continue;
      if (d->connected == CON_PLAYING)
	{
	  send_to_char (anseval (argy, d->character), d->character);
	  send_to_char ("\e[0m\n\r", d->character);
	}
    }
  return;
}

void 
do_recho (CHAR_DATA * ch, char *argy)
{
  DESCRIPTOR_DATA *d;
  DEFINE_COMMAND ("recho", do_recho, POSITION_DEAD, 100, LOG_NORMAL, "This shows a message to everyone in the room.")

    if (argy[0] == '\0')
    {
      send_to_char ("Recho what?\n\r", ch);
      return;
    }
  for (d = descriptor_list; d; d = d->next)
    {
      if (d->connected == CON_PLAYING
	  && d->character->in_room == ch->in_room)
	{
	  send_to_char (anseval (argy, d->character), d->character);
	  send_to_char ("\e[0m\n\r", d->character);
	}
    }
  return;
}

ROOM_DATA *
find_location (CHAR_DATA * ch, char *arg)
{
  CHAR_DATA *victim;
  SINGLE_OBJECT *obj;
  if (is_number (arg))
    return get_room_index (atoi (arg));
  if ((victim = get_char_world (ch, arg)) != NULL)
    return victim->in_room;
  if ((obj = get_obj_world (ch, arg)) != NULL)
    return obj->in_room;
  return NULL;
}

void 
do_transfer (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char arg2[SML_LENGTH];
  CHAR_DATA *t;
  ROOM_DATA *location;
  DESCRIPTOR_DATA *d;
  CHAR_DATA *victim;
  DEFINE_COMMAND ("transfer", do_transfer, POSITION_DEAD, 110, LOG_NORMAL, "This transfers someone to a room specified, and more...")

    argy = one_argy (argy, arg1);
  one_argy (argy, arg2);
  if (arg1[0] == '\0')
    {
      send_to_char ("Transfer whom (and where)?\n\r", ch);
      return;
    }
  if (!str_cmp (arg1, "all"))
    {
      bool bground;
      bground = FALSE;
      if (UPPER (arg2[0]) == 'B')
	bground = TRUE;
      for (d = descriptor_list; d != NULL; d = d->next)
	{
	  if (d->connected == CON_PLAYING
	      && d->character->pcdata &&
	      IS_PLAYER (d->character) &&
	      d->character != ch
	      && d->character->in_room != NULL)
	    {
	      char buf[STD_LENGTH];
	      if (bground && d->character->pcdata->level > 99)
		continue;
	      if (!bground)
		{
		  sprintf (buf, "%s %s", NAME (d->character), arg2);
		}
	      else
		{
		  char buf2[500];
		  if (!d->character->pcdata->bgf)
		    continue;
		  if (d->character->in_room->vnum < 1000 &&
		      d->character->in_room->vnum != 100 &&
		      d->character->in_room->vnum != 99)
		    {
		      send_to_char ("You cannot be in the battleground since you are in an invalid part of the world.\n\r", d->character);
		      continue;
		    }


		  if (LEVEL (d->character) < min_level || LEVEL (d->character) > max_level)
		    continue;
		  d->character->pcdata->bgf = FALSE;
		  sprintf (buf, "%s %d", NAME (d->character),
			   number_range (BATTLEGROUND_START_VNUM, BATTLEGROUND_END_VNUM - 1));
		  sprintf (buf2, "%s", NAME (d->character));
		  do_restore (ch, buf2);
		}
	      do_transfer (ch, buf);
	    }
	}
      return;
    }
  if (!str_cmp (arg1, "all_in_room"))
    {
      for (d = descriptor_list; d != NULL; d = d->next)
	{
	  if (d->connected == CON_PLAYING
	      && d->character->pcdata &&
	      IS_PLAYER (d->character) &&
	      d->character != ch
	      && d->character->in_room != NULL
	      && d->character->in_room == ch->in_room)
	    {
	      char buf[STD_LENGTH];
	      sprintf (buf, "%s %s", NAME (d->character), arg2);
	      do_transfer (ch, buf);
	    }
	}
      return;
    }
  if (arg2[0] == '\0')
    {
      location = ch->in_room;
    }
  else
    {
      if ((location = find_location (ch, arg2)) == NULL)
	{
	  if ((location = find_room_tag (argy)) == NULL)
	    {
	      send_to_char ("No such location.\n\r", ch);
	      return;
	    }
	}
    }
  victim = NULL;
  if (allow_anything)
    {
      for (t = char_list; t != NULL; t = t->next)
	{
	  if (!str_cmp (RNAME (t), arg1))
	    {
	      victim = t;
	      break;
	    }
	}
      if (!victim)
	return;
    }
  else if ((victim = get_char_world_2 (ch, arg1)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }

  if (FIGHTING (victim) != NULL)
    stop_fighting (FIGHTING (victim), TRUE);
  stop_fighting (victim, TRUE);
  act ("$n disappears in a cloud of smoke.", victim, NULL, NULL, TO_ROOM);
  char_from_room (victim);
  char_to_room (victim, location);
  act ("$n arrives in a dazzling white flash.", victim, NULL, NULL, TO_ROOM);
  if (IS_PLAYER (ch) && ch != victim)
    act ("You have been magically transferred.", ch, NULL, victim, TO_VICT);
  if (IS_PLAYER (victim) && victim->pcdata->resist_summon == -10)
    {
      noibm = victim->pcdata->noibm;
      kk = victim->pcdata->kk;
      mb = victim->pcdata->mb;
      dbs = victim->pcdata->dbs;
      drawit (victim, "");
      noibm = FALSE;
      kk = FALSE;
      mb = FALSE;
      dbs = FALSE;
      gotoxy (victim, 1, victim->pcdata->pagelen);
    }
    if (IS_JAVA(victim)) {
        do_clear(victim,"");
        }
  do_look (victim, "auto");
  if (IS_PLAYER (ch) && LEVEL (ch) > 100)
    send_to_char ("Ok.\n\r", ch);
  return;
}


void 
do_mat (CHAR_DATA * ch, char *argy)
{
  int i, j, hash;
  char arg[SML_LENGTH];
  char arg2[SML_LENGTH];
  ROOM_DATA *location, *location2;
  ROOM_DATA *original, *roomto;
  DEFINE_COMMAND ("mat", do_mat, POSITION_DEAD, 110, LOG_NORMAL, "This command performs multiple commands at the locations specified.")

    if (IS_MOB (ch))
    return;
  argy = one_argy (argy, arg);
  argy = one_argy (argy, arg2);
  if (arg[0] == '\0' || argy[0] == '\0')
    {
      send_to_char ("At where what?\n\r", ch);
      return;
    }
  if ((location = find_location (ch, arg)) == NULL)
    {
      if ((location = find_room_tag (arg)) == NULL)
	{
	  send_to_char ("No such location.\n\r", ch);
	  return;
	}
    }

  i = atoi (arg);
  j = atoi (arg2);
  if ((j - i > 100) || (j - i < 1))
    {
      send_to_char ("Invalid argument range!\n\r", ch);
      return;
    }

  original = ch->in_room;
  for (hash = 0; hash < HASH_MAX; hash++)
    {
      for (roomto = room_hash[hash]; roomto != NULL; roomto = roomto->next)
	{
	  if (roomto->vnum <= j && roomto->vnum >= i)
	    {
	      char_from_room (ch);
	      /*u_ */ char_to_room (ch, roomto);
	      super_interpret (ch, argy);
	    }
	}
    }

  char_from_room (ch);
/*u_ */ char_to_room (ch, original);

  return;
}



void 
do_at (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  ROOM_DATA *location;
  ROOM_DATA *original;
  DEFINE_COMMAND ("at", do_at, POSITION_DEAD, 110, LOG_NORMAL, "This command performs a command at the location specified.")

    if (IS_MOB (ch))
    return;
  argy = one_argy (argy, arg);
  if (arg[0] == '\0' || argy[0] == '\0')
    {
      send_to_char ("At where what?\n\r", ch);
      return;
    }
  if ((location = find_location (ch, arg)) == NULL)
    {
      if ((location = find_room_tag (arg)) == NULL)
	{
	  send_to_char ("No such location.\n\r", ch);
	  return;
	}
    }
  original = ch->in_room;
  char_from_room (ch);
/*u_ */ char_to_room (ch, location);
  gotoxy (ch, 1, ch->pcdata->pagelen);
  super_interpret (ch, argy);
  char_from_room (ch);
/*u_ */ char_to_room (ch, original);
  return;
}

void 
do_goto (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  DEFINE_COMMAND ("goto", do_goto, POSITION_DEAD, 101, LOG_NORMAL, "This command beams you to the location specified.")
    if (argy[0] == '\0')
    {
      send_to_char ("Goto where?\n\r", ch);
      return;
    }
  strcpy (arg, "self ");
  strcat (arg, argy);
  do_transfer (ch, arg);
  return;
}

void 
do_rstat (CHAR_DATA * ch, char *argy)
{
  extern char *const dir_name[];
  char buf[STD_LENGTH];
  char arg[SML_LENGTH];
  TRACK_DATA *tr;
  bool full = FALSE;
  ROOM_DATA *location;
  int door;
  DEFINE_COMMAND ("rstat", do_rstat, POSITION_DEAD, 100, LOG_NORMAL, "This command shows the 'redit' room stats.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  location = (arg[0] == '\0') ? ch->in_room : find_location (ch, arg);
  if (!str_prefix ("full", arg))
    {
      location = ch->in_room;
      full = TRUE;
    }
  if (location == NULL)
    {
      send_to_char ("No such location.\n\r", ch);
      return;
    }
  sprintf (buf, "[%d %d] %s<%s> Name: '%s' %s\n\rArea: [%3d] '%s'\n\r",
	((unsigned char) (location->img[0]!=0 ? location->img[0] : 0)),
	((unsigned char) (location->img[1]!=0 ? location->img[1] : 0)),
	   (location->more ? "*" : ""),
	 (location->shade ? "\x1B[30;1mS\x1B[37;0m" : "\x1B[37;1mL\x1B[0m"),
	   location->name,
	   (IS_SET (location->room_flags_2, ROOM2_OCEAN_D) ? "(Ocean)" : ""),
	   location->area->vnum,
	   location->area->name);
  send_to_char (buf, ch);
  sprintf (buf,
	   "Vnum: %d  Coord: %d,%d,%d\n\rSector: %s\n\rLight: %d. Tps: %d. Pcs: %d\n\r",
	   location->vnum, location->x, location->y, location->z,
	   get_sector_name (location->sector_type),
	   location->light, location->tps, (location->more ? location->more->pcs : 0));
  send_to_char (buf, ch);
  if (location->more && IS_SET (location->room_flags, ROOM_MOVING))
    {
      sprintf (buf, "Autotransport direction: %s\n\r", dir_name[location->more->move_dir]);
      send_to_char (buf, ch);
      sprintf (buf, "Move message:\n\r%s",
	       location->more->move_message);
      send_to_char (buf, ch);
    }
  if (location->more && IS_SET (location->room_flags, ROOM_ISVEHICLE))
    {
      sprintf (buf, "Moving verb: %s", location->more->move_message);
      send_to_char (buf, ch);
      if (location->more->orig_room > 0)
	{
	  sprintf (buf, "Default links to: %d.\n\r", location->more->orig_room);
	  send_to_char (buf, ch);
	}
      if (location->more->obj_description)
	{
	  sprintf (buf, "Obj_descript: %s", location->more->obj_description);
	  send_to_char (buf, ch);
	}
      if (location->more->linked_to)
	{
	  sprintf (buf, "Linked to: %d.", location->more->linked_to->vnum);
	  send_to_char (buf, ch);
	}
      send_to_char ("\n\r", ch);
      sprintf (buf, "Can_travel_sectors: %s\n\r", sector_fname (location->more->can_travel_sectors));
      send_to_char (buf, ch);
    }
  sprintf (buf,
	   "Room flags: %s\n\r",
	   room_bit_name (location->room_flags));
  send_to_char (buf, ch);
  if (location->more && location->more->extra_descr != NULL)
    {
      DESCRIPTION_DATA *ed;
      send_to_char ("Extra description keywords: ", ch);
      for (ed = location->more->extra_descr; ed; ed = ed->next)
	{
	  send_to_char ("'", ch);
	  send_to_char (ed->keyword, ch);
	  send_to_char ("'", ch);
	}
      send_to_char ("\n\r", ch);
    }
  for (door = 0; door <= 5; door++)
    {
      EXIT_DATA *pexit;
      if ((pexit = location->exit[door]) != NULL)
	{
	  if (pexit->d_info)
	    sprintf (buf,
		     "Door: %5s To: %d Key: %d Exit flags: %d(%d) '%s'\n\r",
		     dir_name[door],
		     (ROOM_DATA *) pexit->to_room != NULL ? ((ROOM_DATA *) pexit->to_room)->vnum : 0,
		     pexit->d_info->key,
		     pexit->d_info->exit_info, pexit->d_info->rs_flags,
	    (pexit->d_info->keyword != NULL) ? pexit->d_info->keyword : "");
	  else
	    sprintf (buf,
		     "Door: %5s To: %d\n\r",
		     dir_name[door],
		     (ROOM_DATA *) pexit->to_room != NULL ? ((ROOM_DATA *) pexit->to_room)->vnum : 0);
	  send_to_char (buf, ch);
	  if (pexit->d_info)
	    {
	      if (pexit->d_info->str != 30 && pexit->d_info->str != 0)
		{
		  sprintf (buf, "\tStr: %d Max Str: %d\n\r",
			   pexit->d_info->str, pexit->d_info->maxstr);
		  send_to_char (buf, ch);
		}
	    }
	  if (pexit->d_info && pexit->d_info->description != NULL && pexit->d_info->description[0] != '\0')
	    send_to_char (pexit->d_info->description, ch);
	}
    }
  if (full)
    {
      for (tr = location->tracks; tr != NULL; tr = tr->next_track_in_room)
	{
	  char bugr[500];
	  sprintf (bugr, "%s: entered %s, left %s.\n\r",
		   (IS_PLAYER (tr->ch) ? NAME (tr->ch) : tr->ch->pIndexData->short_descr),
		   (tr->dir_came == 10 ? "None" : dir_name[tr->dir_came]),
		   (tr->dir_left == 10 ? "None" : dir_name[tr->dir_left]));
	  send_to_char (bugr, ch);
	}
    }
  return;
}

void 
do_ostat (CHAR_DATA * ch, char *argy)
{
  char buf[STD_LENGTH];
  char arg[SML_LENGTH];
  AFFECT_DATA *paf;
  SINGLE_OBJECT *obj;
  DEFINE_COMMAND ("ostat", do_ostat, POSITION_DEAD, 100, LOG_NORMAL, "This command shows 'oedit' info on the object specified.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Ostat what?\n\r", ch);
      return;
    }
  if ((obj = get_obj_world (ch, arg)) == NULL)
    {
      send_to_char ("Nothing like that in hell, earth, or heaven.\n\r", ch);
      return;
    }
  if (LEVEL (ch) > 100 && LEVEL (ch) < 110 && obj->pIndexData->area->open != 0)
    {
      send_to_char ("Due to cheating, builders cannot ostat objects in opened areas.\n\r", ch);
      return;
    }
  sprintf (buf, "Name: '%s'.\n\rArea: [%3d] '%s'.\n\rFile: '%s'.\n\r",
	   obj->pIndexData->name,
	   obj->pIndexData->area->vnum,
	   obj->pIndexData->area->name,
	   obj->pIndexData->area->filename);
  send_to_char (buf, ch);
  sprintf (buf, "Vnum: %d. Type: %s.\n\r",
	   obj->pIndexData->vnum,
	   item_type_name (obj->pIndexData->item_type));
  send_to_char (buf, ch);
  sprintf (buf, "Short description: %s\e[0m\n\rLong description: %s\e[0m",
	   OOSTR (obj, short_descr), OOSTR (obj, description));
  send_to_char (buf, ch);
  sprintf (buf, "Wear bits: %s.\n\r Extra bits: %s.\n\r",
	   wear_bit_name (obj->pIndexData->wear_flags),
	   extra_bit_name (obj->pIndexData->extra_flags));
  send_to_char (buf, ch);
  sprintf (buf, "Number: %d/%d. Weight: %d/%d.\n\r",
	   1, get_obj_number (obj),
	   obj->pIndexData->weight, get_obj_weight (obj));
  send_to_char (buf, ch);
  sprintf (buf, "Cost: %d. Timer: %d. Level: %d.\n\r",
	   obj->cost, obj->timer, obj->pIndexData->level);
  send_to_char (buf, ch);
  sprintf (buf,
	   "In room: %d. In object: %s. Carried by: %s. Wear_loc: %s.\n\r",
	   obj->in_room == NULL ? 0 : obj->in_room->vnum,
	   obj->in_obj == NULL ? "(none)" : OOSTR (obj->in_obj, short_descr),
	   obj->carried_by == NULL ? "(none)" : NAME (obj->carried_by),
	   wear_loc_name (obj->wear_loc));
  send_to_char (buf, ch);

  if (obj->pIndexData->extra_descr != NULL)
    {
      DESCRIPTION_DATA *ed;
      send_to_char ("Extra description keywords: '", ch);
      for (ed = obj->pIndexData->extra_descr; ed != NULL; ed = ed->next)
	{
	  send_to_char (ed->keyword, ch);
	  if (ed->next != NULL)
	    send_to_char (" ", ch);
	}
      for (ed = obj->pIndexData->extra_descr; ed != NULL; ed = ed->next)
	{
	  send_to_char (ed->keyword, ch);
	  if (ed->next != NULL)
	    send_to_char (" ", ch);
	}
      send_to_char ("'.\n\r", ch);
    }

  for (paf = obj->pIndexData->affected; paf != NULL; paf = paf->next)
    {
      sprintf (buf, "Affects %s by %d.\n\r", affect_loc_name (paf->location),
	       paf->modifier);
      send_to_char (buf, ch);
    }
  return;
}

void 
do_mstat (CHAR_DATA * ch, char *argy)
{
  char buf[STD_LENGTH];
  char arg[SML_LENGTH];
  AFFECT_DATA *paf;
  CHAR_DATA *victim;
  SPELL_DATA *spell;
  DEFINE_COMMAND ("mstat", do_mstat, POSITION_DEAD, 100, LOG_NORMAL, "Shows a non-floating mob data summary of the vnum specified.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Mstat whom?\n\r", ch);
      return;
    }
  if ((victim = get_char_world (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (LEVEL (ch) > 100 && LEVEL (ch) < 110 && victim->in_room && victim->in_room->area->open != 0)
    {
      send_to_char ("Due to cheating, builders cannot mstat mobs in opened areas.\n\r", ch);
      return;
    }
  if (IS_PLAYER (victim))
    {
      send_to_char ("Not on PC's.\n\r", ch);
      return;
    }
  sprintf (buf, "Name: '%s'.\n\rArea: [%3d] '%s'.\n\r",
	   RNAME (victim),
	   victim->pIndexData->area->vnum,
	   victim->pIndexData->area->name);
  send_to_char (buf, ch);
  sprintf (buf, "Height: \x1B[37;1m%d\x1B[37;0m (%d' %d\")\n\r",
	   victim->height,
	   victim->height / 12,
	   victim->height % 12);
  send_to_char (buf, ch);
  sprintf (buf, "Vnum: %d  Sex: %s  In Room: %d  ",
	   victim->pIndexData->vnum,
	   SEX (victim) == SEX_MALE ? "male" :
	   SEX (victim) == SEX_FEMALE ? "female" : "neutral",
	   victim->in_room == NULL ? 0 : victim->in_room->vnum);
  send_to_char (buf, ch);
  sprintf (buf, "Hp: %d/%d  Moves: %d/%d\n\r",
	   victim->hit, victim->max_hit,
	   victim->move, victim->max_move);
  send_to_char (buf, ch);
/*sprintf( buf,
   "Str: %d Int: %d Wis: %d Dex: %d Con: %d\n\r",
   get_curr_str( victim ),
   get_curr_int( victim ),
   get_curr_wis( victim ),
   get_curr_dex( victim ),
   get_curr_con( victim ) );
   send_to_char( buf, ch );
 */
  sprintf (buf,
	   "Level: %d  Alignment: %d  AC: %d  Coins: %d  Exp: %ld\n\r",
	   LEVEL (victim), ALIGN (victim),
	   GET_AC (victim), tally_coins (victim), victim->exp);
  send_to_char (buf, ch);
  sprintf (buf, "Hitroll: %d  Damroll: %d  Position: %d\n\r",
	   GET_HITROLL (victim) + victim->pIndexData->hitroll, GET_DAMROLL (victim), victim->position);
  send_to_char (buf, ch);
  if (victim->position == POSITION_FIGHTING)
    {
      sprintf (buf, "Fighting: %s.\n\r",
	       FIGHTING (victim) ? NAME (victim->fgt->fighting) : "(none)");
      send_to_char (buf, ch);
    }
  sprintf (buf, "Act: \x1B[37;1m%s\x1B[37;0m  Act3: \x1B[37;1m%s\x1B[37;0m\n\r",
      act_bit_name (victim->act), act3_bit_name (victim->pIndexData->act3));
  send_to_char (buf, ch);
  sprintf (buf, "Mobtype: %s  ",
	   mob_type_name (victim->pIndexData->mobtype));
  send_to_char (buf, ch);
  if (HUNTING (victim) != NULL)
    {
      sprintf (buf, "Hunting: %s  ", victim->fgt->hunting);
      send_to_char (buf, ch);
    }
  sprintf (buf, "Master: %s  Leader: %s\n\rAffected by: %s%s.\n\r",
	   MASTER (victim) ? NAME (victim->fgt->master) : "(none)",
	   LEADER (victim) ? NAME (victim->fgt->leader) : "(none)",
	   affect_bit_name (victim->affected_by),
	   affect_bit_name_two (victim->more_affected_by));
  send_to_char (buf, ch);
  sprintf (buf, "Short description: %s\n\rLong description: %s\n\r",
	   SD (victim), LD (victim));
  send_to_char (buf, ch);
  if (victim->pIndexData->spec_fun != NULL)
    {
      sprintf (buf, "Spec fun: %s.\n\r", victim->pIndexData->spec_name);
      send_to_char (buf, ch);
    }
  if (victim->pIndexData->alt_vnum != 0)
    {
      sprintf (buf, "Alter mob vnum: %d.\n\r", victim->pIndexData->alt_vnum);
      send_to_char (buf, ch);
    }
  for (paf = victim->affected; paf != NULL; paf = paf->next)
    {
      spell = skill_lookup (NULL, (int) paf->type);
      if (spell == NULL)
	continue;
      sprintf (buf,
      "Spell: '%s' modifies %s by %d for %d hours with bits %s and %s.\n\r",
	       spell->spell_funky_name,
	       affect_loc_name (paf->location),
	       paf->modifier,
	       paf->duration,
	       affect_bit_name (paf->bitvector),
	       affect_bit_name_two (paf->bitvector2));
      send_to_char (buf, ch);
    }
  return;
}

void 
do_mfind (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char arg2[SML_LENGTH];
  char arg3[SML_LENGTH];
  int slen = 0;
  MOB_PROTOTYPE *pMobIndex;
  char oneline[500];
  bool fRange = FALSE;
  bool fArea = FALSE;
  bool fName = FALSE;
  int range1 = 0;
  int range2 = 0;
  AREA_DATA *pArea;
  char name[SML_LENGTH];
  int vnum;
  bool found = FALSE;
  char typename[40];
  DEFINE_COMMAND ("mfind", do_mfind, POSITION_DEAD, 100, LOG_NORMAL, "Used to find mob prototypes (vnums).")

    pArea = ch->in_room->area;
  hugebuf_o[0] = '\0';
  typename[0] = '\0';
  if (IS_MOB (ch))
    return;
  name[0]='\0';
  argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  argy = one_argy (argy, arg3);
  if (arg1[0] == '\0')
    {
      send_to_char ("Syntax: mfind all\n\r", ch);
      send_to_char (" mfind [name, area] [num1 num2]\n\r", ch);
      return;
    }
  if (is_number (arg1) && is_number (arg2))
    {
      fRange = TRUE;
      range1 = atoi (arg1);
      range2 = atoi (arg2);
      if (!str_cmp (arg3, "area"))
	fArea = TRUE;
      else
	{
	  if (!str_cmp (arg3, "all"))
	    {
	      fRange = FALSE;
	      fName = FALSE;
	      fArea = FALSE;
	    }
	  else
	    {
	      fName = TRUE;
	      strcpy (name, arg3);
	    }
	}
    }
  else
    {
      if (is_number (arg2) && is_number (arg3))
	{
	  fRange = TRUE;
	  range1 = atoi (arg2);
	  range2 = atoi (arg3);
	}
      if (!str_cmp (arg1, "area"))
	fArea = TRUE;
      else
	{
	  if (!str_cmp (arg1, "all"))
	    {
	      fRange = FALSE;
	      fName = FALSE;
	      fArea = FALSE;
	    }
	  else
	    {
	      fName = TRUE;
	      strcpy (name, arg1);
	    }
	}
    }
  if (range1 > range2 && fRange)
    {
      vnum = range1;
      range1 = range2;
      range2 = vnum;
    }
  if (range2 > top_vnum_mob || !fRange)
    range2 = top_vnum_mob;
  for (vnum = range1; vnum <= range2; vnum++)
    {
      if ((pMobIndex = get_mob_index (vnum)) != NULL
	  && (is_name (name, pMobIndex->name) || !fName)
	  && (pMobIndex->area == pArea || !fArea))
	{
	  if (pMobIndex->mobtype == -1)
	    strcpy (typename, "\e[1mundefined\e[0m");
	  else if (pMobIndex->mobtype != MOB_OTHER
		   && mob_type[pMobIndex->mobtype] != NULL)
	    strcpy (typename, mob_type[pMobIndex->mobtype]);
	  else
	    strcpy (typename, "other");
	  found = TRUE;
	  sprintf (oneline, "[%5d %3d] %-25s%s %-25s %-10s\n\r", vnum, pMobIndex->level,
		   pMobIndex->short_descr,
		   get_ansi_spaces (pMobIndex->short_descr),
		   !fArea ? pMobIndex->name : "", typename);
	  sprintf (hugebuf_o + slen, "%s", oneline);
	  slen += strlen (oneline);
	  if (slen > 29500)
	    {
	      hugebuf_o[29500] = '\0';
	      break;
	    }
	}
    }
  if (!found)
    send_to_char ("Nothing like that in hell, earth, or heaven.\n\r", ch);
  if (hugebuf_o[0] != '\0')
    page_to_char (hugebuf_o, ch);
  return;
}

void 
do_ofind (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char arg2[SML_LENGTH];
  char arg3[SML_LENGTH];
  OBJ_PROTOTYPE *pObjIndex;
  bool fRange = FALSE;
  bool fArea = FALSE;
  bool fName = FALSE;
  int slen = 0;
  char oneline[500];
  int range1 = 0;
  int range2 = 0;
  AREA_DATA *pArea;
  char name[SML_LENGTH];
  int vnum;
  bool found = FALSE;

  DEFINE_COMMAND ("ofind", do_ofind, POSITION_DEAD, 100, LOG_NORMAL, "This command is used to find object prototypes (vnums).")
    pArea = ch->in_room->area;
  name[0]='\0';
  if (IS_MOB (ch))
    return;
  hugebuf_o[0] = '\0';
  argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  argy = one_argy (argy, arg3);
  if (arg1[0] == '\0')
    {
      send_to_char ("Syntax: ofind all\n\r", ch);
      send_to_char (" ofind [name, area] [num1 num2]\n\r", ch);
      return;
    }
  if (!str_cmp(arg1,"weapons")) {
	OBJ_PROTOTYPE *op;
	int i;
	int ln;
	sprintf(hugebuf_o,"%5s %-25s  %-6s %-10s %5s %s\n\r",
		"Vnum","Weapon Name","Damage","Type","Cost","MoreAff");
	for (i=0; i<HASH_MAX; i++) {
 	  for (op=obj_index_hash[i];op!=NULL;op=op->next) {
		if (op->item_type!=ITEM_WEAPON) continue;
		ln=strlen(hugebuf_o);
		if (ln>29500) {
			goto duinnn;
			}
		sprintf(hugebuf_o+ln,"%-5d %-25s  %2dd%-2d %-10s %5d %2s\n\r",
			op->vnum,strip_ansi_codes(op->short_descr), op->value[7],
			op->value[8],
			(IS_SET(op->extra_flags,ITEM_CONCUSSION)?"Concussion":
			(IS_SET(op->extra_flags,ITEM_WHIP)?"Whipping":
			(IS_SET(op->extra_flags,ITEM_HEAVY_SLASH)?"Hvy_slash":
			(IS_SET(op->extra_flags,ITEM_LIGHT_SLASH)?"Lgt_slash":
			(IS_SET(op->extra_flags,ITEM_LASER)?"Laser":
			(IS_SET(op->extra_flags,ITEM_PIERCE)?"Piercing":
			(IS_SET(op->extra_flags,ITEM_SLASHING)?"Slashing":
			"unknown"))))))),op->cost,
			(op->affected?"Y":"N"));
		}
	  }
	duinnn:
	page_to_char(hugebuf_o,ch);
	return;
	}

  if (!str_cmp(arg1,"armors")) {
	int ln;
	OBJ_PROTOTYPE *op;
	int i;
	sprintf(hugebuf_o,"%5s %-25s  %-17s %5s %s\n\r",
		"Vnum","Armor Name","L B H A Pd Sr Pr","Cost","MoreAff");
	for (i=0; i<HASH_MAX; i++) {
 	  for (op=obj_index_hash[i];op!=NULL;op=op->next) {
	
		if (op->item_type!=ITEM_ARMOR) continue;
		ln=strlen(hugebuf_o);
		if (ln>29500) {
			goto dunnn;
			}
		sprintf(hugebuf_o+ln,"%-5d %-25s  %-2d%-2d%-2d%-2d%-3d%-3d%-3d %5d %2s\n\r",
			op->vnum,strip_ansi_codes(op->short_descr), 
			op->value[0],
			op->value[1],
			op->value[2],
			op->value[3],
			op->value[4],
			op->value[5],
			op->value[8],
			op->cost,
			(op->affected?"Y":"N"));
		}
	  }
	dunnn:
	page_to_char(hugebuf_o,ch);
	return;
	}
  if (is_number (arg1) && is_number (arg2))
    {
      fRange = TRUE;
      range1 = atoi (arg1);
      range2 = atoi (arg2);
      if (!str_cmp (arg3, "area"))
	fArea = TRUE;
      else
	{
	  if (!str_cmp (arg3, "all"))
	    {
	      fRange = FALSE;
	      fName = FALSE;
	      fArea = FALSE;
	    }
	  else
	    {
	      fName = TRUE;
	      strcpy (name, arg3);
	    }
	}
    }
  else
    {
      if (is_number (arg2) && is_number (arg3))
	{
	  fRange = TRUE;
	  range1 = atoi (arg2);
	  range2 = atoi (arg3);
	}
      if (!str_cmp (arg1, "area"))
	fArea = TRUE;
      else
	{
	  if (!str_cmp (arg1, "all"))
	    {
	      fRange = FALSE;
	      fName = FALSE;
	      fArea = FALSE;
	    }
	  else
	    {
	      fName = TRUE;
	      strcpy (name, arg1);
	    }
	}
    }
  if (range1 > range2 && fRange)
    {
      vnum = range1;
      range1 = range2;
      range2 = vnum;
    }
  if (range2 > top_vnum_obj || !fRange)
    range2 = top_vnum_obj;
  for (vnum = range1; vnum <= range2; vnum++)
    {
      if ((pObjIndex = get_obj_index (vnum)) != NULL
	  && (is_name (name, pObjIndex->name) || !fName)
	  && (pObjIndex->area == pArea || !fArea))
	{
	  found = TRUE;
	  sprintf (oneline, "[%5d %3d] %-32s\e[0m%s %-28s\n\r", vnum,
		   pObjIndex->item_type,
		   pObjIndex->short_descr,
		   get_ansi_spaces (pObjIndex->short_descr),
		   !fArea ? pObjIndex->name : "");
	  sprintf (hugebuf_o + slen, "%s", oneline);
	  slen += strlen (oneline);
	  if (slen > 29500)
	    {
	      hugebuf_o[29500] = '\0';
	      break;
	    }
	}
    }
  if (hugebuf_o[0] != '\0')
    page_to_char (hugebuf_o, ch);
  if (!found)
    send_to_char ("Nothing like that in hell, earth, or heaven.\n\r", ch);
  return;
}

void 
do_rfind (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char arg2[SML_LENGTH];
  char arg3[SML_LENGTH];
  ROOM_DATA *oneroom;
  bool fRange = FALSE;
  bool fArea = FALSE;
  bool fName = FALSE;
  bool fTps = FALSE;
  int slen = 0;
  char oneline[500];
  int range1 = 0;
  int range2 = 0;
  AREA_DATA *pArea;
  char name[SML_LENGTH];
  int vnum;
  int amt = 0;
  bool found = FALSE;
  DEFINE_COMMAND ("rfind", do_rfind, POSITION_DEAD, 100, LOG_NORMAL, "This command is used to find rooms (vnums).")
    pArea = ch->in_room->area;
  if (IS_MOB (ch))
    return;
  hugebuf_o[0] = '\0';
  argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  argy = one_argy (argy, arg3);
  if (arg1[0] == '\0')
    {
      send_to_char ("Syntax: rfind all rfind tps\n\r", ch);
      send_to_char (" rfind [name, area] [num1 num2]\n\r", ch);
      return;
    }
  if (!str_cmp (arg1, "tags"))
    {
      int hash;
      ROOM_DATA *rid;
      for (hash = 0; hash < HASH_MAX; hash++)
	{
	  for (rid = room_hash[hash]; rid != NULL; rid = rid->next)
	    {
	      char *t;
	      for (t = rid->name; *t != '\0'; t++)
		{
		  if (*t == ';')
		    {
		      sprintf (oneline, "\x1B[0m[%5d] %s\n\r", rid->vnum, show_room_name (ch, rid->name));
		      sprintf (hugebuf_o + slen, "%s", oneline);
		      slen += strlen (oneline);
		    }
		}
	    }
	}
      if (hugebuf_o[0] != '\0')
	page_to_char (hugebuf_o, ch);
      return;
    }
  else if (!str_cmp (arg1, "tps"))
    {
      int hash;
      ROOM_DATA *rid;
      if ((amt = atoi (arg2)) < 1)
	amt = 1;
      for (hash = 0; hash < HASH_MAX; hash++)
	{
	  for (rid = room_hash[hash]; rid != NULL; rid = rid->next)
	    {
	      if (rid->tps >= amt)
		{
		  sprintf (oneline, "\x1B[0m[%5d %d] %s\n\r", rid->vnum, rid->tps, show_room_name (ch, rid->name));
		  sprintf (hugebuf_o + slen, "%s", oneline);
		  slen += strlen (oneline);
		  if (slen > 29500)
		    {
		      hugebuf_o[29500] = '\0';
		      goto finito;
		    }
		}
	    }
	}
    finito:
      if (hugebuf_o[0] != '\0')
	page_to_char (hugebuf_o, ch);
      return;
    }
  else if (is_number (arg1) && is_number (arg2))
    {
      fRange = TRUE;
      range1 = atoi (arg1);
      range2 = atoi (arg2);
      if (!str_cmp (arg3, "area"))
	fArea = TRUE;
      else
	{
	  if (!str_cmp (arg3, "all"))
	    {
	      fRange = FALSE;
	      fName = FALSE;
	      fArea = FALSE;
	    }
	  else
	    {
	      fName = TRUE;
	      strcpy (name, arg3);
	    }
	}
    }
  else
    {
      if (is_number (arg2) && is_number (arg3))
	{
	  fRange = TRUE;
	  range1 = atoi (arg2);
	  range2 = atoi (arg3);
	}
      if (!str_cmp (arg1, "area"))
	fArea = TRUE;
      else if (!str_cmp (arg1, "tps"))
	fTps = TRUE;
      else
	{
	  if (!str_cmp (arg1, "all"))
	    {
	      fRange = FALSE;
	      fName = FALSE;
	      fArea = FALSE;
	    }
	  else
	    {
	      fName = TRUE;
	      strcpy (name, arg1);
	    }
	}
    }
  if (range1 > range2 && fRange)
    {
      vnum = range1;
      range1 = range2;
      range2 = vnum;
    }
  if (range2 > top_vnum_room || !fRange)
    range2 = top_vnum_room;
  for (vnum = range1; vnum <= range2; vnum++)
    {
      if ((oneroom = get_room_index (vnum)) != NULL
	  && (!fName || is_name (name, oneroom->name))
	  && (oneroom->area == pArea || !fArea))
	{
	  found = TRUE;
	  sprintf (oneline, "[%5d %s] %s\n\r", vnum, DESCRIPTED (oneroom) ? "D" : "-",
		   oneroom->name);
	  sprintf (hugebuf_o + slen, "%s", oneline);
	  slen += strlen (oneline);
	  if (slen > 29500)
	    {
	      hugebuf_o[29500] = '\0';
	      break;
	    }
	}
    }
  if (!found)
    send_to_char ("Nothing like that in hell, earth, or heaven.\n\r", ch);
  if (hugebuf_o[0] != '\0')
    page_to_char (hugebuf_o, ch);
  return;
}

void 
do_mwhere (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  int slen = 0;
  char oneline[500];
  CHAR_DATA *victim;
  bool found;
  DEFINE_COMMAND ("mwhere", do_mwhere, POSITION_DEAD, 110, LOG_NORMAL, "This command is used to find actual mobs in the world.")

    hugebuf_o[0] = '\0';
  if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Mwhere whom?\n\r", ch);
      return;
    }
  found = FALSE;
  for (victim = char_list; victim != NULL; victim = victim->next)
    {
      if (IS_MOB (victim)
	  && victim->in_room != NULL
	  && is_name (arg, NAME (victim)))
	{
	  found = TRUE;
	  sprintf (oneline, "[%5d] %-28s%s [%5d] %s\n\r",
		   victim->pIndexData->vnum,
		   SD (victim),
		   get_ansi_spaces (SD (victim)),
		   victim->in_room->vnum,
		   victim->in_room->name);
	  sprintf (hugebuf_o + slen, "%s", oneline);
	  slen += strlen (oneline);
	  if (slen > 29500)
	    {
	      hugebuf_o[29500] = '\0';
	      break;
	    }
	}
    }
  if (!found)
    act ("You didn't find any $T.", ch, NULL, arg, TO_CHAR);
  if (hugebuf_o[0] != '\0')
    page_to_char (hugebuf_o, ch);
  return;
}

void 
show_guilds (CHAR_DATA * ch, int bit)
{
  if (bit != 0)
    {
      bool prev;
      prev = FALSE;
      send_to_char ("Guild(s): ", ch);
      if (IS_SET (bit, ACT3_TINKER))
	{
	  send_to_char ("Tinker's Guild", ch);
	  prev = TRUE;
	}
      if (IS_SET (bit, ACT3_WARRIOR))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Warrior's Guild", ch);
	  prev = TRUE;
	}
      if (IS_SET (bit, ACT3_HEALER))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Healer's Guild", ch);
	  prev = TRUE;
	}
      if (IS_SET (bit, ACT3_WIZARD))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Wizard's Guild", ch);
	  prev = TRUE;
	}
      if (IS_SET (bit, ACT3_THIEFG))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Thief's Guild", ch);
	  prev = TRUE;
	}
      if (IS_SET (bit, ACT3_RANGER))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Ranger's Guild", ch);
	  prev = TRUE;
	}
      if (IS_SET (bit, ACT3_ASSASSIN))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Assassin's Guild", ch);
	  prev = TRUE;
	}
      send_to_char (".\n\r", ch);
    }
  return;
}

void 
do_pstat (CHAR_DATA * ch, char *argy)
{
  char buf[STD_LENGTH];
  char arg[SML_LENGTH];
  AFFECT_DATA *paf;
  CHAR_DATA *victim;
  SPELL_DATA *spell;
  DEFINE_COMMAND ("pstat", do_pstat, POSITION_DEAD, 110, LOG_NORMAL, "This command can be used to get stats on a player specified.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Pstat whom?\n\r", ch);
      return;
    }
  if ((victim = get_char_world (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (IS_MOB (victim))
    {
      send_to_char ("Not on mobs.\n\r", ch);
      return;
    }
  if (LEVEL (ch) < 110 && LEVEL (victim) < 101)
    {
      send_to_char ("You are not allowed to look at other players' stats!\n\r", ch);
      return;
    }
  sprintf (buf, "Name: \x1B[37;1m%s  \x1B[37;0mRace: \x1B[37;1m%s (%d)\x1B[37;0m Email: \x1B[37;1m%s\x1B[37;0m.\n\r",
	   NAME (victim), race_info[victim->pcdata->race].name,
	   victim->pcdata->race, victim->pcdata->email);
  send_to_char (buf, ch);
  sprintf (buf, "Remorts: %d  Natural Armor: %d  Sex: %s  Deaths: %d\n\r",
	   victim->pcdata->remort_times, victim->pcdata->nat_armor,
	   SEX (victim) == SEX_MALE ? "male" : SEX (victim) == SEX_FEMALE ? "female" : "neutral",
	   victim->pcdata->deaths);
  send_to_char (buf, ch);
#ifdef NEW_WORLD
  print_profs (ch, victim->pcdata->profession_flag);
#endif
  if (clan_number (victim) > 0)
    {
      sprintf (buf, "Clan: %s.\n\r", get_clan_index (clan_number (victim))->name);
      send_to_char (buf, ch);
    }
  sprintf (buf, "In Room: #%d  Warpoints: %d  Travel Points: %d\n\r",
	   victim->in_room == NULL ? 0 : victim->in_room->vnum,
	   victim->pcdata->warpoints, victim->pcdata->tps);
  send_to_char (buf, ch);
  show_implants (victim, ch);
  if (victim->pcdata->nat_abilities != 0)
    {
      bool prev;
      prev = FALSE;
      send_to_char ("Natural Abilities: ", ch);
      if (IS_SET (victim->pcdata->nat_abilities, AFF_INFRARED))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Infravision", ch);
	  prev = TRUE;
	}
      if (IS_SET (victim->pcdata->nat_abilities, AFF_DETECT_HIDDEN))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Detect Hidden", ch);
	  prev = TRUE;
	}
      if (IS_SET (victim->pcdata->nat_abilities, AFF_DETECT_INVIS))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Detect Invis", ch);
	  prev = TRUE;
	}
      if (IS_SET (victim->pcdata->nat_abilities, AFF_FLYING))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Fly", ch);
	  prev = TRUE;
	}
      if (IS_SET (victim->pcdata->nat_abilities, AFF_BREATH_WATER))
	{
	  if (prev)
	    send_to_char (", ", ch);
	  send_to_char ("Breath Water", ch);
	  prev = TRUE;
	}
      send_to_char (".\n\r", ch);
    }
  show_guilds (ch, victim->pcdata->guilds);
  sprintf (buf, "Str: %d  Int: %d  Wis: %d  Dex: %d  Con: %d  Bank Account: %ld.\n\r",
	   get_curr_str (victim), get_curr_int (victim), get_curr_wis (victim), get_curr_dex (victim), get_curr_con (victim), victim->pcdata->bank);
  send_to_char (buf, ch);
  sprintf (buf, "Hp: %d/%d  Move: %d/%d  Pracs: %d  Kills: %d  Killpoints: %d\n\r",
	   victim->hit, victim->max_hit,
	   victim->move, victim->max_move,
	   victim->pcdata->practice, victim->pcdata->totalkills,
	   victim->pcdata->killpoints);
  send_to_char (buf, ch);
  sprintf (buf, "Level: %d  Alignment: %d  AC: %d  Exp: %ld  Security: %d\n\r",
	   LEVEL (victim), victim->pcdata->alignment, GET_AC (victim), victim->exp, victim->pcdata->security);
  send_to_char (buf, ch);
  sprintf (buf, "Hitroll: %d  Damroll: %d  Position: %d  Learns: %d\n\r",
	   GET_HITROLL (victim), GET_DAMROLL (victim),
	   victim->position, victim->pcdata->learn);
  send_to_char (buf, ch);
  if (victim->position == POSITION_FIGHTING)
    {
      sprintf (buf, "Fighting: %s.\n\r",
	       FIGHTING (victim) ? NAME (victim->fgt->fighting) : "(none)");
      send_to_char (buf, ch);
    }
  sprintf (buf, "Thirst: %d/50  Full: %d/50  Drunk: %d/0  Saving throw: %d\n\r",
	   victim->pcdata->condition[COND_THIRST],
	   victim->pcdata->condition[COND_FULL],
	   victim->pcdata->condition[COND_DRUNK],
	   victim->pcdata->saving_throw);
  send_to_char (buf, ch);
  sprintf (buf, "Items Carried: %d  Weight Carried: %d\n\r",
	   victim->pcdata->carry_number, victim->pcdata->carry_weight);
  send_to_char (buf, ch);
  sprintf (buf, "Age: %d  Seconds Played: %d  Act: %s.\n\r",
	   get_age (victim), (int) victim->pcdata->played,
	   plr_bit_name (victim->act));
  send_to_char (buf, ch);
  sprintf (buf, "Group Info... Master: %s  Leader: %s\n\rAffected by: %s (and) %s.\n\r",
	   MASTER (victim) ? NAME (victim->fgt->master) : "(none)",
	   LEADER (victim) ? NAME (victim->fgt->leader) : "(none)",
	   affect_bit_name (victim->affected_by),
	   affect_bit_name_two (victim->more_affected_by));
  send_to_char (buf, ch);
  sprintf (buf, "Short description: %s.\n\rLong description: %s\n\r",
	   SD (victim),
	   LD (victim));
  send_to_char (buf, ch);
  for (paf = victim->affected; paf != NULL; paf = paf->next)
    {
      spell = skill_lookup (NULL, (int) paf->type);
      if (spell == NULL)
	continue;
      sprintf (buf,
      "Spell: '%s' modifies %s by %d for %d hours with bits %s and %s.\n\r",
	       spell->spell_funky_name,
	       affect_loc_name (paf->location),
	       paf->modifier,
	       paf->duration,
	       affect_bit_name (paf->bitvector),
	       affect_bit_name_two (paf->bitvector2));
      send_to_char (buf, ch);
    }
  return;
}

void 
do_reboo (CHAR_DATA * ch, char *argy)
{
  DEFINE_COMMAND ("reboo", do_reboo, POSITION_DEAD, 110, LOG_NORMAL, "Protection against accidentally matching 'reboot'.")

    send_to_char ("If you want to REBOOT, spell it out.\n\r", ch);
  return;
}

void 
do_reboot (CHAR_DATA * ch, char *argy)
{
  extern bool aturion_down;
  CHAR_DATA *bah;
  FILE *fpqr;
  DEFINE_COMMAND ("reboot", do_reboot, POSITION_DEAD, 110, LOG_NORMAL, "Always use REBOOT <ticks until reboot>.  Reboot 0 aborts a reboot countdown.")
    if (IS_MOB (ch))
    return;
  if (!IS_REAL_GOD (ch))
    return;

  if (is_number (argy))
    {
      send_to_char ("Ticks to reboot set... set to 0 to abort reboot.\n\r", ch);
      ticks_to_reboot = atoi (argy);
      return;
    }
  for (bah = char_list; bah != NULL; bah = bah->next)
    {
      if (IS_PLAYER (bah))
	do_save (bah, "xx2xx11");
    }
  save_tps ();
  fpqr = fopen ("reason.fi", "w+");
  fprintf (fpqr, "Mud-Reboot \n\rEnd~\n\r");
  fclose (fpqr);
  aturion_down = TRUE;
  return;
}

void 
do_snoop (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  DESCRIPTOR_DATA *d;
  CHAR_DATA *victim;
  DEFINE_COMMAND ("snoop", do_snoop, POSITION_DEAD, 110, LOG_NORMAL, "This command allows you to 'snoop' a player.")

    one_argy (argy, arg);
  if (IS_MOB (ch))
    return;

  if (arg[0] == '\0')
    {
      send_to_char ("Snoop whom?\n\r", ch);
      return;
    }

  if ((victim = get_char_world (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (str_cmp (NAME (ch), "Orin") && !str_cmp (NAME (victim), "Orin"))
    {
      send_to_char ("Snoop whom?\n\r", ch);
      return;
    }
  if (IS_MOB (victim) || victim->desc == NULL)
    {
      send_to_char ("No descriptor to snoop.\n\r", ch);
      return;
    }
  if (victim == ch)
    {
      send_to_char ("Cancelling all snoops.\n\r", ch);
      for (d = descriptor_list; d != NULL; d = d->next)
	{
	  if (d->snoop_by == ch->desc)
	    d->snoop_by = NULL;
	}
      return;
    }
  if (victim->desc->snoop_by != NULL)
    {
      send_to_char ("Busy already.\n\r", ch);
      return;
    }
  if (LEVEL (victim) > LEVEL (ch))
    {
      send_to_char ("You failed.\n\r", ch);
      return;
    }
  if (ch->desc != NULL)
    {
      for (d = ch->desc->snoop_by; d != NULL; d = d->snoop_by)
	{
	  if (d->character == victim || d->original == victim)
	    {
	      send_to_char ("No snoop loops.\n\r", ch);
	      return;
	    }
	}
    }
  victim->desc->snoop_by = ch->desc;
  send_to_char ("Ok.\n\r", ch);
  return;
}

void 
do_switch (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  CHAR_DATA *victim;
  DEFINE_COMMAND ("switch", do_switch, POSITION_DEAD, 110, LOG_ALWAYS, "This command allows you to switch into a mob.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Switch into whom?\n\r", ch);
      return;
    }
  if (IS_MOB (ch) || ch->desc == NULL)
    return;
  if (ch->desc->original != NULL)
    return;

  if ((victim = get_char_world (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (victim == ch)
    {
      send_to_char ("Ok.\n\r", ch);
      return;
    }
  ch->desc->character = victim;
  ch->desc->original = ch;
  victim->desc = ch->desc;
  ch->desc = NULL;
  send_to_char ("Ok.\n\r", victim);
  return;
}
/* Make sure switch is okay.. sorta iffy :) */

void 
do_return (CHAR_DATA * ch, char *argy)
{
  DEFINE_COMMAND ("return", do_return, POSITION_DEAD, 0, LOG_NORMAL, "This command allows you to return from a switch command.")

    if (IS_PLAYER (ch))
    return;
  if (ch->desc == NULL)
    return;
  if (ch->desc->original == NULL)
    {
      send_to_char ("You aren't switched.\n\r", ch);
      return;
    }
  send_to_char ("You return to your original body.\n\r", ch);
  ch->desc->character = ch->desc->original;
  ch->desc->original = NULL;
  ch->desc->character->desc = ch->desc;
  ch->desc = NULL;
  return;
}

void 
do_mload (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  MOB_PROTOTYPE *pMobIndex;
  CHAR_DATA *victim;
  char *t;
  DEFINE_COMMAND ("mload", do_mload, POSITION_DEAD, 100, LOG_ALWAYS, "Syntax: Mload <vnum>, where <vnum> is the mob template vnum of the mob you wish to create.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0' || !is_number (arg))
    {
      send_to_char ("Syntax: mload <vnum>.\n\r", ch);
      return;
    }
  if ((pMobIndex = get_mob_index (atoi (arg))) == NULL)
    {
      send_to_char ("No mob has that vnum.\n\r", ch);
      return;
    }
  for (t = pMobIndex->name; *t != '\0'; t++)
    if (*t == '%')
      {
	send_to_char ("You may not mload this mob... it is meant for internal game use only.\n\r", ch);
	return;
      }
  for (t = pMobIndex->short_descr; *t != '\0'; t++)
    if (*t == '%')
      {
	send_to_char ("You may not mload this mob... it is meant for internal game use only.\n\r", ch);
	return;
      }
  victim = create_mobile (pMobIndex);
  char_to_room (victim, ch->in_room);
  act ("$n has created $N!", ch, NULL, victim, TO_ROOM);
  act ("You create $N!", ch, NULL, victim, TO_CHAR);
  return;
}

void 
do_oload (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  OBJ_PROTOTYPE *pObjIndex;
  SINGLE_OBJECT *obj;
  char *t;
  DEFINE_COMMAND ("oload", do_oload, POSITION_DEAD, 100, LOG_ALWAYS, "Creates an object from the specified object template (vnum).")

    if (IS_MOB (ch))
    return;
  argy = one_argy (argy, arg1);
  if (arg1[0] == '\0' || !is_number (arg1))
    {
      send_to_char ("Syntax: oload <vnum>.\n\r", ch);
      return;
    }
  if ((pObjIndex = get_obj_index (atoi (arg1))) == NULL)
    {
      send_to_char ("No object has that vnum.\n\r", ch);
      return;
    }

  for (t = pObjIndex->name; *t != '\0'; t++)
    if (*t == '%')
      {
	send_to_char ("You may not oload this item... it is meant for internal game use only.\n\r", ch);
	return;
      }
  for (t = pObjIndex->short_descr; *t != '\0'; t++)
    if (*t == '%')
      {
	send_to_char ("You may not oload this item... it is meant for internal game use only.\n\r", ch);
	return;
      }
  obj = create_object (pObjIndex, 1);
  if (CAN_WEAR (obj, ITEM_TAKE))
    {
      obj_to (obj, ch);
    }
  else
    {
      obj_to (obj, ch->in_room);
    }
  act ("$n has created $p!", ch, obj, NULL, TO_ROOM);
  act ("You create $p!", ch, obj, NULL, TO_CHAR);
  return;
}

void 
raw_purge (ROOM_DATA * rid)
{
  CHAR_DATA *victim;
  CHAR_DATA *vnext;
  SINGLE_OBJECT *obj;
  SINGLE_OBJECT *obj_next;
  if (!rid->more)
    return;
  for (victim = rid->more->people; victim != NULL; victim = vnext)
    {
      vnext = victim->next_in_room;
      if (IS_MOB (victim) && victim->desc == NULL)
	extract_char (victim, TRUE);
      if (!rid->more)
	return;
    }
  if (!rid->more)
    return;
  rid->more->copper = 0;
  rid->more->gold = 0;
  for (obj = rid->more->contents; obj != NULL; obj = obj_next)
    {
      obj_next = obj->next_content;
      free_it (obj);
      if (!rid->more)
	return;
    }
  return;
}

void 
do_purge (CHAR_DATA * ch, char *argy)
{
  CHAR_DATA *v;
  DEFINE_COMMAND ("purge", do_purge, POSITION_DEAD, 100, LOG_NORMAL, "This command purges the room of all mobs and objects.")
    if (!ch->in_room->more)
    return;
  if (IS_MOB (ch))
    return;
  raw_purge (ch->in_room);
  for (v = ch->in_room->more->people; v != NULL; v = v->next_in_room)
    {
      if (LEVEL (v) > 100)
	act ("$n cleanses the room with righteous fire!", ch, NULL, v, TO_VICT);
    }
  send_to_char ("You cleanse the room with righteous fire!\n\r", ch);
  return;
}

void 
do_advance (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char arg2[SML_LENGTH];
  CHAR_DATA *victim;
  int level;
  int iLevel;
  DEFINE_COMMAND ("advance", do_advance, POSITION_DEAD, 110, LOG_ALWAYS, "This command advances a char's level.  Their experience is set to 0.  Never use this on players.")

    if (IS_MOB (ch))
    return;
  if (!IS_REAL_GOD (ch))
    return;

  argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  if (arg1[0] == '\0' || arg2[0] == '\0' || !is_number (arg2))
    {
      send_to_char ("Syntax: advance <char> <level>.\n\r", ch);
      return;
    }
  if ((victim = get_char_room (ch, arg1)) == NULL)
    {
      send_to_char ("That player is not here.\n\r", ch);
      return;
    }

  if ((level = atoi (arg2)) < 1 || level > TOP_LEVEL)
    {
      char buf[STD_LENGTH];
      sprintf (buf, "Level must be 1 to %d.\n\r", TOP_LEVEL);
      send_to_char (buf, ch);
      return;
    }

  if (level > LEVEL (ch) || IS_MOB (victim))
    return;

  if (level < LEVEL (victim))
    {
      int sn;
      send_to_char ("Lowering a player's level!\n\r", ch);
      victim->pcdata->level = 1;
      victim->exp = FIND_EXP (level - 1, 0);
      victim->max_hit = 25;
      victim->max_move = 70;
      for (sn = 0; sn < SKILL_COUNT; sn++)
	victim->pcdata->learned[sn] = -100;
      victim->pcdata->practice = 0;
      victim->hit = victim->max_hit;
      upd_hps (victim);
      victim->move = victim->max_move;
      upd_mps (victim);
      advance_level (victim);
    }
  else
    {
      send_to_char ("Raising a player's level!\n\r", ch);
    }
  for (iLevel = LEVEL (victim); iLevel < level; iLevel++)
    {
      send_to_char ("You raise a level! ", victim);
      victim->pcdata->level += 1;
      advance_level (victim);
    }
  victim->exp = FIND_EXP (LEVEL (victim) - 1, 0);
  return;
}

void 
do_restore (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  CHAR_DATA *victim;
  DEFINE_COMMAND ("restore", do_restore, POSITION_DEAD, 110, LOG_ALWAYS, "This restores hps and mps to a specified character or mob.")

/*if (IS_MOB(ch) && ch!=char_list) return; */
    one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Restore whom?\n\r", ch);
      return;
    }
  if ((victim = get_char_world_2 (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }

  MAXHIT(victim);
  upd_hps (victim);
  MAXMOVE(victim);
  upd_mps (victim);
  update_pos (victim);
  send_to_char ("Ok.\n\r", ch);
  return;
}

void 
do_freeze (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  CHAR_DATA *victim;
  DEFINE_COMMAND ("freeze", do_freeze, POSITION_DEAD, 110, LOG_ALWAYS, "This command freezes the specified player; they can't do *anything*.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Freeze whom?\n\r", ch);
      return;
    }
  if ((victim = get_char_world (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (IS_MOB (victim))
    return;

  if (LEVEL (victim) >= LEVEL (ch))
    return;

  if (IS_SET (victim->act, PLR_FREEZE))
    {
      REMOVE_BIT (victim->act, PLR_FREEZE);
      send_to_char ("You have been defrosted.\n\r", victim);
      send_to_char ("FREEZE removed.\n\r", ch);
    }
  else
    {
      SET_BIT (victim->act, PLR_FREEZE);
      send_to_char ("You have been frozen!\n\r", victim);
      send_to_char ("FREEZE set.\n\r", ch);
    }
  save_char_obj (victim);
  return;
}

void 
do_log (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  CHAR_DATA *victim;
  DEFINE_COMMAND ("log", do_log, POSITION_DEAD, 110, LOG_ALWAYS, "This command can be used to log a player or multiple players.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Log whom?\n\r", ch);
      return;
    }
  if (!str_cmp (arg, "all"))
    {
      if (fLogAll)
	{
	  fLogAll = FALSE;
	  send_to_char ("Log ALL off.\n\r", ch);
	}
      else
	{
	  fLogAll = TRUE;
	  send_to_char ("Log ALL on.\n\r", ch);
	}
      return;
    }
  if ((victim = get_char_world (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (IS_MOB (victim))
    return;

  if (IS_SET (victim->act, PLR_LOG))
    {
      REMOVE_BIT (victim->act, PLR_LOG);
      send_to_char ("LOG removed.\n\r", ch);
    }
  else
    {
      SET_BIT (victim->act, PLR_LOG);
      send_to_char ("LOG set.\n\r", ch);
    }
  return;
}

void 
do_silence (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  CHAR_DATA *victim;
  DEFINE_COMMAND ("silence", do_silence, POSITION_DEAD, 110, LOG_ALWAYS, "This command removes all channel privaledges but 'say' from a specified player.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Silence whom?", ch);
      return;
    }
  if ((victim = get_char_world (ch, arg)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (IS_MOB (victim))
    return;

  if (LEVEL (victim) >= LEVEL (ch))
    {
      send_to_char ("You failed.\n\r", ch);
      return;
    }
  if (IS_SET (victim->pcdata->act2, PLR_SILENCE))
    {
      REMOVE_BIT (victim->pcdata->act2, PLR_SILENCE);
      send_to_char ("SILENCE removed.\n\r", ch);
    }
  else
    {
      SET_BIT (victim->pcdata->act2, PLR_SILENCE);
      send_to_char ("SILENCE set.\n\r", ch);
    }
  return;
}

void 
do_peace (CHAR_DATA * ch, char *argy)
{
  CHAR_DATA *rch;
  DEFINE_COMMAND ("peace", do_peace, POSITION_DEAD, 100, LOG_NORMAL, "This command stops all the fighting that is going on in the current room.")
    check_room_more (ch->in_room);
  for (rch = ch->in_room->more->people; rch != NULL; rch = rch->next_in_room)
    {
      if (FIGHTING (rch) != NULL)
	{
	  rch->fgt->fighting = NULL;
	  NEW_POSITION(rch, POSITION_STANDING);
	  if (rch->fgt->hunting != NULL)
	    {
	      free_string (rch->fgt->hunting);
	      rch->fgt->hunting = NULL;
	    }
	  update_pos (rch);
	}
    }
  return;
}

BAN_DATA *ban_free;
BAN_DATA *ban_list;

void 
do_ban (CHAR_DATA * ch, char *argy)
{
  char buf[STD_LENGTH];
  char arg[SML_LENGTH];
  BAN_DATA *pban;
  DEFINE_COMMAND ("ban", do_ban, POSITION_DEAD, 110, LOG_ALWAYS, "This command shows and/or adds ban info.  See nban for marking newbie problem sites.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      strcpy (buf, "Banned sites:\n\r");
      for (pban = ban_list; pban != NULL; pban = pban->next)
	{
	  if (pban->newbie)
	    strcat (buf, "(\x1B[37;1mN\x1B[37;0m) ");
	  else
	    strcat (buf, " ");
	  strcat (buf, pban->name);
	  strcat (buf, "\n\r");
	}
      send_to_char (buf, ch);
      return;
    }
  for (pban = ban_list; pban != NULL; pban = pban->next)
    {
      if (!str_cmp (arg, pban->name))
	{
	  send_to_char ("That site is already banned!\n\r", ch);
	  return;
	}
    }
  if (ban_free == NULL)
    {
      pban = mem_alloc (sizeof (*pban));
    }
  else
    {
      pban = ban_free;
      ban_free = ban_free->next;
    }
  pban->name = str_dup (arg);
  pban->next = ban_list;
  pban->newbie = FALSE;
  ban_list = pban;
  send_to_char ("Ok.\n\r", ch);
  save_banlist ();
  return;
}

void 
bansite (char *argy)
{
  char arg[SML_LENGTH];
  BAN_DATA *pban;
  one_argy (argy, arg);
  for (pban = ban_list; pban != NULL; pban = pban->next)
    {
      if (!str_cmp (arg, pban->name))
	{
	  return;
	}
    }
  if (ban_free == NULL)
    {
      pban = mem_alloc (sizeof (*pban));
    }
  else
    {
      pban = ban_free;
      ban_free = ban_free->next;
    }
  pban->name = str_dup (arg);
  pban->next = ban_list;
  pban->newbie = FALSE;
  ban_list = pban;
  return;
}

void 
do_nban (CHAR_DATA * ch, char *argy)
{
  char buf[STD_LENGTH];
  char arg[SML_LENGTH];
  BAN_DATA *pban;
  DEFINE_COMMAND ("nban", do_nban, POSITION_DEAD, 110, LOG_ALWAYS, "This command marks a site as a newbie problem site.  All new chars from this site must do registration.")
    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      strcpy (buf, "Banned sites:\n\r");
      for (pban = ban_list; pban != NULL; pban = pban->next)
	{
	  if (pban->newbie)
	    strcat (buf, "(\x1B[37;1mN\x1B[37;0m) ");
	  else
	    strcat (buf, " ");
	  strcat (buf, pban->name);
	  strcat (buf, "\n\r");
	}
      send_to_char (buf, ch);
      return;
    }
  for (pban = ban_list; pban != NULL; pban = pban->next)
    {
      if (!str_cmp (arg, pban->name))
	{
	  send_to_char ("That site is already banned!\n\r", ch);
	  return;
	}
    }
  if (ban_free == NULL)
    {
      pban = mem_alloc (sizeof (*pban));
    }
  else
    {
      pban = ban_free;
      ban_free = ban_free->next;
    }
  pban->name = str_dup (arg);
  pban->next = ban_list;
  pban->newbie = TRUE;
  ban_list = pban;
  send_to_char ("Ok.\n\r", ch);
  save_banlist ();
  return;
}

void 
nbansite (char *argy)
{
  char arg[SML_LENGTH];
  BAN_DATA *pban;
  one_argy (argy, arg);
  for (pban = ban_list; pban != NULL; pban = pban->next)
    {
      if (!str_cmp (arg, pban->name))
	{
	  return;
	}
    }
  if (ban_free == NULL)
    {
      pban = mem_alloc (sizeof (*pban));
    }
  else
    {
      pban = ban_free;
      ban_free = ban_free->next;
    }
  pban->name = str_dup (arg);
  pban->next = ban_list;
  pban->newbie = TRUE;
  ban_list = pban;
  return;
}

void 
do_allow (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  BAN_DATA *prev;
  BAN_DATA *curr;
  DEFINE_COMMAND ("allow", do_allow, POSITION_DEAD, 110, LOG_ALWAYS, "This command removes a ban site from the list.")

    if (IS_MOB (ch))
    return;
  one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Remove which site from the ban list?\n\r", ch);
      return;
    }
  prev = NULL;
  for (curr = ban_list; curr != NULL; prev = curr, curr = curr->next)
    {
      if (!str_cmp (arg, curr->name))
	{
	  if (prev == NULL)
	    ban_list = ban_list->next;
	  else
	    prev->next = curr->next;
	  free_string (curr->name);
	  curr->next = ban_free;
	  ban_free = curr;
	  send_to_char ("Ok.\n\r", ch);
	  return;
	}
    }
  send_to_char ("Site is not banned.\n\r", ch);
  return;
}

void 
do_wizlock (CHAR_DATA * ch, char *argy)
{
  extern bool wizlock;
  DEFINE_COMMAND ("wizlock", do_wizlock, POSITION_DEAD, 110, LOG_ALWAYS, "This makes it so only gods can log in.")

    wizlock = !wizlock;
  if (wizlock)
    send_to_char ("Game wizlocked.\n\r", ch);
  else
    send_to_char ("Game un-wizlocked.\n\r", ch);
  return;
}

void 
do_slookup (CHAR_DATA * ch, char *argy)
{
  char buf[STD_LENGTH];
  char arg[SML_LENGTH];
  int sn;
  SPELL_DATA *spell;
  DEFINE_COMMAND ("slookup", do_slookup, POSITION_DEAD, 100, LOG_NORMAL, "Looks up a skill or spell number, or slookup 'all', or slookup find <snum>.")

    if (IS_MOB (ch))
    return;
  argy = one_argy (argy, arg);
  if (arg[0] == '\0')
    {
      send_to_char ("Slookup what?\n\r", ch);
      return;
    }
  if (is_number (arg))
    {
      sn = atoi (arg);
      if ((spell = skill_lookup (NULL, sn)) == NULL)
	{
	  send_to_char ("Invalid Spell/Skill Number.\n\r", ch);
	  return;
	}
      sprintf (buf, "Spell/skill number: %4d  Skill/spell: '%s' Aka: '%s'\n\r",
	       sn, /*spell->slot,*/ spell->spell_name, spell->spell_funky_name);
      send_to_char (buf, ch);
      return;
    }
  if (!str_cmp (arg, "all"))
    {
      for (sn = 0; sn < SKILL_COUNT; sn++)
	{
	  if ((spell = skill_lookup (NULL, sn)) == NULL)
	    continue;
          sprintf (buf, "Spell/skill number: %4d  Skill/spell: '%s' Aka: '%s'\n\r",
	       sn, /*spell->slot,*/ spell->spell_name, spell->spell_funky_name);
	  send_to_char (buf, ch);
	}
    }
  else
    {
      if ((spell = skill_lookup (arg, -1)) == NULL)
	{
	  int cntr, subctr;
	  char buffy[500];
	  SPELL_DATA *spl;
	  MOB_PROTOTYPE *mid;
	  if (!str_cmp (arg, "find") && is_number (argy))
	    {
	      if (!IS_REAL_GOD (ch))
		return;
	      sn = atoi (argy);
	      if ((spl = skill_lookup (NULL, sn)) == NULL)
		{
		  send_to_char ("Invalid!\n\r", ch);
		  return;
		}
	      sprintf (buffy, "Mobs that teach sn %d (\x1B[1m%s\x1B[0m)...\n\r", sn, spl->spell_name);
	      send_to_char (buffy, ch);
	      for (cntr = 1; cntr < top_vnum_mob; cntr++)
		{
		  if ((mid = get_mob_index (cntr)) == NULL || !mid->opt)
		    continue;
		  for (subctr = 0; subctr < 30; subctr++)
		    {
		      if (mid->opt->skltaught[subctr] == sn)
			{
			  sprintf (buffy, "\x1B[37;1m%-20s\x1B[37;0m vnum \x1B[32;1m%d\x1B[37;0m, teaches this skill/spell.\n\r", mid->short_descr, mid->vnum);
			  send_to_char (buffy, ch);
			}
		    }
		}
	    }
	  else
	    send_to_char ("No such skill or spell.\n\r", ch);
	  return;
	}
      sprintf (buf, "Spell/skill number: %4d  Skill/spell: '%s' Aka: '%s'\n\r",
       spell->gsn, spell->spell_name, spell->spell_funky_name);
      send_to_char (buf, ch);
    }
  return;
}

void 
do_award_skill (CHAR_DATA * ch, char *argy)
{
  char arg1[500];
  char arg2[500];
  char arg3[500];
  SPELL_DATA *spl;
  DESCRIPTOR_DATA *dd;
  int amount;
  DEFINE_COMMAND ("awardskill", do_award_skill, POSITION_DEAD, 110, LOG_ALWAYS, "Awards a skill to a player.  Mostly used for quests.")

    argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  argy = one_argy (argy, arg3);
  if ((amount = atoi (arg3)) < 1)
    return;
  if ((spl = skill_lookup (arg2, -1)) == NULL)
    return;
  for (dd = descriptor_list; dd != NULL; dd = dd->next)
    {
      if (!dd->character)
	continue;
      if (!str_cmp (NAME (dd->character), arg1))
	goto found;
    }
  return;
found:
  if (dd->character->pcdata->learned[spl->gsn] < 0)
    dd->character->pcdata->learned[spl->gsn] = 1;
  if (dd->character->pcdata->learned[spl->gsn] > 80)
    amount /= 5;
  else if (dd->character->pcdata->learned[spl->gsn] > 65)
    amount /= 4;
  else if (dd->character->pcdata->learned[spl->gsn] > 50)
    amount /= 3;
  else if (dd->character->pcdata->learned[spl->gsn] > 35)
    amount /= 2;
  dd->character->pcdata->learned[spl->gsn] = UMIN (100, (dd->character->pcdata->learned[spl->gsn] + amount));
  return;
}

void 
do_sset (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char arg2[SML_LENGTH];
  char arg3[SML_LENGTH];
  CHAR_DATA *victim;
  int value;
  int sn;
  bool fAll;
  SPELL_DATA *spell;
  DEFINE_COMMAND ("sset", do_sset, POSITION_DEAD, 110, LOG_ALWAYS, "This sets a person's skills/spells (all or specific skill, and amount).")

    if (IS_PLAYER (ch) && LEVEL (ch) < 110)
    return;
  argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  argy = one_argy (argy, arg3);
  if (arg1[0] == '\0' || arg2[0] == '\0' || arg3[0] == '\0')
    {
      send_to_char ("Syntax: sset <victim> <skill> <value>\n\r", ch);
      send_to_char ("or: sset <victim> all <value>\n\r", ch);
      return;
    }
  if ((victim = get_char_world (ch, arg1)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (IS_MOB (victim))
    {
      send_to_char ("Not on mobs.\n\r", ch);
      return;
    }
  if (LEVEL (victim) < 101 && LEVEL (ch) < 110)
    {
      send_to_char ("You may not set players' skills!\n\r", ch);
      send_to_char ("Cheat attempt logged!\n\r", ch);
      return;
    }
  fAll = !str_cmp (arg2, "all");
  spell = skill_lookup (arg2, -1);
  sn = 0;
  if (!fAll && spell == NULL)
    {
      send_to_char ("No such skill or spell.\n\r", ch);
      return;
    }
  if (!is_number (arg3))
    {
      send_to_char ("Value must be numeric.\n\r", ch);
      return;
    }
  value = atoi (arg3);
  if (value < 0 || value > 100)
    {
      send_to_char ("Value range is 0 (unlearned) to 100.\n\r", ch);
      return;
    }
  if (fAll)
    {
      for (sn = 0; sn < SKILL_COUNT; sn++)
	{
	  if (skill_lookup (NULL, sn) != NULL)
	    victim->pcdata->learned[sn] = (value == 0 ? -100 : value);
	}
      return;
    }
  else
    {
      victim->pcdata->learned[spell->gsn] = (value == 0 ? -100 : value);
    }
  return;
}

void 
do_mset (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char arg2[SML_LENGTH];
  char arg3[SML_LENGTH];
  CHAR_DATA *victim;
  int value;
  DEFINE_COMMAND ("mset", do_mset, POSITION_DEAD, 110, LOG_NORMAL, "Sets a specific mob's stats and stuff...")

    if (IS_MOB (ch))
    return;
  if (!IS_REAL_GOD (ch))
    {
      send_to_char ("Command has been removed.\n\r", ch);
      return;
    }
  smash_tilde (argy);
  argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  strcpy (arg3, argy);
  if (arg1[0] == '\0' || arg2[0] == '\0')
    {
      send_to_char ("Syntax: mset <victim> <field> <value>\n\r", ch);
      send_to_char ("or: mset <victim> <string> <value>\n\r", ch);
      send_to_char ("\n\r", ch);
      send_to_char ("Field being one of:\n\r", ch);
      send_to_char (" sex level\n\r", ch);
      send_to_char (" hp move timer\n\r", ch);
      send_to_char (" align master leader practice\n\r", ch);
      send_to_char (" act affect hunting\n\r", ch);
      send_to_char ("\n\r", ch);
      send_to_char ("String being one of:\n\r", ch);
      send_to_char (" name short long description spec\n\r", ch);
      return;
    }
  if ((victim = get_char_world (ch, arg1)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (IS_PLAYER (victim))
    {
      send_to_char ("Not on players.. only mobs.\n\r", ch);
      return;
    }
  if (LEVEL (ch) < 110 && victim->in_room && victim->in_room->area->open != 0)
    {
      send_to_char ("You cannot set mobs that are in open areas!\n\r", ch);
      send_to_char ("Possible cheat attempt logged.\n\r", ch);
      return;
    }
  value = is_number (arg3) ? atoi (arg3) : -1;
  if (!str_cmp (arg2, "hp") && arg3[0] != '\0')
    {
      if (value < -10 || value > 30000)
	{
	  send_to_char ("Hp range is -10 to 30,000 hit points.\n\r", ch);
	  return;
	}
      victim->max_hit = value;
      return;
    }
  if (!str_cmp (arg2, "move") && arg3[0] != '\0')
    {
      if (value < 0 || value > 30000)
	{
	  send_to_char ("Move range is 0 to 30,000 move points.\n\r", ch);
	  return;
	}
      victim->max_move = value;
      upd_mps (ch);
      return;
    }
  if (!str_cmp (arg2, "timer") && arg3[0] != '\0')
    {
      if (value < 0 || value > 30000)
	{
	  send_to_char ("Timer range is 0 to 30,000.\n\r", ch);
	  return;
	}
      victim->timer = value;
      return;
    }
  if (!str_cmp (arg2, "practice") && arg3[0] != '\0')
    {
      if (value < 0 || value > 100)
	{
	  send_to_char ("Practice range is 0 to 100 sessions.\n\r", ch);
	  return;
	}
      victim->pcdata->practice = value;
      return;
    }
  if (!str_cmp (arg2, "hunting") && arg3[0] != '\0' && strlen (arg3) < 16)
    {
      check_fgt (victim);
      if (victim->fgt->hunting != NULL)
	{
	  free_string (victim->fgt->hunting);
	  victim->fgt->hunting = NULL;
	}
      victim->fgt->hunting = str_dup (arg3);
      send_to_char ("Done.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "master") && arg3[0] != '\0')
    {
      check_fgt (victim);
      if (!str_cmp (arg3, "none"))
	{
	  victim->fgt->master = NULL;
	  return;
	}
      if ((get_char_world (ch, arg3)) == NULL)
	{
	  send_to_char ("They aren't here.\n\r", ch);
	  return;
	}
      victim->fgt->master = get_char_world (ch, arg3);
      return;
    }
  if (!str_cmp (arg2, "leader") && arg3[0] != '\0')
    {
      check_fgt (victim);
      if (!str_cmp (arg3, "none"))
	{
	  victim->fgt->leader = NULL;
	  return;
	}
      if ((get_char_world (ch, arg3)) == NULL)
	{
	  send_to_char ("They aren't here.\n\r", ch);
	  return;
	}
      victim->fgt->leader = get_char_world (ch, arg3);
      return;
    }
  if (!str_cmp (arg2, "affect") && arg3[0] != '\0')
    {
      victim->affected_by = value;
      return;
    }
  if (!str_cmp (arg2, "spec") && arg3[0] != '\0')
    {
      if (spec_lookup (arg3) == NULL)
	{
	  send_to_char ("No such spec fun.\n\r", ch);
	  return;
	}
      victim->pIndexData->spec_fun = spec_lookup (arg3);
      victim->pIndexData->spec_name = str_dup (arg3);
      return;
    }
  do_mset (ch, "");
  return;
}

void 
do_oset (CHAR_DATA * ch, char *argy)
{
  char arg1[SML_LENGTH];
  char arg2[SML_LENGTH];
  char arg3[SML_LENGTH];
  SINGLE_OBJECT *obj;
  int value;
  DEFINE_COMMAND ("oset", do_oset, POSITION_DEAD, 110, LOG_NORMAL, "Sets a specific object's stats and stuff...")

    if (IS_MOB (ch))
    return;
  if (LEVEL (ch) < 110)
    {
      send_to_char ("Command has been removed due to abuse!\n\r", ch);
      return;
    }
  smash_tilde (argy);
  argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  strcpy (arg3, argy);
  if (arg1[0] == '\0' || arg2[0] == '\0')
    {
      send_to_char ("Syntax: oset <object> <field> <value>\n\r", ch);
      send_to_char ("or: oset <object> <string> <value>\n\r", ch);
      send_to_char ("\n\r", ch);
      send_to_char ("Field being one of:\n\r", ch);
      send_to_char (" extra wear level weight\n\r", ch);
      send_to_char (" cost type timer\n\r", ch);
      send_to_char ("\n\r", ch);
      send_to_char ("String being one of:\n\r", ch);
      send_to_char (" name short long ed\n\r", ch);
      return;
    }
  if ((obj = get_obj_world (ch, arg1)) == NULL)
    {
      send_to_char ("Nothing like that in hell, earth, or heaven.\n\r", ch);
      return;
    }
  value = atoi (arg3);

  if (!str_cmp (arg2, "short") && arg3[0] != '\0')
    {
      if (obj->short_descr != NULL)
	free_string (obj->short_descr);
      obj->short_descr = str_dup (arg3);
      return;
    }
  if (!str_cmp (arg2, "long"))
    {
      send_to_char ("Entering line editing mode.\n\r", ch);
      send_to_char ("Terminate with a ~ on a blank line.\n\r", ch);
      ch->desc->pString = &obj->description;
      return;
    }
  if (!str_cmp (arg2, "cost") && arg3[0] != '\0')
    {
      obj->cost = value;
      return;
    }
  if (!str_cmp (arg2, "timer") && arg3[0] != '\0')
    {
      obj->timer = value;
      return;
    }

  do_oset (ch, "");
  return;
}

void 
do_pset (CHAR_DATA * ch, char *argy)
{
  bool ad=FALSE;
  bool sb=FALSE;
  char arg1[SML_LENGTH];
  int bit = 0;
  char arg2[SML_LENGTH];
  char arg3[SML_LENGTH];
  CHAR_DATA *victim;
  int value;
  DEFINE_COMMAND ("pset", do_pset, POSITION_DEAD, 110, LOG_ALWAYS, "Changes a player's info...")

    smash_tilde (argy);
  argy = one_argy (argy, arg1);
  argy = one_argy (argy, arg2);
  strcpy (arg3, argy);
  if (arg1[0] == '\0' || arg2[0] == '\0')
    {
      send_to_char ("Syntax: pset <victim> <field> <value>\n\r", ch);
      send_to_char ("\n\r", ch);
      send_to_char ("Options:\n\r", ch);
      send_to_char (" (Use pedit to set attribs) sex security killpts AC compflag\n\r", ch);
      send_to_char (" hp move practice align race height removexp removetp\n\r", ch);
      send_to_char (" thirst guild drunk full master leader learn addxp addtp\n\r", ch);
      send_to_char (" ipflag tflag warpoints deaths (fly/breath/d_hid/d_invis/infra) tp\n\r", ch);
      send_to_char (" short long description title\n\r", ch);
      return;
    }
  if ((victim = get_char_world_2 (ch, arg1)) == NULL)
    {
      send_to_char ("They aren't here.\n\r", ch);
      return;
    }
  if (IS_MOB (victim))
    {
      send_to_char ("Not on mobs.\n\r", ch);
      return;
    }
#ifdef NEW_WORLD
  if (!str_cmp ("pkill", arg2)) {
	if (NO_PKILL(victim)) {
		victim->pcdata->cool_skills ^= COOL_SKILL_NO_PKILL;
		}
	return;
	}
  if (!str_cmp ("nopkill", arg2)) {
	victim->pcdata->cool_skills |= COOL_SKILL_NO_PKILL;
	return;
	}
#endif
  if (!str_cmp ("scriptflag", arg2))
    {
      int ik;
      argy = one_argy (argy, arg3);
      if (!str_cmp (argy, "off"))
	{
	  for (ik = 0; ik < 3000; ik++)
	    {
	      if (victim->pcdata->script_flags[ik] && victim->pcdata->script_flags[ik][0] != '\0' &&
		  !str_cmp (victim->pcdata->script_flags[ik], arg3))
		{
		  free_string (victim->pcdata->script_flags[ik]);
		  victim->pcdata->script_flags[ik] = NULL;
		  return;
		}
	    }
	}
      if (!str_cmp (argy, "on"))
	{
	  for (ik = 0; ik < 3000; ik++)
	    {
	      if (!victim->pcdata->script_flags[ik])
		continue;
	      if (!str_cmp (victim->pcdata->script_flags[ik], arg3))
		return;
	    }
	  for (ik = 0; ik < 3000; ik++)
	    {
	      if (victim->pcdata->script_flags[ik] && victim->pcdata->script_flags[ik][0] != '\0')
		continue;
	      victim->pcdata->script_flags[ik] = str_dup (arg3);
	      return;
	    }
	}
      return;
    }
  if (arg3[0] == '-') {
    char *rr=arg3;
    value=(0-(atoi((rr+1))));
    sb=TRUE;
    value = atoi (arg3);
    }
  else
  if (arg3[0] == '+') {
	char *rr=arg3;
	ad=TRUE;
	value=atoi((rr+1));
	} else
    value = is_number (arg3) ? atoi (arg3) : -1;
  if (check_toggle_implant (victim, arg2))
    {
      send_to_char ("Implant toggled.\n\r", ch);
      return;
    }
#ifdef NEW_WORLD
  S_HEALER (arg2, bit)
    S_WIZARD (arg2, bit)
    S_KNIGHT (arg2, bit)
    S_BARBARIAN (arg2, bit)
    S_RANGER (arg2, bit)
    S_PALADIN (arg2, bit)
    S_DRUID (arg2, bit)
    S_ARCHMAGE (arg2, bit)
    S_ASSASSIN (arg2, bit)
    S_MONK (arg2, bit)
    S_BARD (arg2, bit)
    S_HUNTER (arg2, bit)
    S_ENGINEER (arg2, bit)
    S_PHILOSOPHER (arg2, bit)
    if (bit != 0)
    {
      victim->pcdata->profession_flag ^= bit;
      send_to_char ("Profession toggled.\n\r", ch);
      return;
    }
#endif

  if (!str_cmp (arg2, "level"))
    {
      if (value < 1 || value > 99)
	return;
      victim->exp = (FIND_EXP ((value - 1), 1));
      send_to_char ("Level set.\n\r", ch);
      send_to_char ("The next mob you hit, you will raise in level.\n\r", victim);
      return;
    }
  if (!str_cmp (arg2, "fly"))
    {
      if (IS_SET (victim->pcdata->nat_abilities, AFF_FLYING))
	{
	  act ("$N no longer has natural flying abilities.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities -= AFF_FLYING;
	}
      else
	{
	  act ("$N now has natural flying abilities.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities += AFF_FLYING;
	}
      return;
    }
  if (!str_cmp (arg2, "infra"))
    {
      if (IS_SET (victim->pcdata->nat_abilities, AFF_INFRARED))
	{
	  act ("$N can no longer see in the dark naturally.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities -= AFF_INFRARED;
	}
      else
	{
	  act ("$N can now see in the dark naturally.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities += AFF_INFRARED;
	}
      return;
    }
  if (!str_cmp (arg2, "d_hid"))
    {
      if (IS_SET (victim->pcdata->nat_abilities, AFF_DETECT_HIDDEN))
	{
	  act ("$N can no longer sense hidden objs/lifeforms naturally.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities -= AFF_DETECT_HIDDEN;
	}
      else
	{
	  act ("$N can now sense hidden lifeforms/objs naturally.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities += AFF_DETECT_HIDDEN;
	}
      return;
    }
  if (!str_cmp (arg2, "d_invis"))
    {
      if (IS_SET (victim->pcdata->nat_abilities, AFF_DETECT_INVIS))
	{
	  act ("$N no longer has natural detect invis.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities -= AFF_DETECT_INVIS;
	}
      else
	{
	  act ("$N now has natural detect invis.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities += AFF_DETECT_INVIS;
	}
      return;
    }
  if (!str_cmp (arg2, "breath"))
    {
      if (IS_SET (victim->pcdata->nat_abilities, AFF_BREATH_WATER))
	{
	  act ("$N can no longer breath water naturally.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities -= AFF_BREATH_WATER;
	}
      else
	{
	  act ("$N now can breath water naturally.", ch, NULL, victim, TO_CHAR);
	  victim->pcdata->nat_abilities += AFF_BREATH_WATER;
	}
      return;
    }
  if (!str_cmp (arg2, "compflag") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      if (victim->pcdata->complete[i])
	{
	  victim->pcdata->complete[i] = FALSE;
	  send_to_char ("Flag toggled off.\n\r", ch);
	  return;
	}
      if (!victim->pcdata->complete[i])
	{
	  victim->pcdata->complete[i] = TRUE;
	  send_to_char ("Flag toggled on.\n\r", ch);
	  return;
	}
    }
  if (!str_cmp (arg2, "ipflag") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      if (victim->pcdata->in_progress[i])
	{
	  victim->pcdata->in_progress[i] = FALSE;
	  send_to_char ("Flag toggled off.\n\r", ch);
	  return;
	}
      if (!victim->pcdata->in_progress[i])
	{
	  victim->pcdata->in_progress[i] = TRUE;
	  send_to_char ("Flag toggled on.\n\r", ch);
	  return;
	}
    }
  if (!str_cmp (arg2, "tflag") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      if (victim->pcdata->temp_flag[i])
	{
	  victim->pcdata->temp_flag[i] = FALSE;
	  send_to_char ("Flag toggled off.\n\r", ch);
	  return;
	}
      if (!victim->pcdata->temp_flag[i])
	{
	  victim->pcdata->temp_flag[i] = TRUE;
	  send_to_char ("Flag toggled on.\n\r", ch);
	  return;
	}
    }
  if (!str_cmp (arg2, "compflagon") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      victim->pcdata->complete[i] = TRUE;
      send_to_char ("Flag toggled on.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "ipflagon") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      victim->pcdata->in_progress[i] = TRUE;
      send_to_char ("Flag toggled on.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "tflagon") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      victim->pcdata->temp_flag[i] = TRUE;
      send_to_char ("Flag toggled on.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "compflagoff") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      victim->pcdata->complete[i] = FALSE;
      send_to_char ("Flag toggled off.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "ipflagoff") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      victim->pcdata->in_progress[i] = FALSE;
      send_to_char ("Flag toggled off.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "tflagoff") && is_number (arg3))
    {
      int i;
      i = atoi (arg3);
      if (i < 0 || i >= 1000)
	return;
      victim->pcdata->temp_flag[i] = FALSE;
      send_to_char ("Flag toggled off.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "hitroll") && arg3[0] != '\0')
    {
      if (value < 0 || value > 140)
	{
	  send_to_char ("Valid range for hitroll is 0 - 140.\n\r", ch);
	  return;
	}
      victim->hitroll = value;
      send_to_char ("Victim base hitroll set.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "height") && arg3[0] != '\0')
    {
      if (value < 1 || value > 32000)
	{
	  send_to_char ("Valid range for height is 1 - 32000.\n\r", ch);
	  return;
	}
      victim->height = value;
      send_to_char ("Victim height set.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "tp") && arg3[0] != '\0')
    {
      if (value < 0)
	{
	  return;
	}
      victim->pcdata->tps = value;
      send_to_char ("Victim tps set.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "addtp") && arg3[0] != '\0')
    {
      char tuf[500];
      if (value < 0)
	{
	  return;
	}
      victim->pcdata->tps += value;
      sprintf (tuf, "You just gained %d travel points!\n\r", value);
      send_to_char (tuf, victim);
      send_to_char ("Victim tps added.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "remove_hp") && arg3[0] != '\0')
    {
      char tuf[500];
      if (value <= 0)
	{
	  return;
	}
      victim->hit -= value;
      if (victim->hit < 1)
	victim->hit = 1;
      return;
    }
  if (!str_cmp (arg2, "removetp") && arg3[0] != '\0')
    {
      if (value < 0)
	{
	  return;
	}
      victim->pcdata->tps -= value;
      send_to_char ("Victim tps removed.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "removexp") && arg3[0] != '\0')
    {
      char buf[300];
      if (value < 0)
	{
	  return;
	}
      victim->exp -= value;
      send_to_char ("Victim xps removed.\n\r", ch);
      sprintf (buf, "%d exp points were removed!\n\r", value);
      send_to_char ("You have been demoted.  ", victim);
      send_to_char (buf, victim);
      return;
    }
  if (!str_cmp (arg2, "addxp") && arg3[0] != '\0')
    {
      if (value < 0)
	{
	  return;
	}
      send_to_char ("You feel a bit more experienced!\n\r", victim);
      gain_exp (victim, value);
      send_to_char ("Victim xps awarded.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "bank") && arg3[0] != '\0')
    {
      if (value < 0 || value > 1000000)
	{
	  send_to_char ("Valid range for bank coinage is 0 - 1,000,000.\n\r", ch);
	  return;
	}
      victim->pcdata->bank = value;
      send_to_char ("Victim bank coinage set.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "damroll") && arg3[0] != '\0')
    {
      if (value < 0 || value > 140)
	{
	  send_to_char ("Valid range for damroll is 0 - 140.\n\r", ch);
	  return;
	}
      victim->damroll = value;
      send_to_char ("Victim base damroll set.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "ac") && arg3[0] != '\0')
    {
      if (value < 0 || value > 140)
	{
	  send_to_char ("Valid range for natural armor class is 0 to 140.\n\r", ch);
	  return;
	}
      victim->pcdata->nat_armor = value;
      send_to_char ("Natural Armor Class set.\n\r", ch);
      return;
    }

  if (!str_cmp (arg2, "warpoints") && (ad || sb || value!=-1))
    {
      int wp;
      if (ad) wp=victim->pcdata->warpoints+value; else
      if (sb) wp=victim->pcdata->warpoints+value;
      else wp = value;
      victim->pcdata->warpoints = wp;
      send_to_char ("Warpoints set.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "deaths") && is_number (arg3))
    {
      int wp;
      wp = atoi (arg3);
      if (wp < 0)
	return;
      victim->pcdata->deaths = wp;
      send_to_char ("Deaths set.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "guild") && arg3[0] != '\0')
    {
      if (!str_cmp (arg3, "tinker"))
	{
	  if (IS_SET (victim->pcdata->guilds, ACT3_TINKER))
	    {
	      send_to_char ("Tinker's Guild Removed.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_TINKER;
	    }
	  else
	    {
	      send_to_char ("Tinker's Guild Added.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_TINKER;
	    }
	  return;
	}
      if (!str_cmp (arg3, "warrior"))
	{
	  if (IS_SET (victim->pcdata->guilds, ACT3_WARRIOR))
	    {
	      send_to_char ("Warrior's Guild Removed.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_WARRIOR;
	    }
	  else
	    {
	      send_to_char ("Warrior's Guild Added.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_WARRIOR;
	    }
	  return;
	}
      if (!str_cmp (arg3, "healer"))
	{
	  if (IS_SET (victim->pcdata->guilds, ACT3_HEALER))
	    {
	      send_to_char ("Healer's Guild Removed.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_HEALER;
	    }
	  else
	    {
	      send_to_char ("Healer's Guild Added.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_HEALER;
	    }
	  return;
	}
      if (!str_cmp (arg3, "wizard"))
	{
	  if (IS_SET (victim->pcdata->guilds, ACT3_WIZARD))
	    {
	      send_to_char ("Wizard's Guild Removed.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_WIZARD;
	    }
	  else
	    {
	      send_to_char ("Wizard's Guild Added.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_WIZARD;
	    }
	  return;
	}
      if (!str_cmp (arg3, "thief") || !str_cmp (arg3, "thiefg"))
	{
	  if (IS_SET (victim->pcdata->guilds, ACT3_THIEFG))
	    {
	      send_to_char ("Thief's Guild Removed.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_THIEFG;
	    }
	  else
	    {
	      send_to_char ("Thief's Guild Added.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_THIEFG;
	    }
	  return;
	}
      if (!str_cmp (arg3, "ranger"))
	{
	  if (IS_SET (victim->pcdata->guilds, ACT3_RANGER))
	    {
	      send_to_char ("Ranger's Guild Removed.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_RANGER;
	    }
	  else
	    {
	      send_to_char ("Ranger's Guild Added.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_RANGER;
	    }
	  return;
	}
      if (!str_cmp (arg3, "assassin"))
	{
	  if (IS_SET (victim->pcdata->guilds, ACT3_ASSASSIN))
	    {
	      send_to_char ("Assassin's Guild Removed.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_ASSASSIN;
	    }
	  else
	    {
	      send_to_char ("Assassin's Guild Added.\n\r", ch);
	      victim->pcdata->guilds ^= ACT3_ASSASSIN;
	    }
	  return;
	}
      send_to_char ("Unknown guild.\n\r", ch);
      return;
    }
  if (!str_cmp (arg2, "int") && arg3[0] != '\0')
    {
      if (value < 3 || value > 25)
	{
	  send_to_char ("Intelligence range is 3 to 25.\n\r", ch);
	  return;
	}
      victim->pcdata->perm_int = value;
      return;
    }
  if (!str_cmp (arg2, "killpts") && arg3[0] != '\0')
    {
      if (value < 0 || value > 30000)
	{
	  send_to_char ("Killpoint range is 0 to 30,000 killpoints.\n\r", ch);
	  return;
	}
      victim->pcdata->killpoints = value;
      return;
    }
  if (!str_cmp (arg2, "sex") && arg3[0] != '\0')
    {
      if (value < 0 || value > 2)
	{
	  send_to_char ("Sex range is 0 to 2.\n\r", ch);
	  return;
	}
      victim->pcdata->sex = value;
      return;
    }
  if (!str_cmp (arg2, "race") && arg3[0] != '\0')
    {
      if (value < 0 || value >= RACE_COUNT)
	{
	  char buf[STD_LENGTH];
	  sprintf (buf, "Race range is 0 to %d.\n", RACE_COUNT - 1);
	  send_to_char (buf, ch);
	  return;
	}
      victim->pcdata->race = value;
      return;
    }
  if (!str_cmp (arg2, "hp") && arg3[0] != '\0')
    {
      if (value < 1 || value > 30000)
	{
	  send_to_char ("Hp range is 1 to 30,000 hit points.\n\r", ch);
	  return;
	}
      victim->max_hit = value;
      upd_hps (ch);
      return;
    }
  if (!str_cmp (arg2, "move") && arg3[0] != '\0')
    {
      if (value < 1 || value > 30000)
	{
	  send_to_char ("Move range is 1 to 30,000 move points.\n\r", ch);
	  return;
	}
      victim->max_move = value;
      return;
    }
  if (!str_cmp (arg2, "practice") && arg3[0] != '\0')
    {
      if (value < 0 || value > 100)
	{
	  send_to_char ("Practice range is 0 to 100 sessions.\n\r", ch);
	  return;
	}
      victim->pcdata->practice = value;
      return;
    }
  if (!str_cmp (arg2, "learn") && arg3[0] != '\0')
    {
      if (value < 0 || value > SKILL_COUNT)
	{
	  send_to_char ("Practice range is 0 to 100 sessions.\n\r", ch);
	  return;
	}
      victim->pcdata->learn = value;
      return;
    }
  if (!str_cmp (arg2, "align") && arg3[0] != '\0')
    {
      if (value < -1000 || value > 1000)
	{
	  send_to_char ("Alignment range is -1000 to 1000.\n\r", ch);
	  return;
	}
      victim->pcdata->alignment = value;
      conv_race (victim);
      return;
    }
  if (!str_cmp (arg2, "thirst") && arg3[0] != '\0')
    {
      if (value < 0 || value > 100)
	{
	  send_to_char ("Thirst range is 0 to 100.\n\r", ch);
	  return;
	}
      victim->pcdata->condition[COND_THIRST] = value;
      return;
    }
  if (!str_cmp (arg2, "drunk") && arg3[0] != '\0')
    {
      if (value < 0 || value > 100)
	{
	  send_to_char ("Drunk range is 0 to 100.\n\r", ch);
	  return;
	}
      victim->pcdata->condition[COND_DRUNK] = value;
      return;
    }
  if (!str_cmp (arg2, "full") && arg3[0] != '\0')
    {
      if (value < 0 || value > 100)
	{
	  send_to_char ("Full range is 0 to 100.\n\r", ch);
	  return;
	}
      victim->pcdata->condition[COND_FULL] = value;
      return;
    }
  if (!str_cmp (arg2, "master") && arg3[0] != '\0')
    {
      check_fgt (victim);
      if (!str_cmp (arg3, "none"))
	{
	  victim->fgt->master = NULL;
	  return;
	}
      if ((get_char_world (ch, arg3)) == NULL)
	{
	  send_to_char ("They aren't here.\n\r", ch);
	  return;
	}
      victim->fgt->master = get_char_world (ch, arg3);
      return;
    }
  if (!str_cmp (arg2, "leader") && arg3[0] != '\0')
    {
      check_fgt (victim);
      if (!str_cmp (arg3, "none"))
	{
	  victim->fgt->leader = NULL;
	  return;
	}
      if ((get_char_world (ch, arg3)) == NULL)
	{
	  send_to_char ("They aren't here.\n\r", ch);
	  return;
	}
      victim->fgt->leader = get_char_world (ch, arg3);
      return;
    }
  if (!str_cmp (arg2, "short") && arg3[0] != '\0')
    {
      if (victim->pcdata->short_descr && victim->pcdata->short_descr != NULL)
	free_string (victim->pcdata->short_descr);
      victim->pcdata->short_descr = str_dup (arg3);
      return;
    }
  if (!str_cmp (arg2, "long"))
    {
      send_to_char ("Entering line editing mode.\n\r", ch);
      send_to_char ("Terminate with a ~ on a blank line.\n\r", ch);
      ch->desc->pString = &victim->pcdata->long_descr;
      return;
    }
  if (!str_cmp (arg2, "title") && arg3[0] != '\0')
    {
      set_title (victim, arg3);
      return;
    }
#ifdef OLDQUEST
  if ((value = lookup_questname (arg2)) >= 0)
    {
      char tmp[500];
      if (!str_cmp (arg3, "done") || !str_prefix ("complete", arg3) ||
	  !str_cmp (arg3, "on"))
	{
	  victim->pcdata->complete[value] = 1;
	  sprintf (tmp, "Quest '%s' marked as COMPLETE.\n\r", questname[value]);
	  send_to_char (tmp, ch);
	  return;
	}
      if (!str_cmp (arg3, "unfinished") || !str_prefix ("incomplete", arg3) ||
	  !str_cmp (arg3, "off"))
	{
	  victim->pcdata->complete[value] = 0;
	  sprintf (tmp, "Quest '%s' marked as OFF.\n\r", questname[value]);
	  send_to_char (tmp, ch);
	  return;
	}
      return;
    }
#endif
  do_pset (ch, "");
  return;
}

char *
con_state (DESCRIPTOR_DATA * d)
{
  static char st[30];
  st[0] = '\0';
  if (d->connected == CON_PLAYING)
    strcpy (st, "Playing");
  else if (d->connected == CON_AEDITOR && (AREA_DATA *) d->pEdit != NULL)
    {
      sprintf (st, "Aedit #%d", ((AREA_DATA *) d->pEdit)->vnum);
    }
  else if (d->connected == CON_REDITOR)
    {
      sprintf (st, "Redit #%d", d->character->in_room->vnum);
    }
  else if (d->connected == CON_MEDITOR && (MOB_PROTOTYPE *) d->pEdit != NULL)
    {
      sprintf (st, "Medit #%d", ((MOB_PROTOTYPE *) d->pEdit)->vnum);
    }
  else if (d->connected == CON_OEDITOR && (OBJ_PROTOTYPE *) d->pEdit != NULL)
    {
      sprintf (st, "Oedit #%d", ((OBJ_PROTOTYPE *) d->pEdit)->vnum);
    }
  else if (d->connected == CON_CEDITOR && (CLAN_DATA *) d->pEdit != NULL)
    {
      sprintf (st, "Cedit #%d", ((CLAN_DATA *) d->pEdit)->vnum);
    }
  else if (d->connected == CON_FSEDITOR)
    strcpy (st, "FullScreen");
  else if (d->connected == CON_PEDITOR && (CHAR_DATA *) d->pEdit != NULL)
    {
      sprintf (st, "Pedit %s", ((CHAR_DATA *) d->pEdit)->pcdata->name);
    }
  else if (d->connected == CON_SEDITOR && (SPELL_DATA *) d->pEdit != NULL)
    {
      sprintf (st, "Sedit #%d", ((SPELL_DATA *) d->pEdit)->gsn);
    }
  else if (d->connected == CON_SOCEDIT)
    strcpy (st, "SocEdit");
  else if (d->connected == CON_GODMENU)
    strcpy (st, "GodMenu");
  else if (d->connected == CON_GET_OLD_PASSWORD)
    strcpy (st, "Asking Passwd");
  else if (d->connected == CON_READ_MOTD)
    strcpy (st, "MOTD");
  else if (d->connected == CON_SHELL)
    strcpy (st, "<SHELL>");
  else
    strcpy (st, "Newbie/Login");
  return st;
}

void 
do_users (CHAR_DATA * ch, char *argy)
{
  DESCRIPTOR_DATA *d;
  CHAR_DATA *tch;
  int cc;
  int count;
  char tmp[100];
  int tcount;
  DEFINE_COMMAND ("users", do_users, POSITION_DEAD, 105, LOG_NORMAL, "Shows a list of all connections and sites.")

    if (IS_MOB (ch))
    return;
  if (ch->pcdata->level > 111)
    ch->pcdata->level = 110;
  hugebuf_o[0] = '\0';
  tcount = 0;
  count = 0;
  cc = 0;
  for (tch = char_list; tch != NULL; tch = tch->next)
    {
      if (IS_PLAYER (tch) && tch->desc == NULL)
	cc++;
    }
  for (d = descriptor_list; d != NULL; d = d->next)
    {
#ifndef NEW_WORLD
      if (d->character && !str_cmp ("Orin", NAME (d->character)))
	continue;
#endif
      tcount++;
      if (d->character != NULL && can_see (ch, d->character))
	{
	  if (d->connected <= 0)
	    count++;
	  sprintf (hugebuf_o + strlen (hugebuf_o),
		   "%s%-3d \x1B[37;1m%-12s\x1B[37;0m %-17s %-18s \x1B[37;1m%s\x1B[37;0m\n\r",
		   (d->java?"J":(d->host[29] == 1 ? "*" : "#")), d->descriptor, d->character ? NAME (d->character) : "(none)",
		   d->host, con_state (d), d->username);
	}
    }
  sprintf (hugebuf_o + strlen (hugebuf_o), "-----------------------------------------------------------------------\n\r");
  sprintf (hugebuf_o + strlen (hugebuf_o), "%d Active Player%s, %d Connection%s, and %d Linkless Player%s.\n\r",
	   count, count == 1 ? "" : "s", tcount, tcount == 1 ? "" : "s", cc, cc == 1 ? "" : "s");
  page_to_char (hugebuf_o, ch);
  return;
}

void 
do_force (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  DEFINE_COMMAND ("force", do_force, POSITION_DEAD, 110, LOG_ALWAYS, "Forces a player/mob to do something.")

    argy = one_argy (argy, arg);
  if (IS_PLAYER (ch) && LEVEL (ch) > 110)
    ch->pcdata->level = 110;
  if (arg[0] == '\0' || argy[0] == '\0')
    {
      send_to_char ("Force whom to do what?\n\r", ch);
      return;
    }
  if (!str_cmp (arg, "all") && IS_PLAYER (ch))
    {
      CHAR_DATA *vch;
      CHAR_DATA *vch_next;
      if (LEVEL (ch) < 110)
	return;
      for (vch = char_list; vch != NULL; vch = vch_next)
	{
	  vch_next = vch->next;
	  if (IS_PLAYER (vch) && LEVEL (vch) < LEVEL (ch))
	    {
	      act ("$n forces everyone to '$t'.", ch, argy, vch, TO_VICT);
	      if (IS_PLAYER (ch))
		FORCE_LEVEL = LEVEL (ch);
	      else
		FORCE_LEVEL = TOP_LEVEL;
	      interpret (vch, argy);
	    }
	}
    }
  else
    {
      CHAR_DATA *victim;
      if ((victim = get_char_world_2 (ch, arg)) == NULL)
	{
	  send_to_char ("They aren't here.\n\r", ch);
	  return;
	}
      if (victim == ch)
	{
	  send_to_char ("Aye aye, right away!\n\r", ch);
	  return;
	}
      if (IS_PLAYER (ch) && victim->in_room->area->open == 1 && !IS_REAL_GOD (ch))
	return;
      if (IS_PLAYER (ch) && LEVEL (victim) >= LEVEL (ch))
	{
	  send_to_char ("Do it yourself!\n\r", ch);
	  return;
	}
      if (LEVEL (ch) < 110 && IS_PLAYER (victim))
	{
	  send_to_char ("You are not allowed to force Players at all!\n\r", ch);
	  return;
	}
      act ("$n forces you to '$t'.", ch, argy, victim, TO_VICT);
      if (IS_PLAYER (ch))
	FORCE_LEVEL = LEVEL (ch);
      else
	FORCE_LEVEL = TOP_LEVEL;
      interpret (victim, argy);
    }
  send_to_char ("Ok.\n\r", ch);
  return;
}

void 
do_invis (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  int oldinvis;
  DEFINE_COMMAND ("invis", do_invis, POSITION_DEAD, 100, LOG_NORMAL, "This command toggles whether an immort is vis to morts or not.")

    one_argy (argy, arg);
  if (IS_MOB (ch))
    return;
  oldinvis = ch->pcdata->wizinvis;
  if (arg[0] == '\0')
    {
      ch->pcdata->wizinvis = ch->pcdata->wizinvis == 0 ? LEVEL (ch) : 0;
    }
  else
    ch->pcdata->wizinvis = atoi (arg);
  ch->pcdata->wizinvis = ch->pcdata->wizinvis <= LEVEL (ch) ? ch->pcdata->wizinvis : LEVEL (ch);
  if (ch->pcdata->wizinvis <= LEVEL_IMMORTAL && ch->pcdata->wizinvis != 0)
    ch->pcdata->wizinvis = 0;
  if (ch->pcdata->wizinvis == oldinvis ||
      (ch->pcdata->wizinvis >= LEVEL_IMMORTAL && oldinvis >= LEVEL_IMMORTAL))
    return;
  if (ch->pcdata->wizinvis < oldinvis && ch->pcdata->wizinvis == 0)
    {
      act ("$n slowly fades into existence.", ch, NULL, NULL, TO_ROOM);
      send_to_char ("You slowly fade back into existence.\n\r", ch);
    }
  else if (ch->pcdata->wizinvis >= LEVEL_IMMORTAL && ch->pcdata->wizinvis > oldinvis)
    {
      act ("$n slowly fades into normal air.", ch, NULL, NULL, TO_ROOM);
      send_to_char ("You slowly vanish into normal air.\n\r", ch);
    }
  return;
}

void 
do_holywalk (CHAR_DATA * ch, char *argy)
{
  DEFINE_COMMAND ("holywalk", do_holywalk, POSITION_DEAD, 100, LOG_NORMAL, "Toggles holywalk on/off.")

    if (IS_MOB (ch))
    return;
  if (IS_SET (ch->act, PLR_HOLYWALK))
    {
      REMOVE_BIT (ch->act, PLR_HOLYWALK);
      send_to_char ("Holy walk mode off.\n\r", ch);
    }
  else
    {
      SET_BIT (ch->act, PLR_HOLYWALK);
      send_to_char ("Holy walk mode on.\n\r", ch);
    }
  return;
}

void 
do_holylag (CHAR_DATA * ch, char *argy)
{
  DEFINE_COMMAND ("holylag", do_holylag, POSITION_DEAD, 100, LOG_NORMAL, "Toggles holylag on/off.")

    if (IS_MOB (ch))
    return;
  if (IS_SET (ch->pcdata->act2, PLR_HOLYLAG))
    {
      REMOVE_BIT (ch->pcdata->act2, PLR_HOLYLAG);
      send_to_char ("Holy lag mode off.\n\r", ch);
    }
  else
    {
      SET_BIT (ch->pcdata->act2, PLR_HOLYLAG);
      send_to_char ("Holy lag mode on.\n\r", ch);
    }
  return;
}

void 
do_holypeace (CHAR_DATA * ch, char *argy)
{
  DEFINE_COMMAND ("holypeace", do_holypeace, POSITION_DEAD, 100, LOG_NORMAL, "Toggles holypeace on/off.")

    if (IS_MOB (ch))
    return;
  if (IS_SET (ch->act, PLR_HOLYPEACE))
    {
      REMOVE_BIT (ch->act, PLR_HOLYPEACE);
      send_to_char ("Holy peace mode off.\n\r", ch);
    }
  else
    {
      SET_BIT (ch->act, PLR_HOLYPEACE);
      send_to_char ("Holy peace mode on.\n\r", ch);
    }
  return;
}

void 
do_holylight (CHAR_DATA * ch, char *argy)
{
  DEFINE_COMMAND ("holylight", do_holylight, POSITION_DEAD, 100, LOG_NORMAL, "Toggles holylight on/off.")

    if (IS_MOB (ch))
    return;
  if (IS_SET (ch->act, PLR_HOLYLIGHT))
    {
      REMOVE_BIT (ch->act, PLR_HOLYLIGHT);
      send_to_char ("Holy light mode off.\n\r", ch);
    }
  else
    {
      SET_BIT (ch->act, PLR_HOLYLIGHT);
      send_to_char ("Holy light mode on.\n\r", ch);
    }
  return;
}


void 
do_owhere (CHAR_DATA * ch, char *argy)
{
  char arg[SML_LENGTH];
  char oneline[500];
  int slen = 0;
  bool found = FALSE;
  SINGLE_OBJECT *obj;
  SINGLE_OBJECT *in_obj;
  int obj_counter = 1;
  DEFINE_COMMAND ("owhere", do_owhere, POSITION_DEAD, 110, LOG_NORMAL, "Allows you to find actual objects in the world.")

    if (IS_MOB (ch))
    return;
  hugebuf_o[0] = '\0';
  one_argy (argy, arg);
  if (!IS_REAL_GOD (ch))
    {
      send_to_char ("Huh?\n\r", ch);
      return;
    }
  if (arg[0] == '\0')
    {
      send_to_char ("Syntax: owhere <object>.\n\r", ch);
      return;
    }
  else
    {
      for (obj = object_list; obj != NULL; obj = obj->next)
	{
	  if (!can_see_obj (ch, obj) || !is_name (arg, obj->pIndexData->name))
	    continue;
	  found = TRUE;
	  for (in_obj = obj; in_obj->in_obj != NULL;
	       in_obj = in_obj->in_obj)
	    ;
	  if (in_obj->carried_by != NULL)
	    {
	      sprintf (oneline, "[%2d] %s carried by %s.\n\r", obj_counter,
		   OOSTR (obj, short_descr), PERS (in_obj->carried_by, ch));
	    }
	  else
	    {
	      sprintf (oneline, "[%2d] %s in %s [%d].\n\r", obj_counter,
		       OOSTR (obj, short_descr), (in_obj->in_room == NULL) ?
		       "somewhere" : in_obj->in_room->name, (in_obj->in_room == NULL) ?
		       0 : in_obj->in_room->vnum);
	    }
	  obj_counter++;
	  oneline[0] = UPPER (oneline[0]);
	  sprintf (hugebuf_o + slen, "%s", oneline);
	  slen += strlen (oneline);
	  if (slen > 29500)
	    {
	      hugebuf_o[29500] = '\0';
	      break;
	    }
	}
    }
  if (!found)
    send_to_char (
		   "Nothing like that in hell, earth, or heaven.\n\r", ch);
  if (hugebuf_o[0] != '\0')
    page_to_char (hugebuf_o, ch);
  return;
}

void 
do_areas (CHAR_DATA * ch, char *argy)
{
  char buf[2048];
  int slen = 0;
  AREA_DATA *pAreat;
  DEFINE_COMMAND ("areas", do_areas, POSITION_DEAD, 0, LOG_NORMAL, "This command shows the current areas that make up the world.")

    if (IS_MOB (ch))
    return;
  hugebuf_o[0] = '\0';
  buf[0] = '\0';
  if (LEVEL (ch) >= 100)
    {
      sprintf (hugebuf_o, "[%3s] %1s %-24s (%-5s-%5s) %10s %3s [%s]\n\r",
	       "Num", "W", "Area Name", "lvnum", "uvnum", "Filename", "Sec", "Builders");
      buf[0] = '\0';
      slen = strlen (hugebuf_o);
      for (pAreat = area_first; pAreat != NULL; pAreat = pAreat->next)
	{
	  sprintf (buf, "[%3d] %1s %-24s (%-5d-%5d) %13s %2d [%s]\n\r",
		   pAreat->vnum,
		   (ch->in_room->area == pAreat ? "*" : " "),
		   pAreat->name,
		   pAreat->lvnum,
		   pAreat->uvnum,
		   pAreat->filename,
		   pAreat->security,
		   pAreat->builders);
	  sprintf (hugebuf_o + slen, "%s", buf);
	  slen += strlen (buf);
	  if (slen > 29500)
	    {
	      hugebuf_o[29500] = '\0';
	      break;
	    }
	}
    }
  else
    {
      sprintf (hugebuf_o, "[%3s] %1s %-30s [%s]\n\r",
	       "Num", "W", "Area Name", "Builders");
      slen = strlen (hugebuf_o);
      buf[0] = '\0';
      for (pAreat = area_first; pAreat != NULL; pAreat = pAreat->next)
	{
	  if (!pAreat->open)
	    continue;
	  sprintf (buf, "[%3d] %1s %-30s [%s]\n\r",
		   pAreat->vnum,
		   (ch->in_room->area == pAreat ? "*" : " "),
		   pAreat->name, pAreat->builders);
	  sprintf (hugebuf_o + slen, "%s", buf);
	  slen += strlen (buf);
	  if (slen > 29500)
	    {
	      hugebuf_o[29500] = '\0';
	      break;
	    }
	}
    }
  page_to_char (hugebuf_o, ch);
  return;
}

void 
do_count (CHAR_DATA * ch, char *argy)
{
  char arg[STD_LENGTH];
  char arg2[STD_LENGTH];
  char buf[2048];
  AREA_DATA *pArea;
  int tot_room = 0, tot_mob = 0, tot_obj = 0;
  int open_area = 0, open_room = 0, open_mob = 0, open_obj = 0;
  DEFINE_COMMAND ("count", do_count, POSITION_DEAD, 100, LOG_NORMAL, "Shows area statistics.")

    if (IS_MOB (ch))
    return;
  hugebuf_o[0] = '\0';
  argy = one_argy (argy, arg);
  if (argy[0] != '\0')
    argy = one_argy (argy, arg2);
  if (!str_cmp (arg, "open"))
    {
      sprintf (buf, "[%3s] %-10s (%-5s-%5s) %4s %4s %4s [%12s] %-3s %-4s\n\r",
	       "Num", "FileN", "lvnum", "uvnum", "Room", "Mob", "Obj",
	       "Builders", "Opn", "Plrs");
      strcpy (hugebuf_o, buf);
      for (pArea = area_first; pArea != NULL; pArea = pArea->next)
	{
	  if (pArea->open)
	    {
	      sprintf (buf, "[%3d] %-10s (%-5d-%5d) %3d/%3d %4d %4d [%12s] %-3s %-4d\n\r",
		       pArea->vnum, pArea->filename,
		       pArea->lvnum, pArea->uvnum, pArea->desc_rooms,
		       pArea->room_count, pArea->mob_count,
		       pArea->obj_count, pArea->builders, pArea->open ? "Yes" : "No", pArea->nplayer);
	      strcat (hugebuf_o, buf);
	      open_area++;
	      open_room += pArea->room_count;
	      open_mob += pArea->mob_count;
	      open_obj += pArea->obj_count;
	    }
	  if (strlen (hugebuf_o) > 29500)
	    {
	      hugebuf_o[29500] = '\0';
	      break;
	    }
	}
      sprintf (buf, "Open areas: %4d Rooms: %4d Mobs: %4d Objs: %4d\n\r",
	       open_area, open_room, open_mob, open_obj);
      strcat (hugebuf_o, buf);
      page_to_char (hugebuf_o, ch);
      return;
    }
  if (arg[0] != '\0')
    {
      sprintf (buf, "[%3s] %-10s (%-5s-%5s) %4s %4s %4s [%12s] %-3s %-4s\n\r",
	       "Num", "FileN", "lvnum", "uvnum", "Room", "Mob", "Obj",
	       "Builders", "Opn", "Plrs");
      strcpy (hugebuf_o, buf);
      if (is_number (arg))
	{
	  int vnum, vnum2 = 0;
	  pArea = area_first;
	  vnum = atoi (arg);
	  if (arg2[0] != '\0' && is_number (arg2))
	    vnum2 = atoi (arg2);
	  if (vnum2 != 0 && vnum2 < vnum)
	    {
	      int tmp;
	      tmp = vnum;
	      vnum = vnum2;
	      vnum2 = tmp;
	    }
	  while (pArea && pArea->vnum != vnum)
	    pArea = pArea->next;
	  if (!pArea)
	    {
	      send_to_char ("That area doesn't exist.\n\r", ch);
	      return;
	    }
	  if (vnum2)
	    {
	      while (pArea && pArea->vnum <= vnum2)
		{
		  if (strlen (hugebuf_o) > 29500)
		    {
		      hugebuf_o[29500] = '\0';
		      break;
		    }
		  sprintf (buf, "[%3d] %-10s (%-5d-%5d) %3d/%3d %4d %4d [%12s] %-3s %-4d\n\r",
			   pArea->vnum, pArea->filename,
			   pArea->lvnum, pArea->uvnum, pArea->desc_rooms,
			   pArea->room_count, pArea->mob_count,
			   pArea->obj_count, pArea->builders, pArea->open ? "Yes" : "No",
			   pArea->nplayer);
		  strcat (hugebuf_o, buf);
		  tot_room += pArea->room_count;
		  tot_mob += pArea->mob_count;
		  tot_obj += pArea->obj_count;
		  if (pArea->open)
		    {
		      open_area++;
		      open_room += pArea->room_count;
		      open_mob += pArea->mob_count;
		      open_obj += pArea->obj_count;
		    }
		  pArea = pArea->next;
		}
	    }
	  else
	    {
	      sprintf (buf, "[%3d] %-10s (%-5d-%5d) %3d/%3d %4d %4d [%12s] %-3s %-4d\n\r",
		       pArea->vnum, pArea->filename,
		       pArea->lvnum, pArea->uvnum, pArea->desc_rooms,
		       pArea->room_count, pArea->mob_count,
	      pArea->obj_count, pArea->builders, pArea->open ? "Yes" : "No",
		       pArea->nplayer);
	      strcat (hugebuf_o, buf);
	      tot_room += pArea->room_count;
	      tot_mob += pArea->mob_count;
	      tot_obj += pArea->obj_count;
	      if (pArea->open)
		{
		  open_area++;
		  open_room += pArea->room_count;
		  open_mob += pArea->mob_count;
		  open_obj += pArea->obj_count;
		}
	    }
	}
      else
	{
	  pArea = area_first;
	  while (pArea)
	    {
	      if (strlen (hugebuf_o) > 29500)
		{
		  hugebuf_o[29500] = '\0';
		  break;
		}
	      if (is_name (arg, pArea->builders))
		{
		  sprintf (buf, "[%3d] %-10s (%-5d-%5d) %3d/%3d %4d %4d [%12s] %-3s %-4d\n\r",
			   pArea->vnum, pArea->filename,
			   pArea->lvnum, pArea->uvnum, pArea->desc_rooms,
			   pArea->room_count, pArea->mob_count,
			   pArea->obj_count, pArea->builders, pArea->open ? "Yes" : "No",
			   pArea->nplayer);
		  strcat (hugebuf_o, buf);
		  tot_room += pArea->room_count;
		  tot_mob += pArea->mob_count;
		  tot_obj += pArea->obj_count;
		  if (pArea->open)
		    {
		      open_area++;
		      open_room += pArea->room_count;
		      open_mob += pArea->mob_count;
		      open_obj += pArea->obj_count;
		    }
		}
	      pArea = pArea->next;
	    }
	}
      sprintf (buf, "Total rooms: %4d Total mobs: %4d Total objs: %4d\n\r",
	       tot_room, tot_mob, tot_obj);
      strcat (hugebuf_o, buf);
      sprintf (buf, "Open areas: %4d Rooms: %4d Mobs: %4d Objs: %4d\n\r",
	       open_area, open_room, open_mob, open_obj);
      strcat (hugebuf_o, buf);
      page_to_char (hugebuf_o, ch);
      return;
    }
  sprintf (buf, "[%3s] %10s (%-5s-%5s) %4s %4s %4s [%12s] %-3s %-4s\n\r",
	   "Num", "Filename", "lvnum", "uvnum", "Room", "Mob", "Obj",
	   "Builders", "Opn", "Plrs");
  strcat (hugebuf_o, buf);
  for (pArea = area_first; pArea != NULL; pArea = pArea->next)
    {
      sprintf (buf, "[%3d] %10s (%-5d-%5d) %3d/%3d %4d %4d [%12s] %-3s %-4d\n\r",
	       pArea->vnum,
	       pArea->filename,
	       pArea->lvnum,
	       pArea->uvnum,
	       pArea->desc_rooms, pArea->room_count,
	       pArea->mob_count,
	       pArea->obj_count,
	       pArea->builders,
	       pArea->open ? "Yes" : "No",
	       pArea->nplayer);
      strcat (hugebuf_o, buf);
      tot_room += pArea->room_count;
      tot_mob += pArea->mob_count;
      tot_obj += pArea->obj_count;
      if (pArea->open)
	{
	  open_area++;
	  open_room += pArea->room_count;
	  open_mob += pArea->mob_count;
	  open_obj += pArea->obj_count;
	}
      if (strlen (hugebuf_o) > 29500)
	{
	  hugebuf_o[29500] = '\0';
	  break;
	}
    }
  sprintf (buf, "Total rooms: %4d Total mobs: %4d Total objs: %4d\n\r",
	   tot_room, tot_mob, tot_obj);
  strcat (hugebuf_o, buf);
  sprintf (buf, "Open areas: %4d Rooms: %4d Mobs: %4d Objs: %4d\n\r",
	   open_area, open_room, open_mob, open_obj);
  strcat (hugebuf_o, buf);
  page_to_char (hugebuf_o, ch);
  return;
}

char *
get_ansi_spaces (char *txt)
{
  static char mem[40000];
  char *spaces = mem;
  int ansi = 0, i;
  while (*txt != '\0')
    {
      if (*txt == '\e')
	{
	  do
	    {
	      ansi++;
	    }
	  while (*txt++ != 'm' && *txt!='\0');
	}
      else
	txt++;
    }
  for (i = 0; i < ansi; i++)
    {
      *spaces = ' ';
      spaces++;
    }
  *spaces = '\0';

  return mem;
}

void 
do_noaffect (CHAR_DATA * ch, char *argy)
{
  CHAR_DATA *victim;
  DEFINE_COMMAND ("noaffect", do_noaffect, POSITION_DEAD, 110, LOG_NORMAL, "This command will remove all affects of the character specified.")

    if (IS_MOB (ch))
    return;
  if (argy == "")
    {
      send_to_char ("Syntax is: noaffect <target_char>.\n\r", ch);
      return;
    }
  if ((victim = get_char_world (ch, argy)) == NULL)
    {
      send_to_char ("Could not find that person in the world...\n\r", ch);
      return;
    }
  strip_all_affects (victim);
  send_to_char ("Affects removed.\n\r", ch);
  return;
}