act_wiz.c

Go to the documentation of this file.

/***************************************************************************
 *  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
 *  Michael Seifert, Hans Henrik Strfeldt, Tom Madsen, and Katja Nyboe.    *
 *                                                                         *
 *  Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael          *
 *  Chastain, Michael Quan, and Mitchell Tse.                              *
 *                                                                         *
 *  In order to use any part of this Merc Diku Mud, you must comply with   *
 *  both the original Diku license in 'license.doc' as well the Merc       *
 *  license in 'license.txt'.  In particular, you may not remove either of *
 *  these copyright notices.                                               *
 *                                                                         *
 *  Much time and thought has gone into this software and you are          *
 *  benefitting.  We hope that you share your changes too.  What goes      *
 *  around, comes around.                                                  *
 **************************************************************************/

/***************************************************************************
 *   ROM 2.4 is copyright 1993-1998 Russ Taylor                            *
 *   ROM has been brought to you by the ROM consortium                     *
 *       Russ Taylor (rtaylor@hypercube.org)                               *
 *       Gabrielle Taylor (gtaylor@hypercube.org)                          *
 *       Brian Moore (zump@rom.org)                                        *
 *   By using this code, you have agreed to follow the terms of the        *
 *   ROM license, in the file Rom24/doc/rom.license                        *
 **************************************************************************/

/*   QuickMUD - The Lazy Man's ROM - $Id: act_wiz.c,v 1.3 2000/12/01 10:48:33 ring0 Exp $ */

#if defined(macintosh)
#include <types.h>
#include <time.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>                /* For execl in copyover() */
#include "merc.h"
#include "interp.h"
#include "recycle.h"
#include "tables.h"
#include "lookup.h"

/*
 * Stolen from save.c for reading in QuickMUD config stuff
 */
#if defined(KEY)
#undef KEY
#endif

#define KEY( literal, field, value )            \
                if ( !str_cmp( word, literal ) )    \
        {                   \
            field  = value;         \
            fMatch = TRUE;          \
            break;              \
        }

/*
 * Local functions.
 */
ROOM_INDEX_DATA *find_location args ((CHAR_DATA * ch, char *arg));


void do_wiznet (CHAR_DATA * ch, char *argument)
{
    int flag;
    char buf[MAX_STRING_LENGTH];

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->wiznet, WIZ_ON))
        {
            send_to_char ("Signing off of Wiznet.\n\r", ch);
            REMOVE_BIT (ch->wiznet, WIZ_ON);
        }
        else
        {
            send_to_char ("Welcome to Wiznet!\n\r", ch);
            SET_BIT (ch->wiznet, WIZ_ON);
        }
        return;
    }

    if (!str_prefix (argument, "on"))
    {
        send_to_char ("Welcome to Wiznet!\n\r", ch);
        SET_BIT (ch->wiznet, WIZ_ON);
        return;
    }

    if (!str_prefix (argument, "off"))
    {
        send_to_char ("Signing off of Wiznet.\n\r", ch);
        REMOVE_BIT (ch->wiznet, WIZ_ON);
        return;
    }

    /* show wiznet status */
    if (!str_prefix (argument, "status"))
    {
        buf[0] = '\0';

        if (!IS_SET (ch->wiznet, WIZ_ON))
            strcat (buf, "off ");

        for (flag = 0; wiznet_table[flag].name != NULL; flag++)
            if (IS_SET (ch->wiznet, wiznet_table[flag].flag))
            {
                strcat (buf, wiznet_table[flag].name);
                strcat (buf, " ");
            }

        strcat (buf, "\n\r");

        send_to_char ("Wiznet status:\n\r", ch);
        send_to_char (buf, ch);
        return;
    }

    if (!str_prefix (argument, "show"))
        /* list of all wiznet options */
    {
        buf[0] = '\0';
    int col;
    col = 0;
    send_to_char("Wiznet options available for you, are:\n\r",ch);

        for (flag = 0; wiznet_table[flag].name != NULL; flag++)
        {
            if (wiznet_table[flag].level <= get_trust (ch))
            {
                sprintf(buf, "{c%-10s{x[%-7s{x]%-3s{x", wiznet_table[flag].name, IS_SET(ch->wiznet, wiznet_table[flag].flag) ? "{RON{x" : "{DOFF{x", "");
        //strcat (buf, " ");
        send_to_char(buf,ch);
        if (++col % 3 == 0)
            send_to_char("\n\r",ch);
        
        }
        }

 //       send_to_char ("Wiznet options available to you are:\n\r", ch);
//  send_to_char(buf_string(buffer),ch);
        return;
    }

    flag = wiznet_lookup (argument);

    if (flag == -1 || get_trust (ch) < wiznet_table[flag].level)
    {
        send_to_char ("No such option.\n\r", ch);
        return;
    }

    if (IS_SET (ch->wiznet, wiznet_table[flag].flag))
    {
        sprintf (buf, "You will no longer see %s on wiznet.\n\r",
                 wiznet_table[flag].name);
        send_to_char (buf, ch);
        REMOVE_BIT (ch->wiznet, wiznet_table[flag].flag);
        return;
    }
    else
    {
        sprintf (buf, "You will now see %s on wiznet.\n\r",
                 wiznet_table[flag].name);
        send_to_char (buf, ch);
        SET_BIT (ch->wiznet, wiznet_table[flag].flag);
        return;
    }

}

void wiznet (char *string, CHAR_DATA * ch, OBJ_DATA * obj,
             long flag, long flag_skip, int min_level)
{
    DESCRIPTOR_DATA *d;
    if (string == NULL || string[0] == '\0')
        return;

    for (d = descriptor_list; d != NULL; d = d->next)
    {
        if (d->connected == CON_PLAYING && IS_IMMORTAL (d->character)
            && IS_SET (d->character->wiznet, WIZ_ON)
            && (!flag || IS_SET (d->character->wiznet, flag))
            && (!flag_skip || !IS_SET (d->character->wiznet, flag_skip))
            && get_trust (d->character) >= min_level && d->character != ch)
        {
            if (IS_SET (d->character->wiznet, WIZ_PREFIX))
                send_to_char ("{RWIZNET{x ", d->character);
            else
                send_to_char ("{x", d->character);
            act_new (string, d->character, obj, ch, TO_CHAR, POS_DEAD);
            send_to_char ("{x", d->character);
        }
    }

    return;
}
void do_gstat (CHAR_DATA *ch, char *argument)
{
    extern unsigned long int r_count;
    extern unsigned long int s_count;
    extern unsigned long int m_count;
    extern unsigned long int o_count;
    extern unsigned long int reset_count;
    extern unsigned long int h_count;
    extern unsigned long int so_count;
    extern unsigned long int v_count;

    send_to_char("{cGame Stats:\n\r-------------------------{x\n\r",ch);
    printf_to_char(ch, "{cRooms    {R[{c%d{R]{x\n\r",r_count);
    printf_to_char(ch, "{cMobs     {R[{c%d{R]{x\n\r", m_count);
    printf_to_char(ch, "{cObjects  {R[{c%d{R]{x\n\r",o_count);
    printf_to_char(ch, "{cResets   {R[{c%d{R]{x\n\r",reset_count);
    printf_to_char(ch, "{cShops    {R[{c%d{R]{x\n\r",s_count);
    printf_to_char(ch, "{cHelps    {R[{c%d{R]{x\n\r", h_count);
    printf_to_char(ch, "{cSocials  {R[{c%d{R]{x\n\r", so_count);
    printf_to_char(ch, "{cVehicles {R[{c%d{R]{x\n\r",v_count);
    send_to_char("{c-------------------------{x\n\r",ch);
    return;
}


/* lag a player :) */
void do_lag (CHAR_DATA *ch, char *argument)
{
    
    CHAR_DATA *victim;
    char arg1[MAX_STRING_LENGTH]; /* overkill!*/

    argument = one_argument(argument, arg1);

    if (argument[0] == '\0' || arg1 == '\0')
    {
        send_to_char("Lag <who> <harshness>\n\r",ch);
        return;
    }

    if ((victim = get_char_world(ch, arg1)) == NULL)
    {
        send_to_char("They arn't here.\n\r",ch);
        return;
    }

    if (victim == ch)
    {
        send_to_char("Now why on earth would you lag yourself?\n\r",ch);
        return;
    }
    if (victim->level >= ch->level)
    {
        send_to_char ("That isn't right! You know that gets logged, right?\n\r",ch);
        return;
    }


    if (!is_number(argument))
    {
        send_to_char("<hardness> must be a number.\n\r",ch);
        return;
    }

    if (atoi(argument) > 50)
    {
        send_to_char ("Thats a little much, don't you think?\n\r",ch);
        return;
    }

    send_to_char("AIEEEEEE!!! The lag monster has attacked you!\n\r",victim);
    WAIT_STATE (victim, atoi(argument));
    send_to_char("You are really mean, you know that, right?\n\r",ch);
    return;
}
/* Set an immtitle */
void do_immtitle (CHAR_DATA *ch, char * argument)
{
    CHAR_DATA *victim;
    char arg[MAX_STRING_LENGTH];
    char buf[MAX_STRING_LENGTH];
    
    argument = one_argument(argument, arg);

    if (arg[0] == '\0' || argument[0] == '\0')
    {
        send_to_char("Syntax: immtitle <person> <title>\n\r",ch);
        return;
    }

    if ((victim = get_char_world(ch, arg)) == NULL)
    {
        send_to_char("They are currently not playing.\n\r",ch);
        return;
    }
    if (IS_NPC(victim))
    {
        send_to_char("Not on NPCs!\n\r",ch);
        return;
    }
    if (victim->level < LEVEL_IMMORTAL)
    {
        sprintf(buf, "%s must be atleast level %d\n\r", victim->name, LEVEL_IMMORTAL);
        send_to_char(buf,ch);
        return;
    }
    victim->pcdata->imm_title = NULL;
    victim->pcdata->imm_title = str_dup(argument);
    if (victim == ch)
    {
        sprintf(buf, "Your immtitle has been set to %s.\n\r", str_dup(argument));
        send_to_char(buf, ch);
        return;
    }
    else
    {
        sprintf(buf, "%s's immtitle has been set to %s.\n\r", victim->name, str_dup(argument));
        send_to_char(buf,ch);
        sprintf(buf, "Your immtitle has been set to %s.\n\r", str_dup(argument));
        send_to_char(buf,victim);
        return;
    }
    send_to_char("Error.\n\r",ch);
    return;
}

    
/* Set a player's look stuff */
void do_cset (CHAR_DATA *ch, char *argument)
{
    CHAR_DATA *victim;
    char arg[MAX_STRING_LENGTH];
    char arg2[MAX_STRING_LENGTH];
    char buf[MAX_STRING_LENGTH];
    bool same;
    same = FALSE;  /* to shut the compiler the hell up! */
    
    argument = one_argument(argument, arg);
    argument = one_argument(argument, arg2);

    if (arg[0] == '\0' || arg2[0] == '\0' || argument[0] == '\0')
    {
        send_to_char("Syntax - cset <person> <field> <info>\n\r"
                "Field - eyes, hairlength, hairtype, haircolor, bodytype, facialhair\n\r",ch);
        return;
    }
    if ((victim = get_char_world(ch, arg)) == NULL)
    {
        send_to_char("They are currently not playing.\n\r",ch);
        return;
    }
    if (IS_NPC(victim))
    {
        send_to_char("Not on NPCs!\n\r",ch);
        return;
    }
    if (victim == ch)
        same = TRUE;
    
    /*if (str_prefix(arg2, "eyes") || str_prefix(arg2, "hairlength") 
            || str_prefix(arg2, "hairtype") || str_prefix(arg2, "haircolor")
            || str_prefix(arg2, "bodytype") || str_prefix(arg2, "facialhair"))
    {
        send_to_char("Invalid field. Valid fields:\n\r"
                "eyes, hairlength, hairtype, haircolor, bodytype, facialhair\n\r",ch);
        return;
    }
    */
    if (!str_prefix(arg2, "eyes"))
    {
        free_string(victim->pcdata->eyecolor);
        victim->pcdata->eyecolor = str_dup(argument);
        if (!same)
        {
            sprintf(buf, "%s's eye color set to %s\n\r", victim->name, argument);
            send_to_char(buf,ch);
        }
        sprintf(buf, "Your eye color has been set to %s\n\r", argument);
        send_to_char(buf,victim);
        return;
    
    }
    if (!str_prefix(arg2, "hairlength"))
    {
        free_string(victim->pcdata->hairlength);
        victim->pcdata->hairlength = str_dup(argument);
        if (!same)
        {
            sprintf(buf, "%s's hairlength has been set to %s\n\r", victim->name, argument);
            send_to_char(buf,ch);
        }
        sprintf(buf, "Your hair length has been set to %s\n\r",argument);
        send_to_char(buf,victim);
        return;
    }
    if (!str_prefix(arg2, "hairtype"))
    {
        free_string(victim->pcdata->hairtype);
        victim->pcdata->hairtype = str_dup(argument);
        if (!same)
        {
            sprintf(buf, "%s's hair type set to %s\n\r", victim->name, argument);
            send_to_char(buf,ch);
        }
        sprintf(buf, "Your hair type has been set to %s\n\r",argument);
        send_to_char(buf,victim);
        return;
    }
    if (!str_prefix(arg2, "haircolor"))
    {
        free_string(victim->pcdata->haircolor);
        victim->pcdata->haircolor = str_dup(argument);
        if (!same)
        {
            sprintf(buf, "%s's hair color set to %s\n\r", victim->name, argument);
            send_to_char(buf,ch);
        }
        
        sprintf(buf, "Your hair color has been set to %s\n\r", argument);
        send_to_char(buf, victim);
        return;
    }
    if (!str_prefix(arg2, "bodytype"))
    {
        free_string(victim->pcdata->bodytype);
        victim->pcdata->bodytype = str_dup(argument);
        if (!same)
        {
            sprintf(buf, "%s's body type set to %s\n\r", victim->name, argument);
            send_to_char(buf,ch);
        }
        
        sprintf(buf, "Your boy type set to %s\n\r", argument);
        send_to_char(buf, victim);
        return;
    }
    if (!str_prefix(arg2, "facialhair"))
    {
        free_string(victim->pcdata->facialhair);
        victim->pcdata->facialhair = str_dup(argument);
        if (!same)
        {
            sprintf(buf, "%s's facial hair set to %s\n\r", victim->name, argument);
            send_to_char(buf,ch);
        }
        sprintf(buf, "Your facial hair set to %s\n\r", argument);
        send_to_char(buf, victim);
        return;
    }
    send_to_char("Invalid Field.\n\r",ch);
    return;
}

        


/*
void do_nogoto (CHAR_DATA *ch, char *argument)
{
    if (argument[0] == '\0')
    {
        if (IS_SET(ch->chann,WIZ_NOGOTO))
        {
            send_to_char("You are now allow people to 'goto' you.\n\r",ch);
            REMOVE_BIT(ch->chann, WIZ_NOGOTO);
        }
        else
        {
            send_to_char ("You will no longer be able to 'goto' to.\n\r", ch);
            SET_BIT (ch->chann, WIZ_NOGOTO);
        }
        return;
    }
    REMOVE_BIT (ch->chann, WIZ_NOGOTO);
    return;
}
*/


void do_notrans (CHAR_DATA *ch, char *argument)
{
//DESCRIPTOR_DATA *d;

//char arg1[MAX_INPUT_LENGTH];
//char arg2[MAX_INPUT_LENGTH];
//ROOM_INDEX_DATA *location;
//DESCRIPTOR_DATA *d;
CHAR_DATA *victim;
//argument = one_argument (argument, arg1);
//argument = one_argument (argument, arg2);
//if (argument[0] == '\0')
  //  {
  if (argument[0] == '\0')
  {  

    if (IS_SET (ch->comm, WIZ_NOTRANS))
        {
            send_to_char ("You are now able to be transed from other IMMs.\n\r", ch);
            REMOVE_BIT (ch->comm, WIZ_NOTRANS);
        }
        else
        {
            send_to_char ("You will no longer be able to be transed from IMMs.\n\r", ch);
            SET_BIT (ch->comm, WIZ_NOTRANS);
        }
        return;
    }
  
  
//  if((victim = get_char_world(ch,argument)) == NULL)
    if((victim = get_char_world (ch, argument)) == NULL)
    {
        send_to_char("they arn't here.\n\r",ch);
        return;
    }
    
        if(ch->level < 60)
        {
            send_to_char ("Invalid use.\n\r",ch);
        return;
        }
    
        if(IS_SET(victim->comm, WIZ_NOTRANS))
        {
            send_to_char("Their notrans bit has been removed.\n\r",ch);
            REMOVE_BIT(victim->comm, WIZ_NOTRANS);
            return;
        }
        if (!IS_SET(victim->comm, WIZ_NOTRANS))
        {
            send_to_char("They are currently able to be transed. Bit not removed. \n\r",ch);
            return;
        }
  



        
   
 // REMOVE_BIT (ch->comm, WIZ_NOTRANS);
return;
}    

void do_kcshow (CHAR_DATA *ch, char *argument)
{
    BUFFER *buffer;
    char buf[MAX_STRING_LENGTH];
    int runner,col=0;
    buffer = new_buf();
    add_buf(buffer, "\n\r{xKingdoms:{x\n\r");

    for (runner = 1; runner < MAX_KINGDOM; runner++)
    {
        
        sprintf(buf, "{c%-2d{x) {W%-15.15s{x", runner, kingdom_table[runner].name);
        add_buf(buffer, buf);
        if (++col % 3 == 0)
            add_buf(buffer, "\n\r");
    }
    add_buf(buffer, "\n\r{xClans:\n\r");
    col=0;
    for (runner = 1; runner < MAX_CLAN; runner++)
    {
        sprintf(buf, "{c%-2d{x) {W%-15.15s{x", runner, clan_table[runner].name);
        add_buf(buffer, buf);
        if (++col % 3 == 0)
            add_buf(buffer, "\n\r");
    }
    page_to_char(buf_string(buffer), ch);
    free_buf(buffer);
    return;
}




void do_port (CHAR_DATA *ch, char *argument)
{
    if (IS_SET (ch->pcdata->immortal, IMMORTAL_PORT))
    {
        send_to_char("You will no longer see the port in your prompt.\n\r",ch);
        REMOVE_BIT(ch->pcdata->immortal, IMMORTAL_PORT);
        return;
    }
    send_to_char("You will now see the port in your prompt.\n\r",ch);
    SET_BIT(ch->pcdata->immortal, IMMORTAL_PORT);
    return;
}



void show_classes (CHAR_DATA *ch, char *argument)
{
    char buf[MSL];
    BUFFER *buffer;
    int runner=0;
    int col=0;

    buffer=new_buf();

    add_buf(buffer, "\n\r{xClasses:{x\n\r");

    for (runner=0;runner < MAX_CLASS;runner++)
    {
        sprintf(buf, "{x[{c%-3d{x] {W%-10s{x ", runner, class_table[runner].name);
        add_buf(buffer,buf);
        if (++col % 4 == 0)
            add_buf(buffer, "\n\r");
    }

    page_to_char(buf_string(buffer),ch);
}

    

void do_cshow (CHAR_DATA *ch, char *argument)
{
    BUFFER *buffer;
    char buf[MAX_STRING_LENGTH];
    int runner,col=0;
    buffer = new_buf();
    add_buf(buffer, "\n\r{xContinents:{x\n\r");

    for (runner =1;runner < MAX_CONT; runner++)
    {
        sprintf(buf, "{c%-2d{x) {W%-15.15s{x", runner, conts_table[runner].name);
        add_buf(buffer,buf);
        if (++col % 2 == 0)
            add_buf(buffer, "\n\r");
    }
    add_buf(buffer, "\n\r");
    page_to_char(buf_string(buffer),ch);
    free_buf(buffer);
    return;
}

        
    

    

    

    void do_show_skill(CHAR_DATA *ch, char *argument)
    {
        BUFFER *buf;
        char buf2[MAX_STRING_LENGTH];
        char buf3[MAX_STRING_LENGTH];
        int i,result=0;
        int class,rCol=0;
        if (argument[0] == '\0')
        {
            send_to_char("Syntax - Showskill <class>\n\r",ch);
            return;
        }
        if ((class = class_lookup(argument)) == -1)
        {
            send_to_char("That is not a valid class.\n\r",ch);
            return;
        }
        
        buf = new_buf();
        for (i = 0; i < MAX_SKILL; i++)
        {
            if (skill_table[i].name == NULL)
                break;
            sprintf(buf2, "{C%s{x - {R%-15.15s{x level[{c%-2d{x] ", class_table[class].name, skill_table[i].name,
                    skill_table[i].skill_level[class]);
            if (++rCol % 2 == 0)
                strcat(buf2, "\n\r");
            
        add_buf(buf, buf2);
        result ++;
            
            
        }
        sprintf(buf3, "%d skills/spells found.\n\r", result);

        add_buf(buf, buf3);
        page_to_char(buf_string(buf),ch);
        free_buf(buf);
        //free_string(buf2);
        //free_string(buf3);
        /*for (fleh = 0 ; fleh < 100 ; fleh++)
        {
            sprintf (buf2, "\e[1;47r %d", fleh);
            send_to_char(buf2,ch);
        }*/

        return;
    }
    void null_class (CHAR_DATA *ch, char *argument)
    {
    //  char arg1[MAX_STRING_LENGTH];
        int iClassLookup, i;
    //argument = one_argument(argument, arg1);

        if (argument[0]== '\0')
        {
            send_to_char("Syntax - nullclass <class>\n\r",ch);
            return;
        }
        if ((iClassLookup = class_lookup(argument)) == -1)
        {
            send_to_char("That is not a valid class.\n\r",ch);
            return;
        }
        for (i = 0; i < MAX_SKILL; i++)
        {
            if (skill_table[i].name == NULL)
                break;
            skill_table[i].skill_level[iClassLookup] = 52;
        }
            do_function(ch,do_save_class,"");

        do_function(ch, do_show_skill, class_table[iClassLookup].name);
    
    return;
}

    


void do_pload( CHAR_DATA *ch, char *argument )
{
  DESCRIPTOR_DATA d;
  bool isChar = FALSE;
  char name[MAX_INPUT_LENGTH];

  if (argument[0] == '\0')
  {
    send_to_char("Load who?\n\r", ch);
    return;
  }

  argument[0] = UPPER(argument[0]);
  argument = one_argument(argument, name);

  /* Dont want to load a second copy of a player who's allready online! */
  if ( get_char_world( ch, name ) != NULL )
  {
    send_to_char( "That person is allready connected!\n\r", ch );
    return;
  }

  isChar = load_char_obj(&d, name); /* char pfile exists? */

  if (!isChar)
  {
    send_to_char("Load Who? Are you sure? I cant seem to find them.\n\r", ch);
    return;
  }

  d.character->desc     = NULL;
  d.character->next     = char_list;
  char_list             = d.character;
  d.connected           = CON_PLAYING;
  reset_char(d.character);

  /* bring player to imm */
  if ( d.character->in_room != NULL )
  {
    char_to_room( d.character, ch->in_room); /* put in room imm is in */
  }

  act( "$n has pulled $N from the pattern!",
        ch, NULL, d.character, TO_ROOM );

  if (d.character->pet != NULL)
   {
     char_to_room(d.character->pet,d.character->in_room);
     act("$n has entered the game.",d.character->pet,NULL,NULL,TO_ROOM);
   }

}

void do_punload( CHAR_DATA *ch, char *argument )
{
  CHAR_DATA *victim;
  char who[MAX_INPUT_LENGTH];

  argument = one_argument(argument, who);

  if ( ( victim = get_char_world( ch, who ) ) == NULL )
  {
    send_to_char( "They aren't here.\n\r", ch );
    return;
  }

  if (victim->desc != NULL)
  {
    send_to_char("I dont think that would be a good idea...\n\r", ch);
    return;
  }

  if (victim->was_in_room != NULL) /* return player and pet to orig room */
  {
    char_to_room(victim, victim->was_in_room);
    if (victim->pet != NULL)
      char_to_room(victim->pet, victim->was_in_room);
  }

  save_char_obj(victim);
  do_quit(victim,"");

  act("$n has released $N back to the Pattern.",
       ch, NULL, victim, TO_ROOM);
}


void do_guild (CHAR_DATA * ch, char *argument)
{
    char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
    char buf[MAX_STRING_LENGTH];
    CHAR_DATA *victim;
    int clan;

    argument = one_argument (argument, arg1);
    argument = one_argument (argument, arg2);

    if (arg1[0] == '\0' || arg2[0] == '\0')
    {
        send_to_char ("Syntax: guild <char> <cln name>\n\r", ch);
        return;
    }
    if ((victim = get_char_world (ch, arg1)) == NULL)
    {
        send_to_char ("They aren't playing.\n\r", ch);
        return;
    }

    if (!str_prefix (arg2, "none"))
    {
        send_to_char ("They are now clanless.\n\r", ch);
        send_to_char ("You are now a member of no clan!\n\r", victim);
        victim->clan = 0;
        REMOVE_BIT (victim->comm, CLAN_LEADER);
    REMOVE_BIT (victim->comm, CLAN_REC);

    return;
    }

    if ((clan = clan_lookup (arg2)) == 0)
    {
        send_to_char ("No such clan exists.\n\r", ch);
        return;
    }

    if (clan_table[clan].independent)
    {
        sprintf (buf, "They are now a %s.\n\r", clan_table[clan].name);
        send_to_char (buf, ch);
        sprintf (buf, "You are now a %s.\n\r", clan_table[clan].name);
        send_to_char (buf, victim);
    }
    else
    {
        sprintf (buf, "They are now a member of clan %s.\n\r",
                 capitalize (clan_table[clan].name));
        send_to_char (buf, ch);
        sprintf (buf, "You are now a member of clan %s.\n\r",
                 capitalize (clan_table[clan].name));
    }

    victim->clan = clan;
}

/* equips a character */
void do_outfit (CHAR_DATA * ch, char *argument)
{
    OBJ_DATA *obj;
    int i, sn, vnum;

    if (ch->level > 5 || IS_NPC (ch))
    {
        send_to_char ("Find it yourself!\n\r", ch);
        return;
    }

    if ((obj = get_eq_char (ch, WEAR_LIGHT)) == NULL)
    {
        obj = create_object (get_obj_index (OBJ_VNUM_SCHOOL_BANNER), 0);
        obj->cost = 0;
        obj_to_char (obj, ch);
        equip_char (ch, obj, WEAR_LIGHT);
    }

    if ((obj = get_eq_char (ch, WEAR_BODY)) == NULL)
    {
        obj = create_object (get_obj_index (OBJ_VNUM_SCHOOL_VEST), 0);
        obj->cost = 0;
        obj_to_char (obj, ch);
        equip_char (ch, obj, WEAR_BODY);
    }

    /* do the weapon thing */
    if ((obj = get_eq_char (ch, WEAR_WIELD)) == NULL)
    {
        sn = 0;
        vnum = OBJ_VNUM_SCHOOL_SWORD;    /* just in case! */

        for (i = 0; weapon_table[i].name != NULL; i++)
        {
            if (ch->pcdata->learned[sn] <
                ch->pcdata->learned[*weapon_table[i].gsn])
            {
                sn = *weapon_table[i].gsn;
                vnum = weapon_table[i].vnum;
            }
        }

        obj = create_object (get_obj_index (vnum), 0);
        obj_to_char (obj, ch);
        equip_char (ch, obj, WEAR_WIELD);
    }

    if (((obj = get_eq_char (ch, WEAR_WIELD)) == NULL
         || !IS_WEAPON_STAT (obj, WEAPON_TWO_HANDS))
        && (obj = get_eq_char (ch, WEAR_SHIELD)) == NULL)
    {
        obj = create_object (get_obj_index (OBJ_VNUM_SCHOOL_SHIELD), 0);
        obj->cost = 0;
        obj_to_char (obj, ch);
        equip_char (ch, obj, WEAR_SHIELD);
    }

    send_to_char ("You have been equipped by the Gods.\n\r", ch);
}


/* RT nochannels command, for those spammers */
void do_nochannels (CHAR_DATA * ch, char *argument)
{
    char arg[MAX_INPUT_LENGTH], buf[MAX_STRING_LENGTH];
    CHAR_DATA *victim;

    one_argument (argument, arg);

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

    if ((victim = get_char_world (ch, arg)) == NULL)
    {
        send_to_char ("They aren't here.\n\r", ch);
        return;
    }

    if (get_trust (victim) >= get_trust (ch))
    {
        send_to_char ("You failed.\n\r", ch);
        return;
    }

    if (IS_SET (victim->comm, COMM_NOCHANNELS))
    {
        REMOVE_BIT (victim->comm, COMM_NOCHANNELS);
        send_to_char ("The gods have restored your channel priviliges.\n\r",
                      victim);
        send_to_char ("NOCHANNELS removed.\n\r", ch);
        sprintf (buf, "$N restores channels to %s", victim->name);
        wiznet (buf, ch, NULL, WIZ_PENALTIES, WIZ_SECURE, 0);
    }
    else
    {
        SET_BIT (victim->comm, COMM_NOCHANNELS);
        send_to_char ("The gods have revoked your channel priviliges.\n\r",
                      victim);
        send_to_char ("NOCHANNELS set.\n\r", ch);
        sprintf (buf, "$N revokes %s's channels.", victim->name);
        wiznet (buf, ch, NULL, WIZ_PENALTIES, WIZ_SECURE, 0);
    }

    return;
}


void do_smote (CHAR_DATA * ch, char *argument)
{
    CHAR_DATA *vch;
    char *letter, *name;
    char last[MAX_INPUT_LENGTH], temp[MAX_STRING_LENGTH];
    int matches = 0;

    if (!IS_NPC (ch) && IS_SET (ch->comm, COMM_NOEMOTE))
    {
        send_to_char ("You can't show your emotions.\n\r", ch);
        return;
    }

    if (argument[0] == '\0')
    {
        send_to_char ("Emote what?\n\r", ch);
        return;
    }

    if (strstr (argument, ch->name) == NULL)
    {
        send_to_char ("You must include your name in an smote.\n\r", ch);
        return;
    }

    send_to_char (argument, ch);
    send_to_char ("\n\r", ch);

    for (vch = ch->in_room->people; vch != NULL; vch = vch->next_in_room)
    {
        if (vch->desc == NULL || vch == ch)
            continue;

        if ((letter = strstr (argument, vch->name)) == NULL)
        {
            send_to_char (argument, vch);
            send_to_char ("\n\r", vch);
            continue;
        }

        strcpy (temp, argument);
        temp[strlen (argument) - strlen (letter)] = '\0';
        last[0] = '\0';
        name = vch->name;

        for (; *letter != '\0'; letter++)
        {
            if (*letter == '\'' && matches == strlen (vch->name))
            {
                strcat (temp, "r");
                continue;
            }

            if (*letter == 's' && matches == strlen (vch->name))
            {
                matches = 0;
                continue;
            }

            if (matches == strlen (vch->name))
            {
                matches = 0;
            }

            if (*letter == *name)
            {
                matches++;
                name++;
                if (matches == strlen (vch->name))
                {
                    strcat (temp, "you");
                    last[0] = '\0';
                    name = vch->name;
                    continue;
                }
                strncat (last, letter, 1);
                continue;
            }

            matches = 0;
            strcat (temp, last);
            strncat (temp, letter, 1);
            last[0] = '\0';
            name = vch->name;
        }

        send_to_char (temp, vch);
        send_to_char ("\n\r", vch);
    }

    return;
}

void do_bamfin (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];

    if (!IS_NPC (ch))
    {
        smash_tilde (argument);

        if (argument[0] == '\0')
        {
            sprintf (buf, "Your poofin is %s\n\r", ch->pcdata->bamfin);
            send_to_char (buf, ch);
            return;
        }

        if (strstr (argument, ch->name) == NULL)
        {
            send_to_char ("You must include your name.\n\r", ch);
            return;
        }

        free_string (ch->pcdata->bamfin);
        ch->pcdata->bamfin = str_dup (argument);

        sprintf (buf, "Your poofin is now %s\n\r", ch->pcdata->bamfin);
        send_to_char (buf, ch);
    }
    return;
}

void do_bamfout (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];

    if (!IS_NPC (ch))
    {
        smash_tilde (argument);

        if (argument[0] == '\0')
        {
            sprintf (buf, "Your poofout is %s\n\r", ch->pcdata->bamfout);
            send_to_char (buf, ch);
            return;
        }

        if (strstr (argument, ch->name) == NULL)
        {
            send_to_char ("You must include your name.\n\r", ch);
            return;
        }

        free_string (ch->pcdata->bamfout);
        ch->pcdata->bamfout = str_dup (argument);

        sprintf (buf, "Your poofout is now %s\n\r", ch->pcdata->bamfout);
        send_to_char (buf, ch);
    }
    return;
}



void do_deny (CHAR_DATA * ch, char *argument)
{
    char arg[MAX_INPUT_LENGTH], buf[MAX_STRING_LENGTH];
    CHAR_DATA *victim;
if (ch->level < 59)
{
send_to_char("Only imps can perform this function.\n\r",ch);
return;
}

    one_argument (argument, arg);
    if (arg[0] == '\0')
    {
        send_to_char ("Deny 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_NPC (victim))
    {
        send_to_char ("Not on NPC's.\n\r", ch);
        return;
    }

    if (get_trust (victim) >= get_trust (ch))
    {
        send_to_char ("You failed.\n\r", ch);
        return;
    }

    SET_BIT (victim->act, PLR_DENY);
    send_to_char ("You are denied access!\n\r", victim);
    sprintf (buf, "$N denies access to %s", victim->name);
    wiznet (buf, ch, NULL, WIZ_PENALTIES, WIZ_SECURE, 0);
    send_to_char ("OK.\n\r", ch);
    save_char_obj (victim);
    stop_fighting (victim, TRUE);
    do_function (victim, &do_quit, "");

    return;
}



void do_disconnect (CHAR_DATA * ch, char *argument)
{
    char arg[MAX_INPUT_LENGTH];
    DESCRIPTOR_DATA *d;
    CHAR_DATA *victim;

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

    if (is_number (arg))
    {
        int desc;

        desc = atoi (arg);
        for (d = descriptor_list; d != NULL; d = d->next)
        {
            if (d->descriptor == desc)
            {
                close_socket (d);
                send_to_char ("Ok.\n\r", ch);
                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("Do not disconnect yourself...\n\r",ch);
        return;
    }

    if (victim->desc == NULL)
    {
        act ("$N doesn't have a descriptor.", ch, NULL, victim, TO_CHAR);
        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;
        }
    }

    bug ("Do_disconnect: desc not found.", 0);
    send_to_char ("Descriptor not found!\n\r", ch);
    return;
}

void do_asleep(CHAR_DATA *ch, char *argument)
{
    if (IS_SET(ch->sleep, BTS_SLEEP))
    {
        send_to_char ("Sleep status removed.\n\r",ch);
        REMOVE_BIT (ch->sleep, BTS_SLEEP);
        return;
    }
    if (!IS_SET(ch->sleep, BTS_SLEEP))
    {
        send_to_char("Sweet dreams...\n\r",ch);
        SET_BIT(ch->sleep, BTS_SLEEP);
        return;
    }
}

void do_pardon (CHAR_DATA * ch, char *argument)
{
    char arg1[MAX_INPUT_LENGTH];
    char arg2[MAX_INPUT_LENGTH];
    CHAR_DATA *victim;

    argument = one_argument (argument, arg1);
    argument = one_argument (argument, arg2);

    if (arg1[0] == '\0' || arg2[0] == '\0')
    {
        send_to_char ("Syntax: pardon <character> <killer|thief>.\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_NPC (victim))
    {
        send_to_char ("Not on NPC's.\n\r", ch);
        return;
    }

    if (!str_cmp (arg2, "killer"))
    {
        if (IS_SET (victim->act, PLR_KILLER))
        {
            REMOVE_BIT (victim->act, PLR_KILLER);
            send_to_char ("Killer flag removed.\n\r", ch);
            send_to_char ("You are no longer a KILLER.\n\r", victim);
        }
        return;
    }

    if (!str_cmp (arg2, "thief"))
    {
        if (IS_SET (victim->act, PLR_THIEF))
        {
            REMOVE_BIT (victim->act, PLR_THIEF);
            send_to_char ("Thief flag removed.\n\r", ch);
            send_to_char ("You are no longer a THIEF.\n\r", victim);
        }
        return;
    }

    send_to_char ("Syntax: pardon <character> <killer|thief>.\n\r", ch);
    return;
}



void do_echo (CHAR_DATA * ch, char *argument)
{
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        send_to_char ("Global echo what?\n\r", ch);
        return;
    }

    for (d = descriptor_list; d; d = d->next)
    {
        if (d->connected == CON_PLAYING)
        {
            if (get_trust (d->character) >= get_trust (ch))
                send_to_char ("global> ", d->character);
            send_to_char (argument, d->character);
            send_to_char ("\n\r", d->character);
        }
    }

    return;
}



void do_recho (CHAR_DATA * ch, char *argument)
{
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        send_to_char ("Local echo 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)
        {
            if (get_trust (d->character) >= get_trust (ch))
                send_to_char ("local> ", d->character);
            send_to_char (argument, d->character);
            send_to_char ("\n\r", d->character);
        }
    }

    return;
}

void do_zecho (CHAR_DATA * ch, char *argument)
{
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        send_to_char ("Zone echo what?\n\r", ch);
        return;
    }

    for (d = descriptor_list; d; d = d->next)
    {
        if (d->connected == CON_PLAYING
            && d->character->in_room != NULL && ch->in_room != NULL
            && d->character->in_room->area == ch->in_room->area)
        {
            if (get_trust (d->character) >= get_trust (ch))
                send_to_char ("zone> ", d->character);
            send_to_char (argument, d->character);
            send_to_char ("\n\r", d->character);
        }
    }
}

void do_pecho (CHAR_DATA * ch, char *argument)
{
    char arg[MAX_INPUT_LENGTH];
    CHAR_DATA *victim;

    argument = one_argument (argument, arg);

    if (argument[0] == '\0' || arg[0] == '\0')
    {
        send_to_char ("Personal echo what?\n\r", ch);
        return;
    }

    if ((victim = get_char_world (ch, arg)) == NULL)
    {
        send_to_char ("Target not found.\n\r", ch);
        return;
    }

    if (get_trust (victim) >= get_trust (ch) && get_trust (ch) != MAX_LEVEL)
        send_to_char ("personal> ", victim);

    send_to_char (argument, victim);
    send_to_char ("\n\r", victim);
    send_to_char ("personal> ", ch);
    send_to_char (argument, ch);
    send_to_char ("\n\r", ch);
}


ROOM_INDEX_DATA *find_location (CHAR_DATA * ch, char *arg)
{
    CHAR_DATA *victim;
    OBJ_DATA *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 *argument)
{
    char arg1[MAX_INPUT_LENGTH];
    char arg2[MAX_INPUT_LENGTH];
    ROOM_INDEX_DATA *location;
    DESCRIPTOR_DATA *d;
    CHAR_DATA *victim;
    CHAR_DATA *victim2;
  //  CHAR_DATA *vch;
    //CHAR_DATA *vch_next;

    argument = one_argument (argument, arg1);
    argument = one_argument (argument, arg2);

    if (arg1[0] == '\0')
    {
        send_to_char ("Transfer whom (and where)?\n\r", ch);
        return;
    }
/*
    if (!str_cmp (arg1, "sall"))
    {
        char buf2[MSL];
        for (vch = char_list; vch != NULL; vch = vch_next)
        {
            vch_next = vch->next;
            sprintf (buf2, "%s %s", vch->name, arg2);
            do_transfer(ch, buf2);
        }
        return;
    }

*/      
    if (!str_cmp (arg1, "all"))
    {
        for (d = descriptor_list; d != NULL; d = d->next)
        {
            if (d->connected == CON_PLAYING
                && d->character != ch
                && d->character->in_room != NULL
                && can_see (ch, d->character)/*&& d->character->comm != WIZ_NOTRANS*/)
            {
                char buf[MAX_STRING_LENGTH];
                sprintf (buf, "%s %s", d->character->name, arg2);
                do_function (ch, &do_transfer, buf);
            }
        }
        return;
    }

    /*
     * Thanks to Grodyn for the optional location parameter.
     */
    if (arg2[0] == '\0')
    {
        location = ch->in_room;
    }
    
    if ((victim2 = get_char_world(ch, arg2)) !=NULL)
    {
        if (!IS_NPC(victim2))
        {
            if (IS_SET(victim2->comm, WIZ_NOTRANS))
            {
                send_to_char("That person is not available for trans at the moment.\n\r",ch);
                return;
            }
        }
    }
    if (arg2[0] == '\0')
    {
        location = ch->in_room;
    }
    else
    {
        if ((location = find_location (ch, arg2)) == NULL)
        {
            send_to_char ("No such location.\n\r", ch);
            return;
        }

        if (!is_room_owner (ch, location) && room_is_private (location)
            && get_trust (ch) < MAX_LEVEL)
        {
            send_to_char ("That room is private right now.\n\r", ch);
            return;
        }
    }

    if ((victim = get_char_world (ch, arg1)) == NULL)
    {
        send_to_char ("They aren't here.\n\r", ch);
        return;
    }

    if (victim->in_room == NULL)
    {
        send_to_char ("They are in limbo.\n\r", ch);
        return;
    }

   if (!IS_NPC(victim) && IS_SET(victim->comm, WIZ_NOTRANS))
   {
       send_to_char("This person is not avaiable for transfer at the moment.\n\r",ch);
      return;
    } 
   if (victim->fighting != NULL)
        stop_fighting (victim, TRUE);
    act ("$n disappears in a mushroom cloud.", victim, NULL, NULL, TO_ROOM);
    char_from_room (victim);
    char_to_room (victim, location);
    act ("$n arrives from a puff of smoke.", victim, NULL, NULL, TO_ROOM);
    if (ch != victim)
        act ("$n has transferred you.", ch, NULL, victim, TO_VICT);
    do_function (victim, &do_look, "auto");
    send_to_char ("Ok.\n\r", ch);
}


void do_at (CHAR_DATA * ch, char *argument)
{
    char arg[MAX_INPUT_LENGTH];
    ROOM_INDEX_DATA *location;
    ROOM_INDEX_DATA *original;
    OBJ_DATA *on;
    CHAR_DATA *wch;

    argument = one_argument (argument, arg);

 //  if (ch->level < 60)
   // {
//      send_to_char("You are not high enough level to do this.\n\r",ch);
//      return;
  //  }

    if (arg[0] == '\0' || argument[0] == '\0')
    {
        send_to_char ("At where what?\n\r", ch);
        return;
    }

    if ((location = find_location (ch, arg)) == NULL)
    {
        send_to_char ("No such location.\n\r", ch);
        return;
    }

    if (!is_room_owner (ch, location) && room_is_private (location)
        && get_trust (ch) < MAX_LEVEL)
    {
        send_to_char ("That room is private right now.\n\r", ch);
        return;
    }

    original = ch->in_room;
    on = ch->on;
    char_from_room (ch);
    char_to_room (ch, location);
    interpret (ch, argument);

    /*
     * See if 'ch' still exists before continuing!
     * Handles 'at XXXX quit' case.
     */
    for (wch = char_list; wch != NULL; wch = wch->next)
    {
        if (wch == ch)
        {
            char_from_room (ch);
            char_to_room (ch, original);
            ch->on = on;
            break;
        }
    }

    return;
}



void do_goto (CHAR_DATA * ch, char *argument)
{
    ROOM_INDEX_DATA *location;
    CHAR_DATA *rch;
    CHAR_DATA *victim;
    int count = 0;

    if (argument < 0)
    {
        send_to_char("Yea.....right. Actually think there are negative vnums? pfft.\n\r",ch);
        return;
    }

    if (argument[0] == '\0')
    {
        send_to_char ("Goto where?\n\r", ch);
        return;
    }
    if ((victim = get_char_world(ch, argument))  != NULL)
    {
        /*    if (!IS_NPC(victim) && IS_SET(victim->chann, WIZ_NOGOTO))
        {
            send_to_char("Leave them alone.\n\r",ch);
            return;
        }*/
    }
    if ((location = find_location (ch, argument)) == NULL)
    {
        send_to_char ("No such location.\n\r", ch);
        return;
    }
   
   
        
    count = 0;
    for (rch = location->people; rch != NULL; rch = rch->next_in_room)
        count++;

    if (victim == ch)
    {
        send_to_char("You'll implode!\n\r",ch);
        return;
    }

    if (!is_room_owner (ch, location) && room_is_private (location)
        && (count > 1 || get_trust (ch) < MAX_LEVEL))
    {
        send_to_char ("That room is private right now.\n\r", ch);
        return;
    }