/***************************************************************************
* Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, *
* Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. *
* *
* Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael *
* Chastain, Michael Quan, and Mitchell Tse. *
* *
* In order to use any part of this Merc Diku Mud, you must comply with *
* both the original Diku license in 'license.doc' as well the Merc *
* license in 'license.txt'. In particular, you may not remove either of *
* these copyright notices. *
* *
* Much time and thought has gone into this software and you are *
* benefitting. We hope that you share your changes too. What goes *
* around, comes around. *
***************************************************************************/
/***************************************************************************
* ROM 2.4 is copyright 1993-1998 Russ Taylor *
* ROM has been brought to you by the ROM consortium *
* Russ Taylor (rtaylor@hypercube.org) *
* Gabrielle Taylor (gtaylor@hypercube.org) *
* Brian Moore (zump@rom.org) *
* By using this code, you have agreed to follow the terms of the *
* ROM license, in the file Rom24/doc/rom.license *
***************************************************************************/
#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include "merc.h"
#include "interp.h"
#include "magic.h"
#include "recycle.h"
#include "tables.h"
#include "lookup.h"
char *const where_name[] = {
"{C<{WUsed As Light {C>{x",
"{C<{WWorn On Left Finger {C>{x",
"{C<{WWorn On Right Finger {C>{x",
"{C<{WWorn Around Neck {C>{x",
"{C<{WWorn around neck {C>{x",
"{C<{WWorn About Body {C>{x",
"{C<{WWorn On Head {C>{x",
"{C<{WWorn On Legs {C>{x",
"{C<{WWorn On Feet {C>{x",
"{C<{WWorn On Hands {C>{x",
"{C<{WWorn On Arms {C>{x",
"{C<{WWorn As Shield {C>{x",
"{C<{WWorn On Torso {C>{x",
"{C<{WWorn About Waist {C>{x",
"{C<{WWorn On Left Wrist {C>{x",
"{C<{WWorn On Right Wrist {C>{x",
"{C<{RWielded {C>{x",
"{C<{WHeld {C>{x",
"{C<{WFloating Nearby {C>{x",
"{C<{WWorn On Tail {C>{x",
"{C<{WWorn On Face {C>{x",
"{C<{WWorn On Eyes {C>{x",
"{C<{WWorn On Ears {C>{x",
"{C<{WWorn On Left Ankle {C>{x",
"{C<{WWorn On Right Ankle {C>{x",
"{C<{WWorn Under Armor {C>{x",
"{C<{WWorn On Stomach {C>{x",
"{C<{WAs Greaves {C>{x",
"{C<{WWorn Over Back {C>{x",
"{C<{RSecondary Weapon {C>{x", /* ADD THIS */
"{C<{WWorn Over Shoulders {C>{x",
"{W({Rlodged in a leg{W) {x",
"{W({Rlodged in an arm{W) {x",
"{W({Rlodged in a rib{W) {x"
};
/* for keeping track of the player count */
int max_on = 0;
/*
* Local functions.
*/
char *format_obj_to_char args ((OBJ_DATA * obj, CHAR_DATA * ch, bool fShort));
void show_char_to_char_0 args ((CHAR_DATA * victim, CHAR_DATA * ch));
char *
format_obj_to_char (OBJ_DATA * obj, CHAR_DATA * ch, bool fShort)
{
static char buf[MAX_STRING_LENGTH];
buf[0] = '\0';
if ((fShort && (obj->short_descr == NULL || obj->short_descr[0] == '\0'))
|| (obj->description == NULL || obj->description[0] == '\0'))
return buf;
/* TAKA added color */
if (IS_OBJ_STAT (obj, ITEM_INVIS))
strcat (buf, "{D[I] {y");
if (IS_AFFECTED (ch, AFF_DETECT_EVIL) && IS_OBJ_STAT (obj, ITEM_EVIL))
strcat (buf, "{R(Red Aura) {y");
if (IS_AFFECTED (ch, AFF_DETECT_GOOD) && IS_OBJ_STAT (obj, ITEM_BLESS))
strcat (buf, "{B(Blue Aura) {y");
if (IS_AFFECTED (ch, AFF_DETECT_MAGIC) && IS_OBJ_STAT (obj, ITEM_MAGIC))
strcat (buf, "{M[M] {y");
if (IS_OBJ_STAT (obj, ITEM_GLOW))
strcat (buf, "{G[G] {y");
if (IS_OBJ_STAT (obj, ITEM_HUM))
strcat (buf, "{Y[H] {y");
if (IS_OBJ_STAT (obj, ITEM_HIDDEN))
strcat (buf, "{D({wHidden{D){y ");
if (fShort)
{
if (obj->short_descr != NULL)
strcat (buf, obj->short_descr);
}
else
{
if (obj->description != NULL)
strcat (buf, obj->description);
}
return buf;
}
/*
* Show a list to a character.
* Can coalesce duplicated items.
*/
void
show_list_to_char (OBJ_DATA * list, CHAR_DATA * ch, bool fShort,
bool fShowNothing)
{
char buf[MAX_STRING_LENGTH];
BUFFER *output;
char **prgpstrShow;
int *prgnShow;
char *pstrShow;
OBJ_DATA *obj;
int nShow;
int iShow;
int count;
bool fCombine;
if (ch->desc == NULL)
return;
/*
* Alloc space for output lines.
*/
output = new_buf ();
count = 0;
for (obj = list; obj != NULL; obj = obj->next_content)
count++;
prgpstrShow = alloc_mem (count * sizeof (char *));
prgnShow = alloc_mem (count * sizeof (int));
nShow = 0;
/*
* Format the list of objects.
*/
for (obj = list; obj != NULL; obj = obj->next_content)
{
if (obj->wear_loc == WEAR_NONE && can_see_obj (ch, obj))
{
pstrShow = format_obj_to_char (obj, ch, fShort);
fCombine = FALSE;
if (IS_NPC (ch) || IS_SET (ch->comm, COMM_COMBINE))
{
/*
* Look for duplicates, case sensitive.
* Matches tend to be near end so run loop backwords.
*/
for (iShow = nShow - 1; iShow >= 0; iShow--)
{
if (!strcmp (prgpstrShow[iShow], pstrShow))
{
prgnShow[iShow]++;
fCombine = TRUE;
break;
}
}
}
/*
* Couldn't combine, or didn't want to.
*/
if (!fCombine)
{
prgpstrShow[nShow] = str_dup (pstrShow);
prgnShow[nShow] = 1;
nShow++;
}
}
}
/*
* Output the formatted list.
*/
for (iShow = 0; iShow < nShow; iShow++)
{
if (prgpstrShow[iShow][0] == '\0')
{
free_string (prgpstrShow[iShow]);
continue;
}
if (IS_NPC (ch) || IS_SET (ch->comm, COMM_COMBINE))
{
if (prgnShow[iShow] != 1)
{
sprintf (buf, "{r({G%2d{r){y ", prgnShow[iShow]);
add_buf (output, buf);
}
else
{
add_buf (output, "{y ");
}
}
add_buf (output, prgpstrShow[iShow]);
add_buf (output, "{x\n\r");
free_string (prgpstrShow[iShow]);
}
if (fShowNothing && nShow == 0)
{
if (IS_NPC (ch) || IS_SET (ch->comm, COMM_COMBINE))
send_to_char (" ", ch);
send_to_char ("{yNothing.{x\n\r", ch);
}
page_to_char (buf_string (output), ch);
/*
* Clean up.
*/
free_buf (output);
free_mem (prgpstrShow, count * sizeof (char *));
free_mem (prgnShow, count * sizeof (int));
return;
}
void
show_char_to_char_0 (CHAR_DATA * victim, CHAR_DATA * ch)
{
char buf[MAX_STRING_LENGTH], message[MAX_STRING_LENGTH];
buf[0] = '\0';
/* TAKA added color */
if (RIDDEN (victim))
{
if (ch != RIDDEN (victim))
{
strcat (buf, "(Ridden) ");
}
else
{
strcat (buf, "(Your mount) ");
}
}
if (DRIVING (victim))
{
victim->on = victim->ve_control;
}
if (DRIVING (ch))
{
ch->on = ch->ve_control;
}
if (IS_SET (victim->comm, COMM_AFK))
strcat (buf, "{C[AFK] {x");
if (IS_AFFECTED (victim, AFF_INVISIBLE))
strcat (buf, "{w[I] {x");
if (victim->invis_level >= LEVEL_HERO)
strcat (buf, "{C[W] {x");
if (IS_AFFECTED (victim, AFF_HIDE))
strcat (buf, "{D[H] {x");
if (IS_AFFECTED (victim, AFF_CHARM))
strcat (buf, "{W[C] {x");
if (IS_AFFECTED (victim, AFF_PASS_DOOR))
strcat (buf, "{w(Translucent) {x");
if (IS_AFFECTED (victim, AFF_FAERIE_FIRE))
strcat (buf, "{y({RFire{y) {x");
if (IS_EVIL (victim) && IS_AFFECTED (ch, AFF_DETECT_EVIL))
strcat (buf, "{R(Red Aura) {x");
if (IS_GOOD (victim) && IS_AFFECTED (ch, AFF_DETECT_GOOD))
strcat (buf, "{Y(Golden Aura) {x");
if (IS_AFFECTED (victim, AFF_SANCTUARY))
strcat (buf, "{W(White Aura) {x");
if (IS_IMMORTAL (victim) && victim->level >= LEVEL_IMMORTAL)
strcat (buf, "{C(Immortal) {x");
if (!IS_NPC (victim) && !victim->desc)
strcat (buf, "{R({DNo Soul{R){x ");
if (!IS_IMMORTAL (victim))
{
if (!IS_NPC (victim) && !IS_SET (ch->comm, COMM_BRIEF))
strcat (buf, victim->pcdata->title);
}
if (victim->position == victim->start_pos && victim->long_descr[0] != '\0')
{
strcat (buf, "{B");
strcat (buf, victim->long_descr);
send_to_char (buf, ch);
return;
}
strcat (buf, PERS (victim, ch));
if (IS_IMMORTAL (victim))
{
if (!IS_NPC (victim) && !IS_SET (ch->comm, COMM_BRIEF)
&& victim->position == POS_STANDING && ch->on == NULL)
strcat (buf, victim->pcdata->title);
}
switch (victim->position)
{
case POS_DEAD:
strcat (buf, "{W is {DDEAD{W!!");
break;
case POS_MORTAL:
strcat (buf, "{W is mortally wounded.");
break;
case POS_INCAP:
strcat (buf, "{W is incapacitated.");
break;
case POS_STUNNED:
strcat (buf, "{W is lying here stunned.");
break;
case POS_SLEEPING:
if (victim->on != NULL)
{
if (IS_SET (victim->on->value[2], SLEEP_AT))
{
sprintf (message, "{W is sleeping at {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
else if (IS_SET (victim->on->value[2], SLEEP_ON))
{
sprintf (message, "{W is sleeping on {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
else
{
sprintf (message, "{W is sleeping in {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
}
else
strcat (buf, "{W is sleeping here.");
break;
case POS_RESTING:
if (victim->on != NULL)
{
if (IS_SET (victim->on->value[2], REST_AT))
{
sprintf (message, "{W is resting at {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
else if (IS_SET (victim->on->value[2], REST_ON))
{
sprintf (message, "{W is resting on {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
else
{
sprintf (message, "{W is resting in {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
}
else
strcat (buf, "{W is resting here.");
break;
case POS_SITTING:
if (victim->on != NULL)
{
if (IS_SET (victim->on->value[2], SIT_AT))
{
sprintf (message, "{W is sitting at {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
else if (IS_SET (victim->on->value[2], SIT_ON))
{
sprintf (message, "{W is sitting on {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
else
{
sprintf (message, "{W is sitting in {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
}
else
strcat (buf, "{W is sitting here.{x");
break;
case POS_STANDING:
if (victim->on != NULL)
{
if (IS_SET (victim->on->value[2], STAND_AT))
{
sprintf (message, "{W is standing at {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
else if (IS_SET (victim->on->value[2], STAND_ON))
{
sprintf (message, "{W is standing on {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
else
{
sprintf (message, "{W is standing in {W%s.",
victim->on->short_descr);
strcat (buf, message);
}
}
else if (MOUNTED (victim))
{
strcat (buf, " is here, riding ");
strcat (buf, MOUNTED (victim)->short_descr);
strcat (buf, ".");
}
else
{
strcat (buf, " is here.");
}
break;
case POS_FIGHTING:
strcat (buf, "{W is here, fighting ");
if (victim->fighting == NULL)
strcat (buf, "{wthin air{W??");
else if (victim->fighting == ch)
strcat (buf, "{RYOU{W!");
else if (victim->in_room == victim->fighting->in_room)
{
strcat (buf, PERS (victim->fighting, ch));
strcat (buf, ".");
}
else
strcat (buf, "{Wsomeone who left??{x");
break;
}
strcat (buf, "{x\n\r");
buf[0] = UPPER (buf[0]);
send_to_char (buf, ch);
return;
}
void
show_char_to_char_1 (CHAR_DATA * victim, CHAR_DATA * ch)
{
char buf[MAX_STRING_LENGTH];
OBJ_DATA *obj;
int iWear;
int percent;
bool found;
if ((can_see (victim, ch) && get_trust (victim) >= ch->ghost_level))
{
if (ch == victim)
act ("{W$n looks at $mself.{x", ch, NULL, NULL, TO_ROOM);
else
{
act ("{W$n looks at you.{x", ch, NULL, victim, TO_VICT);
act ("{W$n looks at {W$N{W.{x", ch, NULL, victim, TO_NOTVICT);
}
}
if (victim->description[0] != '\0')
{
send_to_char (victim->description, ch);
}
else
{
act ("{WYou see nothing special about $M.{x", ch, NULL, victim,
TO_CHAR);
}
if (MOUNTED (victim))
{
sprintf (buf, "%s is riding %s.\n\r", victim->name,
MOUNTED (victim)->short_descr);
send_to_char (buf, ch);
}
if (RIDDEN (victim))
{
sprintf (buf, "%s is being ridden by %s.\n\r", victim->short_descr,
RIDDEN (victim)->name);
send_to_char (buf, ch);
}
if (victim->max_hit > 0)
percent = (100 * victim->hit) / victim->max_hit;
else
percent = -1;
strcpy (buf, PERS (victim, ch));
if (percent >= 100)
strcat (buf, " {Wis in {Yexcellent {Wcondition.{x\n\r");
else if (percent >= 90)
strcat (buf, " {Whas a few {rscratches{W.{x\n\r");
else if (percent >= 75)
strcat (buf, " {Whas some small {rwounds {Wand {Dbruises{W.{x\n\r");
else if (percent >= 50)
strcat (buf, " {Whas quite a few {rwounds{W.{x\n\r");
else if (percent >= 30)
strcat (buf, " {Whas some big nasty {rwounds {Wand {rscratches{W.{x\n\r");
else if (percent >= 15)
strcat (buf, " {Wlooks pretty {rhurt.{x\n\r");
else if (percent >= 0)
strcat (buf, " {Wis in {Rawful {Wcondition.{x\n\r");
else
strcat (buf, " {Wis {Rbleeding{W to {Ddeath{W.{x\n\r");
buf[0] = UPPER (buf[0]);
send_to_char (buf, ch);
found = FALSE;
for (iWear = 0; iWear < MAX_WEAR; iWear++)
{
if ((obj = get_eq_char (victim, iWear)) != NULL
&& can_see_obj (ch, obj))
{
if (!found)
{
send_to_char ("\n\r", ch);
act ("{W$N is using:{x", ch, NULL, victim, TO_CHAR);
found = TRUE;
}
send_to_char (where_name[iWear], ch);
send_to_char (format_obj_to_char (obj, ch, TRUE), ch);
send_to_char ("\n\r", ch);
}
}
if (victim != ch && !IS_NPC (ch)
&& number_percent () < get_skill (ch, gsn_peek))
{
send_to_char ("\n\r{GYou peek at the inventory:{x\n\r", ch);
check_improve (ch, gsn_peek, TRUE, 4);
show_list_to_char (victim->carrying, ch, TRUE, TRUE);
}
return;
}
void
show_char_to_char (CHAR_DATA * list, CHAR_DATA * ch)
{
CHAR_DATA *rch;
for (rch = list; rch != NULL; rch = rch->next_in_room)
{
if (rch == ch)
continue;
if (rch == ch
|| (RIDDEN (rch) && rch->in_room == RIDDEN (rch)->in_room
&& RIDDEN (rch) != ch))
continue;
if (get_trust (ch) < rch->invis_level)
continue;
if (get_trust (ch) < rch->ghost_level)
continue;
if (can_see (ch, rch))
{
show_char_to_char_0 (rch, ch);
if (MOUNTED (rch) && (rch->in_room == MOUNTED (rch)->in_room))
show_char_to_char_0 (MOUNTED (rch), ch);
}
else if (room_is_dark (ch->in_room) && IS_AFFECTED (rch, AFF_INFRARED))
{
send_to_char
("{GYou see {Yglowing {Rred {Geyes watching YOU!{x\n\r", ch);
}
}
return;
}
bool
check_blind (CHAR_DATA * ch)
{
if (!IS_NPC (ch) && IS_SET (ch->act, PLR_HOLYLIGHT))
return TRUE;
if (IS_AFFECTED (ch, AFF_BLIND))
{
send_to_char ("{RYou can't see a thing!{x\n\r", ch);
return FALSE;
}
return TRUE;
}
/* changes your scroll */
void
do_scroll (CHAR_DATA * ch, char *argument)
{
char arg[MAX_INPUT_LENGTH];
char buf[100];
int lines;
one_argument (argument, arg);
if (arg[0] == '\0')
{
if (ch->lines == 0)
send_to_char ("{YYou do not page long messages.{x\n\r", ch);
else
{
sprintf (buf,
"{YYou currently display {W%d {Ylines per page.{x\n\r",
ch->lines + 2);
send_to_char (buf, ch);
}
return;
}
if (!is_number (arg))
{
send_to_char ("{RYou must provide a number.{x\n\r", ch);
return;
}
lines = atoi (arg);
if (lines == 0)
{
send_to_char ("{YPaging disabled.{x\n\r", ch);
ch->lines = 0;
return;
}
if (lines < 10 || lines > 100)
{
send_to_char ("{RYou must provide a reasonable number.{x\n\r", ch);
return;
}
sprintf (buf, "{GScroll set to {W%d {Glines.{x\n\r", lines);
send_to_char (buf, ch);
ch->lines = lines - 2;
}
/* RT does socials */
void
do_socials (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
int iSocial;
int col;
col = 0;
for (iSocial = 0; social_table[iSocial].name[0] != '\0'; iSocial++)
{
sprintf (buf, "%-12s", social_table[iSocial].name);
send_to_char (buf, ch);
if (++col % 6 == 0)
send_to_char ("\n\r", ch);
}
if (col % 6 != 0)
send_to_char ("\n\r", ch);
return;
}
/* RT Commands to replace news, motd, imotd, etc from ROM */
void
do_motd (CHAR_DATA * ch, char *argument)
{
do_function (ch, &do_help, "motd");
}
void
do_imotd (CHAR_DATA * ch, char *argument)
{
do_function (ch, &do_help, "imotd");
}
void
do_rules (CHAR_DATA * ch, char *argument)
{
do_function (ch, &do_help, "rules");
}
void
do_story (CHAR_DATA * ch, char *argument)
{
do_function (ch, &do_help, "story");
}
void
do_wizlist (CHAR_DATA * ch, char *argument)
{
do_function (ch, &do_help, "wizlist");
}
/* RT this following section holds all the auto commands from ROM, as well as
replacements for config */
void
do_autolist (CHAR_DATA * ch, char *argument)
{
/* lists most player flags */
if (IS_NPC (ch))
return;
send_to_char ("{w action {Rstatus{x\n\r", ch);
send_to_char ("{W---------------------{x\n\r", ch);
send_to_char ("{wautoassist{R ", ch);
if (IS_SET (ch->act, PLR_AUTOASSIST))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wautodamage{R ", ch);
if (IS_SET (ch->act, PLR_AUTODAMAGE))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wautoexit{R ", ch);
if (IS_SET (ch->act, PLR_AUTOEXIT))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wautogold{R ", ch);
if (IS_SET (ch->act, PLR_AUTOGOLD))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wautoloot{R ", ch);
if (IS_SET (ch->act, PLR_AUTOLOOT))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wautosac{R ", ch);
if (IS_SET (ch->act, PLR_AUTOSAC))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wautosplit{R ", ch);
if (IS_SET (ch->act, PLR_AUTOSPLIT))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wautoconsume{R ", ch);
if (IS_SET (ch->act, PLR_AUTOCONSUME))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wautoweather ", ch);
if (IS_SET (ch->act, PLR_AUTOWEATHER))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wcompact mode{R ", ch);
if (IS_SET (ch->comm, COMM_COMPACT))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wprompt{R ", ch);
if (IS_SET (ch->comm, COMM_PROMPT))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
send_to_char ("{wcombine items{R ", ch);
if (IS_SET (ch->comm, COMM_COMBINE))
send_to_char ("ON{x\n\r", ch);
else
send_to_char ("OFF{x\n\r", ch);
if (!IS_SET (ch->act, PLR_CANLOOT))
send_to_char ("{wYour corpse is safe from thieves.{x\n\r", ch);
else
send_to_char ("{wYour corpse may be looted.{x\n\r", ch);
if (IS_SET (ch->act, PLR_NOSUMMON))
send_to_char ("{wYou cannot be summoned.{x\n\r", ch);
else
send_to_char ("{wYou can be summoned.{x\n\r", ch);
if (IS_SET (ch->act, PLR_NOFOLLOW))
send_to_char ("{wYou do not welcome followers.{x\n\r", ch);
else
send_to_char ("{wYou accept followers.{x\n\r", ch);
if (IS_SET (ch->act, PLR_EQLIST))
send_to_char ("{wAutoEQ: Full EQ list shown.{x\n\r", ch);
else
send_to_char ("{wAutoEQ: EQ list broken down.{x\n\r", ch);
}
void
do_autoassist (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOASSIST))
{
send_to_char ("{wAutoassist removed.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOASSIST);
}
else
{
send_to_char ("{wYou will now assist when needed.{x\n\r", ch);
SET_BIT (ch->act, PLR_AUTOASSIST);
}
}
void
do_autodamage (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTODAMAGE))
{
send_to_char ("{wAutodamage is currently OFF.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTODAMAGE);
}
else
{
send_to_char ("{wAutodamage is currently ON.{x\n\r", ch);
SET_BIT (ch->act, PLR_AUTODAMAGE);
}
}
/*
* autoconsume code by TAKA
*/
void
do_autoconsume (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (!IS_SET (ch->form, FORM_UNDEAD))
{
send_to_char ("{RYou are not undead!{x\n\r", ch);
return;
}
if (IS_SET (ch->act, PLR_AUTOCONSUME))
{
send_to_char ("{wAutoconsume removed.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOCONSUME);
}
else
{
send_to_char ("{wYou will now consume the blood of corpses!{x\n\r", ch);
SET_BIT (ch->act, PLR_AUTOCONSUME);
}
}
void
do_autoexit (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOEXIT))
{
send_to_char ("{wExits will no longer be displayed.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOEXIT);
}
else
{
send_to_char ("{wExits will now be displayed.{x\n\r", ch);
SET_BIT (ch->act, PLR_AUTOEXIT);
}
}
void
do_autoeq (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_EQLIST))
{
send_to_char ("{wEq list will now be broken down.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_EQLIST);
}
else
{
send_to_char ("{wFull EQ list will now be displayed.{x\n\r", ch);
SET_BIT (ch->act, PLR_EQLIST);
}
}
void
do_autogold (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOGOLD))
{
send_to_char ("{wAutogold removed.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOGOLD);
}
else
{
send_to_char ("{wAutomatic gold looting set.{x\n\r", ch);
SET_BIT (ch->act, PLR_AUTOGOLD);
}
}
void
do_autoloot (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOLOOT))
{
send_to_char ("{wAutolooting removed.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOLOOT);
}
else
{
send_to_char ("{wAutomatic corpse looting set.{x\n\r", ch);
SET_BIT (ch->act, PLR_AUTOLOOT);
}
}
void
do_autosac (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOSAC))
{
send_to_char ("{wAutosacrificing removed.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOSAC);
}
else
{
send_to_char ("{wAutomatic corpse sacrificing set.{x\n\r", ch);
SET_BIT (ch->act, PLR_AUTOSAC);
}
}
void
do_autosplit (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOSPLIT))
{
send_to_char ("{wAutosplitting removed.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOSPLIT);
}
else
{
send_to_char ("{wAutomatic gold splitting set.{x\n\r", ch);
SET_BIT (ch->act, PLR_AUTOSPLIT);
}
}
/* turn on all auto flags! TAKA */
void
do_autoall (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
SET_BIT (ch->act, PLR_AUTOASSIST);
SET_BIT (ch->act, PLR_AUTOEXIT);
SET_BIT (ch->act, PLR_AUTOGOLD);
SET_BIT (ch->act, PLR_AUTOLOOT);
SET_BIT (ch->act, PLR_AUTOSAC);
SET_BIT (ch->act, PLR_AUTOSPLIT);
SET_BIT (ch->act, PLR_AUTODAMAGE);
SET_BIT (ch->act, PLR_AUTOWEATHER);
send_to_char ("{RAll autos turned on.{x\n\r", ch);
}
void
do_brief (CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->comm, COMM_BRIEF))
{
send_to_char ("{YFull descriptions activated.{x\n\r", ch);
REMOVE_BIT (ch->comm, COMM_BRIEF);
}
else
{
send_to_char ("{YShort descriptions activated.{x\n\r", ch);
SET_BIT (ch->comm, COMM_BRIEF);
}
}
void
do_compact (CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->comm, COMM_COMPACT))
{
send_to_char ("{YCompact mode removed.{x\n\r", ch);
REMOVE_BIT (ch->comm, COMM_COMPACT);
}
else
{
send_to_char ("{YCompact mode set.{x\n\r", ch);
SET_BIT (ch->comm, COMM_COMPACT);
}
}
void
do_show (CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->comm, COMM_SHOW_AFFECTS))
{
send_to_char ("{YAffects will no longer be shown in score.{x\n\r", ch);
REMOVE_BIT (ch->comm, COMM_SHOW_AFFECTS);
}
else
{
send_to_char ("{YAffects will now be shown in score.{x\n\r", ch);
SET_BIT (ch->comm, COMM_SHOW_AFFECTS);
}
}
void
do_prompt (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
if (argument[0] == '\0')
{
if (IS_SET (ch->comm, COMM_PROMPT))
{
send_to_char ("{YYou will no longer see prompts.{x\n\r", ch);
REMOVE_BIT (ch->comm, COMM_PROMPT);
}
else
{
send_to_char ("{YYou will now see prompts.{x\n\r", ch);
SET_BIT (ch->comm, COMM_PROMPT);
}
return;
}
if (!strcmp (argument, "all"))
strcpy (buf, "{p%b{p<{W%h{Rhp {W%m{Rm {W%v{Rmv{p>{x ");
else
{
if (strlen (argument) > 50)
argument[50] = '\0';
strcpy (buf, argument);
smash_tilde (buf);
if (str_suffix ("%c", buf))
strcat (buf, " ");
}
free_string (ch->prompt);
ch->prompt = str_dup (buf);
sprintf (buf, "{GPrompt set to:{x %s\n\r", ch->prompt);
send_to_char (buf, ch);
return;
}
void
do_combine (CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->comm, COMM_COMBINE))
{
send_to_char ("{YLong inventory selected.{x\n\r", ch);
REMOVE_BIT (ch->comm, COMM_COMBINE);
}
else
{
send_to_char ("{YCombined inventory selected.{x\n\r", ch);
SET_BIT (ch->comm, COMM_COMBINE);
}
}
void
do_noloot (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_CANLOOT))
{
send_to_char ("{YYour corpse is now safe from thieves.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_CANLOOT);
}
else
{
send_to_char ("{YYour corpse may now be looted.{x\n\r", ch);
SET_BIT (ch->act, PLR_CANLOOT);
}
}
void
do_nofollow (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_NOFOLLOW))
{
send_to_char ("{YYou now accept followers.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOFOLLOW);
}
else
{
send_to_char ("{YYou no longer accept followers.{x\n\r", ch);
SET_BIT (ch->act, PLR_NOFOLLOW);
die_follower (ch);
}
}
void
do_nosummon (CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
{
if (IS_SET (ch->imm_flags, IMM_SUMMON))
{
send_to_char ("{YYou are no longer immune to summon.{x\n\r", ch);
REMOVE_BIT (ch->imm_flags, IMM_SUMMON);
}
else
{
send_to_char ("{YYou are now immune to summoning.{x\n\r", ch);
SET_BIT (ch->imm_flags, IMM_SUMMON);
}
}
else
{
if (IS_SET (ch->act, PLR_NOSUMMON))
{
send_to_char ("{YYou are no longer immune to summon.{x\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOSUMMON);
}
else
{
send_to_char ("{YYou are now immune to summoning.{x\n\r", ch);
SET_BIT (ch->act, PLR_NOSUMMON);
}
}
}
void
do_look (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
EXIT_DATA *pexit;
CHAR_DATA *victim;
OBJ_DATA *obj;
char *pdesc;
int door;
int number, count;
if (ch->desc == NULL)
return;
if (ch->position < POS_SLEEPING)
{
send_to_char ("{RYou can't see anything but stars!{x\n\r", ch);
return;
}
if (ch->position == POS_SLEEPING)
{
send_to_char ("{RYou can't see anything, you're sleeping!{x\n\r", ch);
return;
}
if (!check_blind (ch))
return;
if (!IS_NPC (ch)
&& !IS_SET (ch->act, PLR_HOLYLIGHT) && room_is_dark (ch->in_room))
{
send_to_char ("{DIt is pitch black ... {x\n\r", ch);
show_char_to_char (ch->in_room->people, ch);
return;
}
argument = one_argument (argument, arg1);
argument = one_argument (argument, arg2);
number = number_argument (arg1, arg3);
count = 0;
if (arg1[0] == '\0' || !str_cmp (arg1, "auto"))
{
/* 'look' or 'look auto' */
if (IS_SET (ch->act, PLR_AUTOWEATHER) && IS_OUTDOORS (ch))
{
show_weather (ch);
}
send_to_char ("\n\r", ch);
send_to_char ("{C", ch);
send_to_char (ch->in_room->name, ch);
send_to_char ("{x", ch);
if ((IS_IMMORTAL (ch)
&& (IS_NPC (ch) || IS_SET (ch->act, PLR_HOLYLIGHT)))
|| IS_BUILDER (ch, ch->in_room->area))
{
sprintf (buf, "{r [{RRoom %ld{r]{x", ch->in_room->vnum);
send_to_char (buf, ch);
}
send_to_char ("\n\r", ch);
if (arg1[0] == '\0' || (!IS_NPC (ch) && !IS_SET (ch->comm, COMM_BRIEF)))
{
send_to_char (" ", ch);
send_to_char ("{S", ch);
send_to_char (ch->in_room->description, ch);
send_to_char ("{x", ch);
}
if (!IS_NPC (ch) && IS_SET (ch->act, PLR_AUTOEXIT))
{
send_to_char ("\n\r", ch);
do_function (ch, &do_exits, "auto");
}
do_outside_look (ch, "auto");
show_list_to_char (ch->in_room->contents, ch, FALSE, FALSE);
show_char_to_char (ch->in_room->people, ch);
return;
}
if (!str_cmp (arg1, "i") || !str_cmp (arg1, "in") || !str_cmp (arg1, "on"))
{
/* 'look in' */
if (arg2[0] == '\0')
{
send_to_char ("{RLook in what?{x\n\r", ch);
return;
}
if ((obj = get_obj_here (ch, NULL, arg2)) == NULL)
{
send_to_char ("{RYou do not see that here.{x\n\r", ch);
return;
}
switch (obj->item_type)
{
default:
send_to_char ("{RThat is not a container.{x\n\r", ch);
break;
case ITEM_DRINK_CON:
if (obj->value[1] <= 0)
{
send_to_char ("{YIt is empty.{x\n\r", ch);
break;
}
sprintf (buf, "{YIt's %sfilled with a %s liquid.{x\n\r",
obj->value[1] < obj->value[0] / 4
? "less than half-" :
obj->value[1] < 3 * obj->value[0] / 4
? "about half-" : "more than half-",
liq_table[obj->value[2]].liq_color);
send_to_char (buf, ch);
break;
case ITEM_CONTAINER:
case ITEM_CORPSE_NPC:
case ITEM_CORPSE_PC:
if (IS_SET (obj->value[1], CONT_CLOSED))
{
send_to_char ("{YIt is closed.{x\n\r", ch);
case ITEM_QUIVER:
if (obj->value[0] <= 0)
{
send_to_char ("{WThe quiver is out of arrows.{x\n\r", ch);
break;
}
if (obj->value[0] == 1)
{
send_to_char
("{WThe quiver has 1 arrow remaining in it.{x\n\r", ch);
break;
}
if (obj->value[0] > 1)
{
sprintf (buf, "{WThe quiver has %d arrows in it.{x\n\r",
obj->value[0]);
}
send_to_char (buf, ch);
break;
}
act ("$p holds:", ch, obj, NULL, TO_CHAR);
show_list_to_char (obj->contains, ch, TRUE, TRUE);
break;
}
return;
}
if ((victim = get_char_room (ch, NULL, arg1)) != NULL)
{
show_char_to_char_1 (victim, ch);
return;
}
for (obj = ch->carrying; obj != NULL; obj = obj->next_content)
{
if (can_see_obj (ch, obj))
{ /* player can see object */
pdesc = get_extra_descr (arg3, obj->extra_descr);
if (pdesc != NULL)
{
if (++count == number)
{
send_to_char (pdesc, ch);
return;
}
else
continue;
}
pdesc = get_extra_descr (arg3, obj->pIndexData->extra_descr);
if (pdesc != NULL)
{
if (++count == number)
{
send_to_char (pdesc, ch);
return;
}
else
continue;
}
if (is_name (arg3, obj->name))
if (++count == number)
{
send_to_char (obj->description, ch);
send_to_char ("\n\r", ch);
return;
}
}
}
for (obj = ch->in_room->contents; obj != NULL; obj = obj->next_content)
{
if (can_see_obj (ch, obj))
{
pdesc = get_extra_descr (arg3, obj->extra_descr);
if (pdesc != NULL)
if (++count == number)
{
send_to_char (pdesc, ch);
return;
}
pdesc = get_extra_descr (arg3, obj->pIndexData->extra_descr);
if (pdesc != NULL)
if (++count == number)
{
send_to_char (pdesc, ch);
return;
}
if (is_name (arg3, obj->name))
if (++count == number)
{
send_to_char (obj->description, ch);
send_to_char ("\n\r", ch);
return;
}
}
}
pdesc = get_extra_descr (arg3, ch->in_room->extra_descr);
if (pdesc != NULL)
{
if (++count == number)
{
send_to_char (pdesc, ch);
return;
}
}
if (count > 0 && count != number)
{
if (count == 1)
sprintf (buf, "{GYou only see one {w%s {Ghere.{x\n\r", arg3);
else
sprintf (buf, "{GYou only see {w%d {Gof those here.{x\n\r", count);
send_to_char (buf, ch);
return;
}
if (!str_cmp (arg1, "n") || !str_cmp (arg1, "north"))
door = 0;
else if (!str_cmp (arg1, "e") || !str_cmp (arg1, "east"))
door = 1;
else if (!str_cmp (arg1, "s") || !str_cmp (arg1, "south"))
door = 2;
else if (!str_cmp (arg1, "w") || !str_cmp (arg1, "west"))
door = 3;
else if (!str_cmp (arg1, "u") || !str_cmp (arg1, "up"))
door = 4;
else if (!str_cmp (arg1, "d") || !str_cmp (arg1, "down"))
door = 5;
else
{
send_to_char ("{RYou do not see that here.{x\n\r", ch);
return;
}
/* 'look direction' */
if ((pexit = ch->in_room->exit[door]) == NULL)
{
send_to_char ("{YNothing special there.{x\n\r", ch);
return;
}
if (pexit->description != NULL && pexit->description[0] != '\0')
send_to_char (pexit->description, ch);
else
send_to_char ("{YNothing special there.{x\n\r", ch);
if (pexit->keyword != NULL
&& pexit->keyword[0] != '\0' && pexit->keyword[0] != ' ')
{
if (IS_SET (pexit->exit_info, EX_CLOSED))
{
act ("{GThe $d is closed.{x", ch, NULL, pexit->keyword, TO_CHAR);
}
else if (IS_SET (pexit->exit_info, EX_ISDOOR))
{
act ("{GThe $d is open.{x", ch, NULL, pexit->keyword, TO_CHAR);
}
}
return;
}
/* RT added back for the hell of it */
void
do_read (CHAR_DATA * ch, char *argument)
{
do_function (ch, &do_look, argument);
}
void
do_examine (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
one_argument (argument, arg);
if (arg[0] == '\0')
{
send_to_char ("{RExamine what?{x\n\r", ch);
return;
}
do_function (ch, &do_look, arg);
if ((obj = get_obj_here (ch, NULL, arg)) != NULL)
{
switch (obj->item_type)
{
default:
break;
case ITEM_JUKEBOX:
do_function (ch, &do_play, "list");
break;
case ITEM_MONEY:
if (obj->value[0] == 0)
{
if (obj->value[1] == 0)
sprintf (buf, "{YOdd...there's no coins in the pile.{x\n\r");
else if (obj->value[1] == 1)
sprintf (buf, "{YWow. {yOne gold {Ycoin.{x\n\r");
else
sprintf (buf,
"{YThere are {g%d gold {Ycoins in the pile.{xn\r",
obj->value[1]);
}
else if (obj->value[1] == 0)
{
if (obj->value[0] == 1)
sprintf (buf, "{YWow. {DOne silver {Ycoin.{x\n\r");
else
sprintf (buf,
"{YThere are {D%d silver {Ycoins in the pile.{x\n\r",
obj->value[0]);
}
else
sprintf (buf,
"{YThere are {y%d gold {Yand {D%d silver {Ycoins in the pile.{x\n\r",
obj->value[1], obj->value[0]);
send_to_char (buf, ch);
break;
case ITEM_DRINK_CON:
case ITEM_CONTAINER:
case ITEM_CORPSE_NPC:
case ITEM_CORPSE_PC:
sprintf (buf, "in %s", argument);
do_function (ch, &do_look, buf);
}
}
return;
}
/*
* Thanks to Zrin for auto-exit part.
*/
void
do_exits (CHAR_DATA * ch, char *argument)
{
extern char *const dir_name[];
char buf[MAX_STRING_LENGTH];
EXIT_DATA *pexit;
bool found;
bool fAuto;
int door;
fAuto = !str_cmp (argument, "auto");
if (!check_blind (ch))
return;
if (fAuto)
sprintf (buf, "{C[{wExits:{G");
else if (IS_IMMORTAL (ch))
sprintf (buf, "{GObvious exits from room {w%ld{G:{x\n\r",
ch->in_room->vnum);
else
sprintf (buf, "{GObvious exits:{x\n\r");
found = FALSE;
for (door = 0; door <= 5; door++)
{
if ((pexit = ch->in_room->exit[door]) != NULL
&& pexit->u1.to_room != NULL
&& can_see_room (ch, pexit->u1.to_room)
&& !IS_SET (pexit->exit_info, EX_CLOSED))
{
found = TRUE;
if (fAuto)
{
strcat (buf, " ");
strcat (buf, dir_name[door]);
}
else
{
sprintf (buf + strlen (buf), "%-5s - %s",
capitalize (dir_name[door]),
room_is_dark (pexit->u1.to_room)
? "{DToo dark to tell{x" : pexit->u1.to_room->name);
if (IS_IMMORTAL (ch))
sprintf (buf + strlen (buf),
" {Y({Groom {w%ld{Y){x\n\r",
pexit->u1.to_room->vnum);
else
sprintf (buf + strlen (buf), "\n\r");
}
}
}
if (!found)
strcat (buf, fAuto ? " none" : "{GNone.{x\n\r");
if (fAuto)
strcat (buf, "{C]{x\n\r");
send_to_char (buf, ch);
return;
}
void
do_worth (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
if (IS_NPC (ch))
{
sprintf (buf, "{GYou have {y%ld gold {Gand {D%ld silver{G.{x\n\r",
ch->gold, ch->silver);
send_to_char (buf, ch);
return;
}
sprintf (buf,
"{GYou have {y%ld gold{G, {D%ld silver{G, and {B%d {Gexperience {Y({w%d {Gexp to level{Y){G.{x\n\r",
ch->gold, ch->silver, ch->exp,
(ch->level + 1) * exp_per_level (ch,
ch->pcdata->points) - ch->exp);
send_to_char (buf, ch);
return;
}
/*
* score and effects commands by TAKA!
* of the ROFT and Ghost Dancer mud projects!
*/
void
do_score (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
// CLAN_DATA clanl;
if (IS_NPC (ch))
return;
/*
This code replaced by TAKA to add mud time to a file for better
tracking :) Also for our own birthday code logic!
*/
sprintf (buf, " You were born on %d/%d/%d (D/M/Y)", ch->startday,
ch->startmonth, ch->startyear);
send_to_char (buf, ch);
if (ch->startmonth == time_info.month && ch->startday == time_info.day)
send_to_char (" {z{CToday is your birthday.{x\n\r", ch);
else
send_to_char ("\n\r", ch);
/* End TAKA time mods */
// clanl = c_sprintf(clan_table[ch->clan].who_name);
/*
Reformated score screen by TAKA or Ghost Dancers Mud
*/
send_to_char
("{C={c-{W-{w-{D-----------------------------------------------------------------------{w-{W-{c-{C={x\n\r",
ch);
sprintf (buf, "{WN{Dame {w:{x %-7s {WS{Dtatus{w:{x %-40s \n\r", ch->name,
IS_NPC (ch) ? "" : ch->pcdata->title);
send_to_char (buf, ch);
sprintf (buf, "{WC{Dlan {w:{x %-14s {WR{Dank{w:{x %-20s \n\r",
clan_table[ch->clan].who_name, player_rank (ch));
send_to_char (buf, ch);
sprintf (buf,
"{WL{Devel {w:{x %-3d {WA{Dge{w:{x %-5d \n\r",
ch->level, get_age (ch));
send_to_char (buf, ch);
sprintf (buf,
"{WC{Dlass {w:{x %-10s {WG{Dender{w:{x %-10s \n\r", IS_NPC (ch) ? "mobile" : class_table[ch->class].name, ch->sex == 0 ? "sexless" : ch->sex == 1 ? "male" : "female");
send_to_char (buf, ch);
sprintf (buf,"{WR{Dace {w:{x %-17s {WS{Dpecies{w:{x %-10s \n\r",race_table[ch->race].name, species_table[ch->species].name);
send_to_char (buf, ch);
send_to_char
("\n\r",
ch);
if (ch->level > 5)
{
send_to_char
("{C={B[{WPhysical Base Mod{B]{D--{B[{WMental Base Mod{B]{D--{B[{WArmor Rating{B]{D---------{C={x\n\r",
ch);
sprintf (buf,
" {cS{Dtrength {C({w%2d{C) ({w%2d{C) {cI{Dntellect {C({w%2d{C) ({w%2d{C) {DPierce{W: {w%4d{x \n\r",
ch->perm_stat[STAT_STR], get_curr_stat (ch, STAT_STR),
ch->perm_stat[STAT_INT], get_curr_stat (ch, STAT_INT),
GET_AC (ch, AC_PIERCE));
send_to_char (buf, ch);
sprintf (buf,
" {cD{Dexterity {C({w%2d{C) ({w%2d{C) {cS{Dpirituality {C({w%2d{C) ({w%2d{C) {DSlash {W: {w%4d{x \n\r",
ch->perm_stat[STAT_DEX], get_curr_stat (ch, STAT_DEX),
ch->perm_stat[STAT_SPI], get_curr_stat (ch, STAT_SPI),
GET_AC (ch, AC_SLASH));
send_to_char (buf, ch);
sprintf (buf,
" {cA{Dgility {C({w%2d{C) ({w%2d{C) {cP{Dresence {C({w%2d{C) ({w%2d{C) {DBash {W: {w%4d{x \n\r",
ch->perm_stat[STAT_AGI], get_curr_stat (ch, STAT_AGI),
ch->perm_stat[STAT_PRE], get_curr_stat (ch, STAT_PRE),
GET_AC (ch, AC_BASH));
send_to_char (buf, ch);
sprintf (buf,
" {cF{Dortitude {C({w%2d{C) ({w%2d{C) {cW{Dill {C({w%2d{C) ({w%2d{C) {DMagic {W: {w%4d{x \n\r",
PERM_STAT_FOR, CURR_STAT_FOR, PERM_STAT_WIL, CURR_STAT_WIL,
GET_AC (ch, AC_EXOTIC));
send_to_char (buf, ch);
send_to_char
(" \n\r",
ch);
}
send_to_char
("{C={B[{WStat Current Maximum{B][{WCombat Rate{B][{WExperience Amount{B]{D--{C={x\n\r",
ch);
sprintf (buf,
" {RH{Dealth {w%7d{D/{w%7d{x {WH{Dit {WR{Doll {C({wHR{C) {w%4d{x Earned %11d Exp \n\r",
ch->hit, ch->max_hit, GET_HITROLL (ch), ch->exp);
send_to_char (buf, ch);
sprintf (buf,
" {CE{Dnergy {w%7d{D/{w%7d{x {WD{Damage {WR{Doll{C({wDR{C){w %4d{x Per Level %11d Exp \n\r",
ch->mana, ch->max_mana, GET_DAMROLL (ch), exp_per_level (ch, ch->pcdata->points));
send_to_char (buf, ch);
sprintf (buf,
" {WM{Dove {w%7d{D/{w%7d{x {WW{Dimpy {w%4d{x Till Level %11d Exp \n\r",
ch->move, ch->max_move, ch->wimpy,
((ch->level + 1) * exp_per_level (ch,
ch->pcdata->points) - ch->exp));
send_to_char (buf, ch);
send_to_char
(" \n\r",
ch);
send_to_char
("{C={B[{WTraining Amnt{B]{D-----{B[{WCurrency Amount{B]{D-------{B[{WCarrying Amnt Max{B]{D----{C={x\n\r",
ch);
sprintf (buf,
" {WP{Dractices{w %-4d {yG{Dold {w%-13ld {WI{Dtems {w%-10d %-10d{x\n\r",
ch->practice, ch->gold, ch->carry_number, can_carry_n (ch));
send_to_char (buf, ch);
sprintf (buf,
" {WT{Drains{w %-4d {wS{Dilver {w%-13ld {WW{Deight {w %-10ld %-10d{x\n\r",
ch->train, ch->silver, get_carry_weight (ch) / 10,
can_carry_w (ch) / 10);
send_to_char (buf, ch);
send_to_char
(" \n\r",
ch);
send_to_char
("{C={c-{W-{w-{D-----------------------------------------------------------------------{w-{W-{c-{C={x\n\r",
ch);
sprintf (buf,
"You have %ld gold and %ld silver in the bank. \n\r",
ch->pcdata->balance, ch->pcdata->sbalance);
send_to_char (buf, ch);
send_to_char ("Conditions: {x", ch);
if (!IS_NPC (ch) && ch->pcdata->condition[COND_DRUNK] > 10)
send_to_char ("{wdrunk. ", ch);
else
send_to_char ("{D . ", ch);
if (!IS_NPC (ch) && ch->pcdata->condition[COND_THIRST] == 0)
send_to_char ("{wthirsty. ", ch);
else
send_to_char ("{D . ", ch);
if (!IS_NPC (ch) && ch->pcdata->condition[COND_HUNGER] == 0)
send_to_char ("{whungry. ", ch);
else
send_to_char ("{D . ", ch);
send_to_char ("{x\n\r", ch);
send_to_char ("You are: {x", ch);
if (ch->alignment > 900)
send_to_char ("{CA{wngelic.{x {x\n\r", ch);
else if (ch->alignment > 700)
send_to_char ("{cSaintly. {x\n\r", ch);
else if (ch->alignment > 350)
send_to_char ("{WGood. {x\n\r", ch);
else if (ch->alignment > 100)
send_to_char ("{WKind. {x\n\r", ch);
else if (ch->alignment > -100)
send_to_char ("{wNeutral. {x\n\r", ch);
else if (ch->alignment > -350)
send_to_char ("{DCruel. {x\n\r", ch);
else if (ch->alignment > -700)
send_to_char ("{DEvil. {x\n\r", ch);
else if (ch->alignment > -900)
send_to_char ("{rDiabolic. {x\n\r", ch);
else
send_to_char ("{RD{Demonic.{x {x\n\r", ch);
send_to_char
(" \n\r",
ch);
send_to_char
("{C={c-{W-{w-{D-----------------------------------------------------------------------{w-{W-{c-{C={x\n\r",
ch);
switch (ch->position)
{
case POS_DEAD:
send_to_char ("{DYou are DEAD!!{x ", ch);
break;
case POS_MORTAL:
send_to_char ("{wYou are mortally wounded.{x", ch);
break;
case POS_INCAP:
send_to_char ("{wYou are incapacitated.{x ", ch);
break;
case POS_STUNNED:
send_to_char ("{wYou are stunned.{x ", ch);
break;
case POS_SLEEPING:
send_to_char ("{DYou are sleeping.{x ", ch);
break;
case POS_RESTING:
send_to_char ("{wYou are resting.{x ", ch);
break;
case POS_SITTING:
send_to_char ("{wYou are sitting.{x ", ch);
break;
case POS_STANDING:
if (MOUNTED (ch))
{
sprintf (buf, "You are riding on %s.\n\r",
MOUNTED (ch)->short_descr);
send_to_char (buf, ch);
}
else
{
send_to_char ("You are standing.\n\r", ch);
}
break;
case POS_FIGHTING:
send_to_char ("You are fighting.\n\r", ch);
break;
}
if (RIDDEN (ch))
{
sprintf (buf, "You are ridden by %s.\n\r",
IS_NPC (RIDDEN (ch)) ? RIDDEN (ch)->short_descr : RIDDEN (ch)->
name);
send_to_char (buf, ch);
}
/* RT wizinvis and holy light */
if (IS_IMMORTAL (ch))
{
send_to_char ("{WHoly Light: ", ch);
if (IS_SET (ch->act, PLR_HOLYLIGHT))
send_to_char ("{Won{x", ch);
else
send_to_char ("{Doff{x", ch);
if (ch->invis_level)
{
sprintf (buf, " {DInvisible: level {W%d", ch->invis_level);
send_to_char (buf, ch);
}
if (ch->incog_level)
{
sprintf (buf, " {DIncognito: level {W%d", ch->incog_level);
send_to_char (buf, ch);
}
if (ch->ghost_level)
{
sprintf (buf, " Ghost: level {W%d{x", ch->ghost_level);
send_to_char (buf, ch);
}
send_to_char ("\n\r", ch);
}
if (is_clan (ch))
{
sprintf (buf, "You are a %s of the %s\n\r",
player_rank (ch), player_clan (ch));
send_to_char (buf, ch);
}
if (IS_SET (ch->comm, COMM_SHOW_AFFECTS))
do_affects (ch, "");
}
void
do_affects (CHAR_DATA * ch, char *argument)
{
AFFECT_DATA *paf, *paf_last = NULL;
char buf[MAX_STRING_LENGTH];
if (ch->affected != NULL)
{
send_to_char ("{wYou are affected by the following spells:{x\n\r", ch);
for (paf = ch->affected; paf != NULL; paf = paf->next)
{
if (paf_last != NULL && paf->type == paf_last->type)
if (ch->level >= 20)
sprintf (buf, " ");
else
continue;
else
sprintf (buf, "{wSpell: {W%-15s", skill_table[paf->type].name);
send_to_char (buf, ch);
if (ch->level >= 20)
{
sprintf (buf,
"{w: modifies {W%s {wby {W%d ",
affect_loc_name (paf->location), paf->modifier);
send_to_char (buf, ch);
if (paf->duration == -1)
sprintf (buf, "{wpermanently");
else
sprintf (buf, "{wfor {W%d {whours", paf->duration);
send_to_char (buf, ch);
}
send_to_char ("\n\r", ch);
paf_last = paf;
}
}
else
send_to_char ("{RYou are not affected by any spells.{x\n\r", ch);
if (ch->affected_by)
{
sprintf (buf, "{wTraits and Affects:\n\r {W%s{x\n\r",
affect_bit_name (ch->affected_by));
send_to_char (buf, ch);
}
return;
}
/* end of score and affects sections and formating */
char *const day_name[] = {
"Jedahmar", "Madakar", "Deminar", "Ordilimar", "Savidmar",
"Eridmar", "Vesi Kilimar"
};
char *const month_name[] = {
"Winter", "the Winter Wolf", "the Frost Giant", "the Old Forces",
"the Grand Struggle", "the Spring", "Nature", "Futility", "the Dragon",
"the Sun", "the Heat", "the Battle", "the Dark Shades", "the Shadows",
"the Long Shadows", "the Ancient Darkness", "the Great Evil"
};
void
do_time (CHAR_DATA * ch, char *argument)
{
extern char str_boot_time[];
char buf[MAX_STRING_LENGTH];
char *suf;
int day;
day = time_info.day + 1;
if (day > 4 && day < 20)
suf = "th";
else if (day % 10 == 1)
suf = "st";
else if (day % 10 == 2)
suf = "nd";
else if (day % 10 == 3)
suf = "rd";
else
suf = "th";
sprintf (buf,
"{wIt is {w%d {wo'clock {W%s{w, Day of {W%s{w, {Y%d%s {wthe Month of {Y%s{w.{x\n\r",
(time_info.hour % 12 == 0) ? 12 : time_info.hour % 12,
time_info.hour >= 12 ? "pm" : "am",
day_name[day % 7], day, suf, month_name[time_info.month]);
send_to_char (buf, ch);
sprintf (buf,
"{wAlternate Eternity {wstarted up at {w%s{x\n\r{wThe system time is {W%s{x\n\r",
str_boot_time, (char *) ctime (¤t_time));
send_to_char (buf, ch);
sprintf (buf, "Reboot will commence in %i minutes.\n\r", reboot_counter);
send_to_char (buf, ch);
return;
}
void
reboot_countdown (void)
{
DESCRIPTOR_DATA *d;
for (d = descriptor_list; d; d = d->next)
{
if (d->connected == CON_PLAYING)
{
if (reboot_counter == 4)
{
send_to_char
("{z{B***{x {RReboot in {W4{R hours.{x {z{B***{x\n\r",
d->character);
}
if (reboot_counter == 3)
{
send_to_char
("{z{B***{x {RReboot in {W3{R hours.{x {z{B***{x\n\r",
d->character);
}
if (reboot_counter == 2)
{
send_to_char
("{z{B***{x {RReboot in {W2{R hours.{x {z{B***{x\n\r",
d->character);
}
if (reboot_counter == 1)
{
send_to_char
("{z{B***{x {RReboot in {W1{R hours.{x {z{B***{x\n\r",
d->character);
}
if (reboot_counter == 5)
{
send_to_char
("{z{B***{x {RReboot in {W5{R hours.{x {z{B***{x\n\r",
d->character);
}
}
}
if (reboot_counter == 0)
{
reboot_rot ();
}
return;
}
void
do_help (CHAR_DATA * ch, char *argument)
{
HELP_DATA *pHelp;
BUFFER *output;
bool found = FALSE;
char argall[MAX_INPUT_LENGTH], argone[MAX_INPUT_LENGTH];
char nohelp[MAX_STRING_LENGTH];
int level;
output = new_buf ();
if (argument[0] == '\0')
argument = "summary";
strcpy (nohelp, argument);
/* this parts handles help a b so that it returns help 'a b' */
argall[0] = '\0';
while (argument[0] != '\0')
{
argument = one_argument (argument, argone);
if (argall[0] != '\0')
strcat (argall, " ");
strcat (argall, argone);
}
for (pHelp = help_first; pHelp != NULL; pHelp = pHelp->next)
{
level = (pHelp->level < 0) ? -1 * pHelp->level - 1 : pHelp->level;
if (level > get_trust (ch))
continue;
if (is_name (argall, pHelp->keyword))
{
/* add seperator if found */
if (found)
add_buf (output,
"\n\r{M============================================================{x\n\r\n\r");
if (pHelp->level >= 0 && str_cmp (argall, "imotd"))
{
add_buf (output, pHelp->keyword);
add_buf (output, "\n\r");
}
/*
* Strip leading '.' to allow initial blanks.
*/
if (pHelp->text[0] == '.')
add_buf (output, pHelp->text + 1);
else
add_buf (output, pHelp->text);
found = TRUE;
/* small hack :) */
if (ch->desc != NULL && ch->desc->connected != CON_PLAYING
&& ch->desc->connected != CON_GEN_GROUPS)
break;
}
}
if (!found)
{
send_to_char ("No help on that word.\n\r", ch);
append_file (ch, HELP_FILE, nohelp);
}
else
page_to_char (buf_string (output), ch);
free_buf (output);
}
/* whois command */
void
do_whois (CHAR_DATA * ch, char *argument)
{
char arg[MAX_INPUT_LENGTH];
BUFFER *output;
char buf[MAX_STRING_LENGTH];
DESCRIPTOR_DATA *d;
bool found = FALSE;
one_argument (argument, arg);
if (arg[0] == '\0')
{
send_to_char ("{RYou must provide a name.{x\n\r", ch);
return;
}
output = new_buf ();
for (d = descriptor_list; d != NULL; d = d->next)
{
CHAR_DATA *wch;
char const *class;
if (d->connected != CON_PLAYING || !can_see (ch, d->character))
continue;
wch = (d->original != NULL) ? d->original : d->character;
if (!can_see (ch, wch))
continue;
if (!str_prefix (arg, wch->name))
{
found = TRUE;
/* work out the printing */
class = class_table[wch->class].who_name;
switch (wch->level)
{
case MAX_LEVEL - 0:
class = "IMP";
break;
case MAX_LEVEL - 1:
class = "CRE";
break;
case MAX_LEVEL - 2:
class = "SUP";
break;
case MAX_LEVEL - 3:
class = "DEI";
break;
case MAX_LEVEL - 4:
class = "GOD";
break;
case MAX_LEVEL - 5:
class = "IMM";
break;
case MAX_LEVEL - 6:
class = "DEM";
break;
case MAX_LEVEL - 7:
class = "ANG";
break;
case MAX_LEVEL - 8:
class = "AVA";
break;
}
/* a little formatting */
sprintf (buf, "{W[ %3d %s ] %s%s%s%s%s%s%s%s{x\n\r",
wch->level,
wch->race <
MAX_PC_RACE ? pc_race_table[wch->race].who_name : " ",
wch->incog_level >= LEVEL_HERO ? "{C({WIncog{C){x " : "",
wch->invis_level >= LEVEL_HERO ? "{C({WWizi{C){x " : "",
wch->ghost_level >= LEVEL_HERO
&& (ch->level >= wch->level) ? "{R({wGhost{R){x " : "",
clan_table[wch->clan].who_name, IS_SET (wch->comm,
COMM_AFK) ?
"{C[{YAFK{C]{G " : "", IS_SET (wch->act,
PLR_THIEF) ?
"{C({rTHIEF{C){G " : "", wch->name,
IS_NPC (wch) ? "" : wch->pcdata->title);
add_buf (output, buf);
}
}
if (!found)
{
send_to_char ("{RNo one of that name is playing.{x\n\r", ch);
return;
}
page_to_char (buf_string (output), ch);
free_buf (output);
}
void
do_who (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH], buf2[MAX_STRING_LENGTH];
BUFFER *output;
DESCRIPTOR_DATA *d;
int iClass, iRace, iClan, iLevelLower, iLevelUpper;
int nNumber, nMatch, immmatch, mortmatch, wlevel;
bool rgfClass[MAX_CLASS];
bool rgfRace[MAX_PC_RACE];
bool rgfClan[MAX_CLAN];
bool fClassRestrict = FALSE;
bool fClanRestrict = FALSE;
bool fClan = FALSE;
bool fRaceRestrict = FALSE;
bool fImmortalOnly = FALSE;
/*
* Initalize Variables.
*/
immmatch = 0;
mortmatch = 0;
nNumber = 0;
nMatch = 0;
buf[0] = '\0';
output = new_buf ();
/*
* Set default arguments.
*/
iLevelLower = 0;
iLevelUpper = MAX_LEVEL;
for (iClass = 0; iClass < MAX_CLASS; iClass++)
rgfClass[iClass] = FALSE;
for (iRace = 0; iRace < MAX_PC_RACE; iRace++)
rgfRace[iRace] = FALSE;
for (iClan = 0; iClan < MAX_CLAN; iClan++)
rgfClan[iClan] = FALSE;
/*
* Parse arguments.
*/
for (;;)
{
char arg[MAX_STRING_LENGTH];
argument = one_argument (argument, arg);
if (arg[0] == '\0')
break;
if (is_number (arg))
{
switch (++nNumber)
{
case 1:
iLevelLower = atoi (arg);
break;
case 2:
iLevelUpper = atoi (arg);
break;
default:
send_to_char ("Only two level numbers allowed.\n\r", ch);
return;
}
}
else
{
/*
* Look for classes to turn on.
*/
if ((!str_prefix (arg, "immortals")) || (!str_prefix (arg, "imm")))
{
fImmortalOnly = TRUE;
}
else
{
iClass = class_lookup (arg);
if (iClass == -1)
{
iRace = race_lookup (arg);
if (iRace == 0 || iRace >= MAX_PC_RACE)
{
if (!str_prefix (arg, "clan"))
fClan = TRUE;
else
{
iClan = clan_lookup (arg);
if (iClan)
{
fClanRestrict = TRUE;
rgfClan[iClan] = TRUE;
}
else
{
send_to_char
("That's not a valid race, class, or clan.\n\r",
ch);
return;
}
}
}
else
{
fRaceRestrict = TRUE;
rgfRace[iRace] = TRUE;
}
}
else
{
fClassRestrict = TRUE;
rgfClass[iClass] = TRUE;
}
}
}
} // for
/*
* Count and output the IMMs.
*/
sprintf (buf,
"{c<{D-{R-----------{D-{WImmortals{D-{R-----------{D-{c>{x\n\r");
add_buf (output, buf);
sprintf (buf, "{D[{w Rnk -Race- Class {D]{w Immortal's Name{x\n\r");;
add_buf (output, buf);
for (wlevel = MAX_LEVEL; wlevel > LEVEL_HERO; wlevel--)
{
for (d = descriptor_list; d != NULL; d = d->next)
{
CHAR_DATA *wch;
char const *class;
if (d->connected != CON_PLAYING || !can_see (ch, d->character))
continue;
wch = (d->original != NULL) ? d->original : d->character;
if (wch->level != wlevel)
continue;
if (!can_see (ch, wch) || wch->level < LEVEL_IMMORTAL)
continue;
if (wch->level < iLevelLower
|| wch->level > iLevelUpper
|| (fImmortalOnly && wch->level < LEVEL_IMMORTAL)
|| (fClassRestrict && !rgfClass[wch->class])
|| (fRaceRestrict && !rgfRace[wch->race])
|| (fClan && !is_clan (wch))
|| (fClanRestrict && !rgfClan[wch->clan]))
continue;
immmatch++;
nMatch++;
/*
* Figure out what to print for class.
*/
class = class_table[wch->class].who_name;
switch (wch->level)
{
default:
break;
{
case MAX_LEVEL - 0:
class = "Implement";
break;
case MAX_LEVEL - 1:
class = "Admin";
break;
case MAX_LEVEL - 2:
class = "Overseer";
break;
case MAX_LEVEL - 3:
class = "Security";
break;
case MAX_LEVEL - 4:
class = "HdBuilder";
break;
case MAX_LEVEL - 5:
class = "AvBuilder";
break;
case MAX_LEVEL - 6:
class = "Builder";
break;
case MAX_LEVEL - 7:
class = "Guild";
break;
case MAX_LEVEL - 8:
class = "Training";
break;
}
}
/*
* Format it up.
*/
sprintf (buf, "{D[ %3d {w%6s {W%10s {D]{x %s%s%s{W%s{x%s\n\r",
wch->level - (MAX_LEVEL - 8),
wch->race < MAX_PC_RACE ? pc_race_table[wch->race].who_name
: " ", class,
wch->incog_level >= LEVEL_HERO ? "{C({WInco{C){x " : "",
wch->invis_level >= LEVEL_HERO ? "{C({WWizi{C){x " : "",
IS_SET (wch->comm, COMM_AFK) ? "{C[{YAFK{C] " : "",
wch->name, IS_NPC (wch) ? "" : wch->pcdata->title);
add_buf (output, buf);
}
}
/*
* Count and output the Morts.
*/
sprintf (buf,
" \n\r{c<{C-{D------------{C-{WMortals{C-{D------------{C-{c>{x\n\r");
add_buf (output, buf);
sprintf (buf, "{x{D[ {w-Race- {D]{w Mortal's Name{x\n\r");;
add_buf (output, buf);
for (wlevel = LEVEL_HERO; wlevel > 0; wlevel--)
{
for (d = descriptor_list; d != NULL; d = d->next)
{
CHAR_DATA *wch;
char const *class;
if (d->connected != CON_PLAYING || !can_see (ch, d->character))
continue;
wch = (d->original != NULL) ? d->original : d->character;
if (wch->level != wlevel)
continue;
/* if (!can_see(ch,wch) || wch->level > ch->level || wch->level > (MAX_LEVEL - 5))
continue; */
if (!can_see (ch, wch))
continue;
if (wch->level < iLevelLower
|| wch->level > iLevelUpper
|| (fImmortalOnly && wch->level < LEVEL_IMMORTAL)
|| (fClassRestrict && !rgfClass[wch->class])
|| (fRaceRestrict && !rgfRace[wch->race])
|| (fClan && !is_clan (wch))
|| (fClanRestrict && !rgfClan[wch->clan]))
continue;
mortmatch++;
nMatch++;
/*
* Figure out what to print for class.
*/
class = class_table[wch->class].who_name;
switch (wch->level)
{
default:
break;
{
case MAX_LEVEL - 0:
class = "IMP";
break;
case MAX_LEVEL - 1:
class = "CRE";
break;
case MAX_LEVEL - 2:
class = "SUP";
break;
case MAX_LEVEL - 3:
class = "DEI";
break;
case MAX_LEVEL - 4:
class = "GOD";
break;
case MAX_LEVEL - 5:
class = "IMM";
break;
case MAX_LEVEL - 6:
class = "DEM";
break;
case MAX_LEVEL - 7:
class = "ANG";
break;
case MAX_LEVEL - 8:
class = "AVA";
break;
}
}
/*
* Format it up.
*/
sprintf (buf, "{D[ {w%6s {D]{x {W%s{x%s {x{r%s{x\n\r",
wch->race <
MAX_PC_RACE ? pc_race_table[wch->race].who_name : " ",
IS_NPC (wch) ? "" : wch->pcdata->title,
wch->name, clan_table[wch->clan].who_name);
add_buf (output, buf);
}
}
max_on = UMAX (nMatch, max_on);
sprintf (buf2,
"\n\r{xPlayers found: {W%d{x, Immortals: {W%d{x, Mortals: {W%d\n\r{xMost on today {x%d{x\n\r",
nMatch, immmatch, mortmatch, max_on);
add_buf (output, buf2);
page_to_char (buf_string (output), ch);
free_buf (output);
return;
}
void
do_count (CHAR_DATA * ch, char *argument)
{
int count;
DESCRIPTOR_DATA *d;
char buf[MAX_STRING_LENGTH];
count = 0;
for (d = descriptor_list; d != NULL; d = d->next)
if (d->connected == CON_PLAYING && can_see (ch, d->character))
count++;
max_on = UMAX (count, max_on);
if (max_on == count)
sprintf (buf,
"{GThere are {W%d {Gcharacters on, the most so far today.{x\n\r",
count);
else
sprintf (buf,
"{GThere are {W%d {Gcharacters on, the most on today was {W%d{G.{x\n\r",
count, max_on);
send_to_char (buf, ch);
}
void
do_inventory (CHAR_DATA * ch, char *argument)
{
send_to_char ("{GYou are carrying:{x\n\r", ch);
show_list_to_char (ch->carrying, ch, TRUE, TRUE);
return;
}
char *eq_worn(CHAR_DATA *ch, int iWear)
{
OBJ_DATA *obj;
if ((obj = get_eq_char(ch,iWear)) != NULL){
if ( can_see_obj( ch, obj ) )
{
return(format_obj_to_char(obj, ch, TRUE));
}
else
{
return( "Something");
}
}
return("");
}
void do_new_equipment( CHAR_DATA *ch, char *argument )
{
send_to_char("\n{wYou are currently Wearing the following Eq:{x\n\r",ch);
// printf_to_char(ch,"{CF{Wloatin{Cg {g:{x%-40s\n",eq_worn(ch,WEAR_FLOAT));
if (!IS_SET (ch->act, PLR_EQLIST))
{
if (eq_worn(ch,WEAR_LIGHT) != "")
{
printf_to_char(ch,"{C<{DAs Light {C>{x %s\n\r",eq_worn(ch,WEAR_LIGHT));
}
}
if (IS_SET (ch->act, PLR_EQLIST))
{
printf_to_char(ch,"{C<{DOn Left Finger {C>{x %s\n\r",eq_worn(ch,WEAR_FINGER_L));
printf_to_char(ch,"{C<{DOn Right Finger{C>{x %s\n\r",eq_worn(ch,WEAR_FINGER_R));
printf_to_char(ch,"{C<{DAround Neck {C>{x %s\n\r",eq_worn(ch,WEAR_NECK_1));
printf_to_char(ch,"{C<{DAround Neck {C>{x %s\n\r",eq_worn(ch,WEAR_NECK_2));
printf_to_char(ch,"{C<{DOn Body {C>{x %s\n\r",eq_worn(ch,WEAR_BODY));
printf_to_char(ch,"{C<{DOn Head {C>{x %s\n\r",eq_worn(ch,WEAR_HEAD));
printf_to_char(ch,"{C<{DOn Legs {C>{x %s\n\r",eq_worn(ch,WEAR_LEGS));
printf_to_char(ch,"{C<{DOn Feet {C>{x %s\n\r",eq_worn(ch,WEAR_FEET));
printf_to_char(ch,"{C<{DOn Hands {C>{x %s\n\r",eq_worn(ch,WEAR_HANDS));
printf_to_char(ch,"{C<{DOn Arms {C>{x %s\n\r",eq_worn(ch,WEAR_ARMS));
printf_to_char(ch,"{C<{DAs Shield {C>{x %s\n\r",eq_worn(ch,WEAR_SHIELD));
printf_to_char(ch,"{C<{DAbout Body {C>{x %s\n\r",eq_worn(ch,WEAR_ABOUT));
printf_to_char(ch,"{C<{DOn Waist {C>{x %s\n\r",eq_worn(ch,WEAR_WAIST));
printf_to_char(ch,"{C<{DOn Left Wrist {C>{x %s\n\r",eq_worn(ch,WEAR_WRIST_L));
printf_to_char(ch,"{C<{DOn Right Wrist {C>{x %s\n\r",eq_worn(ch,WEAR_WRIST_R));
printf_to_char(ch,"{C<{DWield {C>{x %s\n\r",eq_worn(ch,WEAR_WIELD));
printf_to_char(ch,"{C<{DHeld {C>{x %s\n\r",eq_worn(ch,WEAR_HOLD));
printf_to_char(ch,"{C<{DFloating Nearby{C>{x %s\n\r",eq_worn(ch,WEAR_FLOAT));
printf_to_char(ch,"{C<{DOn Tail {C>{x %s\n\r",eq_worn(ch,WEAR_TAIL));
printf_to_char(ch,"{C<{DOver Face {C>{x %s\n\r",eq_worn(ch,WEAR_FACE));
printf_to_char(ch,"{C<{DOver Eyes {C>{x %s\n\r",eq_worn(ch,WEAR_EYES));
printf_to_char(ch,"{C<{DEar Piercing {C>{x %s\n\r",eq_worn(ch,WEAR_EARS));
printf_to_char(ch,"{C<{DOn Left Ankle {C>{x %s\n\r",eq_worn(ch,WEAR_ANKLE_L));
printf_to_char(ch,"{C<{DOn Right Ankle {C>{x %s\n\r",eq_worn(ch,WEAR_ANKLE_R));
printf_to_char(ch,"{C<{DAs Padding {C>{x %s\n\r",eq_worn(ch,WEAR_UNDERWEAR));
printf_to_char(ch,"{C<{DOver Abdomen {C>{x %s\n\r",eq_worn(ch,WEAR_BELLY));
printf_to_char(ch,"{C<{DOver Knees {C>{x %s\n\r",eq_worn(ch,WEAR_KNEES));
printf_to_char(ch,"{C<{DOn Back {C>{x %s\n\r",eq_worn(ch,WEAR_BACK));
printf_to_char(ch,"{C<{DDual Wield {C>{x %s\n\r",eq_worn(ch,WEAR_SECONDARY));
printf_to_char(ch,"{C<{DOn Shoulders {C>{x %s\n\r",eq_worn(ch,WEAR_SHOULDERS));
}
else
{
if (eq_worn(ch,WEAR_FINGER_L) != "")
printf_to_char(ch,"{C<{DOn Left Finger {C>{x %s\n\r",eq_worn(ch,WEAR_FINGER_L));
if (eq_worn(ch,WEAR_FINGER_R) != "")
printf_to_char(ch,"{C<{DOn Right Finger{C>{x %s\n\r",eq_worn(ch,WEAR_FINGER_R));
if (eq_worn(ch,WEAR_NECK_1) != "")
printf_to_char(ch,"{C<{DAround Neck {C>{x %s\n\r",eq_worn(ch,WEAR_NECK_1));
if (eq_worn(ch,WEAR_NECK_2) != "")
printf_to_char(ch,"{C<{DAround Neck {C>{x %s\n\r",eq_worn(ch,WEAR_NECK_2));
if (eq_worn(ch,WEAR_BODY) != "")
printf_to_char(ch,"{C<{DOn Body {C>{x %s\n\r",eq_worn(ch,WEAR_BODY));
if (eq_worn(ch,WEAR_HEAD) != "")
printf_to_char(ch,"{C<{DOn Head {C>{x %s\n\r",eq_worn(ch,WEAR_HEAD));
if (eq_worn(ch,WEAR_LEGS) != "")
printf_to_char(ch,"{C<{DOn Legs {C>{x %s\n\r",eq_worn(ch,WEAR_LEGS));
if (eq_worn(ch,WEAR_FEET) != "")
printf_to_char(ch,"{C<{DOn Feet {C>{x %s\n\r",eq_worn(ch,WEAR_FEET));
if (eq_worn(ch,WEAR_HANDS) != "")
printf_to_char(ch,"{C<{DOn Hands {C>{x %s\n\r",eq_worn(ch,WEAR_HANDS));
if (eq_worn(ch,WEAR_ARMS) != "")
printf_to_char(ch,"{C<{DOn Arms {C>{x %s\n\r",eq_worn(ch,WEAR_ARMS));
if (eq_worn(ch,WEAR_SHIELD) != "")
printf_to_char(ch,"{C<{DAs Shield {C>{x %s\n\r",eq_worn(ch,WEAR_SHIELD));
if (eq_worn(ch,WEAR_ABOUT) != "")
printf_to_char(ch,"{C<{DAbout Body {C>{x %s\n\r",eq_worn(ch,WEAR_ABOUT));
if (eq_worn(ch,WEAR_WAIST) != "")
printf_to_char(ch,"{C<{DOn Waist {C>{x %s\n\r",eq_worn(ch,WEAR_WAIST));
if (eq_worn(ch,WEAR_WRIST_L) != "")
printf_to_char(ch,"{C<{DOn Left Wrist {C>{x %s\n\r",eq_worn(ch,WEAR_WRIST_L));
if (eq_worn(ch,WEAR_WRIST_R) != "")
printf_to_char(ch,"{C<{DOn Right Wrist {C>{x %s\n\r",eq_worn(ch,WEAR_WRIST_R));
if (eq_worn(ch,WEAR_WIELD) != "")
printf_to_char(ch,"{C<{DWield {C>{x %s\n\r",eq_worn(ch,WEAR_WIELD));
if (eq_worn(ch,WEAR_HOLD) != "")
printf_to_char(ch,"{C<{DHeld {C>{x %s\n\r",eq_worn(ch,WEAR_HOLD));
if (eq_worn(ch,WEAR_FLOAT) != "")
printf_to_char(ch,"{C<{DFloating Nearby{C>{x %s\n\r",eq_worn(ch,WEAR_FLOAT));
if (eq_worn(ch,WEAR_TAIL) != "")
printf_to_char(ch,"{C<{DOn Tail {C>{x %s\n\r",eq_worn(ch,WEAR_TAIL));
if (eq_worn(ch,WEAR_FACE) != "")
printf_to_char(ch,"{C<{DOver Face {C>{x %s\n\r",eq_worn(ch,WEAR_FACE));
if (eq_worn(ch,WEAR_EYES) != "")
printf_to_char(ch,"{C<{DOver Eyes {C>{x %s\n\r",eq_worn(ch,WEAR_EYES));
if (eq_worn(ch,WEAR_EARS) != "")
printf_to_char(ch,"{C<{DEar Piercing {C>{x %s\n\r",eq_worn(ch,WEAR_EARS));
if (eq_worn(ch,WEAR_ANKLE_L) != "")
printf_to_char(ch,"{C<{DOn Left Ankle {C>{x %s\n\r",eq_worn(ch,WEAR_ANKLE_L));
if (eq_worn(ch,WEAR_ANKLE_R) != "")
printf_to_char(ch,"{C<{DOn Right Ankle {C>{x %s\n\r",eq_worn(ch,WEAR_ANKLE_R));
if (eq_worn(ch,WEAR_UNDERWEAR) != "")
printf_to_char(ch,"{C<{DAs Padding {C>{x %s\n\r",eq_worn(ch,WEAR_UNDERWEAR));
if (eq_worn(ch,WEAR_BELLY) != "")
printf_to_char(ch,"{C<{DOver Abdomen {C>{x %s\n\r",eq_worn(ch,WEAR_BELLY));
if (eq_worn(ch,WEAR_KNEES) != "")
printf_to_char(ch,"{C<{DOver Knees {C>{x %s\n\r",eq_worn(ch,WEAR_KNEES));
if (eq_worn(ch,WEAR_BACK) != "")
printf_to_char(ch,"{C<{DOn Back {C>{x %s\n\r",eq_worn(ch,WEAR_BACK));
if (eq_worn(ch,WEAR_SECONDARY) != "")
printf_to_char(ch,"{C<{DDual Wield {C>{x %s\n\r",eq_worn(ch,WEAR_SECONDARY));
if (eq_worn(ch,WEAR_SHOULDERS) != "")
printf_to_char(ch,"{C<{DOn Shoulders {C>{x %s\n\r",eq_worn(ch,WEAR_SHOULDERS));
}
return;
}
void
do_equipment (CHAR_DATA * ch, char *argument)
{
OBJ_DATA *obj;
int iWear, iOrder;
bool found;
/* custom wear location display
* be sure and insert into this table where
* you want equipment to list in the equip
* command ***CUSTOM TAKA ***
*/
int iWear_order[MAX_WEAR] = { 18, 0, 6, 21, 22, 20, 3, 4, 5, 30, 10,
14, 15, 9, 1, 2, 17, 11, 16, 12, 28, 26,
13, 25, 19, 7, 27, 24, 23, 8, 29, 31, 32, 33
};
send_to_char ("{GYou are using:{x\n\r", ch);
found = FALSE;
for (iWear = 0; iWear < MAX_WEAR; iWear++)
{
iOrder = iWear_order[iWear];
if ((obj = get_eq_char (ch, iOrder)) == NULL)
{
if ((iWear_order[iWear] == 8) && !IS_SET (ch->parts, PART_TAIL))
continue;
// send_to_char( "{C", ch );
// send_to_char( where_name[iOrder], ch );
// send_to_char( "{x\n\r", ch );
continue;
}
send_to_char ("{C", ch);
send_to_char (where_name[iOrder], ch);
send_to_char ("{x", ch);
if (can_see_obj (ch, obj))
{
send_to_char (format_obj_to_char (obj, ch, TRUE), ch);
send_to_char ("\n\r", ch);
}
else
{
send_to_char ("{csomething.{x\n\r", ch);
}
found = TRUE;
}
if (!found)
send_to_char ("{YNothing.{x\n\r", ch);
return;
}
void
do_compare (CHAR_DATA * ch, char *argument)
{
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
OBJ_DATA *obj1;
OBJ_DATA *obj2;
int value1;
int value2;
char *msg;
argument = one_argument (argument, arg1);
argument = one_argument (argument, arg2);
if (arg1[0] == '\0')
{
send_to_char ("{RCompare what to what?{x\n\r", ch);
return;
}
if ((obj1 = get_obj_carry (ch, arg1, ch)) == NULL)
{
send_to_char ("{RYou do not have that item.{x\n\r", ch);
return;
}
if (arg2[0] == '\0')
{
for (obj2 = ch->carrying; obj2 != NULL; obj2 = obj2->next_content)
{
if (obj2->wear_loc != WEAR_NONE && can_see_obj (ch, obj2)
&& obj1->item_type == obj2->item_type
&& (obj1->wear_flags & obj2->wear_flags & ~ITEM_TAKE) != 0)
break;
}
if (obj2 == NULL)
{
send_to_char ("{YYou aren't wearing anything comparable.{x\n\r",
ch);
return;
}
}
else if ((obj2 = get_obj_carry (ch, arg2, ch)) == NULL)
{
send_to_char ("{YYou do not have that item.{x\n\r", ch);
return;
}
msg = NULL;
value1 = 0;
value2 = 0;
if (obj1 == obj2)
{
msg = "{GYou compare {w$p {Gto itself. {YIt looks about the same.{x";
}
else if (obj1->item_type != obj2->item_type)
{
msg = "{GYou can't compare {w$p {Gand {w$P{G.{x";
}
else
{
switch (obj1->item_type)
{
default:
msg = "{GYou can't compare {w$p {Gand {w$P{G.{c";
break;
case ITEM_ARMOR:
value1 = obj1->value[0] + obj1->value[1] + obj1->value[2];
value2 = obj2->value[0] + obj2->value[1] + obj2->value[2];
break;
case ITEM_WEAPON:
if (obj1->pIndexData->new_format)
value1 = (1 + obj1->value[2]) * obj1->value[1];
else
value1 = obj1->value[1] + obj1->value[2];
if (obj2->pIndexData->new_format)
value2 = (1 + obj2->value[2]) * obj2->value[1];
else
value2 = obj2->value[1] + obj2->value[2];
break;
}
}
if (msg == NULL)
{
if (value1 == value2)
msg = "{w$p {Gand {w$P {Glook about the same.{x";
else if (value1 > value2)
msg = "{w$p {Glooks better than {w$P{G.{x";
else
msg = "{w$p {Glooks worse than {w$P{G.{x";
}
act (msg, ch, obj1, obj2, TO_CHAR);
return;
}
void
do_credits (CHAR_DATA * ch, char *argument)
{
do_function (ch, &do_help, "diku");
do_function (ch, &do_help, "ghost");
return;
}
void
do_where (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
DESCRIPTOR_DATA *d;
bool found;
one_argument (argument, arg);
sprintf (buf, "\n{WIn Area: {M%s{x\n\n\r", ch->in_room->area->name);
send_to_char (buf, ch);
if (arg[0] == '\0')
{
send_to_char ("{GPlayers near you:{x\n\r", ch);
found = FALSE;
for (d = descriptor_list; d; d = d->next)
{
if (d->connected == CON_PLAYING
&& (victim = d->character) != NULL && !IS_NPC (victim)
&& victim->in_room != NULL
&& !IS_SET (victim->in_room->room_flags, ROOM_NOWHERE)
&& (is_room_owner (ch, victim->in_room)
|| !room_is_private (victim->in_room))
&& get_trust (ch) >= victim->ghost_level
&& victim->in_room->area == ch->in_room->area
&& can_see (ch, victim))
{
found = TRUE;
sprintf (buf, "{W%-28s {G%s{x\n\r",
victim->name, victim->in_room->name);
send_to_char (buf, ch);
}
}
if (!found)
send_to_char ("{GNone{x\n\r", ch);
}
else
{
found = FALSE;
for (victim = char_list; victim != NULL; victim = victim->next)
{
if (victim->in_room != NULL
&& victim->in_room->area == ch->in_room->area
&& get_trust (ch) >= victim->ghost_level
&& !IS_AFFECTED (victim, AFF_HIDE)
&& !IS_AFFECTED (victim, AFF_SNEAK)
&& can_see (ch, victim)
&& is_name (arg, victim->name) && !IS_NPC (victim))
{
found = TRUE;
sprintf (buf, "{W%-28s {G%s{x\n\r",
PERS (victim, ch), victim->in_room->name);
send_to_char (buf, ch);
break;
}
}
if (!found)
act ("{RYou didn't find any {w$T{R.{x", ch, NULL, arg, TO_CHAR);
}
return;
}
void
do_consider (CHAR_DATA * ch, char *argument)
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
char *msg;
int diff;
one_argument (argument, arg);
if (arg[0] == '\0')
{
send_to_char ("{RConsider killing whom?{x\n\r", ch);
return;
}
if ((victim = get_char_room (ch, NULL, arg)) == NULL)
{
send_to_char ("{RThey're not here.{x\n\r", ch);
return;
}
if (is_safe (ch, victim))
{
send_to_char ("{RDon't even think about it.{x\n\r", ch);
return;
}
diff = victim->level - ch->level;
if (diff <= -10)
msg = "{GYou can kill {w$N {Gnaked and weaponless.{x";
else if (diff <= -5)
msg = "{W$N {Gis no match for you.{x";
else if (diff <= -2)
msg = "{W$N {Glooks like an easy kill.{x";
else if (diff <= 1)
msg = "{YThe perfect match!{x";
else if (diff <= 4)
msg = "{W$N {Gsays 'Do you feel lucky, punk?'{x.";
else if (diff <= 9)
msg = "{W$N {Glaughs at you mercilessly.{x";
else
msg = "{DDeath will thank you for your gift.{x";
act (msg, ch, NULL, victim, TO_CHAR);
return;
}
void
set_title (CHAR_DATA * ch, char *title)
{
char buf[MAX_STRING_LENGTH];
if (IS_NPC (ch))
{
bug ("{GSet_title: {YNPC{G.{x", 0);
return;
}
if (IS_IMMORTAL (ch))
{
if (title[0] != '.' && title[0] != ',' && title[0] != '!'
&& title[0] != '?')
{
buf[0] = ' ';
strcpy (buf + 1, title);
}
else
{
strcpy (buf, title);
}
}
else
{
strcpy (buf, title);
strcat (buf, " ");
}
free_string (ch->pcdata->title);
ch->pcdata->title = str_dup (buf);
return;
}
void
do_title (CHAR_DATA * ch, char *argument)
{
strip_mortal_color (argument, TRUE);
if (IS_NPC (ch))
return;
if (argument[0] == '\0')
{
send_to_char ("{RChange your title to what?{x\n\r", ch);
return;
}
if (strlen (argument) > 45)
argument[70] = '\0';
smash_tilde (argument);
set_title (ch, argument);
send_to_char ("{GTitle changed.{x\n\r", ch);
}
void
do_description (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
if (argument[0] != '\0')
{
buf[0] = '\0';
smash_tilde (argument);
if (argument[0] == '-')
{
int len;
bool found = FALSE;
if (ch->description == NULL || ch->description[0] == '\0')
{
send_to_char ("{RNo lines left to remove.{x\n\r", ch);
return;
}
strcpy (buf, ch->description);
for (len = strlen (buf); len > 0; len--)
{
if (buf[len] == '\r')
{
if (!found)
{ /* back it up */
if (len > 0)
len--;
found = TRUE;
}
else
{ /* found the second one */
buf[len + 1] = '\0';
free_string (ch->description);
ch->description = str_dup (buf);
send_to_char ("{GYour description is:{x\n\r", ch);
send_to_char (ch->description ? ch->description :
"{G(None).{x\n\r", ch);
return;
}
}
}
buf[0] = '\0';
free_string (ch->description);
ch->description = str_dup (buf);
send_to_char ("{GDescription cleared.{x\n\r", ch);
return;
}
if (argument[0] == '+')
{
if (ch->description != NULL)
strcat (buf, ch->description);
argument++;
while (isspace (*argument))
argument++;
}
if (strlen (buf) >= 1024)
{
send_to_char ("{RDescription too long.{x\n\r", ch);
return;
}
strcat (buf, argument);
strcat (buf, "\n\r");
free_string (ch->description);
ch->description = str_dup (buf);
}
send_to_char ("{GYour description is:{x\n\r", ch);
send_to_char (ch->description ? ch->description : "{G(None).{x\n\r", ch);
return;
}
void
do_report (CHAR_DATA * ch, char *argument)
{
char buf[MAX_INPUT_LENGTH];
sprintf (buf,
"{GYou say 'I have {R%d{G/{W%d {Ghp {R%d{G/{W%d {Gmana {R%d{G/{W%d {Gmv {M%d {Gxp.{x'\n\r",
ch->hit, ch->max_hit,
ch->mana, ch->max_mana, ch->move, ch->max_move, ch->exp);
send_to_char (buf, ch);
sprintf (buf,
"{W$n {Gsays 'I have {R%d{G/{W%d {Ghp {R%d{G/{W%d {Gmana {R%d{G/{W%d {Gmv {M%d {Gxp.'{x",
ch->hit, ch->max_hit, ch->mana, ch->max_mana, ch->move,
ch->max_move, ch->exp);
act (buf, ch, NULL, NULL, TO_ROOM);
return;
}
void
do_practice (CHAR_DATA * ch, char *argument)
{
BUFFER *buffer = new_buf ();
char buf[MAX_STRING_LENGTH];
char buf2[MAX_STRING_LENGTH];
int sn, first = 0;
if (IS_NPC (ch))
return;
if (argument[0] == '\0')
{
int col;
col = 0;
add_buf (buffer,"{G=-=-=- Spells -=-=-={W\n\r");
for (sn = 0; sn < MAX_SKILL; sn++)
{
if (skill_table[sn].name == NULL)
break;
if (ch->level < skill_table[sn].skill_level[ch->class]
|| ch->pcdata->learned[sn] < 1 /* skill is not known */ )
continue;
if (ch->pcdata->learned[sn] <= 25)
sprintf (buf2, "{W%-22s {r%3d{W%% {x",
capitalize (skill_table[sn].name),
ch->pcdata->learned[sn]);
else if (ch->pcdata->learned[sn] <= 50)
sprintf (buf2, "{W%-22s {R%3d{W%% {x",
capitalize (skill_table[sn].name),
ch->pcdata->learned[sn]);
else if (ch->pcdata->learned[sn] <= 75)
sprintf (buf2, "{W%-22s {Y%3d{W%% {x",
capitalize (skill_table[sn].name),
ch->pcdata->learned[sn]);
else if (ch->pcdata->learned[sn] <= 99)
sprintf (buf2, "{W%-22s {W%3d%% {x",
capitalize (skill_table[sn].name),
ch->pcdata->learned[sn]);
else if (ch->pcdata->learned[sn] >= 100)
sprintf (buf2, "{W%-22s {C%3d%% {x",
capitalize (skill_table[sn].name),
ch->pcdata->learned[sn]);
if ((skill_table[sn].spell_fun == spell_null) && (first == 0))
{
first = 1;
col = 0;
add_buf(buffer,"\n\n {G =-=-=- Skills -=-=-= {x\n\r");
}
add_buf(buffer,buf2);
if (++col % 3 == 0)
{
add_buf(buffer,"\n\r");
}
}
if (col % 3 != 0)
{
send_to_char ("\n\r", ch);
}
sprintf (buf, "\n{RYou have {W%d {Rpractice sessions left.{x\n\r",
ch->practice);
add_buf(buffer, buf);
buf[0] = '\0';
buf2[0] = '\0';
page_to_char (buf_string (buffer), ch);
free_buf(buffer);
}
else
{
CHAR_DATA *mob;
int adept;
if (!IS_AWAKE (ch))
{
send_to_char ("{RIn your dreams, or what?{x\n\r", ch);
return;
}
for (mob = ch->in_room->people; mob != NULL; mob = mob->next_in_room)
{
if (IS_NPC (mob) && IS_SET (mob->act, ACT_PRACTICE))
break;
}
if (mob == NULL)
{
send_to_char ("{RYou can't do that here.{x\n\r", ch);
return;
}
if (ch->practice <= 0)
{
send_to_char ("{RYou have no practice sessions left.{x\n\r", ch);
return;
}
if ((sn = find_spell (ch, argument)) < 0 || (!IS_NPC (ch) && (ch->level < skill_table[sn].skill_level[ch->class] || ch->pcdata->learned[sn] < 1 /* skill is not known */
||
skill_table
[sn].
rating
[ch->
class] ==
0)))
{
send_to_char ("{RYou can't practice that.{x\n\r", ch);
return;
}
adept = IS_NPC (ch) ? 100 : class_table[ch->class].skill_adept;
if (ch->pcdata->learned[sn] >= adept)
{
sprintf (buf, "{RYou are already learned at {W%s.{x\n\r",
skill_table[sn].name);
send_to_char (buf, ch);
}
else
{
ch->practice--;
ch->pcdata->learned[sn] +=
int_app[get_curr_stat (ch, STAT_INT)].learn /
skill_table[sn].rating[ch->class];
if (ch->pcdata->learned[sn] < adept)
{
act ("{RYou practice {W$T.{x",
ch, NULL, skill_table[sn].name, TO_CHAR);
act ("{W$n {Rpractices {W$T.{x",
ch, NULL, skill_table[sn].name, TO_ROOM);
}
else
{
ch->pcdata->learned[sn] = adept;
act ("{YYou are now learned at {W$T.{x",
ch, NULL, skill_table[sn].name, TO_CHAR);
act ("{W$n {Yis now learned at {W$T.{x",
ch, NULL, skill_table[sn].name, TO_ROOM);
}
}
}
return;
}
/*
* 'Wimpy' originally by Dionysos.
*/
void
do_wimpy (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
int wimpy;
one_argument (argument, arg);
if (arg[0] == '\0')
wimpy = ch->max_hit / 5;
else
wimpy = atoi (arg);
if (wimpy < 0)
{
send_to_char ("{RYour courage exceeds your wisdom.{x\n\r", ch);
return;
}
if (wimpy > ch->max_hit / 2)
{
send_to_char ("{RSuch cowardice ill becomes you.{x\n\r", ch);
return;
}
ch->wimpy = wimpy;
sprintf (buf, "{RWimpy set to {W%d {Rhit points.{x\n\r", wimpy);
send_to_char (buf, ch);
return;
}
void
do_password (CHAR_DATA * ch, char *argument)
{
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char *pArg;
char *pwdnew;
char *p;
char cEnd;
if (IS_NPC (ch))
return;
/*
* Can't use one_argument here because it smashes case.
* So we just steal all its code. Bleagh.
*/
pArg = arg1;
while (isspace (*argument))
argument++;
cEnd = ' ';
if (*argument == '\'' || *argument == '"')
cEnd = *argument++;
while (*argument != '\0')
{
if (*argument == cEnd)
{
argument++;
break;
}
*pArg++ = *argument++;
}
*pArg = '\0';
pArg = arg2;
while (isspace (*argument))
argument++;
cEnd = ' ';
if (*argument == '\'' || *argument == '"')
cEnd = *argument++;
while (*argument != '\0')
{
if (*argument == cEnd)
{
argument++;
break;
}
*pArg++ = *argument++;
}
*pArg = '\0';
if (arg1[0] == '\0' || arg2[0] == '\0')
{
send_to_char ("{RSyntax: {Wpassword {C<{Yold{C> <{Ynew{C>{G.{x\n\r",
ch);
return;
}
if (strcmp ((char *) crypt (arg1, ch->pcdata->pwd), ch->pcdata->pwd))
{
WAIT_STATE (ch, 40);
send_to_char ("{RWrong password. Wait 10 seconds.{x\n\r", ch);
return;
}
if (strlen (arg2) < 5)
{
send_to_char
("{RNew password must be at least five characters long.{x\n\r", ch);
return;
}
/*
* No tilde allowed because of player file format.
*/
pwdnew = (char *) crypt (arg2, ch->name);
for (p = pwdnew; *p != '\0'; p++)
{
if (*p == '~')
{
send_to_char ("{RNew password not acceptable, try again.{x\n\r",
ch);
return;
}
}
free_string (ch->pcdata->pwd);
ch->pcdata->pwd = str_dup (pwdnew);
save_char_obj (ch);
send_to_char ("{GPassword changed!{x\n\r", ch);
return;
}
/* TAKA JAIL COMMAND */
void
do_jail (CHAR_DATA * ch, char *argument)
{
char arg[MAX_INPUT_LENGTH], buf[MAX_STRING_LENGTH];
CHAR_DATA *victim;
one_argument (argument, arg);
if (arg[0] == '\0')
{
send_to_char ("{RJail whom?{x\n\r", ch);
return;
}
if ((victim = get_char_world (ch, arg)) == NULL)
{
send_to_char ("{RThey aren't here.{x\n\r", ch);
return;
}
if (IS_NPC (victim))
{
send_to_char ("{RNot on NPC's.{x\n\r", ch);
return;
}
if (get_trust (victim) >= get_trust (ch))
{
send_to_char ("{RYou failed.{x\n\r", ch);
return;
}
sprintf (buf, "$N jails %s", victim->name);
wiznet (buf, ch, NULL, WIZ_PENALTIES, WIZ_SECURE, 0);
send_to_char ("OK.\n\r", ch);
save_char_obj (victim);
stop_fighting (victim, TRUE);
sprintf (buf, "%s 1", victim->name);
do_transfer (ch, buf);
do_freeze (ch, victim->name);
do_disconnect (ch, victim->name);
return;
}
void
do_omni (CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
char buf2[MAX_STRING_LENGTH];
BUFFER *output;
DESCRIPTOR_DATA *d;
int immmatch, nMatch;
int mortmatch;
int hptemp, wlevel, MLevel;
/*
* Initalize Variables.
*/
immmatch = 0;
mortmatch = 0;
buf[0] = '\0';
output = new_buf ();
/*
* Count and output the IMMs.
*/
sprintf (buf, "{Y ----Immortals:----\n\r");
add_buf (output, buf);
sprintf (buf,
"{GName {RLevel {MWiz {CIncog {G[{W Vnum{G]{x\n\r");
add_buf (output, buf);
for (wlevel = MAX_LEVEL; wlevel > LEVEL_HERO; wlevel--)
{
for (d = descriptor_list; d != NULL; d = d->next)
{
CHAR_DATA *wch;
if (d->connected != CON_PLAYING || !can_see (ch, d->character))
continue;
wch = (d->original != NULL) ? d->original : d->character;
if (wch->level != wlevel)
continue;
if (!can_see (ch, wch) || wch->level < LEVEL_IMMORTAL)
continue;
immmatch++;
nMatch++;
sprintf (buf,
"{G%-14s {R%d {M%-3d {C%-3d {G[{W%5ld{G]{x\n\r",
wch->name, wch->level, wch->invis_level, wch->incog_level,
wch->in_room->vnum);
add_buf (output, buf);
}
}
/*
* Count and output the Morts.
*/
sprintf (buf, " \n\r {Y----Mortals:----\n\r");
add_buf (output, buf);
sprintf (buf,
"{GName {RRace{G/{cClass {CPosition {BLev {M%%hps {G[{W Vnum{G] TrL{x\n\r");
add_buf (output, buf);
hptemp = 0;
for (wlevel = LEVEL_HERO; wlevel > 0; wlevel--)
{
for (d = descriptor_list; d != NULL; d = d->next)
{
CHAR_DATA *wch;
char const *class;
if (d->connected != CON_PLAYING || !can_see (ch, d->character))
continue;
wch = (d->original != NULL) ? d->original : d->character;
if (wch->level != wlevel)
continue;
if (!can_see (ch, wch) || wch->level > ch->level
|| wch->level > (MAX_LEVEL - 5))
continue;
mortmatch++;
if ((wch->max_hit != wch->hit) && (wch->hit > 0))
hptemp = (wch->hit * 100) / wch->max_hit;
else if (wch->max_hit == wch->hit)
hptemp = 100;
else if (wch->hit < 0)
hptemp = 0;
class = class_table[wch->class].who_name;
if (ch->trust > ch->level)
MLevel = ch->trust;
else
MLevel = ch->level;
sprintf (buf,
"{G%-14s {R%5s{G/{c%3s {C%-15s {B%-3d {M%3d%% {G[{W%5ld{G] %3d{x\n\r",
wch->name,
wch->race <
MAX_PC_RACE ? pc_race_table[wch->race].who_name : " ",
class, capitalize (position_table[wch->position].name),
wch->level, hptemp, wch->in_room->vnum,
(MLevel >= wch->trust) ? wch->trust : 0);
add_buf (output, buf);
}
}
/*
* Tally the counts and send the whole list out.
*/
sprintf (buf2, "\n\r{DIMMs found: {W%d{x\n\r", immmatch);
add_buf (output, buf2);
sprintf (buf2, "{DMorts found: {W%d{x\n\r", mortmatch);
add_buf (output, buf2);
page_to_char (buf_string (output), ch);
free_buf (output);
return;
}
/*
* This command checks for hidden objects
* (c) 2000 TAKA
*/
void
do_search (CHAR_DATA * ch, char *argument)
{
OBJ_DATA *obj;
if (IS_NPC (ch))
return;
if (ch->pcdata->learned[gsn_search] < 1)
{
send_to_char ("{GYou search around making lots of noise.{x\n\r", ch);
return;
}
if (number_percent () < ch->pcdata->learned[gsn_search])
{
check_improve (ch, gsn_search, TRUE, 4);
send_to_char ("{GYou search the room..{x\n\r", ch);
for (obj = ch->in_room->contents; obj != NULL; obj = obj->next_content)
{
if (IS_SET (obj->extra_flags, ITEM_HIDDEN))
{
printf_to_char (ch, "{GYou reveal {W%s{x\n\r",
obj->short_descr);
REMOVE_BIT (obj->extra_flags, ITEM_HIDDEN);
}
}
send_to_char ("{GYou have searched everywhere.{x\n\r", ch);
WAIT_STATE (ch, 24);
}
else
send_to_char ("{GYou didn't uncover anything unusual.{x\n\r", ch);
check_improve (ch, gsn_search, FALSE, 4);
WAIT_STATE (ch, 24);
return;
}
void
do_peek (CHAR_DATA * ch, char *argument)
{
CHAR_DATA *victim;
if ((victim = get_char_room (ch, NULL, argument)) == NULL)
{
send_to_char ("They aren't here.\n\r", ch);
return;
}
if (number_percent () < get_skill (ch, gsn_peek))
{
act ("You peek at $N's inventory:", ch, NULL, victim, TO_CHAR);
check_improve (ch, gsn_peek, TRUE, 4);
show_list_to_char (victim->carrying, ch, TRUE, TRUE);
if (get_curr_stat (victim, STAT_INT) > get_curr_stat (ch, STAT_INT))
act ("$n peeks inside your inventory!", ch, NULL, victim, TO_VICT);
}
else
{
act ("You failed to peek inside $N's inventory!", ch, NULL, victim,
TO_NOTVICT);
act ("$n tried to peek inside your inventory!", ch, NULL, victim,
TO_VICT);
act ("$n tried to peek inside $N's inventory!", ch, NULL, victim,
TO_ROOM);
check_improve (ch, gsn_peek, FALSE, 4);
}
return;
}