nethack-gwaa-kiwi/nethack
1
0
Fork 0
Code Pull Requests Activity

just the one mstrength() for makedefs and game

Browse Source
This commit is contained in:
nhmall
2022-10-07 11:00:15 -04:00
parent c4fc5cf9ce
commit 26d13f6656
4 changed files with 98 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/extern.h
View File

@@ -1312,6 +1312,9 @@ extern void release_runtime_info(void);
#ifdef ENHANCED_SYMBOLS
extern void dump_glyphids(void);
#endif
#if (NH_DEVEL_STATUS != NH_STATUS_RELEASED) || defined(DEBUG) || defined(MAKEDEFS_C)
extern int mstrength(struct permonst *);
#endif
/* ### mhitm.c ### */
@@ -1604,9 +1607,6 @@ extern void pacify_guards(void);
extern void decide_to_shapeshift(struct monst *, int);
extern boolean vamp_stone(struct monst *);
extern void check_gear_next_turn(struct monst *);
#if (NH_DEVEL_STATUS != NH_STATUS_RELEASED) || defined(DEBUG)
extern int mstrength(struct permonst *ptr);
#endif
/* ### mondata.c ### */

95
src/mdlib.c
View File

@@ -297,6 +297,101 @@ nh_snprintf(const char *func UNUSED, int line UNUSED, char *str, size_t size,
RESTORE_WARNING_FORMAT_NONLITERAL
#endif /* MAKEDEFS_C */
#if defined(MAKEDEFS_C) \
|| (NH_DEVEL_STATUS != NH_STATUS_RELEASED) || defined(DEBUG)
/*
* In 3.4.3 and earlier, this code was used to construct monstr[] array
* in generated file src/monstr.c. It wasn't used in 3.6. For 3.7 it
* has been reincarnated as a way to generate default monster strength
* values:
* add new monster(s) to include/monsters.h with placeholder value
* for the monstr field;
* run 'makedefs -m' to create src/monstr.c; ignore the complaints
* about it being deprecated;
* transfer relevant generated monstr values to include/monsters.h;
* delete src/monstr.c.
*/
static boolean ranged_attk(struct permonst *);
/*
* This routine is designed to return an integer value which represents
* an approximation of monster strength. It uses a similar method of
* determination as "experience()" to arrive at the strength.
*/
int
mstrength(struct permonst* ptr)
{
int i, tmp2, n, tmp = ptr->mlevel;
if (tmp > 49) /* special fixed hp monster */
tmp = 2 * (tmp - 6) / 4;
/* for creation in groups */
n = (!!(ptr->geno & G_SGROUP));
n += (!!(ptr->geno & G_LGROUP)) << 1;
/* for ranged attacks */
if (ranged_attk(ptr))
n++;
/* for higher ac values */
n += (ptr->ac < 4);
n += (ptr->ac < 0);
/* for very fast monsters */
n += (ptr->mmove >= 18);
/* for each attack and "special" attack */
for (i = 0; i < NATTK; i++) {
tmp2 = ptr->mattk[i].aatyp;
n += (tmp2 > 0);
n += (tmp2 == AT_MAGC);
n += (tmp2 == AT_WEAP && (ptr->mflags2 & M2_STRONG));
}
/* for each "special" damage type */
for (i = 0; i < NATTK; i++) {
tmp2 = ptr->mattk[i].adtyp;
if ((tmp2 == AD_DRLI) || (tmp2 == AD_STON) || (tmp2 == AD_DRST)
|| (tmp2 == AD_DRDX) || (tmp2 == AD_DRCO) || (tmp2 == AD_WERE))
n += 2;
else if (strcmp(ptr->pmnames[NEUTRAL], "grid bug"))
n += (tmp2 != AD_PHYS);
n += ((int) (ptr->mattk[i].damd * ptr->mattk[i].damn) > 23);
}
/* Leprechauns are special cases. They have many hit dice so they
can hit and are hard to kill, but they don't really do much damage. */
if (!strcmp(ptr->pmnames[NEUTRAL], "leprechaun"))
n -= 2;
/* finally, adjust the monster level 0 <= n <= 24 (approx.) */
if (n == 0)
tmp--;
else if (n >= 6)
tmp += (n / 2);
else
tmp += (n / 3 + 1);
return (tmp >= 0) ? tmp : 0;
}
/* returns True if monster can attack at range */
static boolean
ranged_attk(register struct permonst* ptr)
{
register int i, j;
register int atk_mask = (1 << AT_BREA) | (1 << AT_SPIT) | (1 << AT_GAZE);
for (i = 0; i < NATTK; i++) {
if ((j = ptr->mattk[i].aatyp) >= AT_WEAP
|| (j < 32 && (atk_mask & (1 << j)) != 0))
return TRUE;
}
return FALSE;
}
#endif /* (NH_DEVEL_STATUS != NH_STATUS_RELEASED) || DEBUG || MAKEDEFS_C */
char *
version_id_string(char *outbuf, int bufsz, const char *build_date)
{

64
src/mon.c
View File

@@ -30,10 +30,6 @@ static struct permonst *accept_newcham_form(struct monst *, int);
static void kill_eggs(struct obj *);
static void pacify_guard(struct monst *);
#if (NH_DEVEL_STATUS != NH_STATUS_RELEASED) || defined(DEBUG)
int mstrength(struct permonst *ptr);
#endif
#define LEVEL_SPECIFIC_NOCORPSE(mdat) \
(Is_rogue_level(&u.uz) \
|| (g.level.flags.graveyard && is_undead(mdat) && rn2(3)))
@@ -5180,64 +5176,4 @@ check_gear_next_turn(struct monst *mon)
{
mon->misc_worn_check |= I_SPECIAL;
}
#if (NH_DEVEL_STATUS != NH_STATUS_RELEASED) || defined(DEBUG)
/* This routine is designed to return an integer value which represents
* an approximation of monster strength. It uses a similar method of
* determination as "experience()" to arrive at the strength.
*/
int
mstrength(struct permonst *ptr)
{
int i, tmp2, n, tmp = ptr->mlevel;
if(tmp > 49) /* special fixed hp monster */
tmp = 2*(tmp - 6) / 4;
/* For creation in groups */
n = (!!(ptr->geno & G_SGROUP));
n += (!!(ptr->geno & G_LGROUP)) << 1;
/* For ranged attacks */
if (ranged_attk(ptr)) n++;
/* For higher ac values */
n += (ptr->ac < 4);
n += (ptr->ac < 0);
/* For very fast monsters */
n += (ptr->mmove >= 18);
/* For each attack and "special" attack */
for(i = 0; i < NATTK; i++) {
tmp2 = ptr->mattk[i].aatyp;
n += (tmp2 > 0);
n += (tmp2 == AT_MAGC);
n += (tmp2 == AT_WEAP && (ptr->mflags2 & M2_STRONG));
}
/* For each "special" damage type */
for(i = 0; i < NATTK; i++) {
tmp2 = ptr->mattk[i].adtyp;
if ((tmp2 == AD_DRLI) || (tmp2 == AD_STON) || (tmp2 == AD_DRST)
|| (tmp2 == AD_DRDX) || (tmp2 == AD_DRCO) || (tmp2 == AD_WERE))
n += 2;
else if (strcmp(ptr->pmnames[NEUTRAL], "grid bug")) n += (tmp2 != AD_PHYS);
n += ((int) (ptr->mattk[i].damd * ptr->mattk[i].damn) > 23);
}
/* Leprechauns are special cases. They have many hit dice so they
can hit and are hard to kill, but they don't really do much damage. */
if (!strcmp(ptr->pmnames[NEUTRAL], "leprechaun")) n -= 2;
/* Finally, adjust the monster level 0 <= n <= 24 (approx.) */
if(n == 0) tmp--;
else if(n >= 6) tmp += ( n / 2 );
else tmp += ( n / 3 + 1);
return((tmp >= 0) ? tmp : 0);
}
#endif /* (NH_DEVEL_STATUS != NH_STATUS_RELEASED) || DEBUG */
/*mon.c*/

93
util/makedefs.c
View File

@@ -1873,99 +1873,6 @@ do_dungeon(void)
return;
}
/*
* In 3.4.3 and earlier, this code was used to construct monstr[] array
* in generated file src/monstr.c. It wasn't used in 3.6. For 3.7 it
* has been reincarnated as a way to generate default monster strength
* values:
* add new monster(s) to include/monsters.h with placeholder value
* for the monstr field;
* run 'makedefs -m' to create src/monstr.c; ignore the complaints
* about it being deprecated;
* transfer relevant generated monstr values to include/monsters.h;
* delete src/monstr.c.
*/
static int mstrength(struct permonst *);
static boolean ranged_attk(struct permonst *);
/*
* This routine is designed to return an integer value which represents
* an approximation of monster strength. It uses a similar method of
* determination as "experience()" to arrive at the strength.
*/
static int
mstrength(struct permonst* ptr)
{
int i, tmp2, n, tmp = ptr->mlevel;
if (tmp > 49) /* special fixed hp monster */
tmp = 2 * (tmp - 6) / 4;
/* for creation in groups */
n = (!!(ptr->geno & G_SGROUP));
n += (!!(ptr->geno & G_LGROUP)) << 1;
/* for ranged attacks */
if (ranged_attk(ptr))
n++;
/* for higher ac values */
n += (ptr->ac < 4);
n += (ptr->ac < 0);
/* for very fast monsters */
n += (ptr->mmove >= 18);
/* for each attack and "special" attack */
for (i = 0; i < NATTK; i++) {
tmp2 = ptr->mattk[i].aatyp;
n += (tmp2 > 0);
n += (tmp2 == AT_MAGC);
n += (tmp2 == AT_WEAP && (ptr->mflags2 & M2_STRONG));
}
/* for each "special" damage type */
for (i = 0; i < NATTK; i++) {
tmp2 = ptr->mattk[i].adtyp;
if ((tmp2 == AD_DRLI) || (tmp2 == AD_STON) || (tmp2 == AD_DRST)
|| (tmp2 == AD_DRDX) || (tmp2 == AD_DRCO) || (tmp2 == AD_WERE))
n += 2;
else if (strcmp(ptr->pmnames[NEUTRAL], "grid bug"))
n += (tmp2 != AD_PHYS);
n += ((int) (ptr->mattk[i].damd * ptr->mattk[i].damn) > 23);
}
/* Leprechauns are special cases. They have many hit dice so they
can hit and are hard to kill, but they don't really do much damage. */
if (!strcmp(ptr->pmnames[NEUTRAL], "leprechaun"))
n -= 2;
/* finally, adjust the monster level 0 <= n <= 24 (approx.) */
if (n == 0)
tmp--;
else if (n >= 6)
tmp += (n / 2);
else
tmp += (n / 3 + 1);
return (tmp >= 0) ? tmp : 0;
}
/* returns True if monster can attack at range */
static boolean
ranged_attk(register struct permonst* ptr)
{
register int i, j;
register int atk_mask = (1 << AT_BREA) | (1 << AT_SPIT) | (1 << AT_GAZE);
for (i = 0; i < NATTK; i++) {
if ((j = ptr->mattk[i].aatyp) >= AT_WEAP
|| (j < 32 && (atk_mask & (1 << j)) != 0))
return TRUE;
}
return FALSE;
}
/* not quite obsolete but no longer needed to build nethack */
void
do_monstr(void)