/***************************************************************************
* 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. *
***************************************************************************/
#if defined(macintosh)
#include <types.h>
#else
#include <sys/types.h>
#endif
#include <math.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "merc.h"
AFFECT_DATA * affect_free;
/*
* Local functions.
*/
void affect_modify args( ( CHAR_DATA *ch, AFFECT_DATA *paf, bool fAdd ) );
/*
* Retrieve a character's trusted level for permission checking.
*/
int get_trust( CHAR_DATA *ch )
{
if ( IS_NPC(ch) )
{
/* switched mob */
if ( ch->desc != NULL )
return ch->desc->original->level;
else
return LEVEL_HERO - 1;
}
if ( ch->desc != NULL && ch->desc->original != NULL )
ch = ch->desc->original;
if ( ch->trust != 0 )
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) ) / 14400;
12240 assumes 30 second hours, 24 hours a day, 20 day - Kahn */
return 17 + ( ch->played / 8760 );
/* new played is in ticks, years are 24 * 365 */
}
/*
* Retrieve character's current strength.
*
int get_curr_str( CHAR_DATA *ch )
{
int max;
if ( IS_NPC(ch) )
return 13;
if ( class_table[ch->class].attr_prime == APPLY_STR )
max = 25;
else
max = 22;
return URANGE( 3, ch->pcdata->perm_str + ch->pcdata->mod_str, max );
}
*/
/*
* 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;
if ( IS_NPC(ch) )
return ch->level;
else
return MAX_WEAR + 2 * ch->pcdata->body / 2;
}
/*
* Retrieve a character's carry capacity.
*/
int can_carry_w( CHAR_DATA *ch )
{
if ( !IS_NPC(ch) && ch->level >= LEVEL_IMMORTAL )
return 1000000;
if ( IS_NPC(ch) && IS_SET(ch->act, ACT_PET) )
return 0;
if ( IS_NPC(ch) )
return ch->level * 50;
else
return ch->pcdata->body * 10;
}
/*
* See if a string is one of the names of an object.
*/
/*
* New is_name sent in by Alander.
*/
bool is_name( const char *str, char *namelist )
{
char name[MAX_INPUT_LENGTH];
for ( ; ; )
{
namelist = one_argument( namelist, name );
if ( name[0] == '\0' )
return FALSE;
/* if ( !str_cmp( str, name ) ) taken out for abbreviations */
if ( !str_prefix( str, name ) )
return TRUE;
}
}
bool is_full_name( const char *str, 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;
}
}
/*
* Apply or remove an affect to a character.
*/
void affect_modify( CHAR_DATA *ch, AFFECT_DATA *paf, bool fAdd )
{
OBJ_DATA *wield;
int mod;
mod = paf->modifier;
if ( fAdd )
{
SET_BIT( ch->affected_by, paf->bitvector );
}
else
{
REMOVE_BIT( ch->affected_by, paf->bitvector );
mod = 0 - mod;
}
if ( IS_NPC(ch) )
return;
switch ( paf->location )
{
default:
/* massive uninformative log spam
bug( "Affect_modify: unknown location %d.", paf->location );
*/
return;
case APPLY_NONE: break;
/* case APPLY_STR: ch->pcdata->mod_str += 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: ch->armor += mod; break;
case APPLY_HITROLL: ch->hitroll += mod; break;
case APPLY_DAMROLL: ch->damroll += mod; break;
case APPLY_SAVING_PARA: 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;
}
/*
* Check for weapon wielding.
* Guard against recursion (for weapons with affects).
*/
if ( ( wield = get_eq_char( ch, WEAR_WIELD ) ) != NULL
&& get_obj_weight(wield) > ch->pcdata->body )
{
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;
}
/*
* Give an affect to a char.
*/
void affect_to_char( CHAR_DATA *ch, AFFECT_DATA *paf )
{
AFFECT_DATA *paf_new;
if ( affect_free == NULL )
{
paf_new = alloc_perm( sizeof(*paf_new), PERM_AFF );
}
else
{
paf_new = affect_free;
affect_free = affect_free->next;
}
*paf_new = *paf;
paf_new->next = ch->affected;
ch->affected = paf_new;
affect_modify( ch, paf_new, TRUE );
return;
}
/*
* Remove an affect from a char.
*/
void affect_remove( CHAR_DATA *ch, AFFECT_DATA *paf )
{
if ( ch->affected == NULL )
{
bug( "Affect_remove: no affect.", 0 );
return;
}
affect_modify( ch, paf, FALSE );
if ( paf == ch->affected )
{
ch->affected = paf->next;
}
else
{
AFFECT_DATA *prev;
for ( prev = ch->affected; prev != NULL; prev = prev->next )
{
if ( prev->next == paf )
{
prev->next = paf->next;
break;
}
}
if ( prev == NULL )
{
bug( "Affect_remove: cannot find paf.", 0 );
return;
}
}
paf->next = affect_free;
affect_free = paf->next;
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->affected; 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->affected; 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->affected; paf_old != NULL; paf_old = paf_old->next )
{
if ( paf_old->type == paf->type )
{
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;
if ( ch == ch->in_room->people )
{
ch->in_room->people = ch->next_in_room;
}
else
{
CHAR_DATA *prev;
for ( prev = ch->in_room->people; prev; prev = prev->next_in_room )
{
if ( prev->next_in_room == ch )
{
prev->next_in_room = ch->next_in_room;
break;
}
}
if ( prev == NULL )
bug( "Char_from_room: ch not found.", 0 );
}
ch->in_room = NULL;
ch->next_in_room = NULL;
return;
}
/*
* Move a char into a room.
*/
void char_to_room( CHAR_DATA *ch, ROOM_INDEX_DATA *pRoomIndex )
{
OBJ_DATA *obj;
if ( pRoomIndex == NULL )
{
bug( "Char_to_room: NULL.", 0 );
return;
}
ch->in_room = pRoomIndex;
ch->next_in_room = pRoomIndex->people;
pRoomIndex->people = ch;
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;
return;
}
/*
* Give an obj to a char.
*/
void obj_to_char( OBJ_DATA *obj, CHAR_DATA *ch )
{
obj->next_content = ch->carrying;
ch->carrying = 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 );
}
/*
* 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 );
if ( ch->carrying == obj )
{
ch->carrying = obj->next_content;
}
else
{
OBJ_DATA *prev;
for ( prev = ch->carrying; prev != NULL; prev = prev->next_content )
{
if ( prev->next_content == obj )
{
prev->next_content = obj->next_content;
break;
}
}
if ( prev == NULL )
bug( "Obj_from_char: obj not in list.", 0 );
}
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 )
{
if ( obj->item_type != ITEM_ARMOR )
return 0;
switch ( iWear )
{
case WEAR_BODY: return 3 * obj->value[0];
case WEAR_HEAD: return 2 * obj->value[0];
case WEAR_LEGS: return obj->value[0];
case WEAR_FEET: return obj->value[0];
case WEAR_HANDS: return obj->value[0];
case WEAR_ARMS: return obj->value[0];
case WEAR_SHIELD: return 2 * obj->value[0];
case WEAR_FINGER_L: return 0;
case WEAR_FINGER_R: return 0;
case WEAR_NECK_1: return 0;
case WEAR_NECK_2: return 0;
case WEAR_ABOUT: return obj->value[0];
case WEAR_WAIST: return 0;
case WEAR_WRIST_L: return obj->value[0];
case WEAR_WRIST_R: return obj->value[0];
case WEAR_HOLD: return 0;
}
return 0;
}
/*
* Find a piece of eq on a character.
*/
OBJ_DATA *get_eq_char( CHAR_DATA *ch, int iWear )
{
OBJ_DATA *obj;
for ( obj = ch->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;
if ( get_eq_char( ch, iWear ) != NULL )
{
bug( "Equip_char: already equipped (%d).", iWear );
return;
}
if ( IS_CLASS(ch,CLASS_MAZOKU) && !IS_OBJ_STAT(obj,ITEM_ASTRAL)
&& !IS_SET(ch->pcdata->powers[M_SET],M_HUMAN) )
{ act( "You have no need for such material things.", ch, obj, NULL, TO_CHAR );
return;
}
ch->armor -= apply_ac( obj, iWear );
obj->wear_loc = iWear;
for ( paf = obj->pIndexData->affected; paf != NULL; paf = paf->next )
affect_modify( ch, paf, TRUE );
for ( paf = obj->affected; paf != NULL; paf = paf->next )
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;
if ( obj->wear_loc == WEAR_NONE )
{
bug( "Unequip_char: already unequipped.", 0 );
return;
}
ch->armor += apply_ac( obj, obj->wear_loc );
obj->wear_loc = -1;
for ( paf = obj->pIndexData->affected; paf != NULL; paf = paf->next )
affect_modify( ch, paf, FALSE );
for ( paf = obj->affected; paf != NULL; paf = paf->next )
affect_modify( ch, paf, FALSE );
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;
if ( ( in_room = obj->in_room ) == NULL )
{
bug( "obj_from_room: NULL.", 0 );
return;
}
if ( obj == in_room->contents )
{
in_room->contents = obj->next_content;
}
else
{
OBJ_DATA *prev;
for ( prev = in_room->contents; prev; prev = prev->next_content )
{
if ( prev->next_content == obj )
{
prev->next_content = obj->next_content;
break;
}
}
if ( prev == NULL )
{
bug( "Obj_from_room: obj not found.", 0 );
return;
}
}
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 )
{
obj->next_content = pRoomIndex->contents;
pRoomIndex->contents = obj;
obj->in_room = pRoomIndex;
obj->carried_by = NULL;
obj->in_obj = NULL;
return;
}
/*
* Move an object into an object.
*/
void obj_to_obj( OBJ_DATA *obj, OBJ_DATA *obj_to )
{
obj->next_content = obj_to->contains;
obj_to->contains = obj;
obj->in_obj = obj_to;
obj->in_room = NULL;
obj->carried_by = NULL;
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 );
}
}
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;
}
if ( obj == obj_from->contains )
{
obj_from->contains = obj->next_content;
}
else
{
OBJ_DATA *prev;
for ( prev = obj_from->contains; prev; prev = prev->next_content )
{
if ( prev->next_content == obj )
{
prev->next_content = obj->next_content;
break;
}
}
if ( prev == NULL )
{
bug( "Obj_from_obj: obj not found.", 0 );
return;
}
}
obj->next_content = NULL;
obj->in_obj = NULL;
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 );
}
}
return;
}
/*
* Extract an obj from the world.
*/
void extract_obj( OBJ_DATA *obj )
{
OBJ_DATA *obj_content;
OBJ_DATA *obj_next;
OBJ_DATA *unique;
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->contains; obj_content; obj_content = obj_next )
{
obj_next = obj_content->next_content;
/* no killing uniques by destroying containers */
if ( IS_OBJ_STAT(obj->contains,ITEM_UNIQUE) )
{
unique = obj->contains;
obj_from_obj( unique );
obj_to_room( unique, get_rand_room() );
}
else
extract_obj( obj->contains );
}
if ( object_list == obj )
{
object_list = obj->next;
}
else
{
OBJ_DATA *prev;
for ( prev = object_list; prev != NULL; prev = prev->next )
{
if ( prev->next == obj )
{
prev->next = obj->next;
break;
}
}
if ( prev == NULL )
{
bug( "Extract_obj: obj %d not found.", obj->pIndexData->vnum );
return;
}
}
{
AFFECT_DATA *paf;
AFFECT_DATA *paf_next;
for ( paf = obj->affected; paf != NULL; paf = paf_next )
{
paf_next = paf->next;
paf->next = affect_free;
affect_free = paf;
}
}
{
EXTRA_DESCR_DATA *ed;
EXTRA_DESCR_DATA *ed_next;
for ( ed = obj->extra_descr; ed != NULL; ed = ed_next )
{
ed_next = ed->next;
free_string( ed->description );
free_string( ed->keyword );
extra_descr_free = ed;
}
}
free_string( obj->name );
free_string( obj->description );
free_string( obj->short_descr );
free_string( obj->owner );
--obj->pIndexData->count;
obj->next = obj_free;
obj_free = obj;
obj_free_num++;
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;
MPROG_ACT_LIST *actprog;
MPROG_ACT_LIST *actprog_next;
if ( ch->in_room == NULL )
{
bug( "Extract_char: NULL.", 0 );
return;
}
if ( fPull )
die_follower( ch );
stop_fighting( ch, TRUE );
for ( obj = ch->carrying; obj != NULL; obj = obj_next )
{
obj_next = obj->next_content;
/* inserted for claimed shit */
if ( fPull )
extract_obj( obj );
}
char_from_room( ch );
if ( !fPull )
{
char_to_room( ch, get_room_index( ROOM_VNUM_ALTAR ) );
return;
}
if ( IS_NPC(ch) && ch->mpact != NULL )
{
ch->mpactnum = 0;
for ( actprog = ch->mpact; actprog != NULL; actprog = actprog_next )
{
actprog_next = actprog->next;
free_string( actprog->buf );
free_mem( actprog, sizeof( MPROG_ACT_LIST ) );
act_prog_num--;
}
}
if ( IS_NPC(ch) )
--ch->pIndexData->count;
if ( ch->desc != NULL && ch->desc->original != NULL )
do_return( ch, "" );
for ( wch = char_list; wch != NULL; wch = wch->next )
{
if ( wch->reply == ch )
wch->reply = NULL;
}
if ( ch == char_list )
{
char_list = ch->next;
}
else
{
CHAR_DATA *prev;
for ( prev = char_list; prev != NULL; prev = prev->next )
{
if ( prev->next == ch )
{
prev->next = ch->next;
break;
}
}
if ( prev == NULL )
{
bug( "Extract_char: char not found.", 0 );
return;
}
}
if ( ch->desc )
ch->desc->character = NULL;
free_char( ch );
return;
}
/*
* Find a char in the room.
*/
CHAR_DATA *get_char_room( CHAR_DATA *ch, 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;
for ( rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room )
{
if ( !can_see( ch, rch ) || !is_name( arg, rch->name ) )
continue;
if ( ++count == number )
return rch;
}
return NULL;
}
/*
* Find a char in the room, match only full name
*/
CHAR_DATA *get_full_char_room( CHAR_DATA *ch, 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;
for ( rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room )
{
if ( !can_see( ch, rch ) || !is_full_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, char *argument )
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *wch;
int number;
int count;
if ( ( wch = get_char_room( ch, argument ) ) != NULL )
return wch;
number = number_argument( argument, arg );
count = 0;
for ( wch = char_list; wch != NULL ; wch = wch->next )
{
if ( !can_see( ch, wch ) || !is_name( arg, wch->name ) )
continue;
if ( ++count == number )
return wch;
}
return NULL;
}
CHAR_DATA *get_char_area( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *wch;
int number;
int count;
if ( ( wch = get_char_room( ch, argument ) ) != NULL )
return wch;
number = number_argument( argument, arg );
count = 0;
for ( wch = char_list; wch != NULL ; wch = wch->next )
{
if ( !can_see(ch,wch) || !is_name(arg,wch->name)
|| ch->in_room->area != wch->in_room->area )
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_list; 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, 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, char *argument )
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int number;
int count;
number = number_argument( argument, arg );
count = 0;
for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
{
if ( obj->wear_loc == WEAR_NONE
&& can_see_obj( ch, obj )
&& 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, char *argument )
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int number;
int count;
number = number_argument( argument, arg );
count = 0;
for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
{
if ( obj->wear_loc != WEAR_NONE
&& can_see_obj( ch, obj )
&& 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, char *argument )
{
OBJ_DATA *obj;
obj = get_obj_list( ch, argument, ch->in_room->contents );
if ( obj != NULL )
return obj;
if ( ( obj = get_obj_carry( ch, argument ) ) != NULL )
return obj;
if ( ( obj = get_obj_wear( ch, argument ) ) != NULL )
return obj;
return NULL;
}
/*
* Find an obj in the world.
*/
OBJ_DATA *get_obj_world( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int number;
int count;
if ( ( obj = get_obj_here( ch, argument ) ) != NULL )
return obj;
number = number_argument( argument, arg );
count = 0;
for ( obj = object_list; obj != NULL; obj = obj->next )
{
if ( can_see_obj( ch, obj ) && is_name( arg, obj->name ) )
{
if ( ++count == number )
return obj;
}
}
return NULL;
}
/*
* Create a 'money' obj.
*/
OBJ_DATA *create_money( int amount )
{
char buf[MAX_STRING_LENGTH];
OBJ_DATA *obj;
if ( amount <= 0 )
{
bug( "Create_money: zero or negative money %d.", amount );
amount = 1;
}
if ( amount == 1 )
{
obj = create_object( get_obj_index( OBJ_VNUM_MONEY_ONE ), 0 );
obj->value[0] = 1; /* fucking drop 1, get 1-15 gold dupe */
}
else
{
obj = create_object( get_obj_index( OBJ_VNUM_MONEY_SOME ), 0 );
sprintf( buf, obj->short_descr, amount );
free_string( obj->short_descr );
obj->short_descr = str_dup( buf );
obj->value[0] = amount;
}
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;
number = 0;
if ( obj->item_type == ITEM_CONTAINER )
for ( obj = obj->contains; obj != NULL; obj = obj->next_content )
number += get_obj_number( obj );
else
number = 1;
return number;
}
/*
* Return weight of an object, including weight of contents.
*/
int get_obj_weight( OBJ_DATA *obj )
{
int weight;
weight = obj->weight;
for ( obj = obj->contains; 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;
}
/*
* True if room is private.
*/
bool room_is_private( ROOM_INDEX_DATA *pRoomIndex )
{
CHAR_DATA *rch;
int count;
return FALSE;
count = 0;
for ( rch = pRoomIndex->people; rch != NULL; rch = rch->next_in_room )
if ( !IS_NPC(rch) && rch->level >= 2 ) // only count player avatars
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;
return FALSE;
}
/*
* True if char can see victim.
*/
bool can_see( CHAR_DATA *ch, CHAR_DATA *victim )
{
if ( ch == victim )
return TRUE;
if ( !IS_NPC(victim)
&& IS_SET(victim->act, PLR_WIZINVIS)
&& get_trust( ch ) < get_trust( victim ) )
return FALSE;
if ( !IS_NPC(ch) && IS_SET(ch->act, PLR_HOLYLIGHT) )
return TRUE;
if ( IS_NPC(ch) && ch->desc != NULL )
return TRUE;
/* deathscythe cloaker */
if ( IS_NPC(ch) && is_cloaked(victim, ch) )
return FALSE;
/* Suits have cameras, lights, radar.. can't be blinded */
if ( IS_SUIT(ch) )
return TRUE;
if ( IS_NPC(ch) && ch->level > 100 )
return TRUE;
if ( IS_AFFECTED(ch, AFF_BLIND) )
return FALSE;
if ( !IS_NPC(ch) && IS_SET(ch->act,PLR_TRUESIGHT) )
return TRUE;
if ( IS_CLASS(ch,CLASS_MAZOKU) && IS_SET(ch->pcdata->powers[M_SET],M_EYES) )
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;
if ( IS_AFFECTED(victim, AFF_HIDE)
&& !IS_AFFECTED(ch, AFF_DETECT_HIDDEN)
&& victim->fighting == NULL
&& ( IS_NPC(ch) ? !IS_NPC(victim) : IS_NPC(victim) ) )
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_NPC(ch) && IS_SET(ch->act,PLR_TRUESIGHT) )
return TRUE;
if ( IS_CLASS(ch,CLASS_MAZOKU) && IS_SET(ch->pcdata->powers[M_SET],M_EYES) )
return TRUE;
if ( obj->item_type == ITEM_POTION )
return TRUE;
if ( IS_AFFECTED( ch, AFF_BLIND ) )
return FALSE;
if ( obj->item_type == ITEM_LIGHT && obj->value[2] != 0 )
return TRUE;
if ( room_is_dark( ch->in_room ) && !IS_AFFECTED(ch, AFF_INFRARED) )
return FALSE;
if ( IS_SET(obj->extra_flags, ITEM_INVIS)
&& !IS_AFFECTED(ch, AFF_DETECT_INVIS) )
return FALSE;
return TRUE;
}
/*
* True if char can drop obj.
*/
bool can_drop_obj( CHAR_DATA *ch, OBJ_DATA *obj )
{
if ( !IS_NPC(ch) && ch->level >= LEVEL_HERO )
return TRUE;
if ( !IS_NPC(ch) && IS_OBJ_STAT(obj,ITEM_ASTRAL) )
return FALSE;
if ( !IS_NPC(ch) && IS_OBJ_STAT(obj,ITEM_UNIQUE) )
return FALSE;
if ( IS_NPC(ch) || !IS_SET(obj->extra_flags, ITEM_NODROP) )
return TRUE;
return FALSE;
}
/*
* Return ascii name of an item type.
*/
char *item_type_name( int obj_item_type )
{
switch ( obj_item_type )
{
case ITEM_LIGHT: return "light";
case ITEM_SCROLL: return "scroll";
case ITEM_WAND: return "wand";
case ITEM_STAFF: return "staff";
case ITEM_WEAPON: return "weapon";
case ITEM_TREASURE: return "treasure";
case ITEM_ARMOR: return "armor";
case ITEM_POTION: return "potion";
case ITEM_FURNITURE: return "furniture";
case ITEM_TRASH: return "trash";
case ITEM_CONTAINER: return "container";
case ITEM_DRINK_CON: return "drink container";
case ITEM_KEY: return "key";
case ITEM_FOOD: return "food";
case ITEM_MONEY: return "money";
case ITEM_BOAT: return "boat";
case ITEM_CORPSE_NPC: return "npc corpse";
case ITEM_CORPSE_PC: return "pc corpse";
case ITEM_FOUNTAIN: return "fountain";
case ITEM_PILL: return "pill";
case ITEM_PORTAL: return "portal";
case ITEM_GATE: return "gate";
case ITEM_ACCESSORY: return "accessory";
case ITEM_MATERIA: return "materia";
case ITEM_MUNITION: return "munition";
}
bug( "Item_type_name: unknown type %d.", obj_item_type );
return "(unknown)";
}
/*
* Return ascii name of an affect location.
*/
char *affect_loc_name( int location )
{
switch ( location )
{
case APPLY_NONE: return "none";
case APPLY_STR: return "strength";
case APPLY_DEX: return "dexterity";
case APPLY_INT: return "intelligence";
case APPLY_WIS: return "wisdom";
case APPLY_CON: return "constitution";
case APPLY_SEX: return "sex";
case APPLY_CLASS: return "class";
case APPLY_LEVEL: return "level";
case APPLY_AGE: return "age";
case APPLY_MANA: return "mana";
case APPLY_HIT: return "hp";
case APPLY_MOVE: return "moves";
case APPLY_GOLD: return "gold";
case APPLY_EXP: return "experience";
case APPLY_AC: return "armor class";
case APPLY_HITROLL: return "hit roll";
case APPLY_DAMROLL: return "damage roll";
case APPLY_SAVING_PARA: return "save vs paralysis";
case APPLY_SAVING_ROD: return "save vs rod";
case APPLY_SAVING_PETRI: return "save vs petrification";
case APPLY_SAVING_BREATH: return "save vs breath";
case APPLY_SAVING_SPELL: return "save vs spell";
}
bug( "Affect_location_name: unknown location %d.", location );
return "(unknown)";
}
/*
* Return ascii name of an affect bit vector.
*/
char *affect_bit_name( int vector )
{
static char buf[512];
buf[0] = '\0';
if ( vector & AFF_BLIND ) strcat( buf, " blind" );
if ( vector & AFF_INVISIBLE ) strcat( buf, " invisible" );
if ( vector & AFF_DETECT_EVIL ) strcat( buf, " detect_evil" );
if ( vector & AFF_DETECT_INVIS ) strcat( buf, " detect_invis" );
if ( vector & AFF_DETECT_MAGIC ) strcat( buf, " detect_magic" );
if ( vector & AFF_DETECT_HIDDEN ) strcat( buf, " detect_hidden" );
if ( vector & AFF_CHAOS_STRING ) strcat( buf, " chaos string" );
if ( vector & AFF_SANCTUARY ) strcat( buf, " sanctuary" );
if ( vector & AFF_FAERIE_FIRE ) strcat( buf, " faerie_fire" );
if ( vector & AFF_INFRARED ) strcat( buf, " infrared" );
if ( vector & AFF_CURSE ) strcat( buf, " curse" );
if ( vector & AFF_VISFARANK ) strcat( buf, " visfarank" );
if ( vector & AFF_POISON ) strcat( buf, " poison" );
if ( vector & AFF_PROTECT ) strcat( buf, " protect" );
if ( vector & AFF_VAS_GLUUDO ) strcat( buf, " vas gluudo" );
if ( vector & AFF_SLEEP ) strcat( buf, " sleep" );
if ( vector & AFF_SNEAK ) strcat( buf, " sneak" );
if ( vector & AFF_HIDE ) strcat( buf, " hide" );
if ( vector & AFF_CHARM ) strcat( buf, " charm" );
if ( vector & AFF_FLYING ) strcat( buf, " flying" );
if ( vector & AFF_PASS_DOOR ) strcat( buf, " pass_door" );
if ( vector & AFF_NO_FLEE ) strcat( buf, " no_flee" );
if ( vector & AFF_HOLY_RESIST ) strcat( buf, " holy resist" );
if ( vector & AFF_WINDY_SHIELD ) strcat( buf, " windy shield" );
if ( vector & AFF_RAYWING ) strcat( buf, " raywing" );
return ( buf[0] != '\0' ) ? buf+1 : "none";
}
/*
* Return ascii name of extra flags vector.
*/
char *extra_bit_name( int extra_flags )
{
static char buf[512];
buf[0] = '\0';
if ( extra_flags & ITEM_GLOW ) strcat( buf, " glow" );
if ( extra_flags & ITEM_HUM ) strcat( buf, " hum" );
if ( extra_flags & ITEM_DARK ) strcat( buf, " dark" );
if ( extra_flags & ITEM_LOCK ) strcat( buf, " lock" );
if ( extra_flags & ITEM_EVIL ) strcat( buf, " evil" );
if ( extra_flags & ITEM_INVIS ) strcat( buf, " invis" );
if ( extra_flags & ITEM_MAGIC ) strcat( buf, " magic" );
if ( extra_flags & ITEM_NODROP ) strcat( buf, " nodrop" );
if ( extra_flags & ITEM_BLESS ) strcat( buf, " bless" );
if ( extra_flags & ITEM_ANTI_GOOD ) strcat( buf, " anti-good" );
if ( extra_flags & ITEM_ANTI_EVIL ) strcat( buf, " anti-evil" );
if ( extra_flags & ITEM_ANTI_NEUTRAL ) strcat( buf, " anti-neutral" );
if ( extra_flags & ITEM_NOREMOVE ) strcat( buf, " noremove" );
if ( extra_flags & ITEM_INVENTORY ) strcat( buf, " inventory" );
if ( extra_flags & ITEM_UNIQUE ) strcat( buf, " unique" );
if ( extra_flags & ITEM_ASTRAL ) strcat( buf, " astral" );
if ( extra_flags & ITEM_NOLOOT ) strcat( buf, " no-loot" );
if ( extra_flags & ITEM_HARDENED ) strcat( buf, " hardened" );
return ( buf[0] != '\0' ) ? buf+1 : "none";
}
/*
* Expand a bitvector out to 1|2|4|...|2^30 format.
*/
char *expand_bits( int bits )
{
static char buf[MAX_INPUT_LENGTH];
char temp[MAX_INPUT_LENGTH];
int i = 0;
bool match = FALSE;
buf[0] = '\0';
for ( i = 0; i < 30; i++ )
{
if ( bits & (int)pow(2,i) )
{
if ( match )
sprintf( temp, "|%d", (int)pow(2,i) );
else
{
sprintf( temp, "%d", (int)pow(2,i) );
match = TRUE;
}
strcat( buf, temp );
}
}
if ( buf[0] == '\0' )
sprintf( buf, "0" );
return buf;
}
/*
* Return the evaluation of a char
*/
void eval( CHAR_DATA *ch )
{ int point, i=0, j=0, pk, pd;
if ( IS_NPC(ch) )
return;
point = UMAX( 1, ch->max_hit ) / 1500;
if ( ch->class == CLASS_SAIYAN )
{ point += ch->pcdata->powers[S_POWER_MAX] / 3000;
point += (ch->pcdata->powers[S_STRENGTH_MAX]-99) / 150;
point += (ch->pcdata->powers[S_SPEED_MAX]-99) / 150;
point += (ch->pcdata->powers[S_AEGIS_MAX]-99) / 150;
point += ch->max_move/1500 + ch->max_mana/3000;
}
else if ( ch->class == CLASS_PATRYN )
{ i = get_runes( ch, RUNE_ALL, LEFTARM );
i += get_runes( ch, RUNE_ALL, RIGHTARM );
i += get_runes( ch, RUNE_ALL, LEFTLEG );
i += get_runes( ch, RUNE_ALL, RIGHTLEG );
i += get_runes( ch, RUNE_ALL, TORSO );
point += i / 5;
for ( i = 2; i <= 7; i++ )
point += ch->pcdata->powers[i] / 33;
point += ch->max_mana/1500 + ch->max_move/3000;
}
else if ( ch->class == CLASS_FIST )
{ point += ch->pcdata->powers[F_DISC] / 2;
for ( i = 3; i <= 6; i++ )
point += (ch->pcdata->powers[i]+1) / 20;
point += ch->max_move/1500 + ch->max_mana/3000;
}
else if ( ch->class == CLASS_SORCERER )
{
for ( i = 2; i <= 8; i++ )
point += ch->pcdata->powers[i] / 11;
if ( ch->pcdata->powers[SORC_SPEC] == SCHOOL_BLACK )
point += ch->pcdata->powers[SCHOOL_BLACK] / 12;
if ( ch->pcdata->powers[SORC_SPEC] == SCHOOL_WHITE )
point += ch->pcdata->powers[SCHOOL_WHITE] / 12;
for ( i = 2; i <= 8; i++ )
if ( ch->pcdata->powers[i] >= 45 && point < 10 )
point = 10;
point += ch->max_mana/1500 + ch->max_move/3000;
}
else if ( ch->class == CLASS_MAZOKU )
{
/* No secondary stat, counts twice */
point += (ch->max_hit-2000) / 3000;
point += (ch->pcdata->powers[M_MATTER]+1)/20;
point += (ch->pcdata->powers[M_ASTRAL]+1)/20;
point += (ch->pcdata->powers[M_FOCUS]+1)/20;
for ( i = 4; i <= 15; i++ )
{
j = pow(2,i);
if ( IS_SET(ch->pcdata->powers[M_LEARNED],j) )
point++;
}
point += ch->max_move/2250 + ch->max_mana/2250;
}
/* promote newbie pk sluts to higher status */
if ( point < 30 )
{
pk = ch->pcdata->kills[PK];
pd = ch->pcdata->kills[PD];
if ( point < 20 && pk > 50 && (pk/pd) >= 2 )
point = 20;
if ( point < 30 && pk > 100 && (pk/pd) >= 2 )
point = 30;
}
/* promote exp stackers to higher status */
if ( ch->exp > 30000000 )
{
point = UMIN( point + (ch->exp - 30000000)/10000000, 50 );
}
point = URANGE( 1, point, 65 );
// wierd errors cropping up somewhere
if ( ch->pcdata->extras2[EVAL] > 65 )
ch->pcdata->extras2[EVAL] = 65;
if ( ch->pcdata->extras2[EVAL] < point )
{
/* clear kills on turning Unholy, once */
if ( ch->pcdata->extras2[EVAL] < 50 && point >= 50 )
{
for ( i = 4; i <= 8; i++ )
ch->pcdata->kills[i] = 0;
}
ch->pcdata->extras2[EVAL] = point;
}
return;
}
/*
This function allows the following kinds of bets to be made:
Absolute bet
============
bet 14k, bet 50m66, bet 100k
Relative bet
============
These bets are calculated relative to the current bet. The '+' symbol adds
a certain number of percent to the current bet. The default is 25, so
with a current bet of 1000, bet + gives 1250, bet +50 gives 1500 etc.
Please note that the number must follow exactly after the +, without any
spaces!
The '*' or 'x' bet multiplies the current bet by the number specified,
defaulting to 2. If the current bet is 1000, bet x gives 2000, bet x10
gives 10,000 etc.
*/
int advatoi (const char *s)
{
/* the pointer to buffer stuff is not really necessary, but originally I
modified the buffer, so I had to make a copy of it. What the hell, it
works:) (read: it seems to work:)
*/
char string[MAX_INPUT_LENGTH]; /* a buffer to hold a copy of the argument */
char *stringptr = string; /* a pointer to the buffer so we can move around */
char tempstring[2]; /* a small temp buffer to pass to atoi*/
int number = 0; /* number to be returned */
int multiplier = 0; /* multiplier used to get the extra digits right */
strcpy (string,s); /* working copy */
while ( isdigit (*stringptr)) /* as long as the current character is a digit */
{
strncpy (tempstring,stringptr,1); /* copy first digit */
number = (number * 10) + atoi( tempstring ); /* add to current number */
stringptr++; /* advance */
}
switch (UPPER(*stringptr)) {
case 'K' : multiplier = 1000; number *= multiplier; stringptr++; break;
case 'M' : multiplier = 1000000; number *= multiplier; stringptr++; break;
case '\0' : break;
default : return 0; /* not k nor m nor NUL - return 0! */
}
while ( isdigit (*stringptr) && (multiplier > 1)) /* if any digits follow k/m, add those too */
{
strncpy (tempstring,stringptr,1); /* copy first digit */
multiplier = multiplier / 10; /* the further we get to right, the less are the digit 'worth' */
number = number + (atoi(tempstring) * multiplier);
stringptr++;
}
if (*stringptr != '\0' && !isdigit(*stringptr)) /* a non-digit character was found, other than NUL */
return 0; /* If a digit is found, it means the multiplier is 1 - i.e. extra
digits that just have to be ignore, liked 14k4443 -> 3 is ignored */
return (number);
}
int parsebet (const int currentbet, const char *argument)
{
int newbet = 0; /* a variable to temporarily hold the new bet */
char string[MAX_INPUT_LENGTH]; /* a buffer to modify the bet string */
char *stringptr = string; /* a pointer we can move around */
strcpy (string,argument); /* make a work copy of argument */
if (*stringptr) /* check for an empty string */
{
if (isdigit (*stringptr)) /* first char is a digit assume e.g. 433k */
newbet = advatoi (stringptr); /* parse and set newbet to that value */
else
if (*stringptr == '+') /* add ?? percent */
{
if (strlen (stringptr) == 1) /* only + specified, assume default */
newbet = (currentbet * 125) / 100; /* default: add 25% */
else
newbet = (currentbet * (100 + atoi (++stringptr))) / 100; /* cut off the first char */
}
else
{
printf ("considering: * x \n\r");
if ((*stringptr == '*') || (*stringptr == 'x')) /* multiply */
{ if (strlen (stringptr) == 1) /* only x specified, assume default */
newbet = currentbet * 2 ; /* default: twice */
else /* user specified a number */
newbet = currentbet * atoi (++stringptr); /* cut off the first char */
}
}
}
return newbet; /* return the calculated bet */
}
void obj_affect_remove( OBJ_DATA *obj, AFFECT_DATA *af )
{ AFFECT_DATA *prev;
if ( af == NULL )
{ bug( "obj_affect_remove: null affect", 0 );
return;
}
if ( obj->affected == af )
{ obj->affected = af->next;
af->next = affect_free;
affect_free = af;
return;
}
prev = obj->affected;
while ( prev != NULL && prev != af )
prev = prev->next;
if ( prev == NULL )
{ bug( "obj_affect_remove: bad affect.", 0 );
return;
}
prev->next = af->next;
af->next = affect_free;
affect_free = af;
return;
}
bool timer_check( CHAR_DATA *ch, CHAR_DATA *victim )
{
if ( IS_NPC(ch) || IS_NPC(victim) )
return FALSE;
if ( ch->pcdata->extras[TIMER] < 16 )
ch->pcdata->extras[TIMER] = 16;
if ( victim->pcdata->extras[TIMER] < 16 )
victim->pcdata->extras[TIMER] = 16;
return TRUE;
}
void dec_duration( CHAR_DATA *ch, sh_int gsn, int dur )
{
AFFECT_DATA *paf;
AFFECT_DATA *paf_next;
for ( paf = ch->affected; paf != NULL; paf = paf_next )
{
paf_next = paf->next;
if ( paf->type == gsn )
{
paf->duration -= dur;
if ( paf->duration < 0 )
{
act( skill_table[paf->type].msg_off, ch, NULL, NULL, TO_CHAR );
act( skill_table[paf->type].msg_off, ch, NULL, NULL, TO_ROOM );
affect_strip( ch, gsn );
}
};
}
return;
}
bool is_same_clan( CHAR_DATA *ch, CHAR_DATA *victim )
{
int cclan, vclan;
if ( IS_NPC(ch) )
cclan = ch->pIndexData->clan;
else
cclan = ch->pcdata->clan[CLAN];
if ( IS_NPC(victim) )
vclan = victim->pIndexData->clan;
else
vclan = victim->pcdata->clan[CLAN];
return (cclan == vclan);
}
CHAR_DATA * get_admin_char( void )
{
CHAR_DATA *vch;
for ( vch = char_list; vch != NULL; vch = vch->next )
{
if ( !IS_NPC(vch) && vch->level == MAX_LEVEL && !str_cmp( vch->name, "Alathon" ) )
return vch;
}
return NULL;
}