/***************************************************************************
* 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-1995 Russ Taylor *
* ROM has been brought to you by the ROM consortium *
* Russ Taylor (rtaylor@pacinfo.com) *
* Gabrielle Taylor (gtaylor@pacinfo.com) *
* Brian Moore (rom@rom.efn.org) *
* By using this code, you have agreed to follow the terms of the *
* ROM license, in the file Rom24/doc/rom.license *
***************************************************************************/
/***************************************************************************
* ROT 1.4 is copyright 1996-1997 by Russ Walsh *
* By using this code, you have agreed to follow the terms of the *
* ROT license, in the file doc/rot.license *
***************************************************************************/
#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include "merc.h"
#include "magic.h"
#include "recycle.h"
#include "tables.h"
#include "lookup.h"
#include "newclan.h"
#include "newquest.h"
#include "global_mods.h"
long obj_points(OBJ_INDEX_DATA * obj);
long obj_balance(OBJ_INDEX_DATA * obj);
/* command procedures needed */
DECLARE_DO_FUN (do_exits);
DECLARE_DO_FUN (do_look);
DECLARE_DO_FUN (do_help);
DECLARE_DO_FUN (do_affects);
DECLARE_DO_FUN (do_play);
DECLARE_DO_FUN (do_inventory);
DECLARE_DO_FUN (do_mstat);
DECLARE_DO_FUN (do_sense);
int focus_dam(CHAR_DATA *ch);
int focus_ac(CHAR_DATA *ch);
int focus_hit(CHAR_DATA *ch);
int tier_level_bonus(CHAR_DATA *ch);
char * total_length(char *input, int length);
char * get_descr_form(CHAR_DATA *ch,CHAR_DATA *looker, bool get_long);
char * escape_colours(char *argument);
int tier_wear_limit(CHAR_DATA *ch, OBJ_DATA *obj);
char * const where_name[] =
{ "{G<{Cused as light{G>{x ", "{G<{Cworn on finger{G>{x ",
"{G<{Cworn on finger{G>{x ", "{G<{Cworn around neck{G>{x ",
"{G<{Cworn around neck{G>{x ", "{G<{Cworn on torso{G>{x ",
"{G<{Cworn on head{G>{x ", "{G<{Cworn on legs{G>{x ",
"{G<{Cworn on feet{G>{x ", "{G<{Cworn on hands{G>{x ",
"{G<{Cworn on arms{G>{x ", "{G<{Cworn as shield{G>{x ",
"{G<{Cworn about body{G>{x ", "{G<{Cworn about waist{G>{x ",
"{G<{Cworn around wrist{G>{x ", "{G<{Cworn around wrist{G>{x ",
"{G<{Cprimary wield{G>{x ", "{G<{Cheld{G>{x ",
"{G<{Cfloating nearby{G>{x ", "{G<{Csecondary wield{G>{x ",
"{G<{Cworn on face{G>{x ", "{G<{Cworn on ears{G>{x ",
"{G<{Cworn on {!bug{G>{x ", "{G<{Cworn on ankle{G>{x ",
"{G<{Cworn on ankle{G>{x ", "{G<{Cclan patch{G>{x ",
"{G<{Creligion patch{G>{x ", "{G<{Cchest patch{G>{x ",
"{G<{Cworn on back{G>{x " };
sh_int const where_order[] =
{ 1, 2, 3, 4, 5, 6, 20, 7, 23, 24, 8, 9, 10, 11, 12, 13, 14, 15, 16, 19, 17,
18, 21, 22, 28, 0, 25, 26, 27 };
/* for do_count */
int max_on = 0;
bool is_pm = FALSE;
/*
* Local functions.
*/
char *format_obj_to_char(OBJ_DATA * obj, CHAR_DATA * ch, bool fShort);
BUFFER * show_list_to_char(OBJ_DATA * list, CHAR_DATA * ch, bool fShort, bool fShowNothing);
void show_char_to_char_0(CHAR_DATA * victim, CHAR_DATA * ch);
void show_char_to_char_1(CHAR_DATA * victim, CHAR_DATA * ch);
void show_char_to_char(CHAR_DATA * list, CHAR_DATA * ch);
bool check_blind(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;
if (!IS_SET (ch->comm, COMM_LONG))
{
strcat(buf, "{x[{y.{R.{B.{M.{Y.{W.{G.{x]");
if (IS_OBJ_STAT (obj, ITEM_INVIS))
buf[5] = 'V';
if (IS_AFFECTED (ch, AFF_DETECT_EVIL) && IS_OBJ_STAT (obj, ITEM_EVIL))
buf[8] = 'E';
if (IS_AFFECTED (ch, AFF_DETECT_GOOD) && IS_OBJ_STAT (obj, ITEM_BLESS))
buf[11] = 'B';
if (IS_AFFECTED (ch, AFF_DETECT_MAGIC) && IS_OBJ_STAT (obj, ITEM_MAGIC))
buf[14] = 'M';
if (IS_OBJ_STAT (obj, ITEM_GLOW))
buf[17] = 'G';
// if (IS_OBJ_STAT (obj, ITEM_HUM))
if ((obj->tier_level > tier_level_bonus(ch)) && (obj->tier_level < tier_level_bonus(ch) + 10))
buf[20] = 'h';
else if ((obj->tier_level >= tier_level_bonus(ch) + 10) && (obj->tier_level < tier_level_bonus(ch) + 25))
buf[20] = 'H';
else if ((obj->tier_level >= tier_level_bonus(ch) + 25) && (obj->tier_level < tier_level_bonus(ch) + 50))
buf[20] = 'v';
else if (obj->tier_level >= (tier_level_bonus(ch) + 50) )
buf[20] = 'V';
if (IS_OBJ_STAT (obj, ITEM_QUEST))
buf[23] = 'Q';
if (!strcmp(buf, "{x[{y.{R.{B.{M.{Y.{W.{G.{x]"))
buf[0] = '\0';
}
else
{
if (IS_OBJ_STAT (obj, ITEM_INVIS))
strcat(buf, "({yInvis{x)");
if (IS_OBJ_STAT (obj, ITEM_DARK))
strcat(buf, "({DHidden{x)");
if (IS_AFFECTED (ch, AFF_DETECT_EVIL) && IS_OBJ_STAT (obj, ITEM_EVIL))
strcat(buf, "({RRed Aura{x)");
if (IS_AFFECTED (ch, AFF_DETECT_GOOD) && IS_OBJ_STAT (obj, ITEM_BLESS))
strcat(buf, "({BBlue Aura{x)");
if (IS_AFFECTED (ch, AFF_DETECT_MAGIC) && IS_OBJ_STAT (obj, ITEM_MAGIC))
strcat(buf, "({yMagical{x)");
if (IS_OBJ_STAT (obj, ITEM_GLOW))
strcat(buf, "({YGlowing{x)");
if (IS_OBJ_STAT (obj, ITEM_HUM))
strcat(buf, "({yHumming{x)");
if ((obj->tier_level > tier_level_bonus(ch)) && (obj->tier_level < tier_level_bonus(ch) + 10))
strcat(buf, "({yHumming{x)");
else if ((obj->tier_level >= tier_level_bonus(ch) + 10) && (obj->tier_level < tier_level_bonus(ch) + 25))
strcat(buf, "({YHumming{x)");
else if ((obj->tier_level >= tier_level_bonus(ch) + 25) && (obj->tier_level < tier_level_bonus(ch) + 50))
strcat(buf, "({yBuzzing{x)");
else if (obj->tier_level >= (tier_level_bonus(ch) + 50) )
strcat(buf, "({YBuzzing{x)");
if (IS_OBJ_STAT (obj, ITEM_QUEST))
strcat(buf, "({GQuest{x)");
if (obj->owner != NULL && ch->name != NULL && !str_cmp(obj->owner,
ch->name))
strcat(buf, "({#Emblazoned{x)");
}
if (buf[0] != '\0')
{
strcat(buf, " ");
}
if (fShort)
{
if (obj->short_descr != NULL)
strcat(buf, obj->short_descr);
}
else
{
if (obj->description != NULL)
strcat(buf, obj->description);
}
if (strlen(buf) <= 0)
strcat(buf, "This object has no description. Please inform Tas.");
return buf;
}
/*
* Show a list to a character.
* Can coalesce duplicated items.
*/
BUFFER *show_list_to_char(OBJ_DATA *list, CHAR_DATA *ch, bool fShort,
bool fShowNothing)
{
BUFFER *final = new_buf();
char buf[MAX_STRING_LENGTH];
char **prgpstrShow;
int *prgnShow;
char *pstrShow;
OBJ_DATA *obj;
int nShow;
int iShow;
int count = 0;
bool fCombine;
for (obj = list; obj != NULL; obj = obj->next_content)
{
if (++count >= 8500)
{
add_buf(final, "{RToo many objects found.{x\n\r");
return final;
}
}
prgpstrShow = alloc_mem(count * sizeof(char *));
prgnShow = alloc_mem(count * sizeof(int));
nShow = 0;
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, "(%2d) ", prgnShow[iShow]);
add_buf(final, buf);
}
else
{
add_buf(final, " ");
}
}
add_buf(final, prgpstrShow[iShow]);
add_buf(final, "\n\r");
free_string(prgpstrShow[iShow]);
}
if (fShowNothing && nShow == 0)
{
if (IS_NPC(ch) || IS_SET( ch->comm, COMM_COMBINE ))
add_buf(final, " ");
add_buf(final, "{WNothing.{x\n\r");
}
/*
* Clean up.
*/
free_mem(prgpstrShow, count * sizeof(char *));
free_mem(prgnShow, count * sizeof(int));
return final;
}
void show_char_to_char_0(CHAR_DATA * victim, CHAR_DATA * ch)
{
char buf[MAX_STRING_LENGTH], message[MAX_STRING_LENGTH];
buf[0] = '\0';
if (!IS_SET (ch->comm, COMM_LONG))
{
strcat(buf, "{x[{y.{D.{c.{b.{w.{C.{r.{B.{D.{R.{Y.{W.{G.{x]");
if (IS_SHIELDED (victim, SHD_INVISIBLE))
buf[5] = 'V';
if (IS_AFFECTED (victim, AFF_HIDE))
buf[8] = 'H';
if (IS_AFFECTED (victim, AFF_CHARM))
buf[11] = 'C';
if (IS_AFFECTED (victim, AFF_PASS_DOOR))
buf[14] = 'T';
if (IS_AFFECTED (victim, AFF_FAERIE_FIRE))
buf[17] = 'P';
if (IS_SHIELDED (victim, SHD_ICE))
buf[20] = 'I';
if (IS_SHIELDED (victim, SHD_FIRE))
buf[23] = 'F';
if (IS_SHIELDED (victim, SHD_SHOCK))
buf[26] = 'L';
if (IS_SHIELDED (victim, SHD_DEATH))
buf[29] = 'D';
if (IS_EVIL (victim) && IS_AFFECTED (ch, AFF_DETECT_EVIL))
buf[32] = 'E';
if (IS_GOOD (victim) && IS_AFFECTED (ch, AFF_DETECT_GOOD))
buf[35] = 'G';
if (IS_SHIELDED (victim, SHD_SANCTUARY))
buf[38] = 'S';
if (victim->on_quest)
{
if (!IS_NPC (victim) || IS_IMMORTAL (ch))
buf[41] = 'Q';
}
if (!str_cmp(buf, "{x[{y.{D.{c.{b.{w.{C.{r.{B.{D.{R.{Y.{W.{G.{x]"))
buf[0] = '\0';
if (IS_SET (victim->plyr, PLAYER_GHOST))
strcat(buf, "[{7G{wH{7O{wS{7T{x]");
if (IS_SET (victim->comm, COMM_AFK))
strcat(buf, "[{yAFK{x]");
if (victim->invis_level >= LEVEL_HERO)
strcat(buf, "({WWizi{x)");
}
else
{
if (IS_SET (victim->plyr, PLAYER_GHOST))
strcat(buf, "[{7G{wH{7O{wS{7T{x]");
if (IS_SET (victim->comm, COMM_AFK))
strcat(buf, "[{yAFK{x]");
if (IS_SHIELDED (victim, SHD_INVISIBLE))
strcat(buf, "({yInvis{x)");
if (victim->invis_level >= LEVEL_HERO)
strcat(buf, "({WWizi{x)");
if (IS_AFFECTED (victim, AFF_HIDE))
strcat(buf, "({DHide{x)");
if (IS_AFFECTED (victim, AFF_CHARM))
strcat(buf, "({cCharmed{x)");
if (IS_AFFECTED (victim, AFF_PASS_DOOR))
strcat(buf, "({bTranslucent{x)");
if (IS_AFFECTED (victim, AFF_FAERIE_FIRE))
strcat(buf, "({wPink Aura{x)");
if (IS_SHIELDED (victim, SHD_ICE))
strcat(buf, "({DGrey Aura{x)");
if (IS_SHIELDED (victim, SHD_FIRE))
strcat(buf, "({rOrange Aura{x)");
if (IS_SHIELDED (victim, SHD_SHOCK))
strcat(buf, "({BBlue Aura{x)");
if (IS_SHIELDED (victim, SHD_DEATH))
strcat(buf, "({DBlack Aura{x)");
if (IS_EVIL (victim) && IS_AFFECTED (ch, AFF_DETECT_EVIL))
strcat(buf, "({RRed Aura{x)");
if (IS_GOOD (victim) && IS_AFFECTED (ch, AFF_DETECT_GOOD))
strcat(buf, "({YGolden Aura{x)");
if (IS_SHIELDED (victim, SHD_SANCTUARY))
strcat(buf, "({WWhite Aura{x)");
if (victim->on_quest)
{
if (!IS_NPC (victim) || IS_IMMORTAL (ch))
strcat(buf, "({GQuest{x)");
}
}
if (!IS_NPC (victim) && IS_SET (victim->act, PLR_TWIT))
strcat(buf, "({rTWIT{x)");
if (IS_NPC (victim) && ch->qstate == QSTATE_MOB && victim->pIndexData->vnum
== ch->qtarget)
strcat(buf, "{R[TARGET]{x ");
if ((victim->long_descr[0] != '\0') || (victim->morph_form[0] != 0))
{
strcat(buf, get_descr_form(victim, ch, TRUE));
send_to_char(buf, ch);
return;
}
if (!IS_NPC (victim) && !IS_SET (ch->comm, COMM_BRIEF) && victim->position
== POS_STANDING && ch->on == NULL && victim->morph_form[0] == 0)
strcat(buf, victim->pcdata->pretit);
if (buf[0] != '\0')
{
strcat(buf, " ");
}
strcat(buf, get_descr_form(victim, ch, FALSE));
if (!IS_NPC (victim) && !IS_SET (ch->comm, COMM_BRIEF) && victim->position
== POS_STANDING && ch->on == NULL && victim->morph_form[0] == 0)
strcat(buf, victim->pcdata->title);
switch (victim->position)
{
case POS_DEAD:
strcat(buf, " is DEAD!!");
break;
case POS_MORTAL:
strcat(buf, " is mortally wounded.");
break;
case POS_INCAP:
strcat(buf, " is incapacitated.");
break;
case POS_STUNNED:
strcat(buf, " is lying here stunned.");
break;
case POS_SLEEPING:
if (victim->on != NULL)
{
if (IS_SET (victim->on->value[2], SLEEP_AT))
{
sprintf(message, " is sleeping at %s.", victim->on->short_descr);
strcat(buf, message);
}
else if (IS_SET (victim->on->value[2], SLEEP_ON))
{
sprintf(message, " is sleeping on %s.", victim->on->short_descr);
strcat(buf, message);
}
else
{
sprintf(message, " is sleeping in %s.", victim->on->short_descr);
strcat(buf, message);
}
}
else
strcat(buf, " is sleeping here.");
break;
case POS_RESTING:
if (victim->on != NULL)
{
if (IS_SET (victim->on->value[2], REST_AT))
{
sprintf(message, " is resting at %s.", victim->on->short_descr);
strcat(buf, message);
}
else if (IS_SET (victim->on->value[2], REST_ON))
{
sprintf(message, " is resting on %s.", victim->on->short_descr);
strcat(buf, message);
}
else
{
sprintf(message, " is resting in %s.", victim->on->short_descr);
strcat(buf, message);
}
}
else
strcat(buf, " is resting here.");
break;
case POS_SITTING:
if (victim->on != NULL)
{
if (IS_SET (victim->on->value[2], SIT_AT))
{
sprintf(message, " is sitting at %s.", victim->on->short_descr);
strcat(buf, message);
}
else if (IS_SET (victim->on->value[2], SIT_ON))
{
sprintf(message, " is sitting on %s.", victim->on->short_descr);
strcat(buf, message);
}
else
{
sprintf(message, " is sitting in %s.", victim->on->short_descr);
strcat(buf, message);
}
}
else
strcat(buf, " is sitting here.");
break;
case POS_STANDING:
if (victim->on != NULL)
{
if (IS_SET (victim->on->value[2], STAND_AT))
{
sprintf(message, " is standing at %s.", victim->on->short_descr);
strcat(buf, message);
}
else if (IS_SET (victim->on->value[2], STAND_ON))
{
sprintf(message, " is standing on %s.", victim->on->short_descr);
strcat(buf, message);
}
else
{
sprintf(message, " is standing in %s.", victim->on->short_descr);
strcat(buf, message);
}
}
else
strcat(buf, " is here.");
break;
case POS_FIGHTING:
strcat(buf, " is here, fighting ");
if (victim->fighting == NULL)
strcat(buf, "thin air??");
else if (victim->fighting == ch)
strcat(buf, "YOU!");
else if (victim->in_room == victim->fighting->in_room)
{
strcat(buf, PERS (victim->fighting, ch));
strcat(buf, ".");
}
else
strcat(buf, "someone who left??");
break;
}
strcat(buf, "\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 oWear;
int percent;
bool found;
CHAR_DATA *tch;
/* if (can_see (victim, ch)
&& get_trust (victim) >= ch->ghost_level)
{
if (ch == victim)
act ("$n looks at $mself.", ch, NULL, NULL, TO_ROOM);
else
{
act ("$n looks at you.", ch, NULL, victim, TO_VICT);
act ("$n looks at $N.", ch, NULL, victim, TO_NOTVICT);
}
} */
if (ch == victim)
{
for (tch = ch->in_room->people; tch != NULL; tch = tch->next_in_room)
{
if (can_see(tch, ch) && (ch != victim) && (tch != ch) && get_trust(
victim) >= ch->ghost_level)
act("$n looks at $mself.", ch, NULL, tch, TO_VICT);
}
}
else
{
if (can_see(victim, ch) && get_trust(victim) >= ch->ghost_level)
act("$n looks at you.", ch, NULL, victim, TO_VICT );
for (tch = ch->in_room->people; tch != NULL; tch = tch->next_in_room)
{
if (can_see(tch, ch) && (tch != victim) && get_trust(victim)
>= ch->ghost_level)
{
sprintf(buf, "$n looks at %s.", get_descr_form(victim, tch,
FALSE));
act(buf, ch, NULL, tch, TO_VICT);
}
}
}
if (!IS_IMMORTAL(ch) && !is_same_clan(ch, victim)
&& (is_affected(victim, gsn_conceal)
|| is_affected(victim, gsn_conceal2)
|| is_affected(victim, gsn_concealClan1)
|| is_affected(victim, gsn_concealClan2)))
{
send_to_char(
"The figure is buried deep within a dark green colored cloak.\n\r",
ch);
}
else if (victim->description[0] != '\0')
{
sprintf(buf, "{C%s{x", victim->description);
send_to_char(buf, ch);
}
else
{
act("{CYou see nothing special about $M.{x", ch, NULL, victim, TO_CHAR );
}
if (victim->max_hit > 0)
percent = (100 * victim->hit) / victim->max_hit;
else
percent = -1;
buf[0] = '\0';
strcpy(buf, get_descr_form(victim, ch, FALSE));
if (percent >= 100)
strcat(buf, " {(is in excellent condition.{x\n\r");
else if (percent >= 90)
strcat(buf, " {(has a few scratches.{x\n\r");
else if (percent >= 75)
strcat(buf, " {(has small wounds and bruises.{x\n\r");
else if (percent >= 50)
strcat(buf, " {(has quite a few wounds.{x\n\r");
else if (percent >= 30)
strcat(buf, " {(has some big nasty wounds and scratches.{x\n\r");
else if (percent >= 15)
strcat(buf, " {(is pretty hurt.{x\n\r");
else if (percent >= 0)
strcat(buf, " {(is in awful condition.{x\n\r");
else
strcat(buf, " {(is beyond dead...{x\n\r");
buf[0] = UPPER (buf[0]);
send_to_char(buf, ch);
if (IS_SHIELDED (victim, SHD_ICE))
{
sprintf(buf, "%s is surrounded by an {Cicy{x shield.\n\r",
PERS (victim, ch));
buf[0] = UPPER (buf[0]);
send_to_char(buf, ch);
}
if (IS_SHIELDED (victim, SHD_FIRE))
{
sprintf(buf, "%s is surrounded by a {Rfiery{x shield.\n\r",
PERS (victim, ch));
buf[0] = UPPER (buf[0]);
send_to_char(buf, ch);
}
if (IS_SHIELDED (victim, SHD_SHOCK))
{
sprintf(buf, "%s is surrounded by a {Bcrackling{x shield.\n\r",
PERS (victim, ch));
buf[0] = UPPER (buf[0]);
send_to_char(buf, ch);
}
if (IS_SHIELDED (victim, SHD_DEATH))
{
sprintf(buf, "%s is surrounded by a {Ddeath{x shield.\n\r",
PERS (victim, ch));
buf[0] = UPPER (buf[0]);
send_to_char(buf, ch);
}
if (!IS_IMMORTAL(ch) && !is_same_clan(ch, victim)
&& (is_affected(victim, gsn_conceal)
|| is_affected(victim, gsn_conceal2)
|| is_affected(victim, gsn_concealClan1)
|| is_affected(victim, gsn_concealClan2)))
;
else
// if (!is_affected(victim, gsn_conceal) || IS_IMMORTAL(ch) || (is_affected(
// victim, gsn_conceal) && is_same_clan(ch, victim)))
{
found = FALSE;
for (oWear = 0; oWear < MAX_WEAR; oWear++)
{
iWear = where_order[oWear];
if ((obj = get_eq_char(victim, iWear)) != NULL && can_see_obj(ch,
obj))
{
if (!found)
{
send_to_char("\n\r", ch);
sprintf(buf, "{G%s is using:{x\n\r", victim->name);
send_to_char(buf, ch);
found = TRUE;
}
sprintf(buf, "%s%s\n\r", where_name[iWear], format_obj_to_char(
obj, ch, TRUE));
send_to_char(buf, ch);
}
}
}
if (victim != ch && !IS_NPC (ch) && number_percent() < get_skill(ch,
gsn_peek) && IS_SET (ch->act, PLR_AUTOPEEK))
{
BUFFER *output = show_list_to_char(victim->carrying, ch, TRUE, TRUE );
send_to_char("\n\r{GYou peek at the inventory:{x\n\r", ch);
check_improve(ch, gsn_peek, TRUE, 4);
page_to_char(output->string, ch);
free_buf(output);
}
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 (get_trust(ch) < rch->invis_level)
continue;
if ((!str_cmp(rch->long_descr, "{x\n\r")) && IS_NPC(rch))
continue;
if (get_trust(ch) < rch->ghost_level)
continue;
/* if(ch->long_descr == "")
continue; */
if (can_see(ch, rch))
{
show_char_to_char_0(rch, ch);
}
else if (room_is_dark(ch->in_room) && IS_AFFECTED (rch, AFF_INFRARED))
{
send_to_char("You see {Rglowing red{x eyes watching YOU!\n\r", ch);
}
}
return;
}
void do_peek(CHAR_DATA * ch, char *argument)
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
one_argument(argument, arg);
if (IS_NPC (ch))
return;
if (arg[0] == '\0')
{
send_to_char("Peek at who?\n\r", ch);
return;
}
if ((victim = get_char_room(ch, arg)) == NULL)
{
send_to_char("They aren't here.\n\r", ch);
return;
}
if (victim == ch)
{
do_inventory(ch, "");
return;
}
if (can_see(victim, ch) && get_trust(victim) >= ch->ghost_level)
{
act("$n peers intently at you.", ch, NULL, victim, TO_VICT);
act("$n peers intently at $N.", ch, NULL, victim, TO_NOTVICT);
}
if (number_percent() < get_skill(ch, gsn_peek))
{
BUFFER *output = show_list_to_char(victim->carrying, ch, TRUE, TRUE );
send_to_char("\n\r{GYou peek at the inventory:{x\n\r", ch);
check_improve(ch, gsn_peek, TRUE, 4);
page_to_char(output->string, ch);
free_buf(output);
}
else
{
send_to_char("{RYou fail to see anything.{x\n\r", ch);
check_improve(ch, gsn_peek, FALSE, 2);
}
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("You can't see a thing!\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("You do not page long messages.\n\r", ch);
else
{
sprintf(buf, "You currently display %d lines per page.\n\r",
ch->lines + 2);
send_to_char(buf, ch);
}
return;
}
if (!is_number(arg))
{
send_to_char("You must provide a number.\n\r", ch);
return;
}
lines = atoi(arg);
if (lines == 0)
{
send_to_char("Paging disabled.\n\r", ch);
ch->lines = 0;
return;
}
if (lines < 10 || lines > 100)
{
send_to_char("You must provide a reasonable number.\n\r", ch);
return;
}
sprintf(buf, "Scroll set to %d lines.\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_help(ch, "motd");
}
void do_imotd(CHAR_DATA * ch, char *argument)
{
do_help(ch, "imotd");
}
void do_rules(CHAR_DATA * ch, char *argument)
{
do_help(ch, "rules");
}
void do_story(CHAR_DATA * ch, char *argument)
{
do_help(ch, "story");
}
/* 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("{! ____________________________________ \n\r", ch);
send_to_char("{!| {!|\n\r", ch);
send_to_char("{!| {@action {@status {!|\n\r", ch);
send_to_char("{!| {!|\n\r", ch);
send_to_char("{!| {6newlook ", ch);
if (IS_SET(ch->plyr, PLAYER_NEWLOOK))
send_to_char(" {@ON {!|{x\n\r", ch);
else
send_to_char(" {!OFF {!|{x\n\r", ch);
send_to_char("{!| {6autoassist ", 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("{!| {6autoexit ", 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("{!| {6autogold ", 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("{!| {6autoloot ", 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("{!| {6autosac ", 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("{!| {6autosplit ", 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("{!| {6autopeek ", ch);
if (IS_SET(ch->act,PLR_AUTOPEEK))
send_to_char(" {@ON {!|{x\n\r", ch);
else
send_to_char(" {!OFF {!|{x\n\r", ch);
send_to_char("{!| {6autostore ", ch);
if (IS_SET(ch->comm,COMM_STORE))
send_to_char(" {@ON {!|{x\n\r", ch);
else
send_to_char(" {!OFF {!|{x\n\r", ch);
send_to_char("{!| {6compact mode ", 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("{!| {6prompt ", 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("{!| {6combine items", 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);
send_to_char("{!| {6long flags ", ch);
if (IS_SET(ch->comm,COMM_LONG))
send_to_char(" {@ON {!|{x\n\r", ch);
else
send_to_char(" {!OFF {!|{x\n\r", ch);
send_to_char("{!| {6noevolve ", ch);
if (IS_SET (ch->act,PLR_NOEVOLVE))
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("{!| {$Your corpse is harder to loot. {!|{x\n\r", ch);
else
send_to_char("{!| {$Your corpse is fully lootable {!|\n\r", ch);
if (IS_SET(ch->act,PLR_NOSUMMON))
send_to_char("{!| {$You cannot be summoned. {!|\n\r", ch);
else
send_to_char("{!| {$You can be summoned. {!|\n\r", ch);
if (IS_SET(ch->act,PLR_NOFOLLOW))
send_to_char("{!| {$You do not welcome followers. {!|\n\r", ch);
else
send_to_char("{!| {$You accept followers. {!|\n\r", ch);
if (IS_SET (ch->act, PLR_NOCANCEL))
send_to_char("{!| {$You are immune to cancel. {!|\n\r", ch);
else
send_to_char("{!| {$Cancel can be cast upon you. {!|\n\r", ch);
if (IS_SET (ch->act, PLR_NOTRAN))
send_to_char("{!| {$You are immune to transport. {!|\n\r", ch);
else
send_to_char("{!| {$You can be transported. {!|\n\r", ch);
if (IS_SET (ch->plyr, PLAYER_SUBDUE))
send_to_char("{!| {$You subdue your victims. {!|\n\r", ch);
else
send_to_char("{!| {$You kill your victims. {!|\n\r", ch);
send_to_char("{!| {!|\n\r", ch);
send_to_char("{!|____________________________________|{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("Autoassist removed.\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOASSIST);
}
else
{
send_to_char("You will now assist when needed.\n\r", ch);
SET_BIT (ch->act, PLR_AUTOASSIST);
}
}
void do_autoexit(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOEXIT))
{
send_to_char("Exits will no longer be displayed.\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOEXIT);
}
else
{
send_to_char("Exits will now be displayed.\n\r", ch);
SET_BIT (ch->act, PLR_AUTOEXIT);
}
}
void do_autogold(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOGOLD))
{
send_to_char("Autogold removed.\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOGOLD);
}
else
{
send_to_char("Automatic gold looting set.\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("Autolooting removed.\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOLOOT);
}
else
{
send_to_char("Automatic corpse looting set.\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("Autosacrificing removed.\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOSAC);
}
else
{
send_to_char("Automatic corpse sacrificing set.\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("Autosplitting removed.\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOSPLIT);
}
else
{
send_to_char("Automatic gold splitting set.\n\r", ch);
SET_BIT (ch->act, PLR_AUTOSPLIT);
}
}
void do_autopeek(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_AUTOPEEK))
{
send_to_char("Autopeek removed.\n\r", ch);
REMOVE_BIT (ch->act, PLR_AUTOPEEK);
}
else
{
send_to_char("Automatic peek set.\n\r", ch);
SET_BIT (ch->act, PLR_AUTOPEEK);
}
}
void do_brief(CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->comm, COMM_BRIEF))
{
send_to_char("Full descriptions activated.\n\r", ch);
REMOVE_BIT (ch->comm, COMM_BRIEF);
}
else
{
send_to_char("Short descriptions activated.\n\r", ch);
SET_BIT (ch->comm, COMM_BRIEF);
}
}
void do_short(CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->act, PLR_SHORT_COMBAT))
{
send_to_char("Short combat disabled.\n\r", ch);
REMOVE_BIT (ch->act, PLR_SHORT_COMBAT);
}
else
{
send_to_char("Short combat activated.\n\r", ch);
SET_BIT (ch->act, PLR_SHORT_COMBAT);
}
}
void do_compact(CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->comm, COMM_COMPACT))
{
send_to_char("Compact mode removed.\n\r", ch);
REMOVE_BIT (ch->comm, COMM_COMPACT);
}
else
{
send_to_char("Compact mode set.\n\r", ch);
SET_BIT (ch->comm, COMM_COMPACT);
}
}
void do_long(CHAR_DATA * ch, char *argument)
{
if (!IS_SET (ch->comm, COMM_LONG))
{
send_to_char("Long flags activated.\n\r", ch);
SET_BIT (ch->comm, COMM_LONG);
}
else
{
send_to_char("Short flags activated.\n\r", ch);
REMOVE_BIT (ch->comm, COMM_LONG);
}
}
void do_show(CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->comm, COMM_SHOW_AFFECTS))
{
send_to_char("Affects will no longer be shown in score.\n\r", ch);
REMOVE_BIT (ch->comm, COMM_SHOW_AFFECTS);
}
else
{
send_to_char("Affects will now be shown in score.\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("You will no longer see prompts.\n\r", ch);
REMOVE_BIT (ch->comm, COMM_PROMPT);
}
else
{
send_to_char("You will now see prompts.\n\r", ch);
SET_BIT (ch->comm, COMM_PROMPT);
}
send_to_char("Note: use the 'all' argument to set the default prompt, and the 'info' argument to see what your prompt currently is.\r\n", ch);
return;
}
if (!strcmp(argument, "all"))
strcpy(buf, "<%hhp %mm %vmv> ");
else if (!strcmp(argument, "info")) {
send_to_char("Your prompt is currently set to:\r\n", ch);
send_to_char(escape_colours(ch->prompt), ch);
send_to_char("\r\n", ch);
return;
} else {
if (strlen(argument) > 100)
argument[50] = '\0';
strcpy(buf, argument);
smash_tilde(buf);
if (str_suffix("%c", buf))
strcat(buf, "{x ");
}
free_string(ch->prompt);
ch->prompt = str_dup(buf);
send_to_char("Prompt set to:\r\n", ch);
send_to_char(escape_colours(ch->prompt), ch);
send_to_char("\r\n", ch);
return;
}
void do_combine(CHAR_DATA * ch, char *argument)
{
if (IS_SET (ch->comm, COMM_COMBINE))
{
send_to_char("Long inventory selected.\n\r", ch);
REMOVE_BIT (ch->comm, COMM_COMBINE);
}
else
{
send_to_char("Combined inventory selected.\n\r", ch);
SET_BIT (ch->comm, COMM_COMBINE);
}
}
void do_noevolve(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_NOEVOLVE))
{
send_to_char("You now have the possibility of evolving.\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOEVOLVE);
}
else
{
send_to_char("You will no longer evolve.\n\r", ch);
SET_BIT (ch->act, PLR_NOEVOLVE);
}
}
void do_nofalcon(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->plyr, PLAYER_NOFALCON))
{
send_to_char("You now have the help of your falcon.\n\r", ch);
REMOVE_BIT (ch->plyr, PLAYER_NOFALCON);
}
else
{
send_to_char("You will no longer have the help of your falcon.\n\r", ch);
SET_BIT (ch->plyr, PLAYER_NOFALCON);
}
}
void do_noloot(CHAR_DATA * ch, char *argument)
{
extern bool NOLOOT;
CHAR_DATA *wch;
if (IS_NPC (ch))
return;
if (ch->level >= 109)
{
if (NOLOOT)
{
send_to_char("Corpse Looting now allowed.\n\r", ch);
NOLOOT = FALSE;
for (wch = char_list; wch != NULL; wch = wch->next)
{
send_to_char(
"Global Loot Flag On: Your corpse may now be looted.\n\r",
wch);
}
}
else if (!NOLOOT)
{
send_to_char("Corpse Looting now NOT allowed.\n\r", ch);
NOLOOT = TRUE;
for (wch = char_list; wch != NULL; wch = wch->next)
{
send_to_char(
"Global Loot Flag Off: Your corpse is safe from thieves.\n\r",
wch);
}
}
}
else
{
if (IS_SET (ch->act, PLR_CANLOOT))
{
send_to_char("Your corpse is harder to loot.\n\r", ch);
REMOVE_BIT (ch->act, PLR_CANLOOT);
}
else
{
send_to_char("Your corpse is fully lootable.\n\r", ch);
SET_BIT (ch->act, PLR_CANLOOT);
}
}
return;
}
void do_nofollow(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET(ch->affected_by,AFF_CHARM))
{
send_to_char("I don't think so.\n\r", ch);
return;
}
if (IS_SET (ch->act, PLR_NOFOLLOW))
{
send_to_char("You now accept followers.\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOFOLLOW);
}
else
{
send_to_char("You no longer accept followers.\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("You are no longer immune to summon.\n\r", ch);
REMOVE_BIT (ch->imm_flags, IMM_SUMMON);
}
else
{
send_to_char("You are now immune to summoning.\n\r", ch);
SET_BIT (ch->imm_flags, IMM_SUMMON);
}
}
else
{
if (IS_SET (ch->act, PLR_NOSUMMON))
{
send_to_char("You are no longer immune to summon.\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOSUMMON);
}
else
{
send_to_char("You are now immune to summoning.\n\r", ch);
SET_BIT (ch->act, PLR_NOSUMMON);
}
}
}
void do_notran(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
{
return;
}
else
{
if (IS_SET (ch->act, PLR_NOTRAN))
{
send_to_char("You are no longer immune to transport.\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOTRAN);
}
else
{
send_to_char("You are now immune to transport.\n\r", ch);
SET_BIT (ch->act, PLR_NOTRAN);
}
}
}
void do_nogoto(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
{
return;
}
else
{
if (IS_SET (ch->act, PLR_NOGOTO))
{
send_to_char("You are no longer immune to goto.\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOGOTO);
}
else
{
send_to_char("You are now immune to goto.\n\r", ch);
SET_BIT (ch->act, PLR_NOGOTO);
}
}
}
void do_noviolate(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
{
return;
}
else
{
if (IS_SET (ch->act, PLR_NOVIOLATE))
{
send_to_char("You are no longer immune to violate.\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOVIOLATE);
}
else
{
send_to_char("You are now immune to violate.\n\r", ch);
SET_BIT (ch->act, PLR_NOVIOLATE);
}
}
}
void do_nocancel(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
{
return;
}
else
{
if (IS_SET (ch->act, PLR_NOCANCEL))
{
send_to_char("You are no longer immune to cancellation.\n\r", ch);
REMOVE_BIT (ch->act, PLR_NOCANCEL);
}
else
{
send_to_char("You are now immune to cancellation.\n\r", ch);
SET_BIT (ch->act, PLR_NOCANCEL);
}
}
}
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("You can't see anything but stars!\n\r", ch);
return;
}
if (ch->position == POS_SLEEPING)
{
send_to_char("You can't see anything, you're sleeping!\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("It is pitch black ... \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") || !str_cmp(arg1, "vnum"))
{
BUFFER *output;
ROOM_INDEX_DATA *room;
if (!str_cmp(arg1, "vnum"))
room = get_room_index(atoi(arg2));
else
room = ch->in_room;
if (!IS_NPC(ch) && IS_SET(ch->plyr, PLAYER_NEWLOOK)) {
#define ROOM_CHECK(Direction, Letter) \
(room->exit[Direction] != NULL \
&& room->exit[Direction]->u1.to_room \
&& can_see_room(ch, room->exit[Direction]->u1.to_room) \
? (IS_SET(room->exit[Direction]->exit_info, EX_CLOSED) ? "{y#" : "{Y"Letter) \
: ".")
sprintf(buf, "{D..%s{D.%s {C%s{x",
ROOM_CHECK(DIR_NORTH, "N"), ROOM_CHECK(DIR_UP, "U"),
room->name);
if (IS_IMMORTAL(ch)) {
char room_vnum[MAX_STRING_LENGTH];
sprintf(room_vnum, " {B[{wRoom {G%d{w in{G %s{B]",
room->vnum, room->area->name);
strcat(buf, room_vnum);
}
send_to_char(buf, ch);
sprintf(buf, "\r\n{D%s{D.{RX{D.%s {B=====================================================================\r\n",
ROOM_CHECK(DIR_WEST, "W"), ROOM_CHECK(DIR_EAST, "E"));
send_to_char(buf, ch);
sprintf(buf, "{D%s{D.%s{D.. {w",
ROOM_CHECK(DIR_DOWN, "D"), ROOM_CHECK(DIR_SOUTH, "S"));
send_to_char(buf, ch);
if (!IS_NPC (ch) && IS_SET (ch->act, PLR_AUTOEXIT)) {
if (str_cmp(arg1, "vnum")) //Just make sure it isn't vnum
do_exits(ch, "auto");
else {
sprintf(buf, "vnum %s", arg2);
do_exits(ch, buf);
}
}
else
send_to_char("\r\n", ch);
send_to_char("{x", ch);
} else {
/* 'look' or 'look auto' */
send_to_char("{<", ch);
//send_to_char(ch->in_room->name, ch);
send_to_char(room->name, ch);
send_to_char("{x", ch);
if ((IS_IMMORTAL (ch) && (IS_NPC (ch)
|| IS_SET (ch->act, PLR_HOLYLIGHT)))
|| IS_BUILDER (ch, room->area))
{
sprintf(buf, " [Room %d]", 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)) || (!str_cmp(arg1, "vnum")))
{
send_to_char(" ", ch);
send_to_char(room->description, ch);
send_to_char("{x", ch);
if (room->vnum == chain)
{
send_to_char(
"A huge black iron chain as thick as a tree trunk is drifting above the ground\n\r",
ch);
send_to_char("here.\n\r", ch);
}
if (IS_SET(room->affected_by, ROOM_AFF_FAERIE))
send_to_char("This room contains a purple haze.\n\r", ch);
}
if (IS_SET(room->affected_by, ROOM_AFF_FIRES))
send_to_char(
"\n\rThe {!f{1i{!r{1e{!s{x of {r-{RT{Dor{rM{Den{Rt{r-{x burn brightly in the room.\n\r",
ch);
if (IS_SET(room->affected_by, ROOM_AFF_OVERGROWN))
send_to_char(
"\n\rA magical {GF{go{Gre{gs{Gt{x has sprouted in this room.\n\r",
ch);
if (!IS_NPC (ch) && !IS_SET(ch->plyr, PLAYER_NEWLOOK) && IS_SET (ch->act, PLR_AUTOEXIT))
{
send_to_char("\n\r", ch);
if (!str_cmp(arg1, "vnum"))
sprintf(buf, "vnum %s", arg2);
else
strcpy(buf, "auto");
do_exits(ch, buf);
}
output = show_list_to_char(room->contents, ch, FALSE, FALSE);
send_to_char(output->string, ch);
free_buf(output);
show_char_to_char(room->people, ch);
return;
}
if (!str_cmp(arg1, "auto1"))
{
send_to_char("{<", ch);
send_to_char(ch->in_room->name, ch);
send_to_char("{x\n\r", ch);
return;
}
if (!str_cmp(arg1, "i") || !str_cmp(arg1, "in") || !str_cmp(arg1, "on"))
{
BUFFER *final;
/* 'look in' */
if (arg2[0] == '\0')
{
send_to_char("Look in what?\n\r", ch);
return;
}
if ((obj = get_obj_here(ch, arg2)) == NULL)
{
send_to_char("You do not see that here.\n\r", ch);
return;
}
switch (obj->item_type)
{
default:
send_to_char("That is not a container.\n\r", ch);
break;
case ITEM_DRINK_CON:
if (obj->value[1] <= 0)
{
send_to_char("It is empty.\n\r", ch);
break;
}
sprintf(buf, "It's %sfilled with a %s liquid.\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_PIT:
case ITEM_CORPSE_NPC:
case ITEM_CORPSE_PC:
if (IS_SET (obj->value[1], CONT_CLOSED))
{
send_to_char("It is closed.\n\r", ch);
break;
}
act("$p holds:", ch, obj, NULL, TO_CHAR);
final = show_list_to_char(obj->contains, ch, TRUE, TRUE);
send_to_char(final->string, ch);
free_buf(final);
break;
}
return;
}
if ((victim = get_char_room(ch, 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, "You only see one %s here.\n\r", arg3);
else
sprintf(buf, "You only see %d of those here.\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("You do not see that here.\n\r", ch);
return;
}
/* 'look direction' */
if ((ch->alignment < 0) && (pexit = ch->in_room->exit[door + 6]) != NULL)
door += 6;
if ((pexit = ch->in_room->exit[door]) == NULL)
{
send_to_char("Nothing special there.\n\r", ch);
return;
}
if (pexit->description != NULL && pexit->description[0] != '\0')
send_to_char(pexit->description, ch);
else
send_to_char("Nothing special there.\n\r", ch);
if (pexit->keyword != NULL && pexit->keyword[0] != '\0'
&& pexit->keyword[0] != ' ')
{
if (IS_SET (pexit->exit_info, EX_CLOSED))
{
act("The $d is closed.", ch, NULL, pexit->keyword, TO_CHAR);
}
else if (IS_SET (pexit->exit_info, EX_ISDOOR))
{
act("The $d is open.", ch, NULL, pexit->keyword, TO_CHAR);
}
}
return;
}
/* RT added back for the hell of it */
void do_read(CHAR_DATA * ch, char *argument)
{
do_look(ch, 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("Examine what?\n\r", ch);
return;
}
do_look(ch, arg);
if ((obj = get_obj_here(ch, arg)) != NULL)
{
switch (obj->item_type)
{
default:
break;
case ITEM_JUKEBOX:
do_play(ch, "list");
break;
case ITEM_MONEY:
if (obj->value[0] == 0)
{
if (obj->value[1] == 0)
sprintf(buf, "Odd...there's no coins in the pile.\n\r");
else if (obj->value[1] == 1)
sprintf(buf, "Wow. One gold coin.\n\r");
else
sprintf(buf, "There are %d gold coins in the pile.\n\r",
obj->value[1]);
}
else if (obj->value[1] == 0)
{
if (obj->value[0] == 1)
sprintf(buf, "Wow. One silver coin.\n\r");
else
sprintf(buf, "There are %d silver coins in the pile.\n\r",
obj->value[0]);
}
else
sprintf(
buf,
"There are %d gold and %d silver coins in the pile.\n\r",
obj->value[1], obj->value[0]);
send_to_char(buf, ch);
break;
case ITEM_DRINK_CON:
case ITEM_CONTAINER:
case ITEM_PIT:
case ITEM_CORPSE_NPC:
case ITEM_CORPSE_PC:
sprintf(buf, "in %s", argument);
do_look(ch, 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];
char arg1[MSL];
char arg2[MSL];
EXIT_DATA *pexit;
bool found;
bool round;
bool fAuto;
int door;
int outlet;
ROOM_INDEX_DATA *room;
argument = one_argument(argument, arg1);
argument = one_argument(argument, arg2);
fAuto = ((!str_cmp(arg1, "auto")) || (!str_cmp(arg1, "vnum")));
if (!str_cmp(arg1, "vnum")) {
room = get_room_index(atoi(arg2));
}
else {
room = ch->in_room;
}
if (!check_blind(ch))
return;
if (fAuto)
sprintf(buf, "[Exits:");
else if (IS_IMMORTAL (ch))
sprintf(buf, "Obvious exits from room %d:\n\r", room->vnum);
else
sprintf(buf, "Obvious exits:\n\r");
found = FALSE;
for (door = 0; door < 6; door++)
{
round = FALSE;
outlet = door;
if ((ch->alignment < 0) && (pexit = room->exit[door + 6])
!= NULL)
outlet += 6;
if ((pexit = room->exit[outlet]) != NULL && pexit->u1.to_room
!= NULL && can_see_room(ch, pexit->u1.to_room))
{
found = TRUE;
round = TRUE;
if (fAuto)
{
if (!IS_SET(pexit->exit_info,EX_HIDDEN))
{
strcat(buf, " ");
if (IS_SET (pexit->exit_info, EX_CLOSED )
&& !IS_SET(pexit->exit_info,EX_HIDDEN))
strcat(buf, "<");
strcat(buf, dir_name[outlet]);
if (IS_SET (pexit->exit_info, EX_CLOSED)
&& !IS_SET(pexit->exit_info,EX_HIDDEN))
strcat(buf, ">");
}
}
else
{
sprintf(buf + strlen(buf), "%-5s - %s", capitalize(
dir_name[outlet]),
room_is_dark(pexit->u1.to_room) ? "Too dark to tell"
: pexit->u1.to_room->name);
if (IS_IMMORTAL (ch))
sprintf(buf + strlen(buf), " (room %d)\n\r",
pexit->u1.to_room->vnum);
else
sprintf(buf + strlen(buf), "\n\r");
}
}
if (!round)
{
OBJ_DATA *portal;
ROOM_INDEX_DATA *to_room;
portal = get_obj_exit(dir_name[door], room->contents);
if (portal != NULL)
{
found = TRUE;
round = TRUE;
if (fAuto)
{
strcat(buf, " ");
strcat(buf, dir_name[door]);
}
else
{
to_room = get_room_index(portal->value[0]);
sprintf(buf + strlen(buf), "%-5s - %s", capitalize(
dir_name[door]),
room_is_dark(to_room) ? "Too dark to tell"
: to_room->name);
if (IS_IMMORTAL (ch))
sprintf(buf + strlen(buf), " (room %d)\n\r",
to_room->vnum);
else
sprintf(buf + strlen(buf), "\n\r");
}
}
}
}
if (!found)
strcat(buf, fAuto ? " none" : "None.\n\r");
if (fAuto)
strcat(buf, "]\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, "You have %ld platinum, %ld gold and %ld silver.\n\r",
ch->platinum, ch->gold, ch->silver);
send_to_char(buf, ch);
return;
}
send_to_char("{y___________________________________________\n\r", ch);
sprintf(buf, "{y| {WPlatinum{8: {W%-12ld {y|\n\r",
ch->platinum);
send_to_char(buf, ch);
sprintf(buf, "{y| {WGold{8: {Y%-12ld {y|\n\r",
ch->gold);
send_to_char(buf, ch);
sprintf(buf, "{y| {WSilver{8: {w%-12ld {y|\n\r",
ch->silver);
send_to_char(buf, ch);
sprintf(buf, "{y| {WExp{8: {x%8ld (%8ld Exp to level) {y|\n\r", ch->exp,
(ch->level + 1) * exp_per_level(ch, ch->pcdata->points) - ch->exp);
send_to_char(buf, ch);
send_to_char("{y___________________________________________\n\r", ch);
sprintf(buf, "{y| {WQuest Points{8: {X%-12d {y|\n\r",
ch->questpoints);
send_to_char(buf, ch);
/*sprintf (buf, "{y| {WBank Balance{8: {W%-12d {y|\n\r",
ch->balance[bank]);
send_to_char (buf, ch);*/
send_to_char("{y___________________________________________{x\n\r", ch);
return;
}
/*
* do_score modifications by Vengeance and Artema
*/
void do_score(CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
int i;
if (IS_NPC (ch))
{
do_mstat(ch, "self");
return;
}
sprintf(buf, "{xYou are {G%s{x%s{x\n\r", ch->name, ch->pcdata->title);
send_to_char(buf, ch);
if (IS_IMMORTAL(ch)) {
sprintf(buf, "{xLevel {B%d{x, {B%d{x years old.\n\r", ch->level, get_age(
ch));
}
else {
sprintf(buf, "{xLevel {B%d{x, {B%d{x years old.\n\r", ch->level + tier_level_bonus(ch), get_age(ch));
}
send_to_char(buf, ch);
if (get_trust(ch) != ch->level)
{
sprintf(buf, "{xYou are trusted at level {B%d{x.\n\r", get_trust(ch));
send_to_char(buf, ch);
}
sprintf(buf,
"{xRace: {M%s{x Sex: {M%s{x Class: {M%s{x Size: {M%s{x\n\r",
race_table[ch->race].name, ch->sex == 0 ? "sexless"
: ch->sex == 1 ? "male" : "female",
class_table[ch->class].name, size_table[ch->size].name);
send_to_char(buf, ch);
sprintf(
buf,
"{xYou have {G%d{x/{B%d{x hit, {G%d{x/{B%d{x mana, {G%d{x/{B%d{x movement.\n\r",
ch->hit, ch->max_hit, ch->mana, ch->max_mana, ch->move,
ch->max_move);
send_to_char(buf, ch);
sprintf(
buf,
"{xYou have {M%d{x practice%s and {Y%d{x train%s\n\r",
ch->practice, ch->practice == 1 ? "" : "s", ch->train, ch->train
== 1 ? "" : "s");
send_to_char(buf, ch);
if (is_clan(ch))
{
CLAN_DATA *clan = get_clan_by_ch(ch);
sprintf(buf, "{xYou are in the [{G%s{x] clan, which is a %s clan.\n\r",
clan->c_name,
clan->pkill ? "{RPkill{x" : "{WNon-Pkill{x");
send_to_char(buf, ch);
/* if (is_pkill(ch))
{
sprintf( buf,
"{xPk Rank: {R%d {xArena Rank: {R%d{x\n\r",
ch->pcdata->prank, ch->pcdata->arank);
send_to_char(buf,ch);
} */
}
if (!IS_NPC (ch))
{
if (ch->challenger != NULL)
{
sprintf(buf,
"[{garena{x] You have been {rchallenged{x by {b%s{x.\n\r",
ch->challenger->name);
send_to_char(buf, ch);
}
if (ch->challenged != NULL)
{
sprintf(buf, "[{garena{x] You have {rchallenged{x {b%s{x.\n\r",
ch->challenged->name);
send_to_char(buf, ch);
}
if (ch->gladiator != NULL)
{
sprintf(buf,
"[{garena bet{x] You have a {y%d{x gold bet on {b%s{x\n\r",
ch->pcdata->plr_wager, ch->gladiator->name);
send_to_char(buf, ch);
}
}
sprintf(
buf,
"{xYou are carrying {G%d{x/{B%d{x items with weight {G%ld{x/{B%d{x pounds.\n\r",
ch->carry_number, can_carry_n(ch), get_carry_weight (ch) / 10,
can_carry_w(ch) / 10);
send_to_char(buf, ch);
sprintf(
buf,
"{xStr: {R%d{x({r%d{x) Int: {R%d{x({r%d{x) Wis: {R%d{x({r%d{x) Dex: {R%d{x({r%d{x) Con: {R%d{x({r%d{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),
ch->perm_stat[STAT_WIS], get_curr_stat(ch, STAT_WIS),
ch->perm_stat[STAT_DEX], get_curr_stat(ch, STAT_DEX),
ch->perm_stat[STAT_CON], get_curr_stat(ch, STAT_CON));
send_to_char(buf, ch);
sprintf(
buf,
"{xYou have {W%ld platinum{x, {Y%ld gold{x and {w%ld silver{x coins.\n\r",
ch->platinum, ch->gold, ch->silver);
send_to_char(buf, ch);
if (!IS_NPC (ch) && ch->level == LEVEL_HERO)
{
sprintf(buf, "{xYou have scored {C%ld exp{x.\n\r", ch->exp);
send_to_char(buf, ch);
}
else if (!IS_NPC (ch) && ch->level < LEVEL_HERO)
{
sprintf(
buf,
"{xYou have scored {C%ld exp{x. You need {C%ld exp{x to level.\n\r",
ch->exp, ((ch->level + 1) * exp_per_level(ch,
ch->pcdata->points) - ch->exp));
send_to_char(buf, ch);
}
if (ch->wimpy)
{
sprintf(buf, "Wimpy set to %d hit points.\n\r", ch->wimpy);
send_to_char(buf, ch);
}
if (!IS_NPC (ch) && ch->pcdata->condition[COND_DRUNK] > 10)
{
sprintf(buf, "{yYou are drunk.{x\n\r");
send_to_char(buf, ch);
}
if (!IS_NPC (ch) && ch->pcdata->condition[COND_THIRST] == 0)
{
sprintf(buf, "{yYou are thirsty.{x\n\r");
send_to_char(buf, ch);
}
if (!IS_NPC (ch) && ch->pcdata->condition[COND_HUNGER] == 0)
{
sprintf(buf, "{yYou are hungry.{x\n\r");
send_to_char(buf, ch);
}
switch (ch->position)
{
case POS_DEAD:
sprintf(buf, "{RYou are DEAD!!{x\n\r");
send_to_char(buf, ch);
break;
case POS_MORTAL:
sprintf(buf, "{RYou are mortally wounded.{x\n\r");
send_to_char(buf, ch);
break;
case POS_INCAP:
sprintf(buf, "{RYou are incapacitated.{x\n\r");
send_to_char(buf, ch);
break;
case POS_STUNNED:
sprintf(buf, "{RYou are stunned.{x\n\r");
send_to_char(buf, ch);
break;
case POS_SLEEPING:
sprintf(buf, "{BYou are sleeping.{x\n\r");
send_to_char(buf, ch);
break;
case POS_RESTING:
sprintf(buf, "{BYou are resting.{x\n\r");
send_to_char(buf, ch);
break;
case POS_STANDING:
sprintf(buf, "{BYou are standing.{x\n\r");
send_to_char(buf, ch);
break;
case POS_FIGHTING:
sprintf(buf, "{RYou are fighting.{x\n\r");
send_to_char(buf, ch);
break;
}
/* print AC values */
if (ch->level >= 25)
{
sprintf(
buf,
"{xArmor: pierce: {G%d{x bash: {G%d{x slash: {G%d{x exotic: {G%d{x\n\r",
GET_AC (ch, AC_PIERCE), GET_AC (ch, AC_BASH),
GET_AC (ch, AC_SLASH), GET_AC (ch, AC_EXOTIC));
send_to_char(buf, ch);
}
for (i = 0; i < 4; i++)
{
char *temp;
switch (i)
{
case (AC_PIERCE):
temp = "piercing";
break;
case (AC_BASH):
temp = "bashing";
break;
case (AC_SLASH):
temp = "slashing";
break;
case (AC_EXOTIC):
temp = "exotic";
break;
default:
temp = "error";
break;
}
sprintf(buf, "{xYou are ");
send_to_char(buf, ch);
if (GET_AC (ch, i) >= 101)
sprintf(buf, "{Rhopelessly vulnerable{x to %s.\n\r", temp);
else if (GET_AC (ch, i) >= 80)
sprintf(buf, "{Rdefenseless{x against %s.\n\r", temp);
else if (GET_AC (ch, i) >= 60)
sprintf(buf, "{Rbarely protected{x from %s.\n\r", temp);
else if (GET_AC (ch, i) >= 40)
sprintf(buf, "{yslightly armored{x against %s.\n\r", temp);
else if (GET_AC (ch, i) >= 20)
sprintf(buf, "{ysomewhat armored{x against %s.\n\r", temp);
else if (GET_AC (ch, i) >= 0)
sprintf(buf, "{yarmored{x against %s.\n\r", temp);
else if (GET_AC (ch, i) >= -20)
sprintf(buf, "{ywell-armored{x against %s.\n\r", temp);
else if (GET_AC (ch, i) >= -40)
sprintf(buf, "{yvery well-armored{x against %s.\n\r", temp);
else if (GET_AC (ch, i) >= -60)
sprintf(buf, "{Bheavily armored{x against %s.\n\r", temp);
else if (GET_AC (ch, i) >= -100)
sprintf(buf, "{Bsuperbly armored{x against %s.\n\r", temp);
else if (GET_AC (ch, i) >= -200)
sprintf(buf, "{Ynear invulnerable{x to %s.\n\r", temp);
else if (GET_AC (ch, i) >= -300)
sprintf(buf, "{Yalmost invulnerable{x to %s.\n\r", temp);
else
sprintf(buf, "{Wdivinely armored{x against %s.\n\r", temp);
send_to_char(buf, ch);
}
/* RT wizinvis and holy light */
if (IS_IMMORTAL (ch))
{
sprintf(buf, "Holy Light: ");
send_to_char(buf, ch);
if (IS_SET (ch->act, PLR_HOLYLIGHT))
sprintf(buf, "{Won{x");
else
sprintf(buf, "{Roff{x");
send_to_char(buf, ch);
if (ch->invis_level)
{
sprintf(buf, " Invisible: level {W%d{x", ch->invis_level);
send_to_char(buf, ch);
}
if (ch->incog_level)
{
sprintf(buf, " Incognito: level {W%d{x", 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);
}
sprintf(buf, "\n\r");
send_to_char(buf, ch);
}
if (ch->level >= 15)
{
sprintf(buf, "{xHitroll: {G%d{x Damroll: {G%d{x Saves: {G%d{x.\n\r",
GET_HITROLL (ch), GET_DAMROLL (ch), ch->saving_throw);
send_to_char(buf, ch);
}
if (ch->level >= 10)
{
sprintf(buf, "{xAlignment: {B%d{x. ", ch->alignment);
send_to_char(buf, ch);
}
sprintf(buf, "{xYou are ");
send_to_char(buf, ch);
if (ch->alignment > 900)
sprintf(buf, "{&O{7di{&n{x's chosen{x.\n\r");
else if (ch->alignment > 700)
sprintf(buf, "{&O{7di{&n{x's servant{x.\n\r");
else if (ch->alignment > 500)
sprintf(buf, "{wsaintly{x.\n\r");
else if (ch->alignment > 350)
sprintf(buf, "{wgood{x.\n\r");
else if (ch->alignment > 225)
sprintf(buf, "{ykind{x.\n\r");
else if (ch->alignment > 100)
sprintf(buf, "{ynice{x.\n\r");
else if (ch->alignment > -100)
sprintf(buf, "{yneutral{x.\n\r");
else if (ch->alignment > -225)
sprintf(buf, "{yunkind{x.\n\r");
else if (ch->alignment > -350)
sprintf(buf, "{ymean{x.\n\r");
else if (ch->alignment > -500)
sprintf(buf, "{revil{x.\n\r");
else if (ch->alignment > -700)
sprintf(buf, "{rdemonic{x.\n\r");
else if (ch->alignment > -900)
sprintf(buf, "{!H{1e{!l{x's servant{x.\n\r");
else
sprintf(buf, "{!H{1e{!l{x's chosen{x.\n\r");
send_to_char(buf, ch);
/* if (ch->invited)
{
sprintf( buf, "{RYou have been invited to join clan {x[{%s%s{x]\n\r",
clan_table[ch->invited].pkill ? "B" : "M",
clan_table[ch->invited].who_name);
send_to_char(buf,ch);
} */
if (IS_SET (ch->comm, COMM_SHOW_AFFECTS))
do_affects(ch, "");
}
void do_abilities(CHAR_DATA *ch, char *argument)
{
int count = 0;
if (IS_NPC(ch))
return;
send_to_char("{D ._______________________________________________.{x\n\r",
ch);
send_to_char(
"{D / {y[{cABILITIES{y] {D\\{x\n\r",
ch);
send_to_char(
"{D| {D|{x\n\r",
ch);
if (ch->class == CLASS_SHADE || ch->class == CLASS_LICH || ch->class
== CLASS_FADE || ch->class == CLASS_BANSHEE)
{
count = (count == 1 ? 1 : count + 1);
send_to_char("{D| {mNightstalker{w:", ch);
if (IS_SET( ch->ability_lich, ABILITY_LICH_NIGHTSTALKER ))
send_to_char(" {GON {D|{x\n\r", ch);
else
send_to_char(" {ROFF {D|{x\n\r", ch);
}
/*if ( ch->class == CLASS_CRUSADER )
{
count = ( count == 1 ? 1 : count + 1 );
send_to_char("{D| {mSunder{w:",ch);
if ( IS_SET( ch->ability_crusader, ABILITY_CRUSADER_SUNDER ) )
send_to_char(" {GON {D|{x \n\r",ch);
else
send_to_char(" {ROFF {D|{x\n\r",ch);
} */
if (count == 0)
send_to_char(
"{D| {RTHERE ARE NONE {D|{x\n\r",
ch);
else
send_to_char(
"{D| {D|{x\n\r",
ch);
send_to_char(
"{D|___________________________________________________|{x\n\r", ch);
}
void do_affects(CHAR_DATA * ch, char *argument)
{
AFFECT_DATA *paf, *paf_last = NULL;
char buf[MAX_STRING_LENGTH];
if (ch->affected_by)
{
sprintf(buf, "Affected by %s\n\r", affect_bit_name(ch->affected_by));
send_to_char(buf, ch);
}
if (ch->shielded_by)
{
sprintf(buf, "Shielded by %s\n\r", shield_bit_name(ch->shielded_by));
send_to_char(buf, ch);
}
if (ch->affected != NULL)
{
sprintf(buf, "You are affected by the following spells:\n\r");
send_to_char(buf, ch);
if (ch->class == 25)
{
sprintf(
buf,
"{WF{waith{x Modifies: {BH{bitroll {R%d, {BD{bamroll {R%d, {BS{btrength {R%d, {BD{bexterity {R%d{x\n\r",
(ch->alignment * ch->level) / 2000, (ch->alignment
* ch->level) / 2000, ch->alignment / 300,
ch->alignment / 300);
send_to_char(buf, ch);
}
if (ch->class == CLASS_MONK)
{
sprintf(buf, "{WC{whi{x Modifies: DamRoll %d HitRoll %d.\n\r",
ch->pcdata->power[0] / 10 + ch->pcdata->power[1] / 10,
ch->pcdata->power[0] / 10);
send_to_char(buf, ch);
}
for (paf = ch->affected; paf != NULL; paf = paf->next)
{
if (paf_last != NULL && paf->type == paf_last->type)
sprintf(buf, " ");
else
sprintf(buf, "Spell: {W%-15s{x", skill_table[paf->type].name);
send_to_char(buf, ch);
sprintf(buf, ": modifies {R%s{x by {G%d{x ", affect_loc_name(
paf->location), paf->modifier);
send_to_char(buf, ch);
if (paf->duration == -1)
sprintf(buf, "{Bpermanently{x");
else
sprintf(buf, "for {B%d hours{x", paf->duration);
send_to_char(buf, ch);
sprintf(buf, "\n\r");
send_to_char(buf, ch);
paf_last = paf;
}
}
else
{
sprintf(buf, "You are not affected by any spells.\n\r");
send_to_char(buf, ch);
if (ch->class == 25)
{
sprintf(
buf,
"{WF{waith{x Modifies: {BH{bitroll {R%d, {BD{bamroll {R%d, {BS{btrength {R%d, {BD{bexterity {R%d{x\n\r",
ch->alignment / 100, ch->alignment / 100, ch->alignment
/ 300, ch->alignment / 300);
send_to_char(buf, ch);
}
}
return;
}
/*
void do_cooldowns(CHAR_DATA * ch, char *argument)
{
COOLDOWN_DATA *pcd = NULL;
char buf[MAX_STRING_LENGTH];
if (ch->cooldowns != NULL)
{
sprintf(buf, "Cooldowns:\n\r");
send_to_char(buf, ch);
for (pcd = ch->cooldowns; pcd != NULL; pcd = pcd->next)
{
sprintf(buf, "{W%-15s{x: {B%d rounds{x\n\r",
skill_table[pcd->type].name, pcd->duration);
send_to_char(buf, ch);
}
}
else
{
sprintf(buf, "Nothing is on cooldown.\n\r");
send_to_char(buf, ch);
}
return;
}
*/
char
* const day_name[] =
{ "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
"Sunday" };
char * const month_name[] =
{ "January", "February", "March", "April", "May", "June", "July", "August",
"September", "October", "November", "December" /* , "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, "It is %d o'clock %s, Day of %s, %d%s the Month of %s.\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,
GAME_COL_NAME" started up at %s\n\rThe system time is %s\n\r",
str_boot_time, (char *) ctime(¤t_time));
send_to_char(buf, ch);
send_to_char("Use the {Ggamestatus{x command to see more details.\r\n", ch);
}
void do_weather(CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
static char * const sky_look[4] =
{ "cloudless", "cloudy", "rainy", "lit by flashes of lightning" };
if (!IS_OUTSIDE (ch))
{
send_to_char("You can't see the weather indoors.\n\r", ch);
return;
}
sprintf(buf, "The sky is %s and %s.\n\r", sky_look[weather_info.sky],
weather_info.change >= 0 ? "a warm southerly breeze blows"
: "a cold northern gust blows");
send_to_char(buf, ch);
return;
}
/* Old help, won't do anything at the moment */
/*void do_help (CHAR_DATA * ch, char *argument)
{
HELP_DATA *pHelp;
char argall[MAX_INPUT_LENGTH], argone[MAX_INPUT_LENGTH];
if (argument[0] == '\0')
argument = "summary";
if(is_racename(argument))
{
do_racehelp(ch,argument);
}
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)
{
if (pHelp->level > get_trust (ch))
continue;
if (is_name (argall, pHelp->keyword))
{
if (pHelp->level >= 0 && str_cmp (argall, "imotd"))
{
send_to_char (pHelp->keyword, ch);
send_to_char ("\n\r", ch);
}
if (pHelp->text[0] == '.')
page_to_char (pHelp->text + 1, ch);
else
page_to_char (pHelp->text, ch);
if (ch->desc != NULL && ch->desc->connected != CON_PLAYING
&& ch->desc->connected != CON_GEN_GROUPS)
break;
return;
}
}
send_to_char ("No help on that word, use the nohelp command to log it.\n\r", ch);
return;
}*/
void do_classstat(CHAR_DATA *ch, char *argument)
{
/* ClassHelps -- Skyntil */
if (is_classname(argument))
{
do_classhelp(ch, argument);
return;
}
send_to_char("That is not a valid class.\n\r", ch);
return;
}
void do_oldhelp(CHAR_DATA *ch, char *argument)
{
HELP_DATA *pHelp;
bool found = FALSE;
char argall[MAX_INPUT_LENGTH], argone[MAX_INPUT_LENGTH];
int level;
if (argument[0] == '\0')
argument = "summary";
/* 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)
send_to_char(
"\n\r============================================================\n\r\n\r",
ch);
if (pHelp->level >= 0 && str_cmp(argall, "imotd"))
{
send_to_char(pHelp->keyword, ch);
send_to_char("\n\r", ch);
}
/*
* Strip leading '.' to allow initial blanks.
*/
if (pHelp->text[0] == '.')
send_to_char(pHelp->text + 1, ch);
else
send_to_char(pHelp->text, ch);
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);
return;
}
/* 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("You must provide a name.\n\r", ch);
return;
}
output = new_buf();
for (d = descriptor_list; d != NULL; d = d->next)
{
CHAR_DATA *wch;
char class[MAX_STRING_LENGTH];
char sex[MAX_STRING_LENGTH];
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 (wch->pcdata->pretit == '\0')
wch->pcdata->pretit = "{x";
if (IS_NPC (wch))
continue;
if (!str_prefix(arg, wch->name))
{
found = TRUE;
if (wch->pcdata->tier == 1)
{
sprintf(class, "{R%c{r%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
else if (wch->pcdata->tier == 2)
{
sprintf(class, "{B%c{b%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
else if (wch->pcdata->tier >= 3)
{
sprintf(class, "{G%c{g%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
if (wch->sex == 1)
{
sprintf(sex, "{#M{x");
}
else if (wch->sex == 2)
{
sprintf(sex, "{#F{x");
}
else if (wch->sex == 0)
{
sprintf(sex, "{#N{x");
}
CLAN_DATA *clan = get_clan_by_ch( wch );
ROSTER_DATA *roster;
GET_ROSTER( wch, roster );
/* a little formatting */
sprintf(
buf,
"[%-3d %-12s %s %s{x] %s %s %s%s%s%s%s%s%s%s%s%s%s{x",
wch->level < 102 ? wch->level + tier_level_bonus(wch) : wch->level + 100,
wch->race < MAX_PC_RACE ? pc_race_table[wch->race].who_name
: " ",
class,
sex,
end_string( clan->c_name, MAX_CLAN_WHO_LENGTH ),
(!roster || is_indep(wch)) ? "---" : clan->r_who[get_r_rank_index( roster )],
((wch->ghost_level >= LEVEL_HERO) && (ch->level
>= wch->level)) ? "(Ghost) " : "",
wch->incog_level >= LEVEL_HERO ? "({^Incog{x) " : "",
wch->invis_level >= LEVEL_HERO ? "({&Wizi{x) " : "",
IS_SET (wch->plyr, PLAYER_GHOST) ? "({7G{wH{7O{wS{7T{x) "
: "",
IS_SET (wch->comm, COMM_QUIET) ? "({@Quiet{x) " : "",
IS_SET (wch->comm, COMM_AFK) ? "{3[{#AFK{3]{x " : "",
IS_SET (wch->act, PLR_TWIT) ? "({RTWIT{x) " : "",
(roster && IS_SET (roster->flags, ROST_NEWBIE)) ? "{Y{{{Rn00b{Y}{x " : "",
wch->pcdata->pretit, wch->name, IS_NPC (wch) ? ""
: wch->pcdata->title);
add_buf(output, buf);
PKILL_DATA *pkdata;
if (roster && (pkdata = roster->pkilldata))
{
float ratio;
sprintf(buf, "\n\r{wKill Points: {Y%ld\r\n",
pkdata->kPoints);
add_buf(output, buf);
ratio = ((float)pkdata->kills)/UMAX((float)pkdata->deaths, 1.0f);
sprintf(buf, "{wKills/Deaths: {G%d{w/{R%d {w(Ratio: {%c%.2f{w)\r\n",
pkdata->kills, pkdata->deaths, (ratio >= 1 ? 'G' : 'r'), ratio);
add_buf(output, buf);
ratio = ((float)pkdata->wins)/UMAX((float)pkdata->losses, 1.0f);
sprintf(buf, "{wWins/Losses: {G%d{w/{R%d {w(Ratio: {%c%.2f{w){x\r\n",
pkdata->wins, pkdata->losses, (ratio >= 1 ? 'G' : 'r'), ratio);
add_buf(output, buf);
}
sprintf(buf, "{C%s{x", wch->description);
add_buf(output, buf);
}
}
if (!found)
{
send_to_char("No one of that name is playing.\n\r", ch);
return;
}
page_to_char(buf_string(output), ch);
free_buf(output);
}
/*
* New 'who' command originally by Alander of Rivers of Mud.
*/
void do_who(CHAR_DATA * ch, char *argument)
{
FILE *fp;
char buf[MAX_STRING_LENGTH];
char buf2[MAX_STRING_LENGTH];
char questdat[MAX_STRING_LENGTH];
char whodesc[MAX_STRING_LENGTH];
char race[MAX_STRING_LENGTH];
char sex[MAX_STRING_LENGTH];
char level[MAX_STRING_LENGTH];
char clan[MAX_STRING_LENGTH];
char rank[MAX_STRING_LENGTH];
char *mplayer_name = "";
char *immplayer_name = "";
BUFFER *output;
BUFFER *outputimm;
BUFFER *ftier;
BUFFER *stier;
BUFFER *ttier;
DESCRIPTOR_DATA *d;
int iClass;
int iRace;
int iLevelLower;
int iLevelUpper;
int nNumber;
int nMatch;
bool rgfClass[MAX_CLASS];
bool rgfRace[MAX_PC_RACE];
bool fClassRestrict = FALSE;
bool fClanRestrict = FALSE;
bool fClan = FALSE;
bool fRaceRestrict = FALSE;
bool fImmortalOnly = FALSE;
bool fPkillOnly = FALSE;
bool fArenaOnly = FALSE;
bool fMCCPOnly = FALSE;
int count;
int countimm;
int hour;
int most_ever = 0;
int most_hours = 0;
int immost_hours = 0;
CLAN_DATA *iClan = NULL, *wchClan;
ROSTER_DATA *wchRoster;
/*
* 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;
/*
* Parse arguments.
*/
count = 0;
countimm = 0;
nNumber = 0;
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"))
{
fImmortalOnly = TRUE;
}
else if (!str_prefix(arg, "pkill"))
{
fPkillOnly = TRUE;
}
else if (!str_prefix(arg, "arena"))
{
fArenaOnly = TRUE;
}
else if (!str_prefix(arg, "mccp"))
{
fMCCPOnly = 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;
}
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;
}
}
}
}
/*
* Now show matching chars.
*/
nMatch = 0;
buf[0] = '\0';
output = new_buf();
outputimm = new_buf();
ftier = new_buf();
stier = new_buf();
ttier = new_buf();
add_buf(outputimm, "\n\r{xVisible {GImmortals{x:\n\r");
add_buf(ftier, "\n\r{xVisible {GMortals{x:\n\r");
for (d = descriptor_list; d != NULL; d = d->next)
{
CHAR_DATA *wch;
char class[MAX_STRING_LENGTH];
/*
* Check for match against restrictions.
* Don't use trust as that exposes trusted mortals.
*/
if (d->connected != CON_PLAYING || !can_see(ch, d->character))
continue;
wch = (d->original != NULL) ? d->original : d->character;
if (!can_see(ch, wch) && IS_SHIELDED (wch, SHD_INVISIBLE))
continue;
wchClan = get_clan_by_ch( wch );
GET_ROSTER( wch, wchRoster );
/* Assassins don't show up */
// if(is_affected(wch,gsn_conceal) && ch != wch)
// continue;
if (wch->pcdata->pretit == '\0')
wch->pcdata->pretit = "{x";
if (fPkillOnly)
continue;
if (fArenaOnly)
continue;
if (!can_see(ch, wch) && wch->level >= SQUIRE && ch->level < wch->level)
continue;
if (!IS_IMMORTAL (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 && iClan != wchClan) || (fMCCPOnly
&& !d->out_compress))
continue;
countimm++;
nMatch++;
strcpy( clan, end_string( wchClan->c_name, MAX_CLAN_WHO_LENGTH ) );
sprintf( rank, " %s", is_indep(wch) ? "---" : wchClan->r_who[get_r_rank_index( wchRoster )] );
/*
* Figure out what to print for class.
*/
if (wch->pcdata->who_descr[0] == '\0')
{
sprintf(level, "%-3d ", wch->level);
if (wch->pcdata->tier == 1)
{
sprintf(class, "{R%c{r%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
else if (wch->pcdata->tier == 2)
{
sprintf(class, "{B%c{b%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
else if (wch->pcdata->tier >= 3)
{
sprintf(class, "{G%c{g%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
if (wch->sex == 1)
{
sprintf(sex, " {#M{x");
}
else if (wch->sex == 2)
{
sprintf(sex, " {#F{x");
}
else if (wch->sex == 0)
{
sprintf(sex, " {#N{x");
}
if (wch->race < MAX_PC_RACE)
{
sprintf(race, "%-7s", pc_race_table[wch->race].who_name);
}
else
{
sprintf(race, " ");
}
sprintf(whodesc, "%s%s%s%s %s%s", level, race, class, sex, clan, rank);
}
else
sprintf (whodesc, "%s %s%s", end_string(wch->pcdata->who_descr, 16), clan, rank);
/*
* Format it up.
*/
if (!wch->on_quest)
{
questdat[0] = '\0';
}
else
{
sprintf(questdat, "[{GQ{x] ");
}
sprintf(buf, "[%s] %s%s%s%s%s%s%s%s%s%s%s%s%s{x\n\r", whodesc,
questdat, ((wch->ghost_level >= LEVEL_HERO) && (ch->level
>= wch->level)) ? "(Ghost) " : "", wch->incog_level
>= LEVEL_HERO ? "(Incog) " : "", wch->invis_level
>= LEVEL_HERO ? "(Wizi) " : "",
IS_SET (wch->plyr, PLAYER_GHOST) ? "({7G{wH{7O{wS{7T{x) " : "",
IS_SET (wch->comm, COMM_QUIET) ? "({@Quiet{x)" : "",
IS_SET (wch->comm, COMM_AFK) ? "[{yAFK{x] " : "",
IS_SET (wch->act, PLR_TWIT) ? "({RTWIT{x) " : "",
(wchRoster && IS_SET (wchRoster->flags, ROST_NEWBIE)) ? "{Y{{{Rn00b{Y}{x " : "",
is_enemy(ch, wch) ? "{Y-{RENEMY{Y-{x" : "",
wch->pcdata->pretit, wch->name, IS_NPC (wch) ? ""
: wch->pcdata->title);
if ((wch->played / 3600) > immost_hours)
{
immplayer_name = wch->name;
immost_hours = (wch->played / 3600);
}
add_buf(outputimm, buf);
}
add_buf(outputimm, "\n\r");
buf[0] = '\0';
for (d = descriptor_list; d != NULL; d = d->next)
{
CHAR_DATA *wch;
char class[MAX_STRING_LENGTH];
/*
* Check for match against restrictions.
* Don't use trust as that exposes trusted mortals.
*/
if (d->connected != CON_PLAYING || !can_see(ch, d->character))
continue;
wch = (d->original != NULL) ? d->original : d->character;
wchClan = get_clan_by_ch( wch );
GET_ROSTER( wch, wchRoster );
if (!can_see(ch, wch) && IS_SHIELDED (wch, SHD_INVISIBLE))
continue;
// if(is_affected(wch,gsn_conceal) && ch != wch && !IS_IMMORTAL(ch))
// continue;
if (!can_see(ch, wch) && wch->level >= SQUIRE && ch->level < wch->level)
continue;
if (wch->pcdata->pretit == '\0')
wch->pcdata->pretit = "{x";
if (IS_IMMORTAL (wch))
continue;
if (fPkillOnly)
{ //NEWBIE INSERT
if (!is_pkill(ch) && !IS_SET (wch->act, PLR_TWIT))
continue;
if (IS_SET (wch->act, PLR_TWIT))
break;
if (!is_pkill(wch))
continue;
if (ch->level > wch->level + 10)
continue;
if (ch->level < wch->level - 10)
continue;
if (((ch->pcdata->tier == 3) && (wch->pcdata->tier == 1))
|| ((ch->pcdata->tier == 1) && (wch->pcdata->tier == 3)))
continue;
/*if ( ch->pcdata->prank > (wch->pcdata->prank + 200) )
continue;
if ( ch->pcdata->prank < (wch->pcdata->prank - 200) )
continue;*/
/* if ((ch->pcdata->tier == 2)
&& (wch->pcdata->tier == 1))
continue;
if ((ch->pcdata->tier == 1)
&& (wch->pcdata->tier == 2))
continue; */
/* if (wch->clan == ch->clan && clan_table[ch->clan].name != "LONER")
continue;*/
}
count++;
if ((wch->in_room->vnum == ROOM_VNUM_CORNER) && (!IS_IMMORTAL (ch)))
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 && iClan != wchClan) || (fMCCPOnly
&& !d->out_compress))
continue;
nMatch++;
/*
* Figure out what to print for class.
*/
if (wch->sex == 1)
{
sprintf(sex, " {#M{x");
}
else if (wch->sex == 2)
{
sprintf(sex, " {#F{x");
}
else if (wch->sex == 0)
{
sprintf(sex, " {#N{x");
}
if (wch->level == MAX_LEVEL - 9)
{
if (wch->pcdata->tier >= 3)
{
sprintf(level, "{#LGD{x ");
}
else if (wch->pcdata->tier == 2)
{
sprintf(level, "{!HRO{x ");
}
else
{
sprintf(level, "{@LDR{x ");
}
}
else
{
sprintf(level, "%-3d ", wch->level);
}
strcpy( clan, end_string( wchClan->c_name, MAX_CLAN_WHO_LENGTH ) );
sprintf( rank, " %s", is_indep(wch) ? "---" : wchClan->r_who[get_r_rank_index( wchRoster )] );
if (wch->pcdata->who_descr[0] == '\0')
{
if (wch->pcdata->tier == 1)
{
sprintf(class, "{R%c{r%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
else if (wch->pcdata->tier == 2)
{
sprintf(class, "{B%c{b%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
else
{
sprintf(class, "{G%c{g%c%c{x",
class_table[wch->class].who_name[0],
class_table[wch->class].who_name[1],
class_table[wch->class].who_name[2]);
}
if (wch->race < MAX_PC_RACE)
{
sprintf(race, "%-7s", pc_race_table[wch->race].who_name);
}
else
{
sprintf(race, " ");
}
sprintf(whodesc, "%s%s%s%s %s%s", level, race, class, sex, clan,
rank);
}
else
sprintf(whodesc, "%s%s%s %s%s", level, end_string(wch->pcdata->who_descr, 12), sex,
clan, rank);
/*
* Format it up.
*/
if (!wch->on_quest)
{
questdat[0] = '\0';
}
else
{
sprintf(questdat, "[{GQ{x] ");
}
sprintf(buf, "[%s{x] %s%s%s%s%s%s%s%s%s%s%s%s%s%s{x\n\r", whodesc,
questdat, ((wch->ghost_level >= LEVEL_HERO) && (ch->level
>= wch->level)) ? "(Ghost) " : "", wch->incog_level
>= LEVEL_HERO ? "(Incog) " : "", wch->invis_level
>= LEVEL_HERO ? "(Wizi) " : "",
IS_SET (wch->plyr, PLAYER_GHOST) ? "({7G{wH{7O{wS{7T{x) " : "",
IS_SET (wch->comm, COMM_QUIET) ? "({@Quiet{x)" : "",
IS_SET (wch->comm, COMM_AFK) ? "[{yAFK{x] " : "",
IS_SET (wch->act, PLR_TWIT) ? "({RTWIT{x) " : "",
(wchRoster && IS_SET (wchRoster->flags, ROST_NEWBIE)) ? "{Y{{{Rn00b{Y}{x " : "",
"", is_enemy(ch, wch) ? "(ENEMY)" : "", wch->pcdata->pretit,
wch->name, IS_NPC (wch) ? "" : wch->pcdata->title);
if (wch->pcdata->tier == 1)
add_buf(ftier, buf);
else if (wch->pcdata->tier == 2)
add_buf(stier, buf);
else if (wch->pcdata->tier == 3)
add_buf(ttier, buf);
else
add_buf(output, buf);
if ((wch->played / 3600) > most_hours)
{
mplayer_name = wch->name;
most_hours = (wch->played / 3600);
}
}
count += countimm;
hour = (int) (struct tm *) localtime(¤t_time)->tm_hour;
if (hour < 12)
{
if (is_pm)
{
is_pm = FALSE;
/* Wipe Most-on today count at midnight */
max_on = 0;
fp = fopen(MAX_FILE, "w");
fprintf(fp, "%d", max_on);
fclose(fp);
//expire_notes ();
randomize_entrances(ROOM_VNUM_CLANS);
}
}
else
{
is_pm = TRUE;
}
if ((fp = fopen(MOST_FILE, "r")) != NULL)
{
most_ever = fread_number(fp);
fclose(fp);
}
if ((fp = fopen(MAX_FILE, "r")) != NULL)
{
max_on = fread_number(fp);
fclose(fp);
}
if (count > max_on)
{
max_on = UMAX (count, max_on);
fp = fopen(MAX_FILE, "w");
fprintf(fp, "%d", max_on);
fclose(fp);
}
if (max_on > most_ever)
{
most_ever = UMAX (max_on, most_ever);
fp = fopen(MOST_FILE, "w");
fprintf(fp, "%d", most_ever);
fclose(fp);
}
if (global_quest)
{
sprintf(buf2, "\n\r{GThe global quest flag is on.{x");
add_buf(output, buf2);
}
int i;
bool found = FALSE;
sprintf(buf2, "\r\n{BActive modifiers: ");
add_buf(output, buf2);
for (i = GMOD_FIRST; i < GMOD_MAX; i++) {
float mult = gmod_get_mult(i);
if (mult > 1.0f) {
if (found)
add_buf(output, "{B, ");
sprintf(buf2, "{W%s{B({G%.2f{Wx{B)", gmod_get_name(i), mult);
add_buf(output, buf2);
found = TRUE;
}
}
if (!found)
add_buf(output, "{Wnone");
add_buf(output, "{B.{x");
if (nMatch != count)
{
sprintf(buf2, "\n\r{BMatches found: {W%d{x\n\r", nMatch);
add_buf(output, buf2);
}
else
{
sprintf(
buf2,
"\n\r{BPlayers found: {W%d {BMost on today: {W%d {BMost on ever: {W%d{x\n\r",
count, max_on, most_ever);
add_buf(output, buf2);
if (countimm >= 1)
{
sprintf(buf2,
"{BImmortal - Most Hours: {W%s {B- {W%d {BHours.{x\n\r",
immplayer_name, immost_hours);
add_buf(output, buf2);
}
sprintf(buf2, "{BMortal - Most Hours: {W%s {B- {W%d {BHours.{x\n\r",
mplayer_name, most_hours);
add_buf(output, buf2);
}
add_buf(ftier, buf_string(stier));
add_buf(ftier, buf_string(ttier));
add_buf(ftier, buf_string(output));
add_buf(
ftier,
"{BPlease {WVOTE{x {Bfor us at:\r\n{Y> {Rhttp://www.mudconnect.com/mud-bin/vote_rank.cgi?mud=Asgard {Y<{x\r\n");
if (countimm >= 1)
{
add_buf(outputimm, buf_string(ftier));
page_to_char(buf_string(outputimm), ch);
}
else
page_to_char(buf_string(ftier), ch);
free_buf(output);
free_buf(outputimm);
free_buf(ftier);
free_buf(stier);
free_buf(ttier);
return;
}
void do_count(CHAR_DATA * ch, char *argument)
{
FILE *fp;
int count;
int hour;
DESCRIPTOR_DATA *d;
char buf[MAX_STRING_LENGTH];
count = 0;
hour = (int) (struct tm *) localtime(¤t_time)->tm_hour;
if (hour < 12)
{
if (is_pm)
{
is_pm = FALSE;
/* Wipe Most-on today count at midnight */
max_on = 0;
fp = fopen(MAX_FILE, "w");
fprintf(fp, "%d", max_on);
fclose(fp);
//expire_notes ();
randomize_entrances(ROOM_VNUM_CLANS);
}
}
else
{
is_pm = TRUE;
}
for (d = descriptor_list; d != NULL; d = d->next)
if (d->connected == CON_PLAYING && can_see(ch, d->character))
count++;
if (count > max_on)
{
max_on = UMAX (count, max_on);
fp = fopen(MAX_FILE, "w");
fprintf(fp, "%d", max_on);
fclose(fp);
}
if (max_on == count)
sprintf(
buf,
"{BThere are {W%d {Bcharacters on, the most so far today.{x\n\r",
count);
else
sprintf(
buf,
"{BThere are {W%d {Bcharacters on, the most on today was {W%d{x.\n\r",
count, max_on);
send_to_char(buf, ch);
}
void do_inventory(CHAR_DATA * ch, char *argument)
{
BUFFER *final = show_list_to_char(ch->carrying, ch, TRUE, TRUE);
send_to_char("You are carrying:\n\r", ch);
page_to_char(final->string, ch);
free_buf(final);
return;
}
void do_equipment(CHAR_DATA * ch, char *argument)
{
OBJ_DATA *obj;
int iWear;
int oWear;
bool found, showEmpty = FALSE;
char buf[MSL];
send_to_char("You are using:\n\r", ch);
found = FALSE;
if (argument[0] != '\0' && !str_prefix(argument, "empty"))
showEmpty = TRUE;
for (oWear = 0; oWear < MAX_WEAR; oWear++)
{
iWear = where_order[oWear];
if ((obj = get_eq_char(ch, iWear)) == NULL)
{
if (showEmpty)
{
send_to_char(where_name[iWear], ch);
send_to_char("Nothing.\r\n", ch);
}
continue;
}
send_to_char(where_name[iWear], 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("something.\n\r", ch);
}
found = TRUE;
}
if (!found)
send_to_char("Nothing.\n\r", ch);
if ((ch->level >= LEVEL_HERO) && (found)) {
sprintf(buf, "You are currently using %d/50 equipment bonus levels.\n\r", tier_wear_limit(ch, NULL));
send_to_char(buf, ch);
}
if (!showEmpty)
send_to_char("Use the argument \"empty\" to see empty slots\r\n", 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;
float value1;
float value2;
char *msg;
argument = one_argument(argument, arg1);
argument = one_argument(argument, arg2);
if (arg1[0] == '\0')
{
send_to_char("Compare what to what?\n\r", ch);
return;
}
if ((obj1 = get_obj_carry(ch, arg1)) == NULL)
{
send_to_char("You do not have that item.\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->wear_flags & obj2->wear_flags & ~ITEM_TAKE) != 0)
break;
}
if (obj2 == NULL)
{
send_to_char("You aren't wearing anything comparable.\n\r", ch);
return;
}
}
else if ((obj2 = get_obj_carry(ch, arg2)) == NULL)
{
send_to_char("You do not have that item.\n\r", ch);
return;
}
msg = NULL;
value1 = 0;
value2 = 0;
if (obj1 == obj2)
{
msg = "You compare $p to itself. It looks about the same.";
}
else
{
value1 = obj_balance(obj1->pIndexData);
value2 = obj_balance(obj2->pIndexData);
}
if (msg == NULL)
{
if (value2 == 0)
value2 = 1;
if (value1 == value2)
msg = "$p and $P look about the same.";
else if (value1 > value2)
msg = "$p looks better than $P.";
else
msg = "$p looks worse than $P.";
}
act(msg, ch, obj1, obj2, TO_CHAR);
return;
}
void do_credits(CHAR_DATA * ch, char *argument)
{
do_help(ch, "diku");
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);
if (arg[0] == '\0')
{
sprintf(buf, "Players near you in %s:\n\r", ch->in_room->area->name);
send_to_char(buf, ch);
found = FALSE;
for (d = descriptor_list; d; d = d->next)
{
char name_buf[MIL];
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(
ch, victim->in_room)) && victim->in_room->area
== ch->in_room->area && get_trust(ch)
>= victim->ghost_level && can_see(ch, victim)
&& victim->level < 180)
{
found = TRUE;
if (is_affected(victim, gsn_conceal)
|| is_affected(victim, gsn_conceal2)
|| is_affected(victim, gsn_concealClan1)
|| is_affected(victim, gsn_concealClan2))
{
if (!is_same_clan(ch, victim) && !IS_IMMORTAL(ch))
sprintf(buf, "%-28s %s\n\r", get_pers(victim, NULL),
victim->in_room->name);
else
/* (IS_IMMORTAL(ch)) */
sprintf(buf, "(%s) %-28s %s\n\r", get_name(victim,
NULL, name_buf), victim->name,
victim->in_room->name);
send_to_char(buf, ch);
}
else
{
sprintf(buf, "%-28s %s\n\r", victim->name,
victim->in_room->name);
send_to_char(buf, ch);
}
}
}
if (!found)
send_to_char("None\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
/* && !IS_AFFECTED (victim, AFF_HIDE)
&& !IS_AFFECTED (victim, AFF_SNEAK) */
&& get_trust(ch) >= victim->ghost_level
&& !IS_SET (victim->in_room->room_flags, ROOM_NOWHERE)
&& can_see(ch, victim) && victim->level < 180)
{
found = TRUE;
if (is_affected(victim, gsn_conceal) && number_percent() > 25
&& (!str_prefix(arg, "green") || !str_prefix(arg,
"cloaked")))
{
sprintf(buf, "%-28s %s\n\r", get_pers(victim, NULL),
victim->in_room->name);
send_to_char(buf, ch);
break;
}
else if (is_name(arg, victim->name) && !is_affected(victim,
gsn_conceal))
{
sprintf(buf, "%-28s %s\n\r", //MORPH BREE WHERE
PERS (victim, ch), victim->in_room->name);
send_to_char(buf, ch);
break;
}
}
}
if (!found)
act("You didn't find any $T.", ch, NULL, arg, TO_CHAR);
}
return;
}
void do_track(CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
EXIT_DATA *pexit;
ROOM_INDEX_DATA *in_room;
sh_int track_vnum;
int door, move, chance, track;
one_argument(argument, arg);
if ((chance = get_skill(ch, gsn_track)) == 0)
{
send_to_char("You don't know how to track.\n\r", ch);
return;
}
if (arg[0] == '\0')
{
send_to_char("Track whom?\n\r", ch);
return;
}
in_room = ch->in_room;
track_vnum = in_room->vnum;
move = movement_loss[UMIN (SECT_MAX - 1, in_room->sector_type)];
if (ch->move < move)
{
send_to_char("You are too exhausted.\n\r", ch);
return;
}
if (number_percent() < (100 - chance))
{
sprintf(buf, "You can find no recent tracks for %s.\n\r", arg);
send_to_char(buf, ch);
check_improve(ch, gsn_track, FALSE, 1);
WAIT_STATE (ch, 1)
; ch->move -= move / 2;
return;
}
for (victim = char_list; victim != NULL; victim = victim->next)
{
if (victim->in_room != NULL
&& !IS_NPC (victim)
&& can_see (ch, victim)
&& is_name (arg, victim->name))
{
if (victim->in_room->vnum == track_vnum)
{
act ("The tracks end right under $S feet.", ch, NULL, victim, TO_CHAR);
return;
}
for (track = 0; track < MAX_TRACK; track++)
{
if (victim->track_from[track] == track_vnum)
{
for (door = 0; door < 12; door++)
{
if ((pexit = in_room->exit[door]) != NULL)
{
if (pexit->u1.to_room->vnum == victim->track_to[track])
{
sprintf (buf, "Some tracks lead off to the %s.\n\r", dir_name[door]);
send_to_char (buf, ch);
check_improve (ch, gsn_track, TRUE, 1);
WAIT_STATE (ch, 1);
ch->move -= move;
return;
}
}
}
act ("$N seems to have vanished here.", ch, NULL, victim, TO_CHAR);
check_improve (ch, gsn_track, TRUE, 1);
WAIT_STATE (ch, 1);
ch->move -= move;
return;
}
}
act ("You can find no recent tracks for $N.", ch, NULL, victim, TO_CHAR);
check_improve (ch, gsn_track, FALSE, 1);
WAIT_STATE (ch, 1);
ch->move -= move / 2;
return;
}
}
for (victim = char_list; victim != NULL; victim = victim->next)
{
if ((victim->in_room != NULL)
&& IS_NPC (victim)
&& can_see (ch, victim)
&& (victim->in_room->area == ch->in_room->area)
&& is_name (arg, victim->name))
{
if (victim->in_room->vnum == track_vnum)
{
act ("The tracks end right under $S feet.", ch, NULL, victim, TO_CHAR);
return;
}
for (track = 0; track < MAX_TRACK; track++)
{
if (victim->track_from[track] == track_vnum)
{
for (door = 0; door < 12; door++)
{
if ((pexit = in_room->exit[door]) != NULL)
{
if (pexit->u1.to_room->vnum == victim->track_to[track])
{
sprintf (buf, "Some tracks lead off to the %s.\n\r", dir_name[door]);
send_to_char (buf, ch);
check_improve (ch, gsn_track, TRUE, 1);
WAIT_STATE (ch, 1);
ch->move -= move;
return;
}
}
}
act ("$N seems to have vanished here.", ch, NULL, victim, TO_CHAR);
check_improve (ch, gsn_track, TRUE, 1);
WAIT_STATE (ch, 1);
ch->move -= move;
return;
}
}
}
}
sprintf (buf, "You can find no recent tracks for %s.\n\r", arg);
send_to_char (buf, ch);
check_improve (ch, gsn_track, FALSE, 1);
WAIT_STATE (ch, 1);
ch->move -= move / 2;
return;
}
void do_consider(CHAR_DATA * ch, char *argument)
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
char *msg;
int lvldiff, hpdiff, manadiff;
one_argument(argument, arg);
if (arg[0] == '\0')
{
send_to_char("Consider killing whom?\n\r", ch);
return;
}
if ((victim = get_char_room(ch, arg)) == NULL)
{
send_to_char("They're not here.\n\r", ch);
return;
}
if (is_safe(ch, victim))
{
send_to_char("Don't even think about it.\n\r", ch);
return;
}
msg = "$N";
act(msg, ch, NULL, victim, TO_CHAR);
send_to_char("----------\n\r", ch);
lvldiff = victim->level - ch->level;
send_to_char("Level: ", ch);
if (lvldiff <= 0)
msg = "you wouldn't waste your time with them.";
else if (lvldiff <= 5)
msg = "$N is no match for you.";
else if (lvldiff <= 10)
msg = "$N cowers in fear from you.";
else if (lvldiff <= 15)
msg = "$N smiles nervously at you.";
else if (lvldiff == 20)
msg = "the perfect match!";
else if (lvldiff <= 25)
msg = "$N says '{_Do you feel lucky, punk?{x'.";
else if (lvldiff <= 30)
msg = "$N backs you into a corner.";
else if (lvldiff <= 35)
msg = "$N says ' Bring a friend'";
else if (lvldiff >= 50)
msg = "eats players like you for breakfast.";
else
msg = "this is not supposed to be seen.";
act(msg, ch, NULL, victim, TO_CHAR);
hpdiff = (ch->hit - victim->hit);
send_to_char("Health:", ch);
if (hpdiff >= 150)
msg = " you are currently much healthier than $E.";
else if (hpdiff >= 50)
msg = " you are currently healthier than $E.";
else if (hpdiff >= 25)
msg = " you are currently slightly healthier than $E.";
else if (hpdiff >= 1)
msg = " you are a teensy bit healthier than $E.";
else if (hpdiff == 0)
msg = " $E is a perfect match for you.";
else if (hpdiff <= -1)
msg = " $E is a teensy bit healthier than you.";
else if (hpdiff <= -25)
msg = " $E is slightly healthier than you.";
else if (hpdiff <= -50)
msg = " $E is healthier than you.";
else if (hpdiff <= -150)
msg = " $E is much healthier than you.";
else
msg = " this is not supposed to be seen.";
act(msg, ch, NULL, victim, TO_CHAR);
manadiff = (ch->mana - victim->mana);
send_to_char("Magic:", ch);
if (manadiff >= 150)
msg = " you are currently much more powerful than $E.";
else if (manadiff >= 50)
msg = " you are currently more powerful than $E.";
else if (manadiff >= 25)
msg = " you are currently slightly more powerful than $E.";
else if (manadiff >= 1)
msg = " you are a teensy bit more powerful than $E.";
else if (manadiff == 0)
msg = " $E is a perfect match for you.";
else if (manadiff <= -1)
msg = " $E is a teensy bit more powerful than you.";
else if (manadiff <= -25)
msg = " $E is slightly more powerful than you.";
else if (manadiff <= -50)
msg = " $E is more powerful than you.";
else if (manadiff <= -150)
msg = " $E is much more powerful than you.";
else
msg = " this is not supposed to be seen.";
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))
{
printf_debug("Set_title: NPC.");
return;
}
if (title[0] != '.' && title[0] != ',' && title[0] != '!' && title[0]
!= '?')
{
buf[0] = ' ';
strcpy(buf + 1, title);
}
else
{
strcpy(buf, title);
}
free_string(ch->pcdata->title);
ch->pcdata->title = str_dup(buf);
ch->pcdata->usr_ttl = TRUE;
return;
}
void do_title(CHAR_DATA * ch, char *argument)
{
if (IS_NPC (ch))
return;
if (IS_SET (ch->act, PLR_NOTITLE))
return;
if ((ch->in_room->vnum == ROOM_VNUM_CORNER) && (!IS_IMMORTAL (ch)))
{
send_to_char(
"Just keep your nose in the corner like a good little player.\n\r",
ch);
return;
}
if (argument[0] == '{' && argument[1] == '\0')
return;
if (argument[0] == '\0')
{
send_to_char("Change your title to what?\n\r", ch);
return;
}
if (strlen(argument) > 45)
total_length(argument, 45);
smash_tilde(argument);
set_title(ch, argument);
send_to_char("Ok.\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("No lines left to remove.\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("Your description is:\n\r", ch);
send_to_char(ch->description ? ch->description
: "(None).\n\r", ch);
return;
}
}
}
buf[0] = '\0';
free_string(ch->description);
ch->description = str_dup(buf);
send_to_char("Description cleared.\n\r", ch);
return;
}
if (argument[0] == '+')
{
if (ch->description != NULL)
strcat(buf, ch->description);
argument++;
while (isspace (*argument))
argument++;
}
if (strlen(buf) + strlen(argument) >= MAX_STRING_LENGTH - 2)
{
send_to_char("Description too long.\n\r", ch);
return;
}
strcat(buf, argument);
strcat(buf, "\n\r");
free_string(ch->description);
ch->description = str_dup(buf);
}
send_to_char("Your description is:\n\r", ch);
send_to_char(ch->description ? ch->description : "(None).\n\r", ch);
return;
}
void do_report(CHAR_DATA * ch, char *argument)
{
char buf[MAX_INPUT_LENGTH];
sprintf(buf,
"You say '{SI have %d/%d hp %d/%d mana %d/%d mv %ld xp.{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, "$n says '{SI have %d/%d hp %d/%d mana %d/%d mv %ld xp.{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)
{
char buf[MAX_STRING_LENGTH];
int sn;
if (IS_NPC (ch))
return;
if (argument[0] == '\0')
{
int col;
col = 0;
for (sn = 0; sn < MAX_SKILL; sn++)
{
if (skill_table[sn].name == NULL)
break;
if (ch->level < ch->pcdata->learnlvl[sn] || ch->pcdata->learned[sn]
< 1 /* skill is not known */)
continue;
sprintf(buf, "{&%-18s{x {$%3d%%{x ", skill_table[sn].name,
ch->pcdata->learned[sn]);
send_to_char(buf, ch);
if (++col % 3 == 0)
send_to_char("\n\r", ch);
}
if (col % 3 != 0)
send_to_char("\n\r", ch);
sprintf(buf, "You have {&%d{x practice sessions left.\n\r",
ch->practice);
send_to_char(buf, ch);
}
else
{
CHAR_DATA *mob;
int adept;
if (!IS_AWAKE (ch))
{
send_to_char("In your dreams, or what?\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("You can't do that here.\n\r", ch);
return;
}
if (ch->practice <= 0)
{
send_to_char("You have no practice sessions left.\n\r", ch);
return;
}
if ((sn = find_spell(ch, argument)) < 0 || (!IS_NPC (ch) && (ch->level
< ch->pcdata->learnlvl[sn] || ch->pcdata->learned[sn] < 1)))
{
send_to_char("You can't practice that.\n\r", ch);
return;
}
adept = IS_NPC (ch) ? 100 : class_table[ch->class].skill_adept;
if (ch->pcdata->learned[sn] >= adept)
{
sprintf(buf, "You are already learned at %s.\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)
{
sprintf(buf, "You practice $T.{@({&%d{@){x",
ch->pcdata->learned[sn]);
act(buf, ch, NULL, skill_table[sn].name, TO_CHAR);
act("$n practices $T.", ch, NULL, skill_table[sn].name, TO_ROOM);
}
else
{
ch->pcdata->learned[sn] = adept;
act("You are now learned at $T.", ch, NULL,
skill_table[sn].name, TO_CHAR);
act("$n is now learned at $T.", 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("Your courage exceeds your wisdom.\n\r", ch);
return;
}
if (wimpy > ch->max_hit / 2)
{
send_to_char("Such cowardice ill becomes you.\n\r", ch);
return;
}
ch->wimpy = wimpy;
sprintf(buf, "Wimpy set to %d hit points.\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("Syntax: password <old> <new>.\n\r", ch);
return;
}
if (strcmp(crypt(arg1, ch->pcdata->pwd), ch->pcdata->pwd))
{
WAIT_STATE (ch, 40)
; send_to_char ("Wrong password. Wait 10 seconds.\n\r", ch);
return;
}
if (strlen (arg2) < 5)
{
send_to_char (
"New password must be at least five characters long.\n\r", ch);
return;
}
/*
* No tilde allowed because of player file format.
*/
pwdnew = crypt (arg2, ch->name);
for (p = pwdnew; *p != '\0'; p++)
{
if (*p == '~')
{
send_to_char (
"New password not acceptable, try again.\n\r", ch);
return;
}
}
free_string (ch->pcdata->pwd);
ch->pcdata->pwd = str_dup (pwdnew);
save_char_obj (ch);
send_to_char ("Ok.\n\r", ch);
return;
}
void do_nscore(CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH], buf2[256];
BUFFER *output = new_buf();
CLAN_DATA *clan = get_clan_by_ch( ch );
ROSTER_DATA *roster;
GET_ROSTER( ch, roster );
if (IS_NPC (ch))
sprintf(buf, "\n\r%s\n\r", ch->name);
else
sprintf(buf, "\n\r%s%s%s\n\r", ch->pcdata->pretit, ch->name,
ch->pcdata->title);
add_buf(output, buf);
buf[0] = '\0';
sprintf(
buf,
"{y______________________________________________________________________________{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y|\\___________________________________________________________________________/|{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y||{WLevel{x: %-3d {WAge{x: %-3d {WRace{x: %-13s {WGender{x: %-6s {WClass{x: %-12s{y||{x\n\r",
ch->level + tier_level_bonus(ch), get_age(ch), race_table[ch->race].name,
ch->sex == 0 ? "none" : ch->sex == 1 ? "male" : "female",
IS_NPC (ch) ? "mobile" : class_table[ch->class].name);
add_buf(output, buf);
if (get_trust(ch) > LEVEL_HERO)
{
sprintf(
buf,
"{y||{WTrust{x: %-3d {WHoly Light{x: %-3s {WWizInvis Level{x: %-3d {WIncognito Level{x: %-3d {y||{x\n\r",
get_trust(ch), IS_SET (ch->act, PLR_HOLYLIGHT) ? "on" : "off",
ch->invis_level, ch->incog_level);
add_buf(output, buf);
}
if (!IS_NPC (ch))
{
sprintf(
buf,
"{y||{WPractices{x: %-5d {WTrains{x: %-5d {WExperience{x: %-9ld {WNeeded to level{x: %-5ld{y||{x\n\r",
ch->practice, ch->train, ch->exp, IS_HERO (ch) ? (0)
: ((ch->level + 1) * exp_per_level(ch,
ch->pcdata->points) - ch->exp));
add_buf(output, buf);
}
sprintf(
buf,
"{y||___________________________________________________________________________||{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y|/___________________________________________________________________________\\|{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y|\\_______________________________/| |\\_______________________________________/|{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y||{x{WStr{x: {Y%-2d{x({C%2d{x) {WHit{x: %-2d {WDam{x: %-2d {y|| ||{x {WHit Points{x: %5d/%5d {WSaves: %5d {y||\n\r",
ch->perm_stat[STAT_STR], get_curr_stat(ch, STAT_STR),
str_app[get_curr_stat(ch, STAT_STR)].tohit, str_app[get_curr_stat(
ch, STAT_STR)].todam, ch->hit, ch->max_hit,
ch->saving_throw);
add_buf(output, buf);
sprintf(
buf,
"{y||{x{WInt{x: {Y%-2d{x({C%2d{x) {WLearn{x: %-2d%% {y|| ||{x {WMana{x: %5d/%5d {WMove{x: %5d/%5d {y||{x\n\r",
ch->perm_stat[STAT_INT], get_curr_stat(ch, STAT_INT),
int_app[get_curr_stat(ch, STAT_INT)].learn, ch->mana, ch->max_mana,
ch->move, ch->max_move);
add_buf(output, buf);
sprintf(
buf,
"{y||{x{WWis{x: {Y%-2d{x({C%2d{x) {WPracs{x: %-2d {y|| ||{x {WHitroll{x: %-3d {WDamroll{x: %-3d {y||{x\n\r",
ch->perm_stat[STAT_WIS], get_curr_stat(ch, STAT_WIS),
wis_app[get_curr_stat(ch, STAT_WIS)].practice, GET_HITROLL (ch),
GET_DAMROLL (ch));
add_buf(output, buf);
sprintf(
buf,
"{y||{x{WDex{x: {Y%-2d{x({C%2d{x) {WACmod{x: %-4d {y|| ||{x {WACpierce{x: %-5d {WACbash{x: %-5d {y||{x\n\r",
ch->perm_stat[STAT_DEX], get_curr_stat(ch, STAT_DEX),
dex_app[get_curr_stat(ch, STAT_DEX)].defensive,
GET_AC (ch, AC_PIERCE), GET_AC (ch, AC_BASH));
add_buf(output, buf);
sprintf(
buf,
"{y||{x{WCon{x: {Y%-2d{x({C%2d{x) {WHP{x: %-2d {WSS{x: %-3d%% {y|| ||{x {WACslash{x: %-8d {WACexotic{x: %-5d {y||{x\n\r",
ch->perm_stat[STAT_CON], get_curr_stat(ch, STAT_CON),
con_app[get_curr_stat(ch, STAT_CON)].hitp, con_app[get_curr_stat(
ch, STAT_CON)].shock, GET_AC (ch, AC_SLASH),
GET_AC (ch, AC_EXOTIC));
add_buf(output, buf);
sprintf(
buf,
"{y||_______________________________|| ||_______________________________________||{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y|/_______________________________\\| |/_______________________________________\\|{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y|\\___________________________________________________________________________/|{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y||{WPlatinum{x: %-7ld {WGold{x: %-7ld {WSilver{x: %-7ld {WYour Deity{x: %-9s {y||{x\n\r{y||{WItems{x: %4d/%4d {WWeight{x: %7ld/%7d {WAlign{x: %-5d {y||{x\n\r",
ch->platinum, ch->gold, ch->silver, (god_table[ch->god].name),
ch->carry_number, can_carry_n(ch), get_carry_weight (ch) / 10,
can_carry_w(ch) / 10, ch->alignment);
add_buf(output, buf);
/* if ( ch->alignment > 900 ) send_to_char( "{&O{7di{&n{x's chosen {x{y||{x\n\r", ch );
else if ( ch->alignment > 700 ) send_to_char( "{&O{7di{&n{x's servant {y||{x\n\r", ch );
else if ( ch->alignment > 350 ) send_to_char( "{Ygood{x {y||{x\n\r", ch );
else if ( ch->alignment > 100 ) send_to_char( "kind {y||{x\n\r", ch );
else if ( ch->alignment > -100 ) send_to_char( "neutral {y||{x\n\r", ch );
else if ( ch->alignment > -350 ) send_to_char( "mean {y||{x\n\r", ch );
else if ( ch->alignment > -700 ) send_to_char( "{Revil {x {y||{x\n\r", ch );
else if ( ch->alignment > -900 ) send_to_char( "{!H{1e{!l{x's servant {x{y||{x\n\r", ch );
else send_to_char( "{!H{1e{!l{x's chosen {x{y||{x\n\r", ch ); */
sprintf(
buf,
"{y||{WSize:{x %-11s {WWimpy:{x %-5d {WQuest Points:{x %-14d {y||{x\n\r",
size_table[ch->size].name, ch->wimpy, ch->questpoints);
add_buf(output, buf);
if (!IS_NPC(ch))
{
if (clan)
{
sprintf(buf,
"{WCLAN:{x %-30s - {WA %-13s {Wclan. {x",
end_string(clan->c_name, MAX_CLAN_WHO_LENGTH ),
clan->pkill ? "{RPkill {x" : "{WNon-Pkill {x");
sprintf(buf2, "{y||%-76s{y||{x\n\r", buf);
add_buf(output, buf2);
sprintf (buf, "{y||{W%s Points:{x %-6ld {WHours: {x%-5d {y||{x\n\r",
clan->pkill ? "Pkill" : "Arena", roster->pkilldata->kPoints, ch->played/3600);
add_buf(output,buf);
}
if (ch->challenger != NULL)
{
sprintf(
buf,
"{y||{x{3[{^Arena{3]{x You have been {rchallenged{x by {b%-10s{x {y||{x\n\r",
ch->challenger->name);
add_buf(output, buf);
}
if (ch->challenged != NULL)
{
sprintf(
buf,
"{y||{3[{^Arena{3]{x You have {rchallenged{x {b%-10s{x {y||{x\n\r",
ch->challenged->name);
add_buf(output, buf);
}
if (ch->gladiator != NULL)
{
sprintf(
buf,
"{y||{3[{{^Arena Bet{3]{x You have a {y%-8d{x gold bet on {b%-10s{x {y||\n\r",
ch->pcdata->plr_wager, ch->gladiator->name);
add_buf(output, buf);
}
}
if (!IS_NPC (ch) && ch->pcdata->condition[COND_DRUNK] > 10)
{
sprintf(
buf,
"{y|| {xYou are {ydrunk.{x {y||{x\n\r");
add_buf(output, buf);
}
if (!IS_NPC (ch) && ch->pcdata->condition[COND_THIRST] == 0)
{
sprintf(
buf,
"{y|| {xYou are {^thirsty.{x {y||{x\n\r");
add_buf(output, buf);
}
if (!IS_NPC (ch) && ch->pcdata->condition[COND_HUNGER] == 0)
{
sprintf(
buf,
"{y|| {xYou are {#hungry.{x {y||{x\n\r");
add_buf(output, buf);
}
if (IS_SET(ch->plyr,PLAYER_GHOST) && ch->ghost_timer > 0)
{
sprintf(
buf,
"{y|| {xYou are a {7G{wH{7O{wS{7T{x for %d more ticks. {y||{x\n\r",
ch->ghost_timer);
add_buf(output, buf);
}
if (ch->fight_timer > 0)
{
sprintf(
buf,
"{y|| {xYou have ({R%2d{x) ticks left on your fight timer. {y||{x\n\r",
ch->fight_timer);
add_buf(output, buf);
}
switch (ch->position)
{
case POS_DEAD:
sprintf(
buf,
"{y||{x You are {z{!DEAD!!{x {y||{x\n\r");
add_buf(output, buf);
break;
case POS_MORTAL:
sprintf(
buf,
"{y||{x You are {%mortally wounded!!{x {y||{x\n\r");
add_buf(output, buf);
break;
case POS_INCAP:
sprintf(
buf,
"{y||{x You are {1incapacitated.{x {y||{x\n\r");
add_buf(output, buf);
break;
case POS_STUNNED:
sprintf(
buf,
"{y||{x You are {@stunned.{x {y||{x\n\r");
add_buf(output, buf);
break;
case POS_SLEEPING:
sprintf(
buf,
"{y||{x You are {$sleeping.{x {y||{x\n\r");
add_buf(output, buf);
break;
case POS_RESTING:
sprintf(
buf,
"{y||{x You are {4resting.{x {y||{x\n\r");
add_buf(output, buf);
break;
case POS_STANDING:
sprintf(
buf,
"{y||{x You are {5standing.{x {y||{x\n\r");
add_buf(output, buf);
break;
case POS_FIGHTING:
sprintf(
buf,
"{y||{x You are {&fighting.{x {y||{x\n\r");
add_buf(output, buf);
break;
}
sprintf(
buf,
"{y||{WHp Regen Rate: {R%-3d{x {W:: Mana Regen Rate: {R%-3d{x {y||{x\n\r",
ch->regen_rate, ch->mana_regen_rate);
add_buf(output, buf);
sprintf(
buf,
"{y||___________________________________________________________________________||{x\n\r");
add_buf(output, buf);
sprintf(
buf,
"{y|/___________________________________________________________________________\\|{x\n\r");
add_buf(output, buf);
page_to_char(buf_string(output), ch);
if (IS_SET (ch->comm, COMM_SHOW_AFFECTS))
do_affects(ch, "");
}
void do_gods(CHAR_DATA * ch, char *argument)
{
char buf[MAX_STRING_LENGTH];
int god;
int blank;
blank = 0;
if (IS_NPC (ch))
return;
send_to_char(" ", ch);
for (god = 0; god < MAX_GOD; god++)
{
if ((god_table[god].pc_evil && ch->alignment <= -200)
|| (god_table[god].pc_neutral && ch->alignment == 0)
|| (god_table[god].pc_good && ch->alignment >= 200))
{
if ((god_table[god].pc_mage && ch->class == 0)
|| (god_table[god].pc_cleric && ch->class == 1)
|| (god_table[god].pc_thief && ch->class == 2)
|| (god_table[god].pc_warrior && ch->class == 3)
|| (god_table[god].pc_ranger && ch->class == 4)
|| (god_table[god].pc_druid && ch->class == 5)
|| (god_table[god].pc_vampire && ch->class == 6)
|| (god_table[god].pc_wizard && ch->class == 7)
|| (god_table[god].pc_priest && ch->class == 8)
|| (god_table[god].pc_mercenary && ch->class == 9)
|| (god_table[god].pc_gladiator && ch->class == 10)
|| (god_table[god].pc_strider && ch->class == 11)
|| (god_table[god].pc_sage && ch->class == 12)
|| (god_table[god].pc_lich && ch->class == 13)
|| (god_table[god].pc_forsaken && ch->class == 14)
|| (god_table[god].pc_conjurer && ch->class == 15)
|| (god_table[god].pc_archmage && ch->class == 16)
|| (god_table[god].pc_voodan && ch->class == 17)
|| (god_table[god].pc_monk && ch->class == 18)
|| (god_table[god].pc_saint && ch->class == 19)
|| (god_table[god].pc_assassin && ch->class == 20)
|| (god_table[god].pc_ninja && ch->class == 21)
|| (god_table[god].pc_bard && ch->class == 22)
|| (god_table[god].pc_barbarian && ch->class == 23)
|| (god_table[god].pc_swashbuckler && ch->class == 24)
|| (god_table[god].pc_crusader && ch->class == 25)
|| (god_table[god].pc_darkpaladin && ch->class == 26)
|| (god_table[god].pc_hunter && ch->class == 27)
|| (god_table[god].pc_paladin && ch->class == 28)
|| (god_table[god].pc_warlock && ch->class == 29)
|| (god_table[god].pc_alchemist && ch->class == 30)
|| (god_table[god].pc_shaman && ch->class == 31)
|| (god_table[god].pc_fade && ch->class == 32)
|| (god_table[god].pc_banshee && ch->class == 33))
{
sprintf(buf, "%-10s ", god_table[god].name);
send_to_char(buf, ch);
}
if (++blank % 3 == 0)
send_to_char("\n\r ", ch);
}
}
return;
}
void do_identify(CHAR_DATA * ch, char *argument)
{
OBJ_DATA *obj;
CHAR_DATA *rch;
if ((obj = get_obj_carry(ch, argument)) == NULL)
{
send_to_char("You are not carrying that.\n\r", ch);
return;
}
for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room)
if (IS_NPC (rch) && rch->pIndexData->vnum == MOB_VNUM_SAGE)
break;
if (!rch)
{
send_to_char("No one here seems to know much about that.\n\r", ch);
return;
}
if (IS_IMMORTAL (ch))
act("$n cackles and comps you!\n\r", rch, obj, ch, TO_VICT);
else if (ch->gold < obj->level * 100 + 50 && ch->platinum < obj->level
* .25)
{
act("$n resumes tossing bones without looking at $p.", rch, obj, 0,
TO_ROOM);
return;
}
else if (ch->gold > obj->level * 100 + 50)
{
ch->gold -= obj->level * 100 + 50;
send_to_char("Your purse feels lighter.\n\r", ch);
}
else if (ch->platinum > obj->level * .25)
{
ch->platinum -= obj->level * .25;
send_to_char("Your purse feels lighter.\n\r", ch);
}
act("$n fondles $p and tosses some chicken bones to the ground.", rch, obj,
0, TO_ROOM);
spell_identify(100, 0, ch, obj, 0);
}
void do_subdue(CHAR_DATA *ch, char *argument)
{
if (IS_NPC(ch))
return;
if (IS_SET(ch->plyr, PLAYER_SUBDUE))
{
send_to_char("You will now Kill your victims.\n\r", ch);
REMOVE_BIT(ch->plyr,PLAYER_SUBDUE);
}
else
{
send_to_char("You will now subdue your victims.\n\r", ch);
SET_BIT(ch->plyr,PLAYER_SUBDUE);
}
}
const struct l_form
look_form[] =
{
{ " ", " " },
// MORPH_CONCEAL
{ "a {Dg{wr{We{Dy{X {Dshadow{X", "A {Dg{wr{We{wy{X {Dshadow{X is standing here. \n\r" },
// MORPH_BAT
{ "a bat", "A huge bat is flying here.\n\r" },
// MORPH_WOLF
{ "a wolf", "A large grey wolf stands here.\n\r" },
// MORPH_BEAR
{ "a bear", "A large, mean looking bear is standing here.\n\r" },
// MORPH_RED
{ "a red dragon", "A red dragon is here breathing plumes of smoke.\n\r" },
// MORPH_BLACK
{ "a black dragon", "A black dragon is here spitting burning acids.\n\r" },
// MORPH_GREEN
{ "a green dragon", "A green dragon is here breathing noxious poison.\n\r" },
// MORPH_WHITE
{ "a white dragon", "A white dragon sends out blasts of freezing air at you.\n\r" },
// MORPH_GOLD
{ "a gold dragon", "A gold dragon gazes down at you here.\n\r" },
// MORPH_MORPH
{ "an odd", "An odd-looking person stands here.\n\r" },
// MORPH_CONCEAL2
{ "a giant wolf", "A giant wolf is here, growling.\n\r" },
// MORPH_CONCEAL3
{ "a gaseous cloud", "A cloud of boiling gasses is here.\n\r" },
{ "a cloaked figure", "A cloaked figure stands here.\n\r" },
{ "a shrouded figure", "A shrouded figure stands here.\n\r" },
{ "a cloaked figure", "A cloaked figure stands here.\n\r" },
{ "a goat headed", "A goat headed person stands here.\n\r" },
{ "a lion headed", "A lion headed person stands here.\n\r" },
{ "a dragon headed", "A dragon headed person stands here.\n\r" },
{ "", "" } };
/* Morph Stuff */
char * get_descr_form(CHAR_DATA *ch, CHAR_DATA *looker, bool get_long)
{
char buf[MAX_STRING_LENGTH];
char *buf2;
buf[0] = '\0';
buf2 = "";
if (get_long)
{
if (ch->morph_form[0] == 0 || ch->morph_form[0] == MORPH_MORPH)
return ch->long_descr;
else
return look_form[UMAX(ch->morph_form[0], 0)].long_descr;
}
else
{
if (ch->morph_form[0] == 0)
return PERS(ch, looker);
else if (ch->morph_form[0] < MORPH_MORPH)
return look_form[ch->morph_form[0]].short_descr;
else if (ch->morph_form[0] == MORPH_MORPH)
return ch->morph;
else if (ch->sex == SEX_MALE)
sprintf(buf, "%s %s",
look_form[ch->morph_form[0]].short_descr, "man");
else if (ch->sex == SEX_FEMALE)
sprintf(buf, "%s %s",
look_form[ch->morph_form[0]].short_descr, "woman");
else
sprintf(buf, "%s %s",
look_form[ch->morph_form[0]].short_descr,
"creature");
buf2 = buf;
return buf2;
}
if (get_long)
return ch->long_descr;
return PERS(ch,looker);
}
/*
void update_ranklist(CHAR_DATA *ch)
{
#define RANK_SHOW 20
ARANK_DATA *arank;
PRANK_DATA *prank;
Linear Sort
for (count = 0; count < RANK_SHOW; count++)
{
x = count;
for (index = count + 1; index < RANK_SHOW; index++)
if (data[index] > data[x])
x = index;
if (x > count)
swap(data[x], data[count]);
}
}
*/
void do_unghost(CHAR_DATA *ch)
{
if (IS_NPC (ch))
return;
if (!IS_SET(ch->plyr,PLAYER_GHOST))
{
send_to_char("You aren't a ghost.\n\r", ch);
return;
}
else
{
ch->ghost_timer = 0;
REMOVE_BIT(ch->plyr,PLAYER_GHOST);
act("You feel more real.", ch, NULL, NULL, TO_CHAR);
act("$n fades into reality.", ch, NULL, NULL, TO_ROOM);
}
}
/*void do_sunder( CHAR_DATA *ch, char *argument )
{
if ( IS_NPC( ch ) || ch->class != CLASS_CRUSADER )
{
send_to_char("{wIf you want sunder, then go Crusader!\n\r{x",ch);
return;
}
if ( IS_SET(ch->ability_crusader, ABILITY_CRUSADER_SUNDER ) )
{
send_to_char( "{cYou will no longer have the ability to {wsunder{c your opponent.{x\n\r",ch);
REMOVE_BIT( ch->ability_crusader, ABILITY_CRUSADER_SUNDER );
}
else
{
if ( ch->mana < ch->level/2 )
{
send_to_char("{rYou do not have enough money to turn on this ability!{x\n\r",ch);
return;
}
send_to_char( "{mYou will now have the ability to {wsunder{m your opponent.{x\n\r",ch);
SET_BIT( ch->ability_crusader, ABILITY_CRUSADER_SUNDER );
ch->mana -= ch->mana / 4;
}
} */
void do_nightstalker(CHAR_DATA *ch, char *argument)
{
// int count;
if ((ch->class == CLASS_SHADE || ch->class == CLASS_LICH || ch->class
== CLASS_FADE || ch->class == CLASS_BANSHEE) && !IS_NPC(ch))
{
// count = 1;
}
else
{
send_to_char("{wYou can already don't get harmed by sunlight!\n\r{x",
ch);
return;
}
if (IS_SET( ch->ability_lich, ABILITY_LICH_NIGHTSTALKER ))
{
// if (time_info.hour >= 16 && time_info.hour <= 18)
// {
send_to_char(
"{cYou will no longer feel the harmful effects of sunlight, or feel the power of the night.{x\n\r",
ch);
REMOVE_BIT( ch->ability_lich, ABILITY_LICH_NIGHTSTALKER );
// }
// else
// {
// send_to_char(
// "{rYou must wait until the dusk of the evening to relinquish the {DNightstalker{r!{x\n\r",
// ch);
// return;
// }
}
else
{
// if (time_info.hour >= 4 && time_info.hour <= 6)
// {
send_to_char(
"{mYou can now bask in the power of the night, but dread the harmful ray of sunlight!{x\n\r",
ch);
SET_BIT( ch->ability_lich, ABILITY_LICH_NIGHTSTALKER );
ch->mana = ch->mana / 2;
WAIT_STATE(ch,48)
; act("{R$n {renters a deep trance as they are consumed by the {DNightstalker{r!{x",ch,NULL,NULL,TO_ROOM);
// }
// else
// {
// send_to_char( "{rYou must wait until the dawn of a new day to decide to invoke the {DNightstalker{r!{x\n\r",ch);
// return;
// }
}
}
//VoOdan sense vitality by fesdor, works with sense vitality spell.
void do_sense(CHAR_DATA *ch, char *argument)
{
CHAR_DATA *victim;
char hp[MAX_STRING_LENGTH];
char mana[MSL];
char move[MSL];
char buf[MSL];
int temp = 0;
if (ch->class != CLASS_VOODAN || get_skill(ch, gsn_sense) == 0)
{
send_to_char("You do not know how to sense vitals.\n\r", ch);
return;
}
if (argument[0] == '\0')
{
send_to_char("Sense who?\n\r", ch);
return;
}
victim = get_char_world(ch, argument);
if (victim == NULL || victim->level > LEVEL_HERO)
{
send_to_char("You Failed.\n\r", ch);
return;
}
if (saves_spell(ch->level + 5, victim, DAM_OTHER))
{
send_to_char("You Failed.\n\r", ch);
return;
}
if (!is_affected(ch, gsn_sense))
{
send_to_char("You are not sensing anyone right now!\n\r", ch);
return;
}
else if (!is_affected(victim, gsn_sense))
{
send_to_char("You are not attuned to that player's vitals!\n\r", ch);
return;
}
else
{
BUFFER *final;
final = new_buf();
if (victim->max_move > 0)
temp = (100 * victim->move) / victim->max_move;
else
temp = 0;
if (temp >= 68)
{
sprintf(move, "{G%d{x", temp);
}
else if (temp >= 34)
{
sprintf(move, "{Y%d{x", temp);
}
else if (temp <= 33)
{
sprintf(move, "{R%d{x", temp);
}
else
sprintf(move, "{R%d{x", temp);
if (victim->max_hit > 0)
temp = (100 * victim->hit) / victim->max_hit;
else
temp = 0;
if (temp >= 68)
{
sprintf(hp, "{G%d{x", temp);
}
else if (temp >= 34)
{
sprintf(hp, "{Y%d{x", temp);
}
else if (temp <= 33)
{
sprintf(hp, "{R%d{x", temp);
}
else
sprintf(hp, "{R%d{x", temp);
if (victim->max_mana > 0)
temp = (100 * victim->mana) / victim->max_mana;
else
temp = 0;
if (temp >= 68)
{
sprintf(mana, "{G%d{x", temp);
}
else if (temp >= 34)
{
sprintf(mana, "{Y%d{x", temp);
}
else if (temp <= 33)
{
sprintf(mana, "{R%d{x", temp);
}
else
sprintf(mana, "{R%d{x", temp);
sprintf(buf, "You sense %s's vitals: %s{c%%hp %s{c%%mp %s{c%%mv{x",
victim->name, hp, mana, move);
add_buf(final, buf);
page_to_char(buf_string(final), ch);
free_buf(final);
WAIT_STATE(ch, 6)
; return;
}
return;
}
void do_newlook(CHAR_DATA *ch, char *argument) {
if (IS_NPC(ch))
return;
if (IS_SET(ch->plyr, PLAYER_NEWLOOK))
send_to_char("New look disabled.\r\n", ch);
else
send_to_char("New look enabled.\r\n", ch);
TOGGLE_BIT(ch->plyr, PLAYER_NEWLOOK);
}
void do_gamestatus(CHAR_DATA *ch, char *argument) {
BUFFER *output = new_buf();
char tbuf[MAX_STRING_LENGTH], vbuf[MAX_STRING_LENGTH],
format_buf[MAX_STRING_LENGTH];
extern char str_boot_time[];
extern time_t startup_time;
int day = time_info.day + 1;
GMOD_TICKET *ticket;
#define PBUF(Key, Value, ...) \
sprintf(tbuf, "%s", end_string(Key, 16)); \
sprintf(vbuf, Value, ## __VA_ARGS__); \
sprintf(format_buf, "| {W%s {w%s {B|\r\n", \
tbuf, end_string(vbuf, 24)); \
add_buf(output, format_buf);
add_buf(output, "{B+--------------- {GGame Status{B ---------------+\r\n");
PBUF("Startup time:", "%s", str_boot_time);
PBUF("Current time:", "%s", (char*)ctime(¤t_time));
int days, hours, mins, secs;
secs = current_time-startup_time;
mins = secs/60;
hours = mins/60;
days = hours/24;
PBUF("Uptime:", "%dd %dh %dm %ds", days, hours % 24, mins % 60, secs % 60);
PBUF("Mud time:", "%d%2s %3s %3s %d",
time_info.hour % 12, time_info.hour >= 12 ? "PM" : "AM",
day_name[day % 7], month_name[time_info.month], day);
PBUF("XP modifier:", "%.2fx", gmod_get_mult(GMOD_XP));
for (ticket = gmod_tickets; ticket != NULL; ticket = ticket->next) {
if (ticket->type != GMOD_XP)
continue;
sprintf(format_buf, " +%.2fx ticket:", ticket->multiplier);
PBUF(format_buf, "%ld minutes left", (ticket->expiry_time-current_time)/60);
}
PBUF("QR modifier:", "%.2fx", gmod_get_mult(GMOD_QP));
for (ticket = gmod_tickets; ticket != NULL; ticket = ticket->next) {
if (ticket->type != GMOD_QP)
continue;
sprintf(format_buf, " +%.2fx ticket:", ticket->multiplier);
PBUF(format_buf, "%ld minutes left", (ticket->expiry_time-current_time)/60);
}
if (IS_IMMORTAL(ch)) {
extern bool wizlock, newlock;
PBUF("Wizlocked:", "%s", wizlock ? "YES" : "NO");
PBUF("Newlocked:", "%s", newlock ? "YES" : "NO");
}
add_buf(output, "+-------------------------------------------+{x\r\n");
page_to_char(output->string, ch);
free_buf(output);
}