/**************************************************************************
* Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, *
* Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. *
* *
* Merc Diku Mud improvements copyright (C) 1992, 1993 by Michael *
* Chastain, Michael Quan, and Mitchell Tse. *
* *
* In order to use any part of this Merc Diku Mud, you must comply with *
* both the original Diku license in 'license.doc' as well the Merc *
* license in 'license.txt'. In particular, you may not remove either of *
* these copyright notices. *
* *
* Much time and thought has gone into this software and you are *
* benefiting. We hope that you share your changes too. What goes *
* around, comes around. *
***************************************************************************
* ROM 2.4 is copyright 1993-1998 Russ Taylor *
* ROM has been brought to you by the ROM consortium *
* Russ Taylor (rtaylor@hypercube.org) *
* Gabrielle Taylor (gtaylor@hypercube.org) *
* Brian Moore (zump@rom.org) *
* By using this code, you have agreed to follow the terms of the *
* ROM license, in the file Rom24/doc/rom.license *
***************************************************************************
* 1stMUD ROM Derivative (c) 2001-2002 by Ryan Jennings *
* http://1stmud.dlmud.com/ <r-jenn@shaw.ca> *
***************************************************************************/
#include <sys/types.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "merc.h"
#include "interp.h"
#include "magic.h"
#include "recycle.h"
#include "tables.h"
/*
* Local functions.
*/
void affect_modify args((CHAR_DATA * ch, AFFECT_DATA * paf, bool fAdd));
/* friend stuff -- for NPC's mostly */
bool is_friend(CHAR_DATA * ch, CHAR_DATA * victim)
{
if (is_same_group(ch, victim))
return TRUE;
if (!IS_NPC(ch))
return FALSE;
if (!IS_NPC(victim))
{
if (IS_SET(ch->off_flags, ASSIST_PLAYERS))
return TRUE;
else
return FALSE;
}
if (IS_AFFECTED(ch, AFF_CHARM))
return FALSE;
if (IS_SET(ch->off_flags, ASSIST_ALL))
return TRUE;
if (ch->group && ch->group == victim->group)
return TRUE;
if (IS_SET(ch->off_flags, ASSIST_VNUM) &&
ch->pIndexData == victim->pIndexData)
return TRUE;
if (IS_SET(ch->off_flags, ASSIST_RACE) && ch->race == victim->race)
return TRUE;
if (IS_SET(ch->off_flags, ASSIST_ALIGN) &&
!IS_SET(ch->act, ACT_NOALIGN) &&
!IS_SET(victim->act, ACT_NOALIGN) &&
((IS_GOOD(ch) && IS_GOOD(victim)) ||
(IS_EVIL(ch) && IS_EVIL(victim)) || (IS_NEUTRAL(ch) &&
IS_NEUTRAL(victim))))
return TRUE;
return FALSE;
}
/* returns number of people on an object */
int count_users(OBJ_DATA * obj)
{
CHAR_DATA *fch;
int count = 0;
if (obj->in_room == NULL)
return 0;
for (fch = obj->in_room->first_person; fch != NULL; fch = fch->next_in_room)
if (fch->on == obj)
count++;
return count;
}
/* returns material number */
int material_lookup(const char *name)
{
return 0;
}
int weapon_lookup(const char *name)
{
int type;
for (type = 0; weapon_table[type].name != NULL; type++)
{
if (LOWER(name[0]) == LOWER(weapon_table[type].name[0]) &&
!str_prefix(name, weapon_table[type].name))
return type;
}
return -1;
}
int weapon_typ(const char *name)
{
int type;
for (type = 0; weapon_table[type].name != NULL; type++)
{
if (LOWER(name[0]) == LOWER(weapon_table[type].name[0]) &&
!str_prefix(name, weapon_table[type].name))
return weapon_table[type].type;
}
return WEAPON_EXOTIC;
}
const char *item_name(int pitem_type)
{
int type;
for (type = 0; item_table[type].name != NULL; type++)
if (pitem_type == item_table[type].type)
return item_table[type].name;
return "none";
}
const char *weapon_name(int weapon_ptype)
{
int type;
for (type = 0; weapon_table[type].name != NULL; type++)
if (weapon_ptype == weapon_table[type].type)
return weapon_table[type].name;
return "exotic";
}
int attack_lookup(const char *name)
{
int att;
for (att = 0; attack_table[att].name != NULL; att++)
{
if (LOWER(name[0]) == LOWER(attack_table[att].name[0]) &&
!str_prefix(name, attack_table[att].name))
return att;
}
return 0;
}
/* returns a flag for wiznet */
int wiznet_lookup(const char *name)
{
int flag;
for (flag = 0; wiznet_table[flag].name != NULL; flag++)
{
if (LOWER(name[0]) == LOWER(wiznet_table[flag].name[0]) &&
!str_prefix(name, wiznet_table[flag].name))
return flag;
}
return -1;
}
/* returns class number */
int class_lookup(const char *name)
{
int Class;
for (Class = 0; Class < maxClass; Class++)
{
if (LOWER(name[0]) == LOWER(class_table[Class].name[0]) &&
!str_prefix(name, class_table[Class].name))
return Class;
}
return -1;
}
/* for immunity, vulnerabiltiy, and resistant
the 'globals' (magic and weapons) may be overriden
three other cases -- wood, silver, and iron -- are checked in fight.c */
int check_immune(CHAR_DATA * ch, int dam_type)
{
int immune, def;
int bit;
immune = -1;
def = IS_NORMAL;
if (dam_type == DAM_NONE)
return immune;
if (dam_type <= 3)
{
if (IS_SET(ch->imm_flags, IMM_WEAPON))
def = IS_IMMUNE;
else if (IS_SET(ch->res_flags, RES_WEAPON))
def = IS_RESISTANT;
else if (IS_SET(ch->vuln_flags, VULN_WEAPON))
def = IS_VULNERABLE;
}
else /* magical attack */
{
if (IS_SET(ch->imm_flags, IMM_MAGIC))
def = IS_IMMUNE;
else if (IS_SET(ch->res_flags, RES_MAGIC))
def = IS_RESISTANT;
else if (IS_SET(ch->vuln_flags, VULN_MAGIC))
def = IS_VULNERABLE;
}
/* set bits to check -- VULN etc. must ALL be the same or this will fail */
switch (dam_type)
{
case (DAM_BASH):
bit = IMM_BASH;
break;
case (DAM_PIERCE):
bit = IMM_PIERCE;
break;
case (DAM_SLASH):
bit = IMM_SLASH;
break;
case (DAM_FIRE):
bit = IMM_FIRE;
break;
case (DAM_COLD):
bit = IMM_COLD;
break;
case (DAM_LIGHTNING):
bit = IMM_LIGHTNING;
break;
case (DAM_ACID):
bit = IMM_ACID;
break;
case (DAM_POISON):
bit = IMM_POISON;
break;
case (DAM_NEGATIVE):
bit = IMM_NEGATIVE;
break;
case (DAM_HOLY):
bit = IMM_HOLY;
break;
case (DAM_ENERGY):
bit = IMM_ENERGY;
break;
case (DAM_MENTAL):
bit = IMM_MENTAL;
break;
case (DAM_DISEASE):
bit = IMM_DISEASE;
break;
case (DAM_DROWNING):
bit = IMM_DROWNING;
break;
case (DAM_LIGHT):
bit = IMM_LIGHT;
break;
case (DAM_CHARM):
bit = IMM_CHARM;
break;
case (DAM_SOUND):
bit = IMM_SOUND;
break;
default:
return def;
}
if (IS_SET(ch->imm_flags, bit))
immune = IS_IMMUNE;
else if (IS_SET(ch->res_flags, bit) && immune != IS_IMMUNE)
immune = IS_RESISTANT;
else if (IS_SET(ch->vuln_flags, bit))
{
if (immune == IS_IMMUNE)
immune = IS_RESISTANT;
else if (immune == IS_RESISTANT)
immune = IS_NORMAL;
else
immune = IS_VULNERABLE;
}
if (immune == -1)
return def;
else
return immune;
}
bool is_clan(CHAR_DATA * ch)
{
return ch->clan != NULL;
}
bool is_same_clan(CHAR_DATA * ch, CHAR_DATA * victim)
{
if (ch->clan == NULL || victim->clan == NULL
|| ch->clan->independent || victim->clan->independent)
return FALSE;
else
return (ch->clan == victim->clan);
}
/* checks mob format */
bool is_old_mob(CHAR_DATA * ch)
{
if (ch->pIndexData == NULL)
return FALSE;
else if (ch->pIndexData->new_format)
return FALSE;
return TRUE;
}
/* for returning skill information */
int get_skill(CHAR_DATA * ch, int sn)
{
int skill;
if (sn == -1) /* shorthand for level based skills */
{
skill = ch->level * 5 / 2;
}
else if (sn < -1 || sn > maxSkill)
{
bug("Bad sn %d in get_skill.", sn);
skill = 0;
}
else if (!IS_NPC(ch))
{
if (!can_use_skpell(ch, sn))
skill = 0;
else
skill = ch->pcdata->learned[sn];
}
else /* mobiles */
{
if (skill_table[sn].spell_fun != spell_null)
skill = 40 + 2 * ch->level;
else if (sn == gsn_sneak || sn == gsn_hide)
skill = ch->level * 2 + 20;
else if ((sn == gsn_dodge && IS_SET(ch->off_flags, OFF_DODGE))
|| (sn == gsn_parry && IS_SET(ch->off_flags, OFF_PARRY)))
skill = ch->level * 2;
else if (sn == gsn_shield_block)
skill = 10 + 2 * ch->level;
else if (sn == gsn_second_attack &&
(IS_SET(ch->act, ACT_WARRIOR) || IS_SET(ch->act, ACT_THIEF)))
skill = 10 + 3 * ch->level;
else if (sn == gsn_third_attack && IS_SET(ch->act, ACT_WARRIOR))
skill = 4 * ch->level - 40;
else if (sn == gsn_hand_to_hand)
skill = 40 + 2 * ch->level;
else if (sn == gsn_trip && IS_SET(ch->off_flags, OFF_TRIP))
skill = 10 + 3 * ch->level;
else if (sn == gsn_bash && IS_SET(ch->off_flags, OFF_BASH))
skill = 10 + 3 * ch->level;
else if (sn == gsn_disarm &&
(IS_SET(ch->off_flags, OFF_DISARM) ||
IS_SET(ch->act, ACT_WARRIOR) || IS_SET(ch->act, ACT_THIEF)))
skill = 20 + 3 * ch->level;
else if (sn == gsn_berserk && IS_SET(ch->off_flags, OFF_BERSERK))
skill = 3 * ch->level;
else if (sn == gsn_kick)
skill = 10 + 3 * ch->level;
else if (sn == gsn_backstab && IS_SET(ch->act, ACT_THIEF))
skill = 20 + 2 * ch->level;
else if (sn == gsn_rescue)
skill = 40 + ch->level;
else if (sn == gsn_recall)
skill = 40 + ch->level;
else if (sn == gsn_sword || sn == gsn_dagger || sn == gsn_spear ||
sn == gsn_mace || sn == gsn_axe || sn == gsn_flail ||
sn == gsn_whip || sn == gsn_polearm)
skill = 40 + 5 * ch->level / 2;
else
skill = 0;
}
if (ch->daze > 0)
{
if (skill_table[sn].spell_fun != spell_null)
skill /= 2;
else
skill = 2 * skill / 3;
}
if (!IS_NPC(ch) && ch->pcdata->condition[COND_DRUNK] > 10)
skill = 9 * skill / 10;
return URANGE(0, skill, 100);
}
/* for returning weapon information */
int get_weapon_sn(CHAR_DATA * ch)
{
OBJ_DATA *wield;
int sn;
wield = get_eq_char(ch, WEAR_WIELD);
if (wield == NULL || wield->item_type != ITEM_WEAPON)
sn = gsn_hand_to_hand;
else
switch (wield->value[0])
{
default:
sn = -1;
break;
case (WEAPON_SWORD):
sn = gsn_sword;
break;
case (WEAPON_DAGGER):
sn = gsn_dagger;
break;
case (WEAPON_SPEAR):
sn = gsn_spear;
break;
case (WEAPON_MACE):
sn = gsn_mace;
break;
case (WEAPON_AXE):
sn = gsn_axe;
break;
case (WEAPON_FLAIL):
sn = gsn_flail;
break;
case (WEAPON_WHIP):
sn = gsn_whip;
break;
case (WEAPON_POLEARM):
sn = gsn_polearm;
break;
}
return sn;
}
int get_weapon_skill(CHAR_DATA * ch, int sn)
{
int skill;
/* -1 is exotic */
if (IS_NPC(ch))
{
if (sn == -1)
skill = 3 * ch->level;
else if (sn == gsn_hand_to_hand)
skill = 40 + 2 * ch->level;
else
skill = 40 + 5 * ch->level / 2;
}
else
{
if (sn == -1)
skill = 3 * ch->level;
else
skill = ch->pcdata->learned[sn];
}
return URANGE(0, skill, 100);
}
/* used to de-screw characters */
void reset_char(CHAR_DATA * ch)
{
int loc, mod, stat;
OBJ_DATA *obj;
AFFECT_DATA *af;
int i;
if (IS_NPC(ch))
return;
if (ch->pcdata->perm_hit == 0 || ch->pcdata->perm_mana == 0 ||
ch->pcdata->perm_move == 0 || ch->pcdata->last_level == 0)
{
/* do a FULL reset */
for (loc = 0; loc < MAX_WEAR; loc++)
{
obj = get_eq_char(ch, loc);
if (obj == NULL)
continue;
if (!obj->enchanted)
for (af = obj->pIndexData->first_affect; af != NULL;
af = af->next)
{
mod = af->modifier;
switch (af->location)
{
case APPLY_SEX:
ch->sex -= mod;
if (ch->sex < 0 || ch->sex > 2)
ch->sex = IS_NPC(ch) ? 0 : ch->pcdata->true_sex;
break;
case APPLY_MANA:
ch->max_mana -= mod;
break;
case APPLY_HIT:
ch->max_hit -= mod;
break;
case APPLY_MOVE:
ch->max_move -= mod;
break;
}
}
for (af = obj->first_affect; af != NULL; af = af->next)
{
mod = af->modifier;
switch (af->location)
{
case APPLY_SEX:
ch->sex -= mod;
break;
case APPLY_MANA:
ch->max_mana -= mod;
break;
case APPLY_HIT:
ch->max_hit -= mod;
break;
case APPLY_MOVE:
ch->max_move -= mod;
break;
}
}
}
/* now reset the permanent stats */
ch->pcdata->perm_hit = ch->max_hit;
ch->pcdata->perm_mana = ch->max_mana;
ch->pcdata->perm_move = ch->max_move;
ch->pcdata->last_level = ch->played / 3600;
if (ch->pcdata->true_sex < 0 || ch->pcdata->true_sex > 2)
{
if (ch->sex > 0 && ch->sex < 3)
ch->pcdata->true_sex = ch->sex;
else
ch->pcdata->true_sex = 0;
}
}
/* now restore the character to his/her true condition */
for (stat = 0; stat < MAX_STATS; stat++)
ch->mod_stat[stat] = 0;
if (ch->pcdata->true_sex < 0 || ch->pcdata->true_sex > 2)
ch->pcdata->true_sex = 0;
ch->sex = ch->pcdata->true_sex;
ch->max_hit = ch->pcdata->perm_hit;
ch->max_mana = ch->pcdata->perm_mana;
ch->max_move = ch->pcdata->perm_move;
for (i = 0; i < 4; i++)
ch->armor[i] = 100;
ch->hitroll = 0;
ch->damroll = 0;
ch->saving_throw = 0;
/* now start adding back the effects */
for (loc = 0; loc < MAX_WEAR; loc++)
{
obj = get_eq_char(ch, loc);
if (obj == NULL)
continue;
for (i = 0; i < 4; i++)
ch->armor[i] -= apply_ac(obj, loc, i);
if (!obj->enchanted)
for (af = obj->pIndexData->first_affect; af != NULL; af = af->next)
{
mod = af->modifier;
switch (af->location)
{
case APPLY_STR:
ch->mod_stat[STAT_STR] += mod;
break;
case APPLY_DEX:
ch->mod_stat[STAT_DEX] += mod;
break;
case APPLY_INT:
ch->mod_stat[STAT_INT] += mod;
break;
case APPLY_WIS:
ch->mod_stat[STAT_WIS] += mod;
break;
case APPLY_CON:
ch->mod_stat[STAT_CON] += mod;
break;
case APPLY_SEX:
ch->sex += mod;
break;
case APPLY_MANA:
ch->max_mana += mod;
break;
case APPLY_HIT:
ch->max_hit += mod;
break;
case APPLY_MOVE:
ch->max_move += mod;
break;
case APPLY_AC:
for (i = 0; i < 4; i++)
ch->armor[i] += mod;
break;
case APPLY_HITROLL:
ch->hitroll += mod;
break;
case APPLY_DAMROLL:
ch->damroll += mod;
break;
case APPLY_SAVES:
ch->saving_throw += mod;
break;
case APPLY_SAVING_ROD:
ch->saving_throw += mod;
break;
case APPLY_SAVING_PETRI:
ch->saving_throw += mod;
break;
case APPLY_SAVING_BREATH:
ch->saving_throw += mod;
break;
case APPLY_SAVING_SPELL:
ch->saving_throw += mod;
break;
}
}
for (af = obj->first_affect; af != NULL; af = af->next)
{
mod = af->modifier;
switch (af->location)
{
case APPLY_STR:
ch->mod_stat[STAT_STR] += mod;
break;
case APPLY_DEX:
ch->mod_stat[STAT_DEX] += mod;
break;
case APPLY_INT:
ch->mod_stat[STAT_INT] += mod;
break;
case APPLY_WIS:
ch->mod_stat[STAT_WIS] += mod;
break;
case APPLY_CON:
ch->mod_stat[STAT_CON] += mod;
break;
case APPLY_SEX:
ch->sex += mod;
break;
case APPLY_MANA:
ch->max_mana += mod;
break;
case APPLY_HIT:
ch->max_hit += mod;
break;
case APPLY_MOVE:
ch->max_move += mod;
break;
case APPLY_AC:
for (i = 0; i < 4; i++)
ch->armor[i] += mod;
break;
case APPLY_HITROLL:
ch->hitroll += mod;
break;
case APPLY_DAMROLL:
ch->damroll += mod;
break;
case APPLY_SAVES:
ch->saving_throw += mod;
break;
case APPLY_SAVING_ROD:
ch->saving_throw += mod;
break;
case APPLY_SAVING_PETRI:
ch->saving_throw += mod;
break;
case APPLY_SAVING_BREATH:
ch->saving_throw += mod;
break;
case APPLY_SAVING_SPELL:
ch->saving_throw += mod;
break;
}
}
}
/* now add back spell effects */
for (af = ch->first_affect; af != NULL; af = af->next)
{
mod = af->modifier;
switch (af->location)
{
case APPLY_STR:
ch->mod_stat[STAT_STR] += mod;
break;
case APPLY_DEX:
ch->mod_stat[STAT_DEX] += mod;
break;
case APPLY_INT:
ch->mod_stat[STAT_INT] += mod;
break;
case APPLY_WIS:
ch->mod_stat[STAT_WIS] += mod;
break;
case APPLY_CON:
ch->mod_stat[STAT_CON] += mod;
break;
case APPLY_SEX:
ch->sex += mod;
break;
case APPLY_MANA:
ch->max_mana += mod;
break;
case APPLY_HIT:
ch->max_hit += mod;
break;
case APPLY_MOVE:
ch->max_move += mod;
break;
case APPLY_AC:
for (i = 0; i < 4; i++)
ch->armor[i] += mod;
break;
case APPLY_HITROLL:
ch->hitroll += mod;
break;
case APPLY_DAMROLL:
ch->damroll += mod;
break;
case APPLY_SAVES:
ch->saving_throw += mod;
break;
case APPLY_SAVING_ROD:
ch->saving_throw += mod;
break;
case APPLY_SAVING_PETRI:
ch->saving_throw += mod;
break;
case APPLY_SAVING_BREATH:
ch->saving_throw += mod;
break;
case APPLY_SAVING_SPELL:
ch->saving_throw += mod;
break;
}
}
/* make sure sex is RIGHT!!!! */
if (ch->sex < 0 || ch->sex > 2)
ch->sex = ch->pcdata->true_sex;
}
/*
* Retrieve a character's trusted level for permission checking.
*/
int get_trust(CHAR_DATA * ch)
{
if (ch->desc != NULL && ch->desc->original != NULL)
ch = ch->desc->original;
if (ch->trust)
return ch->trust;
if (IS_NPC(ch) && ch->level >= LEVEL_HERO)
return LEVEL_HERO - 1;
else
return ch->level;
}
/*
* Retrieve a character's age.
*/
int get_age(CHAR_DATA * ch)
{
return 17 + (ch->played + (int) (current_time - ch->logon)) / 72000;
}
/* command for retrieving stats */
int get_curr_stat(CHAR_DATA * ch, int stat)
{
int max;
if (IS_NPC(ch) || ch->level > LEVEL_IMMORTAL)
max = 25;
else
{
max = ch->race->max_stats[stat] + 4;
if (is_prime_stat(ch, stat))
max += 2;
if (ch->race == race_lookup("human"))
max += 1;
max = UMIN(max, 25);
}
return URANGE(3, ch->perm_stat[stat] + ch->mod_stat[stat], max);
}
/* command for returning max training score */
int get_max_train(CHAR_DATA * ch, int stat)
{
int max;
if (IS_NPC(ch) || ch->level > LEVEL_IMMORTAL)
return 25;
max = ch->race->max_stats[stat];
if (is_prime_stat(ch, stat))
{
if (ch->race == race_lookup("human"))
max += 3;
else
max += 2;
}
return UMIN(max, 25);
}
/*
* Retrieve a character's carry capacity.
*/
int can_carry_n(CHAR_DATA * ch)
{
if (!IS_NPC(ch) && ch->level >= LEVEL_IMMORTAL)
return 1000;
if (IS_NPC(ch) && IS_SET(ch->act, ACT_PET))
return 0;
return MAX_WEAR + 2 * get_curr_stat(ch, STAT_DEX) + ch->level;
}
/*
* Retrieve a character's carry capacity.
*/
int can_carry_w(CHAR_DATA * ch)
{
if (!IS_NPC(ch) && ch->level >= LEVEL_IMMORTAL)
return 10000000;
if (IS_NPC(ch) && IS_SET(ch->act, ACT_PET))
return 0;
return str_app[get_curr_stat(ch, STAT_STR)].carry * 10 + ch->level * 25;
}
/*
* See if a string is one of the names of an object.
*/
bool is_name(const char *str, const char *namelist)
{
char name[MAX_INPUT_LENGTH], part[MAX_INPUT_LENGTH];
const char *list, *string;
/* fix crash on NULL namelist */
if (namelist == NULL || namelist[0] == '\0')
return FALSE;
/* fixed to prevent is_name on "" returning TRUE */
if (str[0] == '\0')
return FALSE;
string = str;
/* we need ALL parts of string to match part of namelist */
for (;;) /* start parsing string */
{
str = one_argument(str, part);
if (part[0] == '\0')
return TRUE;
/* check to see if this is part of namelist */
list = namelist;
for (;;) /* start parsing namelist */
{
list = one_argument(list, name);
if (name[0] == '\0') /* this name was not found */
return FALSE;
if (!str_prefix(string, name))
return TRUE; /* full pattern match */
if (!str_prefix(part, name))
break;
}
}
}
bool is_exact_name(const char *str, const char *namelist)
{
char name[MAX_INPUT_LENGTH];
if (namelist == NULL)
return FALSE;
for (;;)
{
namelist = one_argument(namelist, name);
if (name[0] == '\0')
return FALSE;
if (!str_cmp(str, name))
return TRUE;
}
}
/* enchanted stuff for eq */
void affect_enchant(OBJ_DATA * obj)
{
/* okay, move all the old flags into new vectors if we have to */
if (!obj->enchanted)
{
AFFECT_DATA *paf, *af_new;
obj->enchanted = TRUE;
for (paf = obj->pIndexData->first_affect; paf != NULL; paf = paf->next)
{
af_new = new_affect();
LINK(af_new, obj->first_affect, obj->last_affect, next, prev);
af_new->where = paf->where;
af_new->type = UMAX(0, paf->type);
af_new->level = paf->level;
af_new->duration = paf->duration;
af_new->location = paf->location;
af_new->modifier = paf->modifier;
af_new->bitvector = paf->bitvector;
}
}
}
/*
* Apply or remove an affect to a character.
*/
void affect_modify(CHAR_DATA * ch, AFFECT_DATA * paf, bool fAdd)
{
OBJ_DATA *wield;
int mod, i;
mod = paf->modifier;
if (fAdd)
{
switch (paf->where)
{
case TO_AFFECTS:
SET_BIT(ch->affected_by, paf->bitvector);
break;
case TO_IMMUNE:
SET_BIT(ch->imm_flags, paf->bitvector);
break;
case TO_RESIST:
SET_BIT(ch->res_flags, paf->bitvector);
break;
case TO_VULN:
SET_BIT(ch->vuln_flags, paf->bitvector);
break;
}
}
else
{
switch (paf->where)
{
case TO_AFFECTS:
REMOVE_BIT(ch->affected_by, paf->bitvector);
break;
case TO_IMMUNE:
REMOVE_BIT(ch->imm_flags, paf->bitvector);
break;
case TO_RESIST:
REMOVE_BIT(ch->res_flags, paf->bitvector);
break;
case TO_VULN:
REMOVE_BIT(ch->vuln_flags, paf->bitvector);
break;
}
mod = 0 - mod;
}
switch (paf->location)
{
default:
bug("Affect_modify: unknown location %d.", paf->location);
return;
case APPLY_NONE:
break;
case APPLY_STR:
ch->mod_stat[STAT_STR] += mod;
break;
case APPLY_DEX:
ch->mod_stat[STAT_DEX] += mod;
break;
case APPLY_INT:
ch->mod_stat[STAT_INT] += mod;
break;
case APPLY_WIS:
ch->mod_stat[STAT_WIS] += mod;
break;
case APPLY_CON:
ch->mod_stat[STAT_CON] += mod;
break;
case APPLY_SEX:
ch->sex += mod;
break;
case APPLY_CLASS:
break;
case APPLY_LEVEL:
break;
case APPLY_AGE:
break;
case APPLY_HEIGHT:
break;
case APPLY_WEIGHT:
break;
case APPLY_MANA:
ch->max_mana += mod;
break;
case APPLY_HIT:
ch->max_hit += mod;
break;
case APPLY_MOVE:
ch->max_move += mod;
break;
case APPLY_GOLD:
break;
case APPLY_EXP:
break;
case APPLY_AC:
for (i = 0; i < 4; i++)
ch->armor[i] += mod;
break;
case APPLY_HITROLL:
ch->hitroll += mod;
break;
case APPLY_DAMROLL:
ch->damroll += mod;
break;
case APPLY_SAVES:
ch->saving_throw += mod;
break;
case APPLY_SAVING_ROD:
ch->saving_throw += mod;
break;
case APPLY_SAVING_PETRI:
ch->saving_throw += mod;
break;
case APPLY_SAVING_BREATH:
ch->saving_throw += mod;
break;
case APPLY_SAVING_SPELL:
ch->saving_throw += mod;
break;
case APPLY_SPELL_AFFECT:
break;
}
/*
* Check for weapon wielding.
* Guard against recursion (for weapons with affects).
*/
if (!IS_NPC(ch) && (wield = get_eq_char(ch, WEAR_WIELD)) != NULL
&& get_obj_weight(wield) >
(str_app[get_curr_stat(ch, STAT_STR)].wield * 10))
{
static int depth;
if (depth == 0)
{
depth++;
act("You drop $p.", ch, wield, NULL, TO_CHAR);
act("$n drops $p.", ch, wield, NULL, TO_ROOM);
obj_from_char(wield);
obj_to_room(wield, ch->in_room);
depth--;
}
}
return;
}
/* find an effect in an affect list */
AFFECT_DATA *affect_find(AFFECT_DATA * paf, int sn)
{
AFFECT_DATA *paf_find;
for (paf_find = paf; paf_find != NULL; paf_find = paf_find->next)
{
if (paf_find->type == sn)
return paf_find;
}
return NULL;
}
/* fix object affects when removing one */
void affect_check(CHAR_DATA * ch, int where, flag_t vector)
{
AFFECT_DATA *paf;
OBJ_DATA *obj;
if (where == TO_OBJECT || where == TO_WEAPON || vector == 0)
return;
for (paf = ch->first_affect; paf != NULL; paf = paf->next)
if (paf->where == where && paf->bitvector == vector)
{
switch (where)
{
case TO_AFFECTS:
SET_BIT(ch->affected_by, vector);
break;
case TO_IMMUNE:
SET_BIT(ch->imm_flags, vector);
break;
case TO_RESIST:
SET_BIT(ch->res_flags, vector);
break;
case TO_VULN:
SET_BIT(ch->vuln_flags, vector);
break;
}
return;
}
for (obj = ch->first_carrying; obj != NULL; obj = obj->next_content)
{
if (obj->wear_loc == -1)
continue;
for (paf = obj->first_affect; paf != NULL; paf = paf->next)
if (paf->where == where && paf->bitvector == vector)
{
switch (where)
{
case TO_AFFECTS:
SET_BIT(ch->affected_by, vector);
break;
case TO_IMMUNE:
SET_BIT(ch->imm_flags, vector);
break;
case TO_RESIST:
SET_BIT(ch->res_flags, vector);
break;
case TO_VULN:
SET_BIT(ch->vuln_flags, vector);
}
return;
}
if (obj->enchanted)
continue;
for (paf = obj->pIndexData->first_affect; paf != NULL; paf = paf->next)
if (paf->where == where && paf->bitvector == vector)
{
switch (where)
{
case TO_AFFECTS:
SET_BIT(ch->affected_by, vector);
break;
case TO_IMMUNE:
SET_BIT(ch->imm_flags, vector);
break;
case TO_RESIST:
SET_BIT(ch->res_flags, vector);
break;
case TO_VULN:
SET_BIT(ch->vuln_flags, vector);
break;
}
return;
}
}
}
/*
* Give an affect to a char.
*/
void affect_to_char(CHAR_DATA * ch, AFFECT_DATA * paf)
{
AFFECT_DATA *paf_new;
paf_new = new_affect();
*paf_new = *paf;
VALIDATE(paf_new); /* in case we missed it when we set up paf */
LINK(paf_new, ch->first_affect, ch->last_affect, next, prev);
affect_modify(ch, paf_new, TRUE);
return;
}
/* give an affect to an object */
void affect_to_obj(OBJ_DATA * obj, AFFECT_DATA * paf)
{
AFFECT_DATA *paf_new;
paf_new = new_affect();
*paf_new = *paf;
VALIDATE(paf_new); /* in case we missed it when we set up paf */
LINK(paf_new, obj->first_affect, obj->last_affect, next, prev);
/* apply any affect vectors to the object's extra_flags */
if (paf->bitvector)
switch (paf->where)
{
case TO_OBJECT:
SET_BIT(obj->extra_flags, paf->bitvector);
break;
case TO_WEAPON:
if (obj->item_type == ITEM_WEAPON)
SET_BIT(obj->value[4], paf->bitvector);
break;
}
return;
}
/*
* Remove an affect from a char.
*/
void affect_remove(CHAR_DATA * ch, AFFECT_DATA * paf)
{
int where;
flag_t vector;
if (ch->first_affect == NULL)
{
bug("Affect_remove: no affect.", 0);
return;
}
affect_modify(ch, paf, FALSE);
where = paf->where;
vector = paf->bitvector;
UNLINK(paf, ch->first_affect, ch->last_affect, next, prev);
free_affect(paf);
affect_check(ch, where, vector);
return;
}
void affect_remove_obj(OBJ_DATA * obj, AFFECT_DATA * paf)
{
int where;
flag_t vector;
if (obj->first_affect == NULL)
{
bug("Affect_remove_object: no affect.", 0);
return;
}
if (obj->carried_by != NULL && obj->wear_loc != -1)
affect_modify(obj->carried_by, paf, FALSE);
where = paf->where;
vector = paf->bitvector;
/* remove flags from the object if needed */
if (paf->bitvector)
switch (paf->where)
{
case TO_OBJECT:
REMOVE_BIT(obj->extra_flags, paf->bitvector);
break;
case TO_WEAPON:
if (obj->item_type == ITEM_WEAPON)
REMOVE_BIT(obj->value[4], paf->bitvector);
break;
}
UNLINK(paf, obj->first_affect, obj->last_affect, next, prev);
free_affect(paf);
if (obj->carried_by != NULL && obj->wear_loc != -1)
affect_check(obj->carried_by, where, vector);
return;
}
/*
* Strip all affects of a given sn.
*/
void affect_strip(CHAR_DATA * ch, int sn)
{
AFFECT_DATA *paf;
AFFECT_DATA *paf_next;
for (paf = ch->first_affect; paf != NULL; paf = paf_next)
{
paf_next = paf->next;
if (paf->type == sn)
affect_remove(ch, paf);
}
return;
}
/*
* Return true if a char is affected by a spell.
*/
bool is_affected(CHAR_DATA * ch, int sn)
{
AFFECT_DATA *paf;
for (paf = ch->first_affect; paf != NULL; paf = paf->next)
{
if (paf->type == sn)
return TRUE;
}
return FALSE;
}
/*
* Add or enhance an affect.
*/
void affect_join(CHAR_DATA * ch, AFFECT_DATA * paf)
{
AFFECT_DATA *paf_old;
bool found;
found = FALSE;
for (paf_old = ch->first_affect; paf_old != NULL; paf_old = paf_old->next)
{
if (paf_old->type == paf->type)
{
paf->level = (paf->level += paf_old->level) / 2;
paf->duration += paf_old->duration;
paf->modifier += paf_old->modifier;
affect_remove(ch, paf_old);
break;
}
}
affect_to_char(ch, paf);
return;
}
/*
* Move a char out of a room.
*/
void char_from_room(CHAR_DATA * ch)
{
OBJ_DATA *obj;
if (ch->in_room == NULL)
{
bug("Char_from_room: NULL.", 0);
return;
}
if (!IS_NPC(ch))
--ch->in_room->area->nplayer;
if ((obj = get_eq_char(ch, WEAR_LIGHT)) != NULL &&
obj->item_type == ITEM_LIGHT && obj->value[2] != 0 &&
ch->in_room->light > 0)
--ch->in_room->light;
UNLINK(ch, ch->in_room->first_person, ch->in_room->last_person,
next_in_room, prev_in_room);
ch->in_room = NULL;
ch->next_in_room = NULL;
ch->on = NULL; /* sanity check! */
return;
}
/*
* Move a char into a room.
*/
void char_to_room(CHAR_DATA * ch, ROOM_INDEX_DATA * pRoomIndex)
{
OBJ_DATA *obj;
if (pRoomIndex == NULL)
{
ROOM_INDEX_DATA *room;
bug("Char_to_room: NULL.", 0);
if ((room = get_room_index(ROOM_VNUM_TEMPLE)) != NULL)
char_to_room(ch, room);
return;
}
ch->in_room = pRoomIndex;
LINK(ch, pRoomIndex->first_person, pRoomIndex->last_person, next_in_room,
prev_in_room);
if (!IS_NPC(ch))
{
if (ch->in_room->area->empty)
{
ch->in_room->area->empty = FALSE;
ch->in_room->area->age = 0;
}
++ch->in_room->area->nplayer;
if (!IS_SET(ch->in_room->room_flags, ROOM_NOEXPLORE))
STR_SET_BIT(ch->pcdata->explored, ch->in_room->vnum);
}
if ((obj = get_eq_char(ch, WEAR_LIGHT)) != NULL &&
obj->item_type == ITEM_LIGHT && obj->value[2] != 0)
++ch->in_room->light;
if (IS_AFFECTED(ch, AFF_PLAGUE))
{
AFFECT_DATA *af, plague;
CHAR_DATA *vch;
for (af = ch->first_affect; af != NULL; af = af->next)
{
if (af->type == gsn_plague)
break;
}
if (af == NULL)
{
REMOVE_BIT(ch->affected_by, AFF_PLAGUE);
return;
}
if (af->level == 1)
return;
plague.where = TO_AFFECTS;
plague.type = gsn_plague;
plague.level = af->level - 1;
plague.duration = number_range(1, 2 * plague.level);
plague.location = APPLY_STR;
plague.modifier = -5;
plague.bitvector = AFF_PLAGUE;
for (vch = ch->in_room->first_person; vch != NULL;
vch = vch->next_in_room)
{
if (!saves_spell(plague.level - 2, vch, DAM_DISEASE) &&
!IS_IMMORTAL(vch) && !IS_AFFECTED(vch, AFF_PLAGUE)
&& number_bits(6) == 0)
{
chprintln(vch, "You feel hot and feverish.");
act("$n shivers and looks very ill.", vch, NULL, NULL, TO_ROOM);
affect_join(vch, &plague);
}
}
}
return;
}
void link_obj_to_char(CHAR_DATA * ch, OBJ_DATA * obj)
{
OBJ_DATA *otmp;
if (!IS_NPC(ch) || !ch->pIndexData->pShop)
{
LINK(obj, ch->first_carrying, ch->last_carrying, next_content,
prev_content);
return;
}
for (otmp = ch->first_carrying; otmp; otmp = otmp->next_content)
{
if (obj->pIndexData == otmp->pIndexData &&
!str_cmp(obj->short_descr, otmp->short_descr))
{
/* if this is an unlimited item, destroy the new one */
if (IS_OBJ_STAT(otmp, ITEM_INVENTORY))
{
extract_obj(obj);
return;
}
obj->cost = otmp->cost; /* keep it standard */
}
if (obj->level > otmp->level)
{
INSERT(obj, otmp, ch->first_carrying, next_content, prev_content);
break;
}
else if (obj->level == otmp->level
&& !str_cmp(obj->short_descr, otmp->short_descr))
{
INSERT(obj, otmp, ch->first_carrying, next_content, prev_content);
break;
}
}
if (!otmp)
LINK(obj, ch->first_carrying, ch->last_carrying, next_content,
prev_content);
}
/*
* Give an obj to a char.
*/
void obj_to_char(OBJ_DATA * obj, CHAR_DATA * ch)
{
link_obj_to_char(ch, obj);
obj->carried_by = ch;
obj->in_room = NULL;
obj->in_obj = NULL;
ch->carry_number += get_obj_number(obj);
ch->carry_weight += get_obj_weight(obj);
if (!IS_NPC(ch) && IS_OBJ_STAT(obj, ITEM_QUEST))
update_questobjs(ch, obj);
if (obj->item_type == ITEM_CORPSE_PC)
update_corpses(obj, FALSE);
}
/*
* Take an obj from its character.
*/
void obj_from_char(OBJ_DATA * obj)
{
CHAR_DATA *ch;
if ((ch = obj->carried_by) == NULL)
{
bug("Obj_from_char: null ch.", 0);
return;
}
if (obj->wear_loc != WEAR_NONE)
unequip_char(ch, obj);
UNLINK(obj, ch->first_carrying, ch->last_carrying, next_content,
prev_content);
obj->carried_by = NULL;
obj->next_content = NULL;
ch->carry_number -= get_obj_number(obj);
ch->carry_weight -= get_obj_weight(obj);
return;
}
/*
* Find the ac value of an obj, including position effect.
*/
int apply_ac(OBJ_DATA * obj, int iWear, int type)
{
if (obj->item_type != ITEM_ARMOR)
return 0;
switch (iWear)
{
case WEAR_BODY:
return 3 * obj->value[type];
case WEAR_HEAD:
return 2 * obj->value[type];
case WEAR_LEGS:
return 2 * obj->value[type];
case WEAR_FEET:
return obj->value[type];
case WEAR_HANDS:
return obj->value[type];
case WEAR_ARMS:
return obj->value[type];
case WEAR_SHIELD:
return obj->value[type];
case WEAR_NECK_1:
return obj->value[type];
case WEAR_NECK_2:
return obj->value[type];
case WEAR_ABOUT:
return 2 * obj->value[type];
case WEAR_WAIST:
return obj->value[type];
case WEAR_WRIST_L:
return obj->value[type];
case WEAR_WRIST_R:
return obj->value[type];
case WEAR_HOLD:
return obj->value[type];
}
return 0;
}
/*
* Find a piece of eq on a character.
*/
OBJ_DATA *get_eq_char(CHAR_DATA * ch, int iWear)
{
OBJ_DATA *obj;
if (ch == NULL)
return NULL;
for (obj = ch->first_carrying; obj != NULL; obj = obj->next_content)
{
if (obj->wear_loc == iWear)
return obj;
}
return NULL;
}
/*
* Equip a char with an obj.
*/
void equip_char(CHAR_DATA * ch, OBJ_DATA * obj, int iWear)
{
AFFECT_DATA *paf;
int i;
if (get_eq_char(ch, iWear) != NULL)
{
bug("Equip_char: already equipped (%d).", iWear);
return;
}
if ((IS_OBJ_STAT(obj, ITEM_ANTI_EVIL) && IS_EVIL(ch)) ||
(IS_OBJ_STAT(obj, ITEM_ANTI_GOOD) && IS_GOOD(ch)) ||
(IS_OBJ_STAT(obj, ITEM_ANTI_NEUTRAL) && IS_NEUTRAL(ch)))
{
/*
* Thanks to Morgenes for the bug fix here!
*/
act("You are zapped by $p and drop it.", ch, obj, NULL, TO_CHAR);
act("$n is zapped by $p and drops it.", ch, obj, NULL, TO_ROOM);
obj_from_char(obj);
obj_to_room(obj, ch->in_room);
return;
}
for (i = 0; i < 4; i++)
ch->armor[i] -= apply_ac(obj, iWear, i);
obj->wear_loc = iWear;
if (!obj->enchanted)
for (paf = obj->pIndexData->first_affect; paf != NULL; paf = paf->next)
if (paf->location != APPLY_SPELL_AFFECT)
affect_modify(ch, paf, TRUE);
for (paf = obj->first_affect; paf != NULL; paf = paf->next)
if (paf->location == APPLY_SPELL_AFFECT)
affect_to_char(ch, paf);
else
affect_modify(ch, paf, TRUE);
if (obj->item_type == ITEM_LIGHT && obj->value[2] != 0 &&
ch->in_room != NULL)
++ch->in_room->light;
return;
}
/*
* Unequip a char with an obj.
*/
void unequip_char(CHAR_DATA * ch, OBJ_DATA * obj)
{
AFFECT_DATA *paf = NULL;
AFFECT_DATA *lpaf = NULL;
AFFECT_DATA *lpaf_next = NULL;
int i;
if (obj->wear_loc == WEAR_NONE)
{
bug("Unequip_char: already unequipped.", 0);
return;
}
for (i = 0; i < 4; i++)
ch->armor[i] += apply_ac(obj, obj->wear_loc, i);
obj->wear_loc = -1;
if (!obj->enchanted)
{
for (paf = obj->pIndexData->first_affect; paf != NULL; paf = paf->next)
if (paf->location == APPLY_SPELL_AFFECT)
{
for (lpaf = ch->first_affect; lpaf != NULL; lpaf = lpaf_next)
{
lpaf_next = lpaf->next;
if ((lpaf->type == paf->type) &&
(lpaf->level == paf->level) &&
(lpaf->location == APPLY_SPELL_AFFECT))
{
affect_remove(ch, lpaf);
lpaf_next = NULL;
}
}
}
else
{
affect_modify(ch, paf, FALSE);
affect_check(ch, paf->where, paf->bitvector);
}
}
for (paf = obj->first_affect; paf != NULL; paf = paf->next)
if (paf->location == APPLY_SPELL_AFFECT)
{
bug("Norm-Apply: %d", 0);
for (lpaf = ch->first_affect; lpaf != NULL; lpaf = lpaf_next)
{
lpaf_next = lpaf->next;
if ((lpaf->type == paf->type) &&
(lpaf->level == paf->level) &&
(lpaf->location == APPLY_SPELL_AFFECT))
{
bug("location = %d", lpaf->location);
bug("type = %d", lpaf->type);
affect_remove(ch, lpaf);
lpaf_next = NULL;
}
}
}
else
{
affect_modify(ch, paf, FALSE);
affect_check(ch, paf->where, paf->bitvector);
}
if (obj->item_type == ITEM_LIGHT && obj->value[2] != 0 &&
ch->in_room != NULL && ch->in_room->light > 0)
--ch->in_room->light;
return;
}
/*
* Count occurrences of an obj in a list.
*/
int count_obj_list(OBJ_INDEX_DATA * pObjIndex, OBJ_DATA * list)
{
OBJ_DATA *obj;
int nMatch;
nMatch = 0;
for (obj = list; obj != NULL; obj = obj->next_content)
{
if (obj->pIndexData == pObjIndex)
nMatch++;
}
return nMatch;
}
/*
* Move an obj out of a room.
*/
void obj_from_room(OBJ_DATA * obj)
{
ROOM_INDEX_DATA *in_room;
CHAR_DATA *ch;
if ((in_room = obj->in_room) == NULL)
{
bug("obj_from_room: NULL.", 0);
return;
}
for (ch = in_room->first_person; ch != NULL; ch = ch->next_in_room)
if (ch->on == obj)
ch->on = NULL;
UNLINK(obj, in_room->first_content, in_room->last_content, next_content,
prev_content);
obj->in_room = NULL;
obj->next_content = NULL;
return;
}
/*
* Move an obj into a room.
*/
void obj_to_room(OBJ_DATA * obj, ROOM_INDEX_DATA * pRoomIndex)
{
if (IS_OBJ_STAT(obj, ITEM_AUCTIONED))
return;
LINK(obj, pRoomIndex->first_content, pRoomIndex->last_content, next_content,
prev_content);
obj->in_room = pRoomIndex;
obj->carried_by = NULL;
obj->in_obj = NULL;
if (obj->item_type == ITEM_CORPSE_PC)
update_corpses(obj, FALSE);
return;
}
/*
* Move an object into an object.
*/
void obj_to_obj(OBJ_DATA * obj, OBJ_DATA * obj_to)
{
if (IS_OBJ_STAT(obj, ITEM_AUCTIONED))
return;
LINK(obj, obj_to->first_content, obj_to->last_content, next_content,
prev_content);
obj->in_obj = obj_to;
obj->in_room = NULL;
obj->carried_by = NULL;
if (obj_to->pIndexData->vnum == OBJ_VNUM_PIT)
obj->cost = 0;
if (obj_to->item_type == ITEM_CORPSE_PC)
update_corpses(obj_to, FALSE);
if (obj->item_type == ITEM_CORPSE_PC)
update_corpses(obj, FALSE);
for (; obj_to != NULL; obj_to = obj_to->in_obj)
{
if (obj_to->carried_by != NULL)
{
obj_to->carried_by->carry_number += get_obj_number(obj);
obj_to->carried_by->carry_weight +=
get_obj_weight(obj) * WEIGHT_MULT(obj_to) / 100;
}
}
return;
}
/*
* Move an object out of an object.
*/
void obj_from_obj(OBJ_DATA * obj)
{
OBJ_DATA *obj_from;
if ((obj_from = obj->in_obj) == NULL)
{
bug("Obj_from_obj: null obj_from.", 0);
return;
}
UNLINK(obj, obj_from->first_content, obj_from->last_content, next_content,
prev_content);
obj->next_content = NULL;
obj->in_obj = NULL;
if (obj_from->item_type == ITEM_CORPSE_PC)
update_corpses(obj_from, FALSE);
for (; obj_from != NULL; obj_from = obj_from->in_obj)
{
if (obj_from->carried_by != NULL)
{
obj_from->carried_by->carry_number -= get_obj_number(obj);
obj_from->carried_by->carry_weight -=
get_obj_weight(obj) * WEIGHT_MULT(obj_from) / 100;
}
}
return;
}
/*
* Extract an obj from the world.
*/
void extract_obj(OBJ_DATA * obj)
{
OBJ_DATA *obj_content;
OBJ_DATA *obj_next;
if (obj->in_room != NULL)
obj_from_room(obj);
else if (obj->carried_by != NULL)
obj_from_char(obj);
else if (obj->in_obj != NULL)
obj_from_obj(obj);
for (obj_content = obj->first_content; obj_content; obj_content = obj_next)
{
obj_next = obj_content->next_content;
extract_obj(obj_content);
}
UNLINK(obj, object_first, object_last, next, prev);
if (obj->item_type == ITEM_CORPSE_PC)
update_corpses(obj, TRUE);
--obj->pIndexData->count;
free_obj(obj);
return;
}
/*
* Extract a char from the world.
*/
void extract_char(CHAR_DATA * ch, bool fPull)
{
CHAR_DATA *wch;
OBJ_DATA *obj;
OBJ_DATA *obj_next;
/* doesn't seem to be necessary
if ( ch->in_room == NULL )
{
bug( "Extract_char: NULL.", 0 );
return;
}
*/
nuke_pets(ch);
ch->pet = NULL; /* just in case */
if (fPull)
{
if (IS_IN_WAR(ch))
return;
if (has_auction(ch))
{
bugf("%s has stake in an auction!", ch->name);
extract_auc(ch);
}
die_follower(ch);
}
stop_fighting(ch, TRUE);
for (obj = ch->first_carrying; obj != NULL; obj = obj_next)
{
obj_next = obj->next_content;
extract_obj(obj);
}
if (ch->in_room != NULL)
char_from_room(ch);
/* Death room is set in the clan tabe now */
if (!fPull)
{
ROOM_INDEX_DATA *room = NULL;
if (is_clan(ch))
room = get_room_index(ch->clan->hall);
if (room == NULL)
room = get_room_index(ROOM_VNUM_ALTAR);
char_to_room(ch, room);
return;
}
if (IS_NPC(ch))
--ch->pIndexData->count;
if (ch->desc != NULL && ch->desc->original != NULL)
{
do_function(ch, &do_return, "");
ch->desc = NULL;
}
for (wch = char_first; wch != NULL; wch = wch->next)
{
if (wch->reply == ch)
wch->reply = NULL;
if (ch->mprog_target == wch)
wch->mprog_target = NULL;
}
UNLINK(ch, char_first, char_last, next, prev);
if (!IS_NPC(ch))
UNLINK(ch, player_first, player_last, next, prev);
if (ch->desc != NULL)
ch->desc->character = NULL;
free_char(ch);
return;
}
/*
* Find a char in the room.
*/
CHAR_DATA *get_char_room(CHAR_DATA * ch, ROOM_INDEX_DATA * room,
const char *argument)
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *rch;
int number;
int count;
number = number_argument(argument, arg);
count = 0;
if (!str_cmp(arg, "self"))
return ch;
if (ch && room)
{
bug("get_char_room received multiple types (ch/room)", 0);
return NULL;
}
if (ch)
rch = ch->in_room->first_person;
else
rch = room->first_person;
for (; rch != NULL; rch = rch->next_in_room)
{
if ((ch && !can_see(ch, rch)) || !is_name(arg, rch->name))
continue;
if (++count == number)
return rch;
}
return NULL;
}
/*
* Find a char in the world.
*/
CHAR_DATA *get_char_world(CHAR_DATA * ch, const char *argument)
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *wch;
int number;
int count;
if (ch && (wch = get_char_room(ch, NULL, argument)) != NULL)
return wch;
number = number_argument(argument, arg);
count = 0;
for (wch = char_first; wch != NULL; wch = wch->next)
{
if (wch->in_room == NULL || (ch && !can_see(ch, wch))
|| !is_name(arg, wch->name))
continue;
if (++count == number)
return wch;
}
return NULL;
}
/*
* Find some object with a given index data.
* Used by area-reset 'P' command.
*/
OBJ_DATA *get_obj_type(OBJ_INDEX_DATA * pObjIndex)
{
OBJ_DATA *obj;
for (obj = object_first; obj != NULL; obj = obj->next)
{
if (obj->pIndexData == pObjIndex)
return obj;
}
return NULL;
}
/*
* Find an obj in a list.
*/
OBJ_DATA *get_obj_list(CHAR_DATA * ch, const char *argument, OBJ_DATA * list)
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int number;
int count;
number = number_argument(argument, arg);
count = 0;
for (obj = list; obj != NULL; obj = obj->next_content)
{
if (can_see_obj(ch, obj) && is_name(arg, obj->name))
{
if (++count == number)
return obj;
}
}
return NULL;
}
/*
* Find an obj in player's inventory.
*/
OBJ_DATA *get_obj_carry(CHAR_DATA * ch, const char *argument,
CHAR_DATA * viewer)
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int number;
int count;
number = number_argument(argument, arg);
count = 0;
for (obj = ch->first_carrying; obj != NULL; obj = obj->next_content)
{
if (obj->wear_loc == WEAR_NONE
&& (viewer ? can_see_obj(viewer, obj) : TRUE)
&& is_name(arg, obj->name))
{
if (++count == number)
return obj;
}
}
return NULL;
}
/*
* Find an obj in player's equipment.
*/
OBJ_DATA *get_obj_wear(CHAR_DATA * ch, const char *argument, bool character)
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int number;
int count;
number = number_argument(argument, arg);
count = 0;
for (obj = ch->first_carrying; obj != NULL; obj = obj->next_content)
{
if (obj->wear_loc != WEAR_NONE
&& (character ? can_see_obj(ch, obj) : TRUE)
&& is_name(arg, obj->name))
{
if (++count == number)
return obj;
}
}
return NULL;
}
/*
* Find an obj in the room or in inventory.
*/
OBJ_DATA *get_obj_here(CHAR_DATA * ch, ROOM_INDEX_DATA * room,
const char *argument)
{
OBJ_DATA *obj;
int number, count;
char arg[MAX_INPUT_LENGTH];
if (ch && room)
{
bug("get_obj_here received a ch and a room", 0);
return NULL;
}
number = number_argument(argument, arg);
count = 0;
if (ch)
{
obj = get_obj_list(ch, argument, ch->in_room->first_content);
if (obj != NULL)
return obj;
if ((obj = get_obj_carry(ch, argument, ch)) != NULL)
return obj;
if ((obj = get_obj_wear(ch, argument, TRUE)) != NULL)
return obj;
}
else
{
for (obj = room->first_content; obj; obj = obj->next_content)
{
if (!is_name(arg, obj->name))
continue;
if (++count == number)
return obj;
}
}
return NULL;
}
/*
* Find an obj in the world.
*/
OBJ_DATA *get_obj_world(CHAR_DATA * ch, const char *argument)
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int number;
int count;
if (ch && (obj = get_obj_here(ch, NULL, argument)) != NULL)
return obj;
number = number_argument(argument, arg);
count = 0;
for (obj = object_first; obj != NULL; obj = obj->next)
{
if ((ch && !can_see_obj(ch, obj)) || !is_name(arg, obj->name))
continue;
if (++count == number)
return obj;
}
return NULL;
}
/* deduct cost from a character */
void deduct_cost(CHAR_DATA * ch, int cost)
{
int silver = 0, gold = 0;
silver = UMIN(ch->silver, cost);
if (silver < cost)
{
gold = ((cost - silver + 99) / 100);
silver = cost - 100 * gold;
}
ch->gold -= gold;
ch->silver -= silver;
if (ch->gold < 0)
{
bug("deduct costs: gold %d < 0", ch->gold);
ch->gold = 0;
}
if (ch->silver < 0)
{
bug("deduct costs: silver %d < 0", ch->silver);
ch->silver = 0;
}
}
/*
* Create a 'money' obj.
*/
OBJ_DATA *create_money(int gold, int silver)
{
char buf[MAX_STRING_LENGTH];
OBJ_DATA *obj;
if (gold < 0 || silver < 0 || (gold == 0 && silver == 0))
{
bug("Create_money: zero or negative money.", UMIN(gold, silver));
gold = UMAX(1, gold);
silver = UMAX(1, silver);
}
if (gold == 0 && silver == 1)
{
obj = create_object(get_obj_index(OBJ_VNUM_SILVER_ONE), 0);
}
else if (gold == 1 && silver == 0)
{
obj = create_object(get_obj_index(OBJ_VNUM_GOLD_ONE), 0);
}
else if (silver == 0)
{
obj = create_object(get_obj_index(OBJ_VNUM_GOLD_SOME), 0);
sprintf(buf, obj->short_descr, gold);
free_string(obj->short_descr);
obj->short_descr = str_dup(buf);
obj->value[1] = gold;
obj->cost = gold;
obj->weight = gold / 5;
}
else if (gold == 0)
{
obj = create_object(get_obj_index(OBJ_VNUM_SILVER_SOME), 0);
sprintf(buf, obj->short_descr, silver);
free_string(obj->short_descr);
obj->short_descr = str_dup(buf);
obj->value[0] = silver;
obj->cost = silver;
obj->weight = silver / 20;
}
else
{
obj = create_object(get_obj_index(OBJ_VNUM_COINS), 0);
sprintf(buf, obj->short_descr, silver, gold);
free_string(obj->short_descr);
obj->short_descr = str_dup(buf);
obj->value[0] = silver;
obj->value[1] = gold;
obj->cost = 100 * gold + silver;
obj->weight = gold / 5 + silver / 20;
}
return obj;
}
/*
* Return # of objects which an object counts as.
* Thanks to Tony Chamberlain for the correct recursive code here.
*/
int get_obj_number(OBJ_DATA * obj)
{
int number;
if (obj->item_type == ITEM_CONTAINER || obj->item_type == ITEM_MONEY ||
obj->item_type == ITEM_GEM || obj->item_type == ITEM_JEWELRY)
number = 0;
else
number = 1;
for (obj = obj->first_content; obj != NULL; obj = obj->next_content)
number += get_obj_number(obj);
return number;
}
/*
* Return weight of an object, including weight of contents.
*/
int get_obj_weight(OBJ_DATA * obj)
{
int weight;
OBJ_DATA *tobj;
weight = obj->weight;
for (tobj = obj->first_content; tobj != NULL; tobj = tobj->next_content)
weight += get_obj_weight(tobj) * WEIGHT_MULT(obj) / 100;
return weight;
}
int get_true_weight(OBJ_DATA * obj)
{
int weight;
weight = obj->weight;
for (obj = obj->first_content; obj != NULL; obj = obj->next_content)
weight += get_obj_weight(obj);
return weight;
}
/*
* True if room is dark.
*/
bool room_is_dark(ROOM_INDEX_DATA * pRoomIndex)
{
if (pRoomIndex->light > 0)
return FALSE;
if (IS_SET(pRoomIndex->room_flags, ROOM_DARK))
return TRUE;
if (pRoomIndex->sector_type == SECT_INSIDE ||
pRoomIndex->sector_type == SECT_CITY)
return FALSE;
if (weather_info.sunlight == SUN_SET || weather_info.sunlight == SUN_DARK)
return TRUE;
return FALSE;
}
bool is_room_owner(CHAR_DATA * ch, ROOM_INDEX_DATA * room)
{
if (room->owner == NULL || room->owner[0] == '\0')
return FALSE;
if (IS_SET(room->area->area_flags, AREA_PLAYER_HOMES))
return TRUE;
return is_name(ch->name, room->owner);
}
/*
* True if room is private.
*/
bool room_is_private(ROOM_INDEX_DATA * pRoomIndex)
{
CHAR_DATA *rch;
int count;
if (pRoomIndex->owner != NULL && pRoomIndex->owner[0] != '\0'
&& !IS_SET(pRoomIndex->area->area_flags, AREA_PLAYER_HOMES))
return TRUE;
count = 0;
for (rch = pRoomIndex->first_person; rch != NULL; rch = rch->next_in_room)
count++;
if (IS_SET(pRoomIndex->room_flags, ROOM_PRIVATE) && count >= 2)
return TRUE;
if (IS_SET(pRoomIndex->room_flags, ROOM_SOLITARY) && count >= 1)
return TRUE;
if (IS_SET(pRoomIndex->room_flags, ROOM_IMP_ONLY))
return TRUE;
return FALSE;
}
/* visibility on a room -- for entering and exits */
bool can_see_room(CHAR_DATA * ch, ROOM_INDEX_DATA * pRoomIndex)
{
if (IS_SET(pRoomIndex->room_flags, ROOM_ARENA))
return TRUE;
if (IS_SET(pRoomIndex->room_flags, ROOM_IMP_ONLY) &&
get_trust(ch) < MAX_LEVEL)
return FALSE;
if (IS_SET(pRoomIndex->room_flags, ROOM_GODS_ONLY) && !IS_IMMORTAL(ch))
return FALSE;
if (IS_SET(pRoomIndex->room_flags, ROOM_HEROES_ONLY) && !IS_IMMORTAL(ch))
return FALSE;
if (IS_SET(pRoomIndex->room_flags, ROOM_NEWBIES_ONLY) && ch->level > 5
&& !IS_IMMORTAL(ch))
return FALSE;
if (!IS_IMMORTAL(ch) && pRoomIndex->clan != NULL
&& ch->clan != pRoomIndex->clan)
return FALSE;
return TRUE;
}
/*
* True if char can see victim.
*/
bool can_see(CHAR_DATA * ch, CHAR_DATA * victim)
{
/* RT changed so that WIZ_INVIS has levels */
if (ch == victim)
return TRUE;
if (get_trust(ch) < victim->invis_level)
return FALSE;
if (get_trust(ch) < victim->incog_level && ch->in_room != victim->in_room)
return FALSE;
if ((!IS_NPC(ch) && IS_SET(ch->act, PLR_HOLYLIGHT)) ||
(IS_NPC(ch) && IS_IMMORTAL(ch)))
return TRUE;
if (IS_AFFECTED(ch, AFF_BLIND))
return FALSE;
if ((!IS_NPC(ch) && ch->in_room &&
IS_SET(ch->in_room->room_flags, ROOM_ARENA)) && (!IS_NPC(victim) &&
victim->in_room
&&
IS_SET
(victim->in_room->
room_flags,
ROOM_ARENA)))
return TRUE;
if (IS_QUESTOR(ch) && IS_NPC(victim)
&& victim->pIndexData->vnum == ch->pcdata->questmob)
return TRUE;
if (gquest_info.running == GQUEST_RUNNING && ON_GQUEST(ch) &&
IS_NPC(victim) && is_gqmob(ch, victim->pIndexData->vnum) != -1)
return TRUE;
if (room_is_dark(ch->in_room) && !IS_AFFECTED(ch, AFF_INFRARED))
return FALSE;
if (IS_AFFECTED(victim, AFF_INVISIBLE) &&
!IS_AFFECTED(ch, AFF_DETECT_INVIS))
return FALSE;
/* sneaking */
if (IS_AFFECTED(victim, AFF_SNEAK) &&
!IS_AFFECTED(ch, AFF_DETECT_HIDDEN) && victim->fighting == NULL)
{
int chance;
chance = get_skill(victim, gsn_sneak);
chance += get_curr_stat(victim, STAT_DEX) * 3 / 2;
chance -= get_curr_stat(ch, STAT_INT) * 2;
chance -= ch->level - victim->level * 3 / 2;
if (number_percent() < chance)
return FALSE;
}
if (IS_AFFECTED(victim, AFF_HIDE) &&
!IS_AFFECTED(ch, AFF_DETECT_HIDDEN) && victim->fighting == NULL)
return FALSE;
return TRUE;
}
/*
* True if char can see obj.
*/
bool can_see_obj(CHAR_DATA * ch, OBJ_DATA * obj)
{
if (!IS_NPC(ch) && IS_SET(ch->act, PLR_HOLYLIGHT))
return TRUE;
if (IS_QUESTOR(ch) && ch->pcdata->questobj == obj->pIndexData->vnum)
return TRUE;
if (IS_SET(obj->extra_flags, ITEM_VIS_DEATH))
return FALSE;
if (IS_AFFECTED(ch, AFF_BLIND) && obj->item_type != ITEM_POTION)
return FALSE;
if (obj->item_type == ITEM_LIGHT && obj->value[2] != 0)
return TRUE;
if (IS_SET(obj->extra_flags, ITEM_INVIS) &&
!IS_AFFECTED(ch, AFF_DETECT_INVIS))
return FALSE;
if (IS_OBJ_STAT(obj, ITEM_GLOW))
return TRUE;
if (room_is_dark(ch->in_room) && !IS_AFFECTED(ch, AFF_DARK_VISION))
return FALSE;
return TRUE;
}
/*
* True if char can drop obj.
*/
bool can_drop_obj(CHAR_DATA * ch, OBJ_DATA * obj)
{
if (IS_SET(obj->extra_flags, ITEM_AUCTIONED))
return FALSE;
if (!IS_SET(obj->extra_flags, ITEM_NODROP))
return TRUE;
if (!IS_NPC(ch) && ch->level >= LEVEL_IMMORTAL)
return TRUE;
return FALSE;
}
/*
* See if a string is one of the names of an object.
*/
bool is_full_name(const char *str, const char *namelist)
{
char name[MAX_INPUT_LENGTH];
for (;;)
{
namelist = one_argument(namelist, name);
if (name[0] == '\0')
return FALSE;
if (!str_cmp(str, name))
return TRUE;
}
}
bool emptystring(const char *str)
{
int i = 0;
for (; str[i]; i++)
if (str[i] != ' ')
return FALSE;
return TRUE;
}
CHAR_DATA *get_char_id(long id)
{
CHAR_DATA *ch, *ch_next;
for (ch = char_first; ch != NULL; ch = ch_next)
{
ch_next = ch->next;
if (ch->id == id)
break;
}
return ch;
}
char *str_time(time_t timet, int tz, const char *format)
{
static char buf_new[5][100];
static int i;
char *result;
// rotate buffers
++i;
i %= 5;
result = buf_new[i];
if (timet <= 0)
{
timet = current_time;
}
if (tz > -1 && tz < MAX_TZONE)
{
timet += timezone;
timet += (60 * 60 * tzone_table[tz].gmt_offset);
}
strftime(result, 100, !IS_NULLSTR(format) ? format : "%a %b %d %r %Y",
localtime(&timet));
return result;
}