Changeset 103

Timestamp:

04/30/07 17:55:16 (2 years ago)

Author:

andrewdoull

Message:

Add code to lib/edit initialisation that balances monster power and outputs revised monster.txt file. Define ALLOW_TEMPLATES_PROCESS and ALLOW_TEMPLATES_OUTPUT in config.h or elsewhere to use.

Files:

• trunk/src/config.h (modified) (1 diff)
• trunk/src/init.h (modified) (3 diffs)
• trunk/src/init1.c (modified) (2 diffs)
• trunk/src/init2.c (modified) (4 diffs)
• trunk/src/types.h (modified) (2 diffs)

trunk/src/config.h

@@ -113 +113 @@
- */
-#define ALLOW_TEMPLATES
+
+
+/*
+ * OPTION: Allow processing of template files once parsed.
+ * This 'evaluates' the contents of the files. It is is currently
+ * used for balancing the monster list (monster.txt).
+ */
+
+/* #define ALLOW_TEMPLATES_PROCESS */
+
+
+/*
+ * OPTION: Allow output of 'parsable' ascii template files.
+ * This can be used to help change the ascii template format, and to
+ * make changes to the data in the parsed files within Angband itself.
+ *
+ * Files are output to lib\user with the same file names as lib\edit.
+ */
+
+/* #define ALLOW_TEMPLATES_OUTPUT */
-
-

trunk/src/init.h

@@ -40 +40 @@
-
-typedef errr (*parse_info_txt_func)(char *buf, header *head);
+typedef errr (*eval_info_power_func)(header *head);
+typedef errr (*emit_info_txt_index_func)(FILE *fp, header *head, int i);
+typedef errr (*emit_info_txt_always_func)(FILE *fp, header *head);
-
-/*
@@ -94 +97 @@
-
-        parse_info_txt_func parse_info_txt;
+        eval_info_power_func eval_info_power;   /* Evaluate after parsing */
+        emit_info_txt_index_func emit_info_txt_index;
+        emit_info_txt_always_func emit_info_txt_always;
+        
-};
-
-extern errr init_info_txt(FILE *fp, char *buf, header *head,
-                          parse_info_txt_func parse_info_txt_line);
+
+extern errr eval_info(eval_info_power_func eval_info_process, header *head);
+
+extern errr emit_info_txt(FILE *fp, FILE *template, char *buf, header *head,
+   emit_info_txt_index_func emit_info_txt_index, emit_info_txt_always_func emit_info_txt_always);
-
-#ifdef ALLOW_TEMPLATES
@@ -114 +126 @@
-extern errr parse_flavor_info(char *buf, header *head);
-extern errr parse_s_info(char *buf, header *head);
+
+#ifdef ALLOW_TEMPLATES_PROCESS
+extern errr eval_r_power(header *head);
+#endif
+
+#ifdef ALLOW_TEMPLATES_OUTPUT
+extern errr emit_r_info_index(FILE *fp, header *head, int i);
+#endif
+
-
-/*

trunk/src/init1.c

@@ -2100 +2100 @@
-                r_ptr->level = lev;
-                r_ptr->rarity = rar;
-extra
+power
-                r_ptr->mexp = exp;
-        }
@@ -3327 +3327 @@
-
-
+/*
+ * Initialise the info
+ */
+errr eval_info(eval_info_power_func eval_info_process, header *head)
+{
+        int err;
+
+        /* Process the info */
+        err = (*eval_info_process)(head);
+
+        return(err);
+}
+
+#ifdef ALLOW_TEMPLATES_PROCESS
+
+/*
+ * Total monster power
+ */
+static s32b tot_mon_power;
+
+
+static long eval_blow_effect(int effect, int atk_dam, int rlev)
+{
+        switch (effect)
+        {
+                /*other bad effects - minor*/
+                case RBE_EAT_GOLD:
+                case RBE_EAT_ITEM:
+                case RBE_EAT_FOOD:
+                case RBE_EAT_LITE:
+                case RBE_LOSE_CHR:
+                {
+                        atk_dam += 5;
+                        break;
+                }
+                /*other bad effects - poison / disease */
+                case RBE_POISON:
+                {
+                        atk_dam *= 5;
+                        atk_dam /= 4;
+                        atk_dam += rlev;
+                        break;
+                }
+                /*other bad effects - elements / sustains*/
+                case RBE_TERRIFY:
+                case RBE_ELEC:
+                case RBE_COLD:
+                case RBE_FIRE:
+                {
+                        atk_dam += 10;
+                        break;
+                }
+                /*other bad effects - elements / major*/
+                case RBE_ACID:
+                case RBE_BLIND:
+                case RBE_CONFUSE:
+                case RBE_LOSE_STR:
+                case RBE_LOSE_INT:
+                case RBE_LOSE_WIS:
+                case RBE_LOSE_DEX:
+                case RBE_HALLU:
+                {
+                        atk_dam += 20;
+                        break;
+                }
+                /*other bad effects - major*/
+                case RBE_UN_BONUS:
+                case RBE_UN_POWER:
+                case RBE_LOSE_CON:
+                {
+                        atk_dam += 30;
+                        break;
+                }
+                /*other bad effects - major*/
+                case RBE_PARALYZE:
+                case RBE_LOSE_ALL:
+                {
+                        atk_dam += 40;
+                        break;
+                }
+                /* Experience draining attacks */
+                case RBE_EXP_10:
+                case RBE_EXP_20:
+                {
+                        atk_dam += 1000 / (rlev + 1);
+                        break;
+                }
+                case RBE_EXP_40:
+                case RBE_EXP_80:
+                {
+                        atk_dam += 2000 / (rlev + 1);
+                        break;
+                }
+                /*Earthquakes*/
+                case RBE_SHATTER:
+                {
+                        atk_dam += 300;
+                        break;
+                }
+                /*nothing special*/
+                default: break;
+        }
+
+        return (atk_dam);
+}
+
+
+
+/*
+ * Go through the attack types for this monster.
+ * We look for the maximum possible maximum damage that this
+ * monster can inflict in 10 game turns.
+ *
+ * We try to scale this based on assumed resists,
+ * chance of casting spells and of spells failing,
+ * chance of hitting in melee, and particularly speed.
+ */
+
+static long eval_max_dam(monster_race *r_ptr)
+{
+        int hp, rlev, i;
+        int melee_dam, atk_dam, spell_dam, breath_dam;
+        int dam = 1;
+
+        /*clear the counters*/
+        melee_dam = breath_dam = atk_dam = spell_dam = 0;
+
+        /* Evaluate average HP for this monster */
+        if (r_ptr->flags1 & (RF1_FORCE_MAXHP)) hp = r_ptr->hdice * r_ptr->hside;
+        else hp = r_ptr->hdice * (r_ptr->hside + 1) / 2;
+
+        /* Extract the monster level, force 1 for town monsters */
+        rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
+
+        /* Note the following code for average damage depends on
+         * a lot of "magic numbers" in melee2.c.  This is
+         * unavoidable.  Any change to the damage calculations
+         * in melee2.c may render the following inaccurate or
+         * obsolete.
+         *
+         * To do: (perhaps) change melee2.c to work with #define
+         * statements or separate methods that can be called from
+         * here, eliminating the need for duplication.
+         */
+
+        /* Assume single resist for the elemental attacks */
+        breath_dam = ((hp / 3) > 1600 ? 533 : (hp / 9));
+        if ((r_ptr->flags4 & RF4_BR_ACID) && spell_dam < breath_dam) spell_dam = breath_dam + 20;
+        if ((r_ptr->flags4 & RF4_BR_ELEC) && spell_dam < breath_dam) spell_dam = breath_dam + 10;
+        if ((r_ptr->flags4 & RF4_BR_FIRE) && spell_dam < breath_dam) spell_dam = breath_dam + 10;
+        if ((r_ptr->flags4 & RF4_BR_COLD) && spell_dam < breath_dam) spell_dam = breath_dam + 10;
+        /* Same for poison, but lower damage cap */
+        breath_dam = ((hp / 3) > 800 ? 266 : (hp / 9));
+        if ((r_ptr->flags4 & RF4_BR_POIS) && spell_dam < breath_dam) spell_dam = (breath_dam * 5 / 4) + rlev;
+        /*
+         * Different formulae for the high resist attacks
+         * (remember, we are assuming maximum resisted damage)
+         * See also: melee2.c, spells1.c
+         */
+        breath_dam = ((hp / 6) > 550 ? 471 : ((hp * 6) / 42));
+        if ((r_ptr->flags4 & RF4_BR_NETH) && spell_dam < breath_dam) spell_dam = breath_dam + 2000 / (rlev + 1);
+        breath_dam = ((hp / 6) > 500 ? 428 : ((hp * 6) / 42));
+        if ((r_ptr->flags4 & RF4_BR_CHAO) && spell_dam < breath_dam) spell_dam = breath_dam + 2000 / (rlev + 1);
+        if ((r_ptr->flags4 & RF4_BR_DISE) && spell_dam < breath_dam) spell_dam = breath_dam + 50;
+        if ((r_ptr->flags4 & RF4_BR_SHAR) && spell_dam < breath_dam) spell_dam = (breath_dam * 5 / 4) + 5;
+        breath_dam = ((hp / 6) > 400 ? 228 : ((hp * 4) / 42));
+        if ((r_ptr->flags4 & RF4_BR_LITE) && spell_dam < breath_dam) spell_dam = breath_dam + 10;
+        if ((r_ptr->flags4 & RF4_BR_DARK) && spell_dam < breath_dam) spell_dam = breath_dam + 10;
+        breath_dam = ((hp / 6) > 400 ? 285 : ((hp * 5) / 42));
+        if ((r_ptr->flags4 & RF4_BR_CONF) && spell_dam < breath_dam) spell_dam = breath_dam + 20;
+        breath_dam = ((hp / 6) > 500 ? 357 : ((hp * 5) / 42));
+        if ((r_ptr->flags4 & RF4_BR_SOUN) && spell_dam < breath_dam) spell_dam = breath_dam + 20;
+        breath_dam = ((hp / 6) > 400 ? 342 : ((hp * 6) / 42));
+        if ((r_ptr->flags4 & RF4_BR_NEXU) && spell_dam < breath_dam) spell_dam = breath_dam + 20;
+        breath_dam = ((hp / 3) > 150 ? 150 : (hp / 9));
+        if ((r_ptr->flags4 & RF4_BR_TIME) && spell_dam < breath_dam) spell_dam = breath_dam + 2000 / (rlev + 1);
+        breath_dam = ((hp / 6) > 200 ? 200 : (hp / 6));
+        if ((r_ptr->flags4 & RF4_BR_INER) && spell_dam < breath_dam) spell_dam = breath_dam + 30;
+        breath_dam = ((hp / 3) > 200 ? 200 : (hp / 3));
+        if ((r_ptr->flags4 & RF4_BR_GRAV) && spell_dam < breath_dam) spell_dam = breath_dam + 30;
+        breath_dam = ((hp / 6) > 150 ? 150 : (hp / 6));
+        if ((r_ptr->flags4 & RF4_BR_PLAS) && spell_dam < breath_dam) spell_dam = breath_dam + 30;
+        breath_dam = ((hp / 6) > 200 ? 200 : (hp / 6));
+        if ((r_ptr->flags4 & RF4_BR_WALL) && spell_dam < breath_dam) spell_dam = breath_dam + 30;
+
+        /* Handle the attack spells, again assuming single resists */
+        if ((r_ptr->flags5 & RF5_BA_ACID) && spell_dam < (rlev * 3 + 15) / 3 + 20)
+                spell_dam = (rlev * 3 + 15) / 3 + 20;
+        if ((r_ptr->flags5 & RF5_BA_ELEC) && spell_dam < ((rlev * 3 / 2) + 8) / 3 + 10)
+                spell_dam = ((rlev * 3 / 2) + 8) / 3 + 10;
+        if ((r_ptr->flags5 & RF5_BA_FIRE) && spell_dam < ((rlev * 7 / 2) + 10) / 3 + 10)
+                spell_dam = ((rlev * 7 / 2) + 10) / 3 + 10;
+        if ((r_ptr->flags5 & RF5_BA_COLD) && spell_dam < ((rlev * 3 / 2) + 10) / 3 + 10)
+                spell_dam = ((rlev * 3 / 2) + 10) / 3 + 10;
+        if ((r_ptr->flags5 & RF5_BA_POIS) && spell_dam < 8)
+                spell_dam = 8;
+        if ((r_ptr->flags5 & RF5_BA_NETH) && spell_dam < ((rlev + 150) * 6) / 7 + 2000 / (rlev + 1))
+                spell_dam = ((rlev + 150) * 6) / 7 + 2000 / (rlev + 1);
+        if ((r_ptr->flags5 & RF5_BA_WATE) && spell_dam < ((rlev * 5) / 2) + 50 + 20)
+                spell_dam = ((rlev * 5) / 2) + 50 + 20;
+        if ((r_ptr->flags5 & RF5_BA_MANA) && spell_dam < rlev * 5 + 100)
+                spell_dam = rlev * 5 + 100;
+        if ((r_ptr->flags5 & RF5_BA_DARK) && spell_dam < ((rlev * 5 + 100) * 4) / 7 + 10)
+                spell_dam = (rlev * 20 + 400) / 7 + 10;
+        /* Small annoyance value */
+        if ((r_ptr->flags5 & RF5_DRAIN_MANA) && spell_dam < 5)
+                spell_dam = 5;
+        /* For all attack forms the player can save against, spell_damage is halved */
+        if ((r_ptr->flags5 & RF5_MIND_BLAST) && spell_dam < 32)
+                spell_dam = 32;
+        if ((r_ptr->flags5 & RF5_BRAIN_SMASH) && spell_dam < 90)
+                spell_dam = 90;
+        if ((r_ptr->flags5 & RF5_CAUSE_1) && spell_dam < 12)
+                spell_dam = 12;
+        if ((r_ptr->flags5 & RF5_CAUSE_2) && spell_dam < 32)
+                spell_dam = 32;
+        if ((r_ptr->flags5 & RF5_CAUSE_3) && spell_dam < 75)
+                spell_dam = 75;
+        if ((r_ptr->flags5 & RF5_CAUSE_4) && spell_dam < 112)
+                spell_dam = 112;
+        if ((r_ptr->flags5 & RF5_BO_ACID) && spell_dam < ((rlev / 3) + 56) / 3 + 20)
+                spell_dam = ((rlev / 3) + 56) / 3 + 20;
+        if ((r_ptr->flags5 & RF5_BO_ELEC) && spell_dam < ((rlev / 3) + 32) / 3 + 10)
+                spell_dam = ((rlev / 3) + 32) / 3 + 10;
+        if ((r_ptr->flags5 & RF5_BO_FIRE) && spell_dam < ((rlev / 3) + 72) / 3 + 10)
+                spell_dam = ((rlev / 3) + 72) / 3 + 10;
+        if ((r_ptr->flags5 & RF5_BO_COLD) && spell_dam < ((rlev / 3) + 48) / 3 + 10)
+                spell_dam = ((rlev / 3) + 48) / 3 + 10;
+        if ((r_ptr->flags5 & RF5_BO_NETH) && spell_dam < ((rlev * 18) / 2 + 330) / 7  + 2000 / (rlev + 1))
+                spell_dam = ((rlev * 18) / 2 + 330) / 7;
+        if ((r_ptr->flags5 & RF5_BO_WATE) && spell_dam < rlev + 100 + 20)
+                spell_dam = rlev + 100;
+        if ((r_ptr->flags5 & RF5_BO_MANA) && spell_dam < (rlev * 7) / 2 + 50)
+                spell_dam = (rlev * 7) / 2 + 50;
+        if ((r_ptr->flags5 & RF5_BO_PLAS) && spell_dam < rlev + 66)
+                spell_dam = rlev + 66;
+        if ((r_ptr->flags5 & RF5_BO_ICEE) && spell_dam < (rlev + 36) / 3)
+                spell_dam = (rlev + 36) / 3;
+        if ((r_ptr->flags5 & RF5_MISSILE) && spell_dam < rlev / 3 + 12)
+                spell_dam = rlev / 3 + 12;
+        /* Small annoyance value */
+        if ((r_ptr->flags5 & RF5_SCARE) && spell_dam < 5)
+                spell_dam = 5;
+        /* Somewhat higher annoyance values */
+        if ((r_ptr->flags5 & RF5_BLIND) && spell_dam < 10)
+                spell_dam = 8;
+        if ((r_ptr->flags5 & RF5_CONF) && spell_dam < 10)
+                spell_dam = 10;
+        /* A little more dangerous */
+        if ((r_ptr->flags5 & RF5_SLOW) && spell_dam < 15)
+                spell_dam = 15;
+        /* Quite dangerous at an early level */
+        if ((r_ptr->flags5 & RF5_HOLD) && spell_dam < 25)
+                spell_dam = 25;
+        /* Arbitrary values along similar lines from here on */
+        if ((r_ptr->flags6 & RF6_HASTE) && spell_dam < 70)
+                spell_dam = 70;
+        if ((r_ptr->flags6 & RF6_HEAL) && spell_dam < 30)
+                spell_dam = 30;
+        if ((r_ptr->flags6 & RF6_BLINK) && spell_dam < 5)
+                spell_dam = 15;
+        if ((r_ptr->flags6 & RF6_TELE_TO) && spell_dam < 25)
+                spell_dam = 25;
+        if ((r_ptr->flags6 & RF6_TELE_AWAY) && spell_dam < 25)
+                spell_dam = 25;
+        if ((r_ptr->flags6 & RF6_TELE_LEVEL) && spell_dam < 40)
+                spell_dam = 25;
+        if ((r_ptr->flags6 & RF6_DARKNESS) && spell_dam < 5)
+                spell_dam = 6;
+        if ((r_ptr->flags6 & RF6_TRAPS) && spell_dam < 10)
+                spell_dam = 5;
+        if ((r_ptr->flags6 & RF6_FORGET) && spell_dam < 25)
+                spell_dam = 5;
+        /* All summons are assigned arbitrary values */
+        /* Summon kin is more dangerous at deeper levels */
+        if ((r_ptr->flags6 & RF6_S_KIN) && spell_dam < rlev * 2)
+                spell_dam = rlev * 2;
+        /* Dangerous! */
+        if ((r_ptr->flags6 & RF6_S_HI_DEMON) && spell_dam < 250)
+                spell_dam = 250;
+        /* Somewhat dangerous */
+        if ((r_ptr->flags6 & RF6_S_MONSTER) && spell_dam < 40)
+                spell_dam = 40;
+        /* More dangerous */
+        if ((r_ptr->flags6 & RF6_S_MONSTERS) && spell_dam < 80)
+                spell_dam = 80;
+        /* Mostly just annoying */
+        if ((r_ptr->flags6 & RF6_S_ANIMAL) && spell_dam < 30)
+                spell_dam = 30;
+        if ((r_ptr->flags6 & RF6_S_SPIDER) && spell_dam < 20)
+                spell_dam = 20;
+        /* Can be quite dangerous */
+        if ((r_ptr->flags6 & RF6_S_HOUND) && spell_dam < 100)
+                spell_dam = 100;
+        /* Dangerous! */
+        if ((r_ptr->flags6 & RF6_S_HYDRA) && spell_dam < 150)
+                spell_dam = 150;
+        /* Can be quite dangerous */
+        if ((r_ptr->flags6 & RF6_S_ANGEL) && spell_dam < 150)
+                spell_dam = 150;
+        /* All of these more dangerous at higher levels */
+        if ((r_ptr->flags6 & RF6_S_DEMON) && spell_dam < (rlev * 3) / 2)
+                spell_dam = (rlev * 3) / 2;
+        if ((r_ptr->flags6 & RF6_S_UNDEAD) && spell_dam < (rlev * 3) / 2)
+                spell_dam = (rlev * 3) / 2;
+        if ((r_ptr->flags6 & RF6_S_DRAGON) && spell_dam < (rlev * 3) / 2)
+                spell_dam = (rlev * 3) / 2;
+        /* Extremely dangerous */
+        if ((r_ptr->flags6 & RF6_S_HI_UNDEAD) && spell_dam < 400)
+                spell_dam = 400;
+        /* Extremely dangerous */
+        if ((r_ptr->flags6 & RF6_S_HI_DRAGON) && spell_dam < 400)
+                spell_dam = 400;
+        /* Extremely dangerous */
+        if ((r_ptr->flags6 & RF6_S_WRAITH) && spell_dam < 450)
+                spell_dam = 450;
+        /* Most dangerous summon */
+        if ((r_ptr->flags6 & RF6_S_UNIQUE) && spell_dam < 500)
+                spell_dam = 500;
+
+        /* Hack - Apply over 10 rounds */
+        spell_dam *= 10;
+
+        /* Scale for frequency and availability of mana / ammo */
+        if (spell_dam)
+        {
+                int freq = r_ptr->freq_spell;
+
+                        /* Hack -- always get 1 shot */
+                        if (freq < 10) freq = 10;
+
+                        /* Adjust for frequency */
+                        spell_dam = spell_dam * freq / 100;
+        }
+
+        /* Check attacks */
+        for (i = 0; i < 4; i++)
+        {
+                /* Extract the attack infomation */
+                int effect = r_ptr->blow[i].effect;
+                int method = r_ptr->blow[i].method;
+                int d_dice = r_ptr->blow[i].d_dice;
+                int d_side = r_ptr->blow[i].d_side;
+
+                /* Hack -- no more attacks */
+                if (!method) continue;
+
+                /* Assume maximum damage*/
+                atk_dam = eval_blow_effect(effect, d_dice * d_side, r_ptr->level);
+
+                switch (method)
+                {
+                                /*stun definitely most dangerous*/
+                                case RBM_PUNCH:
+                                case RBM_KICK:
+                                case RBM_BUTT:
+                                case RBM_CRUSH:
+                                {
+                                        atk_dam *= 4;
+                                        atk_dam /= 3;
+                                        break;
+                                }
+                                /*cut*/
+                                case RBM_CLAW:
+                                case RBM_BITE:
+                                {
+                                        atk_dam *= 7;
+                                        atk_dam /= 5;
+                                        break;
+                                }
+                                default: 
+                                {
+                                        break;
+                                }
+                        }
+
+                        /* Normal melee attack */
+                        if (!(r_ptr->flags1 & (RF1_NEVER_BLOW)))
+                        {
+                                /* Keep a running total */
+                                melee_dam += atk_dam;
+                        }
+        }
+
+                /* 
+                 * Apply damage over 10 rounds. We assume that the monster has to make contact first.
+                 * Hack - speed has more impact on melee as has to stay in contact with player.
+                 * Hack - this is except for pass wall and kill wall monsters which can always get to the player.
+                 * Hack - use different values for huge monsters as they strike out to range 2.
+                 */
+                if (r_ptr->flags2 & (RF2_KILL_WALL | RF2_PASS_WALL))
+                                melee_dam *= 10;
+                else
+                {
+                        melee_dam = melee_dam * 3 + melee_dam * extract_energy[r_ptr->speed + (r_ptr->flags6 & RF6_HASTE ? 5 : 0)] / 7;
+                }
+
+                /*
+                 * Scale based on attack accuracy. We make a massive number of assumptions here and just use monster level.
+                 */
+                melee_dam = melee_dam * MIN(45 + rlev * 3, 95) / 100;
+
+                /* Hack -- Monsters that multiply ignore the following reductions */
+                if (!(r_ptr->flags2 & (RF2_MULTIPLY)))
+                {
+                        /*Reduce damamge potential for monsters that move randomly */
+                        if ((r_ptr->flags1 & (RF1_RAND_25)) || (r_ptr->flags1 & (RF1_RAND_50)))
+                        {
+                                int reduce = 100;
+
+                                if (r_ptr->flags1 & (RF1_RAND_25)) reduce -= 25;
+                                if (r_ptr->flags1 & (RF1_RAND_50)) reduce -= 50;
+
+                                /*even moving randomly one in 8 times will hit the player*/
+                                reduce += (100 - reduce) / 8;
+
+                                /* adjust the melee damage*/
+                                melee_dam = (melee_dam * reduce) / 100;
+                        }
+
+                        /*monsters who can't move aren't nearly as much of a combat threat*/
+                        if (r_ptr->flags1 & (RF1_NEVER_MOVE))
+                        {
+                                if (r_ptr->flags6 & (RF6_TELE_TO | RF6_BLINK))
+                                {
+                                        /* Scale for frequency */
+                                        melee_dam = melee_dam / 5 + 4 * melee_dam * r_ptr->freq_spell / 500;
+
+                                        /* Incorporate spell failure chance */
+                                        if (!(r_ptr->flags2 & RF2_STUPID)) melee_dam = melee_dam / 5 + 4 * melee_dam * MIN(75 + (rlev + 3) / 4, 100) / 500;
+                                }
+                                else if (r_ptr->flags2 & (RF2_INVISIBLE)) melee_dam /= 3;
+                                else melee_dam /= 5;
+                        }
+                }
+
+                /* But keep at a minimum */
+                if (melee_dam < 1) melee_dam = 1;
+
+        /*
+         * Get the max damage attack
+         */
+
+        if (dam < spell_dam) dam = spell_dam;
+        if (dam < melee_dam) dam = melee_dam;
+
+        r_ptr->highest_threat = dam;
+
+        /*
+         * Adjust for speed.  Monster at speed 120 will do double damage,
+         * monster at speed 100 will do half, etc.  Bonus for monsters who can haste self.
+         */
+        dam = (dam * extract_energy[r_ptr->speed + (r_ptr->flags6 & RF6_HASTE ? 5 : 0)]) / 10;
+
+        /*
+         * Adjust threat for speed -- multipliers are more threatening.
+         */
+        if (r_ptr->flags2 & (RF2_MULTIPLY))
+                r_ptr->highest_threat = (r_ptr->highest_threat * extract_energy[r_ptr->speed + (r_ptr->flags6 & RF6_HASTE ? 5 : 0)]) / 5;
+
+        /*
+         * Adjust threat for friends.
+         */
+        if (r_ptr->flags1 & (RF1_FRIENDS))
+                r_ptr->highest_threat *= 2;
+        else if (r_ptr->flags1 & (RF1_FRIEND))
+                r_ptr->highest_threat = r_ptr->highest_threat * 3 / 2;
+                
+        /*but deep in a minimum*/
+        if (dam < 1) dam  = 1;
+
+        /* We're done */
+        return (dam);
+}
+
+/* Evaluate and adjust a monsters hit points for how easily the monster is damaged */
+static long eval_hp_adjust(monster_race *r_ptr)
+{
+        long hp;
+        int resists = 1;
+        int hide_bonus = 0;
+
+        /* Get the monster base hitpoints */
+        if (r_ptr->flags1 & (RF1_FORCE_MAXHP)) hp = r_ptr->hdice * r_ptr->hside;
+        else hp = r_ptr->hdice * (r_ptr->hside + 1) / 2;
+
+        /* Never moves with no ranged attacks - high hit points count for less */
+        if ((r_ptr->flags1 & (RF1_NEVER_MOVE)) && !(r_ptr->freq_innate || r_ptr->freq_spell))
+        {
+                hp /= 2;
+                if (hp < 1) hp = 1;
+        }
+
+        /* Just assume healers have more staying power */
+        if (r_ptr->flags6 & RF6_HEAL) hp = (hp * 6) / 5;
+
+        /* Miscellaneous improvements */
+        if (r_ptr->flags2 & RF2_REGENERATE) {hp *= 10; hp /= 9;}
+        if (r_ptr->flags2 & RF2_PASS_WALL)      {hp *= 3; hp /= 2;}
+
+        /* Calculate hide bonus */
+        if (r_ptr->flags2 & RF2_EMPTY_MIND) hide_bonus += 2;
+        else
+        {
+                if (r_ptr->flags2 & RF2_COLD_BLOOD) hide_bonus += 1;
+                if (r_ptr->flags2 & RF2_WEIRD_MIND) hide_bonus += 1;
+        }
+
+        /* Invisibility */
+        if (r_ptr->flags2 & RF2_INVISIBLE)
+        {
+                hp = (hp * (r_ptr->level + hide_bonus + 1)) / MAX(1, r_ptr->level);
+        }
+
+        /* Monsters that can teleport are a hassle, and can easily run away */
+        if      ((r_ptr->flags6 & RF6_TPORT) ||
+                 (r_ptr->flags6 & RF6_TELE_AWAY)||
+                 (r_ptr->flags6 & RF6_TELE_LEVEL)) hp = (hp * 6) / 5;
+
+        /*
+         * Monsters that multiply are tougher to kill
+         */
+        if (r_ptr->flags2 & (RF2_MULTIPLY)) hp *= 2;
+
+        /* Monsters with resistances are harder to kill.
+           Therefore effective slays / brands against them are worth more. */
+        if (r_ptr->flags3 & RF3_IM_ACID)        resists += 2;
+        if (r_ptr->flags3 & RF3_IM_FIRE)        resists += 2;
+        if (r_ptr->flags3 & RF3_IM_COLD)        resists += 2;
+        if (r_ptr->flags3 & RF3_IM_ELEC)        resists += 2;
+        if (r_ptr->flags3 & RF3_IM_POIS)        resists += 2;
+
+        /* Bonus for multiple basic resists and weapon resists */
+        if (resists >= 12) resists *= 6;
+        else if (resists >= 10) resists *= 4;
+        else if (resists >= 8) resists *= 3;
+        else if (resists >= 6) resists *= 2;
+
+        /* If quite resistant, reduce resists by defense holes */
+        if (resists >= 6)
+        {
+                if (r_ptr->flags3 & RF3_HURT_ROCK)      resists -= 1;
+                if (!(r_ptr->flags3 & RF3_NO_SLEEP))    resists -= 3;
+                if (!(r_ptr->flags3 & RF3_NO_FEAR))     resists -= 2;
+                if (!(r_ptr->flags3 & RF3_NO_CONF))     resists -= 2;
+                if (!(r_ptr->flags3 & RF3_NO_STUN))     resists -= 1;
+
+                if (resists < 5) resists = 5;
+        }
+
+        /* If quite resistant, bonus for high resists */
+        if (resists >= 3)
+        {
+                if (r_ptr->flags3 & RF3_IM_WATER)       resists += 1;
+                if (r_ptr->flags3 & RF3_RES_NETH)       resists += 1;
+                if (r_ptr->flags3 & RF3_RES_NEXUS)      resists += 1;
+                if (r_ptr->flags3 & RF3_RES_DISE)       resists += 1;
+        }
+
+        /* Scale resists */
+        resists = resists * 25;
+
+        /* Monster resistances */
+        if (resists < (r_ptr->ac + resists) / 3)
+        {
+                hp += (hp * resists) / (150 + r_ptr->level);    
+        }
+        else
+        {
+                hp += (hp * (r_ptr->ac + resists) / 3) / (150 + r_ptr->level);                  
+        }
+
+        /*boundry control*/
+        if (hp < 1) hp = 1;
+
+        return (hp);
+
+}
+
+
+/*
+ * Evaluate the monster power ratings to be stored in r_info.raw
+ */
+errr eval_r_power(header *head)
+{
+        int i, j;
+        byte lvl;
+        long hp, av_hp, av_dam;
+        long tot_hp[MAX_DEPTH];
+        long dam;
+        long *power;
+        long tot_dam[MAX_DEPTH];
+        long mon_count[MAX_DEPTH];
+        monster_race *r_ptr = NULL;
+
+        int iteration;
+
+        /* Allocate space for power */
+        C_MAKE(power, z_info->r_max, long);
+
+
+for (iteration = 0; iteration < 3; iteration ++)
+{
+
+        /* Reset the sum of all monster power values */
+        tot_mon_power = 0;
+
+        /* Make sure all arrays start at zero */
+        for (i = 0; i < MAX_DEPTH; i++)
+        {
+                tot_hp[i] = 0;
+                tot_dam[i] = 0;
+                mon_count[i] = 0;
+        }
+
+        /*
+         * Go through r_info and evaluate power ratings & flows.
+         */
+        for (i = 0; i < z_info->r_max; i++)
+        {
+                /* Point at the "info" */
+                r_ptr = (monster_race*)head->info_ptr + i;
+
+                /*** Evaluate power ratings ***/
+
+                /* Set the current level */
+                lvl = r_ptr->level;
+
+                /* Maximum damage this monster can do in 10 game turns */
+                dam = eval_max_dam(r_ptr);
+
+                /* Adjust hit points based on resistances */
+                hp = eval_hp_adjust(r_ptr);
+
+                /* Hack -- set exp */
+                if (lvl == 0) r_ptr->mexp = 0L;
+                else
+                {
+                        /* Compute depths of non-unique monsters */
+                        if (!(r_ptr->flags1 & (RF1_UNIQUE)))
+                        {
+                                long mexp = (hp * dam) / 25;
+                                long threat = r_ptr->highest_threat;
+
+                                /* Compute level algorithmically */
+                                for (j = 1; (mexp > j + 4) || (threat > j + 5); mexp -= j * j, threat -= (j + 4), j++);
+
+                                /* Set level */
+                                lvl = MIN(( j > 250 ? 90 + (j - 250) / 20 :     /* Level 90 and above */
+                                                (j > 130 ? 70 + (j - 130) / 6 : /* Level 70 and above */
+                                                (j > 40 ? 40 + (j - 40) / 3 :   /* Level 40 and above */
+                                                j))), 99);
+
+                                /* Set level */
+                                r_ptr->level = lvl;
+                        }
+
+                        /* Hack -- for Ungoliant */
+                        if (hp > 10000) r_ptr->mexp = (hp / 25) * (dam / lvl);
+                        else r_ptr->mexp = (hp * dam) / (lvl * 25);
+
+                        /* Round to 2 significant figures */
+                        if (r_ptr->mexp > 100)
+                        {
+                                if (r_ptr->mexp < 1000) { r_ptr->mexp = (r_ptr->mexp + 5) / 10; r_ptr->mexp *= 10; }
+                                else if (r_ptr->mexp < 10000) { r_ptr->mexp = (r_ptr->mexp + 50) / 100; r_ptr->mexp *= 100; }
+                                else if (r_ptr->mexp < 100000) { r_ptr->mexp = (r_ptr->mexp + 500) / 1000; r_ptr->mexp *= 1000; }
+                                else if (r_ptr->mexp < 1000000) { r_ptr->mexp = (r_ptr->mexp + 5000) / 10000; r_ptr->mexp *= 10000; }
+                                else if (r_ptr->mexp < 10000000) { r_ptr->mexp = (r_ptr->mexp + 50000) / 100000; r_ptr->mexp *= 100000; }
+                        }
+                }
+
+                if ((lvl) && (r_ptr->mexp < 1L)) r_ptr->mexp = 1L;
+
+                /*
+                 * Hack - We have to use an adjustment factor to prevent overflow.
+                 */
+                if (lvl >= 90)
+                {
+                        hp /= 1000;
+                        dam /= 1000;
+                }
+                else if (lvl >= 65)
+                {
+                        hp /= 100;
+                        dam /= 100;
+                }
+                else if (lvl >= 40)
+                {
+                        hp /= 10;
+                        dam /= 10;
+                }
+
+                /* Define the power rating */
+                power[i] = hp * dam;
+
+                /* Adjust for group monsters.  Average in-level group size is 5 */
+                if (r_ptr->flags1 & RF1_UNIQUE) ;
+
+                else if (r_ptr->flags1 & RF1_FRIEND) power[i] *= 2;
+
+                else if (r_ptr->flags1 & RF1_FRIENDS) power[i] *= 5;
+
+                /* Adjust for multiplying monsters. This is modified by the speed,
+                 * as fast multipliers are much worse than slow ones. We also adjust for
+                 * ability to bypass walls or doors.
+                 */
+                if (r_ptr->flags2 & RF2_MULTIPLY)
+                {
+                        if (r_ptr->flags2 & (RF2_KILL_WALL | RF2_PASS_WALL))
+                                power[i] = MAX(power[i], power[i] * extract_energy[r_ptr->speed
+                                        + (r_ptr->flags6 & RF6_HASTE ? 5 : 0)]);
+                        else if (r_ptr->flags2 & (RF2_OPEN_DOOR | RF2_BASH_DOOR))
+                                power[i] = MAX(power[i], power[i] *  extract_energy[r_ptr->speed
+                                        + (r_ptr->flags6 & RF6_HASTE ? 5 : 0)] * 3 / 2);
+                        else
+                                power[i] = MAX(power[i], power[i] * extract_energy[r_ptr->speed
+                                        + (r_ptr->flags6 & RF6_HASTE ? 5 : 0)] / 2);
+                }
+
+                /*
+                 * Update the running totals - these will be used as divisors later
+                 * Total HP / dam / count for everything up to the current level
+                 */
+                for (j = lvl; j < (lvl == 0 ? lvl + 1: MAX_DEPTH); j++)
+                {
+                        int count = 10;
+
+                        /*
+                         * Uniques don't count towards monster power on the level.
+                         */
+                        if (r_ptr->flags1 & RF1_UNIQUE) continue;
+
+                        /*
+                         * Specifically placed monsters don't count towards monster power on the level.
+                         */
+                        if (!(r_ptr->rarity)) continue;
+
+                        /*
+                         * Hack -- provide adjustment factor to prevent overflow
+                         */
+                        if ((j == 90) && (r_ptr->level < 90))
+                        {
+                                hp /= 10;
+                                dam /= 10;
+                        }
+
+                        if ((j == 65) && (r_ptr->level < 65))
+                        {
+                                hp /= 10;
+                                dam /= 10;
+                        }
+
+                        if ((j == 40) && (r_ptr->level < 40))
+                        {
+                                hp /= 10;
+                                dam /= 10;
+                        }
+
+                        /*