Add new option -- show critical ratio of ammo

[hengband/hengband.git] / src / bldg.c

diff --git a/src/bldg.c b/src/bldg.c
index ac99c9b..0f6bcb3 100644 (file)
--- a/src/bldg.c
+++ b/src/bldg.c
@@ -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,91 @@ 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;
+       
+       /* Extract "shot" power */
+       i = p_ptr->to_h_b * 4 + plus_ammo + (p_ptr->lev * 2);
+       
+       /* 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 += MAX(0, plus_bow - 15) * 4 * (p_ptr->concent ? p_ptr->concent + 5 : 5);
+       
+       if (i < 0) i = 0;
+       
+       return i * 2;
+}
 
-s16b calc_expext_cirt(int weight, int plus, int dam, s16b meichuu, bool dokubari)
+s16b calc_expect_crit_shot(int weight, int plus_ammo, int plus_bow,  int dam)
 {
-       long i,k, num;
+       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;
+}
+
+s16b calc_expect_crit(int weight, int plus, int dam, s16b meichuu, bool dokubari)
+{
+       u32b k, num;
+       int i;
        
        if(dokubari) return dam;
        
        i = weight + (meichuu * 3 + plus * 5) + (p_ptr->lev * 3);
+       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;
 }
@@ -3216,7 +3259,6 @@ static void compare_weapon_aux2(int r, int c, int mindam, int maxdam, cptr attr,
  */
 static void compare_weapon_aux1(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;
@@ -3245,8 +3287,8 @@ 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);
+       critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, mindice, p_ptr->to_h[0], dokubari);
+       critdice_max = calc_expect_crit(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]);
@@ -3271,8 +3313,8 @@ 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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, mindice, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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]);
                
@@ -3289,8 +3331,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
                
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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]);
                
@@ -3308,8 +3350,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3318,8 +3360,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3328,8 +3370,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3338,8 +3380,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3348,8 +3390,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3358,8 +3400,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3368,8 +3410,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3378,8 +3420,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3388,8 +3430,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3398,8 +3440,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3408,8 +3450,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3418,8 +3460,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3428,8 +3470,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3438,8 +3480,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3448,8 +3490,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3458,8 +3500,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3468,8 +3510,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3478,8 +3520,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3488,8 +3530,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3498,8 +3540,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3508,8 +3550,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3518,8 +3560,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3528,8 +3570,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3539,8 +3581,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3549,8 +3591,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3559,8 +3601,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3569,8 +3611,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3579,8 +3621,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3589,8 +3631,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3599,8 +3641,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3609,8 +3651,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3619,8 +3661,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3629,8 +3671,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {       
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3639,8 +3681,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3649,8 +3691,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3659,8 +3701,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3669,8 +3711,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3679,8 +3721,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3689,8 +3731,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3699,8 +3741,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3709,8 +3751,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3719,8 +3761,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3729,8 +3771,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3739,8 +3781,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3749,8 +3791,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -3759,8 +3801,8 @@ static void compare_weapon_aux1(object_type *o_ptr, int col, int r)
        {
                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);
+               critdice_min = calc_expect_crit(o_ptr->weight, o_ptr->to_h, slaydice_min, p_ptr->to_h[0], dokubari);
+               critdice_max = calc_expect_crit(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);
@@ -4162,7 +4204,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];
@@ -4219,7 +4260,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;
@@ -4305,9 +4346,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;