/* wiz.c */

#include "copyright.h"
#include "config.h"

#include <stdio.h>
#ifdef STRING_H
#include <string.h>
#else
#include <strings.h>
#endif                                /* STRING_H */
#include <ctype.h>

#include "teeny.h"

/*
 * Admin only commands. 
 */

voidfunc 
do_boot(player, arg)
  int             player;
  char           *arg;
{
  int             victim;

  if (!iswiz(player))
  {
    notify_player(player, "You can't boot anyone!\r\n");
    return;
  }
  if (!arg || !*arg)
  {
    notify_player(player, "Boot whom?\r\n");
    return;
  }
  if ((victim = match_player(arg)) == -1)
  {
    notify_player(player, "I can't find that player.\r\n");
    return;
  }
  if (!isalive(victim))
  {
    notify_player(player, "That player is not connected.\r\n");
    return;
  }
  if (victim == GOD)
  {
    notify_player(player, "You can't boot God!\r\n");
    return;
  }
  notify_player(victim, "You have been booted off the game.\r\n");
  iobdisconnect(victim);
  disconnect_player(victim);
  autotoadcheck(victim);
  notify_player(player, "Booted.\r\n");
}

voidfunc 
do_chown(player, argone, argtwo)
  int             player;
  char           *argone, *argtwo;
{
  int             owner, obj, flags;

  if (!iswiz(player))
  {
    notify_player(player, "Permission denied.\r\n");
    return;
  }
  if (!argone || !*argone || !argtwo || !*argtwo)
  {
    notify_player(player, "Chown what to who?\r\n");
    return;
  }
  if ((owner = resolve_player(player, argtwo, 1)) == -1)
  {
    notify_player(player, "I can't find that owner.\r\n");
    return;
  }
  if ((obj = resolve_object_or_exit(player, argone, 0)) == -1)
  {
    notify_player(player, "I can't find that object.\r\n");
    return;
  }
  if (obj == -2)
  {
    notify_player(player, "I can't tell which one you mean.\r\n");
    return;
  }
  if (get_int_elt(obj, FLAGS, &flags) == -1)
    goto chownbomb;
  if (((flags & TYPE_MASK) == TYP_PLAYER) && (player != GOD))
  {
    notify_player(player, "Players always own themselves.\r\n");
    return;
  }
  /* OK. Do it. */
#ifdef TIMESTAMPS
  stamp(obj);
#endif

  if (set_int_elt(obj, OWNER, owner) == -1)
    goto chownbomb;
  notify_player(player, "Owner changed.\r\n");
  return;

chownbomb:

  notify_bad(player);
}

voidfunc 
do_dump(player)
  int             player;
{
  if (!iswiz(player))
  {
    notify_player(player, "You're in a no dumping zone.\r\n");
    return;
  }
  notify_player(player, "Dumping...\r\n");
  dump_db();
}

voidfunc 
do_force(player, argone, argtwo)
  int             player;
  char           *argone, *argtwo;
{
  int             obj;

  if (!iswiz(player))
  {
    notify_player(player, "Permission denied.\r\n");
    return;
  }
  if (!argone || !*argone || !argtwo || !*argtwo)
  {
    notify_player(player, "Force who to do what?\r\n");
    return;
  }
  if ((obj = resolve_player(player, argone, 1)) == -1)
  {
    notify_player(player, "I can't find that player.\r\n");
    return;
  }
  if (obj == GOD)
  {
    notify_player(player, "You can't force God to do anything!\r\n");
    return;
  }
  handle_cmd(obj, argtwo);
  notify_player(player, "Ok.\r\n");
}

voidfunc 
do_newpassword(player, argone, argtwo)
  int             player;
  char           *argone, *argtwo;
{
  int             obj;
  char           *name, *p;
  extern char     cmdwork[];

  if (!iswiz(player))
  {
    notify_player(player, "Permission denied.\r\n");
    return;
  }
  if (!argone || !*argone || !argtwo || !*argtwo)
  {
    notify_player(player, "Change who's password to what?\r\n");
    return;
  }
  if ((obj = resolve_player(player, argone, 1)) == -1)
  {
    notify_player(player, "I can't find that player.\r\n");
    return;
  }
  if (obj == GOD && player != GOD)
  {
    notify_player(player, "You can't change God's password!\r\n");
    return;
  }
  if (get_str_elt(obj, NAME, &name) == -1)
    goto newbomb;

  for (p = cmdwork; *name != ' ' && *name; *p++ = *name++);
  *p++ = ' ';
  while (*argtwo)
  {
    *p++ = *argtwo++;
  }
  *p++ = '\0';

  if (set_str_elt(obj, NAME, cmdwork) == -1)
    goto newbomb;

  notify_player(obj, "Your password has been changed to \"");
  notify_player(obj, argtwo);
  notify_player(obj, "\".\r\n");
  notify_player(player, "Password changed.\r\n");
  return;

newbomb:
  notify_bad(player);
  return;
}

voidfunc 
do_textdump(player, file)
  int             player;
  char           *file;
{
  if (!iswiz(player))
  {
    notify_player(player, "You're in a no textdumping zone.\r\n");
    return;
  }
  if (mudstat() == DUMPING)
  {				/* eeek */
    notify_player(player, "Come back later.\r\n");
    return;
  }

  unlock_cache();     /* whoever said text_dump() was meant to run with
                         a locked cache?? */

  if (!file || !*file || (player != GOD))
  {
    text_dump(DEFAULT_TEXTDUMP);
  } else
  {
    text_dump(file);
  }
  lock_cache();               /* handle_at_cmd() will (re)unlock it.. */

  notify_player(player, "Ok.\r\n");
}

voidfunc 
do_toad(player, argone, argtwo)
  int             player;
  char           *argone, *argtwo;
{
  int             newowner, victim, total, flags, loc, list, next;
  char           *name, *p, *q, ch, *buff = (char *)0;
  char            work[128];


  if (!iswiz(player))
  {
    notify_player(player, "The spell fizzles and dies.\r\n");
    return;
  }
  if (!argone || !*argone)
  {
    notify_player(player, "Toad whom?\r\n");
    return;
  }
  if (!argtwo || !*argtwo)
  {
    newowner = -1;		/* purge */
  } else
  {
    if ((newowner = resolve_player(player, argtwo, 1)) == -1 ||
        newowner == -2)
    {
      notify_player(player, "I can't find that owner.\r\n");
      return;
    }
  }

  if ((victim = resolve_player(player, argone, 1)) == -1 || victim == -2)
  {
    notify_player(player, "I can't find who you want to toad.\r\n");
    return;
  }

  /* check for dipshits */

  if (victim == player)
  {
    notify_player(player,
        "Your magic isn't strong enough to toad yourself.\r\n");
    return;
  }
  if (victim == GOD)
  {
    notify_player(player, "God may not be toaded.\r\n");
    return;
  }
  if (iswiz(victim) && (player != GOD))
  {
    notify_player(player, "You can't toad another wizard!\r\n");
    return;
  }
  /* ok, let's do it */

  notify_player(victim,
      "You sense that everything you own is vanishing...\r\n");
  if (newowner != -1)
  {
    total = chownall(victim, newowner);
  } else
  {
    total = purgepossessions(victim);
  }

  if (get_int_elt(victim, FLAGS, &flags) == -1)
    goto toadbomb;
  flags = flags & ~TYPE_MASK;
  flags = flags | TYP_THING;
  if (set_int_elt(victim, FLAGS, flags) == -1)
    goto toadbomb;

  if(isalive(victim))
  {
    notify_player(victim, "yoo haf been turned inna slimy toad.\r\n");
    disconnect_player(victim);
    iobdisconnect(victim);
  }

  if (set_int_elt(victim, SITE, 0) == -1)
    goto toadbomb;

  if (get_str_elt(victim, NAME, &name) == -1)
    goto toadbomb;
  for (p = name; p && *p && *p != ' '; p++);
  *p = '\0';
  buff = ty_malloc(strlen(name) + 1, "do_toad");
  (void) strcpy(buff, name);

  (void) sprintf(work, "A slimy toad named %s.", buff);
  if (set_str_elt(victim, NAME, work) == -1)
    goto toadbomb;

  if (get_int_elt(victim, LOC, &loc) == -1)
    goto toadbomb;
  if(exists_object(loc))
  {
    (void)strcpy(work, buff);
    (void)strcat(work, " turns into a slimy toad before your eyes.\r\n");
    notify_oall(victim, work);
    list_drop(victim, loc, CONTENTS_LIST);
    list_add(victim, player, CONTENTS_LIST);
    if (set_int_elt(victim, LOC, player) == -1)
      goto toadbomb;
  }

  /* ok, now we fix up some lists... */

  if (get_int_elt(victim, CONTENTS, &list) == -1)
    goto toadbomb;
  while (list != -1)
  {
    int             home;

    if (get_int_elt(list, NEXT, &next) == -1)
    {
      warning("do_toad", "bad next ref, list is spam");
      goto toadbomb;
    }
    if (get_int_elt(list, HOME, &home) == -1)
    {
      list = next;
      continue;
    }
    if (!exists_object(home))
    {				/* argh */
      int owner;
      if (get_int_elt(list, OWNER, &owner) == -1)
      {
        list = next;
        continue;
      }
      if (get_int_elt(owner, HOME, &home) == -1)
      {
        list = next;
        continue;
      }
      home = STARTING_LOC;
    }
    if (set_int_elt(list, LOC, home) == -1)
    {
      list = next;
      continue;
    }
    list_drop(list, victim, CONTENTS_LIST);
    list_add(list, home, CONTENTS_LIST);

    list = next;
  }

  if (get_int_elt(victim, EXITS, &list) == -1)
    goto toadbomb;
  if(list)
  {
    while (list != -1)
    {
      if (get_int_elt(list, NEXT, &next) == -1)
      {
        warning("do_toad", "bad next ref, list is spam");
        goto toadbomb;
      }
      recycleobj(list);		/* boom! */
      list = next;
    }
    if(set_int_elt(victim, EXITS, -1) == -1)
      goto toadbomb;
  }

#ifdef TIMESTAMPS
  stamp(victim);
#endif				/* TIMESTAMPS */

  (void)sprintf(work, "Toaded.  %d objects %s.\r\n", total, (newowner == -1) ?
	  "purged" : "chowned");
  notify_player(player, work);

  if (set_int_elt(victim, OWNER, player) == -1)
    goto toadbomb;

  /* log it */

  if (get_str_elt(player, NAME, &q) == -1)
    goto toadbomb;		/* ya, right */
  for (p = q; p && *p && *p != ' '; p++);
  ch = *p;
  *p = '\0';
  log_command("TOAD: %s(#%d) toaded by %s(#%d).\n", buff, victim, q, player);
  *p = ch;

  ty_free(buff);

  return;

toadbomb:

  if (buff)
    ty_free(buff);

  notify_bad(player);
}

voidfunc 
do_wall(player, arg)
  int             player;
  char           *arg;
{
  char           *name, *p, ch;

  if (!iswiz(player))
  {
    notify_player(player, "But what do you want to do with a wall?\r\n");
    return;
  }
  if (!arg || !*arg)
  {
    notify_player(player, "@wall what, silly?\r\n");
    return;
  }
  if (get_str_elt(player, NAME, &name) == -1)
    goto wallbomb;

  /* Temporarily terminate the name */

  for (p = name; !isspace(*p) && *p;)
    p++;
  ch = *p;
  *p = '\0';

  notify_wall(name);

  log_command("WALL: %s(#%d)  \"%s\"\n", name, player, arg);

  *p = ch;

  notify_wall(" shouts, \"");
  notify_wall(arg);
  notify_wall("\"\r\n");
  return;
wallbomb:
  notify_bad(player);
  return;
}

voidfunc 
do_shutdown(player)
  int             player;
{
  if (iswiz(player))
  {
    set_mudstat(STOPPED);
    log_command("SHUTDOWN: by #%d\n", player);
    notify_player(player, "Ok.\r\n");
  } else
  {
    notify_player(player, "Permission denied. Doof.\r\n");
  }
}

voidfunc 
do_teleport(player, argone, argtwo)
  int             player;
  char           *argone;
  char           *argtwo;
{
  int             object, loc, dest, link, objflags, locflags, destflags;
  int             teleport_ok;
  char           *name, *p, *oarr, *olea, ch;

  if (!argone || !*argone)
  {
    notify_player(player, "Usage: @teleport <thing> = <destination>\r\n");
    notify_player(player, "or use @teleport <destination> to move yourself.\r\n");
    return;
  }
  if (!argtwo || !*argtwo)
  {
    object = player;
    if (strcmp(argone, "home") == 0)
    {
      dest = -3;
    } else
    if ((dest = resolve_object(player, argone, 0)) == -1)
    {
      notify_player(player, "I can't find that destination.\r\n");
      return;
    } else
    if (dest == -2)
    {
      notify_player(player, "I don't know which destination you mean.\r\n");
      return;
    }
  } else
  {
    if ((object = resolve_object_or_exit(player, argone, iswiz(player))) == -1)
    {
      notify_player(player, "I can't find what you wish to teleport.\r\n");
      return;
    }
    if (object == -2)
    {
      notify_player(player, "I can't tell which one you wish to teleport.\r\n");
      return;
    }
    if (strcmp(argtwo, "home") == 0)
    {
      if (get_int_elt(object, HOME, &dest) == -1)
        goto telbomb;
    } else
    if ((dest = resolve_object(player, argtwo, iswiz(player))) == -1)
    {
      notify_player(player, "I can't find that destination.\r\n");
      return;
    } else
    if (dest == -2)
    {
      notify_player(player, "I don't know which destination you mean.\r\n");
      return;
    }
  }

  /* do it */

  if (get_int_elt(object, FLAGS, &objflags) == -1)
    goto telbomb;
  if (get_int_elt(object, LOC, &loc) == -1)
    goto telbomb;

  switch (objflags & TYPE_MASK)
  {
  case TYP_ROOM:		/* no go */
  case TYP_EXIT:
    notify_player(player, "You can't teleport that!\r\n");
    return;
  case TYP_PLAYER:		/* our most complex */
    if (get_int_elt(loc, FLAGS, &locflags) == -1)
      goto telbomb;

    if (dest == -3)
    {				/* home */
      int             home;

      if (get_int_elt(object, HOME, &home) == -1)
	goto telbomb;
      if (!exists_object(home))
	home = STARTING_LOC;

      dest = home;
    }
    if (dest == player)
      if (get_int_elt(player, LOC, &dest) == -1)
        goto telbomb;
    if (get_int_elt(dest, FLAGS, &destflags) == -1)
      goto telbomb;
    if ((destflags & TYPE_MASK) != TYP_ROOM)
    {
      notify_player(player, "You can't teleport a player to that!\r\n");
      return;
    }
    if ((player != object) &&
        (!(controls(player, loc) || (objflags & JUMP_OK))))
    {
      notify_player(player, "You're not allowed to teleport that player.\r\n");
      return;
    }
    if (!(controls(player, loc) || (locflags & JUMP_OK)) ||
	!(controls(player, dest) || (destflags & JUMP_OK)))
    {
      notify_player(player, "Permission denied.\r\n");
      return;
    }
    notify_player(object, "You feel a wrenching sensation...\r\n");

    if (get_str_elt(object, NAME, &name) == -1)
      goto telbomb;
    for (p = name; *p && *p != ' '; p++);
    ch = *p;
    *p = '\0';

    if (!(locflags & DARK) && !isdark(object))
    {
      if (get_str_elt(object, SUC, &olea) == -1)
        goto telbomb;
      if (olea != NULL)
      {
        notify_oall(object, name);
        notify_oall(object, " ");
        notify_oall(object, olea);
        notify_oall(object, "\r\n");
      }
      notify_oall(object, name);
      notify_oall(object, " has left.\r\n");
    }
    list_drop(object, loc, CONTENTS_LIST);
    list_add(object, dest, CONTENTS_LIST);
    if (set_int_elt(object, LOC, dest) == -1)
      goto telbomb;
    if (!(destflags & DARK) && !isdark(object))
    {
      if (get_str_elt(object, FAIL, &oarr) == -1)
        goto telbomb;
      if (oarr != NULL)
      {
        notify_oall(object, name);
        notify_oall(object, " ");
        notify_oall(object, oarr);
        notify_oall(object, "\r\n");
      }
      notify_oall(object, name);
      notify_oall(object, " has arrived.\r\n");
    }
    *p = ch;

    do_look(object, (char *) 0);
    flush_room(loc);

    break;
  case TYP_THING:		/* gotta check for non-sticky drop-tos... */
    teleport_ok = FALSE;
    if (dest == -3)
    {
      int             home;

      if (get_int_elt(object, HOME, &home) == -1)
	goto telbomb;
      if (!exists_object(home))
      {
	int             owner;

	if (get_int_elt(object, OWNER, &owner) == -1)
	  goto telbomb;
	if (get_int_elt(owner, HOME, &home) == -1)
	  goto telbomb;
	if (!exists_object(home))
	  home = STARTING_LOC;

      }
      dest = home;
      teleport_ok = TRUE;
    }
    if (get_int_elt(dest, FLAGS, &destflags) == -1)
      goto telbomb;

    if (!(controls(player, object) || (objflags & JUMP_OK) ||
          controls(player, loc)))
    {
      notify_player(player, "Permission denied.\r\n");
      return;
    }
    if ( (!teleport_ok) &&
         (((destflags & TYPE_MASK) == TYP_PLAYER) && (dest != player)) ||
         ((destflags & TYPE_MASK) == TYP_EXIT) ||
         ((destflags & TYPE_MASK) == TYP_THING) ||
         !(controls(player, dest) || (destflags & JUMP_OK)) )
    {
      notify_player(player, "You can't teleport an object to there!\r\n");
      return;
    }
#ifdef TIMESTAMPS
    stamp(object);
#endif				/* TIMESTAMPS */

    list_drop(object, loc, CONTENTS_LIST);
    list_add(object, dest, CONTENTS_LIST);
    if (set_int_elt(object, LOC, dest) == -1)
      goto telbomb;

    if ((destflags & TYPE_MASK) == TYP_ROOM && !(destflags & STICKY))
    {
      char           *odrop;
      int             dropto;

      if (get_int_elt(dest, DROPTO, &dropto) == -1)
	goto telbomb;
      if (dropto != -1)
      {
        if (dropto == -3)
        {
          int             home;

          if (get_int_elt(object, HOME, &home) == -1)
            goto telbomb;
          if (!exists_object(home))
          {
            int             owner;

            if (get_int_elt(object, OWNER, &owner) == -1)
              goto telbomb;
            if (get_int_elt(owner, HOME, &home) == -1)
              goto telbomb;
            if (!exists_object(home))
              home = STARTING_LOC;
          }
          dropto = home;
        }

#ifdef DROP_FIELDS
	if (get_str_elt(object, NAME, &name) == -1)
	  goto telbomb;
	if (get_str_elt(dest, ODROP, &odrop) == -1)
	  goto telbomb;
	if (*odrop)
	{
	  notify_oall(object, name);
	  notify_oall(object, " ");
	  notify_oall(object, odrop);
	  notify_oall(object, "\r\n");
	} else
	{
	  notify_oall(object, name);
	  notify_oall(object, " falls through the floor!\r\n");
	}
#endif				/* DROP_FIELDS */
	list_drop(object, dest, CONTENTS_LIST);
	list_add(object, dropto, CONTENTS_LIST);
	if (set_int_elt(object, LOC, dropto) == -1)
	  goto telbomb;
      }
    }
    break;
  default:
    goto telbomb;
  }

  notify_player(player, "Teleported.\r\n");
  return;

telbomb:

  notify_bad(player);
}

voidfunc 
do_pcreate(player, argone, argtwo)
  int             player;
  char           *argone;
  char           *argtwo;
{
  extern char     cmdwork[];
  int             loc, newplayer;

#ifdef GOD_ONLY_PCREATE
  if (player != GOD)
  {
    notify_player(player, "Permission denied.\r\n");
    return;
  }
#else
  if (!iswiz(player))
  {
    notify_player(player, "Permission denied.\r\n");
    return;
  }
#endif				/* GOD_ONLY_PCREATE */
  if (!argone || !*argone || !argtwo || !*argtwo)
  {
    notify_player(player, "Usage: @pcreate <name> = <password>\r\n");
    return;
  }
  if (match_player(argone) != -1)
  {
    notify_player(player, "A player with that name already exists.\r\n");
    return;
  }
#ifndef REGISTRATION
  if (get_int_elt(player, LOC, &loc) == -1)
  {
    notify_player(player, "I can't get your location!\r\n");
    return;
  }
#endif				/* REGISTRATION */
  strncpy(cmdwork, argone, 16);
  if (strlen(argone) > 16)
    cmdwork[15] = '\0';
  strcat(cmdwork, " ");
  strcat(cmdwork, argtwo);
#ifndef REGISTRATION
  if ((newplayer = create_player(cmdwork, loc)) == -1)
  {
#else
  if ((newplayer = create_player(cmdwork, STARTING_LOC)) == -1)
  {
#endif				/* REGISTRATION */
    notify_player(player, "Pcreate failed.\r\n");
  } else
  {
    char           *p;

    for (p = cmdwork; *p && *p != ' '; p++);
    *p++ = '\0';

    notify_player(player, "Player \"");
    notify_player(player, cmdwork);
    notify_player(player, "\" created with password \"");
    notify_player(player, p);
    notify_player(player, "\".\r\n");

    log_command("PCREATED: %s(#%d) created by player #%d.\n", cmdwork,
		newplayer, player);
  }
}
voidfunc 
do_purge(player, arg)
  int             player;
  char           *arg;
{
  extern char     cmdwork[];
  int             victim;

  if (!iswiz(player))
  {
    notify_player(player, "Someone doesn't want you doing that.\r\n");
    return;
  }
  if (!arg || !*arg)
  {
    notify_player(player, "But who's possessions do you want to purge?\r\n");
    return;
  }
  if ((victim = resolve_player(player, arg, 1)) == -1)
  {
    notify_player(player, "That person does not exist.\r\n");
    return;
  }
  if (victim == GOD)
  {
    notify_player(player, "You may not purge God's possessions.\r\n");
    return;
  }
  sprintf(cmdwork, "Purged %d objects.\r\n", purgepossessions(victim));
  notify_player(player, cmdwork);
}
voidfunc 
do_chownall(player, argone, argtwo)
  int             player;
  char           *argone;
  char           *argtwo;
{
  extern char     cmdwork[];
  int             oldowner, newowner;

  if (!iswiz(player))
  {
    notify_player(player, "Someone doesn't want you doing that.\r\n");
    return;
  }
  if (!argone || !*argone || !argtwo || !argtwo)
  {
    notify_player(player, "Usage: @chownall <oldowner> = <newowner>\r\n");
    return;
  }
  if ((oldowner = resolve_player(player, argone, 1)) == -1)
  {
    notify_player(player, "I can't find that person.\r\n");
    return;
  }
  if ((newowner = resolve_player(player, argtwo, 1)) == -1)
  {
    notify_player(player, "I couldn't find the new owner.\r\n");
    return;
  }
  if (oldowner == GOD)
  {
    notify_player(player, "You may not chown all of God's possessions.\r\n");
    return;
  }
  sprintf(cmdwork, "Chowned %d objects to #%d.\r\n", chownall(oldowner, newowner),
	  newowner);
  notify_player(player, cmdwork);
}