just the one mstrength() for makedefs and game

diff --git a/include/extern.h b/include/extern.h
index 51f13b319555a4e6c59b63d99de9db1fa878df16..e703501d2f94dae952249b12d2302d7bb1a7e39b 100644 (file)
--- a/include/extern.h
+++ b/include/extern.h
@@ -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 ### */
 

diff --git a/src/mdlib.c b/src/mdlib.c
index 7f889914d23e78ec227489b5d272885a49f16e7d..cd7f18fd0c872514e308980e06de9a8eb020652c 100644 (file)
--- a/src/mdlib.c
+++ b/src/mdlib.c
@@ -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)
 {

diff --git a/src/mon.c b/src/mon.c
index dfecac30ec15b1997bef8999a34ca56ed1240aac..1f98181c0e8e17e870ed86631a51ca135ddfe69a 100644 (file)
--- a/src/mon.c
+++ b/src/mon.c
@@ -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*/

diff --git a/util/makedefs.c b/util/makedefs.c
index 782b05de7b0ad20f847c18e5f5b3e289176b5910..cf65ad109f5e1f10a1cc4ef7f4572a4c687c41f0 100644 (file)
--- a/util/makedefs.c
+++ b/util/makedefs.c
@@ -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)