OSDN Git Service

Fix crash bug when resizing sub-window after death (Ticket #31239)
[hengband/hengband.git] / src / bldg.c
index 0d76b7e..f913850 100644 (file)
@@ -1349,17 +1349,8 @@ sprintf(tmp_str, "
 
                        prt(tmp_str, 21, 2);
 
-                       /* Prevent savefile-scumming of the casino */
-/*                     Rand_quick = TRUE; */
-                       Rand_value = time(NULL);
-
                        do
                        {
-#ifdef JP /* Prevent random seed cracking of the casino */
-                               clock_t clk;
-                               clk = clock();
-                               Rand_value *= clk;
-#endif
                                p_ptr->au -= wager;
                                switch (cmd)
                                {
@@ -1645,9 +1636,6 @@ msg_print("
                                }
                        } while ((again == 'y') || (again == 'Y'));
 
-                       /* Switch back to complex RNG */
-                       Rand_quick = FALSE;
-
                        prt("", 18, 37);
                        if (p_ptr->au >= oldgold)
                        {
@@ -3125,36 +3113,97 @@ static void town_history(void)
        screen_load();
 }
 
+/* critical happens at i / 10000 */
+s16b calc_crit_ratio_shot(int weight, int plus_ammo, int plus_bow,  int dam)
+{
+       int i;
+       object_type *j_ptr =  &inventory[INVEN_BOW];
+       
+       /* Extract "shot" power */
+       i = p_ptr->to_h_b + plus_ammo;
+       
+       if (p_ptr->tval_ammo == TV_BOLT)
+               i = (p_ptr->skill_thb + (p_ptr->weapon_exp[0][j_ptr->sval] / 400 + i) * BTH_PLUS_ADJ);
+       else
+               i = (p_ptr->skill_thb + ((p_ptr->weapon_exp[0][j_ptr->sval] - (WEAPON_EXP_MASTER / 2)) / 200 + i) * BTH_PLUS_ADJ);
+
+       /* Snipers can shot more critically with crossbows */
+       if (p_ptr->concent) i += ((i * p_ptr->concent) / 5);
+       if ((p_ptr->pclass == CLASS_SNIPER) && (p_ptr->tval_ammo == TV_BOLT)) i *= 2;
+       
+       /* Good bow makes more critical */
+       i += plus_bow * 8 * (p_ptr->concent ? p_ptr->concent + 5 : 5);
+       
+       if (i < 0) i = 0;
+       
+       return i;
+}
+
+s16b calc_expect_crit_shot(int weight, int plus_ammo, int plus_bow,  int dam)
+{
+       u32b num;
+       int i, k, crit;
+       i = calc_crit_ratio_shot(weight, plus_ammo, plus_bow, dam);
+       
+       k = 0;
+       num = 0;
+       
+       crit = MIN(500, 900/weight);
+       num += dam * 3 /2 * crit;
+       k = crit;
+       
+       crit = MIN(500, 1350/weight);
+       crit -= k;
+       num += dam * 2 * crit;
+       k += crit;
+       
+       if(k < 500)
+       {
+               crit = 500 - k;
+               num += dam * 3 * crit;
+       }
+       
+       num /= 500;
+       
+       num *= i;
+       num += (10000 - i) * dam;
+       num /= 10000;
+       
+       return num;
+}
 
-static s16b calc_expext_cirt(int weight, int plus, int dam, s16b meichuu, bool dokubari)
+s16b calc_expect_crit(int weight, int plus, int dam, s16b meichuu, bool dokubari)
 {
-       long i,k, num;
+       u32b k, num;
+       int i;
        
        if(dokubari) return dam;
        
-       i = weight + (meichuu * 3 + plus * 5) + (p_ptr->lev * 3);
+       i = (weight + (meichuu * 3 + plus * 5) + p_ptr->skill_thn);
+       if (i < 0) i = 0;
+       
        k = weight;
-       num=0;
+       num = 0;
        
        if (k < 400)                                            num += (2 * dam + 5) * (400 - k);
-       if (k < 700)                                            num += (2 * dam + 10) * (MIN(700, k+650) - MAX(400, k));
-       if (k > (700-650) && k < 900)           num += (3 * dam + 15) * (MIN(900, k+650) - MAX(700, k));
-       if (k > (900-650) && k < 1300)          num += (3 * dam + 20) * (MIN(1300, k+650) - MAX(900, k));
-       if (k > (1300-650))                                     num += (7 * dam / 2 + 25) * MIN(650, k-(1300-650));
+       if (k < 700)                                            num += (2 * dam + 10) * (MIN(700, k + 650) - MAX(400, k));
+       if (k > (700 - 650) && k < 900)         num += (3 * dam + 15) * (MIN(900, k + 650) - MAX(700, k));
+       if (k > (900 - 650) && k < 1300)                num += (3 * dam + 20) * (MIN(1300, k + 650) - MAX(900, k));
+       if (k > (1300 - 650))                                   num += (7 * dam / 2 + 25) * MIN(650, k - (1300 - 650));
        
+       num /= 650;
        if(p_ptr->pclass == CLASS_NINJA)
        {
                num *= i;
-               num += (4444 - i) * dam * 650;
+               num += (4444 - i) * dam;
                num /= 4444;
        }
        else
        {
                num *= i;
-               num += (5000 - i) * dam * 650;
+               num += (5000 - i) * dam;
                num /= 5000;
        }
-       num /= 650;
        
        return num;
 }
@@ -3180,17 +3229,28 @@ static s16b calc_slaydam(int dam, int mult, int div, bool force)
        return tmp;
 }
 
+static u32b calc_expect_dice(u32b dam, int mult, int div, bool force, int weight, int plus, s16b meichuu, bool dokubari, int vorpal_mult, int vorpal_div)
+{
+       dam = calc_slaydam(dam, mult, div, force);
+       dam = calc_expect_crit(weight, plus, dam, meichuu, dokubari);
+       dam = calc_slaydam(dam, vorpal_mult, vorpal_div, FALSE);
+       return dam;
+}
+
 /*
  * Display the damage figure of an object
- * (used by compare_weapon_aux1)
+ * (used by compare_weapon_aux)
  *
  * Only accurate for the current weapon, because it includes
  * the current +dam of the player.
  */
-static void compare_weapon_aux2(int r, int c, int mindam, int maxdam, cptr attr, byte color)
+static void show_weapon_dmg(int r, int c, int mindice, int maxdice, int blows, int dam_bonus, cptr attr, byte color)
 {
        char tmp_str[80];
-
+       int mindam, maxdam;
+       
+       mindam = blows * (mindice + dam_bonus);
+       maxdam = blows * (maxdice + dam_bonus);
 
        /* Print the intro text */
        c_put_str(color, attr, r, c);
@@ -3214,9 +3274,8 @@ static void compare_weapon_aux2(int r, int c, int mindam, int maxdam, cptr attr,
  * Only accurate for the current weapon, because it includes
  * the current number of blows for the player.
  */
-static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
+static void compare_weapon_aux(object_type *o_ptr, int col, int r)
 {
-       int mult = 60;
        u32b flgs[TR_FLAG_SIZE];
        int blow = p_ptr->num_blow[0];
        bool force = FALSE;
@@ -3230,12 +3289,9 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        int maxdice = eff_ds * eff_dd;
        int mindam = 0;
        int maxdam = 0;
-       int slaydice_min = 0;
-       int slaydice_max = 0;
-       int critdice_min = 0;
-       int critdice_max = 0;
        int vorpal_mult = 1;
        int vorpal_div = 1;
+       int dmg_bonus = o_ptr->to_d + p_ptr->to_d[0];
        
 
        /* Get the flags of the weapon */
@@ -3245,17 +3301,11 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        
        
        /* Show Critical Damage*/
-       critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, mindice, p_ptr->to_h[0], dokubari);
-       critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, maxdice, p_ptr->to_h[0], dokubari);
-       
-       mindam = blow * (critdice_min+ o_ptr->to_d + p_ptr->to_d[0]);
-       maxdam = blow * (critdice_max+ o_ptr->to_d + p_ptr->to_d[0]);
+       mindam = calc_expect_crit(o_ptr->weight, o_ptr->to_h, mindice, p_ptr->to_h[0], dokubari);
+       maxdam = calc_expect_crit(o_ptr->weight, o_ptr->to_h, maxdice, p_ptr->to_h[0], dokubari);
        
-#ifdef JP
-       compare_weapon_aux2(r++, col, mindam, maxdam, "²ñ¿´:", TERM_L_RED);
-#else
-       compare_weapon_aux2(r++, col, mindam, maxdam, "Critical:", TERM_L_RED);
-#endif
+       show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("²ñ¿´:", "Critical:"), TERM_L_RED);
+
        
        /* Vorpal Hit*/
        if ((have_flag(flgs, TR_VORPAL) || hex_spelling(HEX_RUNESWORD)))
@@ -3271,502 +3321,159 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
                        vorpal_div = 9;
                }
                
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, mindice, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, maxdice, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               
-               #ifdef JP
-                       compare_weapon_aux2(r++, col, mindam, maxdam, "ÀÚ¤ìÌ£:", TERM_L_RED);
-               #else
-                       compare_weapon_aux2(r++, col, mindam, maxdam, "Vorpal:", TERM_L_RED);
-               #endif
+               mindam = calc_expect_dice(mindice, 1, 1, FALSE, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 1, 1, FALSE, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);         
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("ÀÚ¤ìÌ£:", "Vorpal:") , TERM_L_RED);
        }       
        
        if ((p_ptr->pclass != CLASS_SAMURAI) && have_flag(flgs, TR_FORCE_WEAPON) && (p_ptr->csp > (o_ptr->dd * o_ptr->ds / 5)))
        {
                force = TRUE;
                
-               slaydice_min = calc_slaydam(mindice, 1, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 1, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               
-               /* Print the relevant lines */
-#ifdef JP
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ÍýÎÏ:", TERM_L_BLUE);
-#else
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Force  :", TERM_L_BLUE);
-#endif         
+               mindam = calc_expect_dice(mindice, 1, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 1, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("ÍýÎÏ:", "Force  :"), TERM_L_BLUE);
        }
                
        /* Print the relevant lines */
-#ifdef JP
        if (have_flag(flgs, TR_KILL_ANIMAL))
        {
-               slaydice_min = calc_slaydam(mindice, 4, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 4, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ưʪ:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 4, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 4, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);         
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("ưʪ:", "Animals:"), TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_ANIMAL)) 
        {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ưʪ:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("ưʪ:", "Animals:"), TERM_YELLOW);
        }
        if (have_flag(flgs, TR_KILL_EVIL))
        {       
-               slaydice_min = calc_slaydam(mindice, 7, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 7, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "¼Ù°­:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 7, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 7, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("¼Ù°­:", "Evil:"), TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_EVIL))
        {       
-               slaydice_min = calc_slaydam(mindice, 2, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 2, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "¼Ù°­:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 2, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 2, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);         
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("¼Ù°­:", "Evil:"), TERM_YELLOW);
        }
        if (have_flag(flgs, TR_KILL_HUMAN))
        {       
-               slaydice_min = calc_slaydam(mindice, 4, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 4, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "¿Í´Ö:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 4, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 4, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("¿Í´Ö:", "Human:"), TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_HUMAN))
        {       
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "¿Í´Ö:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("¿Í´Ö:", "Human:"), TERM_YELLOW);
        }
        if (have_flag(flgs, TR_KILL_UNDEAD))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ÉÔ»à:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("ÉÔ»à:", "Undead:"), TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_UNDEAD)) 
        {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ÉÔ»à:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("ÉÔ»à:", "Undead:"), TERM_YELLOW);
        }
        if (have_flag(flgs, TR_KILL_DEMON))
        {       
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "°­Ëâ:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("°­Ëâ:", "Demons:") , TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_DEMON))
        {       
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "°­Ëâ:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("°­Ëâ:", "Demons:") , TERM_YELLOW);
        }
        if (have_flag(flgs, TR_KILL_ORC))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "¥ª¡¼¥¯:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("¥ª¡¼¥¯:", "Orcs:"), TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_ORC))
        {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "¥ª¡¼¥¯:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("¥ª¡¼¥¯:", "Orcs:"), TERM_YELLOW);
        }
        if (have_flag(flgs, TR_KILL_TROLL))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "¥È¥í¥ë:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("¥È¥í¥ë:", "Trolls:") , TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_TROLL))
        {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "¥È¥í¥ë:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,   _("¥È¥í¥ë:", "Trolls:") , TERM_YELLOW);
        }
        if (have_flag(flgs, TR_KILL_GIANT))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "µð¿Í:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("µð¿Í:", "Giants:"), TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_GIANT))
        {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "µð¿Í:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("µð¿Í:", "Giants:"), TERM_YELLOW);
        }
        if (have_flag(flgs, TR_KILL_DRAGON))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ε:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("ε:", "Dragons:"), TERM_YELLOW);
        }
        else if (have_flag(flgs, TR_SLAY_DRAGON))
-       {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ε:", TERM_YELLOW);
+       {               
+               mindam = calc_expect_dice(mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,   _("ε:", "Dragons:"), TERM_YELLOW);
        }
        if (have_flag(flgs, TR_BRAND_ACID))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "»À°À­:", TERM_RED);
+               mindam = calc_expect_dice(mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("»À°À­:", "Acid:"), TERM_RED);
        }
        if (have_flag(flgs, TR_BRAND_ELEC))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ÅÅ°À­:", TERM_RED);
+               mindam = calc_expect_dice(mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("ÅÅ°À­:", "Elec:"), TERM_RED);
        }
        if (have_flag(flgs, TR_BRAND_FIRE))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "±ê°À­:", TERM_RED);
+               mindam = calc_expect_dice(mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("±ê°À­:", "Fire:"), TERM_RED);
        }
        if (have_flag(flgs, TR_BRAND_COLD))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Îä°À­:", TERM_RED);
+               mindam = calc_expect_dice(mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus,  _("Îä°À­:", "Cold:"), TERM_RED);
        }
        if (have_flag(flgs, TR_BRAND_POIS))
        {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "ÆÇ°À­:", TERM_RED);
-       }
-#else
-       if (have_flag(flgs, TR_KILL_ANIMAL))
-       {
-               slaydice_min = calc_slaydam(mindice, 4, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 4, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Animals:", TERM_YELLOW);
-       }
-       else if (have_flag(flgs, TR_SLAY_ANIMAL)) 
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Animals:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_KILL_EVIL))
-       {       
-               slaydice_min = calc_slaydam(mindice, 7, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 7, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Evil:", TERM_YELLOW);
+               mindam = calc_expect_dice(mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               maxdam = calc_expect_dice(maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, p_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
+               show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("ÆÇ°À­:", "Poison:"), TERM_RED);
        }
-       else if (have_flag(flgs, TR_SLAY_EVIL))
-       {       
-               slaydice_min = calc_slaydam(mindice, 2, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 2, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Evil:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_KILL_HUMAN))
-       {       
-               slaydice_min = calc_slaydam(mindice, 4, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 4, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Human:", TERM_YELLOW);
-       }
-       else if (have_flag(flgs, TR_SLAY_HUMAN))
-       {       
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Human:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_KILL_UNDEAD))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Undead:", TERM_YELLOW);
-       }
-       else if (have_flag(flgs, TR_SLAY_UNDEAD)) 
-       {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Undead:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_KILL_DEMON))
-       {       
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Demons:", TERM_YELLOW);
-       }
-       else if (have_flag(flgs, TR_SLAY_DEMON))
-       {       
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Demons:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_KILL_ORC))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Orcs:", TERM_YELLOW);
-       }
-       else if (have_flag(flgs, TR_SLAY_ORC))
-       {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Orcs:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_KILL_TROLL))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Trolls:", TERM_YELLOW);
-       }
-       else if (have_flag(flgs, TR_SLAY_TROLL))
-       {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Trolls:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_KILL_GIANT))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Giants:", TERM_YELLOW);
-       }
-       else if (have_flag(flgs, TR_SLAY_GIANT))
-       {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Giants:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_KILL_DRAGON))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Dragons:", TERM_YELLOW);
-       }
-       else if (have_flag(flgs, TR_SLAY_DRAGON))
-       {
-               slaydice_min = calc_slaydam(mindice, 3, 1, force);
-               slaydice_max = calc_slaydam(maxdice, 3, 1, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Dragons:", TERM_YELLOW);
-       }
-       if (have_flag(flgs, TR_BRAND_ACID))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Acid:", TERM_RED);
-       }
-       if (have_flag(flgs, TR_BRAND_ELEC))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Elec:", TERM_RED);
-       }
-       if (have_flag(flgs, TR_BRAND_FIRE))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Fire:", TERM_RED);
-       }
-       if (have_flag(flgs, TR_BRAND_COLD))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Cold:", TERM_RED);
-       }
-       if (have_flag(flgs, TR_BRAND_POIS))
-       {
-               slaydice_min = calc_slaydam(mindice, 5, 2, force);
-               slaydice_max = calc_slaydam(maxdice, 5, 2, force);
-               critdice_min = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
-               critdice_max = calc_expext_cirt(o_ptr->weight, o_ptr->to_h, slaydice_max, p_ptr->to_h[0], dokubari);
-               mindam = blow * (calc_slaydam(critdice_min, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               maxdam = blow * (calc_slaydam(critdice_max, vorpal_mult, vorpal_div, FALSE) + o_ptr->to_d + p_ptr->to_d[0]);
-               compare_weapon_aux2(r++, col, mindam, maxdam, "Poison:", TERM_RED);
-       }
-#endif
-       
 }
 
 static int hit_chance(int to_h, int ac)
@@ -3979,9 +3686,15 @@ static int compare_weapons(int bcost)
 
                        /* List the new values */
                        list_weapon(o_ptr[i], row, col);
-                       compare_weapon_aux1(o_ptr[i], col, row + 8);
+                       compare_weapon_aux(o_ptr[i], col, row + 8);
+
+                       /* Copy back the original weapon into the weapon slot */
+                       object_copy(i_ptr, &orig_weapon);
                }
 
+               /* Reset the values for the old weapon */
+               calc_bonuses();
+
                character_xtra = old_character_xtra;
 
 #ifdef JP
@@ -4025,11 +3738,7 @@ static int compare_weapons(int bcost)
                }
        }
 
-       /* Copy back the original weapon into the weapon slot */
-       object_copy(i_ptr, &orig_weapon);
-
-       /* Reset the values for the old weapon */
-       calc_bonuses();
+       /* Restore the screen */
        screen_load();
 
        /* Done */
@@ -4160,7 +3869,6 @@ static bool item_tester_hook_broken_weapon(object_type *o_ptr)
 static void give_one_ability_of_object(object_type *to_ptr, object_type *from_ptr)
 {
        int i, n = 0;
-       int idx = 0;
        int cand[TR_FLAG_MAX];
        u32b to_flgs[TR_FLAG_SIZE];
        u32b from_flgs[TR_FLAG_SIZE];
@@ -4187,7 +3895,10 @@ static void give_one_ability_of_object(object_type *to_ptr, object_type *from_pt
                case TR_FIXED_FLAVOR:
                        break;
                default:
-                       if (have_flag(from_flgs, i) && !have_flag(to_flgs, i)) cand[n++] = i;
+                       if (have_flag(from_flgs, i) && !have_flag(to_flgs, i))
+                       {
+                               if (!(is_pval_flag(i) && (from_ptr->pval < 1))) cand[n++] = i;
+                       }
                }
        }
 
@@ -4214,7 +3925,7 @@ static int repair_broken_weapon_aux(int bcost)
        int item, mater;
        object_type *o_ptr, *mo_ptr; /* broken weapon and material weapon */
        object_kind *k_ptr;
-       int i, k_idx, tr_idx, dd_bonus, ds_bonus;
+       int i, k_idx, dd_bonus, ds_bonus;
        char basenm[MAX_NLEN];
        cptr q, s; /* For get_item prompt */
        int row = 7;
@@ -4300,9 +4011,11 @@ static int repair_broken_weapon_aux(int bcost)
        {
                int i, n = 1;
 
+               /* Suppress compiler warning */
+               k_idx = 0;
+
                for (i = 1; i < max_k_idx; i++)
                {
-                       object_type forge;
                        object_kind *k_ptr = &k_info[i];
 
                        if (k_ptr->tval != TV_SWORD) continue;
@@ -4374,23 +4087,30 @@ static int repair_broken_weapon_aux(int bcost)
        if (have_flag(k_ptr->flags, TR_ACTIVATE)) o_ptr->xtra2 = k_ptr->act_idx;
 
        /* Dice up */
-       if (dd_bonus)
+       if (dd_bonus > 0)
        {
                o_ptr->dd++;
                for (i = 0; i < dd_bonus; i++)
                {
-                       if (one_in_(o_ptr->dd)) o_ptr->dd++;
+                       if (one_in_(o_ptr->dd + i)) o_ptr->dd++;
                }
        }
-       if (ds_bonus)
+       if (ds_bonus > 0)
        {
                o_ptr->ds++;
                for (i = 0; i < ds_bonus; i++)
                {
-                       if (one_in_(o_ptr->ds)) o_ptr->ds++;
+                       if (one_in_(o_ptr->ds + i)) o_ptr->ds++;
                }
        }
 
+       /* */
+       if (have_flag(k_ptr->flags, TR_BLOWS))
+       {
+               int bmax = MIN(3, MAX(1, 40 / (o_ptr->dd * o_ptr->ds)));
+               o_ptr->pval = MIN(o_ptr->pval, bmax);
+       }
+
        /* Add one random ability from material weapon */
        give_one_ability_of_object(o_ptr, mo_ptr);
 
@@ -5990,6 +5710,9 @@ void quest_discovery(int q_idx)
 #endif
                        /* The unique is already dead */
                        quest[q_idx].status = QUEST_STATUS_FINISHED;
+                       q_ptr->complev = 0;
+                       update_playtime();
+                       q_ptr->comptime = playtime;
                }
                else
                {
@@ -6004,7 +5727,7 @@ void quest_discovery(int q_idx)
        {
                /* Normal monsters */
 #ifdef JP
-msg_format("Ãí°Õ¤·¤í¡ª¤³¤Î³¬¤Ï%dÂΤÎ%s¤Ë¤è¤Ã¤Æ¼é¤é¤ì¤Æ¤¤¤ë¡ª", q_num, name);
+               msg_format("Ãí°Õ¤·¤í¡ª¤³¤Î³¬¤Ï%dÂΤÎ%s¤Ë¤è¤Ã¤Æ¼é¤é¤ì¤Æ¤¤¤ë¡ª", q_num, name);
 #else
                plural_aux(name);
                msg_format("Be warned, this level is guarded by %d %s!", q_num, name);