/*****************************************************************************
Name: flag_value( table, flag )
Purpose: Returns the value of the flags entered. Multi-flags accepted.
Called by: olc.c and olc_act.c.
****************************************************************************/
int flag_value( const struct flag_type *flag_table, char *argument)
{
char word[MAX_INPUT_LENGTH];
int bit;
int marked = 0;
bool found = FALSE;
if ( is_stat( flag_table ) )
return flag_lookup(argument, flag_table);
/*
* Accept multiple flags.
*/
for (; ;)
{
argument = one_argument( argument, word );
if ( word[0] == '\0' )
break;
if ( ( bit = flag_lookup( word, flag_table ) ) != NO_FLAG )
{
SET_BIT( marked, bit );
found = TRUE;
}
}
if ( found )
return marked;
else
return NO_FLAG;
}
/*****************************************************************************
* Name: flag_value(table, flag)
* Purpose: Returns the value of the flags entered. Multi-flags accepted.
* Called by: olc.c and olc_act.c.
****************************************************************************/
long flag_value(const struct flag_type *flag_table, const char *argument)
{
char word[MAX_INPUT_LENGTH];
long bit;
long marked = 0;
bool found = false;
if (is_stat(flag_table))
return flag_lookup(argument, flag_table);
/*
* Accept multiple flags.
*/
for (;; ) {
argument = one_argument(argument, word);
if (word[0] == '\0')
break;
if ((bit = flag_lookup(word, flag_table)) != NO_FLAG) {
SET_BIT(marked, bit);
found = true;
}
}
return (found) ? marked : NO_FLAG;
}
/* ---------------------------------------------------------------------
* CMD_EVAL
* This monster evaluates an if/or/and statement
* There are five kinds of statement:
* 1) keyword and value (no $-code) if random 30
* 2) keyword, comparison and value if people > 2
* 3) keyword and actor if isnpc $n
* 4) keyword, actor and value if carries $n sword
* 5) keyword, actor, comparison and value if level $n >= 10
*
*----------------------------------------------------------------------
*/
int cmd_eval( sh_int vnum, char *line, int check,
CHAR_DATA *mob, CHAR_DATA *ch,
const void *arg1, const void *arg2, CHAR_DATA *rch )
{
CHAR_DATA *lval_char = mob;
CHAR_DATA *vch = (CHAR_DATA *) arg2;
OBJ_DATA *obj1 = (OBJ_DATA *) arg1;
OBJ_DATA *obj2 = (OBJ_DATA *) arg2;
OBJ_DATA *lval_obj = NULL;
char *original, buf[MAX_INPUT_LENGTH], code;
int lval = 0, oper = 0, rval = -1;
original = line;
line = one_argument( line, buf );
if ( buf[0] == '\0' || mob == NULL )
return FALSE;
/*
* If this mobile has no target, let's assume our victim is the one
*/
if ( mob->mprog_target == NULL )
mob->mprog_target = ch;
switch ( check )
{
/*
* Case 1: keyword and value
*/
case CHK_RAND:
return( atoi( buf ) < number_percent() );
case CHK_MOBHERE:
if ( is_number( buf ) )
return( get_mob_vnum_room( mob, atoi(buf) ) );
else
return( (bool) (get_char_room( mob, buf) != NULL) );
case CHK_OBJHERE:
if ( is_number( buf ) )
return( get_obj_vnum_room( mob, atoi(buf) ) );
else
return( (bool) (get_obj_here( mob, buf) != NULL) );
case CHK_MOBEXISTS:
return( (bool) (get_char_world( mob, buf) != NULL) );
case CHK_OBJEXISTS:
return( (bool) (get_obj_world( mob, buf) != NULL) );
/*
* Case 2 begins here: We sneakily use rval to indicate need
* for numeric eval...
*/
case CHK_PEOPLE:
rval = count_people_room( mob, 0 ); break;
case CHK_PLAYERS:
rval = count_people_room( mob, 1 ); break;
case CHK_MOBS:
rval = count_people_room( mob, 2 ); break;
case CHK_CLONES:
rval = count_people_room( mob, 3 ); break;
case CHK_ORDER:
rval = get_order( mob ); break;
case CHK_HOUR:
rval = time_info.hour; break;
default:;
}
/*
* Case 2 continued: evaluate expression
*/
if ( rval >= 0 )
{
if ( (oper = keyword_lookup( fn_evals, buf )) < 0 )
{
sprintf( buf, "Cmd_eval: prog %d syntax error(2) '%s'",
vnum, original );
bug( buf, 0 );
return FALSE;
}
one_argument( line, buf );
lval = rval;
rval = atoi( buf );
return( num_eval( lval, oper, rval ) );
}
/*
* Case 3,4,5: Grab actors from $* codes
*/
if ( buf[0] != '$' || buf[1] == '\0' )
{
sprintf( buf, "Cmd_eval: prog %d syntax error(3) '%s'",
vnum, original );
bug( buf, 0 );
return FALSE;
}
else
code = buf[1];
switch( code )
{
case 'i':
lval_char = mob; break;
case 'n':
lval_char = ch; break;
case 't':
lval_char = vch; break;
case 'r':
lval_char = rch == NULL ? get_random_char( mob ) : rch ; break;
case 'o':
lval_obj = obj1; break;
case 'p':
lval_obj = obj2; break;
case 'q':
lval_char = mob->mprog_target; break;
default:
sprintf( buf, "Cmd_eval: prog %d syntax error(4) '%s'",
vnum, original );
bug( buf, 0 );
return FALSE;
}
/*
* From now on, we need an actor, so if none was found, bail out
*/
if ( lval_char == NULL && lval_obj == NULL )
return FALSE;
/*
* Case 3: Keyword, comparison and value
*/
switch( check )
{
case CHK_ISPC:
return( lval_char != NULL && !IS_NPC( lval_char ) );
case CHK_ISNPC:
return( lval_char != NULL && IS_NPC( lval_char ) );
case CHK_ISGOOD:
return( lval_char != NULL && IS_GOOD( lval_char ) );
case CHK_ISEVIL:
return( lval_char != NULL && IS_EVIL( lval_char ) );
case CHK_ISNEUTRAL:
return( lval_char != NULL && IS_NEUTRAL( lval_char ) );
case CHK_ISIMMORT:
return( lval_char != NULL && IS_IMMORTAL( lval_char ) );
case CHK_ISCHARM: /* A relic from MERC 2.2 MOBprograms */
return( lval_char != NULL && IS_AFFECTED( lval_char, AFF_CHARM ) );
case CHK_ISFOLLOW:
return( lval_char != NULL && lval_char->master != NULL
&& lval_char->master->in_room == lval_char->in_room );
case CHK_ISACTIVE:
return( lval_char != NULL && lval_char->position > POS_SLEEPING );
case CHK_ISDELAY:
return( lval_char != NULL && lval_char->mprog_delay > 0 );
case CHK_ISVISIBLE:
switch( code )
{
default :
case 'i':
case 'n':
case 't':
case 'r':
case 'q':
return( lval_char != NULL && can_see( mob, lval_char ) );
case 'o':
case 'p':
return( lval_obj != NULL && can_see_obj( mob, lval_obj ) );
}
case CHK_HASTARGET:
return( lval_char != NULL && lval_char->mprog_target != NULL
&& lval_char->in_room == lval_char->mprog_target->in_room );
case CHK_ISTARGET:
return( lval_char != NULL && mob->mprog_target == lval_char );
default:;
}
/*
* Case 4: Keyword, actor and value
*/
line = one_argument( line, buf );
switch( check )
{
case CHK_AFFECTED:
return( lval_char != NULL
&& IS_SET(lval_char->affected_by, flag_lookup(buf, affect_flags)) );
case CHK_ACT:
return( lval_char != NULL
&& IS_SET(lval_char->act, flag_lookup(buf, act_flags)) );
case CHK_IMM:
return( lval_char != NULL
&& IS_SET(lval_char->imm_flags, flag_lookup(buf, imm_flags)) );
case CHK_OFF:
return( lval_char != NULL
&& IS_SET(lval_char->off_flags, flag_lookup(buf, off_flags)) );
case CHK_CARRIES:
if ( is_number( buf ) )
return( lval_char != NULL && has_item( lval_char, atoi(buf), -1, FALSE ) );
else
return( lval_char != NULL && (get_obj_carry( lval_char, buf ) != NULL) );
case CHK_WEARS:
if ( is_number( buf ) )
return( lval_char != NULL && has_item( lval_char, atoi(buf), -1, TRUE ) );
else
return( lval_char != NULL && (get_obj_wear( lval_char, buf ) != NULL) );
case CHK_HAS:
return( lval_char != NULL && has_item( lval_char, -1, item_lookup(buf), FALSE ) );
case CHK_USES:
return( lval_char != NULL && has_item( lval_char, -1, item_lookup(buf), TRUE ) );
case CHK_NAME:
switch( code )
{
default :
case 'i':
case 'n':
case 't':
case 'r':
case 'q':
return( lval_char != NULL && is_name( buf, lval_char->name ) );
case 'o':
case 'p':
return( lval_obj != NULL && is_name( buf, lval_obj->name ) );
}
case CHK_POS:
return( lval_char != NULL && lval_char->position == position_lookup( buf ) );
case CHK_CLAN:
return( lval_char != NULL && lval_char->clan == clan_lookup( buf ) );
case CHK_RACE:
return( lval_char != NULL && lval_char->race == race_lookup( buf ) );
case CHK_OBJTYPE:
return( lval_obj != NULL && lval_obj->item_type == item_lookup( buf ) );
default:;
}
/*
* Case 5: Keyword, actor, comparison and value
*/
if ( (oper = keyword_lookup( fn_evals, buf )) < 0 )
{
sprintf( buf, "Cmd_eval: prog %d syntax error(5): '%s'",
vnum, original );
bug( buf, 0 );
return FALSE;
}
one_argument( line, buf );
rval = atoi( buf );
switch( check )
{
case CHK_VNUM:
switch( code )
{
default :
case 'i':
case 'n':
case 't':
case 'r':
case 'q':
if( lval_char != NULL && IS_NPC( lval_char ) )
lval = lval_char->pIndexData->vnum;
break;
case 'o':
case 'p':
if ( lval_obj != NULL )
lval = lval_obj->pIndexData->vnum;
}
break;
case CHK_HPCNT:
if ( lval_char != NULL ) lval = (lval_char->hit * 100)/(UMAX(1,lval_char->max_hit)); break;
case CHK_ROOM:
if ( lval_char != NULL && lval_char->in_room != NULL )
lval = lval_char->in_room->vnum; break;
case CHK_SEX:
if ( lval_char != NULL ) lval = lval_char->sex; break;
case CHK_LEVEL:
if ( lval_char != NULL ) lval = lval_char->level; break;
case CHK_ALIGN:
if ( lval_char != NULL ) lval = lval_char->alignment; break;
case CHK_MONEY: /* Money is converted to silver... */
if ( lval_char != NULL )
lval = lval_char->gold + (lval_char->silver * 100); break;
case CHK_OBJVAL0:
if ( lval_obj != NULL ) lval = lval_obj->value[0]; break;
case CHK_OBJVAL1:
if ( lval_obj != NULL ) lval = lval_obj->value[1]; break;
case CHK_OBJVAL2:
if ( lval_obj != NULL ) lval = lval_obj->value[2]; break;
case CHK_OBJVAL3:
if ( lval_obj != NULL ) lval = lval_obj->value[3]; break;
case CHK_OBJVAL4:
if ( lval_obj != NULL ) lval = lval_obj->value[4]; break;
case CHK_GRPSIZE:
if( lval_char != NULL ) lval = count_people_room( lval_char, 4 ); break;
default:
return FALSE;
}
return( num_eval( lval, oper, rval ) );
}
void do_flag(CHAR_DATA *ch, char *argument)
{
char arg1[MAX_INPUT_LENGTH],arg2[MAX_INPUT_LENGTH],arg3[MAX_INPUT_LENGTH];
char word[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
long *flag, old = 0, inew = 0, marked = 0, pos;
char type;
const struct flag_type *flag_table;
argument = one_argument(argument,arg1);
argument = one_argument(argument,arg2);
argument = one_argument(argument,arg3);
type = argument[0];
if (type == '=' || type == '-' || type == '+')
argument = one_argument(argument,word);
if (arg1[0] == '\0')
{
send_to_char("Syntax:\n\r",ch);
send_to_char(" flag mob <name> <field> <flags>\n\r",ch);
send_to_char(" flag char <name> <field> <flags>\n\r",ch);
send_to_char(" mob flags: act,aff,off,imm,res,vuln,form,part\n\r",ch);
send_to_char(" char flags: plr,comm,aff,imm,res,vuln,\n\r",ch);
send_to_char(" +: add flag, -: remove flag, = set equal to\n\r",ch);
send_to_char(" otherwise flag toggles the flags listed.\n\r",ch);
return;
}
if (arg2[0] == '\0')
{
send_to_char("What do you wish to set flags on?\n\r",ch);
return;
}
if (arg3[0] == '\0')
{
send_to_char("You need to specify a flag to set.\n\r",ch);
return;
}
if (argument[0] == '\0')
{
send_to_char("Which flags do you wish to change?\n\r",ch);
return;
}
if (!str_prefix(arg1,"mob") || !str_prefix(arg1,"char"))
{
victim = get_char_world(ch,arg2);
if (victim == NULL)
{
send_to_char("You can't find them.\n\r",ch);
return;
}
/* select a flag to set */
if (!str_prefix(arg3,"act"))
{
if (!IS_NPC(victim))
{
send_to_char("Use plr for PCs.\n\r",ch);
return;
}
flag = &victim->act;
flag_table = act_flags;
}
else if (!str_prefix(arg3,"plr"))
{
if (IS_NPC(victim))
{
send_to_char("Use act for NPCs.\n\r",ch);
return;
}
flag = &victim->act;
flag_table = plr_flags;
}
else if (!str_prefix(arg3,"aff"))
{
flag = &victim->affected_by;
flag_table = affect_flags;
}
else if (!str_prefix(arg3,"immunity"))
{
flag = &victim->imm_flags;
flag_table = imm_flags;
}
else if (!str_prefix(arg3,"resist"))
{
flag = &victim->res_flags;
flag_table = imm_flags;
}
else if (!str_prefix(arg3,"vuln"))
{
flag = &victim->vuln_flags;
flag_table = imm_flags;
}
else if (!str_prefix(arg3,"form"))
{
if (!IS_NPC(victim))
{
send_to_char("Form can't be set on PCs.\n\r",ch);
return;
}
flag = &victim->form;
flag_table = form_flags;
}
else if (!str_prefix(arg3,"parts"))
{
if (!IS_NPC(victim))
{
send_to_char("Parts can't be set on PCs.\n\r",ch);
return;
}
flag = &victim->parts;
flag_table = part_flags;
}
else if (!str_prefix(arg3,"comm"))
{
if (IS_NPC(victim))
{
send_to_char("Comm can't be set on NPCs.\n\r",ch);
return;
}
flag = &victim->comm;
flag_table = comm_flags;
}
else
{
send_to_char("That's not an acceptable flag.\n\r",ch);
return;
}
old = *flag;
victim->zone = NULL;
if (type != '=')
inew = old;
/* mark the words */
for (; ;)
{
argument = one_argument(argument,word);
if (word[0] == '\0')
break;
pos = flag_lookup(word,flag_table);
if (pos == NO_FLAG)
{
send_to_char("That flag doesn't exist!\n\r",ch);
return;
}
else
SET_BIT(marked,pos);
}
for (pos = 0; flag_table[pos].name != NULL; pos++)
{
if (!flag_table[pos].settable && IS_SET(old,flag_table[pos].bit))
{
SET_BIT(inew,flag_table[pos].bit);
continue;
}
if (IS_SET(marked,flag_table[pos].bit))
{
switch(type)
{
case '=':
case '+':
SET_BIT(inew,flag_table[pos].bit);
break;
case '-':
REMOVE_BIT(inew,flag_table[pos].bit);
break;
default:
if (IS_SET(inew,flag_table[pos].bit))
REMOVE_BIT(inew,flag_table[pos].bit);
else
SET_BIT(inew,flag_table[pos].bit);
}
}
}
*flag = inew;
return;
}
}
void load_mobiles(FILE * fp)
{
MOB_INDEX_DATA *pMobIndex;
if (!area_last) { /* OLC */
bug("Load_mobiles: no #AREA seen yet.", 0);
exit(1);
}
for (;;) {
sh_int vnum;
char letter;
int iHash;
letter = fread_letter(fp);
if (letter != '#') {
bug("Load_mobiles: # not found.", 0);
exit(1);
}
vnum = fread_number(fp);
if (vnum == 0)
break;
fBootDb = FALSE;
if (get_mob_index(vnum) != NULL) {
bug("Load_mobiles: vnum %d duplicated.", vnum);
exit(1);
}
fBootDb = TRUE;
pMobIndex = alloc_perm(sizeof(*pMobIndex));
pMobIndex->vnum = vnum;
pMobIndex->area = area_last; /* OLC */
pMobIndex->new_format = TRUE;
newmobs++;
pMobIndex->player_name = fread_string(fp);
pMobIndex->short_descr = fread_string(fp);
pMobIndex->long_descr = fread_string(fp);
pMobIndex->long_descr_orig = fread_string(fp);
pMobIndex->description = fread_string(fp);
pMobIndex->race = race_lookup(fread_string(fp));
pMobIndex->long_descr[0] = UPPER(pMobIndex->long_descr[0]);
pMobIndex->description[0] = UPPER(pMobIndex->description[0]);
pMobIndex->act = fread_flag(fp) | ACT_IS_NPC
| race_table[pMobIndex->race].act;
pMobIndex->affected_by = fread_flag(fp)
| race_table[pMobIndex->race].aff;
pMobIndex->pShop = NULL;
pMobIndex->alignment = fread_number(fp);
pMobIndex->group = fread_number(fp);
pMobIndex->level = fread_number(fp);
pMobIndex->hitroll = fread_number(fp);
/* read hit dice */
pMobIndex->hit[DICE_NUMBER] = fread_number(fp);
/* 'd' */ fread_letter(fp);
pMobIndex->hit[DICE_TYPE] = fread_number(fp);
/* '+' */ fread_letter(fp);
pMobIndex->hit[DICE_BONUS] = fread_number(fp);
/* read mana dice */
pMobIndex->mana[DICE_NUMBER] = fread_number(fp);
fread_letter(fp);
pMobIndex->mana[DICE_TYPE] = fread_number(fp);
fread_letter(fp);
pMobIndex->mana[DICE_BONUS] = fread_number(fp);
/* read damage dice */
pMobIndex->damage[DICE_NUMBER] = fread_number(fp);
fread_letter(fp);
pMobIndex->damage[DICE_TYPE] = fread_number(fp);
fread_letter(fp);
pMobIndex->damage[DICE_BONUS] = fread_number(fp);
pMobIndex->dam_type = attack_lookup(fread_word(fp));
/* read armor class */
pMobIndex->ac[AC_PIERCE] = fread_number(fp) * 10;
pMobIndex->ac[AC_BASH] = fread_number(fp) * 10;
pMobIndex->ac[AC_SLASH] = fread_number(fp) * 10;
pMobIndex->ac[AC_EXOTIC] = fread_number(fp) * 10;
/* read flags and add in data from the race table */
pMobIndex->off_flags = fread_flag(fp)
| race_table[pMobIndex->race].off;
pMobIndex->imm_flags = fread_flag(fp)
| race_table[pMobIndex->race].imm;
pMobIndex->res_flags = fread_flag(fp)
| race_table[pMobIndex->race].res;
pMobIndex->vuln_flags = fread_flag(fp)
| race_table[pMobIndex->race].vuln;
/* vital statistics */
pMobIndex->start_pos = position_lookup(fread_word(fp));
pMobIndex->default_pos = position_lookup(fread_word(fp));
pMobIndex->sex = sex_lookup(fread_word(fp));
pMobIndex->wealth = fread_number(fp);
pMobIndex->form = fread_flag(fp)
| race_table[pMobIndex->race].form;
pMobIndex->parts = fread_flag(fp)
| race_table[pMobIndex->race].parts;
/* size */
pMobIndex->size = size_lookup(fread_word(fp));
pMobIndex->material = str_dup(fread_word(fp));
for (;;) {
letter = fread_letter(fp);
if (letter == 'F') {
char *word;
long vector;
word = fread_word(fp);
vector = fread_flag(fp);
if (!str_prefix(word, "act"))
REMOVE_BIT(pMobIndex->act, vector);
else if (!str_prefix(word, "aff"))
REMOVE_BIT(pMobIndex->affected_by, vector);
else if (!str_prefix(word, "off"))
REMOVE_BIT(pMobIndex->off_flags, vector);
else if (!str_prefix(word, "imm"))
REMOVE_BIT(pMobIndex->imm_flags, vector);
else if (!str_prefix(word, "res"))
REMOVE_BIT(pMobIndex->res_flags, vector);
else if (!str_prefix(word, "vul"))
REMOVE_BIT(pMobIndex->vuln_flags, vector);
else if (!str_prefix(word, "for"))
REMOVE_BIT(pMobIndex->form, vector);
else if (!str_prefix(word, "par"))
REMOVE_BIT(pMobIndex->parts, vector);
else {
bug("Flag remove: flag not found.", 0);
exit(1);
}
} else if (letter == 'M') {
MPROG_LIST *pMprog;
char *word;
int trigger = 0;
pMprog = alloc_perm(sizeof(*pMprog));
word = fread_word(fp);
if (!(trigger = flag_lookup(word, mprog_flags))) {
bug("MOBprogs: invalid trigger.", 0);
exit(1);
}
SET_BIT(pMobIndex->mprog_flags, trigger);
pMprog->trig_type = trigger;
pMprog->vnum = fread_number(fp);
pMprog->trig_phrase = fread_string(fp);
pMprog->next = pMobIndex->mprogs;
pMobIndex->mprogs = pMprog;
} else {
ungetc(letter, fp);
break;
}
}
iHash = vnum % MAX_KEY_HASH;
pMobIndex->next = mob_index_hash[iHash];
mob_index_hash[iHash] = pMobIndex;
top_mob_index++;
top_vnum_mob = top_vnum_mob < vnum ? vnum : top_vnum_mob; /* OLC */
assign_area_vnum(vnum); /* OLC */
kill_table[URANGE(0, pMobIndex->level, MAX_LEVEL - 1)].number++;
}
return;
}
