act_comm.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_comm.c,v 1.2 2000/12/01 10:48:33 ring0 Exp $ */

#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include "merc.h"
#include "interp.h"
#include "recycle.h"
#include "tables.h"
#include <ctype.h> /* for isalpha() and isspace() -- JR */

/* RT code to delete yourself */

void do_delet (CHAR_DATA * ch, char *argument)
{
    send_to_char ("You must type the full command to delete yourself.\n\r",
                  ch);
}

void do_delete (CHAR_DATA * ch, char *argument)
{
    char strsave[MAX_INPUT_LENGTH];

    if (IS_NPC (ch))
        return;

    if (ch->pcdata->confirm_delete)
    {
        if (argument[0] != '\0')
        {
            send_to_char ("Delete status removed.\n\r", ch);
            ch->pcdata->confirm_delete = FALSE;
            return;
        }
        else
        {
            sprintf (strsave, "%s%s", PLAYER_DIR, capitalize (ch->name));
            wiznet ("$N turns $Mself into line noise.", ch, NULL, 0, 0, 0);
            stop_fighting (ch, TRUE);
            do_function (ch, &do_quit, "");
            unlink (strsave);
            return;
        }
    }

    if (argument[0] != '\0')
    {
        send_to_char ("Just type delete. No argument.\n\r", ch);
        return;
    }

    send_to_char ("Type delete again to confirm this command.\n\r", ch);
    send_to_char ("WARNING: this command is irreversible.\n\r", ch);
    send_to_char
        ("Typing delete with an argument will undo delete status.\n\r", ch);
    ch->pcdata->confirm_delete = TRUE;
    wiznet ("$N is contemplating deletion.", ch, NULL, 0, 0, get_trust (ch));
}

/* Trib do_permit -- Permit a player to preform certain things. */
/* TODO improve this code. Perhaps get rid of using CHAR_DATA
 * and using some sort of string based function. CHAR_DATA 100 times
 * uses alot of memory in doing so. XXX possible memory leaks. */
void do_permit (CHAR_DATA *ch, char *argument)
{
    CHAR_DATA *victim;
    BUFFER *buf;
    char buffer[MSL];
    int pChar=0; /* stop stupid compiler warnings */
    buf = new_buf();
    bool found;
    bool permit_full;
    int col=0;
    int pChar2=0;

    if (argument[0] == '\0')
    {
        send_to_char("The following people have your permission\n\r",ch);
        send_to_char("-----------------------------------------\n\r",ch);

        for (pChar = 0; pChar < MAX_PERMIT; pChar++)
        {
            if (ch->permit[pChar] == NULL)
                continue;
            sprintf(buffer, "{c%-10s{x ", ch->permit[pChar]->name);
            add_buf(buf, buffer);
            if (++col % 3 == 0)
                add_buf(buf, "\n\r");
            found = TRUE;
        }
        add_buf(buf, "{x\n\r\n\r");
        if (!found)
            send_to_char("No one has your permission.\n\r",ch);
        else
            page_to_char(buf_string(buf), ch);
        free_buf(buf);
        return;
    }

    if ((victim = get_char_world(ch, argument)) == NULL)
    {
        send_to_char("They are not currently playing at the moment.\n\r",ch);
        return;
    }
    if (IS_NPC(victim))
    {
        send_to_char("You may not permit NPCs.\n\r",ch);
        return;
    }

    if (ch == victim) /* IQ check */
    {
        send_to_char("But you already have your own permission...weirdo.\n\r",ch);
        return;
    }

    for (pChar = 0; pChar < MAX_PERMIT; pChar++) /* Make sure you don't invite twice */
    {
        if (ch->permit[pChar] == victim)
        {
            send_to_char("They are already permited!\n\r",ch);
            return;
        }
    }

    for (pChar = 0; pChar < MAX_PERMIT; pChar++)
    {
        if (ch->permit[pChar] == NULL)
        {
            ch->permit[pChar] = victim;
            printf_to_char(ch, "%s has been given permission\n\r", victim->name);
            for (pChar2 =0;pChar2 < MAX_PERMIT;pChar2++)
            {
                if (victim->permited_by[pChar2] == NULL)
                {
                    victim->permited_by[pChar2] = ch;
                    printf_to_char(victim, "%s has given you permission.\n\r", ch->name);
                    break;
                }
            }
            permit_full = FALSE;                        
            break; /* Don't set them all... */
        }
        permit_full = TRUE;
    }

    if (permit_full)
    {
        send_to_char("You have already reached your maximum permissions.\n\r",ch);
        return;
    }
    return;

    
        
}

/* unpermit, remove those that were permited using do_permit 
 * TODO Same as do_permit, try to make this into a string
 * based function instead of a CHAR_DATA'd one. 
 * XXX memory leaks probable. */

void do_unpermit (CHAR_DATA *ch, char *argument)
{
    CHAR_DATA *victim;
//  char buf[MSL];
    int pChar=0;
    int pChar2=0;

    if (argument[0] == '\0')
    {
        send_to_char("Syntax: unpermit person\n\r",ch);
        return;
    }

    if ((victim = get_char_world(ch,argument)) == NULL)
    {
        send_to_char("They are not playing.\n\r",ch);
        return;
    }
    if (IS_NPC(victim))
    {
        send_to_char("Not on NPCs\n\r",ch);
        return;
    }

    for (pChar=0;pChar < MAX_PERMIT;pChar++)
    {
        if (ch->permit[pChar] == victim)
        {
            ch->permit[pChar] = NULL;
            printf_to_char(ch, "You have removed %s's permission.\n\r",victim->name);
            for (pChar2 =0;pChar2 < MAX_PERMIT; pChar2++)
            {
                if (victim->permited_by[pChar2] == ch)
                {
                    victim->permited_by[pChar2] = NULL;
                    printf_to_char(victim, "%s has removed your permission!\n\r",ch->name);
                    break;
                }
            }
        }
        /* let it keep running through the for, just incase some
         * weird thing happened and it put them in there twice. */
    }
    return;
}

            

    

        
            
            
        
            

        
        


/* RT code to display channel status */

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

    /* lists all channels and their status */
    send_to_char ("   channel     status\n\r", ch);
    send_to_char ("---------------------\n\r", ch);

    send_to_char ("{dgossip{x         ", ch);
    if (!IS_SET (ch->comm, COMM_NOGOSSIP))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    send_to_char ("{aauction{x        ", ch);
    if (!IS_SET (ch->comm, COMM_NOAUCTION))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    send_to_char ("{emusic{x          ", ch);
    if (!IS_SET (ch->comm, COMM_NOMUSIC))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    send_to_char ("{qQ{x/{fA{x            ", ch);
    if (!IS_SET (ch->comm, COMM_NOQUESTION))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    send_to_char ("{hQuote{x          ", ch);
    if (!IS_SET (ch->comm, COMM_NOQUOTE))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    send_to_char ("{tgrats{x          ", ch);
    if (!IS_SET (ch->comm, COMM_NOGRATS))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    if (IS_IMMORTAL (ch))
    {
        send_to_char ("{igod channel{x    ", ch);
        if (!IS_SET (ch->comm, COMM_NOWIZ))
            send_to_char ("ON\n\r", ch);
        else
            send_to_char ("OFF\n\r", ch);
    }

    send_to_char ("{tshouts{x         ", ch);
    if (!IS_SET (ch->comm, COMM_SHOUTSOFF))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    send_to_char ("{ktells{x          ", ch);
    if (!IS_SET (ch->comm, COMM_DEAF))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    send_to_char ("{tquiet mode{x     ", ch);
    if (IS_SET (ch->comm, COMM_QUIET))
        send_to_char ("ON\n\r", ch);
    else
        send_to_char ("OFF\n\r", ch);

    if (IS_SET (ch->comm, COMM_AFK))
        send_to_char ("You are AFK.\n\r", ch);

    if (IS_SET (ch->comm, COMM_SNOOP_PROOF))
        send_to_char ("You are immune to snooping.\n\r", ch);

    if (ch->lines != PAGELEN)
    {
        if (ch->lines)
        {
            sprintf (buf, "You display %d lines of scroll.\n\r",
                     ch->lines + 2);
            send_to_char (buf, ch);
        }
        else
            send_to_char ("Scroll buffering is off.\n\r", ch);
    }

    if (ch->prompt != NULL)
    {
        sprintf (buf, "Your current prompt is: %s\n\r", ch->prompt);
        send_to_char (buf, ch);
    }

    if (IS_SET (ch->comm, COMM_NOSHOUT))
        send_to_char ("You cannot shout.\n\r", ch);

    if (IS_SET (ch->comm, COMM_NOTELL))
        send_to_char ("You cannot use tell.\n\r", ch);

    if (IS_SET (ch->comm, COMM_NOCHANNELS))
        send_to_char ("You cannot use channels.\n\r", ch);

    if (IS_SET (ch->comm, COMM_NOEMOTE))
        send_to_char ("You cannot show emotions.\n\r", ch);

}

/* RT deaf blocks out all shouts */

void do_deaf (CHAR_DATA * ch, char *argument)
{

    if (IS_SET (ch->comm, COMM_DEAF))
    {
        send_to_char ("You can now hear tells again.\n\r", ch);
        REMOVE_BIT (ch->comm, COMM_DEAF);
    }
    else
    {
        send_to_char ("From now on, you won't hear tells.\n\r", ch);
        SET_BIT (ch->comm, COMM_DEAF);
    }
}

/* RT quiet blocks out all communication */

void do_quiet (CHAR_DATA * ch, char *argument)
{
    if (IS_SET (ch->comm, COMM_QUIET))
    {
        send_to_char ("Quiet mode removed.\n\r", ch);
        REMOVE_BIT (ch->comm, COMM_QUIET);
    }
    else
    {
        send_to_char ("From now on, you will only hear says and emotes.\n\r",
                      ch);
        SET_BIT (ch->comm, COMM_QUIET);
    }
}

/* afk command */

void do_afk (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    if (IS_SET (ch->comm, COMM_AFK))
    {
        send_to_char ("AFK mode removed. Type 'replay' to see tells.\n\r",
                      ch);
        if (ch->pcdata->afk_message != NULL)
    {
        send_to_char ("AFK message cleared.\n\r",ch);
        ch->pcdata->afk_message = NULL;
    }
    REMOVE_BIT (ch->comm, COMM_AFK);
    }
    else
    {
        if (argument[0] != '\0')
    {
        sprintf(buf, "AFK message: %s\n\r", argument);
        send_to_char(buf,ch);
        ch->pcdata->afk_message = str_dup(argument);
    }
    send_to_char ("You are now in AFK mode.\n\r", ch);
        SET_BIT (ch->comm, COMM_AFK);
    }
}

void do_replay (CHAR_DATA * ch, char *argument)
{
    if (IS_NPC (ch))
    {
        send_to_char ("You can't replay.\n\r", ch);
        return;
    }

    if (buf_string (ch->pcdata->buffer)[0] == '\0')
    {
        send_to_char ("You have no tells to replay.\n\r", ch);
        return;
    }

    page_to_char (buf_string (ch->pcdata->buffer), ch);
    clear_buf (ch->pcdata->buffer);
}

/* RT auction rewritten in ROM style */
void do_auction (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOAUCTION))
        {
            send_to_char ("{aAuction channel is now ON.{x\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOAUCTION);
        return;
        }
        else
        {
            send_to_char ("{aAuction channel is now OFF.{x\n\r", ch);
            SET_BIT (ch->comm, COMM_NOAUCTION);
        return;
        }
    }
    else
    {                            /* auction message sent, turn auction on if it is off */

        if (IS_SET (ch->comm, COMM_QUIET))
        {
            send_to_char ("You must turn off quiet mode first.\n\r", ch);
            return;
        }

        if (IS_SET (ch->comm, COMM_NOCHANNELS))
        {
            send_to_char
                ("The gods have revoked your channel priviliges.\n\r", ch);
            return;
        }

        REMOVE_BIT (ch->comm, COMM_NOAUCTION);
    }

    sprintf (buf, "{xYou auction '{c%s{x'{x\n\r", argument);
    send_to_char (buf, ch);
    for (d = descriptor_list; d != NULL; d = d->next)
    {
        CHAR_DATA *victim;

        victim = d->original ? d->original : d->character;

        if (d->connected == CON_PLAYING &&
            d->character != ch &&
            !IS_SET (victim->comm, COMM_NOAUCTION) &&
            !IS_SET (victim->comm, COMM_QUIET))
        {
            act_new ("{x$n auctions '{c$t{x'{x",
                     ch, argument, d->character, TO_VICT, POS_DEAD);
        }
    }
}

/* RT chat replaced with ROM gossip */
void do_clan_gossip (CHAR_DATA *ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        if (IS_SET(ch->comm, COMM_NOCGOS))
        {
            send_to_char("Clan Gossip is now ON.\n\r", ch);
            REMOVE_BIT(ch->comm, COMM_NOCGOS);
        }
        else
        {
            send_to_char("Clan Gossip is now OFF.\n\r",ch);
            SET_BIT(ch->comm, COMM_NOCGOS);
        }
    }
    else
    {
        if (IS_SET(ch->comm, COMM_QUIET))
        {
            send_to_char("You must turn off quiet mode first.\n\r",ch);
            return;
        }
        if (IS_SET(ch->comm, COMM_NOCHANNELS))
        {
                    send_to_char("The gods have revoked your channel privliges.\n\r",ch);
                    return;
        }
        
                REMOVE_BIT(ch->comm, COMM_NOCGOS);
        sprintf(buf, "{xYou clan gossip '{R%s{x'\n\r", argument);
        send_to_char(buf,ch);

        for(d = descriptor_list; d != NULL; d = d->next)
        {
            CHAR_DATA *victim;
            victim  = d->original ? d->original : d->character;

            if (d->connected == CON_PLAYING &&
                    d->character != ch && !IS_SET(victim->comm, COMM_NOCGOS) &&
                    !IS_SET(victim->comm, COMM_QUIET))
            {
                act_new("{x$n clan gossips: '{R$t{x'\n\r",ch,argument,d->character,TO_VICT, POS_SLEEPING);
            }
        }
    }
}

        


void do_gossip (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOGOSSIP))
        {
            send_to_char ("Gossip channel is now ON.\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOGOSSIP);
        }
        else
        {
            send_to_char ("Gossip channel is now OFF.\n\r", ch);
            SET_BIT (ch->comm, COMM_NOGOSSIP);
        }
    }
    else
    {                            /* gossip message sent, turn gossip on if it isn't already */

        if (IS_SET (ch->comm, COMM_QUIET))
        {
            send_to_char ("You must turn off quiet mode first.\n\r", ch);
            return;
        }

        if (IS_SET (ch->comm, COMM_NOCHANNELS))
        {
            send_to_char
                ("The gods have revoked your channel priviliges.\n\r", ch);
            return;

        }

        REMOVE_BIT (ch->comm, COMM_NOGOSSIP);

        sprintf (buf, "{xYou gossip '{W%s{x'{x\n\r", argument);
        send_to_char (buf, ch);
        for (d = descriptor_list; d != NULL; d = d->next)
        {
            CHAR_DATA *victim;

            victim = d->original ? d->original : d->character;

            if (d->connected == CON_PLAYING &&
                d->character != ch &&
                !IS_SET (victim->comm, COMM_NOGOSSIP) &&
                !IS_SET (victim->comm, COMM_QUIET))
            {
                act_new ("{x$n gossips '{W$t{x'{x",
                         ch, argument, d->character, TO_VICT, POS_SLEEPING);
            }
        }
    }
}

void do_grats (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOGRATS))
        {
            send_to_char ("Grats channel is now ON.\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOGRATS);
        }
        else
        {
            send_to_char ("Grats channel is now OFF.\n\r", ch);
            SET_BIT (ch->comm, COMM_NOGRATS);
        }
    }
    else
    {                            /* grats message sent, turn grats on if it isn't already */

        if (IS_SET (ch->comm, COMM_QUIET))
        {
            send_to_char ("You must turn off quiet mode first.\n\r", ch);
            return;
        }

        if (IS_SET (ch->comm, COMM_NOCHANNELS))
        {
            send_to_char
                ("The gods have revoked your channel priviliges.\n\r", ch);
            return;

        }

        REMOVE_BIT (ch->comm, COMM_NOGRATS);

        sprintf (buf, "{xYou grats '{C%s{x'{x\n\r", argument);
        send_to_char (buf, ch);
        for (d = descriptor_list; d != NULL; d = d->next)
        {
            CHAR_DATA *victim;

            victim = d->original ? d->original : d->character;

            if (d->connected == CON_PLAYING &&
                d->character != ch &&
                !IS_SET (victim->comm, COMM_NOGRATS) &&
                !IS_SET (victim->comm, COMM_QUIET))
            {
                act_new ("{x$n grats '{C$t{x'{x",
                         ch, argument, d->character, TO_VICT, POS_SLEEPING);
            }
        }
    }
}

/* banish command for clan AND kingdoms!
 */
void do_banish (CHAR_DATA *ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    char arg1[MAX_STRING_LENGTH];

    CHAR_DATA *victim;
    
    if (ch->level > 51)
    {
        argument = one_argument(argument, arg1);
        //argument = one_argument(argument, arg2);
        if (arg1[0] == '\0' || argument[0] == '\0')
        {
            send_to_char("Syntax (immortal only) - banish [kingdom/clan] <person>\n\r",ch);
            return;
        }
        if (!str_prefix(arg1, "kingdom"))
        {
            if (argument[0] == '\0')
            {
                send_to_char("Syntax (immortal only) - banish kingdom <person>\n\r",ch);
                return;
            }
            if ((victim = get_char_world(ch, argument)) == NULL)
            {
                send_to_char("They are not here.\n\r",ch);
                return;
            }
            if (IS_NPC(victim))
            {
                send_to_char("They are not here.\n\r",ch);
                return;
            }
            if (victim->king == 0)
            {
                send_to_char("They are not part of a kingdom.\n\r",ch);
                return;
            }
            sprintf(buf, "%s %s!\n\r",victim->name, kingdom_table[victim->king].banish_string);
            send_to_all("",buf);
            if (kingdom_data[victim->king].member_count >=1)
                kingdom_data[victim->king].member_count--;
            else
                kingdom_data[victim->king].member_count =0;

            save_kingdom_data();
            victim->king = 0;
            return;
        }
        if (!str_prefix(arg1, "clan"))
        {
            if (argument[0] == '\0')
            {
                send_to_char ("Syntax (immortal only) - banish clan <person>\n\r",ch);
                return;
            }
            if ((victim = get_char_world(ch, argument)) == NULL)
            {
                send_to_char("They are not here.\n\r",ch);
                return;
            }
            if (IS_NPC(victim))
            {
                send_to_char("They are not here.\n\r",ch);
                return;
            }
            if (victim->clan == 0)
            {
                send_to_char("They are not part of a clan.\n\r",ch);
                return;
            }
            sprintf(buf, "%s %s!\n\r",victim->name, clan_table[victim->clan].banish_string);
            send_to_all("",buf);
            victim->clan = 0;
            return;
        }
        return;
    }
    if (ch->clan != 0)
    {
        if (argument[0] == '\0')
        {
            send_to_char ("Syntax - banish <person>\n\r",ch);
            return;
        }
        if (!IS_SET(ch->cclan, CLAN_LEADER))
        {
            send_to_char("You are not a clan leader.\n\r",ch);
            return;
        }
        if ((victim = get_char_world(ch, argument)) == NULL)
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (IS_NPC(victim))
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (victim->clan != ch->clan)
        {
            send_to_char("They are not in YOUR clan.\n\r",ch);
            return;
        }
        sprintf(buf, "%s has been kicked out of your clan.\n\r",victim->name);
        send_to_char(buf,ch);
        sprintf(buf, "%s has been kicked out of the clan %s!\n\r", victim->name, clan_table[victim->clan].banish_string);
        send_to_all("",buf);
        victim->clan = 0;
        return;
    }
    if (ch->king != 0)
    {
        if (argument[0] == '\0')
        {
            send_to_char ("Syntax - banish <person>\n\r",ch);
            return;
        }
        if (!IS_SET(ch->kking, KING_LEADER))
        {
            send_to_char ("You are not a kingdom leader.\n\r",ch);
            return;
        }
        if ((victim = get_char_world(ch, argument)) == NULL)
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (IS_NPC(victim))
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (victim->king != ch->king)
        {
            send_to_char("They are not a member of YOUR kingdom.\n\r",ch);
            return;
        }
        sprintf(buf, "%s has been kicked out of your kingdom.\n\r",victim->name);
        send_to_char(buf,ch);
        sprintf(buf, "%s has been kicked out of the kingdom of %s!\n\r",victim->name, kingdom_table[victim->king].banish_string);
        if (kingdom_data[victim->king].member_count >=1)
            kingdom_data[victim->king].member_count--;
        else
            kingdom_data[victim->king].member_count = 0;

        save_kingdom_data();
        send_to_all("",buf);
        victim->king = 0;
        return;
    }
    return;
}
    
            
void do_quote (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOQUOTE))
        {
            send_to_char ("{xQuest channel is now ON.{x\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOQUOTE);
        }
        else
        {
            send_to_char ("{xQuest channel is now OFF.{x\n\r", ch);
            SET_BIT (ch->comm, COMM_NOQUOTE);
        }
    }
    else
    {                            /* quote message sent, turn quote on if it isn't already */

        if (IS_SET (ch->comm, COMM_QUIET))
        {
            send_to_char ("You must turn off quiet mode first.\n\r", ch);
            return;
        }

        if (IS_SET (ch->comm, COMM_NOCHANNELS))
        {
            send_to_char
                ("The gods have revoked your channel priviliges.\n\r", ch);
            return;

        }

        REMOVE_BIT (ch->comm, COMM_NOQUOTE);

        sprintf (buf, "{xYou quest '{M%s{x'{x\n\r", argument);
        send_to_char (buf, ch);
        for (d = descriptor_list; d != NULL; d = d->next)
        {
            CHAR_DATA *victim;

            victim = d->original ? d->original : d->character;

            if (d->connected == CON_PLAYING &&
                d->character != ch &&
                !IS_SET (victim->comm, COMM_NOQUOTE) &&
                !IS_SET (victim->comm, COMM_QUIET))
            {
                act_new ("{x$n quests '{M$t{h'{x",
                         ch, argument, d->character, TO_VICT, POS_SLEEPING);
            }
        }
    }
}

/* RT question channel */
void do_question (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOQUESTION))
        {
            send_to_char ("Q/A channel is now ON.\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOQUESTION);
        }
        else
        {
            send_to_char ("Q/A channel is now OFF.\n\r", ch);
            SET_BIT (ch->comm, COMM_NOQUESTION);
        }
    }
    else
    {                            /* question sent, turn Q/A on if it isn't already */

        if (IS_SET (ch->comm, COMM_QUIET))
        {
            send_to_char ("You must turn off quiet mode first.\n\r", ch);
            return;
        }

        if (IS_SET (ch->comm, COMM_NOCHANNELS))
        {
            send_to_char
                ("The gods have revoked your channel priviliges.\n\r", ch);
            return;
        }

        REMOVE_BIT (ch->comm, COMM_NOQUESTION);

        sprintf (buf, "{xYou ask '{Y%s{x{x'{x\n\r", argument);
        send_to_char (buf, ch);
        for (d = descriptor_list; d != NULL; d = d->next)
        {
            CHAR_DATA *victim;

            victim = d->original ? d->original : d->character;

            if (d->connected == CON_PLAYING &&
                d->character != ch &&
                !IS_SET (victim->comm, COMM_NOQUESTION) &&
                !IS_SET (victim->comm, COMM_QUIET))
            {
                act_new ("{x$n ask '{Y$t{x'{x",
                         ch, argument, d->character, TO_VICT, POS_SLEEPING);
            }
        }
    }
}

/* RT answer channel - uses same line as questions */
void do_answer (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOQUESTION))
        {
            send_to_char ("Q/A channel is now ON.\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOQUESTION);
        }
        else
        {
            send_to_char ("Q/A channel is now OFF.\n\r", ch);
            SET_BIT (ch->comm, COMM_NOQUESTION);
        }
    }
    else
    {                            /* answer sent, turn Q/A on if it isn't already */

        if (IS_SET (ch->comm, COMM_QUIET))
        {
            send_to_char ("You must turn off quiet mode first.\n\r", ch);
            return;
        }

        if (IS_SET (ch->comm, COMM_NOCHANNELS))
        {
            send_to_char
                ("The gods have revoked your channel priviliges.\n\r", ch);
            return;
        }

        REMOVE_BIT (ch->comm, COMM_NOQUESTION);

        sprintf (buf, "{xYou answer '{Y%s{x'{x\n\r", argument);
        send_to_char (buf, ch);
        for (d = descriptor_list; d != NULL; d = d->next)
        {
            CHAR_DATA *victim;

            victim = d->original ? d->original : d->character;

            if (d->connected == CON_PLAYING &&
                d->character != ch &&
                !IS_SET (victim->comm, COMM_NOQUESTION) &&
                !IS_SET (victim->comm, COMM_QUIET))
            {
                act_new ("{x$n answers '{Y$t{x'{x",
                         ch, argument, d->character, TO_VICT, POS_SLEEPING);
            }
        }
    }
}

/* RT music channel */
void do_music (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOMUSIC))
        {
            send_to_char ("Music channel is now ON.\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOMUSIC);
        }
        else
        {
            send_to_char ("Music channel is now OFF.\n\r", ch);
            SET_BIT (ch->comm, COMM_NOMUSIC);
        }
    }
    else
    {                            /* music sent, turn music on if it isn't already */

        if (IS_SET (ch->comm, COMM_QUIET))
        {
            send_to_char ("You must turn off quiet mode first.\n\r", ch);
            return;
        }

        if (IS_SET (ch->comm, COMM_NOCHANNELS))
        {
            send_to_char
                ("The gods have revoked your channel priviliges.\n\r", ch);
            return;
        }

        REMOVE_BIT (ch->comm, COMM_NOMUSIC);

        sprintf (buf, "{xYou MUSIC: '{C%s{e'{x\n\r", argument);
        send_to_char (buf, ch);
        sprintf (buf, "{x$n MUSIC: '{C%s{x'", argument);
        for (d = descriptor_list; d != NULL; d = d->next)
        {
            CHAR_DATA *victim;

            victim = d->original ? d->original : d->character;

            if (d->connected == CON_PLAYING &&
                d->character != ch &&
                !IS_SET (victim->comm, COMM_NOMUSIC) &&
                !IS_SET (victim->comm, COMM_QUIET))
            {
                act_new ("{x$n MUSIC: '{C$t{e'{x",
                         ch, argument, d->character, TO_VICT, POS_SLEEPING);
            }
        }
    }
}

/* clan channels */



void do_kingdomtalk (CHAR_DATA *ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (!is_kingdom(ch) || ch->king == 0)
    {
        send_to_char("You are not in a kingdom\n\r",ch);
        return;
    }
    if (argument[0] == '\0')
    {
        if (IS_SET(ch->kking, KING_NOKING))
        {
            send_to_char("Kingdom channel now {RON{x\n\r",ch);
            REMOVE_BIT (ch->kking, KING_NOKING);
            return;
        }
        else
        {
            send_to_char("Kingdom channel now {ROFF{x\n\r",ch);
            SET_BIT(ch->kking, KING_NOKING);
            return;
        }
        return;
    }
    if (IS_SET (ch->comm, COMM_NOCHANNELS))
    {
        send_to_char("The gods have revoked your channel priviliges.\n\r",ch);
        return;
    }
    REMOVE_BIT (ch->kking, KING_NOKING);
    sprintf(buf, "{xYou kingdom: '{R%s{x'\n\r", argument);
    send_to_char(buf,ch);
    //sprintf(buf, "{x%s kingdom: '{R%s{x'\n\r", ch->name, argument);
    for (d = descriptor_list; d != NULL; d = d->next)
    {
        if (d->connected == CON_PLAYING && d->character != ch && is_same_kingdom(ch, d->character) &&
                !IS_SET(d->character->kking, KING_NOKING) && !IS_SET(d->character->comm, COMM_QUIET))
        {
            act_new ("$n kingdom: '{R$t{x'{x", ch, argument, d->character, TO_VICT,
                                         POS_DEAD);
        }
    }
    return;

}

void do_clantalk (CHAR_DATA * ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    DESCRIPTOR_DATA *d;

    if (!is_clan (ch) || clan_table[ch->clan].independent)
    {
        send_to_char ("You aren't in a clan.\n\r", ch);
        return;
    }
    if (argument[0] == '\0')
    {
        if (IS_SET (ch->cclan, COMM_NOCLAN))
        {
            send_to_char ("Clan channel is now {RON{x\n\r", ch);
            REMOVE_BIT (ch->cclan, COMM_NOCLAN);
        }
        else
        {
            send_to_char ("Clan channel is now {DOFF{x\n\r", ch);
            SET_BIT (ch->cclan, COMM_NOCLAN);
        }
        return;
    }

    if (IS_SET (ch->comm, COMM_NOCHANNELS))
    {
        send_to_char ("The gods have revoked your channel priviliges.\n\r",
                      ch);
        return;
    }

    REMOVE_BIT (ch->cclan, COMM_NOCLAN);

    sprintf (buf, "You clan '{R%s{x'\n\r", argument);
    send_to_char (buf, ch);
    sprintf (buf, "$n clans '{R%s{x'", argument);
    for (d = descriptor_list; d != NULL; d = d->next)
    {
        if (d->connected == CON_PLAYING &&
            d->character != ch &&
            is_same_clan (ch, d->character) &&
            !IS_SET (d->character->comm, COMM_NOCLAN) &&
            !IS_SET (d->character->comm, COMM_QUIET))
        {
            act_new ("$n clans '{R$t{x'{x", ch, argument, d->character, TO_VICT,
                     POS_DEAD);
        }
    }

    return;
}
void do_oocclan_talk (CHAR_DATA *ch, char *argument)
{
     char buf[MAX_STRING_LENGTH];
         DESCRIPTOR_DATA *d;
         
    if (ch->clan == 0)
    {
        send_to_char("You are not in a clan.\n\r",ch);
        return;
    }
    if (argument[0] == '\0')
    {
        
        if (IS_SET(ch->cclan, CLAN_NOOOCCLAN))
        {
            send_to_char("OOCClan is now on.\n\r",ch);
            REMOVE_BIT(ch->cclan, CLAN_NOOOCCLAN);
            return;
        }
        if (!IS_SET(ch->cclan, CLAN_NOOOCCLAN))
        {
            send_to_char("OOCClan is now off.\n\r",ch);
            REMOVE_BIT(ch->cclan, CLAN_NOOOCCLAN);
            return;
        }
        return;
    }
    if (IS_SET(ch->comm, COMM_NOCHANNELS))
    {
        send_to_char("The Gods have revoked your channel privliages.\n\r",ch);
        return;
    }
    sprintf(buf, "You OOC Clan: '{G%s{x'\n\r", argument);
    send_to_char(buf,ch);
    sprintf(buf, "%s OOC Clan: '{G%s{x'\n\r", ch->name, argument);  
        for (d = descriptor_list; d != NULL; d = d->next)
     {
         if (d->connected == CON_PLAYING &&
              d->character != ch &&
                  is_same_clan (ch, d->character) &&
                  !IS_SET (d->character->comm, CLAN_NOOOCCLAN) &&
                  !IS_SET (d->character->comm, COMM_QUIET))
         {
            act_new ("$n OOC clan: '{G$t{x'{x", ch, argument, d->character, TO_VICT,
                                         POS_DEAD);
         }
     }
}

         
             
             
             

void do_broadcast (CHAR_DATA *ch, char *argument)
{
    DESCRIPTOR_DATA *d;
    char buf[MSL];
    char buffer[MSL*2];
    char *pbuf;
    if (argument[0]=='\0')
    {
        send_to_char ("Can't broadcast a message without a message.\n\r",ch);
        return;
    }
    act_new ("{w({DBroadcast from {R$n{w){x: {C$t{x", ch, argument, NULL, TO_CHAR, POS_DEAD);
    for (d = descriptor_list; d != NULL; d = d->next)
        {
        if (d->connected >= -15 && d->character != ch)
            {

            act_new ("{w({DBroadcast from {R$n{w){x: {C$t{x", ch, argument, d->character,TO_VICT,POS_DEAD);
            /*sprintf(buf, "{w({DBroadcast from {R%s{w){x: {C%s{x\n\r", ch->name, argument);
            pbuf = buffer;
            colourconv(pbuf,buf,d->character);
            write_to_descriptor(d->descriptor,buffer, 0);
            //send_to_char(buf,d->character);
            buf[0]= '\0';*/
                       
            }
    }
//  free_string(pbuf);
    
    return;
}


void do_ooc (CHAR_DATA *ch, char *argument)
{
DESCRIPTOR_DATA *d;
  
if (IS_SET(ch->comm, COMM_NOCHANNELS))
{
    send_to_char("The Gods have revoked your channel privliages.\n\r",ch);
    return;
}

if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOOOC))
        {
            send_to_char ("OOC channel is now ON\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOOOC);
        }
        else
        {
            send_to_char ("OOC channel is now OFF\n\r", ch);
            SET_BIT (ch->comm, COMM_NOOOC);
        }
        return;
    }

    REMOVE_BIT (ch->comm, COMM_NOOOC);

    act_new ("{xYou OOC: '{C$t{x'",ch, argument, NULL, TO_CHAR, POS_DEAD);
//    send_to_char ("{xYou OOC: '{C$t{x'", ch);
    for (d = descriptor_list; d != NULL; d = d->next)
    {
        if (d->connected == CON_PLAYING &&  !IS_SET (d->character->comm, COMM_NOOOC))
        {
act_new ("$n OOC: '{C$t{x'", ch, argument, d->character, TO_VICT,
                     POS_DEAD);
        }
    }

    return;
}





void do_pray (CHAR_DATA * ch, char *argument)
{
    DESCRIPTOR_DATA *d;
    
    if (argument[0]=='\0')
    {
            send_to_char ("What would you like to pray?\n\r",ch);
            return;
    }
act_new ("{r[{Y$n {Gprays{r]{x: {G$t{x", ch, argument, NULL, TO_CHAR, POS_DEAD);
 for (d = descriptor_list; d != NULL; d = d->next)
    {
        if (d->connected == CON_PLAYING &&
            IS_IMMORTAL (d->character) &&
            !IS_SET (d->character->comm, COMM_NOWIZ))
        {
            act_new ("{r[{Y$n {Gprays{r]:{G $t{x", ch, argument, d->character, TO_VICT,
                     POS_DEAD);
        }
    }

    return;
}
void do_admintalk (CHAR_DATA *ch, char * argument)
{
    DESCRIPTOR_DATA *d;
    if (IS_SET(ch->comm, COMM_NOCHANNELS))
    {
        send_to_char("The Gods have revoked your channel privliages.\n\r",ch);
        return;
    }
    if (argument[0] == '\0')
    {
        if (IS_SET(ch->chann, CHAN_ADMIN))
        {
            send_to_char("Admin channel is now ON\n\r",ch);
            REMOVE_BIT(ch->chann, CHAN_ADMIN);
        }
        else
        {
            send_to_char("Admin channel is now OFF\n\r",ch);
            SET_BIT(ch->chann, CHAN_ADMIN);
        }
        return;
    }
    REMOVE_BIT(ch->chann, CHAN_ADMIN);
    act_new("{r[{CAdmin - {D$n{r]{x {R$t{x", ch, argument, NULL, TO_CHAR, POS_DEAD);
    for (d = descriptor_list; d != NULL ; d = d->next)
    {
        if (d->connected == CON_PLAYING && 
                IS_IMMORTAL(d->character) && !IS_SET(d->character->chann, CHAN_ADMIN)
                && get_trust(d->character) > 58)
            
            
        {
            //if (d->character->level > 58)
            //{
                act_new("{r[{CAdmin - {D$n{r]{x {R$t{x", ch, argument, d->character, TO_VICT, POS_DEAD);
        //  }
        }
    }
    return;
}
        

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

    if (IS_SET(ch->comm, COMM_NOCHANNELS))
            {
            send_to_char("The Gods have revoked your channel privliages.",ch);
            return;
            }
            
    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_NOWIZ))
        {
            send_to_char ("Immortal channel is now ON\n\r", ch);
            REMOVE_BIT (ch->comm, COMM_NOWIZ);
        }
        else
        {
            send_to_char ("Immortal channel is now OFF\n\r", ch);
            SET_BIT (ch->comm, COMM_NOWIZ);
        }
        return;
    }

    REMOVE_BIT (ch->comm, COMM_NOWIZ);

    act_new ("{y[{C$n{y]{x: {y$t{x", ch, argument, NULL, TO_CHAR, POS_DEAD);
    for (d = descriptor_list; d != NULL; d = d->next)
    {
        if (d->connected == CON_PLAYING &&
            IS_IMMORTAL (d->character) &&
            !IS_SET (d->character->comm, COMM_NOWIZ))
        {
            act_new ("{y[{C$n{y]{x:{y $t{x", ch, argument, d->character, TO_VICT,
                     POS_DEAD);
        }
    }

    return;
}

void do_btell (CHAR_DATA *ch, char *argument)
{
    if (IS_SET(ch->chann, CHAN_NOBEEP))
    {
        send_to_char("For now on, your tells will beep.\n\r",ch);
        REMOVE_BIT (ch->chann, CHAN_NOBEEP);
        return;
    }
    if (!IS_SET(ch->chann, CHAN_NOBEEP))
    {
        send_to_char("For now on, your tells will not beep.\n\r",ch);
        SET_BIT(ch->chann, CHAN_NOBEEP);
        return;
    }
//REMOVE_BIT(ch->comm, COMM_NOBEEP);
return;
}












void do_dsay (CHAR_DATA * ch, char *argument)

{
    CHAR_DATA *victim;
    char buf[MAX_STRING_LENGTH];
    char arg[MAX_INPUT_LENGTH];
    argument = one_argument (argument, arg);
    CHAR_DATA *to;
    if (arg[0]== '\0' || argument[0] == '\0')
    {
                send_to_char("What would you like to say, and to whom?.\n\r",ch);
                    return;
    }
    if ((victim = get_char_room(ch, arg)) == NULL)
    {
                send_to_char("They arn't here.\n\r",ch);
                    return;
    }
     sprintf(buf, "{x%s says (to You) '{g%s{x'\n\r", IS_NPC(ch) ? ch->short_descr : ch->name, argument);
     send_to_char(buf,victim);
     if (IS_NPC(victim))
     {
         sprintf(buf, "{xYou say (to %s) '{g%s{x'\n\r", victim->short_descr, argument);
     }
     else
     {
             sprintf(buf, "{xYou say (to %s) '{g%s{x'\n\r", victim->name, argument);
     }
     send_to_char(buf,ch);
      for (to=ch->in_room->people ; to != NULL; to = to->next_in_room )
      {
           if (to != ch && to != victim && to->position != POS_SLEEPING)
            {
                 if (IS_NPC(victim))
                 {
                       sprintf(buf, "{x%s says (to %s) '{g%s{x'\n\r",IS_NPC(ch) ? ch->short_descr : ch->name,
                               victim->short_descr, argument);
                 }
                 else
                 {
                     sprintf(buf, "{x%s says (to %s) '{g%s{x'\n\r",IS_NPC(ch) ? ch->short_descr : ch->name,
                           victim->name, argument);
                 }
                 send_to_char(buf,to);
            }
      }
      return;
}



void do_whisper (CHAR_DATA * ch, char *argument)
{
    if(argument[0] == '\0')
    {
        send_to_char ("What would you like to whisper?\n\r", ch);
        return;
    }
act("{x$n whispers, '{c$T{x'", ch, NULL, argument, TO_ROOM);
act("You whisper, '{c$T{x'",ch, NULL, argument, TO_CHAR);

if (!IS_NPC(ch))
 {
   CHAR_DATA *mob, *mob_next;
   for (mob = ch->in_room->people; mob != NULL; mob = mob_next)
   {
       mob_next = mob->next_in_room;



if (IS_NPC(mob) && HAS_TRIGGER (mob, TRIG_SPEECH) && mob->position ==mob->pIndexData->default_pos)
mp_act_trigger (argument, mob,ch, NULL,NULL,TRIG_SPEECH);
}
}
return;
}



void do_say (CHAR_DATA * ch, char *argument)
{
    if (!IS_NPC(ch) && IS_SET(ch->comm, COMM_NOCHANNELS))
    {
        send_to_char("You may not speak!\n\r",ch);
        return;
    }

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

    act ("{x$n says '{g$T{x'{x", ch, NULL, argument, TO_ROOM);
    act ("{xYou say '{g$T{x'{x", ch, NULL, argument, TO_CHAR);

    if (!IS_NPC (ch))
    {
        CHAR_DATA *mob, *mob_next;
        for (mob = ch->in_room->people; mob != NULL; mob = mob_next)
        {
            mob_next = mob->next_in_room;
            if (IS_NPC (mob) && HAS_TRIGGER (mob, TRIG_SPEECH)
                && mob->position == mob->pIndexData->default_pos)
                mp_act_trigger (argument, mob, ch, NULL, NULL, TRIG_SPEECH);
        }
    }
    return;
}



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

    if (argument[0] == '\0')
    {
        if (IS_SET (ch->comm, COMM_SHOUTSOFF))
        {
            send_to_char ("You can hear shouts again.\n\r", ch);
            REMOVE_BIT (ch->comm