/**************************************************************************
* 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-2003 by Ryan Jennings *
* http://1stmud.dlmud.com/ <r-jenn@shaw.ca> *
***************************************************************************/
#include "merc.h"
#include "interp.h"
#include "recycle.h"
#include "tables.h"
#include "lookup.h"
#include "olc.h"
#include "gcn.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];
int hash;
ROOM_INDEX_DATA *pRoom;
PROTOTYPE(void update_webpasses, (CHAR_DATA *, bool));
if (IS_NPC(ch))
return;
if (ch->pcdata->confirm_delete)
{
if (!IS_NULLSTR(argument))
{
chprintln(ch, "Delete status removed.");
ch->pcdata->confirm_delete = FALSE;
return;
}
else
{
delete_home(ch);
update_statlist(ch, TRUE);
update_webpasses(ch, TRUE);
if (is_clan(ch))
{
update_members(ch, TRUE);
}
for (hash = 0; hash < MAX_KEY_HASH; hash++)
{
for (pRoom = room_index_hash[hash]; pRoom != NULL;
pRoom = pRoom->next)
{
if (!IS_NULLSTR(pRoom->owner)
&& !str_cmp(pRoom->owner, ch->name))
{
replace_string(pRoom->owner, "");
}
}
}
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 (!IS_NULLSTR(argument))
{
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));
}
CH_CMD(do_nogocial)
{
set_on_off(ch, &ch->comm, COMM_NOGOCIAL,
"You no longer see socials/emotes over channels.",
"You now see socials/emotes over channels.");
}
/* RT deaf blocks out all shouts */
CH_CMD(do_deaf)
{
set_on_off(ch, &ch->comm, COMM_DEAF,
"From now on, you won't hear tells.",
"You can now hear tells again.");
}
/* RT quiet blocks out all communication */
CH_CMD(do_quiet)
{
set_on_off(ch, &ch->comm, COMM_QUIET,
"From now on, you will only hear says and emotes.",
"Quiet mode removed.");
}
/* 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
{
chprint(ch, "You are now in AFK mode. ");
SET_BIT(ch->comm, COMM_AFK);
if (!IS_NPC(ch))
{
char buf[MSL];
sprintf(buf, "[%s] %s", str_time(-1, GET_TZONE(ch), "%I:%M:%S %p"),
IS_NULLSTR(argument) ? "Please leave a message!" :
argument);
replace_string(ch->pcdata->afk_msg, buf);
chprintln(ch, ch->pcdata->afk_msg);
}
else
chprintln(ch, "");
}
}
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;
}
sendpage(ch, buf_string(ch->pcdata->buffer));
clear_buf(ch->pcdata->buffer);
}
/* clan channels */
CH_CMD(do_clantalk)
{
if (!is_clan(ch) || ch->clan->independent)
{
chprintln(ch, "You aren't in a clan.");
return;
}
public_ch(ch, argument, gcn_clan);
}
CH_CMD(do_say)
{
if (IS_NULLSTR(argument))
{
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;
OBJ_DATA *obj, *obj_next;
for (mob = ch->in_room->first_person; mob != NULL; mob = mob_next)
{
mob_next = mob->next_in_room;
if (IS_NPC(mob) && HAS_TRIGGER_MOB(mob, TRIG_SPEECH) &&
mob->position == mob->pIndexData->default_pos)
p_act_trigger(argument, mob, NULL, NULL, ch, NULL, NULL,
TRIG_SPEECH);
for (obj = mob->first_carrying; obj; obj = obj_next)
{
obj_next = obj->next_content;
if (HAS_TRIGGER_OBJ(obj, TRIG_SPEECH))
p_act_trigger(argument, NULL, obj, NULL, ch, NULL, NULL,
TRIG_SPEECH);
}
}
for (obj = ch->in_room->first_content; obj; obj = obj_next)
{
obj_next = obj->next_content;
if (HAS_TRIGGER_OBJ(obj, TRIG_SPEECH))
p_act_trigger(argument, NULL, obj, NULL, ch, NULL, NULL,
TRIG_SPEECH);
}
if (HAS_TRIGGER_ROOM(ch->in_room, TRIG_SPEECH))
p_act_trigger(argument, NULL, NULL, ch->in_room, ch, NULL, NULL,
TRIG_SPEECH);
}
return;
}
CH_CMD(do_shout)
{
DESCRIPTOR_DATA *d;
if (IS_NULLSTR(argument))
{
set_on_off(ch, &ch->comm, COMM_SHOUTSOFF, "You can hear shouts again.",
"You will no longer hear shouts.");
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_first; 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_ignoring(victim, ch->name, IGNORE_CHANNELS) &&
!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];
CHAR_DATA *victim;
char buf[MSL];
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 (IS_NULLSTR(arg) || IS_NULLSTR(argument))
{
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 (is_ignoring(victim, ch->name, IGNORE_TELLS))
{
act_new("$N doesn't seem to be listening to you.", ch, NULL, victim,
TO_CHAR, POS_DEAD);
return;
}
if (victim->desc == NULL && !IS_NPC(victim))
{
act("$N seems to have misplaced $S link...try again later.", ch,
NULL, victim, TO_CHAR);
bprintlnf(victim->pcdata->buffer, "%s tells you '%s'\n\r",
PERS(ch, victim), argument);
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 ($t), but your tell will go through when $E returns.",
ch, victim->pcdata->afk_msg, victim, TO_CHAR);
bprintlnf(victim->pcdata->buffer, "%s tells you '%s'\n\r",
PERS(ch, victim), argument);
return;
}
act_new(CTAG(_TELLS1) "You tell $N '" CTAG(_TELLS2) "$t"
CTAG(_TELLS1) "'{x", ch, argument, victim, TO_CHAR, POS_DEAD);
sprintf(buf, CTAG(_TELLS1) MXPTAG("Tell '%s'") "$n" MXPTAG("/Tell")
" tells you '" CTAG(_TELLS2) "$t" CTAG(_TELLS1) "'{x", ch->name);
act_new(buf, ch, argument, victim, TO_VICT, POS_DEAD);
victim->reply = ch;
if (!IS_NPC(ch) && IS_NPC(victim) && HAS_TRIGGER_MOB(victim, TRIG_SPEECH))
p_act_trigger(argument, victim, NULL, NULL, ch, NULL, NULL,
TRIG_SPEECH);
return;
}
CH_CMD(do_reply)
{
CHAR_DATA *victim;
char buf[MSL];
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 (is_ignoring(victim, ch->name, IGNORE_TELLS))
{
act_new("$N doesn't seem to be listening to you.", ch, NULL, victim,
TO_CHAR, POS_DEAD);
return;
}
if (victim->desc == NULL && !IS_NPC(victim))
{
act("$N seems to have misplaced $S link...try again later.", ch,
NULL, victim, TO_CHAR);
bprintlnf(victim->pcdata->buffer, "%s tells you '%s'\n\r",
PERS(ch, victim), argument);
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 ($t), but your tell will go through when $E returns.",
ch, victim->pcdata->afk_msg, victim, TO_CHAR, POS_DEAD);
bprintlnf(victim->pcdata->buffer, "%s tells you '%s'", PERS(ch, victim),
argument);
return;
}
act_new(CTAG(_TELLS1) "You tell $N '" CTAG(_TELLS2) "$t"
CTAG(_TELLS1) "'{x", ch, argument, victim, TO_CHAR, POS_DEAD);
sprintf(buf, CTAG(_TELLS1) MXPTAG("Tell '%s'") "$n" MXPTAG("/Tell")
" tells you '" CTAG(_TELLS2) "$t" CTAG(_TELLS1) "'{x", ch->name);
act_new(buf, 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 (IS_NULLSTR(argument))
{
chprintln(ch, "Yell what?");
return;
}
act("You yell '$t'", ch, argument, NULL, TO_CHAR);
for (d = descriptor_first; 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_ignoring(d->character, ch->name, IGNORE_CHANNELS) &&
!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 (IS_NULLSTR(argument))
{
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 (IS_NULLSTR(argument))
{
chprintln(ch, "Emote what?");
return;
}
act("$n $t", ch, argument, NULL, TO_CHAR);
for (vch = ch->in_room->first_person; 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;
}
if (has_auction(ch))
{
chprintln
(ch,
"{YThe Auctioneer will not let you leave while you have an auction running.{x");
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_first; 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);
if (is_clan(ch))
update_members(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 (IS_NULLSTR(arg))
{
chprintln(ch, "Follow whom?");
return;
}
if ((victim = get_char_room(ch, NULL, 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.");
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.");
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_first; 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 (IS_NULLSTR(arg) || IS_NULLSTR(argument))
{
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, NULL, 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->first_person; 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 (IS_NULLSTR(arg))
{
CHAR_DATA *gch;
CHAR_DATA *leader;
leader = (ch->leader != NULL) ? ch->leader : ch;
chprintlnf(ch, "%s's group:", PERS(leader, ch));
for (gch = char_first; 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, NULL, 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 (IS_NULLSTR(arg1))
{
chprintln(ch, "Split how much?");
return;
}
amount_silver = atoi(arg1);
if (!IS_NULLSTR(arg2))
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->first_person; 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->first_person; 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 (IS_NULLSTR(argument))
{
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_first; 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->d_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->d_flags, DESC_COLOUR);
SET_BIT(ch->comm, COMM_NOCOLOUR);
}
return;
}
const struct colour_type *get_col_table(int type)
{
switch (type)
{
case CT_ATTR:
return colour_attributes;
case CT_FORE:
return colour_foregrounds;
case CT_BACK:
return colour_backgrounds;
default:
bug("bad type");
return NULL;
}
}
int ctype_lookup(const char *arg, int type)
{
int i;
const struct colour_type *table = get_col_table(type);
if (!table)
return -1;
for (i = 0; table[i].name != NULL; i++)
if (!str_prefix(arg, table[i].name))
return i;
return -1;
}
void default_colour(CHAR_DATA * ch, int slot)
{
int i = 0;
if (!ch || IS_NPC(ch))
return;
if (slot == -1)
{
for (i = 0; i < MAX_CUSTOM_COLOUR; i++)
{
ch->pcdata->colour[cslot_table[i].slot][CT_ATTR] =
cslot_table[i].col_attr;
ch->pcdata->colour[cslot_table[i].slot][CT_FORE] =
cslot_table[i].col_fore;
ch->pcdata->colour[cslot_table[i].slot][CT_BACK] =
cslot_table[i].col_back;
}
}
else
{
for (i = 0; i < MAX_CUSTOM_COLOUR; i++)
{
if (cslot_table[i].slot == slot)
{
ch->pcdata->colour[slot][CT_ATTR] = cslot_table[i].col_attr;
ch->pcdata->colour[slot][CT_FORE] = cslot_table[i].col_fore;
ch->pcdata->colour[slot][CT_BACK] = cslot_table[i].col_back;
break;
}
}
}
return;
}
const char *char_colour(CHAR_DATA * ch, int slot)
{
EXTERN int col_attr, col_fore, col_back;
if (!ch || !ch->desc || IS_NPC(ch) || slot < 0 || slot >= MAX_CUSTOM_COLOUR)
{
col_attr = CL_CLEAR;
col_fore = FG_NONE;
col_back = BG_NONE;
return CL_DEFAULT;
}
col_attr = ch->pcdata->colour[slot][CT_ATTR];
col_fore = ch->pcdata->colour[slot][CT_FORE];
col_back = ch->pcdata->colour[slot][CT_BACK];
return make_colour();
}
int cslot_lookup(const char *arg)
{
int i;
for (i = 0; i < MAX_CUSTOM_COLOUR; i++)
if (!str_prefix(arg, cslot_table[i].name))
return cslot_table[i].slot;
return -1;
}
CH_CMD(do_colourset)
{
char arg[MIL], attr[MIL], fore[MIL], back[MIL];
int i = 0, slot = 0;
int c_attr, c_fore, c_back;
int pos = 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, attr);
argument = one_argument(argument, fore);
argument = one_argument(argument, back);
if (IS_NULLSTR(arg))
{
chprintln(ch,
"Syntax: colourset colours - lists possible colours");
chprintln(ch,
" colourset status - 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;
}
else if (!str_prefix(arg, "colours") || !str_prefix(arg, "colors"))
{
int j = 0, k = 0;
chprintln(ch, "Attributes Foregrounds Backgrounds");
chprintln(ch, draw_line(ch, NULL, 58));
for (i = 0; colour_attributes[i].name != NULL; i++)
{
chprintf(ch, "%-15s ", colour_attributes[i].name);
if (colour_foregrounds[j].name != NULL)
chprintf(ch, "%-15s ", colour_foregrounds[j++].name);
else
chprintf(ch, "%-15s ", " ");
if (colour_backgrounds[k].name != NULL)
chprintlnf(ch, "%s", colour_backgrounds[k++].name);
else
chprintln(ch, "");
}
while (colour_foregrounds[j].name != NULL)
{
chprintf(ch, "%-15s %-15s ", " ", colour_foregrounds[j++].name);
if (colour_backgrounds[k].name != NULL)
chprintlnf(ch, "%s", colour_backgrounds[k++].name);
else
chprintln(ch, "");
}
while (colour_backgrounds[k].name != NULL)
chprintlnf(ch, "%-15s %-15s %s", " ", " ",
colour_backgrounds[k++].name);
chprintln(ch, draw_line(ch, NULL, 58));
}
else if (!str_prefix(arg, "status"))
{
chprintln(ch,
"Options that can currently be configured for color are:");
chprintln(ch, draw_line(ch, NULL, 58));
for (i = 0; i < MAX_CUSTOM_COLOUR; i++)
{
chprintf(ch, "%-12s - " CTAG(%d) "Looks like this..{x ",
cslot_table[i].name, cslot_table[i].slot);
if (++pos % 2 == 0)
chprintln(ch, "");
}
if (pos % 2 != 0)
chprintln(ch, "");
chprintln(ch, draw_line(ch, NULL, 58));
}
else if (!str_prefix(arg, "default"))
{
if ((slot = cslot_lookup(attr)) == -1)
{
if (!str_cmp(attr, "all"))
chprintln(ch, "All colour values set to default.");
else
{
do_colourset(ch, "");
return;
}
}
else
chprintlnf(ch, "%s set to default value.", cslot_table[slot].name);
default_colour(ch, slot);
return;
}
else
{
if ((slot = cslot_lookup(arg)) == -1)
{
chprintln(ch, "Invalid Option.");
return;
}
if (IS_NULLSTR(attr) || IS_NULLSTR(fore) || IS_NULLSTR(back))
{
chprintln
(ch,
"Syntax: colourset <option> <attribute> <foreground> <background>");
return;
}
if ((c_attr = ctype_lookup(attr, CT_ATTR)) == -1)
{
chprintln(ch, "Invalid Colour Attribute.");
return;
}
if ((c_fore = ctype_lookup(fore, CT_FORE)) == -1)
{
chprintln(ch, "Invalid Foreground Colour.");
return;
}
if ((c_back = ctype_lookup(back, CT_BACK)) == -1)
{
chprintln(ch, "Invalid background Colour.");
return;
}
ch->pcdata->colour[slot][CT_ATTR] = colour_attributes[c_attr].col_type;
ch->pcdata->colour[slot][CT_FORE] = colour_foregrounds[c_fore].col_type;
ch->pcdata->colour[slot][CT_BACK] = colour_backgrounds[c_back].col_type;
chprintlnf(ch, "%s set to %s%s %s, with %s background{x.",
cslot_table[slot].name, char_colour(ch, slot),
colour_attributes[c_attr].name,
colour_foregrounds[c_fore].name,
colour_backgrounds[c_back].name);
return;
}
}
flag_t ignore_bit(flag_t info)
{
switch (info)
{
case INFO_LEVEL:
return IGNORE_LEVELS;
default:
return IGNORE_ANNOUNCE;
}
}
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;
if (IS_NULLSTR(message))
return;
va_start(args, message);
vsnprintf(buf2, sizeof(buf2), message, args);
va_end(args);
if (IS_SET(bit, INFO_PRIVATE))
{
if (ch)
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 if (bit == INFO_AUCTION)
iType = "{YAUCTION";
else if (bit == INFO_ARENA)
iType = "{BARENA";
else
iType = "{RINFO";
sprintf(buf, "%s{W:{x %s{x", iType, buf2);
if (!Private)
{
for (d = descriptor_first; 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)
chprintln(och, buf);
else if (!is_ignoring(och, ch->name, ignore_bit(bit)))
act_new(buf, ch, NULL, och, TO_VICT, POS_DEAD);
}
}
else
{
if (!ch)
{
bug("NULL ch in private announce");
return;
}
chprintln(ch, 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);
}