Main Page | Alphabetical List | Data Structures | File List | Data Fields | Globals

act_comm.c File Reference

#include <sys/types.h>
#include <sys/time.h>
#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>

Include dependency graph for act_comm.c:

Go to the source code of this file.

Functions

void add_follower (CHAR_DATA *ch, CHAR_DATA *master)
void die_follower (CHAR_DATA *ch)
void do_admintalk (CHAR_DATA *ch, char *argument)
void do_afk (CHAR_DATA *ch, char *argument)
void do_answer (CHAR_DATA *ch, char *argument)
void do_auction (CHAR_DATA *ch, char *argument)
void do_banish (CHAR_DATA *ch, char *argument)
void do_broadcast (CHAR_DATA *ch, char *argument)
void do_btell (CHAR_DATA *ch, char *argument)
void do_bug (CHAR_DATA *ch, char *argument)
void do_channels (CHAR_DATA *ch, char *argument)
void do_clan_gossip (CHAR_DATA *ch, char *argument)
void do_clantalk (CHAR_DATA *ch, char *argument)
void do_colour (CHAR_DATA *ch, char *argument)
void do_deaf (CHAR_DATA *ch, char *argument)
void do_delet (CHAR_DATA *ch, char *argument)
void do_delete (CHAR_DATA *ch, char *argument)
void do_dsay (CHAR_DATA *ch, char *argument)
void do_emote (CHAR_DATA *ch, char *argument)
void do_follow (CHAR_DATA *ch, char *argument)
void do_gossip (CHAR_DATA *ch, char *argument)
void do_grats (CHAR_DATA *ch, char *argument)
void do_group (CHAR_DATA *ch, char *argument)
void do_gtell (CHAR_DATA *ch, char *argument)
void do_immtalk (CHAR_DATA *ch, char *argument)
void do_kingdomtalk (CHAR_DATA *ch, char *argument)
void do_music (CHAR_DATA *ch, char *argument)
void do_ooc (CHAR_DATA *ch, char *argument)
void do_oocclan_talk (CHAR_DATA *ch, char *argument)
void do_order (CHAR_DATA *ch, char *argument)
void do_permit (CHAR_DATA *ch, char *argument)
void do_pmote (CHAR_DATA *ch, char *argument)
void do_pose (CHAR_DATA *ch, char *argument)
void do_pray (CHAR_DATA *ch, char *argument)
void do_question (CHAR_DATA *ch, char *argument)
void do_qui (CHAR_DATA *ch, char *argument)
void do_quiet (CHAR_DATA *ch, char *argument)
void do_quit (CHAR_DATA *ch, char *argument)
void do_quote (CHAR_DATA *ch, char *argument)
void do_rent (CHAR_DATA *ch, char *argument)
void do_replay (CHAR_DATA *ch, char *argument)
void do_reply (CHAR_DATA *ch, char *argument)
void do_roar (CHAR_DATA *ch, char *argument)
void do_save (CHAR_DATA *ch, char *argument)
void do_say (CHAR_DATA *ch, char *argument)
void do_shout (CHAR_DATA *ch, char *argument)
void do_split (CHAR_DATA *ch, char *argument)
void do_tell (CHAR_DATA *ch, char *argument)
void do_tick (CHAR_DATA *ch, char *argument)
void do_typo (CHAR_DATA *ch, char *argument)
void do_unpermit (CHAR_DATA *ch, char *argument)
void do_whisper (CHAR_DATA *ch, char *argument)
void do_yell (CHAR_DATA *ch, char *argument)
bool is_same_group (CHAR_DATA *ach, CHAR_DATA *bch)
void nuke_pets (CHAR_DATA *ch)
void stop_follower (CHAR_DATA *ch)

Variables

const struct pose_table_type pose_table []

Function Documentation

void add_follower (  CHAR_DATA *  ch,
CHAR_DATA *  master
) 
 

Definition at line 2450 of file act_comm.c.

References act, bug(), can_see(), char_data::leader, char_data::master, TO_CHAR, and TO_VICT.

Referenced by do_buy(), do_follow(), and spell_charm_person().

02451 {
02452     if (ch->master != NULL)
02453     {
02454         bug ("Add_follower: non-null master.", 0);
02455         return;
02456     }
02457 
02458     ch->master = master;
02459     ch->leader = NULL;
02460 
02461     if (can_see (master, ch))
02462         act ("$n now follows you.", ch, NULL, master, TO_VICT);
02463 
02464     act ("You now follow $N.", ch, NULL, master, TO_CHAR);
02465 
02466     return;
02467 }

Here is the call graph for this function:

void die_follower (  CHAR_DATA *  ch  ) 
 

Definition at line 2517 of file act_comm.c.

References char_list, char_data::leader, char_data::master, char_data::next, char_data::pet, and stop_follower().

Referenced by do_nofollow(), and extract_char().

02518 {
02519     CHAR_DATA *fch;
02520 
02521     if (ch->master != NULL)
02522     {
02523         if (ch->master->pet == ch)
02524             ch->master->pet = NULL;
02525         stop_follower (ch);
02526     }
02527 
02528     ch->leader = NULL;
02529 
02530     for (fch = char_list; fch != NULL; fch = fch->next)
02531     {
02532         if (fch->master == ch)
02533             stop_follower (fch);
02534         if (fch->leader == ch)
02535             fch->leader = fch;
02536     }
02537 
02538     return;
02539 }

Here is the call graph for this function:

void do_admintalk (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 1322 of file act_comm.c.

References act_new(), CHAN_ADMIN, char_data::chann, descriptor_data::character, COMM_NOCHANNELS, CON_PLAYING, descriptor_data::connected, descriptor_list, get_trust(), IS_IMMORTAL, IS_SET, descriptor_data::next, POS_DEAD, REMOVE_BIT, send_to_char(), SET_BIT, TO_CHAR, and TO_VICT.

01323 {
01324     DESCRIPTOR_DATA *d;
01325     if (IS_SET(ch->comm, COMM_NOCHANNELS))
01326     {
01327         send_to_char("The Gods have revoked your channel privliages.\n\r",ch);
01328         return;
01329     }
01330     if (argument[0] == '\0')
01331     {
01332         if (IS_SET(ch->chann, CHAN_ADMIN))
01333         {
01334             send_to_char("Admin channel is now ON\n\r",ch);
01335             REMOVE_BIT(ch->chann, CHAN_ADMIN);
01336         }
01337         else
01338         {
01339             send_to_char("Admin channel is now OFF\n\r",ch);
01340             SET_BIT(ch->chann, CHAN_ADMIN);
01341         }
01342         return;
01343     }
01344     REMOVE_BIT(ch->chann, CHAN_ADMIN);
01345     act_new("{r[{CAdmin - {D$n{r]{x {R$t{x", ch, argument, NULL, TO_CHAR, POS_DEAD);
01346     for (d = descriptor_list; d != NULL ; d = d->next)
01347     {
01348         if (d->connected == CON_PLAYING && 
01349                 IS_IMMORTAL(d->character) && !IS_SET(d->character->chann, CHAN_ADMIN)
01350                 && get_trust(d->character) > 58)
01351             
01352             
01353         {
01354             //if (d->character->level > 58)
01355             //{
01356                 act_new("{r[{CAdmin - {D$n{r]{x {R$t{x", ch, argument, d->character, TO_VICT, POS_DEAD);
01357         //  }
01358         }
01359     }
01360     return;
01361 }

Here is the call graph for this function:

void do_afk (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 404 of file act_comm.c.

References pc_data::afk_message, COMM_AFK, IS_SET, MAX_STRING_LENGTH, char_data::pcdata, REMOVE_BIT, send_to_char(), SET_BIT, and str_dup().

00405 {
00406     char buf[MAX_STRING_LENGTH];
00407     if (IS_SET (ch->comm, COMM_AFK))
00408     {
00409         send_to_char ("AFK mode removed. Type 'replay' to see tells.\n\r",
00410                       ch);
00411         if (ch->pcdata->afk_message != NULL)
00412     {
00413         send_to_char ("AFK message cleared.\n\r",ch);
00414         ch->pcdata->afk_message = NULL;
00415     }
00416     REMOVE_BIT (ch->comm, COMM_AFK);
00417     }
00418     else
00419     {
00420         if (argument[0] != '\0')
00421     {
00422         sprintf(buf, "AFK message: %s\n\r", argument);
00423         send_to_char(buf,ch);
00424         ch->pcdata->afk_message = str_dup(argument);
00425     }
00426     send_to_char ("You are now in AFK mode.\n\r", ch);
00427         SET_BIT (ch->comm, COMM_AFK);
00428     }
00429 }

Here is the call graph for this function:

void do_answer (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 949 of file act_comm.c.

References act_new(), descriptor_data::character, char_data::comm, COMM_NOCHANNELS, COMM_NOQUESTION, COMM_QUIET, CON_PLAYING, descriptor_data::connected, descriptor_list, IS_SET, MAX_STRING_LENGTH, descriptor_data::next, descriptor_data::original, POS_SLEEPING, REMOVE_BIT, send_to_char(), SET_BIT, and TO_VICT.

00950 {
00951     char buf[MAX_STRING_LENGTH];
00952     DESCRIPTOR_DATA *d;
00953 
00954     if (argument[0] == '\0')
00955     {
00956         if (IS_SET (ch->comm, COMM_NOQUESTION))
00957         {
00958             send_to_char ("Q/A channel is now ON.\n\r", ch);
00959             REMOVE_BIT (ch->comm, COMM_NOQUESTION);
00960         }
00961         else
00962         {
00963             send_to_char ("Q/A channel is now OFF.\n\r", ch);
00964             SET_BIT (ch->comm, COMM_NOQUESTION);
00965         }
00966     }
00967     else
00968     {                            /* answer sent, turn Q/A on if it isn't already */
00969 
00970         if (IS_SET (ch->comm, COMM_QUIET))
00971         {
00972             send_to_char ("You must turn off quiet mode first.\n\r", ch);
00973             return;
00974         }
00975 
00976         if (IS_SET (ch->comm, COMM_NOCHANNELS))
00977         {
00978             send_to_char
00979                 ("The gods have revoked your channel priviliges.\n\r", ch);
00980             return;
00981         }
00982 
00983         REMOVE_BIT (ch->comm, COMM_NOQUESTION);
00984 
00985         sprintf (buf, "{xYou answer '{Y%s{x'{x\n\r", argument);
00986         send_to_char (buf, ch);
00987         for (d = descriptor_list; d != NULL; d = d->next)
00988         {
00989             CHAR_DATA *victim;
00990 
00991             victim = d->original ? d->original : d->character;
00992 
00993             if (d->connected == CON_PLAYING &&
00994                 d->character != ch &&
00995                 !IS_SET (victim->comm, COMM_NOQUESTION) &&
00996                 !IS_SET (victim->comm, COMM_QUIET))
00997             {
00998                 act_new ("{x$n answers '{Y$t{x'{x",
00999                          ch, argument, d->character, TO_VICT, POS_SLEEPING);
01000             }
01001         }
01002     }
01003 }

Here is the call graph for this function:

void do_auction (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 450 of file act_comm.c.

References act_new(), descriptor_data::character, char_data::comm, COMM_NOAUCTION, COMM_NOCHANNELS, COMM_QUIET, CON_PLAYING, descriptor_data::connected, descriptor_list, IS_SET, MAX_STRING_LENGTH, descriptor_data::next, descriptor_data::original, POS_DEAD, REMOVE_BIT, send_to_char(), SET_BIT, and TO_VICT.

00451 {
00452     char buf[MAX_STRING_LENGTH];
00453     DESCRIPTOR_DATA *d;
00454 
00455     if (argument[0] == '\0')
00456     {
00457         if (IS_SET (ch->comm, COMM_NOAUCTION))
00458         {
00459             send_to_char ("{aAuction channel is now ON.{x\n\r", ch);
00460             REMOVE_BIT (ch->comm, COMM_NOAUCTION);
00461         return;
00462         }
00463         else
00464         {
00465             send_to_char ("{aAuction channel is now OFF.{x\n\r", ch);
00466             SET_BIT (ch->comm, COMM_NOAUCTION);
00467         return;
00468         }
00469     }
00470     else
00471     {                            /* auction message sent, turn auction on if it is off */
00472 
00473         if (IS_SET (ch->comm, COMM_QUIET))
00474         {
00475             send_to_char ("You must turn off quiet mode first.\n\r", ch);
00476             return;
00477         }
00478 
00479         if (IS_SET (ch->comm, COMM_NOCHANNELS))
00480         {
00481             send_to_char
00482                 ("The gods have revoked your channel priviliges.\n\r", ch);
00483             return;
00484         }
00485 
00486         REMOVE_BIT (ch->comm, COMM_NOAUCTION);
00487     }
00488 
00489     sprintf (buf, "{xYou auction '{c%s{x'{x\n\r", argument);
00490     send_to_char (buf, ch);
00491     for (d = descriptor_list; d != NULL; d = d->next)
00492     {
00493         CHAR_DATA *victim;
00494 
00495         victim = d->original ? d->original : d->character;
00496 
00497         if (d->connected == CON_PLAYING &&
00498             d->character != ch &&
00499             !IS_SET (victim->comm, COMM_NOAUCTION) &&
00500             !IS_SET (victim->comm, COMM_QUIET))
00501         {
00502             act_new ("{x$n auctions '{c$t{x'{x",
00503                      ch, argument, d->character, TO_VICT, POS_DEAD);
00504         }
00505     }
00506 }

Here is the call graph for this function:

void do_banish (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 678 of file act_comm.c.

References char_data::clan, CLAN_LEADER, clan_table, get_char_world(), IS_NPC, IS_SET, char_data::king, KING_LEADER, kingdom_data, kingdom_table, MAX_STRING_LENGTH, kingdom_data_1::member_count, char_data::name, one_argument(), save_kingdom_data(), send_to_all(), send_to_char(), and str_prefix().

00679 {
00680     char buf[MAX_STRING_LENGTH];
00681     char arg1[MAX_STRING_LENGTH];
00682 
00683     CHAR_DATA *victim;
00684     
00685     if (ch->level > 51)
00686     {
00687         argument = one_argument(argument, arg1);
00688         //argument = one_argument(argument, arg2);
00689         if (arg1[0] == '\0' || argument[0] == '\0')
00690         {
00691             send_to_char("Syntax (immortal only) - banish [kingdom/clan] <person>\n\r",ch);
00692             return;
00693         }
00694         if (!str_prefix(arg1, "kingdom"))
00695         {
00696             if (argument[0] == '\0')
00697             {
00698                 send_to_char("Syntax (immortal only) - banish kingdom <person>\n\r",ch);
00699                 return;
00700             }
00701             if ((victim = get_char_world(ch, argument)) == NULL)
00702             {
00703                 send_to_char("They are not here.\n\r",ch);
00704                 return;
00705             }
00706             if (IS_NPC(victim))
00707             {
00708                 send_to_char("They are not here.\n\r",ch);
00709                 return;
00710             }
00711             if (victim->king == 0)
00712             {
00713                 send_to_char("They are not part of a kingdom.\n\r",ch);
00714                 return;
00715             }
00716             sprintf(buf, "%s %s!\n\r",victim->name, kingdom_table[victim->king].banish_string);
00717             send_to_all("",buf);
00718             if (kingdom_data[victim->king].member_count >=1)
00719                 kingdom_data[victim->king].member_count--;
00720             else
00721                 kingdom_data[victim->king].member_count =0;
00722 
00723             save_kingdom_data();
00724             victim->king = 0;
00725             return;
00726         }
00727         if (!str_prefix(arg1, "clan"))
00728         {
00729             if (argument[0] == '\0')
00730             {
00731                 send_to_char ("Syntax (immortal only) - banish clan <person>\n\r",ch);
00732                 return;
00733             }
00734             if ((victim = get_char_world(ch, argument)) == NULL)
00735             {
00736                 send_to_char("They are not here.\n\r",ch);
00737                 return;
00738             }
00739             if (IS_NPC(victim))
00740             {
00741                 send_to_char("They are not here.\n\r",ch);
00742                 return;
00743             }
00744             if (victim->clan == 0)
00745             {
00746                 send_to_char("They are not part of a clan.\n\r",ch);
00747                 return;
00748             }
00749             sprintf(buf, "%s %s!\n\r",victim->name, clan_table[victim->clan].banish_string);
00750             send_to_all("",buf);
00751             victim->clan = 0;
00752             return;
00753         }
00754         return;
00755     }
00756     if (ch->clan != 0)
00757     {
00758         if (argument[0] == '\0')
00759         {
00760             send_to_char ("Syntax - banish <person>\n\r",ch);
00761             return;
00762         }
00763         if (!IS_SET(ch->cclan, CLAN_LEADER))
00764         {
00765             send_to_char("You are not a clan leader.\n\r",ch);
00766             return;
00767         }
00768         if ((victim = get_char_world(ch, argument)) == NULL)
00769         {
00770             send_to_char("They are not here.\n\r",ch);
00771             return;
00772         }
00773         if (IS_NPC(victim))
00774         {
00775             send_to_char("They are not here.\n\r",ch);
00776             return;
00777         }
00778         if (victim->clan != ch->clan)
00779         {
00780             send_to_char("They are not in YOUR clan.\n\r",ch);
00781             return;
00782         }
00783         sprintf(buf, "%s has been kicked out of your clan.\n\r",victim->name);
00784         send_to_char(buf,ch);
00785         sprintf(buf, "%s has been kicked out of the clan %s!\n\r", victim->name, clan_table[victim->clan].banish_string);
00786         send_to_all("",buf);
00787         victim->clan = 0;
00788         return;
00789     }
00790     if (ch->king != 0)
00791     {
00792         if (argument[0] == '\0')
00793         {
00794             send_to_char ("Syntax - banish <person>\n\r",ch);
00795             return;
00796         }
00797         if (!IS_SET(ch->kking, KING_LEADER))
00798         {
00799             send_to_char ("You are not a kingdom leader.\n\r",ch);
00800             return;
00801         }
00802         if ((victim = get_char_world(ch, argument)) == NULL)
00803         {
00804             send_to_char("They are not here.\n\r",ch);
00805             return;
00806         }
00807         if (IS_NPC(victim))
00808         {
00809             send_to_char("They are not here.\n\r",ch);
00810             return;
00811         }
00812         if (victim->king != ch->king)
00813         {
00814             send_to_char("They are not a member of YOUR kingdom.\n\r",ch);
00815             return;
00816         }
00817         sprintf(buf, "%s has been kicked out of your kingdom.\n\r",victim->name);
00818         send_to_char(buf,ch);
00819         sprintf(buf, "%s has been kicked out of the kingdom of %s!\n\r",victim->name, kingdom_table[victim->king].banish_string);
00820         if (kingdom_data[victim->king].member_count >=1)
00821             kingdom_data[victim->king].member_count--;
00822         else
00823             kingdom_data[victim->king].member_count = 0;
00824 
00825         save_kingdom_data();
00826         send_to_all("",buf);
00827         victim->king = 0;
00828         return;
00829     }
00830     return;
00831 }

Here is the call graph for this function:

void do_broadcast (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 1221 of file act_comm.c.

References act_new(), descriptor_data::character, descriptor_data::connected, descriptor_list, MSL, descriptor_data::next, POS_DEAD, send_to_char(), TO_CHAR, and TO_VICT.

01222 {
01223     DESCRIPTOR_DATA *d;
01224     char buf[MSL];
01225     char buffer[MSL*2];
01226     char *pbuf;
01227     if (argument[0]=='\0')
01228     {
01229         send_to_char ("Can't broadcast a message without a message.\n\r",ch);
01230         return;
01231     }
01232     act_new ("{w({DBroadcast from {R$n{w){x: {C$t{x", ch, argument, NULL, TO_CHAR, POS_DEAD);
01233     for (d = descriptor_list; d != NULL; d = d->next)
01234         {
01235         if (d->connected >= -15 && d->character != ch)
01236             {
01237 
01238             act_new ("{w({DBroadcast from {R$n{w){x: {C$t{x", ch, argument, d->character,TO_VICT,POS_DEAD);
01239             /*sprintf(buf, "{w({DBroadcast from {R%s{w){x: {C%s{x\n\r", ch->name, argument);
01240             pbuf = buffer;
01241             colourconv(pbuf,buf,d->character);
01242             write_to_descriptor(d->descriptor,buffer, 0);
01243             //send_to_char(buf,d->character);
01244             buf[0]= '\0';*/
01245                        
01246             }
01247     }
01248 //  free_string(pbuf);
01249     
01250     return;
01251 }

Here is the call graph for this function:

void do_btell (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 1406 of file act_comm.c.

References CHAN_NOBEEP, IS_SET, REMOVE_BIT, send_to_char(), and SET_BIT.

01407 {
01408     if (IS_SET(ch->chann, CHAN_NOBEEP))
01409     {
01410         send_to_char("For now on, your tells will beep.\n\r",ch);
01411         REMOVE_BIT (ch->chann, CHAN_NOBEEP);
01412         return;
01413     }
01414     if (!IS_SET(ch->chann, CHAN_NOBEEP))
01415     {
01416         send_to_char("For now on, your tells will not beep.\n\r",ch);
01417         SET_BIT(ch->chann, CHAN_NOBEEP);
01418         return;
01419     }
01420 //REMOVE_BIT(ch->comm, COMM_NOBEEP);
01421 return;
01422 }

Here is the call graph for this function:

void do_bug (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 2291 of file act_comm.c.

References append_file(), BUG_FILE, and send_to_char().

02292 {
02293     append_file (ch, BUG_FILE, argument);
02294     send_to_char ("Bug logged.\n\r", ch);
02295     return;
02296 }

Here is the call graph for this function:

void do_channels (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 259 of file act_comm.c.

References COMM_AFK, COMM_DEAF, COMM_NOAUCTION, COMM_NOCHANNELS, COMM_NOEMOTE, COMM_NOGOSSIP, COMM_NOGRATS, COMM_NOMUSIC, COMM_NOQUESTION, COMM_NOQUOTE, COMM_NOSHOUT, COMM_NOTELL, COMM_NOWIZ, COMM_QUIET, COMM_SHOUTSOFF, COMM_SNOOP_PROOF, IS_IMMORTAL, IS_SET, MAX_STRING_LENGTH, PAGELEN, and send_to_char().

00260 {
00261     char buf[MAX_STRING_LENGTH];
00262 
00263     /* lists all channels and their status */
00264     send_to_char ("   channel     status\n\r", ch);
00265     send_to_char ("---------------------\n\r", ch);
00266 
00267     send_to_char ("{dgossip{x         ", ch);
00268     if (!IS_SET (ch->comm, COMM_NOGOSSIP))
00269         send_to_char ("ON\n\r", ch);
00270     else
00271         send_to_char ("OFF\n\r", ch);
00272 
00273     send_to_char ("{aauction{x        ", ch);
00274     if (!IS_SET (ch->comm, COMM_NOAUCTION))
00275         send_to_char ("ON\n\r", ch);
00276     else
00277         send_to_char ("OFF\n\r", ch);
00278 
00279     send_to_char ("{emusic{x          ", ch);
00280     if (!IS_SET (ch->comm, COMM_NOMUSIC))
00281         send_to_char ("ON\n\r", ch);
00282     else
00283         send_to_char ("OFF\n\r", ch);
00284 
00285     send_to_char ("{qQ{x/{fA{x            ", ch);
00286     if (!IS_SET (ch->comm, COMM_NOQUESTION))
00287         send_to_char ("ON\n\r", ch);
00288     else
00289         send_to_char ("OFF\n\r", ch);
00290 
00291     send_to_char ("{hQuote{x          ", ch);
00292     if (!IS_SET (ch->comm, COMM_NOQUOTE))
00293         send_to_char ("ON\n\r", ch);
00294     else
00295         send_to_char ("OFF\n\r", ch);
00296 
00297     send_to_char ("{tgrats{x          ", ch);
00298     if (!IS_SET (ch->comm, COMM_NOGRATS))
00299         send_to_char ("ON\n\r", ch);
00300     else
00301         send_to_char ("OFF\n\r", ch);
00302 
00303     if (IS_IMMORTAL (ch))
00304     {
00305         send_to_char ("{igod channel{x    ", ch);
00306         if (!IS_SET (ch->comm, COMM_NOWIZ))
00307             send_to_char ("ON\n\r", ch);
00308         else
00309             send_to_char ("OFF\n\r", ch);
00310     }
00311 
00312     send_to_char ("{tshouts{x         ", ch);
00313     if (!IS_SET (ch->comm, COMM_SHOUTSOFF))
00314         send_to_char ("ON\n\r", ch);
00315     else
00316         send_to_char ("OFF\n\r", ch);
00317 
00318     send_to_char ("{ktells{x          ", ch);
00319     if (!IS_SET (ch->comm, COMM_DEAF))
00320         send_to_char ("ON\n\r", ch);
00321     else
00322         send_to_char ("OFF\n\r", ch);
00323 
00324     send_to_char ("{tquiet mode{x     ", ch);
00325     if (IS_SET (ch->comm, COMM_QUIET))
00326         send_to_char ("ON\n\r", ch);
00327     else
00328         send_to_char ("OFF\n\r", ch);
00329 
00330     if (IS_SET (ch->comm, COMM_AFK))
00331         send_to_char ("You are AFK.\n\r", ch);
00332 
00333     if (IS_SET (ch->comm, COMM_SNOOP_PROOF))
00334         send_to_char ("You are immune to snooping.\n\r", ch);
00335 
00336     if (ch->lines != PAGELEN)
00337     {
00338         if (ch->lines)
00339         {
00340             sprintf (buf, "You display %d lines of scroll.\n\r",
00341                      ch->lines + 2);
00342             send_to_char (buf, ch);
00343         }
00344         else
00345             send_to_char ("Scroll buffering is off.\n\r", ch);
00346     }
00347 
00348     if (ch->prompt != NULL)
00349     {
00350         sprintf (buf, "Your current prompt is: %s\n\r", ch->prompt);
00351         send_to_char (buf, ch);
00352     }
00353 
00354     if (IS_SET (ch->comm, COMM_NOSHOUT))
00355         send_to_char ("You cannot shout.\n\r", ch);
00356 
00357     if (IS_SET (ch->comm, COMM_NOTELL))
00358         send_to_char ("You cannot use tell.\n\r", ch);
00359 
00360     if (IS_SET (ch->comm, COMM_NOCHANNELS))
00361         send_to_char ("You cannot use channels.\n\r", ch);
00362 
00363     if (IS_SET (ch->comm, COMM_NOEMOTE))
00364         send_to_char ("You cannot show emotions.\n\r", ch);
00365 
00366 }

Here is the call graph for this function:

void do_clan_gossip (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 509 of file act_comm.c.

References act_new(), descriptor_data::character, char_data::comm, COMM_NOCGOS, COMM_NOCHANNELS, COMM_QUIET, CON_PLAYING, descriptor_data::connected, descriptor_list, IS_SET, MAX_STRING_LENGTH, descriptor_data::next, descriptor_data::original, POS_SLEEPING, REMOVE_BIT, send_to_char(), SET_BIT, and TO_VICT.

00510 {
00511     char buf[MAX_STRING_LENGTH];
00512     DESCRIPTOR_DATA *d;
00513 
00514     if (argument[0] == '\0')
00515     {
00516         if (IS_SET(ch->comm, COMM_NOCGOS))
00517         {
00518             send_to_char("Clan Gossip is now ON.\n\r", ch);
00519             REMOVE_BIT(ch->comm, COMM_NOCGOS);
00520         }
00521         else
00522         {
00523             send_to_char("Clan Gossip is now OFF.\n\r",ch);
00524             SET_BIT(ch->comm, COMM_NOCGOS);
00525         }
00526     }
00527     else
00528     {
00529         if (IS_SET(ch->comm, COMM_QUIET))
00530         {
00531             send_to_char("You must turn off quiet mode first.\n\r",ch);
00532             return;
00533         }
00534         if (IS_SET(ch->comm, COMM_NOCHANNELS))
00535         {
00536                     send_to_char("The gods have revoked your channel privliges.\n\r",ch);
00537                     return;
00538         }
00539         
00540                 REMOVE_BIT(ch->comm, COMM_NOCGOS);
00541         sprintf(buf, "{xYou clan gossip '{R%s{x'\n\r", argument);
00542         send_to_char(buf,ch);
00543 
00544         for(d = descriptor_list; d != NULL; d = d->next)
00545         {
00546             CHAR_DATA *victim;
00547             victim  = d->original ? d->original : d->character;
00548 
00549             if (d->connected == CON_PLAYING &&
00550                     d->character != ch && !IS_SET(victim->comm, COMM_NOCGOS) &&
00551                     !IS_SET(victim->comm, COMM_QUIET))
00552             {
00553                 act_new("{x$n clan gossips: '{R$t{x'\n\r",ch,argument,d->character,TO_VICT, POS_SLEEPING);
00554             }
00555         }
00556     }
00557 }

Here is the call graph for this function:

void do_clantalk (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 1115 of file act_comm.c.

References act_new(), descriptor_data::character, clan_table, char_data::comm, COMM_NOCHANNELS, COMM_NOCLAN, COMM_QUIET, CON_PLAYING, descriptor_data::connected, descriptor_list, clan_type::independent, is_clan(), is_same_clan(), IS_SET, MAX_STRING_LENGTH, descriptor_data::next, POS_DEAD, REMOVE_BIT, send_to_char(), SET_BIT, and TO_VICT.

01116 {
01117     char buf[MAX_STRING_LENGTH];
01118     DESCRIPTOR_DATA *d;
01119 
01120     if (!is_clan (ch) || clan_table[ch->clan].independent)
01121     {
01122         send_to_char ("You aren't in a clan.\n\r", ch);
01123         return;
01124     }
01125     if (argument[0] == '\0')
01126     {
01127         if (IS_SET (ch->cclan, COMM_NOCLAN))
01128         {
01129             send_to_char ("Clan channel is now {RON{x\n\r", ch);
01130             REMOVE_BIT (ch->cclan, COMM_NOCLAN);
01131         }
01132         else
01133         {
01134             send_to_char ("Clan channel is now {DOFF{x\n\r", ch);
01135             SET_BIT (ch->cclan, COMM_NOCLAN);
01136         }
01137         return;
01138     }
01139 
01140     if (IS_SET (ch->comm, COMM_NOCHANNELS))
01141     {
01142         send_to_char ("The gods have revoked your channel priviliges.\n\r",
01143                       ch);
01144         return;
01145     }
01146 
01147     REMOVE_BIT (ch->cclan, COMM_NOCLAN);
01148 
01149     sprintf (buf, "You clan '{R%s{x'\n\r", argument);
01150     send_to_char (buf, ch);
01151     sprintf (buf, "$n clans '{R%s{x'", argument);
01152     for (d = descriptor_list; d != NULL; d = d->next)
01153     {
01154         if (d->connected == CON_PLAYING &&
01155             d->character != ch &&
01156             is_same_clan (ch, d->character) &&
01157             !IS_SET (d->character->comm, COMM_NOCLAN) &&
01158             !IS_SET (d->character->comm, COMM_QUIET))
01159         {
01160             act_new ("$n clans '{R$t{x'{x", ch, argument, d->character, TO_VICT,
01161                      POS_DEAD);
01162         }
01163     }
01164 
01165     return;
01166 }

Here is the call graph for this function:

void do_colour (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 2898 of file act_comm.c.

References all_colour(), ALTER_COLOUR, default_colour(), IS_SET, MAX_STRING_LENGTH, one_argument(), PLR_COLOUR, REMOVE_BIT, send_to_char(), send_to_char_bw(), SET_BIT, str_cmp(), and wiznet().

02899 {
02900     char arg[MAX_STRING_LENGTH];
02901 
02902 /*    if (IS_NPC (ch))
02903     {
02904         send_to_char_bw ("Color is not on.\n\r", ch);
02905         return;
02906     }*/
02907 
02908     argument = one_argument (argument, arg);
02909 
02910     if (!*arg)
02911     {
02912         if (!IS_SET (ch->act, PLR_COLOUR))
02913         {
02914             SET_BIT (ch->act, PLR_COLOUR);
02915             send_to_char ("Color is now ON.\n\r", ch);
02916         }
02917         else
02918         {
02919             send_to_char_bw ("Color is now OFF.\n\r", ch);
02920             REMOVE_BIT (ch->act, PLR_COLOUR);
02921         }
02922         return;
02923     }
02924 
02925     if (!str_cmp (arg, "default"))
02926     {
02927         default_colour (ch);
02928         send_to_char_bw ("Color setting set to default values.\n\r", ch);
02929         return;
02930     }
02931 
02932     if (!str_cmp (arg, "all"))
02933     {
02934         all_colour (ch, argument);
02935         return;
02936     }
02937 
02938     /*
02939      * Yes, I know this is ugly and unnessessary repetition, but its old
02940      * and I can't justify the time to make it pretty. -Lope
02941      */
02942     if (!str_cmp (arg, "text"))
02943     {
02944     ALTER_COLOUR (text)}
02945     else if (!str_cmp (arg, "auction"))
02946     {
02947     ALTER_COLOUR (auction)}
02948     else if (!str_cmp (arg, "auction_text"))
02949     {
02950     ALTER_COLOUR (auction_text)}
02951     else if (!str_cmp (arg, "gossip"))
02952     {
02953     ALTER_COLOUR (gossip)}
02954     else if (!str_cmp (arg, "gossip_text"))
02955     {
02956     ALTER_COLOUR (gossip_text)}
02957     else if (!str_cmp (arg, "music"))
02958     {
02959     ALTER_COLOUR (music)}
02960     else if (!str_cmp (arg, "music_text"))
02961     {
02962     ALTER_COLOUR (music_text)}
02963     else if (!str_cmp (arg, "question"))
02964     {
02965     ALTER_COLOUR (question)}
02966     else if (!str_cmp (arg, "question_text"))
02967     {
02968     ALTER_COLOUR (question_text)}
02969     else if (!str_cmp (arg, "answer"))
02970     {
02971     ALTER_COLOUR (answer)}
02972     else if (!str_cmp (arg, "answer_text"))
02973     {
02974     ALTER_COLOUR (answer_text)}
02975     else if (!str_cmp (arg, "quote"))
02976     {
02977     ALTER_COLOUR (quote)}
02978     else if (!str_cmp (arg, "quote_text"))
02979     {
02980     ALTER_COLOUR (quote_text)}
02981     else if (!str_cmp (arg, "immtalk_text"))
02982     {
02983     ALTER_COLOUR (immtalk_text)}
02984     else if (!str_cmp (arg, "immtalk_type"))
02985     {
02986     ALTER_COLOUR (immtalk_type)}
02987     else if (!str_cmp (arg, "info"))
02988     {
02989     ALTER_COLOUR (info)}
02990     else if (!str_cmp (arg, "say"))
02991     {
02992     ALTER_COLOUR (say)}
02993     else if (!str_cmp (arg, "say_text"))
02994     {
02995     ALTER_COLOUR (say_text)}
02996     else if (!str_cmp (arg, "tell"))
02997     {
02998     ALTER_COLOUR (tell)}
02999     else if (!str_cmp (arg, "tell_text"))
03000     {
03001     ALTER_COLOUR (tell_text)}
03002     else if (!str_cmp (arg, "reply"))
03003     {
03004     ALTER_COLOUR (reply)}
03005     else if (!str_cmp (arg, "reply_text"))
03006     {
03007     ALTER_COLOUR (reply_text)}
03008     else if (!str_cmp (arg, "gtell_text"))
03009     {
03010     ALTER_COLOUR (gtell_text)}
03011     else if (!str_cmp (arg, "gtell_type"))
03012     {
03013     ALTER_COLOUR (gtell_type)}
03014     else if (!str_cmp (arg, "wiznet"))
03015     {
03016     ALTER_COLOUR (wiznet)}
03017     else if (!str_cmp (arg, "room_title"))
03018     {
03019     ALTER_COLOUR (room_title)}
03020     else if (!str_cmp (arg, "room_text"))
03021     {
03022     ALTER_COLOUR (room_text)}
03023     else if (!str_cmp (arg, "room_exits"))
03024     {
03025     ALTER_COLOUR (room_exits)}
03026     else if (!str_cmp (arg, "room_things"))
03027     {
03028     ALTER_COLOUR (room_things)}
03029     else if (!str_cmp (arg, "prompt"))
03030     {
03031     ALTER_COLOUR (prompt)}
03032     else if (!str_cmp (arg, "fight_death"))
03033     {
03034     ALTER_COLOUR (fight_death)}
03035     else if (!str_cmp (arg, "fight_yhit"))
03036     {
03037     ALTER_COLOUR (fight_yhit)}
03038     else if (!str_cmp (arg, "fight_ohit"))
03039     {
03040     ALTER_COLOUR (fight_ohit)}
03041     else if (!str_cmp (arg, "fight_thit"))
03042     {
03043     ALTER_COLOUR (fight_thit)}
03044     else if (!str_cmp (arg, "fight_skill"))
03045     {
03046     ALTER_COLOUR (fight_skill)}
03047     else
03048     {
03049         send_to_char_bw ("Unrecognised Colour Parameter Not Set.\n\r", ch);
03050         return;
03051     }
03052 
03053     send_to_char_bw ("New Colour Parameter Set.\n\r", ch);
03054     return;
03055 }

Here is the call graph for this function:

void do_deaf (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 370 of file act_comm.c.

References COMM_DEAF, IS_SET, REMOVE_BIT, send_to_char(), and SET_BIT.

00371 {
00372 
00373     if (IS_SET (ch->comm, COMM_DEAF))
00374     {
00375         send_to_char ("You can now hear tells again.\n\r", ch);
00376         REMOVE_BIT (ch->comm, COMM_DEAF);
00377     }
00378     else
00379     {
00380         send_to_char ("From now on, you won't hear tells.\n\r", ch);
00381         SET_BIT (ch->comm, COMM_DEAF);
00382     }
00383 }

Here is the call graph for this function:

void do_delet (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 48 of file act_comm.c.

References send_to_char().

00049 {
00050     send_to_char ("You must type the full command to delete yourself.\n\r",
00051                   ch);
00052 }

Here is the call graph for this function:

void do_delete (  CHAR_DATA *  ch,
char *  argument
) 
 

Definition at line 54 of file act_comm.c.

References capitalize(), do_function(), do_quit(), FALSE, get_trust(), IS_NPC, MAX_INPUT_LENGTH, send_to_char(), stop_fighting(), TRUE, unlink()