/**************************************************************************
* Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, *
* Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. *
* *
* Merc Diku Mud improvements 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 *
* benefiting. 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 *
***************************************************************************
* 1stMUD ROM Derivative (c) 2001-2002 by Ryan Jennings *
* http://1stmud.dlmud.com/ <r-jenn@shaw.ca> *
***************************************************************************/
#include <sys/types.h>
#if !defined(WIN32)
#include <unistd.h>
#include <sys/time.h>
#else
#include "../win32/winstuff.h"
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <stdarg.h>
#include "merc.h"
#include "interp.h"
#include "recycle.h"
#include "tables.h"
#include "lookup.h"
#include "olc.h"
/* RT code to delete yourself */
CH_CMD (do_delet)
{
chprintln (ch, "You must type the full command to delete yourself.");
}
CH_CMD (do_delete)
{
char strsave[MAX_INPUT_LENGTH];
if (IS_NPC (ch))
return;
if (ch->pcdata->confirm_delete)
{
if (argument[0] != '\0')
{
chprintln (ch, "Delete status removed.");
ch->pcdata->confirm_delete = FALSE;
return;
}
else
{
delete_home (ch);
update_statlist (ch, TRUE);
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')
{
chprintln (ch, "Just type delete. No argument.");
return;
}
chprintln (ch, "Type delete again to confirm this command.");
chprintln (ch, "WARNING: this command is irreversible.");
chprintln (ch, "Typing delete with an argument will undo delete status.");
ch->pcdata->confirm_delete = TRUE;
wiznet ("$N is contemplating deletion.", ch, NULL, 0, 0, get_trust (ch));
}
/* RT code to display channel status */
CH_CMD (do_channels)
{
/* lists all channels and their status */
chprintln (ch, " channel status");
chprintln (ch, "---------------------");
chprint (ch, "gossip ");
if (!IS_SET (ch->comm, COMM_NOGOSSIP))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
chprint (ch, "auction ");
if (!IS_SET (ch->comm, COMM_NOAUCTION))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
chprint (ch, "music ");
if (!IS_SET (ch->comm, COMM_NOMUSIC))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
chprint (ch, "Q/A ");
if (!IS_SET (ch->comm, COMM_NOQUESTION))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
chprint (ch, "Quote ");
if (!IS_SET (ch->comm, COMM_NOQUOTE))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
chprint (ch, "grats ");
if (!IS_SET (ch->comm, COMM_NOGRATS))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
if (IS_IMMORTAL (ch))
{
chprint (ch, "god channel ");
if (!IS_SET (ch->comm, COMM_NOWIZ))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
}
chprint (ch, "shouts ");
if (!IS_SET (ch->comm, COMM_SHOUTSOFF))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
chprint (ch, "tells ");
if (!IS_SET (ch->comm, COMM_DEAF))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
chprint (ch, "quiet mode ");
if (IS_SET (ch->comm, COMM_QUIET))
chprintln (ch, "ON");
else
chprintln (ch, "OFF");
if (IS_SET (ch->comm, COMM_AFK))
chprintln (ch, "You are AFK.");
if (IS_SET (ch->comm, COMM_SNOOP_PROOF))
chprintln (ch, "You are immune to snooping.");
if (ch->lines != PAGELEN)
{
if (ch->lines)
{
chprintlnf (ch, "You display %d lines of scroll.", ch->lines + 2);
}
else
chprintln (ch, "Scroll buffering is off.");
}
if (ch->prompt != NULL)
{
chprintlnf (ch, "Your current prompt is: %s", ch->prompt);
}
if (IS_SET (ch->comm, COMM_NOSHOUT))
chprintln (ch, "You cannot shout.");
if (IS_SET (ch->comm, COMM_NOTELL))
chprintln (ch, "You cannot use tell.");
if (IS_SET (ch->comm, COMM_NOCHANNELS))
chprintln (ch, "You cannot use channels.");
if (IS_SET (ch->comm, COMM_NOEMOTE))
chprintln (ch, "You cannot show emotions.");
}
/* RT deaf blocks out all shouts */
CH_CMD (do_deaf)
{
if (IS_SET (ch->comm, COMM_DEAF))
{
chprintln (ch, "You can now hear tells again.");
REMOVE_BIT (ch->comm, COMM_DEAF);
}
else
{
chprintln (ch, "From now on, you won't hear tells.");
SET_BIT (ch->comm, COMM_DEAF);
}
}
/* RT quiet blocks out all communication */
CH_CMD (do_quiet)
{
if (IS_SET (ch->comm, COMM_QUIET))
{
chprintln (ch, "Quiet mode removed.");
REMOVE_BIT (ch->comm, COMM_QUIET);
}
else
{
chprintln (ch, "From now on, you will only hear says and emotes.");
SET_BIT (ch->comm, COMM_QUIET);
}
}
/* afk command */
CH_CMD (do_afk)
{
if (IS_SET (ch->comm, COMM_AFK))
{
chprintln (ch, "AFK mode removed. Type 'replay' to see tells.");
REMOVE_BIT (ch->comm, COMM_AFK);
}
else
{
chprintln (ch, "You are now in AFK mode.");
SET_BIT (ch->comm, COMM_AFK);
}
}
CH_CMD (do_replay)
{
if (IS_NPC (ch))
{
chprintln (ch, "You can't replay.");
return;
}
if (buf_string (ch->pcdata->buffer)[0] == '\0')
{
chprintln (ch, "You have no tells to replay.");
return;
}
page_to_char (buf_string (ch->pcdata->buffer), ch);
clear_buf (ch->pcdata->buffer);
}
/* RT auction rewritten in ROM style */
CH_CMD (do_auction)
{
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOAUCTION))
{
chprintln (ch, "Auction channel is now ON.");
REMOVE_BIT (ch->comm, COMM_NOAUCTION);
}
else
{
chprintln (ch, "Auction channel is now OFF.");
SET_BIT (ch->comm, COMM_NOAUCTION);
}
}
else /* auction message sent, turn auction on if it is off */
{
if (IS_SET (ch->comm, COMM_QUIET))
{
chprintln (ch, "You must turn off quiet mode first.");
return;
}
if (IS_SET (ch->comm, COMM_NOCHANNELS))
{
chprintln (ch, "The gods have revoked your channel priviliges.");
return;
}
REMOVE_BIT (ch->comm, COMM_NOAUCTION);
}
chprintlnf (ch, "You auction '%s'", 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_NOAUCTION) &&
!IS_SET (victim->comm, COMM_QUIET))
{
act_new ("$n auctions '$t'", ch, argument, d->character,
TO_VICT, POS_DEAD);
}
}
}
/* RT chat replaced with ROM gossip */
CH_CMD (do_gossip)
{
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOGOSSIP))
{
chprintln (ch, "Gossip channel is now ON.");
REMOVE_BIT (ch->comm, COMM_NOGOSSIP);
}
else
{
chprintln (ch, "Gossip channel is now OFF.");
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))
{
chprintln (ch, "You must turn off quiet mode first.");
return;
}
if (IS_SET (ch->comm, COMM_NOCHANNELS))
{
chprintln (ch, "The gods have revoked your channel priviliges.");
return;
}
REMOVE_BIT (ch->comm, COMM_NOGOSSIP);
chprintlnf (ch,
"" CTAG (_GOSSIP1) "You gossip '" CTAG (_GOSSIP2) "%s"
CTAG (_GOSSIP1) "'{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_NOGOSSIP) &&
!IS_SET (victim->comm, COMM_QUIET))
{
act_new ("" CTAG (_GOSSIP1) "$n gossips '"
CTAG (_GOSSIP2) "$t" CTAG (_GOSSIP1)
"'{x", ch, argument, d->character,
TO_VICT, POS_SLEEPING);
}
}
}
}
CH_CMD (do_grats)
{
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOGRATS))
{
chprintln (ch, "Grats channel is now ON.");
REMOVE_BIT (ch->comm, COMM_NOGRATS);
}
else
{
chprintln (ch, "Grats channel is now OFF.");
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))
{
chprintln (ch, "You must turn off quiet mode first.");
return;
}
if (IS_SET (ch->comm, COMM_NOCHANNELS))
{
chprintln (ch, "The gods have revoked your channel priviliges.");
return;
}
REMOVE_BIT (ch->comm, COMM_NOGRATS);
chprintlnf (ch,
"" CTAG (_GRATS1) "You grats '" CTAG (_GRATS2) "%s"
CTAG (_GRATS1) "'{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_NOGRATS) &&
!IS_SET (victim->comm, COMM_QUIET))
{
act_new ("" CTAG (_GRATS1) "$n grats '"
CTAG (_GRATS2) "$t" CTAG (_GRATS1) "'{x",
ch, argument, d->character, TO_VICT, POS_SLEEPING);
}
}
}
}
CH_CMD (do_quote)
{
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOQUOTE))
{
chprintln (ch, "Quote channel is now ON.");
REMOVE_BIT (ch->comm, COMM_NOQUOTE);
}
else
{
chprintln (ch, "Quote channel is now OFF.");
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))
{
chprintln (ch, "You must turn off quiet mode first.");
return;
}
if (IS_SET (ch->comm, COMM_NOCHANNELS))
{
chprintln (ch, "The gods have revoked your channel priviliges.");
return;
}
REMOVE_BIT (ch->comm, COMM_NOQUOTE);
chprintlnf (ch,
"" CTAG (_QUOTE1) "You quote '" CTAG (_QUOTE2) "%s"
CTAG (_QUOTE1) "'{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_NOQUOTE) &&
!IS_SET (victim->comm, COMM_QUIET))
{
act_new ("" CTAG (_QUOTE1) "$n quotes '"
CTAG (_QUOTE2) "$t" CTAG (_QUOTE1) "'{x",
ch, argument, d->character, TO_VICT, POS_SLEEPING);
}
}
}
}
/* RT question channel */
CH_CMD (do_question)
{
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOQUESTION))
{
chprintln (ch, "Q/A channel is now ON.");
REMOVE_BIT (ch->comm, COMM_NOQUESTION);
}
else
{
chprintln (ch, "Q/A channel is now OFF.");
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))
{
chprintln (ch, "You must turn off quiet mode first.");
return;
}
if (IS_SET (ch->comm, COMM_NOCHANNELS))
{
chprintln (ch, "The gods have revoked your channel priviliges.");
return;
}
REMOVE_BIT (ch->comm, COMM_NOQUESTION);
chprintlnf (ch,
"" CTAG (_QA1) "You question '" CTAG (_QA2) "%s"
CTAG (_QA1) "'{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_NOQUESTION) &&
!IS_SET (victim->comm, COMM_QUIET))
{
act_new ("" CTAG (_QA1) "$n questions '"
CTAG (_QA2) "$t" CTAG (_QA1) "'{x", ch,
argument, d->character, TO_VICT, POS_SLEEPING);
}
}
}
}
/* RT answer channel - uses same line as questions */
CH_CMD (do_answer)
{
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOQUESTION))
{
chprintln (ch, "Q/A channel is now ON.");
REMOVE_BIT (ch->comm, COMM_NOQUESTION);
}
else
{
chprintln (ch, "Q/A channel is now OFF.");
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))
{
chprintln (ch, "You must turn off quiet mode first.");
return;
}
if (IS_SET (ch->comm, COMM_NOCHANNELS))
{
chprintln (ch, "The gods have revoked your channel priviliges.");
return;
}
REMOVE_BIT (ch->comm, COMM_NOQUESTION);
chprintlnf (ch,
"" CTAG (_QA1) "You answer '" CTAG (_QA2) "%s"
CTAG (_QA1) "'{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_NOQUESTION) &&
!IS_SET (victim->comm, COMM_QUIET))
{
act_new ("" CTAG (_QA1) "$n answers '" CTAG (_QA2)
"$t" CTAG (_QA1) "'{x", ch, argument,
d->character, TO_VICT, POS_SLEEPING);
}
}
}
}
/* RT music channel */
CH_CMD (do_music)
{
char buf[MAX_STRING_LENGTH];
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOMUSIC))
{
chprintln (ch, "Music channel is now ON.");
REMOVE_BIT (ch->comm, COMM_NOMUSIC);
}
else
{
chprintln (ch, "Music channel is now OFF.");
SET_BIT (ch->comm, COMM_NOMUSIC);
}
}
else /* music sent, turn music on if it isn't already */
{
if (IS_SET (ch->comm, COMM_QUIET))
{
chprintln (ch, "You must turn off quiet mode first.");
return;
}
if (IS_SET (ch->comm, COMM_NOCHANNELS))
{
chprintln (ch, "The gods have revoked your channel priviliges.");
return;
}
REMOVE_BIT (ch->comm, COMM_NOMUSIC);
chprintlnf (ch,
"" CTAG (_MUSIC1) "You MUSIC" CTAG (_MUSIC2) ": "
CTAG (_MUSIC1) "'" CTAG (_MUSIC3) "%s" CTAG (_MUSIC1)
"'{x", argument);
sprintf (buf, "$n MUSIC: '%s'", 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 ("" CTAG (_MUSIC1) "$n MUSIC"
CTAG (_MUSIC2) ": " CTAG (_MUSIC1) "'"
CTAG (_MUSIC3) "$t" CTAG (_MUSIC1) "'{x",
ch, argument, d->character, TO_VICT, POS_SLEEPING);
}
}
}
}
/* clan channels */
CH_CMD (do_clantalk)
{
char buf[MAX_STRING_LENGTH];
DESCRIPTOR_DATA *d;
if (!is_clan (ch) || clan_table[ch->clan].independent)
{
chprintln (ch, "You aren't in a clan.");
return;
}
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOCLAN))
{
chprintln (ch, "Clan channel is now ON");
REMOVE_BIT (ch->comm, COMM_NOCLAN);
}
else
{
chprintln (ch, "Clan channel is now OFF");
SET_BIT (ch->comm, COMM_NOCLAN);
}
return;
}
if (IS_SET (ch->comm, COMM_NOCHANNELS))
{
chprintln (ch, "The gods have revoked your channel priviliges.");
return;
}
REMOVE_BIT (ch->comm, COMM_NOCLAN);
chprintlnf (ch, "You clan '%s'", argument);
sprintf (buf, "$n clans '%s'", 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 '$t'", ch, argument, d->character,
TO_VICT, POS_DEAD);
}
}
return;
}
CH_CMD (do_immtalk)
{
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_NOWIZ))
{
chprintln (ch, "Immortal channel is now ON");
REMOVE_BIT (ch->comm, COMM_NOWIZ);
}
else
{
chprintln (ch, "Immortal channel is now OFF");
SET_BIT (ch->comm, COMM_NOWIZ);
}
return;
}
REMOVE_BIT (ch->comm, COMM_NOWIZ);
act_new ("" CTAG (_IMMTALK1) "$n" CTAG (_IMMTALK2) ":"
CTAG (_IMMTALK3) " $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 ("" CTAG (_IMMTALK1) "$n" CTAG (_IMMTALK2) ":"
CTAG (_IMMTALK3) " $t{x", ch, argument,
d->character, TO_VICT, POS_DEAD);
}
}
return;
}
CH_CMD (do_say)
{
if (argument[0] == '\0')
{
chprintln (ch, "Say what?");
return;
}
act ("" CTAG (_SAY1) "$n says '" CTAG (_SAY2) "$T" CTAG (_SAY1)
"'{x", ch, NULL, argument, TO_ROOM);
act ("" CTAG (_SAY1) "You say '" CTAG (_SAY2) "$T" CTAG (_SAY1)
"'{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;
}
CH_CMD (do_shout)
{
DESCRIPTOR_DATA *d;
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_SHOUTSOFF))
{
chprintln (ch, "You can hear shouts again.");
REMOVE_BIT (ch->comm, COMM_SHOUTSOFF);
}
else
{
chprintln (ch, "You will no longer hear shouts.");
SET_BIT (ch->comm, COMM_SHOUTSOFF);
}
return;
}
if (IS_SET (ch->comm, COMM_NOSHOUT))
{
chprintln (ch, "You can't shout.");
return;
}
REMOVE_BIT (ch->comm, COMM_SHOUTSOFF);
WAIT_STATE (ch, 12);
act ("" CTAG (_SHOUT1) "You shout '" CTAG (_SHOUT2) "$T"
CTAG (_SHOUT1) "'{x", ch, NULL, argument, TO_CHAR);
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_SHOUTSOFF) &&
!IS_SET (victim->comm, COMM_QUIET))
{
act ("" CTAG (_SHOUT1) "$n shouts '" CTAG (_SHOUT2) "$t"
CTAG (_SHOUT1) "'{x", ch, argument, d->character, TO_VICT);
}
}
return;
}
CH_CMD (do_tell)
{
char arg[MAX_INPUT_LENGTH], buf[MAX_STRING_LENGTH];
CHAR_DATA *victim;
if (IS_SET (ch->comm, COMM_NOTELL) || IS_SET (ch->comm, COMM_DEAF))
{
chprintln (ch, "Your message didn't get through.");
return;
}
if (IS_SET (ch->comm, COMM_QUIET))
{
chprintln (ch, "You must turn off quiet mode first.");
return;
}
if (IS_SET (ch->comm, COMM_DEAF))
{
chprintln (ch, "You must turn off deaf mode first.");
return;
}
argument = one_argument (argument, arg);
if (arg[0] == '\0' || argument[0] == '\0')
{
chprintln (ch, "Tell whom what?");
return;
}
/*
* Can tell to PC's anywhere, but NPC's only in same room.
* -- Furey
*/
if ((victim = get_char_world (ch, arg)) == NULL ||
(IS_NPC (victim) && victim->in_room != ch->in_room))
{
chprintln (ch, "They aren't here.");
return;
}
if (victim->desc == NULL && !IS_NPC (victim))
{
act ("$N seems to have misplaced $S link...try again later.", ch,
NULL, victim, TO_CHAR);
sprintf (buf, "%s tells you '%s'\n\r", PERS (ch, victim), argument);
buf[0] = UPPER (buf[0]);
add_buf (victim->pcdata->buffer, buf);
return;
}
if (!(IS_IMMORTAL (ch) && ch->level > LEVEL_IMMORTAL) &&
!IS_AWAKE (victim))
{
act ("$E can't hear you.", ch, 0, victim, TO_CHAR);
return;
}
if ((IS_SET (victim->comm, COMM_QUIET) ||
IS_SET (victim->comm, COMM_DEAF)) && !IS_IMMORTAL (ch))
{
act ("$E is not receiving tells.", ch, 0, victim, TO_CHAR);
return;
}
if (IS_SET (victim->comm, COMM_AFK))
{
if (IS_NPC (victim))
{
act ("$E is AFK, and not receiving tells.", ch, NULL,
victim, TO_CHAR);
return;
}
act ("$E is AFK, but your tell will go through when $E returns.",
ch, NULL, victim, TO_CHAR);
sprintf (buf, "%s tells you '%s'\n\r", PERS (ch, victim), argument);
buf[0] = UPPER (buf[0]);
add_buf (victim->pcdata->buffer, buf);
return;
}
act ("" CTAG (_TELLS1) "You tell $N '" CTAG (_TELLS2) "$t"
CTAG (_TELLS1) "'{x", ch, argument, victim, TO_CHAR);
act_new ("" CTAG (_TELLS1) "$n tells you '" CTAG (_TELLS2) "$t"
CTAG (_TELLS1) "'{x", ch, argument, victim, TO_VICT, POS_DEAD);
victim->reply = ch;
if (!IS_NPC (ch) && IS_NPC (victim) && HAS_TRIGGER (victim, TRIG_SPEECH))
mp_act_trigger (argument, victim, ch, NULL, NULL, TRIG_SPEECH);
return;
}
CH_CMD (do_reply)
{
CHAR_DATA *victim;
char buf[MAX_STRING_LENGTH];
if (IS_SET (ch->comm, COMM_NOTELL))
{
chprintln (ch, "Your message didn't get through.");
return;
}
if ((victim = ch->reply) == NULL)
{
chprintln (ch, "They aren't here.");
return;
}
if (victim->desc == NULL && !IS_NPC (victim))
{
act ("$N seems to have misplaced $S link...try again later.", ch,
NULL, victim, TO_CHAR);
sprintf (buf, "%s tells you '%s'\n\r", PERS (ch, victim), argument);
buf[0] = UPPER (buf[0]);
add_buf (victim->pcdata->buffer, buf);
return;
}
if (!IS_IMMORTAL (ch) && !IS_AWAKE (victim))
{
act ("$E can't hear you.", ch, 0, victim, TO_CHAR);
return;
}
if ((IS_SET (victim->comm, COMM_QUIET) ||
IS_SET (victim->comm, COMM_DEAF)) && !IS_IMMORTAL (ch) &&
!IS_IMMORTAL (victim))
{
act_new ("$E is not receiving tells.", ch, 0, victim, TO_CHAR,
POS_DEAD);
return;
}
if (!IS_IMMORTAL (victim) && !IS_AWAKE (ch))
{
chprintln (ch, "In your dreams, or what?");
return;
}
if (IS_SET (victim->comm, COMM_AFK))
{
if (IS_NPC (victim))
{
act_new ("$E is AFK, and not receiving tells.", ch, NULL,
victim, TO_CHAR, POS_DEAD);
return;
}
act_new
("$E is AFK, but your tell will go through when $E returns.",
ch, NULL, victim, TO_CHAR, POS_DEAD);
sprintf (buf, "%s tells you '%s'\n\r", PERS (ch, victim), argument);
buf[0] = UPPER (buf[0]);
add_buf (victim->pcdata->buffer, buf);
return;
}
act_new ("You tell $N '$t'", ch, argument, victim, TO_CHAR, POS_DEAD);
act_new ("$n tells you '$t'", ch, argument, victim, TO_VICT, POS_DEAD);
victim->reply = ch;
return;
}
CH_CMD (do_yell)
{
DESCRIPTOR_DATA *d;
if (IS_SET (ch->comm, COMM_NOSHOUT))
{
chprintln (ch, "You can't yell.");
return;
}
if (argument[0] == '\0')
{
chprintln (ch, "Yell what?");
return;
}
act ("You yell '$t'", ch, argument, NULL, TO_CHAR);
for (d = descriptor_list; d != NULL; d = d->next)
{
if (d->connected == CON_PLAYING && d->character != ch &&
d->character->in_room != NULL &&
d->character->in_room->area == ch->in_room->area &&
!IS_SET (d->character->comm, COMM_QUIET))
{
act ("$n yells '$t'", ch, argument, d->character, TO_VICT);
}
}
return;
}
CH_CMD (do_emote)
{
if (!IS_NPC (ch) && IS_SET (ch->comm, COMM_NOEMOTE))
{
chprintln (ch, "You can't show your emotions.");
return;
}
if (argument[0] == '\0')
{
chprintln (ch, "Emote what?");
return;
}
MOBtrigger = FALSE;
act ("$n $T", ch, NULL, argument, TO_ROOM);
act ("$n $T", ch, NULL, argument, TO_CHAR);
MOBtrigger = TRUE;
return;
}
CH_CMD (do_pmote)
{
CHAR_DATA *vch;
const char *letter, *name;
char last[MAX_INPUT_LENGTH], temp[MAX_STRING_LENGTH];
unsigned int matches = 0;
if (!IS_NPC (ch) && IS_SET (ch->comm, COMM_NOEMOTE))
{
chprintln (ch, "You can't show your emotions.");
return;
}
if (argument[0] == '\0')
{
chprintln (ch, "Emote what?");
return;
}
act ("$n $t", ch, argument, NULL, TO_CHAR);
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)
{
MOBtrigger = FALSE;
act ("$N $t", vch, argument, ch, TO_CHAR);
MOBtrigger = TRUE;
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;
}
MOBtrigger = FALSE;
act ("$N $t", vch, temp, ch, TO_CHAR);
MOBtrigger = TRUE;
}
return;
}
CH_CMD (do_bug)
{
append_file (ch, BUG_FILE, argument);
chprintln (ch, "Bug logged.");
return;
}
CH_CMD (do_typo)
{
append_file (ch, TYPO_FILE, argument);
chprintln (ch, "Typo logged.");
return;
}
CH_CMD (do_rent)
{
chprintln (ch, "There is no rent here. Just save and quit.");
return;
}
CH_CMD (do_qui)
{
chprintln (ch, "If you want to QUIT, you have to spell it out.");
return;
}
CH_CMD (do_quit)
{
DESCRIPTOR_DATA *d, *d_next;
int id;
if (IS_NPC (ch))
return;
if (ch->position == POS_FIGHTING)
{
chprintln (ch, "No way! You are fighting.");
return;
}
if (ch->position < POS_STUNNED)
{
chprintln (ch, "You're not DEAD yet.");
return;
}
chprintln (ch, "Alas, all good things must come to an end.");
announce (ch, INFO_LOGOUT, "$n has left the realms.");
act ("$n has left the game.", ch, NULL, NULL, TO_ROOM);
sprintf (log_buf, "%s has quit.", ch->name);
log_string (log_buf);
wiznet ("$N rejoins the real world.", ch, NULL, WIZ_LOGINS, 0,
get_trust (ch));
/*
* After extract_char the ch is no longer valid!
*/
save_char_obj (ch);
/* Free note that might be there somehow */
if (ch->pcdata->in_progress)
free_note (ch->pcdata->in_progress);
id = ch->id;
d = ch->desc;
extract_char (ch, TRUE);
if (d != NULL)
close_socket (d);
/* toast evil cheating bastards */
for (d = descriptor_list; d != NULL; d = d_next)
{
CHAR_DATA *tch;
d_next = d->next;
tch = d->original ? d->original : d->character;
if (tch && tch->id == id)
{
extract_char (tch, TRUE);
close_socket (d);
}
}
return;
}
CH_CMD (do_save)
{
if (IS_NPC (ch))
return;
save_char_obj (ch);
update_statlist (ch, FALSE);
chprintln (ch, "Saving. Remember that ROM has automatic saving now.");
WAIT_STATE (ch, PULSE_VIOLENCE);
return;
}
CH_CMD (do_follow)
{
/* RT changed to allow unlimited following and follow the NOFOLLOW rules */
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
one_argument (argument, arg);
if (arg[0] == '\0')
{
chprintln (ch, "Follow whom?");
return;
}
if ((victim = get_char_room (ch, arg)) == NULL)
{
chprintln (ch, "They aren't here.");
return;
}
if (IS_AFFECTED (ch, AFF_CHARM) && ch->master != NULL)
{
act ("But you'd rather follow $N!", ch, NULL, ch->master, TO_CHAR);
return;
}
if (victim == ch)
{
if (ch->master == NULL)
{
chprintln (ch, "You already follow yourself.");
return;
}
stop_follower (ch);
return;
}
if (!IS_NPC (victim) && IS_SET (victim->act, PLR_NOFOLLOW) &&
!IS_IMMORTAL (ch))
{
act ("$N doesn't seem to want any followers.\n\r", ch, NULL,
victim, TO_CHAR);
return;
}
REMOVE_BIT (ch->act, PLR_NOFOLLOW);
if (ch->master != NULL)
stop_follower (ch);
add_follower (ch, victim);
return;
}
void add_follower (CHAR_DATA * ch, CHAR_DATA * master)
{
if (ch->master != NULL)
{
bug ("Add_follower: non-null master.", 0);
return;
}
ch->master = master;
ch->leader = NULL;
if (can_see (master, ch))
act ("$n now follows you.", ch, NULL, master, TO_VICT);
act ("You now follow $N.", ch, NULL, master, TO_CHAR);
return;
}
void stop_follower (CHAR_DATA * ch)
{
if (ch->master == NULL)
{
bug ("Stop_follower: null master.", 0);
return;
}
if (IS_AFFECTED (ch, AFF_CHARM))
{
REMOVE_BIT (ch->affected_by, AFF_CHARM);
affect_strip (ch, gsn_charm_person);
}
if (can_see (ch->master, ch) && ch->in_room != NULL)
{
act ("$n stops following you.", ch, NULL, ch->master, TO_VICT);
act ("You stop following $N.", ch, NULL, ch->master, TO_CHAR);
}
if (ch->master->pet == ch)
ch->master->pet = NULL;
ch->master = NULL;
ch->leader = NULL;
return;
}
/* nukes charmed monsters and pets */
void nuke_pets (CHAR_DATA * ch)
{
CHAR_DATA *pet;
if ((pet = ch->pet) != NULL)
{
stop_follower (pet);
if (pet->in_room != NULL)
act ("$N slowly fades away.", ch, NULL, pet, TO_NOTVICT);
extract_char (pet, TRUE);
}
ch->pet = NULL;
return;
}
void die_follower (CHAR_DATA * ch)
{
CHAR_DATA *fch;
if (ch->master != NULL)
{
if (ch->master->pet == ch)
ch->master->pet = NULL;
stop_follower (ch);
}
ch->leader = NULL;
for (fch = char_list; fch != NULL; fch = fch->next)
{
if (fch->master == ch)
stop_follower (fch);
if (fch->leader == ch)
fch->leader = fch;
}
return;
}
CH_CMD (do_order)
{
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
CHAR_DATA *och;
CHAR_DATA *och_next;
bool found;
bool fAll;
argument = one_argument (argument, arg);
one_argument (argument, arg2);
if (!str_cmp (arg2, "delete") || !str_cmp (arg2, "mob"))
{
chprintln (ch, "That will NOT be done.");
return;
}
if (arg[0] == '\0' || argument[0] == '\0')
{
chprintln (ch, "Order whom to do what?");
return;
}
if (IS_AFFECTED (ch, AFF_CHARM))
{
chprintln (ch, "You feel like taking, not giving, orders.");
return;
}
if (!str_cmp (arg, "all"))
{
fAll = TRUE;
victim = NULL;
}
else
{
fAll = FALSE;
if ((victim = get_char_room (ch, arg)) == NULL)
{
chprintln (ch, "They aren't here.");
return;
}
if (victim == ch)
{
chprintln (ch, "Aye aye, right away!");
return;
}
if (!IS_AFFECTED (victim, AFF_CHARM) || victim->master != ch ||
(IS_IMMORTAL (victim) && victim->trust >= ch->trust))
{
chprintln (ch, "Do it yourself!");
return;
}
}
found = FALSE;
for (och = ch->in_room->people; och != NULL; och = och_next)
{
och_next = och->next_in_room;
if (IS_AFFECTED (och, AFF_CHARM) && och->master == ch &&
(fAll || och == victim))
{
found = TRUE;
sprintf (buf, "$n orders you to '%s'.", argument);
act (buf, ch, NULL, och, TO_VICT);
interpret (och, argument);
}
}
if (found)
{
WAIT_STATE (ch, PULSE_VIOLENCE);
chprintln (ch, "Ok.");
}
else
chprintln (ch, "You have no followers here.");
return;
}
CH_CMD (do_group)
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
one_argument (argument, arg);
if (arg[0] == '\0')
{
CHAR_DATA *gch;
CHAR_DATA *leader;
leader = (ch->leader != NULL) ? ch->leader : ch;
chprintlnf (ch, "%s's group:", PERS (leader, ch));
for (gch = char_list; gch != NULL; gch = gch->next)
{
if (is_same_group (gch, ch))
{
chprintlnf (ch,
"[%2d %s] %-16s %4ld/%4ld hp %4ld/%4ld mana %4ld/%4ld mv %5d xp",
gch->level,
IS_NPC (gch) ? "Mob" : class_who (gch),
capitalize (PERS (gch, ch)), gch->hit,
gch->max_hit, gch->mana, gch->max_mana,
gch->move, gch->max_move, gch->exp);
}
}
return;
}
if ((victim = get_char_room (ch, arg)) == NULL)
{
chprintln (ch, "They aren't here.");
return;
}
if (ch->master != NULL || (ch->leader != NULL && ch->leader != ch))
{
chprintln (ch, "But you are following someone else!");
return;
}
if (victim->master != ch && ch != victim)
{
act_new ("$N isn't following you.", ch, NULL, victim, TO_CHAR,
POS_SLEEPING);
return;
}
if (IS_AFFECTED (victim, AFF_CHARM))
{
chprintln (ch, "You can't remove charmed mobs from your group.");
return;
}
if (IS_AFFECTED (ch, AFF_CHARM))
{
act_new ("You like your master too much to leave $m!", ch, NULL,
victim, TO_VICT, POS_SLEEPING);
return;
}
if (is_same_group (victim, ch) && ch != victim)
{
victim->leader = NULL;
act_new ("$n removes $N from $s group.", ch, NULL, victim,
TO_NOTVICT, POS_RESTING);
act_new ("$n removes you from $s group.", ch, NULL, victim,
TO_VICT, POS_SLEEPING);
act_new ("You remove $N from your group.", ch, NULL, victim,
TO_CHAR, POS_SLEEPING);
return;
}
victim->leader = ch;
act_new ("$N joins $n's group.", ch, NULL, victim, TO_NOTVICT,
POS_RESTING);
act_new ("You join $n's group.", ch, NULL, victim, TO_VICT, POS_SLEEPING);
act_new ("$N joins your group.", ch, NULL, victim, TO_CHAR, POS_SLEEPING);
return;
}
/*
* 'Split' originally by Gnort, God of Chaos.
*/
CH_CMD (do_split)
{
char buf[MAX_STRING_LENGTH];
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
CHAR_DATA *gch;
int members;
int amount_gold = 0, amount_silver = 0;
int share_gold, share_silver;
int extra_gold, extra_silver;
argument = one_argument (argument, arg1);
one_argument (argument, arg2);
if (arg1[0] == '\0')
{
chprintln (ch, "Split how much?");
return;
}
amount_silver = atoi (arg1);
if (arg2[0] != '\0')
amount_gold = atoi (arg2);
if (amount_gold < 0 || amount_silver < 0)
{
chprintln (ch, "Your group wouldn't like that.");
return;
}
if (amount_gold == 0 && amount_silver == 0)
{
chprintln (ch, "You hand out zero coins, but no one notices.");
return;
}
if (ch->gold < amount_gold || ch->silver < amount_silver)
{
chprintln (ch, "You don't have that much to split.");
return;
}
members = 0;
for (gch = ch->in_room->people; gch != NULL; gch = gch->next_in_room)
{
if (is_same_group (gch, ch) && !IS_AFFECTED (gch, AFF_CHARM))
members++;
}
if (members < 2)
{
chprintln (ch, "Just keep it all.");
return;
}
share_silver = amount_silver / members;
extra_silver = amount_silver % members;
share_gold = amount_gold / members;
extra_gold = amount_gold % members;
if (share_gold == 0 && share_silver == 0)
{
chprintln (ch, "Don't even bother, cheapskate.");
return;
}
ch->silver -= amount_silver;
ch->silver += share_silver + extra_silver;
ch->gold -= amount_gold;
ch->gold += share_gold + extra_gold;
if (share_silver > 0)
{
chprintlnf (ch,
"You split %d silver coins. Your share is %d silver.",
amount_silver, share_silver + extra_silver);
}
if (share_gold > 0)
{
chprintlnf (ch,
"You split %d gold coins. Your share is %d gold.",
amount_gold, share_gold + extra_gold);
}
if (share_gold == 0)
{
sprintf (buf,
"$n splits %d silver coins. Your share is %d silver.",
amount_silver, share_silver);
}
else if (share_silver == 0)
{
sprintf (buf, "$n splits %d gold coins. Your share is %d gold.",
amount_gold, share_gold);
}
else
{
sprintf (buf,
"$n splits %d silver and %d gold coins, giving you %d silver and %d gold.\n\r",
amount_silver, amount_gold, share_silver, share_gold);
}
for (gch = ch->in_room->people; gch != NULL; gch = gch->next_in_room)
{
if (gch != ch && is_same_group (gch, ch) &&
!IS_AFFECTED (gch, AFF_CHARM))
{
act (buf, ch, NULL, gch, TO_VICT);
gch->gold += share_gold;
gch->silver += share_silver;
}
}
return;
}
CH_CMD (do_gtell)
{
CHAR_DATA *gch;
if (argument[0] == '\0')
{
chprintln (ch, "Tell your group what?");
return;
}
if (IS_SET (ch->comm, COMM_NOTELL))
{
chprintln (ch, "Your message didn't get through!");
return;
}
for (gch = char_list; gch != NULL; gch = gch->next)
{
if (is_same_group (gch, ch))
act_new ("" CTAG (_GTELL1) "$n tells the group '"
CTAG (_GTELL2) "$t" CTAG (_GTELL1) "'{x", ch,
argument, gch, TO_VICT, POS_SLEEPING);
}
return;
}
/*
* It is very important that this be an equivalence relation:
* (1) A ~ A
* (2) if A ~ B then B ~ A
* (3) if A ~ B and B ~ C, then A ~ C
*/
bool is_same_group (CHAR_DATA * ach, CHAR_DATA * bch)
{
if (ach == NULL || bch == NULL)
return FALSE;
if (ach->leader != NULL)
ach = ach->leader;
if (bch->leader != NULL)
bch = bch->leader;
return ach == bch;
}
/* Turns colour on and sets the appropriate flags */
CH_CMD (do_colour)
{
if (!ch)
return;
if (IS_NPC (ch) || ch->desc == NULL)
{
chprintln (ch, "ColoUr is not ON, Way Moron!");
return;
}
if (!DESC_FLAGGED (ch->desc, DESC_COLOUR))
{
SET_BIT (ch->desc->desc_flags, DESC_COLOUR);
REMOVE_BIT (ch->comm, COMM_NOCOLOUR);
chprintln
(ch,
"{`Co{`lo{`U{`r {`i{`s {`n{`o{`w {`ON{`, W{`a{`y C{`oo{`l!{x");
}
else
{
chprintln (ch, "ColoUr is now OFF, <sigh>");
REMOVE_BIT (ch->desc->desc_flags, DESC_COLOUR);
SET_BIT (ch->comm, COMM_NOCOLOUR);
}
return;
}
int find_colour_slot (const char *code)
{
int i;
for (i = 0; colour_chars[i].code != NULL; i++)
if (!str_cmp (code, colour_chars[i].code))
return i;
return 0;
}
/* Sets all or 1 custom colours to default */
void default_colour (CHAR_DATA * ch, int slot)
{
int i = 0;
if (!ch || IS_NPC (ch))
return;
if (slot == -1)
{
for (i = 0; cslot_table[i].def != NULL; i++)
ch->pcdata->colour[cslot_table[i].slot] =
find_colour_slot (cslot_table[i].def);
}
else
{
for (i = 0; cslot_table[i].def != NULL; i++)
{
if (cslot_table[i].slot == slot)
{
ch->pcdata->colour[slot] =
find_colour_slot (cslot_table[i].def);
break;
}
}
}
return;
}
const char *color_default (CHAR_DATA * ch)
{
int colour;
if (!ch || IS_NPC (ch))
return C_CLEAR;
colour = ch->pcdata->colour[_DEFAULT];
if (colour < 0 || colour_chars[colour].code == NULL)
return C_CLEAR;
else if (!str_cmp (colour_chars[colour].code, C_RANDOM))
return random_colour ();
else if (!str_cmp (colour_chars[colour].code, RANDOM_BG))
return random_background ();
else
return colour_chars[ch->pcdata->colour[_DEFAULT]].code;
}
/* return the players ansi code for a slot */
const char *char_colour (CHAR_DATA * ch, int slot)
{
int colour;
if (!ch || IS_NPC (ch) || slot < 0 || slot > MAX_CUSTOM_COLOUR)
return C_CLEAR;
colour = ch->pcdata->colour[slot];
if (colour < 0 || colour_chars[colour].code == NULL)
return C_CLEAR;
else if (!str_cmp (colour_chars[colour].code, C_RANDOM))
return random_colour ();
else if (!str_cmp (colour_chars[colour].code, RANDOM_BG))
return random_background ();
else
return colour_chars[colour].code;
}
/* return a colour number */
int colour_lookup (const char *arg)
{
int i;
for (i = 0; colour_chars[i].name != NULL; i++)
if (!str_cmp (arg, colour_chars[i].name))
return i;
return -1;
}
/* returns a custom colour number */
int cslot_lookup (const char *arg)
{
int i;
for (i = 0; cslot_table[i].name != NULL; i++)
if (!str_prefix (arg, cslot_table[i].name))
return cslot_table[i].slot;
return -1;
}
/* sets custom colours */
CH_CMD (do_colourset)
{
char arg[MIL], arg2[MIL];
int i = 0, pos = 0, slot = 0, color = 0;
if (!ch || IS_NPC (ch) || !ch->desc)
return;
if (!DESC_FLAGGED (ch->desc, DESC_COLOUR))
{
chprintln (ch, "You must have colour on to use colourset.");
return;
}
argument = one_argument (argument, arg);
argument = one_argument (argument, arg2);
if (IS_NULLSTR (arg))
{
chprintln
(ch,
"Syntax: colourset colours - lists possible colours");
chprintln (ch,
" colourset options - lists options to colourize");
chprintln (ch,
" colourset <option> <colour> - sets an option to a colour");
chprintln (ch,
" colourset default <option> - sets option to default value");
chprintln (ch,
" colourset default all - reset all options to default values");
return;
}
if (!str_prefix (arg, "colours") || !str_prefix (arg, "colors"))
{
chprintln (ch, "Available Colours:");
for (i = 0; colour_chars[i].name != NULL; i++)
{
chprintf (ch, "%s%-10s{x", colour_chars[i].code,
colour_chars[i].name);
if (++pos % 4 == 0)
{
chprintln (ch, "");
pos = 0;
}
}
if (pos != 0)
chprintln (ch, "");
}
else if (!str_prefix (arg, "options"))
{
chprintln (ch, "Available Options:");
for (i = 0; cslot_table[i].name != NULL; i++)
{
chprintf (ch, "" CTAG (%d) "%-10s{x", cslot_table[i].slot,
cslot_table[i].name);
if (++pos % 6 == 0)
{
chprintln (ch, "");
pos = 0;
}
}
if (pos != 0)
chprintln (ch, "");
}
else if (!str_prefix (arg, "default"))
{
if ((slot = cslot_lookup (arg2)) == -1)
{
if (!str_cmp (arg2, "all"))
chprintln (ch, "All colour values set to default.");
else
{
do_colourset (ch, "");
return;
}
}
else
chprintf (ch, "%s set to default value.\n\r",
cslot_table[slot].name);
default_colour (ch, slot);
return;
}
else
{
if ((slot = cslot_lookup (arg)) == -1)
{
chprintln (ch, "Invalid Option.");
return;
}
if ((color = colour_lookup (arg2)) == -1)
{
chprintln (ch, "Invalid Colour.");
return;
}
ch->pcdata->colour[slot] = color;
chprintf (ch, "%s%s{x set to %s%s{x.\n\r", char_colour (ch, slot),
cslot_table[slot].name, char_colour (ch, slot),
colour_chars[color].name);
return;
}
}
void announce (CHAR_DATA * ch, flag_t bit, const char *message, ...)
{
DESCRIPTOR_DATA *d;
char buf[MSL], buf2[MSL];
char *iType;
bool Private = FALSE;
va_list args;
va_start (args, message);
vsnprintf (buf2, MSL, message, args);
va_end (args);
if (ch && IS_SET (bit, INFO_PRIVATE))
{
Private = TRUE;
REMOVE_BIT (bit, INFO_PRIVATE);
}
if (bit == INFO_NOTE)
iType = "{GBOARD";
else if (bit == INFO_WAR)
iType = "{CWAR";
else if (bit == INFO_GQUEST)
iType = "{MGQUEST";
else
iType = "{RINFO";
sprintf (buf, "%s{W:{x %s{x", iType, buf2);
if (!Private)
{
for (d = descriptor_list; d; d = d->next)
{
CHAR_DATA *och;
if ((och = d->character) == NULL)
continue;
if (d->connected != CON_PLAYING)
continue;
if (bit == INFO_NOTE && ch &&
!is_note_to (och, ch->pcdata->in_progress))
continue;
if ((IS_SET (och->info_settings, bit) ||
!IS_SET (och->info_settings, INFO_QUIET)) && bit != INFO_ALL)
continue;
if (ch == NULL)
chprintf (och, "%s\n\r", buf);
else
act_new (buf, ch, NULL, och, TO_VICT, POS_DEAD);
}
}
else
{
if (!ch)
{
bug ("NULL ch in private announce", 0);
return;
}
chprintf (ch, "%s\n\r", buf);
}
return;
}
CH_CMD (do_info)
{
int i;
flag_t iValue;
if (!*argument || !str_cmp (argument, "list"))
{
chprintln (ch, "{RInformation settings:");
chprintln (ch, "{r---------------------{x");
for (i = 0; info_flags[i].name != NULL; i++)
{
chprintf (ch, "%-13.25s [%s]\n\r",
info_flags[i].name,
IS_SET (ch->info_settings,
info_flags[i].bit) ? "{WOFF{x" : " {RON{x");
}
return;
}
if ((iValue = flag_value (info_flags, argument)) != NO_FLAG)
{
TOGGLE_BIT (ch->info_settings, iValue);
chprintln (ch, "Info channel set.");
return;
}
chprintln (ch, "Which option??");
return;
}
CH_CMD (do_announce)
{
announce (NULL, INFO_ALL, argument);
}