src/xtra1.c

   1
   2 /* File: misc.c */
   3
   4 /* Purpose: misc code */
   5
   6 /*
   7  * Copyright (c) 1989 James E. Wilson, Robert A. Koeneke
   8  *
   9  * This software may be copied and distributed for educational, research, and
  10  * not for profit purposes provided that this copyright and statement are
  11  * included in all such copies.
  12  */
  13
  14 #include "angband.h"
  15
  16
  17
  18
  19 /*
  20  * Converts stat num into a six-char (right justified) string
  21  */
  22 void cnv_stat(int val, char *out_val)
  23 {
  24         /* Above 18 */
  25         if (val > 18)
  26         {
  27                 int bonus = (val - 18);
  28
  29                 if (bonus >= 220)
  30                 {
  31                         sprintf(out_val, "18/%3s", "***");
  32                 }
  33                 else if (bonus >= 100)
  34                 {
  35                         sprintf(out_val, "18/%03d", bonus);
  36                 }
  37                 else
  38                 {
  39                         sprintf(out_val, " 18/%02d", bonus);
  40                 }
  41         }
  42
  43         /* From 3 to 18 */
  44         else
  45         {
  46                 sprintf(out_val, "    %2d", val);
  47         }
  48 }
  49
  50
  51
  52 /*
  53  * Modify a stat value by a "modifier", return new value
  54  *
  55  * Stats go up: 3,4,...,17,18,18/10,18/20,...,18/220
  56  * Or even: 18/13, 18/23, 18/33, ..., 18/220
  57  *
  58  * Stats go down: 18/220, 18/210,..., 18/10, 18, 17, ..., 3
  59  * Or even: 18/13, 18/03, 18, 17, ..., 3
  60  */
  61 s16b modify_stat_value(int value, int amount)
  62 {
  63         int    i;
  64
  65         /* Reward */
  66         if (amount > 0)
  67         {
  68                 /* Apply each point */
  69                 for (i = 0; i < amount; i++)
  70                 {
  71                         /* One point at a time */
  72                         if (value < 18) value++;
  73
  74                         /* Ten "points" at a time */
  75                         else value += 10;
  76                 }
  77         }
  78
  79         /* Penalty */
  80         else if (amount < 0)
  81         {
  82                 /* Apply each point */
  83                 for (i = 0; i < (0 - amount); i++)
  84                 {
  85                         /* Ten points at a time */
  86                         if (value >= 18+10) value -= 10;
  87
  88                         /* Hack -- prevent weirdness */
  89                         else if (value > 18) value = 18;
  90
  91                         /* One point at a time */
  92                         else if (value > 3) value--;
  93                 }
  94         }
  95
  96         /* Return new value */
  97         return (value);
  98 }
  99
 100
 101
 102 /*
 103  * Print character info at given row, column in a 13 char field
 104  */
 105 static void prt_field(cptr info, int row, int col)
 106 {
 107         /* Dump 13 spaces to clear */
 108         c_put_str(TERM_WHITE, "             ", row, col);
 109
 110         /* Dump the info itself */
 111         c_put_str(TERM_L_BLUE, info, row, col);
 112 }
 113
 114
 115 /*
 116  *  Whether daytime or not
 117  */
 118 bool is_daytime(void)
 119 {
 120         s32b len = TURNS_PER_TICK * TOWN_DAWN;
 121         if ((turn % len) < (len / 2))
 122                 return TRUE;
 123         else
 124                 return FALSE;
 125 }
 126
 127 /*
 128  * Extract day, hour, min
 129  */
 130 void extract_day_hour_min(int *day, int *hour, int *min)
 131 {
 132         s32b len = TURNS_PER_TICK * TOWN_DAWN;
 133         s32b tick = turn % len + len / 4;
 134
 135         if ((p_ptr->prace == RACE_VAMPIRE) ||
 136             (p_ptr->prace == RACE_SKELETON) ||
 137             (p_ptr->prace == RACE_ZOMBIE) ||
 138             (p_ptr->prace == RACE_SPECTRE))
 139                 *day = (turn - (TURNS_PER_TICK * TOWN_DAWN *3/4)) / len + 1;
 140         else
 141                 *day = (turn + (TURNS_PER_TICK * TOWN_DAWN /4))/ len + 1;
 142         *hour = (24 * tick / len) % 24;
 143         *min = (1440 * tick / len) % 60;
 144 }
 145
 146 /*
 147  * Print time
 148  */
 149 void prt_time(void)
 150 {
 151         int day, hour, min;
 152
 153         /* Dump 13 spaces to clear */
 154         c_put_str(TERM_WHITE, "             ", ROW_DAY, COL_DAY);
 155
 156         extract_day_hour_min(&day, &hour, &min);
 157
 158         /* Dump the info itself */
 159         c_put_str(TERM_WHITE, format(
 160 #ifdef JP
 161                 "%2dÆüÌÜ",
 162 #else
 163                 "Day %-2d",
 164 #endif
 165                 day), ROW_DAY, COL_DAY);
 166
 167         c_put_str(TERM_WHITE, format("%2d:%02d", hour, min), ROW_DAY, COL_DAY+7);
 168 }
 169
 170
 171 cptr map_name(void)
 172 {
 173         if (p_ptr->inside_quest && (p_ptr->inside_quest < MIN_RANDOM_QUEST)
 174             && (quest[p_ptr->inside_quest].flags & QUEST_FLAG_PRESET))
 175 #ifdef JP
 176                 return "¥¯¥¨¥¹¥È";
 177 #else
 178                 return "Quest";
 179 #endif
 180         else if (p_ptr->wild_mode)
 181 #ifdef JP
 182                 return "ÃÏ¾å";
 183 #else
 184                 return "Surface";
 185 #endif
 186         else if (p_ptr->inside_arena)
 187 #ifdef JP
 188                 return "¥¢¥ê¡¼¥Ê";
 189 #else
 190                 return "Monster Arena";
 191 #endif
 192         else if (p_ptr->inside_battle)
 193 #ifdef JP
 194                 return "Æ®µ»¾ì";
 195 #else
 196                 return "Arena";
 197 #endif
 198         else if (!dun_level && p_ptr->town_num)
 199                 return town[p_ptr->town_num].name;
 200         else
 201                 return d_name+d_info[dungeon_type].name;
 202 }
 203
 204 /*
 205  * Print dungeon
 206  */
 207 static void prt_dungeon(void)
 208 {
 209         cptr dungeon_name;
 210         int col;
 211
 212         /* Dump 13 spaces to clear */
 213         c_put_str(TERM_WHITE, "             ", ROW_DUNGEON, COL_DUNGEON);
 214
 215         dungeon_name = map_name();
 216
 217         col = COL_DUNGEON + 6 - strlen(dungeon_name)/2;
 218         if (col < 0) col = 0;
 219
 220         /* Dump the info itself */
 221         c_put_str(TERM_L_UMBER, format("%s",dungeon_name),
 222                   ROW_DUNGEON, col);
 223 }
 224
 225
 226
 227
 228 /*
 229  * Print character stat in given row, column
 230  */
 231 static void prt_stat(int stat)
 232 {
 233         char tmp[32];
 234
 235         /* Display "injured" stat */
 236         if (p_ptr->stat_cur[stat] < p_ptr->stat_max[stat])
 237         {
 238                 put_str(stat_names_reduced[stat], ROW_STAT + stat, 0);
 239                 cnv_stat(p_ptr->stat_use[stat], tmp);
 240                 c_put_str(TERM_YELLOW, tmp, ROW_STAT + stat, COL_STAT + 6);
 241         }
 242
 243         /* Display "healthy" stat */
 244         else
 245         {
 246                 put_str(stat_names[stat], ROW_STAT + stat, 0);
 247                 cnv_stat(p_ptr->stat_use[stat], tmp);
 248                 c_put_str(TERM_L_GREEN, tmp, ROW_STAT + stat, COL_STAT + 6);
 249         }
 250
 251         /* Indicate natural maximum */
 252         if (p_ptr->stat_max[stat] == p_ptr->stat_max_max[stat])
 253         {
 254 #ifdef JP
 255                 /* ÆüËÜ¸ì¤Ë¤«¤Ö¤é¤Ê¤¤¤è¤¦¤ËÉ½¼¨°ÌÃÖ¤òÊÑ¹¹ */
 256                 put_str("!", ROW_STAT + stat, 5);
 257 #else
 258                 put_str("!", ROW_STAT + stat, 3);
 259 #endif
 260
 261         }
 262 }
 263
 264
 265 /*
 266  *  Data structure for status bar
 267  */
 268 #define BAR_TSUYOSHI 0
 269 #define BAR_HALLUCINATION 1
 270 #define BAR_BLINDNESS 2
 271 #define BAR_PARALYZE 3
 272 #define BAR_CONFUSE 4
 273 #define BAR_POISONED 5
 274 #define BAR_AFRAID 6
 275 #define BAR_LEVITATE 7
 276 #define BAR_REFLECTION 8
 277 #define BAR_PASSWALL 9
 278 #define BAR_WRAITH 10
 279 #define BAR_PROTEVIL 11
 280 #define BAR_KAWARIMI 12
 281 #define BAR_MAGICDEFENSE 13
 282 #define BAR_EXPAND 14
 283 #define BAR_STONESKIN 15
 284 #define BAR_MULTISHADOW 16
 285 #define BAR_REGMAGIC 17
 286 #define BAR_ULTIMATE 18
 287 #define BAR_INVULN 19
 288 #define BAR_IMMACID 20
 289 #define BAR_RESACID 21
 290 #define BAR_IMMELEC 22
 291 #define BAR_RESELEC 23
 292 #define BAR_IMMFIRE 24
 293 #define BAR_RESFIRE 25
 294 #define BAR_IMMCOLD 26
 295 #define BAR_RESCOLD 27
 296 #define BAR_RESPOIS 28
 297 #define BAR_RESNETH 29
 298 #define BAR_RESTIME 30
 299 #define BAR_DUSTROBE 31
 300 #define BAR_SHFIRE 32
 301 #define BAR_TOUKI 33
 302 #define BAR_SHHOLY 34
 303 #define BAR_EYEEYE 35
 304 #define BAR_BLESSED 36
 305 #define BAR_HEROISM 37
 306 #define BAR_BERSERK 38
 307 #define BAR_ATTKFIRE 39
 308 #define BAR_ATTKCOLD 40
 309 #define BAR_ATTKELEC 41
 310 #define BAR_ATTKACID 42
 311 #define BAR_ATTKPOIS 43
 312 #define BAR_ATTKCONF 44
 313 #define BAR_SENSEUNSEEN 45
 314 #define BAR_TELEPATHY 46
 315 #define BAR_REGENERATION 47
 316 #define BAR_INFRAVISION 48
 317 #define BAR_STEALTH 49
 318 #define BAR_SUPERSTEALTH 50
 319 #define BAR_RECALL 51
 320
 321
 322 static struct {
 323         byte attr;
 324         cptr sstr;
 325         cptr lstr;
 326 } bar[]
 327 #ifdef JP
 328 = {
 329         {TERM_YELLOW, "¤Ä", "¤Ä¤è¤·"},
 330         {TERM_VIOLET, "¸¸", "¸¸³Ð"},
 331         {TERM_L_DARK, "ÌÕ", "ÌÕÌÜ"},
 332         {TERM_RED, "áã", "Ëãáã"},
 333         {TERM_VIOLET, "Íð", "º®Íð"},
 334         {TERM_GREEN, "ÆÇ", "ÆÇ"},
 335         {TERM_BLUE, "¶²", "¶²ÉÝ"},
 336         {TERM_L_BLUE, "Éâ", "ÉâÍ·"},
 337         {TERM_SLATE, "È¿", "È¿¼Í"},
 338         {TERM_SLATE, "ÊÉ", "ÊÉÈ´¤±"},
 339         {TERM_L_DARK, "Í©", "Í©ÂÎ"},
 340         {TERM_SLATE, "¼Ù", "ËÉ¼Ù"},
 341         {TERM_VIOLET, "ÊÑ", "ÊÑ¤ï¤ê¿È"},
 342         {TERM_YELLOW, "Ëâ", "ËâË¡³»"},
 343         {TERM_L_UMBER, "¿", "¿¤Ó"},
 344         {TERM_WHITE, "ÀÐ", "ÀÐÈ©"},
 345         {TERM_L_BLUE, "Ê¬", "Ê¬¿È"},
 346         {TERM_SLATE, "ËÉ", "ËâË¡ËÉ¸æ"},
 347         {TERM_YELLOW, "µæ", "µæ¶Ë"},
 348         {TERM_YELLOW, "̵", "̵Ũ"},
 349         {TERM_L_GREEN, "»À", "»ÀÌÈ±Ö"},
 350         {TERM_GREEN, "»À", "ÂÑ»À"},
 351         {TERM_L_BLUE, "ÅÅ", "ÅÅÌÈ±Ö"},
 352         {TERM_BLUE, "ÅÅ", "ÂÑÅÅ"},
 353         {TERM_L_RED, "²Ð", "²ÐÌÈ±Ö"},
 354         {TERM_RED, "²Ð", "ÂÑ²Ð"},
 355         {TERM_WHITE, "Îä", "ÎäÌÈ±Ö"},
 356         {TERM_SLATE, "Îä", "ÂÑÎä"},
 357         {TERM_GREEN, "ÆÇ", "ÂÑÆÇ"},
 358         {TERM_L_DARK, "¹ö", "ÂÑÃÏ¹ö"},
 359         {TERM_L_BLUE, "»þ", "ÂÑ»þ´Ö"},
 360         {TERM_L_DARK, "¶À", "¶À¥ª¡¼¥é"},
 361         {TERM_L_RED, "¥ª", "²Ð¥ª¡¼¥é"},
 362         {TERM_WHITE, "Æ®", "Æ®µ¤"},
 363         {TERM_WHITE, "À»", "À»¥ª¡¼¥é"},
 364         {TERM_VIOLET, "ÌÜ", "ÌÜ¤Ë¤ÏÌÜ"},
 365         {TERM_WHITE, "½Ë", "½ËÊ¡"},
 366         {TERM_WHITE, "ͦ", "ͦ"},
 367         {TERM_RED, "¶¸", "¶¸Íð"},
 368         {TERM_L_RED, "²Ð", "Ëâ·õ²Ð"},
 369         {TERM_WHITE, "Îä", "Ëâ·õÎä"},
 370         {TERM_L_BLUE, "ÅÅ", "Ëâ·õÅÅ"},
 371         {TERM_SLATE, "»À", "Ëâ·õ»À"},
 372         {TERM_L_GREEN, "ÆÇ", "Ëâ·õÆÇ"},
 373         {TERM_RED, "Íð", "º®ÍðÂÇ·â"},
 374         {TERM_L_BLUE, "»ë", "Æ©ÌÀ»ë"},
 375         {TERM_ORANGE, "¥Æ", "¥Æ¥ì¥Ñ¥·"},
 376         {TERM_L_BLUE, "²ó", "²óÉü"},
 377         {TERM_L_RED, "ÀÖ", "ÀÖ³°"},
 378         {TERM_UMBER, "±£", "±£Ì©"},
 379         {TERM_YELLOW, "Ä¶±£", "Ä¶±£Ì©"},
 380         {TERM_WHITE, "µ¢", "µ¢´Ô"},
 381         {0, NULL, NULL}
 382 };
 383 #else
 384 = {
 385         {TERM_YELLOW, "Ts", "Tsuyoshi"},
 386         {TERM_VIOLET, "Hu", "Hullc"},
 387         {TERM_L_DARK, "Bl", "Blind"},
 388         {TERM_RED, "Pa", "Paralyzed"},
 389         {TERM_VIOLET, "Cf", "Confused"},
 390         {TERM_GREEN, "Po", "Poisoned"},
 391         {TERM_BLUE, "Af", "Afraid"},
 392         {TERM_L_BLUE, "Lv", "Levit"},
 393         {TERM_SLATE, "Rf", "Reflect"},
 394         {TERM_SLATE, "Pw", "PassWall"},
 395         {TERM_L_DARK, "Wr", "Wraith"},
 396         {TERM_SLATE, "Ev", "PrtEvl"},
 397         {TERM_VIOLET, "Kw", "Kawarimi"},
 398         {TERM_YELLOW, "Md", "MgcArm"},
 399         {TERM_L_UMBER, "Eh", "Expand"},
 400         {TERM_WHITE, "Ss", "StnSkn"},
 401         {TERM_L_BLUE, "Ms", "MltShdw"},
 402         {TERM_SLATE, "Rm", "ResMag"},
 403         {TERM_YELLOW, "Ul", "Ultima"},
 404         {TERM_YELLOW, "Iv", "Invuln"},
 405         {TERM_L_GREEN, "IAc", "ImmAcid"},
 406         {TERM_GREEN, "Ac", "Acid"},
 407         {TERM_L_BLUE, "IEl", "ImmElec"},
 408         {TERM_BLUE, "El", "Elec"},
 409         {TERM_L_RED, "IFi", "ImmFire"},
 410         {TERM_RED, "Fi", "Fire"},
 411         {TERM_WHITE, "ICo", "ImmCold"},
 412         {TERM_SLATE, "Co", "Cold"},
 413         {TERM_GREEN, "Po", "Pois"},
 414         {TERM_L_DARK, "Nt", "Nthr"},
 415         {TERM_L_BLUE, "Ti", "Time"},
 416         {TERM_L_DARK, "Mr", "Mirr"},
 417         {TERM_L_RED, "SFi", "SFire"},
 418         {TERM_WHITE, "Fo", "Force"},
 419         {TERM_WHITE, "Ho", "Holy"},
 420         {TERM_VIOLET, "Ee", "EyeEye"},
 421         {TERM_WHITE, "Bs", "Bless"},
 422         {TERM_WHITE, "He", "Hero"},
 423         {TERM_RED, "Br", "Berserk"},
 424         {TERM_L_RED, "BFi", "BFire"},
 425         {TERM_WHITE, "BCo", "BCold"},
 426         {TERM_L_BLUE, "BEl", "BElec"},
 427         {TERM_SLATE, "BAc", "BAcid"},
 428         {TERM_L_GREEN, "BPo", "BPois"},
 429         {TERM_RED, "TCf", "TchCnf"},
 430         {TERM_L_BLUE, "Se", "SInv"},
 431         {TERM_ORANGE, "Te", "Telepa"},
 432         {TERM_L_BLUE, "Rg", "Regen"},
 433         {TERM_L_RED, "If", "Infr"},
 434         {TERM_UMBER, "Sl", "Stealth"},
 435         {TERM_YELLOW, "Stlt", "Stealth"},
 436         {TERM_WHITE, "Rc", "Recall"},
 437         {0, NULL, NULL}
 438 };
 439 #endif
 440
 441 #define ADD_FLG(FLG) (bar_flags[FLG / 32] |= (1L << (FLG % 32)))
 442 #define IS_FLG(FLG) (bar_flags[FLG / 32] & (1L << (FLG % 32)))
 443
 444
 445 /*
 446  *  Show status bar
 447  */
 448 static void prt_status(void)
 449 {
 450         u32b bar_flags[2];
 451         int wid, hgt, row_statbar, max_col_statbar;
 452         int i, col = 0, num = 0;
 453         int space = 2;
 454
 455         Term_get_size(&wid, &hgt);
 456         row_statbar = hgt + ROW_STATBAR;
 457         max_col_statbar = wid + MAX_COL_STATBAR;
 458
 459         Term_erase(0, row_statbar, max_col_statbar);
 460
 461         bar_flags[0] = bar_flags[1] = 0L;
 462
 463         /* Tsuyoshi  */
 464         if (p_ptr->tsuyoshi) ADD_FLG(BAR_TSUYOSHI);
 465
 466         /* Hallucinating */
 467         if (p_ptr->image) ADD_FLG(BAR_HALLUCINATION);
 468
 469         /* Blindness */
 470         if (p_ptr->blind) ADD_FLG(BAR_BLINDNESS);
 471
 472         /* Paralysis */
 473         if (p_ptr->paralyzed) ADD_FLG(BAR_PARALYZE);
 474
 475         /* Confusion */
 476         if (p_ptr->confused) ADD_FLG(BAR_CONFUSE);
 477
 478         /* Posioned */
 479         if (p_ptr->poisoned) ADD_FLG(BAR_POISONED);
 480
 481         /* Times see-invisible */
 482         if (p_ptr->tim_invis) ADD_FLG(BAR_SENSEUNSEEN);
 483
 484         /* Timed esp */
 485         if (p_ptr->tim_esp || music_singing(MUSIC_MIND)) ADD_FLG(BAR_TELEPATHY);
 486
 487         /* Timed regenerate */
 488         if (p_ptr->tim_regen) ADD_FLG(BAR_REGENERATION);
 489
 490         /* Timed infra-vision */
 491         if (p_ptr->tim_infra) ADD_FLG(BAR_INFRAVISION);
 492
 493         /* Protection from evil */
 494         if (p_ptr->protevil) ADD_FLG(BAR_PROTEVIL);
 495
 496         /* Invulnerability */
 497         if (p_ptr->invuln || music_singing(MUSIC_INVULN)) ADD_FLG(BAR_INVULN);
 498
 499         /* Wraith form */
 500         if (p_ptr->wraith_form) ADD_FLG(BAR_WRAITH);
 501
 502         /* Kabenuke */
 503         if (p_ptr->kabenuke) ADD_FLG(BAR_PASSWALL);
 504
 505         if (p_ptr->tim_reflect) ADD_FLG(BAR_REFLECTION);
 506
 507         /* Heroism */
 508         if (p_ptr->hero || music_singing(MUSIC_HERO) || music_singing(MUSIC_SHERO)) ADD_FLG(BAR_HEROISM);
 509
 510         /* Super Heroism / berserk */
 511         if (p_ptr->shero) ADD_FLG(BAR_BERSERK);
 512
 513         /* Blessed */
 514         if (p_ptr->blessed || music_singing(MUSIC_BLESS)) ADD_FLG(BAR_BLESSED);
 515
 516         /* Shield */
 517         if (p_ptr->magicdef) ADD_FLG(BAR_MAGICDEFENSE);
 518
 519         if (p_ptr->tsubureru) ADD_FLG(BAR_EXPAND);
 520
 521         if (p_ptr->shield) ADD_FLG(BAR_STONESKIN);
 522
 523         if (p_ptr->special_defense & NINJA_KAWARIMI) ADD_FLG(BAR_KAWARIMI);
 524
 525         /* Oppose Acid */
 526         if (p_ptr->special_defense & DEFENSE_ACID) ADD_FLG(BAR_IMMACID);
 527         if (p_ptr->oppose_acid || music_singing(MUSIC_RESIST) || (p_ptr->special_defense & KATA_MUSOU)) ADD_FLG(BAR_RESACID);
 528
 529         /* Oppose Lightning */
 530         if (p_ptr->special_defense & DEFENSE_ELEC) ADD_FLG(BAR_IMMELEC);
 531         if (p_ptr->oppose_elec || music_singing(MUSIC_RESIST) || (p_ptr->special_defense & KATA_MUSOU)) ADD_FLG(BAR_RESELEC);
 532
 533         /* Oppose Fire */
 534         if (p_ptr->special_defense & DEFENSE_FIRE) ADD_FLG(BAR_IMMFIRE);
 535         if (p_ptr->oppose_fire || music_singing(MUSIC_RESIST) || (p_ptr->special_defense & KATA_MUSOU)) ADD_FLG(BAR_RESFIRE);
 536
 537         /* Oppose Cold */
 538         if (p_ptr->special_defense & DEFENSE_COLD) ADD_FLG(BAR_IMMCOLD);
 539         if (p_ptr->oppose_cold || music_singing(MUSIC_RESIST) || (p_ptr->special_defense & KATA_MUSOU)) ADD_FLG(BAR_RESCOLD);
 540
 541         /* Oppose Poison */
 542         if (p_ptr->oppose_pois || music_singing(MUSIC_RESIST) || (p_ptr->special_defense & KATA_MUSOU)) ADD_FLG(BAR_RESPOIS);
 543
 544         /* Word of Recall */
 545         if (p_ptr->word_recall) ADD_FLG(BAR_RECALL);
 546
 547         /* Afraid */
 548         if (p_ptr->afraid) ADD_FLG(BAR_AFRAID);
 549
 550         /* Resist time */
 551         if (p_ptr->tim_res_time) ADD_FLG(BAR_RESTIME);
 552
 553         if (p_ptr->multishadow) ADD_FLG(BAR_MULTISHADOW);
 554
 555         /* Confusing Hands */
 556         if (p_ptr->special_attack & ATTACK_CONFUSE) ADD_FLG(BAR_ATTKCONF);
 557
 558         if (p_ptr->resist_magic) ADD_FLG(BAR_REGMAGIC);
 559
 560         /* Ultimate-resistance */
 561         if (p_ptr->ult_res) ADD_FLG(BAR_ULTIMATE);
 562
 563         /* tim levitation */
 564         if (p_ptr->tim_ffall) ADD_FLG(BAR_LEVITATE);
 565
 566         if (p_ptr->tim_res_nether) ADD_FLG(BAR_RESNETH);
 567
 568         if (p_ptr->dustrobe) ADD_FLG(BAR_DUSTROBE);
 569
 570         /* Mahouken */
 571         if (p_ptr->special_attack & ATTACK_FIRE) ADD_FLG(BAR_ATTKFIRE);
 572         if (p_ptr->special_attack & ATTACK_COLD) ADD_FLG(BAR_ATTKCOLD);
 573         if (p_ptr->special_attack & ATTACK_ELEC) ADD_FLG(BAR_ATTKELEC);
 574         if (p_ptr->special_attack & ATTACK_ACID) ADD_FLG(BAR_ATTKACID);
 575         if (p_ptr->special_attack & ATTACK_POIS) ADD_FLG(BAR_ATTKPOIS);
 576         if (p_ptr->special_defense & NINJA_S_STEALTH) ADD_FLG(BAR_SUPERSTEALTH);
 577
 578         /* tim stealth */
 579         if (p_ptr->tim_sh_fire) ADD_FLG(BAR_SHFIRE);
 580
 581         if (p_ptr->tim_stealth || music_singing(MUSIC_STEALTH)) ADD_FLG(BAR_STEALTH);
 582
 583         if (p_ptr->tim_sh_touki) ADD_FLG(BAR_TOUKI);
 584
 585         /* Holy aura */
 586         if (p_ptr->tim_sh_holy) ADD_FLG(BAR_SHHOLY);
 587
 588         /* An Eye for an Eye */
 589         if (p_ptr->tim_eyeeye) ADD_FLG(BAR_EYEEYE);
 590
 591         /* Calcurate length */
 592         for (i = 0; bar[i].sstr; i++)
 593         {
 594                 if (IS_FLG(i))
 595                 {
 596                         col += strlen(bar[i].lstr) + 1;
 597                         num++;
 598                 }
 599         }
 600
 601         /* If there are not excess spaces for long strings, use short one */
 602         if (col - 1 > max_col_statbar)
 603         {
 604                 space = 0;
 605                 col = 0;
 606
 607                 for (i = 0; bar[i].sstr; i++)
 608                 {
 609                         if (IS_FLG(i))
 610                         {
 611                                 col += strlen(bar[i].sstr);
 612                         }
 613                 }
 614
 615                 /* If there are excess spaces for short string, use more */
 616                 if (col - 1 <= max_col_statbar - (num-1))
 617                 {
 618                         space = 1;
 619                         col += num - 1;
 620                 }
 621         }
 622
 623
 624         /* Centering display column */
 625         col = (max_col_statbar - col) / 2;
 626
 627         /* Display status bar */
 628         for (i = 0; bar[i].sstr; i++)
 629         {
 630                 if (IS_FLG(i))
 631                 {
 632                         cptr str;
 633                         if (space == 2) str = bar[i].lstr;
 634                         else str = bar[i].sstr;
 635
 636                         c_put_str(bar[i].attr, str, row_statbar, col);
 637                         col += strlen(str);
 638                         if (space > 0) col++;
 639                         if (col > max_col_statbar) break;
 640                 }
 641         }
 642 }
 643
 644
 645
 646 /*
 647  * Prints "title", including "wizard" or "winner" as needed.
 648  */
 649 static void prt_title(void)
 650 {
 651         cptr p = "";
 652         char str[14];
 653
 654         /* Wizard */
 655         if (wizard)
 656         {
 657 #ifdef JP
 658                 /* ±ÑÆüÀÚ¤êÂØ¤¨µ¡Ç½ ¾Î¹æ */
 659                 p = "[¥¦¥£¥¶¡¼¥É]";
 660 #else
 661                 p = "[=-WIZARD-=]";
 662 #endif
 663
 664         }
 665
 666         /* Winner */
 667         else if (total_winner || (p_ptr->lev > PY_MAX_LEVEL))
 668         {
 669                 if ((p_ptr->arena_number > MAX_ARENA_MONS+2) && (p_ptr->arena_number < 99))
 670                 {
 671 #ifdef JP
 672                         /* ±ÑÆüÀÚ¤êÂØ¤¨µ¡Ç½ ¾Î¹æ */
 673                         p = "*¿¿¡¦¾¡Íø¼Ô*";
 674
 675 #else
 676                         p = "*TRUEWINNER*";
 677 #endif
 678                 }
 679                 else
 680                 {
 681 #ifdef JP
 682                         /* ±ÑÆüÀÚ¤êÂØ¤¨µ¡Ç½ ¾Î¹æ */
 683                         p = "***¾¡Íø¼Ô***";
 684
 685 #else
 686                         p = "***WINNER***";
 687 #endif
 688                 }
 689         }
 690
 691         /* Normal */
 692         else
 693         {
 694 #ifdef JP
 695                 mb_strlcpy(str, player_title[p_ptr->pclass][(p_ptr->lev - 1) / 5], 14);
 696 #else
 697                 strncpy(str, player_title[p_ptr->pclass][(p_ptr->lev - 1) / 5], 13);
 698                 str[13] = '\0';
 699 #endif
 700                 p = str;
 701         }
 702
 703         prt_field(p, ROW_TITLE, COL_TITLE);
 704 }
 705
 706
 707 /*
 708  * Prints level
 709  */
 710 static void prt_level(void)
 711 {
 712         char tmp[32];
 713
 714 #ifdef JP
 715         sprintf(tmp, "%5d", p_ptr->lev);
 716 #else
 717         sprintf(tmp, "%6d", p_ptr->lev);
 718 #endif
 719
 720
 721         if (p_ptr->lev >= p_ptr->max_plv)
 722         {
 723 #ifdef JP
 724                 put_str("¥ì¥Ù¥ë ", ROW_LEVEL, 0);
 725                 c_put_str(TERM_L_GREEN, tmp, ROW_LEVEL, COL_LEVEL + 7);
 726 #else
 727                 put_str("LEVEL ", ROW_LEVEL, 0);
 728                 c_put_str(TERM_L_GREEN, tmp, ROW_LEVEL, COL_LEVEL + 6);
 729 #endif
 730
 731         }
 732         else
 733         {
 734 #ifdef JP
 735                 put_str("x¥ì¥Ù¥ë", ROW_LEVEL, 0);
 736                 c_put_str(TERM_YELLOW, tmp, ROW_LEVEL, COL_LEVEL + 7);
 737 #else
 738                 put_str("Level ", ROW_LEVEL, 0);
 739                 c_put_str(TERM_YELLOW, tmp, ROW_LEVEL, COL_LEVEL + 6);
 740 #endif
 741
 742         }
 743 }
 744
 745
 746 /*
 747  * Display the experience
 748  */
 749 static void prt_exp(void)
 750 {
 751         char out_val[32];
 752
 753         if ((p_ptr->prace == RACE_ANDROID) && !cheat_xtra)
 754                 (void)strcpy(out_val, "*******");
 755         else
 756 #ifdef JP
 757 (void)sprintf(out_val, "%7ld", (long)p_ptr->exp);
 758 #else
 759         (void)sprintf(out_val, "%8ld", (long)p_ptr->exp);
 760 #endif
 761
 762
 763         if (p_ptr->exp >= p_ptr->max_exp)
 764         {
 765 #ifdef JP
 766                 put_str("·Ð¸³ ", ROW_EXP, 0);
 767                 c_put_str(TERM_L_GREEN, out_val, ROW_EXP, COL_EXP + 5);
 768 #else
 769                 put_str("EXP ", ROW_EXP, 0);
 770                 c_put_str(TERM_L_GREEN, out_val, ROW_EXP, COL_EXP + 4);
 771 #endif
 772
 773         }
 774         else
 775         {
 776 #ifdef JP
 777                 put_str("x·Ð¸³", ROW_EXP, 0);
 778                 c_put_str(TERM_YELLOW, out_val, ROW_EXP, COL_EXP + 5);
 779 #else
 780                 put_str("Exp ", ROW_EXP, 0);
 781                 c_put_str(TERM_YELLOW, out_val, ROW_EXP, COL_EXP + 4);
 782 #endif
 783
 784         }
 785 }
 786
 787
 788 /*
 789  * Prints current gold
 790  */
 791 static void prt_gold(void)
 792 {
 793         char tmp[32];
 794
 795 #ifdef JP
 796         put_str("¡ð ", ROW_GOLD, COL_GOLD);
 797 #else
 798         put_str("AU ", ROW_GOLD, COL_GOLD);
 799 #endif
 800
 801         sprintf(tmp, "%9ld", (long)p_ptr->au);
 802         c_put_str(TERM_L_GREEN, tmp, ROW_GOLD, COL_GOLD + 3);
 803 }
 804
 805
 806
 807 /*
 808  * Prints current AC
 809  */
 810 static void prt_ac(void)
 811 {
 812         char tmp[32];
 813
 814 #ifdef JP
 815 /* AC ¤ÎÉ½¼¨Êý¼°¤òÊÑ¹¹¤·¤Æ¤¤¤ë */
 816         put_str(" £Á£Ã(     )", ROW_AC, COL_AC);
 817         sprintf(tmp, "%5d", p_ptr->dis_ac + p_ptr->dis_to_a);
 818         c_put_str(TERM_L_GREEN, tmp, ROW_AC, COL_AC + 6);
 819 #else
 820         put_str("Cur AC ", ROW_AC, COL_AC);
 821         sprintf(tmp, "%5d", p_ptr->dis_ac + p_ptr->dis_to_a);
 822         c_put_str(TERM_L_GREEN, tmp, ROW_AC, COL_AC + 7);
 823 #endif
 824
 825 }
 826
 827
 828 /*
 829  * Prints Cur/Max hit points
 830  */
 831 static void prt_hp(void)
 832 {
 833 /* ¥Ò¥Ã¥È¥Ý¥¤¥ó¥È¤ÎÉ½¼¨ÊýË¡¤òÊÑ¹¹ */
 834         char tmp[32];
 835
 836         byte color;
 837
 838         /* ¥¿¥¤¥È¥ë */
 839 /*      put_str(" £È£Ð¡¦£Í£Ð", ROW_HPMP, COL_HPMP); */
 840
 841         put_str("HP", ROW_CURHP, COL_CURHP);
 842
 843         /* ¸½ºß¤Î¥Ò¥Ã¥È¥Ý¥¤¥ó¥È */
 844         sprintf(tmp, "%4d", p_ptr->chp);
 845
 846         if (p_ptr->chp >= p_ptr->mhp)
 847         {
 848                 color = TERM_L_GREEN;
 849         }
 850         else if (p_ptr->chp > (p_ptr->mhp * hitpoint_warn) / 10)
 851         {
 852                 color = TERM_YELLOW;
 853         }
 854         else
 855         {
 856                 color = TERM_RED;
 857         }
 858
 859         c_put_str(color, tmp, ROW_CURHP, COL_CURHP+3);
 860
 861         /* ¶èÀÚ¤ê */
 862         put_str( "/", ROW_CURHP, COL_CURHP + 7 );
 863
 864         /* ºÇÂç¥Ò¥Ã¥È¥Ý¥¤¥ó¥È */
 865         sprintf(tmp, "%4d", p_ptr->mhp);
 866         color = TERM_L_GREEN;
 867
 868         c_put_str(color, tmp, ROW_CURHP, COL_CURHP + 8 );
 869 }
 870
 871
 872 /*
 873  * Prints players max/cur spell points
 874  */
 875 static void prt_sp(void)
 876 {
 877 /* ¥Þ¥¸¥Ã¥¯¥Ý¥¤¥ó¥È¤ÎÉ½¼¨ÊýË¡¤òÊÑ¹¹¤·¤Æ¤¤¤ë */
 878         char tmp[32];
 879         byte color;
 880
 881
 882         /* Do not show mana unless it matters */
 883         if (!mp_ptr->spell_book) return;
 884
 885         /* ¥¿¥¤¥È¥ë */
 886 /*      put_str(" £Í£Ð / ºÇÂç", ROW_MAXSP, COL_MAXSP); */
 887
 888 #ifdef JP
 889         put_str("MP", ROW_CURSP, COL_CURSP);
 890 #else
 891         put_str("SP", ROW_CURSP, COL_CURSP);
 892 #endif
 893
 894         /* ¸½ºß¤Î¥Þ¥¸¥Ã¥¯¥Ý¥¤¥ó¥È */
 895         sprintf(tmp, "%4d", p_ptr->csp);
 896
 897         if (p_ptr->csp >= p_ptr->msp)
 898         {
 899                 color = TERM_L_GREEN;
 900         }
 901         else if (p_ptr->csp > (p_ptr->msp * hitpoint_warn) / 10)
 902         {
 903                 color = TERM_YELLOW;
 904         }
 905         else
 906         {
 907                 color = TERM_RED;
 908         }
 909
 910         c_put_str(color, tmp, ROW_CURSP, COL_CURSP+3);
 911
 912         /* ¶èÀÚ¤ê */
 913         put_str( "/", ROW_CURSP, COL_CURSP + 7 );
 914
 915         /* ºÇÂç¥Þ¥¸¥Ã¥¯¥Ý¥¤¥ó¥È */
 916         sprintf(tmp, "%4d", p_ptr->msp);
 917         color = TERM_L_GREEN;
 918
 919         c_put_str(color, tmp, ROW_CURSP, COL_CURSP + 8);
 920 }
 921
 922
 923 /*
 924  * Prints depth in stat area
 925  */
 926 static void prt_depth(void)
 927 {
 928         char depths[32];
 929         int wid, hgt, row_depth, col_depth;
 930
 931         Term_get_size(&wid, &hgt);
 932         col_depth = wid + COL_DEPTH;
 933         row_depth = hgt + ROW_DEPTH;
 934
 935         if (!dun_level)
 936         {
 937 #ifdef JP
 938                 strcpy(depths, "ÃÏ¾å");
 939 #else
 940                 strcpy(depths, "Surf.");
 941 #endif
 942         }
 943         else if (p_ptr->inside_quest && !dungeon_type)
 944         {
 945 #ifdef JP
 946 strcpy(depths, "ÃÏ¾å");
 947 #else
 948                 strcpy(depths, "Quest");
 949 #endif
 950
 951         }
 952         else if (depth_in_feet)
 953         {
 954 #ifdef JP
 955 (void)sprintf(depths, "%d ft", dun_level * 50);
 956 #else
 957                 (void)sprintf(depths, "%d ft", dun_level * 50);
 958 #endif
 959
 960         }
 961         else
 962         {
 963 #ifdef JP
 964 sprintf(depths, "%d ³¬", dun_level);
 965 #else
 966                 (void)sprintf(depths, "Lev %d", dun_level);
 967 #endif
 968
 969         }
 970
 971         /* Right-Adjust the "depth", and clear old values */
 972         prt(format("%7s", depths), row_depth, col_depth);
 973 }
 974
 975
 976 /*
 977  * Prints status of hunger
 978  */
 979 static void prt_hunger(void)
 980 {
 981         /* Fainting / Starving */
 982         if (p_ptr->food < PY_FOOD_FAINT)
 983         {
 984 #ifdef JP
 985                 c_put_str(TERM_RED, "¿ê¼å  ", ROW_HUNGRY, COL_HUNGRY);
 986 #else
 987                 c_put_str(TERM_RED, "Weak  ", ROW_HUNGRY, COL_HUNGRY);
 988 #endif
 989
 990         }
 991
 992         /* Weak */
 993         else if (p_ptr->food < PY_FOOD_WEAK)
 994         {
 995 #ifdef JP
 996                 c_put_str(TERM_ORANGE, "¿ê¼å  ", ROW_HUNGRY, COL_HUNGRY);
 997 #else
 998                 c_put_str(TERM_ORANGE, "Weak  ", ROW_HUNGRY, COL_HUNGRY);
 999 #endif
1000
1001         }
1002
1003         /* Hungry */
1004         else if (p_ptr->food < PY_FOOD_ALERT)
1005         {
1006 #ifdef JP
1007                 c_put_str(TERM_YELLOW, "¶õÊ¢  ", ROW_HUNGRY, COL_HUNGRY);
1008 #else
1009                 c_put_str(TERM_YELLOW, "Hungry", ROW_HUNGRY, COL_HUNGRY);
1010 #endif
1011
1012         }
1013
1014         /* Normal */
1015         else if (p_ptr->food < PY_FOOD_FULL)
1016         {
1017                 c_put_str(TERM_L_GREEN, "      ", ROW_HUNGRY, COL_HUNGRY);
1018         }
1019
1020         /* Full */
1021         else if (p_ptr->food < PY_FOOD_MAX)
1022         {
1023 #ifdef JP
1024                 c_put_str(TERM_L_GREEN, "ËþÊ¢  ", ROW_HUNGRY, COL_HUNGRY);
1025 #else
1026                 c_put_str(TERM_L_GREEN, "Full  ", ROW_HUNGRY, COL_HUNGRY);
1027 #endif
1028
1029         }
1030
1031         /* Gorged */
1032         else
1033         {
1034 #ifdef JP
1035                 c_put_str(TERM_GREEN, "¿©²á¤®", ROW_HUNGRY, COL_HUNGRY);
1036 #else
1037                 c_put_str(TERM_GREEN, "Gorged", ROW_HUNGRY, COL_HUNGRY);
1038 #endif
1039
1040         }
1041 }
1042
1043
1044 /*
1045  * Prints Searching, Resting, Paralysis, or 'count' status
1046  * Display is always exactly 10 characters wide (see below)
1047  *
1048  * This function was a major bottleneck when resting, so a lot of
1049  * the text formatting code was optimized in place below.
1050  */
1051 static void prt_state(void)
1052 {
1053         byte attr = TERM_WHITE;
1054
1055         char text[5];
1056
1057         /* Repeating */
1058         if (command_rep)
1059         {
1060                 if (command_rep > 999)
1061                 {
1062 #ifdef JP
1063 sprintf(text, "%2d00", command_rep / 100);
1064 #else
1065                         (void)sprintf(text, "%2d00", command_rep / 100);
1066 #endif
1067
1068                 }
1069                 else
1070                 {
1071 #ifdef JP
1072 sprintf(text, "  %2d", command_rep);
1073 #else
1074                         (void)sprintf(text, "  %2d", command_rep);
1075 #endif
1076
1077                 }
1078         }
1079
1080         /* Action */
1081         else
1082         {
1083                 switch(p_ptr->action)
1084                 {
1085                         case ACTION_SEARCH:
1086                         {
1087 #ifdef JP
1088                                 strcpy(text, "Ãµº÷");
1089 #else
1090                                 strcpy(text, "Sear");
1091 #endif
1092                                 break;
1093                         }
1094                         case ACTION_REST:
1095                         {
1096                                 int i;
1097
1098                                 /* Start with "Rest" */
1099 #ifdef JP
1100                                 strcpy(text, "    ");
1101 #else
1102                                 strcpy(text, "    ");
1103 #endif
1104
1105
1106                                 /* Extensive (timed) rest */
1107                                 if (resting >= 1000)
1108                                 {
1109                                         i = resting / 100;
1110                                         text[3] = '0';
1111                                         text[2] = '0';
1112                                         text[1] = '0' + (i % 10);
1113                                         text[0] = '0' + (i / 10);
1114                                 }
1115
1116                                 /* Long (timed) rest */
1117                                 else if (resting >= 100)
1118                                 {
1119                                         i = resting;
1120                                         text[3] = '0' + (i % 10);
1121                                         i = i / 10;
1122                                         text[2] = '0' + (i % 10);
1123                                         text[1] = '0' + (i / 10);
1124                                 }
1125
1126                                 /* Medium (timed) rest */
1127                                 else if (resting >= 10)
1128                                 {
1129                                         i = resting;
1130                                         text[3] = '0' + (i % 10);
1131                                         text[2] = '0' + (i / 10);
1132                                 }
1133
1134                                 /* Short (timed) rest */
1135                                 else if (resting > 0)
1136                                 {
1137                                         i = resting;
1138                                         text[3] = '0' + (i);
1139                                 }
1140
1141                                 /* Rest until healed */
1142                                 else if (resting == -1)
1143                                 {
1144                                         text[0] = text[1] = text[2] = text[3] = '*';
1145                                 }
1146
1147                                 /* Rest until done */
1148                                 else if (resting == -2)
1149                                 {
1150                                         text[0] = text[1] = text[2] = text[3] = '&';
1151                                 }
1152                                 break;
1153                         }
1154                         case ACTION_LEARN:
1155                         {
1156 #ifdef JP
1157                                 strcpy(text, "³Ø½¬");
1158 #else
1159                                 strcpy(text, "lear");
1160 #endif
1161                                 if (new_mane) attr = TERM_L_RED;
1162                                 break;
1163                         }
1164                         case ACTION_FISH:
1165                         {
1166 #ifdef JP
1167                                 strcpy(text, "Äà¤ê");
1168 #else
1169                                 strcpy(text, "fish");
1170 #endif
1171                                 break;
1172                         }
1173                         case ACTION_KAMAE:
1174                         {
1175                                 int i;
1176                                 for (i = 0; i < MAX_KAMAE; i++)
1177                                         if (p_ptr->special_defense & (KAMAE_GENBU << i)) break;
1178                                 switch (i)
1179                                 {
1180                                         case 0: attr = TERM_GREEN;break;
1181                                         case 1: attr = TERM_WHITE;break;
1182                                         case 2: attr = TERM_L_BLUE;break;
1183                                         case 3: attr = TERM_L_RED;break;
1184                                 }
1185                                 strcpy(text, kamae_shurui[i].desc);
1186                                 break;
1187                         }
1188                         case ACTION_KATA:
1189                         {
1190                                 int i;
1191                                 for (i = 0; i < MAX_KATA; i++)
1192                                         if (p_ptr->special_defense & (KATA_IAI << i)) break;
1193                                 strcpy(text, kata_shurui[i].desc);
1194                                 break;
1195                         }
1196                         case ACTION_SING:
1197                         {
1198 #ifdef JP
1199                                 strcpy(text, "²Î  ");
1200 #else
1201                                 strcpy(text, "Sing");
1202 #endif
1203                                 break;
1204                         }
1205                         case ACTION_HAYAGAKE:
1206                         {
1207 #ifdef JP
1208                                 strcpy(text, "Â®¶î");
1209 #else
1210                                 strcpy(text, "Fast");
1211 #endif
1212                                 break;
1213                         }
1214                         default:
1215                         {
1216                                 strcpy(text, "    ");
1217                                 break;
1218                         }
1219                 }
1220         }
1221
1222         /* Display the info (or blanks) */
1223         c_put_str(attr, format("%5.5s",text), ROW_STATE, COL_STATE);
1224 }
1225
1226
1227 /*
1228  * Prints the speed of a character.                     -CJS-
1229  */
1230 static void prt_speed(void)
1231 {
1232         int i = p_ptr->pspeed;
1233         bool is_fast = (p_ptr->fast || music_singing(MUSIC_SPEED) || music_singing(MUSIC_SHERO));
1234
1235         byte attr = TERM_WHITE;
1236         char buf[32] = "";
1237         int wid, hgt, row_speed, col_speed;
1238
1239         Term_get_size(&wid, &hgt);
1240         col_speed = wid + COL_SPEED;
1241         row_speed = hgt + ROW_SPEED;
1242
1243         /* Hack -- Visually "undo" the Search Mode Slowdown */
1244         if (p_ptr->action == ACTION_SEARCH) i += 10;
1245
1246         /* Fast */
1247         if (i > 110)
1248         {
1249                 if (p_ptr->riding)
1250                 {
1251                         if (m_list[p_ptr->riding].fast && !m_list[p_ptr->riding].slow) attr = TERM_L_BLUE;
1252                         else if (m_list[p_ptr->riding].slow && !m_list[p_ptr->riding].fast) attr = TERM_VIOLET;
1253                         else attr = TERM_GREEN;
1254                 }
1255                 else if ((is_fast && !p_ptr->slow) || p_ptr->lightspeed) attr = TERM_YELLOW;
1256                 else if (p_ptr->slow && !is_fast) attr = TERM_VIOLET;
1257                 else attr = TERM_L_GREEN;
1258 #ifdef JP
1259                 sprintf(buf, "%s(+%d)", (p_ptr->riding ? "¾èÇÏ" : "²ÃÂ®"), (i - 110));
1260 #else
1261                 sprintf(buf, "Fast(+%d)", (i - 110));
1262 #endif
1263
1264         }
1265
1266         /* Slow */
1267         else if (i < 110)
1268         {
1269                 if (p_ptr->riding)
1270                 {
1271                         if (m_list[p_ptr->riding].fast && !m_list[p_ptr->riding].slow) attr = TERM_L_BLUE;
1272                         else if (m_list[p_ptr->riding].slow && !m_list[p_ptr->riding].fast) attr = TERM_VIOLET;
1273                         else attr = TERM_RED;
1274                 }
1275                 else if (is_fast && !p_ptr->slow) attr = TERM_YELLOW;
1276                 else if (p_ptr->slow && !is_fast) attr = TERM_VIOLET;
1277                 else attr = TERM_L_UMBER;
1278 #ifdef JP
1279                 sprintf(buf, "%s(-%d)", (p_ptr->riding ? "¾èÇÏ" : "¸ºÂ®"), (110 - i));
1280 #else
1281                 sprintf(buf, "Slow(-%d)", (110 - i));
1282 #endif
1283         }
1284         else if (p_ptr->riding)
1285         {
1286                 attr = TERM_GREEN;
1287 #ifdef JP
1288                 strcpy(buf, "¾èÇÏÃæ");
1289 #else
1290                 strcpy(buf, "Riding");
1291 #endif
1292         }
1293
1294         /* Display the speed */
1295         c_put_str(attr, format("%-9s", buf), row_speed, col_speed);
1296 }
1297
1298
1299 static void prt_study(void)
1300 {
1301         int wid, hgt, row_study, col_study;
1302
1303         Term_get_size(&wid, &hgt);
1304         col_study = wid + COL_STUDY;
1305         row_study = hgt + ROW_STUDY;
1306
1307         if (p_ptr->new_spells)
1308         {
1309 #ifdef JP
1310                 put_str("³Ø½¬", row_study, col_study);
1311 #else
1312                 put_str("Stud", row_study, col_study);
1313 #endif
1314
1315         }
1316         else
1317         {
1318                 put_str("    ", row_study, col_study);
1319         }
1320 }
1321
1322
1323 static void prt_mane(void)
1324 {
1325         int wid, hgt, row_study, col_study;
1326
1327         Term_get_size(&wid, &hgt);
1328         col_study = wid + COL_STUDY;
1329         row_study = hgt + ROW_STUDY;
1330
1331         if (p_ptr->pclass == CLASS_IMITATOR)
1332         {
1333                 if (mane_num)
1334                 {
1335                         byte attr;
1336                         if (new_mane) attr = TERM_L_RED;
1337                         else attr = TERM_WHITE;
1338 #ifdef JP
1339                         c_put_str(attr, "¤Þ¤Í", row_study, col_study);
1340 #else
1341                         c_put_str(attr, "Mane", row_study, col_study);
1342 #endif
1343                 }
1344                 else
1345                 {
1346                         put_str("    ", row_study, col_study);
1347                 }
1348         }
1349 }
1350
1351
1352 static void prt_cut(void)
1353 {
1354         int c = p_ptr->cut;
1355
1356         if (c > 1000)
1357         {
1358 #ifdef JP
1359                 c_put_str(TERM_L_RED, "Ã×Ì¿½ý      ", ROW_CUT, COL_CUT);
1360 #else
1361                 c_put_str(TERM_L_RED, "Mortal wound", ROW_CUT, COL_CUT);
1362 #endif
1363
1364         }
1365         else if (c > 200)
1366         {
1367 #ifdef JP
1368                 c_put_str(TERM_RED, "¤Ò¤É¤¤¿¼¼ê  ", ROW_CUT, COL_CUT);
1369 #else
1370                 c_put_str(TERM_RED, "Deep gash   ", ROW_CUT, COL_CUT);
1371 #endif
1372
1373         }
1374         else if (c > 100)
1375         {
1376 #ifdef JP
1377                 c_put_str(TERM_RED, "½Å½ý        ", ROW_CUT, COL_CUT);
1378 #else
1379                 c_put_str(TERM_RED, "Severe cut  ", ROW_CUT, COL_CUT);
1380 #endif
1381
1382         }
1383         else if (c > 50)
1384         {
1385 #ifdef JP
1386                 c_put_str(TERM_ORANGE, "ÂçÊÑ¤Ê½ý    ", ROW_CUT, COL_CUT);
1387 #else
1388                 c_put_str(TERM_ORANGE, "Nasty cut   ", ROW_CUT, COL_CUT);
1389 #endif
1390
1391         }
1392         else if (c > 25)
1393         {
1394 #ifdef JP
1395                 c_put_str(TERM_ORANGE, "¤Ò¤É¤¤½ý    ", ROW_CUT, COL_CUT);
1396 #else
1397                 c_put_str(TERM_ORANGE, "Bad cut     ", ROW_CUT, COL_CUT);
1398 #endif
1399
1400         }
1401         else if (c > 10)
1402         {
1403 #ifdef JP
1404                 c_put_str(TERM_YELLOW, "·Ú½ý        ", ROW_CUT, COL_CUT);
1405 #else
1406                 c_put_str(TERM_YELLOW, "Light cut   ", ROW_CUT, COL_CUT);
1407 #endif
1408
1409         }
1410         else if (c)
1411         {
1412 #ifdef JP
1413                 c_put_str(TERM_YELLOW, "¤«¤¹¤ê½ý    ", ROW_CUT, COL_CUT);
1414 #else
1415                 c_put_str(TERM_YELLOW, "Graze       ", ROW_CUT, COL_CUT);
1416 #endif
1417
1418         }
1419         else
1420         {
1421                 put_str("            ", ROW_CUT, COL_CUT);
1422         }
1423 }
1424
1425
1426
1427 static void prt_stun(void)
1428 {
1429         int s = p_ptr->stun;
1430
1431         if (s > 100)
1432         {
1433 #ifdef JP
1434                 c_put_str(TERM_RED, "°Õ¼±ÉÔÌÀÎÆ  ", ROW_STUN, COL_STUN);
1435 #else
1436                 c_put_str(TERM_RED, "Knocked out ", ROW_STUN, COL_STUN);
1437 #endif
1438
1439         }
1440         else if (s > 50)
1441         {
1442 #ifdef JP
1443                 c_put_str(TERM_ORANGE, "¤Ò¤É¤¯Û¯Û°  ", ROW_STUN, COL_STUN);
1444 #else
1445                 c_put_str(TERM_ORANGE, "Heavy stun  ", ROW_STUN, COL_STUN);
1446 #endif
1447
1448         }
1449         else if (s)
1450         {
1451 #ifdef JP
1452                 c_put_str(TERM_ORANGE, "ۯ۰        ", ROW_STUN, COL_STUN);
1453 #else
1454                 c_put_str(TERM_ORANGE, "Stun        ", ROW_STUN, COL_STUN);
1455 #endif
1456
1457         }
1458         else
1459         {
1460                 put_str("            ", ROW_STUN, COL_STUN);
1461         }
1462 }
1463
1464
1465
1466 /*
1467  * Redraw the "monster health bar"      -DRS-
1468  * Rather extensive modifications by    -BEN-
1469  *
1470  * The "monster health bar" provides visual feedback on the "health"
1471  * of the monster currently being "tracked".  There are several ways
1472  * to "track" a monster, including targetting it, attacking it, and
1473  * affecting it (and nobody else) with a ranged attack.
1474  *
1475  * Display the monster health bar (affectionately known as the
1476  * "health-o-meter").  Clear health bar if nothing is being tracked.
1477  * Auto-track current target monster when bored.  Note that the
1478  * health-bar stops tracking any monster that "disappears".
1479  */
1480 static void health_redraw(void)
1481 {
1482
1483 #ifdef DRS_SHOW_HEALTH_BAR
1484
1485         /* Not tracking */
1486         if (!p_ptr->health_who)
1487         {
1488                 /* Erase the health bar */
1489                 Term_erase(COL_INFO, ROW_INFO, 12);
1490         }
1491
1492         /* Tracking an unseen monster */
1493         else if (!m_list[p_ptr->health_who].ml)
1494         {
1495                 /* Indicate that the monster health is "unknown" */
1496                 Term_putstr(COL_INFO, ROW_INFO, 12, TERM_WHITE, "[----------]");
1497         }
1498
1499         /* Tracking a hallucinatory monster */
1500         else if (p_ptr->image)
1501         {
1502                 /* Indicate that the monster health is "unknown" */
1503                 Term_putstr(COL_INFO, ROW_INFO, 12, TERM_WHITE, "[----------]");
1504         }
1505
1506         /* Tracking a dead monster (???) */
1507         else if (!m_list[p_ptr->health_who].hp < 0)
1508         {
1509                 /* Indicate that the monster health is "unknown" */
1510                 Term_putstr(COL_INFO, ROW_INFO, 12, TERM_WHITE, "[----------]");
1511         }
1512
1513         /* Tracking a visible monster */
1514         else
1515         {
1516                 int pct, pct2, len;
1517
1518                 monster_type *m_ptr = &m_list[p_ptr->health_who];
1519
1520                 /* Default to almost dead */
1521                 byte attr = TERM_RED;
1522
1523                 /* Extract the "percent" of health */
1524                 pct = 100L * m_ptr->hp / m_ptr->maxhp;
1525                 pct2 = 100L * m_ptr->hp / m_ptr->max_maxhp;
1526
1527                 /* Badly wounded */
1528                 if (pct >= 10) attr = TERM_L_RED;
1529
1530                 /* Wounded */
1531                 if (pct >= 25) attr = TERM_ORANGE;
1532
1533                 /* Somewhat Wounded */
1534                 if (pct >= 60) attr = TERM_YELLOW;
1535
1536                 /* Healthy */
1537                 if (pct >= 100) attr = TERM_L_GREEN;
1538
1539                 /* Afraid */
1540                 if (m_ptr->monfear) attr = TERM_VIOLET;
1541
1542                 /* Asleep */
1543                 if (m_ptr->csleep) attr = TERM_BLUE;
1544
1545                 /* Invulnerable */
1546                 if (m_ptr->invulner) attr = TERM_WHITE;
1547
1548                 /* Convert percent into "health" */
1549                 len = (pct2 < 10) ? 1 : (pct2 < 90) ? (pct2 / 10 + 1) : 10;
1550
1551                 /* Default to "unknown" */
1552                 Term_putstr(COL_INFO, ROW_INFO, 12, TERM_WHITE, "[----------]");
1553
1554                 /* Dump the current "health" (use '*' symbols) */
1555                 Term_putstr(COL_INFO + 1, ROW_INFO, len, attr, "**********");
1556         }
1557
1558 #endif
1559
1560 }
1561
1562
1563
1564 static void riding_health_redraw(void)
1565 {
1566
1567 #ifdef DRS_SHOW_HEALTH_BAR
1568
1569         /* Not tracking */
1570         if (!p_ptr->riding)
1571         {
1572                 /* Erase the health bar */
1573                 Term_erase(COL_RIDING_INFO, ROW_RIDING_INFO, 12);
1574         }
1575
1576         /* Tracking a hallucinatory monster */
1577         else if (p_ptr->image)
1578         {
1579                 /* Indicate that the monster health is "unknown" */
1580                 Term_putstr(COL_RIDING_INFO, ROW_RIDING_INFO, 12, TERM_WHITE, "[----------]");
1581         }
1582
1583         /* Tracking a dead monster (???) */
1584         else if (!m_list[p_ptr->health_who].hp < 0)
1585         {
1586                 /* Indicate that the monster health is "unknown" */
1587                 Term_putstr(COL_RIDING_INFO, ROW_RIDING_INFO, 12, TERM_WHITE, "[----------]");
1588         }
1589
1590         /* Tracking a visible monster */
1591         else
1592         {
1593                 int pct, pct2, len;
1594
1595                 monster_type *m_ptr = &m_list[p_ptr->riding];
1596
1597                 /* Default to almost dead */
1598                 byte attr = TERM_RED;
1599
1600                 /* Extract the "percent" of health */
1601                 pct = 100L * m_ptr->hp / m_ptr->maxhp;
1602                 pct2 = 100L * m_ptr->hp / m_ptr->max_maxhp;
1603
1604                 /* Badly wounded */
1605                 if (pct >= 10) attr = TERM_L_RED;
1606
1607                 /* Wounded */
1608                 if (pct >= 25) attr = TERM_ORANGE;
1609
1610                 /* Somewhat Wounded */
1611                 if (pct >= 60) attr = TERM_YELLOW;
1612
1613                 /* Healthy */
1614                 if (pct >= 100) attr = TERM_L_GREEN;
1615
1616                 /* Afraid */
1617                 if (m_ptr->monfear) attr = TERM_VIOLET;
1618
1619                 /* Asleep */
1620                 if (m_ptr->csleep) attr = TERM_BLUE;
1621
1622                 /* Invulnerable */
1623                 if (m_ptr->invulner) attr = TERM_WHITE;
1624
1625                 /* Convert percent into "health" */
1626                 len = (pct2 < 10) ? 1 : (pct2 < 90) ? (pct2 / 10 + 1) : 10;
1627
1628                 /* Default to "unknown" */
1629                 Term_putstr(COL_RIDING_INFO, ROW_RIDING_INFO, 12, TERM_WHITE, "[----------]");
1630
1631                 /* Dump the current "health" (use '*' symbols) */
1632                 Term_putstr(COL_RIDING_INFO + 1, ROW_RIDING_INFO, len, attr, "**********");
1633         }
1634
1635 #endif
1636
1637 }
1638
1639
1640
1641 /*
1642  * Display basic info (mostly left of map)
1643  */
1644 static void prt_frame_basic(void)
1645 {
1646         int i;
1647
1648         /* Race and Class */
1649         if (p_ptr->mimic_form)
1650                 prt_field(mimic_info[p_ptr->mimic_form].title, ROW_RACE, COL_RACE);
1651         else
1652         {
1653 #ifdef JP
1654                 char str[14];
1655                 mb_strlcpy(str, rp_ptr->title, 14);
1656                 prt_field(str, ROW_RACE, COL_RACE);
1657 #else
1658                 prt_field(rp_ptr->title, ROW_RACE, COL_RACE);
1659 #endif
1660         }
1661 /*      prt_field(cp_ptr->title, ROW_CLASS, COL_CLASS); */
1662 /*      prt_field(ap_ptr->title, ROW_SEIKAKU, COL_SEIKAKU); */
1663
1664
1665         /* Title */
1666         prt_title();
1667
1668         /* Level/Experience */
1669         prt_level();
1670         prt_exp();
1671
1672         /* All Stats */
1673         for (i = 0; i < 6; i++) prt_stat(i);
1674
1675         /* Armor */
1676         prt_ac();
1677
1678         /* Hitpoints */
1679         prt_hp();
1680
1681         /* Spellpoints */
1682         prt_sp();
1683
1684         /* Gold */
1685         prt_gold();
1686
1687         /* Current depth */
1688         prt_depth();
1689
1690         /* Special */
1691         health_redraw();
1692         riding_health_redraw();
1693 }
1694
1695
1696 /*
1697  * Display extra info (mostly below map)
1698  */
1699 static void prt_frame_extra(void)
1700 {
1701         /* Cut/Stun */
1702         prt_cut();
1703         prt_stun();
1704
1705         /* Food */
1706         prt_hunger();
1707
1708         /* State */
1709         prt_state();
1710
1711         /* Speed */
1712         prt_speed();
1713
1714         /* Study spells */
1715         prt_study();
1716
1717         prt_mane();
1718
1719         prt_status();
1720 }
1721
1722
1723 /*
1724  * Hack -- display inventory in sub-windows
1725  */
1726 static void fix_inven(void)
1727 {
1728         int j;
1729
1730         /* Scan windows */
1731         for (j = 0; j < 8; j++)
1732         {
1733                 term *old = Term;
1734
1735                 /* No window */
1736                 if (!angband_term[j]) continue;
1737
1738                 /* No relevant flags */
1739                 if (!(window_flag[j] & (PW_INVEN))) continue;
1740
1741                 /* Activate */
1742                 Term_activate(angband_term[j]);
1743
1744                 /* Display inventory */
1745                 display_inven();
1746
1747                 /* Fresh */
1748                 Term_fresh();
1749
1750                 /* Restore */
1751                 Term_activate(old);
1752         }
1753 }
1754
1755
1756
1757 /*
1758  * Hack -- display equipment in sub-windows
1759  */
1760 static void fix_equip(void)
1761 {
1762         int j;
1763
1764         /* Scan windows */
1765         for (j = 0; j < 8; j++)
1766         {
1767                 term *old = Term;
1768
1769                 /* No window */
1770                 if (!angband_term[j]) continue;
1771
1772                 /* No relevant flags */
1773                 if (!(window_flag[j] & (PW_EQUIP))) continue;
1774
1775                 /* Activate */
1776                 Term_activate(angband_term[j]);
1777
1778                 /* Display equipment */
1779                 display_equip();
1780
1781                 /* Fresh */
1782                 Term_fresh();
1783
1784                 /* Restore */
1785                 Term_activate(old);
1786         }
1787 }
1788
1789
1790 /*
1791  * Hack -- display equipment in sub-windows
1792  */
1793 static void fix_spell(void)
1794 {
1795         int j;
1796
1797         /* Scan windows */
1798         for (j = 0; j < 8; j++)
1799         {
1800                 term *old = Term;
1801
1802                 /* No window */
1803                 if (!angband_term[j]) continue;
1804
1805                 /* No relevant flags */
1806                 if (!(window_flag[j] & (PW_SPELL))) continue;
1807
1808                 /* Activate */
1809                 Term_activate(angband_term[j]);
1810
1811                 /* Display spell list */
1812                 display_spell_list();
1813
1814                 /* Fresh */
1815                 Term_fresh();
1816
1817                 /* Restore */
1818                 Term_activate(old);
1819         }
1820 }
1821
1822
1823 /*
1824  * Hack -- display character in sub-windows
1825  */
1826 static void fix_player(void)
1827 {
1828         int j;
1829
1830         /* Scan windows */
1831         for (j = 0; j < 8; j++)
1832         {
1833                 term *old = Term;
1834
1835                 /* No window */
1836                 if (!angband_term[j]) continue;
1837
1838                 /* No relevant flags */
1839                 if (!(window_flag[j] & (PW_PLAYER))) continue;
1840
1841                 /* Activate */
1842                 Term_activate(angband_term[j]);
1843
1844                 update_playtime();
1845
1846                 /* Display player */
1847                 display_player(0);
1848
1849                 /* Fresh */
1850                 Term_fresh();
1851
1852                 /* Restore */
1853                 Term_activate(old);
1854         }
1855 }
1856
1857
1858
1859 /*
1860  * Hack -- display recent messages in sub-windows
1861  *
1862  * XXX XXX XXX Adjust for width and split messages
1863  */
1864 static void fix_message(void)
1865 {
1866         int j, i;
1867         int w, h;
1868         int x, y;
1869
1870         /* Scan windows */
1871         for (j = 0; j < 8; j++)
1872         {
1873                 term *old = Term;
1874
1875                 /* No window */
1876                 if (!angband_term[j]) continue;
1877
1878                 /* No relevant flags */
1879                 if (!(window_flag[j] & (PW_MESSAGE))) continue;
1880
1881                 /* Activate */
1882                 Term_activate(angband_term[j]);
1883
1884                 /* Get size */
1885                 Term_get_size(&w, &h);
1886
1887                 /* Dump messages */
1888                 for (i = 0; i < h; i++)
1889                 {
1890                         /* Dump the message on the appropriate line */
1891                         Term_putstr(0, (h - 1) - i, -1, (byte)((i < now_message) ? TERM_WHITE : TERM_SLATE), message_str((s16b)i));
1892
1893                         /* Cursor */
1894                         Term_locate(&x, &y);
1895
1896                         /* Clear to end of line */
1897                         Term_erase(x, y, 255);
1898                 }
1899
1900                 /* Fresh */
1901                 Term_fresh();
1902
1903                 /* Restore */
1904                 Term_activate(old);
1905         }
1906 }
1907
1908
1909 /*
1910  * Hack -- display overhead view in sub-windows
1911  *
1912  * Note that the "player" symbol does NOT appear on the map.
1913  */
1914 static void fix_overhead(void)
1915 {
1916         int j;
1917
1918         int cy, cx;
1919
1920         /* Scan windows */
1921         for (j = 0; j < 8; j++)
1922         {
1923                 term *old = Term;
1924                 int wid, hgt;
1925
1926                 /* No window */
1927                 if (!angband_term[j]) continue;
1928
1929                 /* No relevant flags */
1930                 if (!(window_flag[j] & (PW_OVERHEAD))) continue;
1931
1932                 /* Activate */
1933                 Term_activate(angband_term[j]);
1934
1935                 /* Full map in too small window is useless  */
1936                 Term_get_size(&wid, &hgt);
1937                 if (wid > COL_MAP + 2 && hgt > ROW_MAP + 2)
1938                 {
1939                         /* Redraw map */
1940                         display_map(&cy, &cx);
1941
1942                         /* Fresh */
1943                         Term_fresh();
1944                 }
1945
1946                 /* Restore */
1947                 Term_activate(old);
1948         }
1949 }
1950
1951
1952 /*
1953  * Hack -- display dungeon view in sub-windows
1954  */
1955 static void fix_dungeon(void)
1956 {
1957         int j;
1958
1959         /* Scan windows */
1960         for (j = 0; j < 8; j++)
1961         {
1962                 term *old = Term;
1963
1964                 /* No window */
1965                 if (!angband_term[j]) continue;
1966
1967                 /* No relevant flags */
1968                 if (!(window_flag[j] & (PW_DUNGEON))) continue;
1969
1970                 /* Activate */
1971                 Term_activate(angband_term[j]);
1972
1973                 /* Redraw dungeon view */
1974                 display_dungeon();
1975
1976                 /* Fresh */
1977                 Term_fresh();
1978
1979                 /* Restore */
1980                 Term_activate(old);
1981         }
1982 }
1983
1984
1985 /*
1986  * Hack -- display monster recall in sub-windows
1987  */
1988 static void fix_monster(void)
1989 {
1990         int j;
1991
1992         /* Scan windows */
1993         for (j = 0; j < 8; j++)
1994         {
1995                 term *old = Term;
1996
1997                 /* No window */
1998                 if (!angband_term[j]) continue;
1999
2000                 /* No relevant flags */
2001                 if (!(window_flag[j] & (PW_MONSTER))) continue;
2002
2003                 /* Activate */
2004                 Term_activate(angband_term[j]);
2005
2006                 /* Display monster race info */
2007                 if (p_ptr->monster_race_idx) display_roff(p_ptr->monster_race_idx);
2008
2009                 /* Fresh */
2010                 Term_fresh();
2011
2012                 /* Restore */
2013                 Term_activate(old);
2014         }
2015 }
2016
2017
2018 /*
2019  * Hack -- display object recall in sub-windows
2020  */
2021 static void fix_object(void)
2022 {
2023         int j;
2024
2025         /* Scan windows */
2026         for (j = 0; j < 8; j++)
2027         {
2028                 term *old = Term;
2029
2030                 /* No window */
2031                 if (!angband_term[j]) continue;
2032
2033                 /* No relevant flags */
2034                 if (!(window_flag[j] & (PW_OBJECT))) continue;
2035
2036                 /* Activate */
2037                 Term_activate(angband_term[j]);
2038
2039                 /* Display monster race info */
2040                 if (p_ptr->object_kind_idx) display_koff(p_ptr->object_kind_idx);
2041
2042                 /* Fresh */
2043                 Term_fresh();
2044
2045                 /* Restore */
2046                 Term_activate(old);
2047         }
2048 }
2049
2050
2051 /*
2052  * Calculate number of spells player should have, and forget,
2053  * or remember, spells until that number is properly reflected.
2054  *
2055  * Note that this function induces various "status" messages,
2056  * which must be bypasses until the character is created.
2057  */
2058 static void calc_spells(void)
2059 {
2060         int                     i, j, k, levels;
2061         int                     num_allowed;
2062         int                     num_boukyaku = 0;
2063
2064         magic_type              *s_ptr;
2065         int use_realm1 = p_ptr->realm1 - 1;
2066         int use_realm2 = p_ptr->realm2 - 1;
2067         int which;
2068         int bonus = 0;
2069
2070
2071         cptr p;
2072
2073         /* Hack -- must be literate */
2074         if (!mp_ptr->spell_book) return;
2075
2076         /* Hack -- wait for creation */
2077         if (!character_generated) return;
2078
2079         /* Hack -- handle "xtra" mode */
2080         if (character_xtra) return;
2081
2082         if ((p_ptr->pclass == CLASS_SORCERER) || (p_ptr->pclass == CLASS_RED_MAGE))
2083         {
2084                 p_ptr->new_spells = 0;
2085                 return;
2086         }
2087
2088         p = spell_categoly_name(mp_ptr->spell_book);
2089
2090         /* Determine the number of spells allowed */
2091         levels = p_ptr->lev - mp_ptr->spell_first + 1;
2092
2093         /* Hack -- no negative spells */
2094         if (levels < 0) levels = 0;
2095
2096         /* Extract total allowed spells */
2097         num_allowed = (adj_mag_study[p_ptr->stat_ind[mp_ptr->spell_stat]] * levels / 2);
2098
2099         if ((p_ptr->pclass != CLASS_SAMURAI) && (mp_ptr->spell_book != TV_LIFE_BOOK))
2100         {
2101                 bonus = 4;
2102         }
2103         if (p_ptr->pclass == CLASS_SAMURAI)
2104         {
2105                 num_allowed = 32;
2106         }
2107         else if (p_ptr->realm2 == REALM_NONE)
2108         {
2109                 num_allowed = (num_allowed+1)/2;
2110                 if (num_allowed>(32+bonus)) num_allowed = 32+bonus;
2111         }
2112         else if ((p_ptr->pclass == CLASS_MAGE) || (p_ptr->pclass == CLASS_PRIEST))
2113         {
2114                 if (num_allowed>(96+bonus)) num_allowed = 96+bonus;
2115         }
2116         else
2117         {
2118                 if (num_allowed>(80+bonus)) num_allowed = 80+bonus;
2119         }
2120
2121         /* Count the number of spells we know */
2122         for (j = 0; j < 64; j++)
2123         {
2124                 /* Count known spells */
2125                 if ((j < 32) ?
2126                     (spell_forgotten1 & (1L << j)) :
2127                     (spell_forgotten2 & (1L << (j - 32))))
2128                 {
2129                         num_boukyaku++;
2130                 }
2131         }
2132
2133         /* See how many spells we must forget or may learn */
2134         p_ptr->new_spells = num_allowed + p_ptr->add_spells + num_boukyaku - p_ptr->learned_spells;
2135
2136         /* Forget spells which are too hard */
2137         for (i = 63; i >= 0; i--)
2138         {
2139                 /* Efficiency -- all done */
2140                 if (!spell_learned1 && !spell_learned2) break;
2141
2142                 /* Access the spell */
2143                 j = spell_order[i];
2144
2145                 /* Skip non-spells */
2146                 if (j >= 99) continue;
2147
2148
2149                 /* Get the spell */
2150                 if (!is_magic(((j < 32) ? use_realm1 : use_realm2)+1))
2151                 {
2152                         if (j < 32)
2153                                 s_ptr = &technic_info[use_realm1 - MIN_TECHNIC][j];
2154                         else
2155                                 s_ptr = &technic_info[use_realm2 - MIN_TECHNIC][j%32];
2156                 }
2157                 else if (j < 32)
2158                         s_ptr = &mp_ptr->info[use_realm1][j];
2159                 else
2160                         s_ptr = &mp_ptr->info[use_realm2][j%32];
2161
2162                 /* Skip spells we are allowed to know */
2163                 if (s_ptr->slevel <= p_ptr->lev) continue;
2164
2165                 /* Is it known? */
2166                 if ((j < 32) ?
2167                     (spell_learned1 & (1L << j)) :
2168                     (spell_learned2 & (1L << (j - 32))))
2169                 {
2170                         /* Mark as forgotten */
2171                         if (j < 32)
2172                         {
2173                                 spell_forgotten1 |= (1L << j);
2174                                 which = use_realm1;
2175                         }
2176                         else
2177                         {
2178                                 spell_forgotten2 |= (1L << (j - 32));
2179                                 which = use_realm2;
2180                         }
2181
2182                         /* No longer known */
2183                         if (j < 32)
2184                         {
2185                                 spell_learned1 &= ~(1L << j);
2186                                 which = use_realm1;
2187                         }
2188                         else
2189                         {
2190                                 spell_learned2 &= ~(1L << (j - 32));
2191                                 which = use_realm2;
2192                         }
2193
2194                         /* Message */
2195 #ifdef JP
2196                         msg_format("%s¤Î%s¤òËº¤ì¤Æ¤·¤Þ¤Ã¤¿¡£",
2197                                    spell_names[technic2magic(which+1)-1][j%32], p );
2198 #else
2199                         msg_format("You have forgotten the %s of %s.", p,
2200                         spell_names[technic2magic(which+1)-1][j%32]);
2201 #endif
2202
2203
2204                         /* One more can be learned */
2205                         p_ptr->new_spells++;
2206                 }
2207         }
2208
2209
2210         /* Forget spells if we know too many spells */
2211         for (i = 63; i >= 0; i--)
2212         {
2213                 /* Stop when possible */
2214                 if (p_ptr->new_spells >= 0) break;
2215
2216                 /* Efficiency -- all done */
2217                 if (!spell_learned1 && !spell_learned2) break;
2218
2219                 /* Get the (i+1)th spell learned */
2220                 j = spell_order[i];
2221
2222                 /* Skip unknown spells */
2223                 if (j >= 99) continue;
2224
2225                 /* Forget it (if learned) */
2226                 if ((j < 32) ?
2227                     (spell_learned1 & (1L << j)) :
2228                     (spell_learned2 & (1L << (j - 32))))
2229                 {
2230                         /* Mark as forgotten */
2231                         if (j < 32)
2232                         {
2233                                 spell_forgotten1 |= (1L << j);
2234                                 which = use_realm1;
2235                         }
2236                         else
2237                         {
2238                                 spell_forgotten2 |= (1L << (j - 32));
2239                                 which = use_realm2;
2240                         }
2241
2242                         /* No longer known */
2243                         if (j < 32)
2244                         {
2245                                 spell_learned1 &= ~(1L << j);
2246                                 which = use_realm1;
2247                         }
2248                         else
2249                         {
2250                                 spell_learned2 &= ~(1L << (j - 32));
2251                                 which = use_realm2;
2252                         }
2253
2254                         /* Message */
2255 #ifdef JP
2256                         msg_format("%s¤Î%s¤òËº¤ì¤Æ¤·¤Þ¤Ã¤¿¡£",
2257                                    spell_names[technic2magic(which+1)-1][j%32], p );
2258 #else
2259                         msg_format("You have forgotten the %s of %s.", p,
2260                                    spell_names[technic2magic(which+1)-1][j%32]);
2261 #endif
2262
2263
2264                         /* One more can be learned */
2265                         p_ptr->new_spells++;
2266                 }
2267         }
2268
2269
2270         /* Check for spells to remember */
2271         for (i = 0; i < 64; i++)
2272         {
2273                 /* None left to remember */
2274                 if (p_ptr->new_spells <= 0) break;
2275
2276                 /* Efficiency -- all done */
2277                 if (!spell_forgotten1 && !spell_forgotten2) break;
2278
2279                 /* Get the next spell we learned */
2280                 j = spell_order[i];
2281
2282                 /* Skip unknown spells */
2283                 if (j >= 99) break;
2284
2285                 /* Access the spell */
2286                 if (!is_magic(((j < 32) ? use_realm1 : use_realm2)+1))
2287                 {
2288                         if (j < 32)
2289                                 s_ptr = &technic_info[use_realm1 - MIN_TECHNIC][j];
2290                         else
2291                                 s_ptr = &technic_info[use_realm2 - MIN_TECHNIC][j%32];
2292                 }
2293                 else if (j<32)
2294                         s_ptr = &mp_ptr->info[use_realm1][j];
2295                 else
2296                         s_ptr = &mp_ptr->info[use_realm2][j%32];
2297
2298                 /* Skip spells we cannot remember */
2299                 if (s_ptr->slevel > p_ptr->lev) continue;
2300
2301                 /* First set of spells */
2302                 if ((j < 32) ?
2303                     (spell_forgotten1 & (1L << j)) :
2304                     (spell_forgotten2 & (1L << (j - 32))))
2305                 {
2306                         /* No longer forgotten */
2307                         if (j < 32)
2308                         {
2309                                 spell_forgotten1 &= ~(1L << j);
2310                                 which = use_realm1;
2311                         }
2312                         else
2313                         {
2314                                 spell_forgotten2 &= ~(1L << (j - 32));
2315                                 which = use_realm2;
2316                         }
2317
2318                         /* Known once more */
2319                         if (j < 32)
2320                         {
2321                                 spell_learned1 |= (1L << j);
2322                                 which = use_realm1;
2323                         }
2324                         else
2325                         {
2326                                 spell_learned2 |= (1L << (j - 32));
2327                                 which = use_realm2;
2328                         }
2329
2330                         /* Message */
2331 #ifdef JP
2332                         msg_format("%s¤Î%s¤ò»×¤¤½Ð¤·¤¿¡£",
2333                                    spell_names[technic2magic(which+1)-1][j%32], p );
2334 #else
2335                         msg_format("You have remembered the %s of %s.",
2336                                    p, spell_names[technic2magic(which+1)-1][j%32]);
2337 #endif
2338
2339
2340                         /* One less can be learned */
2341                         p_ptr->new_spells--;
2342                 }
2343         }
2344
2345         k = 0;
2346
2347         if (p_ptr->realm2 == REALM_NONE)
2348         {
2349                 /* Count spells that can be learned */
2350                 for (j = 0; j < 32; j++)
2351                 {
2352                         if (!is_magic(use_realm1+1)) s_ptr = &technic_info[use_realm1-MIN_TECHNIC][j];
2353                         else s_ptr = &mp_ptr->info[use_realm1][j];
2354
2355                         /* Skip spells we cannot remember */
2356                         if (s_ptr->slevel > p_ptr->lev) continue;
2357
2358                         /* Skip spells we already know */
2359                         if (spell_learned1 & (1L << j))
2360                         {
2361                                 continue;
2362                         }
2363
2364                         /* Count it */
2365                         k++;
2366                 }
2367                 if (k>32) k = 32;
2368                 if ((p_ptr->new_spells > k) && ((mp_ptr->spell_book == TV_LIFE_BOOK) || (mp_ptr->spell_book == TV_HISSATSU_BOOK))) p_ptr->new_spells = k;
2369         }
2370
2371         if (p_ptr->new_spells < 0) p_ptr->new_spells = 0;
2372
2373         /* Spell count changed */
2374         if (p_ptr->old_spells != p_ptr->new_spells)
2375         {
2376                 /* Message if needed */
2377                 if (p_ptr->new_spells)
2378                 {
2379                         /* Message */
2380 #ifdef JP
2381                         if( p_ptr->new_spells < 10 ){
2382                                 msg_format("¤¢¤È %d ¤Ä¤Î%s¤ò³Ø¤Ù¤ë¡£", p_ptr->new_spells, p);
2383                         }else{
2384                                 msg_format("¤¢¤È %d ¸Ä¤Î%s¤ò³Ø¤Ù¤ë¡£", p_ptr->new_spells, p);
2385                         }
2386 #else
2387                         msg_format("You can learn %d more %s%s.",
2388                                    p_ptr->new_spells, p,
2389                                    (p_ptr->new_spells != 1) ? "s" : "");
2390 #endif
2391
2392                 }
2393
2394                 /* Save the new_spells value */
2395                 p_ptr->old_spells = p_ptr->new_spells;
2396
2397                 /* Redraw Study Status */
2398                 p_ptr->redraw |= (PR_STUDY);
2399         }
2400 }
2401
2402
2403 /*
2404  * Calculate maximum mana.  You do not need to know any spells.
2405  * Note that mana is lowered by heavy (or inappropriate) armor.
2406  *
2407  * This function induces status messages.
2408  */
2409 static void calc_mana(void)
2410 {
2411         int             msp, levels, cur_wgt, max_wgt;
2412
2413         object_type     *o_ptr;
2414
2415
2416         /* Hack -- Must be literate */
2417         if (!mp_ptr->spell_book) return;
2418
2419         if ((p_ptr->pclass == CLASS_MINDCRAFTER) ||
2420             (p_ptr->pclass == CLASS_MIRROR_MASTER) ||
2421             (p_ptr->pclass == CLASS_BLUE_MAGE))
2422         {
2423                 levels = p_ptr->lev;
2424         }
2425         else
2426         {
2427                 if(mp_ptr->spell_first > p_ptr->lev)
2428                 {
2429                         /* Save new mana */
2430                         p_ptr->msp = 0;
2431
2432                         /* Display mana later */
2433                         p_ptr->redraw |= (PR_MANA);
2434                         return;
2435                 }
2436
2437                 /* Extract "effective" player level */
2438                 levels = (p_ptr->lev - mp_ptr->spell_first) + 1;
2439         }
2440
2441         if (p_ptr->pclass == CLASS_SAMURAI)
2442         {
2443                 msp = (adj_mag_mana[p_ptr->stat_ind[mp_ptr->spell_stat]] + 10) * 2;
2444                 if (msp) msp += (msp * rp_ptr->r_adj[mp_ptr->spell_stat] / 20);
2445         }
2446         else
2447         {
2448                 /* Extract total mana */
2449                 msp = adj_mag_mana[p_ptr->stat_ind[mp_ptr->spell_stat]] * (levels+3) / 4;
2450
2451                 /* Hack -- usually add one mana */
2452                 if (msp) msp++;
2453
2454                 if (msp) msp += (msp * rp_ptr->r_adj[mp_ptr->spell_stat] / 20);
2455
2456                 if (msp && (p_ptr->pseikaku == SEIKAKU_MUNCHKIN)) msp += msp/2;
2457
2458                 /* Hack: High mages have a 25% mana bonus */
2459                 if (msp && (p_ptr->pclass == CLASS_HIGH_MAGE)) msp += msp / 4;
2460
2461                 if (msp && (p_ptr->pclass == CLASS_SORCERER)) msp += msp*(25+p_ptr->lev)/100;
2462         }
2463
2464         /* Only mages are affected */
2465         if (mp_ptr->spell_xtra & MAGIC_GLOVE_REDUCE_MANA)
2466         {
2467                 u32b f1, f2, f3;
2468
2469                 /* Assume player is not encumbered by gloves */
2470                 p_ptr->cumber_glove = FALSE;
2471
2472                 /* Get the gloves */
2473                 o_ptr = &inventory[INVEN_HANDS];
2474
2475                 /* Examine the gloves */
2476                 object_flags(o_ptr, &f1, &f2, &f3);
2477
2478                 /* Normal gloves hurt mage-type spells */
2479                 if (o_ptr->k_idx &&
2480                     !(f2 & (TR2_FREE_ACT)) &&
2481                     !(f1 & (TR1_MAGIC_MASTERY)) &&
2482                     !((f1 & (TR1_DEX)) && (o_ptr->pval > 0)))
2483                 {
2484                         /* Encumbered */
2485                         p_ptr->cumber_glove = TRUE;
2486
2487                         /* Reduce mana */
2488                         msp = (3 * msp) / 4;
2489                 }
2490         }
2491
2492
2493         /* Assume player not encumbered by armor */
2494         p_ptr->cumber_armor = FALSE;
2495
2496         /* Weigh the armor */
2497         cur_wgt = 0;
2498         if(inventory[INVEN_RARM].tval> TV_SWORD) cur_wgt += inventory[INVEN_RARM].weight;
2499         if(inventory[INVEN_LARM].tval> TV_SWORD) cur_wgt += inventory[INVEN_LARM].weight;
2500         cur_wgt += inventory[INVEN_BODY].weight;
2501         cur_wgt += inventory[INVEN_HEAD].weight;
2502         cur_wgt += inventory[INVEN_OUTER].weight;
2503         cur_wgt += inventory[INVEN_HANDS].weight;
2504         cur_wgt += inventory[INVEN_FEET].weight;
2505
2506         /* Subtract a percentage of maximum mana. */
2507         switch (p_ptr->pclass)
2508         {
2509                 /* For these classes, mana is halved if armour
2510                  * is 30 pounds over their weight limit. */
2511                 case CLASS_MAGE:
2512                 case CLASS_HIGH_MAGE:
2513                 case CLASS_BLUE_MAGE:
2514                 case CLASS_MONK:
2515                 case CLASS_FORCETRAINER:
2516                 case CLASS_SORCERER:
2517                 {
2518                         if (inventory[INVEN_RARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_RARM].weight;
2519                         if (inventory[INVEN_LARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_LARM].weight;
2520                         break;
2521                 }
2522
2523                 /* Mana halved if armour is 40 pounds over weight limit. */
2524                 case CLASS_PRIEST:
2525                 case CLASS_BARD:
2526                 case CLASS_TOURIST:
2527                 {
2528                         if (inventory[INVEN_RARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_RARM].weight*2/3;
2529                         if (inventory[INVEN_LARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_LARM].weight*2/3;
2530                         break;
2531                 }
2532
2533                 case CLASS_MINDCRAFTER:
2534                 case CLASS_BEASTMASTER:
2535                 case CLASS_MIRROR_MASTER:
2536                 {
2537                         if (inventory[INVEN_RARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_RARM].weight/2;
2538                         if (inventory[INVEN_LARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_LARM].weight/2;
2539                         break;
2540                 }
2541
2542                 /* Mana halved if armour is 50 pounds over weight limit. */
2543                 case CLASS_ROGUE:
2544                 case CLASS_RANGER:
2545                 case CLASS_RED_MAGE:
2546                 case CLASS_WARRIOR_MAGE:
2547                 {
2548                         if (inventory[INVEN_RARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_RARM].weight/3;
2549                         if (inventory[INVEN_LARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_LARM].weight/3;
2550                         break;
2551                 }
2552
2553                 /* Mana halved if armour is 60 pounds over weight limit. */
2554                 case CLASS_PALADIN:
2555                 case CLASS_CHAOS_WARRIOR:
2556                 {
2557                         if (inventory[INVEN_RARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_RARM].weight/5;
2558                         if (inventory[INVEN_LARM].tval <= TV_SWORD) cur_wgt += inventory[INVEN_LARM].weight/5;
2559                         break;
2560                 }
2561
2562                 /* For new classes created, but not yet added to this formula. */
2563                 default:
2564                 {
2565                         break;
2566                 }
2567         }
2568
2569         /* Determine the weight allowance */
2570         max_wgt = mp_ptr->spell_weight;
2571
2572         /* Heavy armor penalizes mana by a percentage.  -LM- */
2573         if ((cur_wgt - max_wgt) > 0)
2574         {
2575                 /* Encumbered */
2576                 p_ptr->cumber_armor = TRUE;
2577
2578                 /* Subtract a percentage of maximum mana. */
2579                 switch (p_ptr->pclass)
2580                 {
2581                         /* For these classes, mana is halved if armour
2582                          * is 30 pounds over their weight limit. */
2583                         case CLASS_MAGE:
2584                         case CLASS_HIGH_MAGE:
2585                         case CLASS_BLUE_MAGE:
2586                         {
2587                                 msp -= msp * (cur_wgt - max_wgt) / 600;
2588                                 break;
2589                         }
2590
2591                         /* Mana halved if armour is 40 pounds over weight limit. */
2592                         case CLASS_PRIEST:
2593                         case CLASS_MINDCRAFTER:
2594                         case CLASS_BEASTMASTER:
2595                         case CLASS_BARD:
2596                         case CLASS_FORCETRAINER:
2597                         case CLASS_TOURIST:
2598                         case CLASS_MIRROR_MASTER:
2599                         {
2600                                 msp -= msp * (cur_wgt - max_wgt) / 800;
2601                                 break;
2602                         }
2603
2604                         case CLASS_SORCERER:
2605                         {
2606                                 msp -= msp * (cur_wgt - max_wgt) / 900;
2607                                 break;
2608                         }
2609
2610                         /* Mana halved if armour is 50 pounds over weight limit. */
2611                         case CLASS_ROGUE:
2612                         case CLASS_RANGER:
2613                         case CLASS_MONK:
2614                         case CLASS_RED_MAGE:
2615                         {
2616                                 msp -= msp * (cur_wgt - max_wgt) / 1000;
2617                                 break;
2618                         }
2619
2620                         /* Mana halved if armour is 60 pounds over weight limit. */
2621                         case CLASS_PALADIN:
2622                         case CLASS_CHAOS_WARRIOR:
2623                         case CLASS_WARRIOR_MAGE:
2624                         {
2625                                 msp -= msp * (cur_wgt - max_wgt) / 1200;
2626                                 break;
2627                         }
2628
2629                         case CLASS_SAMURAI:
2630                         {
2631                                 p_ptr->cumber_armor = FALSE;
2632                                 break;
2633                         }
2634
2635                         /* For new classes created, but not yet added to this formula. */
2636                         default:
2637                         {
2638                                 msp -= msp * (cur_wgt - max_wgt) / 800;
2639                                 break;
2640                         }
2641                 }
2642         }
2643
2644         /* Mana can never be negative */
2645         if (msp < 0) msp = 0;
2646
2647
2648         /* Maximum mana has changed */
2649         if (p_ptr->msp != msp)
2650         {
2651                 /* Enforce maximum */
2652                 if ((p_ptr->csp >= msp) && (p_ptr->pclass != CLASS_SAMURAI))
2653                 {
2654                         p_ptr->csp = msp;
2655                         p_ptr->csp_frac = 0;
2656                 }
2657
2658 #ifdef JP
2659                 /* ¥ì¥Ù¥ë¥¢¥Ã¥×¤Î»þ¤Ï¾å¾ºÎÌ¤òÉ½¼¨¤¹¤ë */
2660                 if ((level_up == 1) && (msp > p_ptr->msp))
2661                 {
2662                         msg_format("ºÇÂç¥Þ¥¸¥Ã¥¯¡¦¥Ý¥¤¥ó¥È¤¬ %d Áý²Ã¤·¤¿¡ª",
2663                                    (msp - p_ptr->msp));
2664                 }
2665 #endif
2666                 /* Save new mana */
2667                 p_ptr->msp = msp;
2668
2669                 /* Display mana later */
2670                 p_ptr->redraw |= (PR_MANA);
2671
2672                 /* Window stuff */
2673                 p_ptr->window |= (PW_PLAYER);
2674                 p_ptr->window |= (PW_SPELL);
2675         }
2676
2677
2678         /* Hack -- handle "xtra" mode */
2679         if (character_xtra) return;
2680
2681         /* Take note when "glove state" changes */
2682         if (p_ptr->old_cumber_glove != p_ptr->cumber_glove)
2683         {
2684                 /* Message */
2685                 if (p_ptr->cumber_glove)
2686                 {
2687 #ifdef JP
2688                         msg_print("¼ê¤¬Ê¤¤ï¤ì¤Æ¼öÊ¸¤¬¾§¤¨¤Ë¤¯¤¤´¶¤¸¤¬¤¹¤ë¡£");
2689 #else
2690                         msg_print("Your covered hands feel unsuitable for spellcasting.");
2691 #endif
2692
2693                 }
2694                 else
2695                 {
2696 #ifdef JP
2697                         msg_print("¤³¤Î¼ê¤Î¾õÂÖ¤Ê¤é¡¢¤°¤Ã¤È¼öÊ¸¤¬¾§¤¨¤ä¤¹¤¤´¶¤¸¤À¡£");
2698 #else
2699                         msg_print("Your hands feel more suitable for spellcasting.");
2700 #endif
2701
2702                 }
2703
2704                 /* Save it */
2705                 p_ptr->old_cumber_glove = p_ptr->cumber_glove;
2706         }
2707
2708
2709         /* Take note when "armor state" changes */
2710         if (p_ptr->old_cumber_armor != p_ptr->cumber_armor)
2711         {
2712                 /* Message */
2713                 if (p_ptr->cumber_armor)
2714                 {
2715 #ifdef JP
2716                         msg_print("ÁõÈ÷¤Î½Å¤µ¤ÇÆ°¤¤¬Æß¤¯¤Ê¤Ã¤Æ¤·¤Þ¤Ã¤Æ¤¤¤ë¡£");
2717 #else
2718                         msg_print("The weight of your equipment encumbers your movement.");
2719 #endif
2720
2721                 }
2722                 else
2723                 {
2724 #ifdef JP
2725                         msg_print("¤°¤Ã¤È³Ú¤ËÂÎ¤òÆ°¤«¤»¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£");
2726 #else
2727                         msg_print("You feel able to move more freely.");
2728 #endif
2729
2730                 }
2731
2732                 /* Save it */
2733                 p_ptr->old_cumber_armor = p_ptr->cumber_armor;
2734         }
2735 }
2736
2737
2738
2739 /*
2740  * Calculate the players (maximal) hit points
2741  * Adjust current hitpoints if necessary
2742  */
2743 static void calc_hitpoints(void)
2744 {
2745         int bonus, mhp;
2746         byte tmp_hitdie;
2747
2748         /* Un-inflate "half-hitpoint bonus per level" value */
2749         bonus = ((int)(adj_con_mhp[p_ptr->stat_ind[A_CON]]) - 128) * p_ptr->lev / 4;
2750
2751         /* Calculate hitpoints */
2752         mhp = player_hp[p_ptr->lev - 1];
2753
2754         if (p_ptr->mimic_form)
2755         {
2756                 if (p_ptr->pclass == CLASS_SORCERER)
2757                         tmp_hitdie = mimic_info[p_ptr->mimic_form].r_mhp/2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
2758                 else
2759                         tmp_hitdie = mimic_info[p_ptr->mimic_form].r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
2760                 mhp = mhp * tmp_hitdie / p_ptr->hitdie;
2761         }
2762
2763         if (p_ptr->pclass == CLASS_SORCERER)
2764         {
2765                 if (p_ptr->lev < 30)
2766                         mhp = (mhp * (45+p_ptr->lev) / 100);
2767                 else
2768                         mhp = (mhp * 75 / 100);
2769                 bonus = (bonus * 65 / 100);
2770         }
2771
2772         mhp += bonus;
2773
2774         if (p_ptr->pclass == CLASS_BERSERKER)
2775         {
2776                 mhp = mhp*(110+(((p_ptr->lev + 40) * (p_ptr->lev + 40) - 1550) / 110))/100;
2777         }
2778
2779         /* Always have at least one hitpoint per level */
2780         if (mhp < p_ptr->lev + 1) mhp = p_ptr->lev + 1;
2781
2782         /* Factor in the hero / superhero settings */
2783         if (p_ptr->hero || music_singing(MUSIC_HERO) || music_singing(MUSIC_SHERO))
2784         if (p_ptr->shero) mhp += 30;
2785         if (p_ptr->tsuyoshi) mhp += 50;
2786
2787         /* New maximum hitpoints */
2788         if (p_ptr->mhp != mhp)
2789         {
2790                 /* Enforce maximum */
2791                 if (p_ptr->chp >= mhp)
2792                 {
2793                         p_ptr->chp = mhp;
2794                         p_ptr->chp_frac = 0;
2795                 }
2796
2797 #ifdef JP
2798                 /* ¥ì¥Ù¥ë¥¢¥Ã¥×¤Î»þ¤Ï¾å¾ºÎÌ¤òÉ½¼¨¤¹¤ë */
2799                 if ((level_up == 1) && (mhp > p_ptr->mhp))
2800                 {
2801                         msg_format("ºÇÂç¥Ò¥Ã¥È¡¦¥Ý¥¤¥ó¥È¤¬ %d Áý²Ã¤·¤¿¡ª",
2802                                    (mhp - p_ptr->mhp) );
2803                 }
2804 #endif
2805                 /* Save the new max-hitpoints */
2806                 p_ptr->mhp = mhp;
2807
2808                 /* Display hitpoints (later) */
2809                 p_ptr->redraw |= (PR_HP);
2810
2811                 /* Window stuff */
2812                 p_ptr->window |= (PW_PLAYER);
2813         }
2814 }
2815
2816
2817
2818 /*
2819  * Extract and set the current "lite radius"
2820  *
2821  * SWD: Experimental modification: multiple light sources have additive effect.
2822  *
2823  */
2824 static void calc_torch(void)
2825 {
2826         int i;
2827         object_type *o_ptr;
2828         u32b f1, f2, f3;
2829
2830         /* Assume no light */
2831         p_ptr->cur_lite = 0;
2832
2833         /* Loop through all wielded items */
2834         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
2835         {
2836                 o_ptr = &inventory[i];
2837
2838                 /* Examine actual lites */
2839                 if ((i == INVEN_LITE) && (o_ptr->k_idx) && (o_ptr->tval == TV_LITE))
2840                 {
2841                         if (o_ptr->name2 == EGO_LITE_DARKNESS)
2842                         {
2843                                 if (o_ptr->sval == SV_LITE_TORCH)
2844                                 {
2845                                         p_ptr->cur_lite -= 1;
2846                                 }
2847
2848                                 /* Lanterns (with fuel) provide more lite */
2849                                 else if (o_ptr->sval == SV_LITE_LANTERN)
2850                                 {
2851                                         p_ptr->cur_lite -= 2;
2852                                 }
2853
2854                                 else if (o_ptr->sval == SV_LITE_FEANOR)
2855                                 {
2856                                         p_ptr->cur_lite -= 3;
2857                                 }
2858                         }
2859                         /* Torches (with fuel) provide some lite */
2860                         else if ((o_ptr->sval == SV_LITE_TORCH) && (o_ptr->xtra4 > 0))
2861                         {
2862                                 p_ptr->cur_lite += 1;
2863                         }
2864
2865                         /* Lanterns (with fuel) provide more lite */
2866                         else if ((o_ptr->sval == SV_LITE_LANTERN) && (o_ptr->xtra4 > 0))
2867                         {
2868                                 p_ptr->cur_lite += 2;
2869                         }
2870
2871                         else if (o_ptr->sval == SV_LITE_FEANOR)
2872                         {
2873                                 p_ptr->cur_lite += 2;
2874                         }
2875
2876                         /* Artifact Lites provide permanent, bright, lite */
2877                         else if (artifact_p(o_ptr))
2878                         {
2879                                 p_ptr->cur_lite += 3;
2880                         }
2881
2882                         if (o_ptr->name2 == EGO_LITE_SHINE) p_ptr->cur_lite++;
2883                 }
2884                 else
2885                 {
2886                         /* Skip empty slots */
2887                         if (!o_ptr->k_idx) continue;
2888
2889                         /* Extract the flags */
2890                         object_flags(o_ptr, &f1, &f2, &f3);
2891
2892                         /* does this item glow? */
2893                         if (f3 & TR3_LITE)
2894                         {
2895                                 if ((o_ptr->name2 == EGO_DARK) || (o_ptr->name1 == ART_NIGHT)) p_ptr->cur_lite--;
2896                                 else p_ptr->cur_lite++;
2897                         }
2898                 }
2899
2900         }
2901
2902         /* max radius is 5 without rewriting other code -- */
2903         /* see cave.c:update_lite() and defines.h:LITE_MAX */
2904         if (d_info[dungeon_type].flags1 & DF1_DARKNESS && p_ptr->cur_lite > 1)
2905                 p_ptr->cur_lite = 1;
2906         if (p_ptr->cur_lite > 14) p_ptr->cur_lite = 14;
2907         if (p_ptr->cur_lite < 0) p_ptr->cur_lite = 0;
2908
2909         /* check if the player doesn't have a lite source, */
2910         /* but does glow as an intrinsic.                  */
2911         if (p_ptr->cur_lite == 0 && p_ptr->lite) p_ptr->cur_lite = 1;
2912
2913         /* end experimental mods */
2914
2915         /* Reduce lite when running if requested */
2916         if (running && view_reduce_lite)
2917         {
2918                 /* Reduce the lite radius if needed */
2919                 if (p_ptr->cur_lite > 1) p_ptr->cur_lite = 1;
2920         }
2921
2922         /* Notice changes in the "lite radius" */
2923         if (p_ptr->old_lite != p_ptr->cur_lite)
2924         {
2925                 /* Update the lite */
2926                 p_ptr->update |= (PU_LITE);
2927
2928                 /* Update the monsters */
2929                 p_ptr->update |= (PU_MONSTERS);
2930
2931                 /* Remember the old lite */
2932                 p_ptr->old_lite = p_ptr->cur_lite;
2933
2934                 if ((p_ptr->cur_lite > 0) && (p_ptr->special_defense & NINJA_S_STEALTH))
2935                         set_superstealth(FALSE);
2936         }
2937 }
2938
2939
2940
2941 /*
2942  * Computes current weight limit.
2943  */
2944 static int weight_limit(void)
2945 {
2946         int i;
2947
2948         /* Weight limit based only on strength */
2949         i = adj_str_wgt[p_ptr->stat_ind[A_STR]] * 100;
2950         if (p_ptr->pclass == CLASS_BERSERKER) i = i*3/2;
2951
2952         /* Return the result */
2953         return (i);
2954 }
2955
2956
2957 bool buki_motteruka(int i)
2958 {
2959         return ((inventory[i].k_idx && inventory[i].tval >= TV_DIGGING && inventory[i].tval <= TV_SWORD) ? TRUE : FALSE);
2960 }
2961
2962 /*
2963  * Calculate the players current "state", taking into account
2964  * not only race/class intrinsics, but also objects being worn
2965  * and temporary spell effects.
2966  *
2967  * See also calc_mana() and calc_hitpoints().
2968  *
2969  * Take note of the new "speed code", in particular, a very strong
2970  * player will start slowing down as soon as he reaches 150 pounds,
2971  * but not until he reaches 450 pounds will he be half as fast as
2972  * a normal kobold.  This both hurts and helps the player, hurts
2973  * because in the old days a player could just avoid 300 pounds,
2974  * and helps because now carrying 300 pounds is not very painful.
2975  *
2976  * The "weapon" and "bow" do *not* add to the bonuses to hit or to
2977  * damage, since that would affect non-combat things.  These values
2978  * are actually added in later, at the appropriate place.
2979  *
2980  * This function induces various "status" messages.
2981  */
2982 void calc_bonuses(void)
2983 {
2984         int             i, j, hold, neutral[2];
2985         int             old_speed;
2986         int             old_telepathy;
2987         int             old_see_inv;
2988         int             old_dis_ac;
2989         int             old_dis_to_a;
2990         int             extra_blows[2];
2991         int             extra_shots;
2992         object_type     *o_ptr;
2993         u32b            f1, f2, f3;
2994         bool            omoi = FALSE;
2995         bool            yoiyami = FALSE;
2996         bool            down_saving = FALSE;
2997         bool            have_dd_s, have_dd_t, have_sw, have_kabe;
2998         bool            easy_2weapon = FALSE;
2999         s16b this_o_idx, next_o_idx = 0;
3000         player_race *tmp_rp_ptr;
3001
3002
3003         /* Save the old speed */
3004         old_speed = p_ptr->pspeed;
3005
3006         /* Save the old vision stuff */
3007         old_telepathy = p_ptr->telepathy;
3008         old_see_inv = p_ptr->see_inv;
3009
3010         /* Save the old armor class */
3011         old_dis_ac = p_ptr->dis_ac;
3012         old_dis_to_a = p_ptr->dis_to_a;
3013
3014
3015         /* Clear extra blows/shots */
3016         extra_blows[0] = extra_blows[1] = extra_shots = 0;
3017
3018         /* Clear the stat modifiers */
3019         for (i = 0; i < 6; i++) p_ptr->stat_add[i] = 0;
3020
3021
3022         /* Clear the Displayed/Real armor class */
3023         p_ptr->dis_ac = p_ptr->ac = 0;
3024
3025         /* Clear the Displayed/Real Bonuses */
3026         p_ptr->dis_to_h[0] = p_ptr->to_h[0] = 0;
3027         p_ptr->dis_to_h[1] = p_ptr->to_h[1] = 0;
3028         p_ptr->dis_to_d[0] = p_ptr->to_d[0] = 0;
3029         p_ptr->dis_to_d[1] = p_ptr->to_d[1] = 0;
3030         p_ptr->dis_to_h_b = p_ptr->to_h_b = 0;
3031         p_ptr->dis_to_a = p_ptr->to_a = 0;
3032         p_ptr->to_h_m = 0;
3033         p_ptr->to_d_m = 0;
3034
3035         p_ptr->to_m_chance = 0;
3036
3037         /* Start with "normal" speed */
3038         p_ptr->pspeed = 110;
3039
3040         /* Start with a single blow per turn */
3041         p_ptr->num_blow[0] = 1;
3042         p_ptr->num_blow[1] = 1;
3043
3044         /* Start with a single shot per turn */
3045         p_ptr->num_fire = 100;
3046
3047         /* Reset the "xtra" tval */
3048         p_ptr->tval_xtra = 0;
3049
3050         /* Reset the "ammo" tval */
3051         p_ptr->tval_ammo = 0;
3052
3053         /* Clear all the flags */
3054         p_ptr->cursed = 0L;
3055         p_ptr->bless_blade = FALSE;
3056         p_ptr->xtra_might = FALSE;
3057         p_ptr->impact[0] = FALSE;
3058         p_ptr->impact[1] = FALSE;
3059         p_ptr->pass_wall = FALSE;
3060         p_ptr->kill_wall = FALSE;
3061         p_ptr->dec_mana = FALSE;
3062         p_ptr->easy_spell = FALSE;
3063         p_ptr->heavy_spell = FALSE;
3064         p_ptr->see_inv = FALSE;
3065         p_ptr->free_act = FALSE;
3066         p_ptr->slow_digest = FALSE;
3067         p_ptr->regenerate = FALSE;
3068         p_ptr->can_swim = FALSE;
3069         p_ptr->ffall = FALSE;
3070         p_ptr->hold_life = FALSE;
3071         p_ptr->telepathy = FALSE;
3072         p_ptr->lite = FALSE;
3073         p_ptr->sustain_str = FALSE;
3074         p_ptr->sustain_int = FALSE;
3075         p_ptr->sustain_wis = FALSE;
3076         p_ptr->sustain_con = FALSE;
3077         p_ptr->sustain_dex = FALSE;
3078         p_ptr->sustain_chr = FALSE;
3079         p_ptr->resist_acid = FALSE;
3080         p_ptr->resist_elec = FALSE;
3081         p_ptr->resist_fire = FALSE;
3082         p_ptr->resist_cold = FALSE;
3083         p_ptr->resist_pois = FALSE;
3084         p_ptr->resist_conf = FALSE;
3085         p_ptr->resist_sound = FALSE;
3086         p_ptr->resist_lite = FALSE;
3087         p_ptr->resist_dark = FALSE;
3088         p_ptr->resist_chaos = FALSE;
3089         p_ptr->resist_disen = FALSE;
3090         p_ptr->resist_shard = FALSE;
3091         p_ptr->resist_nexus = FALSE;
3092         p_ptr->resist_blind = FALSE;
3093         p_ptr->resist_neth = FALSE;
3094         p_ptr->resist_time = FALSE;
3095         p_ptr->resist_fear = FALSE;
3096         p_ptr->reflect = FALSE;
3097         p_ptr->sh_fire = FALSE;
3098         p_ptr->sh_elec = FALSE;
3099         p_ptr->sh_cold = FALSE;
3100         p_ptr->anti_magic = FALSE;
3101         p_ptr->anti_tele = FALSE;
3102         p_ptr->warning = FALSE;
3103         p_ptr->mighty_throw = FALSE;
3104
3105         p_ptr->immune_acid = FALSE;
3106         p_ptr->immune_elec = FALSE;
3107         p_ptr->immune_fire = FALSE;
3108         p_ptr->immune_cold = FALSE;
3109
3110         p_ptr->ryoute = FALSE;
3111         p_ptr->migite = FALSE;
3112         p_ptr->hidarite = FALSE;
3113         p_ptr->no_flowed = FALSE;
3114
3115         p_ptr->align = 0;
3116
3117         if (p_ptr->mimic_form) tmp_rp_ptr = &mimic_info[p_ptr->mimic_form];
3118         else tmp_rp_ptr = &race_info[p_ptr->prace];
3119
3120         /* Base infravision (purely racial) */
3121         p_ptr->see_infra = tmp_rp_ptr->infra;
3122
3123         /* Base skill -- disarming */
3124         p_ptr->skill_dis = tmp_rp_ptr->r_dis + cp_ptr->c_dis + ap_ptr->a_dis;
3125
3126         /* Base skill -- magic devices */
3127         p_ptr->skill_dev = tmp_rp_ptr->r_dev + cp_ptr->c_dev + ap_ptr->a_dev;
3128
3129         /* Base skill -- saving throw */
3130         p_ptr->skill_sav = tmp_rp_ptr->r_sav + cp_ptr->c_sav + ap_ptr->a_sav;
3131
3132         /* Base skill -- stealth */
3133         p_ptr->skill_stl = tmp_rp_ptr->r_stl + cp_ptr->c_stl + ap_ptr->a_stl;
3134
3135         /* Base skill -- searching ability */
3136         p_ptr->skill_srh = tmp_rp_ptr->r_srh + cp_ptr->c_srh + ap_ptr->a_srh;
3137
3138         /* Base skill -- searching frequency */
3139         p_ptr->skill_fos = tmp_rp_ptr->r_fos + cp_ptr->c_fos + ap_ptr->a_fos;
3140
3141         /* Base skill -- combat (normal) */
3142         p_ptr->skill_thn = tmp_rp_ptr->r_thn + cp_ptr->c_thn + ap_ptr->a_thn;
3143
3144         /* Base skill -- combat (shooting) */
3145         p_ptr->skill_thb = tmp_rp_ptr->r_thb + cp_ptr->c_thb + ap_ptr->a_thb;
3146
3147         /* Base skill -- combat (throwing) */
3148         p_ptr->skill_tht = tmp_rp_ptr->r_thb + cp_ptr->c_thb + ap_ptr->a_thb;
3149
3150         /* Base skill -- digging */
3151         p_ptr->skill_dig = 0;
3152
3153         if (buki_motteruka(INVEN_RARM) && (empty_hands(FALSE) & 0x00000001) && ((inventory[INVEN_RARM].weight > 99) || (inventory[INVEN_RARM].tval == TV_POLEARM)) && (!p_ptr->riding || (p_ptr->pet_extra_flags & PF_RYOUTE))) p_ptr->ryoute = TRUE;
3154         if (((p_ptr->pclass == CLASS_MONK) || (p_ptr->pclass == CLASS_FORCETRAINER) || (p_ptr->pclass == CLASS_BERSERKER)) && (empty_hands(TRUE) == 3) && (!p_ptr->riding || (p_ptr->pet_extra_flags & PF_RYOUTE))) p_ptr->ryoute = TRUE;
3155         if (buki_motteruka(INVEN_RARM) || !buki_motteruka(INVEN_LARM)) p_ptr->migite = TRUE;
3156         if (buki_motteruka(INVEN_LARM)) p_ptr->hidarite = TRUE;
3157
3158         if (p_ptr->special_defense & KAMAE_MASK)
3159         {
3160                 if (empty_hands(TRUE) < 2)
3161                 {
3162                         set_action(ACTION_NONE);
3163                 }
3164         }
3165
3166         switch (p_ptr->pclass)
3167         {
3168                 case CLASS_WARRIOR:
3169                         if (p_ptr->lev > 29) p_ptr->resist_fear = TRUE;
3170                         if (p_ptr->lev > 44) p_ptr->regenerate = TRUE;
3171                         break;
3172                 case CLASS_PALADIN:
3173                         if (p_ptr->lev > 39) p_ptr->resist_fear = TRUE;
3174                         break;
3175                 case CLASS_CHAOS_WARRIOR:
3176                         if (p_ptr->lev > 29) p_ptr->resist_chaos = TRUE;
3177                         if (p_ptr->lev > 39) p_ptr->resist_fear = TRUE;
3178                         break;
3179                 case CLASS_MINDCRAFTER:
3180                         if (p_ptr->lev >  9) p_ptr->resist_fear = TRUE;
3181                         if (p_ptr->lev > 19) p_ptr->sustain_wis = TRUE;
3182                         if (p_ptr->lev > 29) p_ptr->resist_conf = TRUE;
3183                         if (p_ptr->lev > 39) p_ptr->telepathy = TRUE;
3184                         break;
3185                 case CLASS_MONK:
3186                 case CLASS_FORCETRAINER:
3187                         /* Unencumbered Monks become faster every 10 levels */
3188                         if (!(heavy_armor()))
3189                         {
3190                                 if (!((p_ptr->prace == RACE_KLACKON) ||
3191                                       (p_ptr->prace == RACE_SPRITE) ||
3192                                       (p_ptr->pseikaku == SEIKAKU_MUNCHKIN)))
3193                                         p_ptr->pspeed += (p_ptr->lev) / 10;
3194
3195                                 /* Free action if unencumbered at level 25 */
3196                                 if  (p_ptr->lev > 24)
3197                                         p_ptr->free_act = TRUE;
3198                         }
3199                         break;
3200                 case CLASS_SORCERER:
3201                         p_ptr->to_a -= 50;
3202                         p_ptr->dis_to_a -= 50;
3203                         break;
3204                 case CLASS_BARD:
3205                         p_ptr->resist_sound = TRUE;
3206                         break;
3207                 case CLASS_SAMURAI:
3208                         if (p_ptr->lev > 29) p_ptr->resist_fear = TRUE;
3209                         break;
3210                 case CLASS_BERSERKER:
3211                         p_ptr->shero = 1;
3212                         p_ptr->sustain_str = TRUE;
3213                         p_ptr->sustain_dex = TRUE;
3214                         p_ptr->sustain_con = TRUE;
3215                         p_ptr->regenerate = TRUE;
3216                         p_ptr->free_act = TRUE;
3217                         p_ptr->pspeed += 2;
3218                         if (p_ptr->lev > 29) p_ptr->pspeed++;
3219                         if (p_ptr->lev > 39) p_ptr->pspeed++;
3220                         if (p_ptr->lev > 44) p_ptr->pspeed++;
3221                         if (p_ptr->lev > 49) p_ptr->pspeed++;
3222                         p_ptr->to_a += 10+p_ptr->lev/2;
3223                         p_ptr->dis_to_a += 10+p_ptr->lev/2;
3224                         p_ptr->skill_dig += (100+p_ptr->lev*8);
3225                         if (p_ptr->lev > 39) p_ptr->reflect = TRUE;
3226                         p_ptr->redraw |= PR_STATUS;
3227                         break;
3228                 case CLASS_MIRROR_MASTER:
3229                         if (p_ptr->lev > 39) p_ptr->reflect = TRUE;
3230                         break;
3231                 case CLASS_NINJA:
3232                         /* Unencumbered Monks become faster every 10 levels */
3233                         if (heavy_armor())
3234                         {
3235                                 p_ptr->pspeed -= (p_ptr->lev) / 10;
3236                                 p_ptr->skill_stl -= (p_ptr->lev)/10;
3237                         }
3238                         else if (!inventory[INVEN_LARM].tval || p_ptr->hidarite)
3239                         {
3240                                 p_ptr->pspeed += 3;
3241                                 if (!((p_ptr->prace == RACE_KLACKON) ||
3242                                       (p_ptr->prace == RACE_SPRITE) ||
3243                                       (p_ptr->pseikaku == SEIKAKU_MUNCHKIN)))
3244                                         p_ptr->pspeed += (p_ptr->lev) / 10;
3245                                 p_ptr->skill_stl += (p_ptr->lev)/10;
3246
3247                                 /* Free action if unencumbered at level 25 */
3248                                 if  (p_ptr->lev > 24)
3249                                         p_ptr->free_act = TRUE;
3250                         }
3251                         if (!inventory[INVEN_LARM].tval || p_ptr->hidarite)
3252                         {
3253                                 p_ptr->to_a += p_ptr->lev/2+5;
3254                                 p_ptr->dis_to_a += p_ptr->lev/2+5;
3255                         }
3256                         p_ptr->slow_digest = TRUE;
3257                         p_ptr->resist_fear = TRUE;
3258                         if (p_ptr->lev > 19) p_ptr->resist_pois = TRUE;
3259                         if (p_ptr->lev > 24) p_ptr->sustain_dex = TRUE;
3260                         if (p_ptr->lev > 29) p_ptr->see_inv = TRUE;
3261                         if (p_ptr->lev > 44)
3262                         {
3263                                 p_ptr->oppose_pois = 1;
3264                                 p_ptr->redraw |= PR_STATUS;
3265                         }
3266                         break;
3267         }
3268
3269         /***** Races ****/
3270         if (p_ptr->mimic_form)
3271         {
3272                 switch(p_ptr->mimic_form)
3273                 {
3274                 case MIMIC_DEMON:
3275                         p_ptr->hold_life=TRUE;
3276                         p_ptr->resist_chaos=TRUE;
3277                         p_ptr->resist_neth=TRUE;
3278                         p_ptr->resist_fire=TRUE;
3279                         p_ptr->oppose_fire = 1;
3280                         p_ptr->see_inv=TRUE;
3281                         p_ptr->pspeed += 3;
3282                         p_ptr->redraw |= PR_STATUS;
3283                         p_ptr->to_a += 10;
3284                         p_ptr->dis_to_a += 10;
3285                         break;
3286                 case MIMIC_DEMON_LORD:
3287                         p_ptr->hold_life=TRUE;
3288                         p_ptr->resist_chaos=TRUE;
3289                         p_ptr->resist_neth=TRUE;
3290                         p_ptr->immune_fire=TRUE;
3291                         p_ptr->resist_acid = TRUE;
3292                         p_ptr->resist_fire=TRUE;
3293                         p_ptr->resist_cold = TRUE;
3294                         p_ptr->resist_elec = TRUE;
3295                         p_ptr->resist_pois = TRUE;
3296                         p_ptr->resist_conf = TRUE;
3297                         p_ptr->resist_disen = TRUE;
3298                         p_ptr->resist_nexus = TRUE;
3299                         p_ptr->resist_fear = TRUE;
3300                         p_ptr->sh_fire = TRUE;
3301                         p_ptr->see_inv = TRUE;
3302                         p_ptr->telepathy = TRUE;
3303                         p_ptr->ffall = TRUE;
3304                         p_ptr->kill_wall = TRUE;
3305                         p_ptr->pspeed += 5;
3306                         p_ptr->to_a += 20;
3307                         p_ptr->dis_to_a += 20;
3308                         break;
3309                 case MIMIC_VAMPIRE:
3310                         p_ptr->resist_dark = TRUE;
3311                         p_ptr->hold_life = TRUE;
3312                         p_ptr->resist_neth = TRUE;
3313                         p_ptr->resist_cold = TRUE;
3314                         p_ptr->resist_pois = TRUE;
3315                         p_ptr->see_inv = TRUE;
3316                         p_ptr->pspeed += 3;
3317                         p_ptr->to_a += 10;
3318                         p_ptr->dis_to_a += 10;
3319                         if (p_ptr->pclass != CLASS_NINJA) p_ptr->lite = TRUE;
3320                         break;
3321                 }
3322         }
3323         else
3324         {
3325         switch (p_ptr->prace)
3326         {
3327                 case RACE_ELF:
3328                         p_ptr->resist_lite = TRUE;
3329                         break;
3330                 case RACE_HOBBIT:
3331                         p_ptr->sustain_dex = TRUE;
3332                         break;
3333                 case RACE_GNOME:
3334                         p_ptr->free_act = TRUE;
3335                         break;
3336                 case RACE_DWARF:
3337                         p_ptr->resist_blind = TRUE;
3338                         break;
3339                 case RACE_HALF_ORC:
3340                         p_ptr->resist_dark = TRUE;
3341                         break;
3342                 case RACE_HALF_TROLL:
3343                         p_ptr->sustain_str = TRUE;
3344
3345                         if (p_ptr->lev > 14)
3346                         {
3347                                 /* High level trolls heal fast... */
3348                                 p_ptr->regenerate = TRUE;
3349
3350                                 if (p_ptr->pclass == CLASS_WARRIOR || p_ptr->pclass == CLASS_BERSERKER)
3351                                 {
3352                                         p_ptr->slow_digest = TRUE;
3353                                         /* Let's not make Regeneration
3354                                          * a disadvantage for the poor warriors who can
3355                                          * never learn a spell that satisfies hunger (actually
3356                                          * neither can rogues, but half-trolls are not
3357                                          * supposed to play rogues) */
3358                                 }
3359                         }
3360                         break;
3361                 case RACE_AMBERITE:
3362                         p_ptr->sustain_con = TRUE;
3363                         p_ptr->regenerate = TRUE;  /* Amberites heal fast... */
3364                         break;
3365                 case RACE_HIGH_ELF:
3366                         p_ptr->resist_lite = TRUE;
3367                         p_ptr->see_inv = TRUE;
3368                         break;
3369                 case RACE_BARBARIAN:
3370                         p_ptr->resist_fear = TRUE;
3371                         break;
3372                 case RACE_HALF_OGRE:
3373                         p_ptr->resist_dark = TRUE;
3374                         p_ptr->sustain_str = TRUE;
3375                         break;
3376                 case RACE_HALF_GIANT:
3377                         p_ptr->sustain_str = TRUE;
3378                         p_ptr->resist_shard = TRUE;
3379                         break;
3380                 case RACE_HALF_TITAN:
3381                         p_ptr->resist_chaos = TRUE;
3382                         break;
3383                 case RACE_CYCLOPS:
3384                         p_ptr->resist_sound = TRUE;
3385                         break;
3386                 case RACE_YEEK:
3387                         p_ptr->resist_acid = TRUE;
3388                         if (p_ptr->lev > 19) p_ptr->immune_acid = TRUE;
3389                         break;
3390                 case RACE_KLACKON:
3391                         p_ptr->resist_conf = TRUE;
3392                         p_ptr->resist_acid = TRUE;
3393
3394                         /* Klackons become faster */
3395                         p_ptr->pspeed += (p_ptr->lev) / 10;
3396                         break;
3397                 case RACE_KOBOLD:
3398                         p_ptr->resist_pois = TRUE;
3399                         break;
3400                 case RACE_NIBELUNG:
3401                         p_ptr->resist_disen = TRUE;
3402                         p_ptr->resist_dark = TRUE;
3403                         break;
3404                 case RACE_DARK_ELF:
3405                         p_ptr->resist_dark = TRUE;
3406                         if (p_ptr->lev > 19) p_ptr->see_inv = TRUE;
3407                         break;
3408                 case RACE_DRACONIAN:
3409                         p_ptr->ffall = TRUE;
3410                         if (p_ptr->lev >  4) p_ptr->resist_fire = TRUE;
3411                         if (p_ptr->lev >  9) p_ptr->resist_cold = TRUE;
3412                         if (p_ptr->lev > 14) p_ptr->resist_acid = TRUE;
3413                         if (p_ptr->lev > 19) p_ptr->resist_elec = TRUE;
3414                         if (p_ptr->lev > 34) p_ptr->resist_pois = TRUE;
3415                         break;
3416                 case RACE_MIND_FLAYER:
3417                         p_ptr->sustain_int = TRUE;
3418                         p_ptr->sustain_wis = TRUE;
3419                         if (p_ptr->lev > 14) p_ptr->see_inv = TRUE;
3420                         if (p_ptr->lev > 29) p_ptr->telepathy = TRUE;
3421                         break;
3422                 case RACE_IMP:
3423                         p_ptr->resist_fire = TRUE;
3424                         if (p_ptr->lev > 9) p_ptr->see_inv = TRUE;
3425                         break;
3426                 case RACE_GOLEM:
3427                         p_ptr->slow_digest = TRUE;
3428                         p_ptr->free_act = TRUE;
3429                         p_ptr->see_inv = TRUE;
3430                         p_ptr->resist_pois = TRUE;
3431                         if (p_ptr->lev > 34) p_ptr->hold_life = TRUE;
3432                         break;
3433                 case RACE_SKELETON:
3434                         p_ptr->resist_shard = TRUE;
3435                         p_ptr->hold_life = TRUE;
3436                         p_ptr->see_inv = TRUE;
3437                         p_ptr->resist_pois = TRUE;
3438                         if (p_ptr->lev > 9) p_ptr->resist_cold = TRUE;
3439                         break;
3440                 case RACE_ZOMBIE:
3441                         p_ptr->resist_neth = TRUE;
3442                         p_ptr->hold_life = TRUE;
3443                         p_ptr->see_inv = TRUE;
3444                         p_ptr->resist_pois = TRUE;
3445                         p_ptr->slow_digest = TRUE;
3446                         if (p_ptr->lev > 4) p_ptr->resist_cold = TRUE;
3447                         break;
3448                 case RACE_VAMPIRE:
3449                         p_ptr->resist_dark = TRUE;
3450                         p_ptr->hold_life = TRUE;
3451                         p_ptr->resist_neth = TRUE;
3452                         p_ptr->resist_cold = TRUE;
3453                         p_ptr->resist_pois = TRUE;
3454                         if (p_ptr->pclass != CLASS_NINJA) p_ptr->lite = TRUE;
3455                         break;
3456                 case RACE_SPECTRE:
3457                         p_ptr->ffall = TRUE;
3458                         p_ptr->free_act = TRUE;
3459                         p_ptr->resist_neth = TRUE;
3460                         p_ptr->hold_life = TRUE;
3461                         p_ptr->see_inv = TRUE;
3462                         p_ptr->resist_pois = TRUE;
3463                         p_ptr->slow_digest = TRUE;
3464                         p_ptr->resist_cold = TRUE;
3465                         p_ptr->pass_wall = TRUE;
3466                         if (p_ptr->lev > 34) p_ptr->telepathy = TRUE;
3467                         break;
3468                 case RACE_SPRITE:
3469                         p_ptr->ffall = TRUE;
3470                         p_ptr->resist_lite = TRUE;
3471
3472                         /* Sprites become faster */
3473                         p_ptr->pspeed += (p_ptr->lev) / 10;
3474                         break;
3475                 case RACE_BEASTMAN:
3476                         p_ptr->resist_conf  = TRUE;
3477                         p_ptr->resist_sound = TRUE;
3478                         break;
3479                 case RACE_ENT:
3480                         /* Ents dig like maniacs, but only with their hands. */
3481                         if (!inventory[INVEN_RARM].k_idx)
3482                                 p_ptr->skill_dig += p_ptr->lev * 10;
3483                         /* Ents get tougher and stronger as they age, but lose dexterity. */
3484                         if (p_ptr->lev > 25) p_ptr->stat_add[A_STR]++;
3485                         if (p_ptr->lev > 40) p_ptr->stat_add[A_STR]++;
3486                         if (p_ptr->lev > 45) p_ptr->stat_add[A_STR]++;
3487
3488                         if (p_ptr->lev > 25) p_ptr->stat_add[A_DEX]--;
3489                         if (p_ptr->lev > 40) p_ptr->stat_add[A_DEX]--;
3490                         if (p_ptr->lev > 45) p_ptr->stat_add[A_DEX]--;
3491
3492                         if (p_ptr->lev > 25) p_ptr->stat_add[A_CON]++;
3493                         if (p_ptr->lev > 40) p_ptr->stat_add[A_CON]++;
3494                         if (p_ptr->lev > 45) p_ptr->stat_add[A_CON]++;
3495                         break;
3496                 case RACE_ANGEL:
3497                         p_ptr->ffall = TRUE;
3498                         p_ptr->see_inv = TRUE;
3499                         break;
3500                 case RACE_DEMON:
3501                         p_ptr->resist_fire  = TRUE;
3502                         p_ptr->resist_neth  = TRUE;
3503                         p_ptr->hold_life = TRUE;
3504                         if (p_ptr->lev > 9)
3505                                 p_ptr->see_inv = TRUE;
3506                         if (p_ptr->lev > 44)
3507                         {
3508                                 p_ptr->oppose_fire = 1;
3509                                 p_ptr->redraw |= PR_STATUS;
3510                         }
3511                         break;
3512                 case RACE_DUNADAN:
3513                         p_ptr->sustain_con = TRUE;
3514                         break;
3515                 case RACE_S_FAIRY:
3516                         p_ptr->ffall = TRUE;
3517                         break;
3518                 case RACE_KUTA:
3519                         p_ptr->resist_conf = TRUE;
3520                         break;
3521                 case RACE_ANDROID:
3522                         p_ptr->slow_digest = TRUE;
3523                         p_ptr->free_act = TRUE;
3524                         p_ptr->resist_pois = TRUE;
3525                         p_ptr->hold_life = TRUE;
3526                         break;
3527                 default:
3528                         /* Do nothing */
3529                         ;
3530         }
3531         }
3532
3533         if (p_ptr->ult_res || (p_ptr->special_defense & KATA_MUSOU))
3534         {
3535                 p_ptr->see_inv = TRUE;
3536                 p_ptr->free_act = TRUE;
3537                 p_ptr->slow_digest = TRUE;
3538                 p_ptr->regenerate = TRUE;
3539                 p_ptr->ffall = TRUE;
3540                 p_ptr->hold_life = TRUE;
3541                 p_ptr->telepathy = TRUE;
3542                 p_ptr->lite = TRUE;
3543                 p_ptr->sustain_str = TRUE;
3544                 p_ptr->sustain_int = TRUE;
3545                 p_ptr->sustain_wis = TRUE;
3546                 p_ptr->sustain_con = TRUE;
3547                 p_ptr->sustain_dex = TRUE;
3548                 p_ptr->sustain_chr = TRUE;
3549                 p_ptr->resist_acid = TRUE;
3550                 p_ptr->resist_elec = TRUE;
3551                 p_ptr->resist_fire = TRUE;
3552                 p_ptr->resist_cold = TRUE;
3553                 p_ptr->resist_pois = TRUE;
3554                 p_ptr->resist_conf = TRUE;
3555                 p_ptr->resist_sound = TRUE;
3556                 p_ptr->resist_lite = TRUE;
3557                 p_ptr->resist_dark = TRUE;
3558                 p_ptr->resist_chaos = TRUE;
3559                 p_ptr->resist_disen = TRUE;
3560                 p_ptr->resist_shard = TRUE;
3561                 p_ptr->resist_nexus = TRUE;
3562                 p_ptr->resist_blind = TRUE;
3563                 p_ptr->resist_neth = TRUE;
3564                 p_ptr->resist_fear = TRUE;
3565                 p_ptr->reflect = TRUE;
3566                 p_ptr->sh_fire = TRUE;
3567                 p_ptr->sh_elec = TRUE;
3568                 p_ptr->sh_cold = TRUE;
3569                 p_ptr->to_a += 100;
3570                 p_ptr->dis_to_a += 100;
3571         }
3572         /* Temporary shield */
3573         else if (p_ptr->tsubureru || p_ptr->shield || p_ptr->magicdef)
3574         {
3575                 p_ptr->to_a += 50;
3576                 p_ptr->dis_to_a += 50;
3577         }
3578
3579         if (p_ptr->tim_res_nether)
3580         {
3581                 p_ptr->resist_neth = TRUE;
3582         }
3583         if (p_ptr->tim_sh_fire)
3584         {
3585                 p_ptr->sh_fire = TRUE;
3586         }
3587         if (p_ptr->tim_res_time)
3588         {
3589                 p_ptr->resist_time = TRUE;
3590         }
3591
3592         /* Sexy Gal */
3593         if (p_ptr->pseikaku == SEIKAKU_SEXY) p_ptr->cursed |= (TRC_AGGRAVATE);
3594         if (p_ptr->pseikaku == SEIKAKU_NAMAKE) p_ptr->to_m_chance += 10;
3595         if (p_ptr->pseikaku == SEIKAKU_KIREMONO) p_ptr->to_m_chance -= 3;
3596         if ((p_ptr->pseikaku == SEIKAKU_GAMAN) || (p_ptr->pseikaku == SEIKAKU_CHIKARA)) p_ptr->to_m_chance++;
3597
3598         /* Lucky man */
3599         if (p_ptr->pseikaku == SEIKAKU_LUCKY) p_ptr->muta3 |= MUT3_GOOD_LUCK;
3600
3601         if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN)
3602         {
3603                 p_ptr->resist_blind = TRUE;
3604                 p_ptr->resist_conf  = TRUE;
3605                 p_ptr->hold_life = TRUE;
3606                 if (p_ptr->pclass != CLASS_NINJA) p_ptr->lite = TRUE;
3607
3608                 if ((p_ptr->prace != RACE_KLACKON) && (p_ptr->prace != RACE_SPRITE))
3609                         /* Munchkin become faster */
3610                         p_ptr->pspeed += (p_ptr->lev) / 10 + 5;
3611         }
3612
3613         if (p_ptr->riding)
3614         {
3615                 if (!(r_info[m_list[p_ptr->riding].r_idx].flags2 & RF2_PASS_WALL))
3616                         p_ptr->pass_wall = FALSE;
3617                 if (r_info[m_list[p_ptr->riding].r_idx].flags2 & RF2_KILL_WALL)
3618                         p_ptr->pass_wall = TRUE;
3619         }
3620         if (music_singing(MUSIC_WALL)) p_ptr->kill_wall = TRUE;
3621
3622         if (p_ptr->kill_wall) p_ptr->pass_wall = TRUE;
3623
3624         /* Hack -- apply racial/class stat maxes */
3625         /* Apply the racial modifiers */
3626         for (i = 0; i < 6; i++)
3627         {
3628                 /* Modify the stats for "race" */
3629                 p_ptr->stat_add[i] += (tmp_rp_ptr->r_adj[i] + cp_ptr->c_adj[i] + ap_ptr->a_adj[i]);
3630         }
3631
3632
3633         /* I'm adding the mutations here for the lack of a better place... */
3634         if (p_ptr->muta3)
3635         {
3636                 /* Hyper Strength */
3637                 if (p_ptr->muta3 & MUT3_HYPER_STR)
3638                 {
3639                         p_ptr->stat_add[A_STR] += 4;
3640                 }
3641
3642                 /* Puny */
3643                 if (p_ptr->muta3 & MUT3_PUNY)
3644                 {
3645                         p_ptr->stat_add[A_STR] -= 4;
3646                 }
3647
3648                 /* Living computer */
3649                 if (p_ptr->muta3 & MUT3_HYPER_INT)
3650                 {
3651                         p_ptr->stat_add[A_INT] += 4;
3652                         p_ptr->stat_add[A_WIS] += 4;
3653                 }
3654
3655                 /* Moronic */
3656                 if (p_ptr->muta3 & MUT3_MORONIC)
3657                 {
3658                         p_ptr->stat_add[A_INT] -= 4;
3659                         p_ptr->stat_add[A_WIS] -= 4;
3660                 }
3661
3662                 if (p_ptr->muta3 & MUT3_RESILIENT)
3663                 {
3664                         p_ptr->stat_add[A_CON] += 4;
3665                 }
3666
3667                 if (p_ptr->muta3 & MUT3_XTRA_FAT)
3668                 {
3669                         p_ptr->stat_add[A_CON] += 2;
3670                         p_ptr->pspeed -= 2;
3671                 }
3672
3673                 if (p_ptr->muta3 & MUT3_ALBINO)
3674                 {
3675                         p_ptr->stat_add[A_CON] -= 4;
3676                 }
3677
3678                 if (p_ptr->muta3 & MUT3_FLESH_ROT)
3679                 {
3680                         p_ptr->stat_add[A_CON] -= 2;
3681                         p_ptr->stat_add[A_CHR] -= 1;
3682                         p_ptr->regenerate = FALSE;
3683                         /* Cancel innate regeneration */
3684                 }
3685
3686                 if (p_ptr->muta3 & MUT3_SILLY_VOI)
3687                 {
3688                         p_ptr->stat_add[A_CHR] -= 4;
3689                 }
3690
3691                 if (p_ptr->muta3 & MUT3_BLANK_FAC)
3692                 {
3693                         p_ptr->stat_add[A_CHR] -= 1;
3694                 }
3695
3696                 if (p_ptr->muta3 & MUT3_XTRA_EYES)
3697                 {
3698                         p_ptr->skill_fos += 15;
3699                         p_ptr->skill_srh += 15;
3700                 }
3701
3702                 if (p_ptr->muta3 & MUT3_MAGIC_RES)
3703                 {
3704                         p_ptr->skill_sav += (15 + (p_ptr->lev / 5));
3705                 }
3706
3707                 if (p_ptr->muta3 & MUT3_XTRA_NOIS)
3708                 {
3709                         p_ptr->skill_stl -= 3;
3710                 }
3711
3712                 if (p_ptr->muta3 & MUT3_INFRAVIS)
3713                 {
3714                         p_ptr->see_infra += 3;
3715                 }
3716
3717                 if (p_ptr->muta3 & MUT3_XTRA_LEGS)
3718                 {
3719                         p_ptr->pspeed += 3;
3720                 }
3721
3722                 if (p_ptr->muta3 & MUT3_SHORT_LEG)
3723                 {
3724                         p_ptr->pspeed -= 3;
3725                 }
3726
3727                 if (p_ptr->muta3 & MUT3_ELEC_TOUC)
3728                 {
3729                         p_ptr->sh_elec = TRUE;
3730                 }
3731
3732                 if (p_ptr->muta3 & MUT3_FIRE_BODY)
3733                 {
3734                         p_ptr->sh_fire = TRUE;
3735                         p_ptr->lite = TRUE;
3736                 }
3737
3738                 if (p_ptr->muta3 & MUT3_WART_SKIN)
3739                 {
3740                         p_ptr->stat_add[A_CHR] -= 2;
3741                         p_ptr->to_a += 5;
3742                         p_ptr->dis_to_a += 5;
3743                 }
3744
3745                 if (p_ptr->muta3 & MUT3_SCALES)
3746                 {
3747                         p_ptr->stat_add[A_CHR] -= 1;
3748                         p_ptr->to_a += 10;
3749                         p_ptr->dis_to_a += 10;
3750                 }
3751
3752                 if (p_ptr->muta3 & MUT3_IRON_SKIN)
3753                 {
3754                         p_ptr->stat_add[A_DEX] -= 1;
3755                         p_ptr->to_a += 25;
3756                         p_ptr->dis_to_a += 25;
3757                 }
3758
3759                 if (p_ptr->muta3 & MUT3_WINGS)
3760                 {
3761                         p_ptr->ffall = TRUE;
3762                 }
3763
3764                 if (p_ptr->muta3 & MUT3_FEARLESS)
3765                 {
3766                         p_ptr->resist_fear = TRUE;
3767                 }
3768
3769                 if (p_ptr->muta3 & MUT3_REGEN)
3770                 {
3771                         p_ptr->regenerate = TRUE;
3772                 }
3773
3774                 if (p_ptr->muta3 & MUT3_ESP)
3775                 {
3776                         p_ptr->telepathy = TRUE;
3777                 }
3778
3779                 if (p_ptr->muta3 & MUT3_LIMBER)
3780                 {
3781                         p_ptr->stat_add[A_DEX] += 3;
3782                 }
3783
3784                 if (p_ptr->muta3 & MUT3_ARTHRITIS)
3785                 {
3786                         p_ptr->stat_add[A_DEX] -= 3;
3787                 }
3788
3789                 if (p_ptr->muta3 & MUT3_MOTION)
3790                 {
3791                         p_ptr->free_act = TRUE;
3792                         p_ptr->skill_stl += 1;
3793                 }
3794
3795                 if (p_ptr->muta3 & MUT3_ILL_NORM)
3796                 {
3797                         p_ptr->stat_add[A_CHR] = 0;
3798                 }
3799         }
3800
3801         if (p_ptr->tsuyoshi)
3802         {
3803                 p_ptr->stat_add[A_STR] += 4;
3804                 p_ptr->stat_add[A_CON] += 4;
3805         }
3806
3807         /* Scan the usable inventory */
3808         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
3809         {
3810                 int bonus_to_h, bonus_to_d;
3811                 o_ptr = &inventory[i];
3812
3813                 /* Skip non-objects */
3814                 if (!o_ptr->k_idx) continue;
3815
3816                 /* Extract the item flags */
3817                 object_flags(o_ptr, &f1, &f2, &f3);
3818
3819                 p_ptr->cursed |= (o_ptr->curse_flags & (0xFFFFFFF0L));
3820                 if (o_ptr->name1 == ART_CHAINSWORD) p_ptr->cursed |= TRC_CHAINSWORD;
3821
3822                 /* Affect stats */
3823                 if (f1 & (TR1_STR)) p_ptr->stat_add[A_STR] += o_ptr->pval;
3824                 if (f1 & (TR1_INT)) p_ptr->stat_add[A_INT] += o_ptr->pval;
3825                 if (f1 & (TR1_WIS)) p_ptr->stat_add[A_WIS] += o_ptr->pval;
3826                 if (f1 & (TR1_DEX)) p_ptr->stat_add[A_DEX] += o_ptr->pval;
3827                 if (f1 & (TR1_CON)) p_ptr->stat_add[A_CON] += o_ptr->pval;
3828                 if (f1 & (TR1_CHR)) p_ptr->stat_add[A_CHR] += o_ptr->pval;
3829
3830                 if (f1 & (TR1_MAGIC_MASTERY))    p_ptr->skill_dev += 8*o_ptr->pval;
3831
3832                 /* Affect stealth */
3833                 if (f1 & (TR1_STEALTH)) p_ptr->skill_stl += o_ptr->pval;
3834
3835                 /* Affect searching ability (factor of five) */
3836                 if (f1 & (TR1_SEARCH)) p_ptr->skill_srh += (o_ptr->pval * 5);
3837
3838                 /* Affect searching frequency (factor of five) */
3839                 if (f1 & (TR1_SEARCH)) p_ptr->skill_fos += (o_ptr->pval * 5);
3840
3841                 /* Affect infravision */
3842                 if (f1 & (TR1_INFRA)) p_ptr->see_infra += o_ptr->pval;
3843
3844                 /* Affect digging (factor of 20) */
3845                 if (f1 & (TR1_TUNNEL)) p_ptr->skill_dig += (o_ptr->pval * 20);
3846
3847                 /* Affect speed */
3848                 if (f1 & (TR1_SPEED)) p_ptr->pspeed += o_ptr->pval;
3849
3850                 /* Affect blows */
3851                 if (f1 & (TR1_BLOWS))
3852                 {
3853                         if((i == INVEN_RARM || i == INVEN_RIGHT) && !p_ptr->ryoute) extra_blows[0] += o_ptr->pval;
3854                         else if((i == INVEN_LARM || i == INVEN_LEFT) && !p_ptr->ryoute) extra_blows[1] += o_ptr->pval;
3855                         else {extra_blows[0] += o_ptr->pval; extra_blows[1] += o_ptr->pval;}
3856                 }
3857
3858                 /* Hack -- cause earthquakes */
3859                 if (f1 & (TR1_IMPACT)) p_ptr->impact[(i == INVEN_RARM) ? 0 : 1] = TRUE;
3860
3861                 /* Boost shots */
3862                 if (f3 & (TR3_XTRA_SHOTS)) extra_shots++;
3863
3864                 /* Various flags */
3865                 if (f3 & (TR3_AGGRAVATE))   p_ptr->cursed |= TRC_AGGRAVATE;
3866                 if (f3 & (TR3_DRAIN_EXP))   p_ptr->cursed |= TRC_DRAIN_EXP;
3867                 if (f3 & (TR3_TY_CURSE))    p_ptr->cursed |= TRC_TY_CURSE;
3868                 if (f3 & (TR3_DEC_MANA))    p_ptr->dec_mana = TRUE;
3869                 if (f3 & (TR3_BLESSED))     p_ptr->bless_blade = TRUE;
3870                 if (f3 & (TR3_XTRA_MIGHT))  p_ptr->xtra_might = TRUE;
3871                 if (f3 & (TR3_SLOW_DIGEST)) p_ptr->slow_digest = TRUE;
3872                 if (f3 & (TR3_REGEN))       p_ptr->regenerate = TRUE;
3873                 if (f3 & (TR3_TELEPATHY))   p_ptr->telepathy = TRUE;
3874                 if (f3 & (TR3_SEE_INVIS))   p_ptr->see_inv = TRUE;
3875                 if (f3 & (TR3_FEATHER))     p_ptr->ffall = TRUE;
3876                 if (f2 & (TR2_FREE_ACT))    p_ptr->free_act = TRUE;
3877                 if (f2 & (TR2_HOLD_LIFE))   p_ptr->hold_life = TRUE;
3878                 if (f3 & (TR3_WARNING)){
3879                         if (!o_ptr->inscription || !(strchr(quark_str(o_ptr->inscription),'$')))
3880                           p_ptr->warning = TRUE;
3881                 }
3882
3883                 if (f3 & (TR3_TELEPORT))
3884                 {
3885                         if (cursed_p(o_ptr)) p_ptr->cursed |= TRC_TELEPORT;
3886                         else if (!o_ptr->inscription || !(strchr(quark_str(o_ptr->inscription),'.')))
3887                                 p_ptr->cursed |= TRC_TELEPORT_SELF;
3888                 }
3889
3890                 /* Immunity flags */
3891                 if (f2 & (TR2_IM_FIRE)) p_ptr->immune_fire = TRUE;
3892                 if (f2 & (TR2_IM_ACID)) p_ptr->immune_acid = TRUE;
3893                 if (f2 & (TR2_IM_COLD)) p_ptr->immune_cold = TRUE;
3894                 if (f2 & (TR2_IM_ELEC)) p_ptr->immune_elec = TRUE;
3895
3896                 /* Resistance flags */
3897                 if (f2 & (TR2_RES_ACID))   p_ptr->resist_acid = TRUE;
3898                 if (f2 & (TR2_RES_ELEC))   p_ptr->resist_elec = TRUE;
3899                 if (f2 & (TR2_RES_FIRE))   p_ptr->resist_fire = TRUE;
3900                 if (f2 & (TR2_RES_COLD))   p_ptr->resist_cold = TRUE;
3901                 if (f2 & (TR2_RES_POIS))   p_ptr->resist_pois = TRUE;
3902                 if (f2 & (TR2_RES_FEAR))   p_ptr->resist_fear = TRUE;
3903                 if (f2 & (TR2_RES_CONF))   p_ptr->resist_conf = TRUE;
3904                 if (f2 & (TR2_RES_SOUND))  p_ptr->resist_sound = TRUE;
3905                 if (f2 & (TR2_RES_LITE))   p_ptr->resist_lite = TRUE;
3906                 if (f2 & (TR2_RES_DARK))   p_ptr->resist_dark = TRUE;
3907                 if (f2 & (TR2_RES_CHAOS))  p_ptr->resist_chaos = TRUE;
3908                 if (f2 & (TR2_RES_DISEN))  p_ptr->resist_disen = TRUE;
3909                 if (f2 & (TR2_RES_SHARDS)) p_ptr->resist_shard = TRUE;
3910                 if (f2 & (TR2_RES_NEXUS))  p_ptr->resist_nexus = TRUE;
3911                 if (f2 & (TR2_RES_BLIND))  p_ptr->resist_blind = TRUE;
3912                 if (f2 & (TR2_RES_NETHER)) p_ptr->resist_neth = TRUE;
3913
3914                 if (f2 & (TR2_REFLECT))  p_ptr->reflect = TRUE;
3915                 if (f3 & (TR3_SH_FIRE))  p_ptr->sh_fire = TRUE;
3916                 if (f3 & (TR3_SH_ELEC))  p_ptr->sh_elec = TRUE;
3917                 if (f3 & (TR3_SH_COLD))  p_ptr->sh_cold = TRUE;
3918                 if (f3 & (TR3_NO_MAGIC)) p_ptr->anti_magic = TRUE;
3919                 if (f3 & (TR3_NO_TELE))  p_ptr->anti_tele = TRUE;
3920
3921                 /* Sustain flags */
3922                 if (f2 & (TR2_SUST_STR)) p_ptr->sustain_str = TRUE;
3923                 if (f2 & (TR2_SUST_INT)) p_ptr->sustain_int = TRUE;
3924                 if (f2 & (TR2_SUST_WIS)) p_ptr->sustain_wis = TRUE;
3925                 if (f2 & (TR2_SUST_DEX)) p_ptr->sustain_dex = TRUE;
3926                 if (f2 & (TR2_SUST_CON)) p_ptr->sustain_con = TRUE;
3927                 if (f2 & (TR2_SUST_CHR)) p_ptr->sustain_chr = TRUE;
3928
3929                 if (o_ptr->name2 == EGO_YOIYAMI) yoiyami = TRUE;
3930                 if (o_ptr->name2 == EGO_2WEAPON) easy_2weapon = TRUE;
3931                 if (o_ptr->name2 == EGO_RING_RES_TIME) p_ptr->resist_time = TRUE;
3932                 if (o_ptr->name2 == EGO_RING_THROW) p_ptr->mighty_throw = TRUE;
3933                 if (o_ptr->name2 == EGO_RING_WIZARD) p_ptr->easy_spell = TRUE;
3934                 if (o_ptr->name2 == EGO_AMU_FOOL) p_ptr->heavy_spell = TRUE;
3935                 if (o_ptr->name2 == EGO_AMU_NAIVETY) down_saving = TRUE;
3936
3937                 if (o_ptr->curse_flags & TRC_LOW_MAGIC)
3938                 {
3939                         if (o_ptr->curse_flags & TRC_HEAVY_CURSE)
3940                         {
3941                                 p_ptr->to_m_chance += 10;
3942                         }
3943                         else
3944                         {
3945                                 p_ptr->to_m_chance += 3;
3946                         }
3947                 }
3948
3949                 if (o_ptr->tval == TV_CAPTURE) continue;
3950
3951                 /* Modify the base armor class */
3952                 p_ptr->ac += o_ptr->ac;
3953
3954                 /* The base armor class is always known */
3955                 p_ptr->dis_ac += o_ptr->ac;
3956
3957                 /* Apply the bonuses to armor class */
3958                 p_ptr->to_a += o_ptr->to_a;
3959
3960                 /* Apply the mental bonuses to armor class, if known */
3961                 if (object_known_p(o_ptr)) p_ptr->dis_to_a += o_ptr->to_a;
3962
3963                 if (o_ptr->curse_flags & TRC_LOW_MELEE)
3964                 {
3965                         int slot = i - INVEN_RARM;
3966                         if (slot < 2)
3967                         {
3968                                 if (o_ptr->curse_flags & TRC_HEAVY_CURSE)
3969                                 {
3970                                         p_ptr->to_h[slot] -= 15;
3971                                         if (o_ptr->ident & IDENT_MENTAL) p_ptr->dis_to_h[slot] -= 15;
3972                                 }
3973                                 else
3974                                 {
3975                                         p_ptr->to_h[slot] -= 5;
3976                                         if (o_ptr->ident & IDENT_MENTAL) p_ptr->dis_to_h[slot] -= 5;
3977                                 }
3978                         }
3979                         else
3980                         {
3981                                 if (o_ptr->curse_flags & TRC_HEAVY_CURSE)
3982                                 {
3983                                         p_ptr->to_h_b -= 15;
3984                                         if (o_ptr->ident & IDENT_MENTAL) p_ptr->dis_to_h_b -= 15;
3985                                 }
3986                                 else
3987                                 {
3988                                         p_ptr->to_h_b -= 5;
3989                                         if (o_ptr->ident & IDENT_MENTAL) p_ptr->dis_to_h_b -= 5;
3990                                 }
3991                         }
3992                 }
3993
3994                 if (o_ptr->curse_flags & TRC_LOW_AC)
3995                 {
3996                         if (o_ptr->curse_flags & TRC_HEAVY_CURSE)
3997                         {
3998                                 p_ptr->to_a -= 30;
3999                                 if (o_ptr->ident & IDENT_MENTAL) p_ptr->dis_to_a -= 30;
4000                         }
4001                         else
4002                         {
4003                                 p_ptr->to_a -= 10;
4004                                 if (o_ptr->ident & IDENT_MENTAL) p_ptr->dis_to_a -= 10;
4005                         }
4006                 }
4007
4008                 /* Hack -- do not apply "weapon" bonuses */
4009                 if (i == INVEN_RARM && buki_motteruka(i)) continue;
4010                 if (i == INVEN_LARM && buki_motteruka(i)) continue;
4011
4012                 /* Hack -- do not apply "bow" bonuses */
4013                 if (i == INVEN_BOW) continue;
4014
4015                 bonus_to_h = o_ptr->to_h;
4016                 bonus_to_d = o_ptr->to_d;
4017
4018                 if (p_ptr->pclass == CLASS_NINJA)
4019                 {
4020                         if (o_ptr->to_h > 0) bonus_to_h = (o_ptr->to_h+1)/2;
4021                         if (o_ptr->to_d > 0) bonus_to_d = (o_ptr->to_d+1)/2;
4022                 }
4023
4024                 /* To Bow and Natural attack */
4025
4026                 /* Apply the bonuses to hit/damage */
4027                 p_ptr->to_h_b += bonus_to_h;
4028                 p_ptr->to_h_m += bonus_to_h;
4029                 p_ptr->to_d_m += bonus_to_d;
4030
4031                 /* Apply the mental bonuses tp hit/damage, if known */
4032                 if (object_known_p(o_ptr)) p_ptr->dis_to_h_b += bonus_to_h;
4033
4034                 /* To Melee */
4035                 if ((i == INVEN_LEFT || i == INVEN_RIGHT) && !p_ptr->ryoute)
4036                 {
4037                         /* Apply the bonuses to hit/damage */
4038                         p_ptr->to_h[i-INVEN_RIGHT] += bonus_to_h;
4039                         p_ptr->to_d[i-INVEN_RIGHT] += bonus_to_d;
4040
4041                         /* Apply the mental bonuses tp hit/damage, if known */
4042                         if (object_known_p(o_ptr))
4043                         {
4044                                 p_ptr->dis_to_h[i-INVEN_RIGHT] += bonus_to_h;
4045                                 p_ptr->dis_to_d[i-INVEN_RIGHT] += bonus_to_d;
4046                         }
4047                 }
4048                 else if (p_ptr->migite && p_ptr->hidarite)
4049                 {
4050                         /* Apply the bonuses to hit/damage */
4051                         p_ptr->to_h[0] += (bonus_to_h > 0) ? (bonus_to_h+1)/2 : bonus_to_h;
4052                         p_ptr->to_h[1] += (bonus_to_h > 0) ? bonus_to_h/2 : bonus_to_h;
4053                         p_ptr->to_d[0] += (bonus_to_d > 0) ? (bonus_to_d+1)/2 : bonus_to_d;
4054                         p_ptr->to_d[1] += (bonus_to_d > 0) ? bonus_to_d/2 : bonus_to_d;
4055
4056                         /* Apply the mental bonuses tp hit/damage, if known */
4057                         if (object_known_p(o_ptr))
4058                         {
4059                                 p_ptr->dis_to_h[0] += (bonus_to_h > 0) ? (bonus_to_h+1)/2 : bonus_to_h;
4060                                 p_ptr->dis_to_h[1] += (bonus_to_h > 0) ? bonus_to_h/2 : bonus_to_h;
4061                                 p_ptr->dis_to_d[0] += (bonus_to_d > 0) ? (bonus_to_d+1)/2 : bonus_to_d;
4062                                 p_ptr->dis_to_d[1] += (bonus_to_d > 0) ? bonus_to_d/2 : bonus_to_d;
4063                         }
4064                 }
4065                 else
4066                 {
4067                         /* Apply the bonuses to hit/damage */
4068                         p_ptr->to_h[0] += bonus_to_h;
4069                         p_ptr->to_d[0] += bonus_to_d;
4070
4071                         /* Apply the mental bonuses tp hit/damage, if known */
4072                         if (object_known_p(o_ptr))
4073                         {
4074                                 p_ptr->dis_to_h[0] += bonus_to_h;
4075                                 p_ptr->dis_to_d[0] += bonus_to_d;
4076                         }
4077                 }
4078         }
4079
4080         if (p_ptr->cursed & TRC_TELEPORT) p_ptr->cursed &= ~(TRC_TELEPORT_SELF);
4081
4082         /* Monks get extra ac for armour _not worn_ */
4083         if (((p_ptr->pclass == CLASS_MONK) || (p_ptr->pclass == CLASS_FORCETRAINER)) && !heavy_armor())
4084         {
4085                 if (!(inventory[INVEN_BODY].k_idx))
4086                 {
4087                         p_ptr->to_a += (p_ptr->lev * 3) / 2;
4088                         p_ptr->dis_to_a += (p_ptr->lev * 3) / 2;
4089                 }
4090                 if (!(inventory[INVEN_OUTER].k_idx) && (p_ptr->lev > 15))
4091                 {
4092                         p_ptr->to_a += ((p_ptr->lev - 13) / 3);
4093                         p_ptr->dis_to_a += ((p_ptr->lev - 13) / 3);
4094                 }
4095                 if (!(inventory[INVEN_LARM].k_idx) && (p_ptr->lev > 10))
4096                 {
4097                         p_ptr->to_a += ((p_ptr->lev - 8) / 3);
4098                         p_ptr->dis_to_a += ((p_ptr->lev - 8) / 3);
4099                 }
4100                 if (!(inventory[INVEN_HEAD].k_idx) && (p_ptr->lev > 4))
4101                 {
4102                         p_ptr->to_a += (p_ptr->lev - 2) / 3;
4103                         p_ptr->dis_to_a += (p_ptr->lev -2) / 3;
4104                 }
4105                 if (!(inventory[INVEN_HANDS].k_idx))
4106                 {
4107                         p_ptr->to_a += (p_ptr->lev / 2);
4108                         p_ptr->dis_to_a += (p_ptr->lev / 2);
4109                 }
4110                 if (!(inventory[INVEN_FEET].k_idx))
4111                 {
4112                         p_ptr->to_a += (p_ptr->lev / 3);
4113                         p_ptr->dis_to_a += (p_ptr->lev / 3);
4114                 }
4115                 if (p_ptr->special_defense & KAMAE_BYAKKO)
4116                 {
4117                         p_ptr->stat_add[A_STR] += 2;
4118                         p_ptr->stat_add[A_DEX] += 2;
4119                         p_ptr->stat_add[A_CON] -= 3;
4120                 }
4121                 else if (p_ptr->special_defense & KAMAE_SEIRYU)
4122                 {
4123                 }
4124                 else if (p_ptr->special_defense & KAMAE_GENBU)
4125                 {
4126                         p_ptr->stat_add[A_INT] -= 1;
4127                         p_ptr->stat_add[A_WIS] -= 1;
4128                         p_ptr->stat_add[A_DEX] -= 2;
4129                         p_ptr->stat_add[A_CON] += 3;
4130                 }
4131                 else if (p_ptr->special_defense & KAMAE_SUZAKU)
4132                 {
4133                         p_ptr->stat_add[A_STR] -= 2;
4134                         p_ptr->stat_add[A_INT] += 1;
4135                         p_ptr->stat_add[A_WIS] += 1;
4136                         p_ptr->stat_add[A_DEX] += 2;
4137                         p_ptr->stat_add[A_CON] -= 2;
4138                 }
4139         }
4140
4141         if (p_ptr->special_defense & KATA_KOUKIJIN)
4142         {
4143                 for (i = 0; i < 6; i++)
4144                         p_ptr->stat_add[i] += 5;
4145                 p_ptr->to_a -= 50;
4146                 p_ptr->dis_to_a -= 50;
4147         }
4148
4149         /* Hack -- aura of fire also provides light */
4150         if (p_ptr->sh_fire) p_ptr->lite = TRUE;
4151
4152         /* Golems also get an intrinsic AC bonus */
4153         if ((p_ptr->prace == RACE_GOLEM) || (p_ptr->prace == RACE_ANDROID))
4154         {
4155                 p_ptr->to_a += 10 + (p_ptr->lev * 2 / 5);
4156                 p_ptr->dis_to_a += 10 + (p_ptr->lev * 2 / 5);
4157         }
4158
4159         /* Calculate stats */
4160         for (i = 0; i < 6; i++)
4161         {
4162                 int top, use, ind;
4163
4164                 /* Extract the new "stat_use" value for the stat */
4165                 top = modify_stat_value(p_ptr->stat_max[i], p_ptr->stat_add[i]);
4166
4167                 /* Notice changes */
4168                 if (p_ptr->stat_top[i] != top)
4169                 {
4170                         /* Save the new value */
4171                         p_ptr->stat_top[i] = top;
4172
4173                         /* Redisplay the stats later */
4174                         p_ptr->redraw |= (PR_STATS);
4175
4176                         /* Window stuff */
4177                         p_ptr->window |= (PW_PLAYER);
4178                 }
4179
4180
4181                 /* Extract the new "stat_use" value for the stat */
4182                 use = modify_stat_value(p_ptr->stat_cur[i], p_ptr->stat_add[i]);
4183
4184                 if ((i == A_CHR) && (p_ptr->muta3 & MUT3_ILL_NORM))
4185                 {
4186                         /* 10 to 18/90 charisma, guaranteed, based on level */
4187                         if (use < 8 + 2 * p_ptr->lev)
4188                         {
4189                                 use = 8 + 2 * p_ptr->lev;
4190                         }
4191                 }
4192
4193                 /* Notice changes */
4194                 if (p_ptr->stat_use[i] != use)
4195                 {
4196                         /* Save the new value */
4197                         p_ptr->stat_use[i] = use;
4198
4199                         /* Redisplay the stats later */
4200                         p_ptr->redraw |= (PR_STATS);
4201
4202                         /* Window stuff */
4203                         p_ptr->window |= (PW_PLAYER);
4204                 }
4205
4206
4207                 /* Values: 3, 4, ..., 17 */
4208                 if (use <= 18) ind = (use - 3);
4209
4210                 /* Ranges: 18/00-18/09, ..., 18/210-18/219 */
4211                 else if (use <= 18+219) ind = (15 + (use - 18) / 10);
4212
4213                 /* Range: 18/220+ */
4214                 else ind = (37);
4215
4216                 /* Notice changes */
4217                 if (p_ptr->stat_ind[i] != ind)
4218                 {
4219                         /* Save the new index */
4220                         p_ptr->stat_ind[i] = ind;
4221
4222                         /* Change in CON affects Hitpoints */
4223                         if (i == A_CON)
4224                         {
4225                                 p_ptr->update |= (PU_HP);
4226                         }
4227
4228                         /* Change in INT may affect Mana/Spells */
4229                         else if (i == A_INT)
4230                         {
4231                                 if (mp_ptr->spell_stat == A_INT)
4232                                 {
4233                                         p_ptr->update |= (PU_MANA | PU_SPELLS);
4234                                 }
4235                         }
4236
4237                         /* Change in WIS may affect Mana/Spells */
4238                         else if (i == A_WIS)
4239                         {
4240                                 if (mp_ptr->spell_stat == A_WIS)
4241                                 {
4242                                         p_ptr->update |= (PU_MANA | PU_SPELLS);
4243                                 }
4244                         }
4245
4246                         /* Change in WIS may affect Mana/Spells */
4247                         else if (i == A_CHR)
4248                         {
4249                                 if (mp_ptr->spell_stat == A_CHR)
4250                                 {
4251                                         p_ptr->update |= (PU_MANA | PU_SPELLS);
4252                                 }
4253                         }
4254
4255                         /* Window stuff */
4256                         p_ptr->window |= (PW_PLAYER);
4257                 }
4258         }
4259
4260
4261         /* Apply temporary "stun" */
4262         if (p_ptr->stun > 50)
4263         {
4264                 p_ptr->to_h[0] -= 20;
4265                 p_ptr->to_h[1] -= 20;
4266                 p_ptr->to_h_b  -= 20;
4267                 p_ptr->to_h_m  -= 20;
4268                 p_ptr->dis_to_h[0] -= 20;
4269                 p_ptr->dis_to_h[1] -= 20;
4270                 p_ptr->dis_to_h_b  -= 20;
4271                 p_ptr->to_d[0] -= 20;
4272                 p_ptr->to_d[1] -= 20;
4273                 p_ptr->to_d_m -= 20;
4274                 p_ptr->dis_to_d[0] -= 20;
4275                 p_ptr->dis_to_d[1] -= 20;
4276         }
4277         else if (p_ptr->stun)
4278         {
4279                 p_ptr->to_h[0] -= 5;
4280                 p_ptr->to_h[1] -= 5;
4281                 p_ptr->to_h_b -= 5;
4282                 p_ptr->to_h_m -= 5;
4283                 p_ptr->dis_to_h[0] -= 5;
4284                 p_ptr->dis_to_h[1] -= 5;
4285                 p_ptr->dis_to_h_b -= 5;
4286                 p_ptr->to_d[0] -= 5;
4287                 p_ptr->to_d[1] -= 5;
4288                 p_ptr->to_d_m -= 5;
4289                 p_ptr->dis_to_d[0] -= 5;
4290                 p_ptr->dis_to_d[1] -= 5;
4291         }
4292
4293         /* wraith_form */
4294         if (p_ptr->wraith_form)
4295         {
4296                 p_ptr->reflect = TRUE;
4297         }
4298
4299         /* Temporary blessing */
4300         if (p_ptr->blessed || music_singing(MUSIC_BLESS))
4301         {
4302                 p_ptr->to_a += 5;
4303                 p_ptr->dis_to_a += 5;
4304                 p_ptr->to_h[0] += 10;
4305                 p_ptr->to_h[1] += 10;
4306                 p_ptr->to_h_b  += 10;
4307                 p_ptr->to_h_m  += 10;
4308                 p_ptr->dis_to_h[0] += 10;
4309                 p_ptr->dis_to_h[1] += 10;
4310                 p_ptr->dis_to_h_b += 10;
4311         }
4312
4313         if (p_ptr->magicdef)
4314         {
4315                 p_ptr->resist_blind = TRUE;
4316                 p_ptr->resist_conf = TRUE;
4317                 p_ptr->reflect = TRUE;
4318                 p_ptr->free_act = TRUE;
4319                 p_ptr->ffall = TRUE;
4320         }
4321
4322         /* Temporary "Hero" */
4323         if (p_ptr->hero || music_singing(MUSIC_HERO) || music_singing(MUSIC_SHERO))
4324         {
4325                 p_ptr->to_h[0] += 12;
4326                 p_ptr->to_h[1] += 12;
4327                 p_ptr->to_h_b  += 12;
4328                 p_ptr->to_h_m  += 12;
4329                 p_ptr->dis_to_h[0] += 12;
4330                 p_ptr->dis_to_h[1] += 12;
4331                 p_ptr->dis_to_h_b  += 12;
4332         }
4333
4334         /* Temporary "Beserk" */
4335         if (p_ptr->shero)
4336         {
4337                 p_ptr->to_h[0] += 12;
4338                 p_ptr->to_h[1] += 12;
4339                 p_ptr->to_h_b  -= 12;
4340                 p_ptr->to_h_m  += 12;
4341                 p_ptr->to_d[0] += 3+(p_ptr->lev/5);
4342                 p_ptr->to_d[1] += 3+(p_ptr->lev/5);
4343                 p_ptr->to_d_m  += 3+(p_ptr->lev/5);
4344                 p_ptr->dis_to_h[0] += 12;
4345                 p_ptr->dis_to_h[1] += 12;
4346                 p_ptr->dis_to_h_b  -= 12;
4347                 p_ptr->dis_to_d[0] += 3+(p_ptr->lev/5);
4348                 p_ptr->dis_to_d[1] += 3+(p_ptr->lev/5);
4349                 p_ptr->to_a -= 10;
4350                 p_ptr->dis_to_a -= 10;
4351                 p_ptr->skill_stl -= 7;
4352                 p_ptr->skill_dev -= 20;
4353                 p_ptr->skill_sav -= 30;
4354                 p_ptr->skill_srh -= 15;
4355                 p_ptr->skill_fos -= 15;
4356                 p_ptr->skill_tht -= 20;
4357                 p_ptr->skill_dig += 30;
4358         }
4359
4360 /* Temporary "fast" */
4361         if (p_ptr->fast || music_singing(MUSIC_SPEED) || music_singing(MUSIC_SHERO))
4362         {
4363                 p_ptr->pspeed += 10;
4364         }
4365
4366         /* Temporary "slow" */
4367         if (p_ptr->slow)
4368         {
4369                 p_ptr->pspeed -= 10;
4370         }
4371
4372         /* Temporary "telepathy" */
4373         if (p_ptr->tim_esp || music_singing(MUSIC_MIND))
4374         {
4375                 p_ptr->telepathy = TRUE;
4376         }
4377
4378         if (p_ptr->ele_immune)
4379         {
4380                 if (p_ptr->special_defense & DEFENSE_ACID)
4381                         p_ptr->immune_acid = TRUE;
4382                 else if (p_ptr->special_defense & DEFENSE_ELEC)
4383                         p_ptr->immune_elec = TRUE;
4384                 else if (p_ptr->special_defense & DEFENSE_FIRE)
4385                         p_ptr->immune_fire = TRUE;
4386                 else if (p_ptr->special_defense & DEFENSE_COLD)
4387                         p_ptr->immune_cold = TRUE;
4388         }
4389
4390         /* Temporary see invisible */
4391         if (p_ptr->tim_invis)
4392         {
4393                 p_ptr->see_inv = TRUE;
4394         }
4395
4396         /* Temporary infravision boost */
4397         if (p_ptr->tim_infra)
4398         {
4399                 p_ptr->see_infra+=3;
4400         }
4401
4402         /* Temporary regeneration boost */
4403         if (p_ptr->tim_regen)
4404         {
4405                 p_ptr->regenerate = TRUE;
4406         }
4407
4408         /* Temporary levitation */
4409         if (p_ptr->tim_ffall)
4410         {
4411                 p_ptr->ffall = TRUE;
4412         }
4413
4414         /* Hack -- Hero/Shero -> Res fear */
4415         if (p_ptr->hero || p_ptr->shero || music_singing(MUSIC_HERO) || music_singing(MUSIC_SHERO))
4416         {
4417                 p_ptr->resist_fear = TRUE;
4418         }
4419
4420
4421         /* Hack -- Telepathy Change */
4422         if (p_ptr->telepathy != old_telepathy)
4423         {
4424                 p_ptr->update |= (PU_MONSTERS);
4425         }
4426
4427         /* Hack -- See Invis Change */
4428         if (p_ptr->see_inv != old_see_inv)
4429         {
4430                 p_ptr->update |= (PU_MONSTERS);
4431         }
4432
4433         /* Bloating slows the player down (a little) */
4434         if (p_ptr->food >= PY_FOOD_MAX) p_ptr->pspeed -= 10;
4435
4436         if (p_ptr->special_defense & KAMAE_SUZAKU) p_ptr->pspeed += 10;
4437
4438         if (!buki_motteruka(INVEN_RARM) && !buki_motteruka(INVEN_LARM))
4439         {
4440                 p_ptr->to_h[0] += (skill_exp[GINOU_SUDE]-4000)/200;
4441                 p_ptr->dis_to_h[0] += (skill_exp[GINOU_SUDE]-4000)/200;
4442         }
4443
4444         if (buki_motteruka(INVEN_RARM) && buki_motteruka(INVEN_LARM))
4445         {
4446                 int penalty1, penalty2;
4447                 penalty1 = ((100-skill_exp[GINOU_NITOURYU]/160) - (130-inventory[INVEN_RARM].weight)/8);
4448                 penalty2 = ((100-skill_exp[GINOU_NITOURYU]/160) - (130-inventory[INVEN_LARM].weight)/8);
4449                 if ((inventory[INVEN_RARM].name1 == ART_QUICKTHORN) && (inventory[INVEN_LARM].name1 == ART_TINYTHORN))
4450                 {
4451                         penalty1 = penalty1 / 2 - 5;
4452                         penalty2 = penalty2 / 2 - 5;
4453                         p_ptr->pspeed += 7;
4454                         p_ptr->to_a += 10;
4455                         p_ptr->dis_to_a += 10;
4456                 }
4457                 if (easy_2weapon)
4458                 {
4459                         if (penalty1 > 0) penalty1 /= 2;
4460                         if (penalty2 > 0) penalty2 /= 2;
4461                 }
4462                 else if ((inventory[INVEN_LARM].tval == TV_SWORD) && ((inventory[INVEN_LARM].sval == SV_MAIN_GAUCHE) || (inventory[INVEN_LARM].sval == SV_WAKIZASHI)))
4463                 {
4464                         penalty1 = MAX(0, penalty1 - 10);
4465                         penalty2 = MAX(0, penalty2 - 10);
4466                 }
4467                 if ((inventory[INVEN_RARM].name1 == ART_MUSASI_KATANA) && (inventory[INVEN_LARM].name1 == ART_MUSASI_WAKIZASI))
4468                 {
4469                         penalty1 = MIN(0, penalty1);
4470                         penalty2 = MIN(0, penalty2);
4471                         p_ptr->to_a += 10;
4472                         p_ptr->dis_to_a += 10;
4473                 }
4474                 else
4475                 {
4476                         if ((inventory[INVEN_RARM].name1 == ART_MUSASI_KATANA) && (penalty1 > 0))
4477                                 penalty1 /= 2;
4478                         if ((inventory[INVEN_LARM].name1 == ART_MUSASI_WAKIZASI) && (penalty2 > 0))
4479                                 penalty2 /= 2;
4480                 }
4481                 if (inventory[INVEN_RARM].tval == TV_POLEARM) penalty1 += 10;
4482                 if (inventory[INVEN_LARM].tval == TV_POLEARM) penalty2 += 10;
4483                 p_ptr->to_h[0] -= penalty1;
4484                 p_ptr->to_h[1] -= penalty2;
4485                 p_ptr->dis_to_h[0] -= penalty1;
4486                 p_ptr->dis_to_h[1] -= penalty2;
4487         }
4488
4489         /* Extract the current weight (in tenth pounds) */
4490         j = p_ptr->total_weight;
4491
4492         /* Extract the "weight limit" (in tenth pounds) */
4493         i = weight_limit();
4494
4495         if (p_ptr->riding)
4496         {
4497                 int speed = m_list[p_ptr->riding].mspeed;
4498                 if (m_list[p_ptr->riding].mspeed > 110)
4499                 {
4500                         p_ptr->pspeed = 110 + (s16b)((speed-110)*(skill_exp[GINOU_RIDING]*3 + p_ptr->lev*160L - 10000L)/(22000L));
4501                         if (p_ptr->pspeed < 110) p_ptr->pspeed = 110;
4502                 }
4503                 else
4504                 {
4505                         p_ptr->pspeed = speed;
4506                 }
4507                 if (m_list[p_ptr->riding].fast) p_ptr->pspeed += 10;
4508                 if (m_list[p_ptr->riding].slow) p_ptr->pspeed -= 10;
4509                 if (r_info[m_list[p_ptr->riding].r_idx].flags7 & RF7_CAN_FLY) p_ptr->ffall = TRUE;
4510                 if (r_info[m_list[p_ptr->riding].r_idx].flags7 & (RF7_CAN_SWIM | RF7_AQUATIC)) p_ptr->can_swim = TRUE;
4511
4512                 if (skill_exp[GINOU_RIDING] < 2000) j += (p_ptr->wt*3*(2000 - skill_exp[GINOU_RIDING]))/2000;
4513
4514                 i = 3000 + r_info[m_list[p_ptr->riding].r_idx].level * 50;
4515         }
4516
4517         /* XXX XXX XXX Apply "encumbrance" from weight */
4518         if (j > i/2) p_ptr->pspeed -= ((j - (i/2)) / (i / 10));
4519
4520         /* Searching slows the player down */
4521         if (p_ptr->action == ACTION_SEARCH) p_ptr->pspeed -= 10;
4522
4523         /* Actual Modifier Bonuses (Un-inflate stat bonuses) */
4524         p_ptr->to_a += ((int)(adj_dex_ta[p_ptr->stat_ind[A_DEX]]) - 128);
4525         p_ptr->to_d[0] += ((int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
4526         p_ptr->to_d[1] += ((int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
4527         p_ptr->to_d_m  += ((int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
4528         p_ptr->to_h[0] += ((int)(adj_dex_th[p_ptr->stat_ind[A_DEX]]) - 128);
4529         p_ptr->to_h[1] += ((int)(adj_dex_th[p_ptr->stat_ind[A_DEX]]) - 128);
4530         p_ptr->to_h_b  += ((int)(adj_dex_th[p_ptr->stat_ind[A_DEX]]) - 128);
4531         p_ptr->to_h_m  += ((int)(adj_dex_th[p_ptr->stat_ind[A_DEX]]) - 128);
4532         p_ptr->to_h[0] += ((int)(adj_str_th[p_ptr->stat_ind[A_STR]]) - 128);
4533         p_ptr->to_h[1] += ((int)(adj_str_th[p_ptr->stat_ind[A_STR]]) - 128);
4534         p_ptr->to_h_b  += ((int)(adj_str_th[p_ptr->stat_ind[A_STR]]) - 128);
4535         p_ptr->to_h_m  += ((int)(adj_str_th[p_ptr->stat_ind[A_STR]]) - 128);
4536
4537         /* Displayed Modifier Bonuses (Un-inflate stat bonuses) */
4538         p_ptr->dis_to_a += ((int)(adj_dex_ta[p_ptr->stat_ind[A_DEX]]) - 128);
4539         p_ptr->dis_to_d[0] += ((int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
4540         p_ptr->dis_to_d[1] += ((int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
4541         p_ptr->dis_to_h[0] += ((int)(adj_dex_th[p_ptr->stat_ind[A_DEX]]) - 128);
4542         p_ptr->dis_to_h[1] += ((int)(adj_dex_th[p_ptr->stat_ind[A_DEX]]) - 128);
4543         p_ptr->dis_to_h_b  += ((int)(adj_dex_th[p_ptr->stat_ind[A_DEX]]) - 128);
4544         p_ptr->dis_to_h[0] += ((int)(adj_str_th[p_ptr->stat_ind[A_STR]]) - 128);
4545         p_ptr->dis_to_h[1] += ((int)(adj_str_th[p_ptr->stat_ind[A_STR]]) - 128);
4546         p_ptr->dis_to_h_b  += ((int)(adj_str_th[p_ptr->stat_ind[A_STR]]) - 128);
4547
4548
4549         /* Obtain the "hold" value */
4550         hold = adj_str_hold[p_ptr->stat_ind[A_STR]];
4551
4552
4553         /* Examine the "current bow" */
4554         o_ptr = &inventory[INVEN_BOW];
4555
4556
4557         /* Assume not heavy */
4558         p_ptr->heavy_shoot = FALSE;
4559
4560         /* It is hard to carholdry a heavy bow */
4561         if (hold < o_ptr->weight / 10)
4562         {
4563                 /* Hard to wield a heavy bow */
4564                 p_ptr->to_h_b  += 2 * (hold - o_ptr->weight / 10);
4565                 p_ptr->dis_to_h_b  += 2 * (hold - o_ptr->weight / 10);
4566
4567                 /* Heavy Bow */
4568                 p_ptr->heavy_shoot = TRUE;
4569         }
4570
4571
4572         /* Compute "extra shots" if needed */
4573         if (o_ptr->k_idx)
4574         {
4575                 /* Analyze the launcher */
4576                 switch (o_ptr->sval)
4577                 {
4578                         case SV_SLING:
4579                         {
4580                                 p_ptr->tval_ammo = TV_SHOT;
4581                                 break;
4582                         }
4583
4584                         case SV_SHORT_BOW:
4585                         case SV_LONG_BOW:
4586                         case SV_NAMAKE_BOW:
4587                         {
4588                                 p_ptr->tval_ammo = TV_ARROW;
4589                                 break;
4590                         }
4591
4592                         case SV_LIGHT_XBOW:
4593                         case SV_HEAVY_XBOW:
4594                         {
4595                                 p_ptr->tval_ammo = TV_BOLT;
4596                                 break;
4597                         }
4598                         case SV_CRIMSON:
4599                         {
4600                                 p_ptr->tval_ammo = TV_NO_AMMO;
4601                                 break;
4602                         }
4603                 }
4604
4605                 /* Apply special flags */
4606                 if (o_ptr->k_idx && !p_ptr->heavy_shoot)
4607                 {
4608                         /* Extra shots */
4609                         p_ptr->num_fire += (extra_shots * 100);
4610
4611                         /* Hack -- Rangers love Bows */
4612                         if ((p_ptr->pclass == CLASS_RANGER) &&
4613                             (p_ptr->tval_ammo == TV_ARROW))
4614                         {
4615                                 p_ptr->num_fire += (p_ptr->lev * 4);
4616                         }
4617
4618                         if ((p_ptr->pclass == CLASS_CAVALRY) &&
4619                             (p_ptr->tval_ammo == TV_ARROW))
4620                         {
4621                                 p_ptr->num_fire += (p_ptr->lev * 3);
4622                         }
4623
4624                         if (p_ptr->pclass == CLASS_ARCHER)
4625                         {
4626                                 if (p_ptr->tval_ammo == TV_ARROW)
4627                                         p_ptr->num_fire += ((p_ptr->lev * 5)+50);
4628                                 else if ((p_ptr->tval_ammo == TV_BOLT) || (p_ptr->tval_ammo == TV_SHOT))
4629                                         p_ptr->num_fire += (p_ptr->lev * 4);
4630                         }
4631
4632                         /*
4633                          * Addendum -- also "Reward" high level warriors,
4634                          * with _any_ missile weapon -- TY
4635                          */
4636                         if (p_ptr->pclass == CLASS_WARRIOR &&
4637                            (p_ptr->tval_ammo <= TV_BOLT) &&
4638                            (p_ptr->tval_ammo >= TV_SHOT))
4639                         {
4640                                 p_ptr->num_fire += (p_ptr->lev * 2);
4641                         }
4642                         if ((p_ptr->pclass == CLASS_ROGUE) &&
4643                             (p_ptr->tval_ammo == TV_SHOT))
4644                         {
4645                                 p_ptr->num_fire += (p_ptr->lev * 4);
4646                         }
4647                 }
4648         }
4649
4650         if (p_ptr->ryoute)
4651                 hold *= 2;
4652
4653         for(i = 0 ; i < 2 ; i++)
4654         {
4655                 /* Examine the "main weapon" */
4656                 o_ptr = &inventory[INVEN_RARM+i];
4657
4658                 object_flags(o_ptr, &f1, &f2, &f3);
4659
4660                 /* Assume not heavy */
4661                 p_ptr->heavy_wield[i] = FALSE;
4662                 p_ptr->icky_wield[i] = FALSE;
4663                 p_ptr->riding_wield[i] = FALSE;
4664
4665                 if (!buki_motteruka(INVEN_RARM+i)) {p_ptr->num_blow[i]=1;continue;}
4666                 /* It is hard to hold a heavy weapon */
4667                 if (hold < o_ptr->weight / 10)
4668                 {
4669                         /* Hard to wield a heavy weapon */
4670                         p_ptr->to_h[i] += 2 * (hold - o_ptr->weight / 10);
4671                         p_ptr->dis_to_h[i] += 2 * (hold - o_ptr->weight / 10);
4672
4673                         /* Heavy weapon */
4674                         p_ptr->heavy_wield[i] = TRUE;
4675                 }
4676                 else if (p_ptr->ryoute && (hold < o_ptr->weight/5)) omoi = TRUE;
4677
4678                 if ((i == 1) && (o_ptr->tval == TV_SWORD) && ((o_ptr->sval == SV_MAIN_GAUCHE) || (o_ptr->sval == SV_WAKIZASHI)))
4679                 {
4680                         p_ptr->to_a += 5;
4681                         p_ptr->dis_to_a += 5;
4682                 }
4683
4684                 /* Normal weapons */
4685                 if (o_ptr->k_idx && !p_ptr->heavy_wield[i])
4686                 {
4687                         int str_index, dex_index;
4688
4689                         int num = 0, wgt = 0, mul = 0, div = 0;
4690
4691                         /* Analyze the class */
4692                         switch (p_ptr->pclass)
4693                         {
4694                                 /* Warrior */
4695                                 case CLASS_WARRIOR:
4696                                         num = 6; wgt = 70; mul = 5; break;
4697
4698                                 /* Berserker */
4699                                 case CLASS_BERSERKER:
4700                                         num = 6; wgt = 70; mul = 7; break;
4701
4702                                 /* Mage */
4703                                 case CLASS_MAGE:
4704                                 case CLASS_HIGH_MAGE:
4705                                 case CLASS_BLUE_MAGE:
4706                                         num = 3; wgt = 100; mul = 2; break;
4707
4708                                 /* Priest, Mindcrafter */
4709                                 case CLASS_PRIEST:
4710                                 case CLASS_MAGIC_EATER:
4711                                 case CLASS_MINDCRAFTER:
4712                                         num = 5; wgt = 100; mul = 3; break;
4713
4714                                 /* Rogue */
4715                                 case CLASS_ROGUE:
4716                                         num = 5; wgt = 40; mul = 3; break;
4717
4718                                 /* Ranger */
4719                                 case CLASS_RANGER:
4720                                         num = 5; wgt = 70; mul = 4; break;
4721
4722                                 /* Paladin */
4723                                 case CLASS_PALADIN:
4724                                 case CLASS_SAMURAI:
4725                                         num = 5; wgt = 70; mul = 4; break;
4726
4727                                 /* Kaji */
4728                                 case CLASS_SMITH:
4729                                         num = 5; wgt = 150; mul = 5; break;
4730
4731                                 /* Warrior-Mage */
4732                                 case CLASS_WARRIOR_MAGE:
4733                                 case CLASS_RED_MAGE:
4734                                         num = 5; wgt = 70; mul = 3; break;
4735
4736                                 /* Chaos Warrior */
4737                                 case CLASS_CHAOS_WARRIOR:
4738                                         num = 5; wgt = 70; mul = 4; break;
4739
4740                                 /* Monk */
4741                                 case CLASS_MONK:
4742                                         num = 5; wgt = 60; mul = 3; break;
4743
4744                                 /* Tourist */
4745                                 case CLASS_TOURIST:
4746                                         num = 4; wgt = 100; mul = 3; break;
4747
4748                                 /* Imitator */
4749                                 case CLASS_IMITATOR:
4750                                         num = 5; wgt = 70; mul = 4; break;
4751
4752                                 /* Beastmaster */
4753                                 case CLASS_BEASTMASTER:
4754                                         num = 5; wgt = 70; mul = 3; break;
4755
4756                                 case CLASS_CAVALRY:
4757                                         if ((p_ptr->riding) && (f2 & TR2_RIDING)) {num = 5; wgt = 70; mul = 4;}
4758                                         else {num = 5; wgt = 100; mul = 3;}
4759                                         break;
4760
4761                                 /* Sorcerer */
4762                                 case CLASS_SORCERER:
4763                                         num = 1; wgt = 1; mul = 1; break;
4764
4765                                 /* Archer, Magic eater */
4766                                 case CLASS_ARCHER:
4767                                 case CLASS_BARD:
4768                                         num = 4; wgt = 70; mul = 2; break;
4769
4770                                 /* ForceTrainer */
4771                                 case CLASS_FORCETRAINER:
4772                                         num = 4; wgt = 60; mul = 2; break;
4773
4774                                 /* Mirror Master */
4775                                 case CLASS_MIRROR_MASTER:
4776                                         num = 3; wgt = 100; mul = 3; break;
4777
4778                                 /* Ninja */
4779                                 case CLASS_NINJA:
4780                                         num = 4; wgt = 20; mul = 1; break;
4781                         }
4782
4783                         /* Enforce a minimum "weight" (tenth pounds) */
4784                         div = ((o_ptr->weight < wgt) ? wgt : o_ptr->weight);
4785
4786                         /* Access the strength vs weight */
4787                         str_index = (adj_str_blow[p_ptr->stat_ind[A_STR]] * mul / div);
4788
4789                         if (p_ptr->ryoute && !omoi) str_index++;
4790                         if (p_ptr->pclass == CLASS_NINJA) str_index = MAX(0, str_index-1);
4791
4792                         /* Maximal value */
4793                         if (str_index > 11) str_index = 11;
4794
4795                         /* Index by dexterity */
4796                         dex_index = (adj_dex_blow[p_ptr->stat_ind[A_DEX]]);
4797
4798                         /* Maximal value */
4799                         if (dex_index > 11) dex_index = 11;
4800
4801                         /* Use the blows table */
4802                         p_ptr->num_blow[i] = blows_table[str_index][dex_index];
4803
4804                         /* Maximal value */
4805                         if (p_ptr->num_blow[i] > num) p_ptr->num_blow[i] = num;
4806
4807                         /* Add in the "bonus blows" */
4808                         p_ptr->num_blow[i] += extra_blows[i];
4809
4810
4811                         if (p_ptr->pclass == CLASS_WARRIOR) p_ptr->num_blow[i] += (p_ptr->lev / 40);
4812                         else if (p_ptr->pclass == CLASS_BERSERKER)
4813                         {
4814                                 p_ptr->num_blow[i] += (p_ptr->lev / 23);
4815                         }
4816                         else if ((p_ptr->pclass == CLASS_ROGUE) && (o_ptr->weight < 50) && (p_ptr->stat_ind[A_DEX] >= 30)) p_ptr->num_blow[i] ++;
4817
4818                         if (p_ptr->special_defense & KATA_FUUJIN) p_ptr->num_blow[i] -= 1;
4819
4820                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DOKUBARI)) p_ptr->num_blow[i] = 1;
4821
4822
4823                         /* Require at least one blow */
4824                         if (p_ptr->num_blow[i] < 1) p_ptr->num_blow[i] = 1;
4825
4826                         /* Boost digging skill by weapon weight */
4827                         p_ptr->skill_dig += (o_ptr->weight / 10);
4828                 }
4829
4830                 /* Assume okay */
4831                 /* Priest weapon penalty for non-blessed edged weapons */
4832                 if ((p_ptr->pclass == CLASS_PRIEST) && (!(f3 & (TR3_BLESSED))) &&
4833                     ((o_ptr->tval == TV_SWORD) || (o_ptr->tval == TV_POLEARM)))
4834                 {
4835                         /* Reduce the real bonuses */
4836                         p_ptr->to_h[i] -= 2;
4837                         p_ptr->to_d[i] -= 2;
4838
4839                         /* Reduce the mental bonuses */
4840                         p_ptr->dis_to_h[i] -= 2;
4841                         p_ptr->dis_to_d[i] -= 2;
4842
4843                         /* Icky weapon */
4844                         p_ptr->icky_wield[i] = TRUE;
4845                 }
4846                 else if (p_ptr->pclass == CLASS_BERSERKER)
4847                 {
4848                         p_ptr->to_h[i] += p_ptr->lev/5;
4849                         p_ptr->to_d[i] += p_ptr->lev/6;
4850                         p_ptr->dis_to_h[i] += p_ptr->lev/5;
4851                         p_ptr->dis_to_d[i] += p_ptr->lev/6;
4852                         if (!p_ptr->hidarite || p_ptr->ryoute)
4853                         {
4854                                 p_ptr->to_h[i] += p_ptr->lev/5;
4855                                 p_ptr->to_d[i] += p_ptr->lev/6;
4856                                 p_ptr->dis_to_h[i] += p_ptr->lev/5;
4857                                 p_ptr->dis_to_d[i] += p_ptr->lev/6;
4858                         }
4859                 }
4860                 else if (p_ptr->pclass == CLASS_SORCERER)
4861                 {
4862                         if (!((o_ptr->tval == TV_HAFTED) && ((o_ptr->sval == SV_WIZSTAFF) || (o_ptr->sval == SV_NAMAKE_HAMMER))))
4863                         {
4864                                 /* Reduce the real bonuses */
4865                                 p_ptr->to_h[i] -= 200;
4866                                 p_ptr->to_d[i] -= 200;
4867
4868                                 /* Reduce the mental bonuses */
4869                                 p_ptr->dis_to_h[i] -= 200;
4870                                 p_ptr->dis_to_d[i] -= 200;
4871
4872                                 /* Icky weapon */
4873                                 p_ptr->icky_wield[i] = TRUE;
4874                         }
4875                         else
4876                         {
4877                                 /* Reduce the real bonuses */
4878                                 p_ptr->to_h[i] -= 30;
4879                                 p_ptr->to_d[i] -= 10;
4880
4881                                 /* Reduce the mental bonuses */
4882                                 p_ptr->dis_to_h[i] -= 30;
4883                                 p_ptr->dis_to_d[i] -= 10;
4884                         }
4885                 }
4886                 if (p_ptr->riding)
4887                 {
4888                         if ((o_ptr->tval == TV_POLEARM) && ((o_ptr->sval == SV_LANCE) || (o_ptr->sval == SV_HEAVY_LANCE)))
4889                         {
4890                                 p_ptr->to_h[i] +=15;
4891                                 p_ptr->dis_to_h[i] +=15;
4892                         }
4893                         else if (!(f2 & TR2_RIDING))
4894                         {
4895                                 int penalty;
4896                                 if ((p_ptr->pclass == CLASS_BEASTMASTER) || (p_ptr->pclass == CLASS_CAVALRY))
4897                                 {
4898                                         penalty = 5;
4899                                 }
4900                                 else
4901                                 {
4902                                         penalty = r_info[m_list[p_ptr->riding].r_idx].level - skill_exp[GINOU_RIDING] / 80;
4903                                         penalty += 30;
4904                                         if (penalty < 30) penalty = 30;
4905                                 }
4906                                 p_ptr->to_h[i] -= penalty;
4907                                 p_ptr->dis_to_h[i] -= penalty;
4908
4909                                 /* Riding weapon */
4910                                 p_ptr->riding_wield[i] = TRUE;
4911                         }
4912                 }
4913         }
4914
4915         if (p_ptr->riding)
4916         {
4917                 int penalty = 0;
4918
4919                 p_ptr->riding_ryoute = FALSE;
4920                 if (p_ptr->ryoute || !empty_hands(FALSE)) p_ptr->riding_ryoute = TRUE;
4921
4922                 if ((p_ptr->pclass == CLASS_BEASTMASTER) || (p_ptr->pclass == CLASS_CAVALRY))
4923                 {
4924                         if (p_ptr->tval_ammo != TV_ARROW) penalty = 5;
4925                 }
4926                 else
4927                 {
4928                         penalty = r_info[m_list[p_ptr->riding].r_idx].level - skill_exp[GINOU_RIDING] / 80;
4929                         penalty += 30;
4930                         if (penalty < 30) penalty = 30;
4931                 }
4932                 if (p_ptr->tval_ammo == TV_BOLT) penalty *= 2;
4933                 p_ptr->to_h_b -= penalty;
4934                 p_ptr->dis_to_h_b -= penalty;
4935         }
4936
4937         /* Different calculation for monks with empty hands */
4938         if (((p_ptr->pclass == CLASS_MONK) || (p_ptr->pclass == CLASS_FORCETRAINER) || (p_ptr->pclass == CLASS_BERSERKER)) && (empty_hands(TRUE) > 1))
4939         {
4940                 int blow_base = p_ptr->lev + adj_dex_blow[p_ptr->stat_ind[A_DEX]];
4941                 p_ptr->num_blow[0] = 0;
4942
4943                 if (p_ptr->pclass == CLASS_FORCETRAINER)
4944                 {
4945                         if (blow_base > 18) p_ptr->num_blow[0]++;
4946                         if (blow_base > 31) p_ptr->num_blow[0]++;
4947                         if (blow_base > 44) p_ptr->num_blow[0]++;
4948                         if (blow_base > 58) p_ptr->num_blow[0]++;
4949                         if (p_ptr->magic_num1[0])
4950                         {
4951                                 p_ptr->to_d[0] += (p_ptr->magic_num1[0]/5);
4952                                 p_ptr->dis_to_d[0] += (p_ptr->magic_num1[0]/5);
4953                         }
4954                 }
4955                 else
4956                 {
4957                         if (blow_base > 12) p_ptr->num_blow[0]++;
4958                         if (blow_base > 22) p_ptr->num_blow[0]++;
4959                         if (blow_base > 31) p_ptr->num_blow[0]++;
4960                         if (blow_base > 39) p_ptr->num_blow[0]++;
4961                         if (blow_base > 46) p_ptr->num_blow[0]++;
4962                         if (blow_base > 53) p_ptr->num_blow[0]++;
4963                         if (blow_base > 59) p_ptr->num_blow[0]++;
4964                 }
4965
4966                 if (heavy_armor() && (p_ptr->pclass != CLASS_BERSERKER))
4967                         p_ptr->num_blow[0] /= 2;
4968                 else
4969                 {
4970                         p_ptr->to_h[0] += (p_ptr->lev / 3);
4971                         p_ptr->dis_to_h[0] += (p_ptr->lev / 3);
4972
4973                         p_ptr->to_d[0] += (p_ptr->lev / 6);
4974                         p_ptr->dis_to_d[0] += (p_ptr->lev / 6);
4975                 }
4976
4977                 if (p_ptr->special_defense & KAMAE_BYAKKO)
4978                 {
4979                         p_ptr->to_a -= 40;
4980                         p_ptr->dis_to_a -= 40;
4981
4982                 }
4983                 else if (p_ptr->special_defense & KAMAE_SEIRYU)
4984                 {
4985                         p_ptr->to_a -= 50;
4986                         p_ptr->dis_to_a -= 50;
4987                         p_ptr->resist_acid = TRUE;
4988                         p_ptr->resist_fire = TRUE;
4989                         p_ptr->resist_elec = TRUE;
4990                         p_ptr->resist_cold = TRUE;
4991                         p_ptr->resist_pois = TRUE;
4992                         p_ptr->sh_fire = TRUE;
4993                         p_ptr->sh_elec = TRUE;
4994                         p_ptr->sh_cold = TRUE;
4995                         p_ptr->ffall = TRUE;
4996                 }
4997                 else if (p_ptr->special_defense & KAMAE_GENBU)
4998                 {
4999                         p_ptr->to_a += (p_ptr->lev*p_ptr->lev)/50;
5000                         p_ptr->dis_to_a += (p_ptr->lev*p_ptr->lev)/50;
5001                         p_ptr->reflect = TRUE;
5002                         p_ptr->num_blow[0] -= 2;
5003                         if ((p_ptr->pclass == CLASS_MONK) && (p_ptr->lev > 42)) p_ptr->num_blow[0]--;
5004                         if (p_ptr->num_blow[0] < 0) p_ptr->num_blow[0] = 0;
5005                 }
5006                 else if (p_ptr->special_defense & KAMAE_SUZAKU)
5007                 {
5008                         p_ptr->to_h[0] -= (p_ptr->lev / 3);
5009                         p_ptr->to_d[0] -= (p_ptr->lev / 6);
5010
5011                         p_ptr->dis_to_h[0] -= (p_ptr->lev / 3);
5012                         p_ptr->dis_to_d[0] -= (p_ptr->lev / 6);
5013                         p_ptr->num_blow[0] /= 2;
5014                         p_ptr->ffall = TRUE;
5015                 }
5016
5017                 p_ptr->num_blow[0] += 1+extra_blows[0];
5018         }
5019
5020         monk_armour_aux = FALSE;
5021
5022         if (heavy_armor())
5023         {
5024                 monk_armour_aux = TRUE;
5025         }
5026
5027         for (i = 0 ; i < 2 ; i++)
5028         {
5029                 if(buki_motteruka(INVEN_RARM+i))
5030                 {
5031                         int tval = inventory[INVEN_RARM+i].tval - TV_BOW;
5032                         int sval = inventory[INVEN_RARM+i].sval;
5033
5034                         p_ptr->to_h[i] += (weapon_exp[tval][sval]-4000)/200;
5035                         p_ptr->dis_to_h[i] += (weapon_exp[tval][sval]-4000)/200;
5036                         if ((p_ptr->pclass == CLASS_MONK) && !(s_info[CLASS_MONK].w_max[tval][sval]))
5037                         {
5038                                 p_ptr->to_h[i] -= 40;
5039                                 p_ptr->dis_to_h[i] -= 40;
5040                                 p_ptr->icky_wield[i] = TRUE;
5041                         }
5042                         else if ((p_ptr->pclass == CLASS_FORCETRAINER) && !(s_info[CLASS_FORCETRAINER].w_max[tval][sval]))
5043                         {
5044                                 p_ptr->to_h[i] -= 40;
5045                                 p_ptr->dis_to_h[i] -= 40;
5046                                 p_ptr->icky_wield[i] = TRUE;
5047                         }
5048                         else if (p_ptr->pclass == CLASS_NINJA)
5049                         {
5050                                 if ((s_info[CLASS_NINJA].w_max[tval][sval] <= 4000) || (inventory[INVEN_LARM-i].tval == TV_SHIELD))
5051                                 {
5052                                         p_ptr->to_h[i] -= 40;
5053                                         p_ptr->dis_to_h[i] -= 40;
5054                                         p_ptr->icky_wield[i] = TRUE;
5055                                         p_ptr->num_blow[i] /= 2;
5056                                         if (p_ptr->num_blow[i] < 1) p_ptr->num_blow[i] = 1;
5057                                 }
5058                         }
5059                 }
5060         }
5061
5062         /* Temporary lightspeed */
5063         if ((p_ptr->lightspeed && !p_ptr->riding) || (p_ptr->pspeed > 209))
5064         {
5065                 p_ptr->pspeed = 209;
5066         }
5067         if (p_ptr->pspeed < 11) p_ptr->pspeed = 11;
5068
5069         /* Display the speed (if needed) */
5070         if (p_ptr->pspeed != old_speed) p_ptr->redraw |= (PR_SPEED);
5071
5072         if (yoiyami)
5073         {
5074                 if (p_ptr->to_a > (0 - p_ptr->ac))
5075                         p_ptr->to_a = 0 - p_ptr->ac;
5076                 if (p_ptr->dis_to_a > (0 - p_ptr->dis_ac))
5077                         p_ptr->dis_to_a = 0 - p_ptr->dis_ac;
5078         }
5079
5080         /* Redraw armor (if needed) */
5081         if ((p_ptr->dis_ac != old_dis_ac) || (p_ptr->dis_to_a != old_dis_to_a))
5082         {
5083                 /* Redraw */
5084                 p_ptr->redraw |= (PR_ARMOR);
5085
5086                 /* Window stuff */
5087                 p_ptr->window |= (PW_PLAYER);
5088         }
5089
5090
5091         if (p_ptr->ryoute && !omoi)
5092         {
5093                 int bonus_to_h=0, bonus_to_d=0;
5094                 bonus_to_d = ((int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128)/2;
5095                 bonus_to_h = ((int)(adj_str_th[p_ptr->stat_ind[A_STR]]) - 128) + ((int)(adj_dex_th[p_ptr->stat_ind[A_DEX]]) - 128);
5096
5097                 p_ptr->to_h[0] += MAX(bonus_to_h,1);
5098                 p_ptr->dis_to_h[0] += MAX(bonus_to_h,1);
5099                 p_ptr->to_d[0] += MAX(bonus_to_d,1);
5100                 p_ptr->dis_to_d[0] += MAX(bonus_to_d,1);
5101         }
5102
5103         if (((p_ptr->pclass == CLASS_MONK) || (p_ptr->pclass == CLASS_FORCETRAINER) || (p_ptr->pclass == CLASS_BERSERKER)) && (empty_hands(TRUE) == 3)) p_ptr->ryoute = FALSE;
5104
5105         /* Affect Skill -- stealth (bonus one) */
5106         p_ptr->skill_stl += 1;
5107
5108         if (p_ptr->tim_stealth || music_singing(MUSIC_STEALTH))
5109                 p_ptr->skill_stl += 99;
5110
5111         /* Affect Skill -- disarming (DEX and INT) */
5112         p_ptr->skill_dis += adj_dex_dis[p_ptr->stat_ind[A_DEX]];
5113         p_ptr->skill_dis += adj_int_dis[p_ptr->stat_ind[A_INT]];
5114
5115         /* Affect Skill -- magic devices (INT) */
5116         p_ptr->skill_dev += adj_int_dev[p_ptr->stat_ind[A_INT]];
5117
5118         /* Affect Skill -- saving throw (WIS) */
5119         p_ptr->skill_sav += adj_wis_sav[p_ptr->stat_ind[A_WIS]];
5120
5121         /* Affect Skill -- digging (STR) */
5122         p_ptr->skill_dig += adj_str_dig[p_ptr->stat_ind[A_STR]];
5123
5124         /* Affect Skill -- disarming (Level, by Class) */
5125         p_ptr->skill_dis += ((cp_ptr->x_dis * p_ptr->lev / 10) + (ap_ptr->a_dis * p_ptr->lev / 50));
5126
5127         /* Affect Skill -- magic devices (Level, by Class) */
5128         p_ptr->skill_dev += ((cp_ptr->x_dev * p_ptr->lev / 10) + (ap_ptr->a_dev * p_ptr->lev / 50));
5129
5130         /* Affect Skill -- saving throw (Level, by Class) */
5131         p_ptr->skill_sav += ((cp_ptr->x_sav * p_ptr->lev / 10) + (ap_ptr->a_sav * p_ptr->lev / 50));
5132
5133         /* Affect Skill -- stealth (Level, by Class) */
5134         p_ptr->skill_stl += (cp_ptr->x_stl * p_ptr->lev / 10);
5135
5136         /* Affect Skill -- search ability (Level, by Class) */
5137         p_ptr->skill_srh += (cp_ptr->x_srh * p_ptr->lev / 10);
5138
5139         /* Affect Skill -- search frequency (Level, by Class) */
5140         p_ptr->skill_fos += (cp_ptr->x_fos * p_ptr->lev / 10);
5141
5142         /* Affect Skill -- combat (normal) (Level, by Class) */
5143         p_ptr->skill_thn += ((cp_ptr->x_thn * p_ptr->lev / 10) + (ap_ptr->a_thn * p_ptr->lev / 50));
5144
5145         /* Affect Skill -- combat (shooting) (Level, by Class) */
5146         p_ptr->skill_thb += ((cp_ptr->x_thb * p_ptr->lev / 10) + (ap_ptr->a_thb * p_ptr->lev / 50));
5147
5148         /* Affect Skill -- combat (throwing) (Level, by Class) */
5149         p_ptr->skill_tht += ((cp_ptr->x_thb * p_ptr->lev / 10) + (ap_ptr->a_thb * p_ptr->lev / 50));
5150
5151
5152         if ((prace_is_(RACE_S_FAIRY)) && (p_ptr->pseikaku != SEIKAKU_SEXY) && (p_ptr->cursed & TRC_AGGRAVATE))
5153         {
5154                 p_ptr->cursed &= ~(TRC_AGGRAVATE);
5155                 p_ptr->skill_stl = MIN(p_ptr->skill_stl - 3, (p_ptr->skill_stl + 2) / 2);
5156         }
5157
5158         /* Limit Skill -- stealth from 0 to 30 */
5159         if (p_ptr->skill_stl > 30) p_ptr->skill_stl = 30;
5160         if (p_ptr->skill_stl < 0) p_ptr->skill_stl = 0;
5161
5162         /* Limit Skill -- digging from 1 up */
5163         if (p_ptr->skill_dig < 1) p_ptr->skill_dig = 1;
5164
5165         if (p_ptr->anti_magic && (p_ptr->skill_sav < (90 + p_ptr->lev))) p_ptr->skill_sav = 90 + p_ptr->lev;
5166
5167         if (p_ptr->tsubureru) p_ptr->skill_sav = 10;
5168
5169         if ((p_ptr->ult_res || p_ptr->resist_magic || p_ptr->magicdef) && (p_ptr->skill_sav < (95 + p_ptr->lev))) p_ptr->skill_sav = 95 + p_ptr->lev;
5170
5171         if (down_saving) p_ptr->skill_sav /= 2;
5172
5173         /* Hack -- handle "xtra" mode */
5174         if (character_xtra) return;
5175
5176         /* Take note when "heavy bow" changes */
5177         if (p_ptr->old_heavy_shoot != p_ptr->heavy_shoot)
5178         {
5179                 /* Message */
5180                 if (p_ptr->heavy_shoot)
5181                 {
5182 #ifdef JP
5183                         msg_print("¤³¤ó¤Ê½Å¤¤µÝ¤òÁõÈ÷¤·¤Æ¤¤¤ë¤Î¤ÏÂçÊÑ¤À¡£");
5184 #else
5185                         msg_print("You have trouble wielding such a heavy bow.");
5186 #endif
5187
5188                 }
5189                 else if (inventory[INVEN_BOW].k_idx)
5190                 {
5191 #ifdef JP
5192                         msg_print("¤³¤ÎµÝ¤Ê¤éÁõÈ÷¤·¤Æ¤¤¤Æ¤â¿É¤¯¤Ê¤¤¡£");
5193 #else
5194                         msg_print("You have no trouble wielding your bow.");
5195 #endif
5196
5197                 }
5198                 else
5199                 {
5200 #ifdef JP
5201                         msg_print("½Å¤¤µÝ¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤ÆÂÎ¤¬³Ú¤Ë¤Ê¤Ã¤¿¡£");
5202 #else
5203                         msg_print("You feel relieved to put down your heavy bow.");
5204 #endif
5205
5206                 }
5207
5208                 /* Save it */
5209                 p_ptr->old_heavy_shoot = p_ptr->heavy_shoot;
5210         }
5211
5212         for(i = 0 ; i < 2 ; i++)
5213         {
5214                 /* Take note when "heavy weapon" changes */
5215                 if (p_ptr->old_heavy_wield[i] != p_ptr->heavy_wield[i])
5216                 {
5217                         /* Message */
5218                         if (p_ptr->heavy_wield[i])
5219                         {
5220 #ifdef JP
5221                                 msg_print("¤³¤ó¤Ê½Å¤¤Éð´ï¤òÁõÈ÷¤·¤Æ¤¤¤ë¤Î¤ÏÂçÊÑ¤À¡£");
5222 #else
5223                                 msg_print("You have trouble wielding such a heavy weapon.");
5224 #endif
5225
5226                         }
5227                         else if (buki_motteruka(INVEN_RARM+i))
5228                         {
5229 #ifdef JP
5230                                 msg_print("¤³¤ì¤Ê¤éÁõÈ÷¤·¤Æ¤¤¤Æ¤â¿É¤¯¤Ê¤¤¡£");
5231 #else
5232                                 msg_print("You have no trouble wielding your weapon.");
5233 #endif
5234
5235                         }
5236                         else if (p_ptr->heavy_wield[1-i])
5237                         {
5238 #ifdef JP
5239                                 msg_print("¤Þ¤ÀÉð´ï¤¬½Å¤¤¡£");
5240 #else
5241                                 msg_print("You have still trouble wielding a heavy weapon.");
5242 #endif
5243
5244                         }
5245                         else
5246                         {
5247 #ifdef JP
5248                                 msg_print("½Å¤¤Éð´ï¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤ÆÂÎ¤¬³Ú¤Ë¤Ê¤Ã¤¿¡£");
5249 #else
5250                                 msg_print("You feel relieved to put down your heavy weapon.");
5251 #endif
5252
5253                         }
5254
5255                         /* Save it */
5256                         p_ptr->old_heavy_wield[i] = p_ptr->heavy_wield[i];
5257                 }
5258
5259                 /* Take note when "heavy weapon" changes */
5260                 if (p_ptr->old_riding_wield[i] != p_ptr->riding_wield[i])
5261                 {
5262                         /* Message */
5263                         if (p_ptr->riding_wield[i])
5264                         {
5265 #ifdef JP
5266                                 msg_print("¤³¤ÎÉð´ï¤Ï¾èÇÏÃæ¤Ë»È¤¦¤Ë¤Ï¤à¤«¤Ê¤¤¤è¤¦¤À¡£");
5267 #else
5268                                 msg_print("This weapon is not suitable for use while riding.");
5269 #endif
5270
5271                         }
5272                         else if (!p_ptr->riding)
5273                         {
5274 #ifdef JP
5275                                 msg_print("¤³¤ÎÉð´ï¤ÏÅÌÊâ¤Ç»È¤¤¤ä¤¹¤¤¡£");
5276 #else
5277                                 msg_print("This weapon was not suitable for use while riding.");
5278 #endif
5279
5280                         }
5281                         else if (buki_motteruka(INVEN_RARM+i))
5282                         {
5283 #ifdef JP
5284                                 msg_print("¤³¤ì¤Ê¤é¾èÇÏÃæ¤Ë¤Ô¤Ã¤¿¤ê¤À¡£");
5285 #else
5286                                 msg_print("This weapon is suitable for use while riding.");
5287 #endif
5288
5289                         }
5290                         /* Save it */
5291                         p_ptr->old_riding_wield[i] = p_ptr->riding_wield[i];
5292                 }
5293
5294                 /* Take note when "illegal weapon" changes */
5295                 if (p_ptr->old_icky_wield[i] != p_ptr->icky_wield[i])
5296                 {
5297                         /* Message */
5298                         if (p_ptr->icky_wield[i])
5299                         {
5300 #ifdef JP
5301                                 msg_print("º£¤ÎÁõÈ÷¤Ï¤É¤¦¤â¼«Ê¬¤Ë¤Õ¤µ¤ï¤·¤¯¤Ê¤¤µ¤¤¬¤¹¤ë¡£");
5302 #else
5303                                 msg_print("You do not feel comfortable with your weapon.");
5304 #endif
5305                                 if (hack_mind)
5306                                 {
5307                                         chg_virtue(V_FAITH, -1);
5308                                 }
5309                         }
5310                         else if (buki_motteruka(INVEN_RARM+i))
5311                         {
5312 #ifdef JP
5313                                 msg_print("º£¤ÎÁõÈ÷¤Ï¼«Ê¬¤Ë¤Õ¤µ¤ï¤·¤¤µ¤¤¬¤¹¤ë¡£");
5314 #else
5315                                 msg_print("You feel comfortable with your weapon.");
5316 #endif
5317
5318                         }
5319                         else
5320                         {
5321 #ifdef JP
5322                                 msg_print("ÁõÈ÷¤ò¤Ï¤º¤·¤¿¤é¿ïÊ¬¤Èµ¤¤¬³Ú¤Ë¤Ê¤Ã¤¿¡£");
5323 #else
5324                                 msg_print("You feel more comfortable after removing your weapon.");
5325 #endif
5326
5327                         }
5328
5329                         /* Save it */
5330                         p_ptr->old_icky_wield[i] = p_ptr->icky_wield[i];
5331                 }
5332         }
5333
5334         if (p_ptr->riding && (p_ptr->old_riding_ryoute != p_ptr->riding_ryoute))
5335         {
5336                 /* Message */
5337                 if (p_ptr->riding_ryoute)
5338                 {
5339 #ifdef JP
5340                         msg_print("Î¾¼ê¤¬¤Õ¤µ¤¬¤Ã¤Æ¤¤¤ÆÇÏ¤òÁà¤ì¤Ê¤¤¡£");
5341 #else
5342                         msg_print("You are using both hand for fighting, and you can't control a riding pet.");
5343 #endif
5344                 }
5345                 else
5346                 {
5347 #ifdef JP
5348                         msg_print("¼ê¤¬¶õ¤¤¤ÆÇÏ¤òÁà¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£");
5349 #else
5350                         msg_print("You began to control riding pet with one hand.");
5351 #endif
5352                 }
5353
5354                 p_ptr->old_riding_ryoute = p_ptr->riding_ryoute;
5355         }
5356
5357         if (((p_ptr->pclass == CLASS_MONK) || (p_ptr->pclass == CLASS_FORCETRAINER) || (p_ptr->pclass == CLASS_NINJA)) && (monk_armour_aux != monk_notify_aux))
5358         {
5359                 if (heavy_armor())
5360                 {
5361 #ifdef JP
5362 msg_print("ÁõÈ÷¤¬½Å¤¯¤Æ¥Ð¥é¥ó¥¹¤ò¼è¤ì¤Ê¤¤¡£");
5363 #else
5364                         msg_print("The weight of your armor disrupts your balance.");
5365 #endif
5366
5367                         if (hack_mind)
5368                         {
5369                                 chg_virtue(V_HARMONY, -1);
5370                         }
5371                 }
5372                 else
5373 #ifdef JP
5374 msg_print("¥Ð¥é¥ó¥¹¤¬¤È¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£");
5375 #else
5376                         msg_print("You regain your balance.");
5377 #endif
5378
5379                 monk_notify_aux = monk_armour_aux;
5380         }
5381
5382         j = 0;
5383         p_ptr->align = friend_align;
5384
5385         /* Determine player alignment */
5386         for (i = 0; i < 8; i++)
5387         {
5388                 if ((p_ptr->vir_types[i] == V_HARMONY) || (p_ptr->vir_types[i] == V_NATURE))
5389                 {
5390                         neutral[j] = i;
5391                         j++;
5392                 }
5393                 else if (p_ptr->vir_types[i] == V_UNLIFE) p_ptr->align -= p_ptr->virtues[i];
5394                 else if (p_ptr->vir_types[i] == V_JUSTICE) p_ptr->align += (p_ptr->virtues[i]*2);
5395                 else if (p_ptr->vir_types[i] != V_CHANCE) p_ptr->align += p_ptr->virtues[i];
5396         }
5397         while (j)
5398         {
5399                 j--;
5400                 if (p_ptr->align > 0)
5401                 {
5402                         p_ptr->align -= (p_ptr->virtues[neutral[j]]/2);
5403                         if (p_ptr->align < 0) p_ptr->align = 0;
5404                 }
5405                 else if (p_ptr->align < 0)
5406                 {
5407                         p_ptr->align += (p_ptr->virtues[neutral[j]]/2);
5408                         if (p_ptr->align > 0) p_ptr->align = 0;
5409                 }
5410         }
5411         if ((inventory[INVEN_RARM].name1 == ART_IRON_BALL) || (inventory[INVEN_LARM].name1 == ART_IRON_BALL)) p_ptr->align -= 1000;
5412         if (prace_is_(RACE_ANGEL)) p_ptr->align += 200;
5413         if ((prace_is_(RACE_DEMON)) || (p_ptr->mimic_form == MIMIC_DEMON_LORD) || (p_ptr->mimic_form == MIMIC_DEMON)) p_ptr->align -= 200;
5414
5415         have_dd_s = FALSE;
5416         have_dd_t = FALSE;
5417         have_sw = FALSE;
5418         have_kabe = FALSE;
5419         for (i = 0; i < INVEN_PACK; i++)
5420         {
5421                 if ((inventory[i].tval == TV_SORCERY_BOOK) && (inventory[i].sval == 3)) have_dd_s = TRUE;
5422                 if ((inventory[i].tval == TV_TRUMP_BOOK) && (inventory[i].sval == 1)) have_dd_t = TRUE;
5423                 if ((inventory[i].tval == TV_NATURE_BOOK) && (inventory[i].sval == 2)) have_sw = TRUE;
5424                 if ((inventory[i].tval == TV_ENCHANT_BOOK) && (inventory[i].sval == 2)) have_kabe = TRUE;
5425         }
5426         for (this_o_idx = cave[py][px].o_idx; this_o_idx; this_o_idx = next_o_idx)
5427         {
5428                 object_type *o_ptr;
5429
5430                 /* Acquire object */
5431                 o_ptr = &o_list[this_o_idx];
5432
5433                 /* Acquire next object */
5434                 next_o_idx = o_ptr->next_o_idx;
5435
5436                 if ((o_ptr->tval == TV_SORCERY_BOOK) && (o_ptr->sval == 3)) have_dd_s = TRUE;
5437                 if ((o_ptr->tval == TV_TRUMP_BOOK) && (o_ptr->sval == 1)) have_dd_t = TRUE;
5438                 if ((o_ptr->tval == TV_NATURE_BOOK) && (o_ptr->sval == 2)) have_sw = TRUE;
5439                 if ((o_ptr->tval == TV_ENCHANT_BOOK) && (o_ptr->sval == 2)) have_kabe = TRUE;
5440         }
5441
5442         if ((p_ptr->pass_wall && !p_ptr->kill_wall) || p_ptr->kabenuke || p_ptr->wraith_form) p_ptr->no_flowed = TRUE;
5443 #if 0
5444         if (have_dd_s && ((p_ptr->realm1 == REALM_SORCERY) || (p_ptr->realm2 == REALM_SORCERY) || (p_ptr->pclass == CLASS_SORCERER)))
5445         {
5446                 magic_type *s_ptr = &mp_ptr->info[REALM_SORCERY-1][SPELL_DD_S];
5447                 if (p_ptr->lev >= s_ptr->slevel) p_ptr->no_flowed = TRUE;
5448         }
5449
5450         if (have_dd_t && ((p_ptr->realm1 == REALM_TRUMP) || (p_ptr->realm2 == REALM_TRUMP) || (p_ptr->pclass == CLASS_SORCERER) || (p_ptr->pclass == CLASS_RED_MAGE)))
5451         {
5452                 magic_type *s_ptr = &mp_ptr->info[REALM_TRUMP-1][SPELL_DD_T];
5453                 if (p_ptr->lev >= s_ptr->slevel) p_ptr->no_flowed = TRUE;
5454         }
5455 #endif
5456         if (have_sw && ((p_ptr->realm1 == REALM_NATURE) || (p_ptr->realm2 == REALM_NATURE) || (p_ptr->pclass == CLASS_SORCERER)))
5457         {
5458                 magic_type *s_ptr = &mp_ptr->info[REALM_NATURE-1][SPELL_SW];
5459                 if (p_ptr->lev >= s_ptr->slevel) p_ptr->no_flowed = TRUE;
5460         }
5461
5462         if (have_kabe && ((p_ptr->realm1 == REALM_ENCHANT) || (p_ptr->realm2 == REALM_ENCHANT) || (p_ptr->pclass == CLASS_SORCERER)))
5463         {
5464                 magic_type *s_ptr = &mp_ptr->info[REALM_ENCHANT-1][SPELL_KABE];
5465                 if (p_ptr->lev >= s_ptr->slevel) p_ptr->no_flowed = TRUE;
5466         }
5467 }
5468
5469
5470
5471 /*
5472  * Handle "p_ptr->notice"
5473  */
5474 void notice_stuff(void)
5475 {
5476         /* Notice stuff */
5477         if (!p_ptr->notice) return;
5478
5479
5480         /* Combine the pack */
5481         if (p_ptr->notice & (PN_COMBINE))
5482         {
5483                 p_ptr->notice &= ~(PN_COMBINE);
5484                 combine_pack();
5485         }
5486
5487         /* Reorder the pack */
5488         if (p_ptr->notice & (PN_REORDER))
5489         {
5490                 p_ptr->notice &= ~(PN_REORDER);
5491                 reorder_pack();
5492         }
5493 }
5494
5495
5496 /*
5497  * Handle "p_ptr->update"
5498  */
5499 void update_stuff(void)
5500 {
5501         /* Update stuff */
5502         if (!p_ptr->update) return;
5503
5504
5505         if (p_ptr->update & (PU_BONUS))
5506         {
5507                 p_ptr->update &= ~(PU_BONUS);
5508                 calc_bonuses();
5509         }
5510
5511         if (p_ptr->update & (PU_TORCH))
5512         {
5513                 p_ptr->update &= ~(PU_TORCH);
5514                 calc_torch();
5515         }
5516
5517         if (p_ptr->update & (PU_HP))
5518         {
5519                 p_ptr->update &= ~(PU_HP);
5520                 calc_hitpoints();
5521         }
5522
5523         if (p_ptr->update & (PU_MANA))
5524         {
5525                 p_ptr->update &= ~(PU_MANA);
5526                 calc_mana();
5527         }
5528
5529         if (p_ptr->update & (PU_SPELLS))
5530         {
5531                 p_ptr->update &= ~(PU_SPELLS);
5532                 calc_spells();
5533         }
5534
5535
5536         /* Character is not ready yet, no screen updates */
5537         if (!character_generated) return;
5538
5539
5540         /* Character is in "icky" mode, no screen updates */
5541         if (character_icky) return;
5542
5543
5544         if (p_ptr->update & (PU_UN_LITE))
5545         {
5546                 p_ptr->update &= ~(PU_UN_LITE);
5547                 forget_lite();
5548         }
5549
5550         if (p_ptr->update & (PU_UN_VIEW))
5551         {
5552                 p_ptr->update &= ~(PU_UN_VIEW);
5553                 forget_view();
5554         }
5555
5556         if (p_ptr->update & (PU_VIEW))
5557         {
5558                 p_ptr->update &= ~(PU_VIEW);
5559                 update_view();
5560         }
5561
5562         if (p_ptr->update & (PU_LITE))
5563         {
5564                 p_ptr->update &= ~(PU_LITE);
5565                 update_lite();
5566         }
5567
5568
5569         if (p_ptr->update & (PU_FLOW))
5570         {
5571                 p_ptr->update &= ~(PU_FLOW);
5572                 update_flow();
5573         }
5574
5575         if (p_ptr->update & (PU_MON_LITE))
5576         {
5577                 p_ptr->update &= ~(PU_MON_LITE);
5578                 update_mon_lite();
5579         }
5580
5581         if (p_ptr->update & (PU_DISTANCE))
5582         {
5583                 p_ptr->update &= ~(PU_DISTANCE);
5584                 p_ptr->update &= ~(PU_MONSTERS);
5585                 update_monsters(TRUE);
5586         }
5587
5588         if (p_ptr->update & (PU_MONSTERS))
5589         {
5590                 p_ptr->update &= ~(PU_MONSTERS);
5591                 update_monsters(FALSE);
5592         }
5593 }
5594
5595
5596 /*
5597  * Handle "p_ptr->redraw"
5598  */
5599 void redraw_stuff(void)
5600 {
5601         /* Redraw stuff */
5602         if (!p_ptr->redraw) return;
5603
5604
5605         /* Character is not ready yet, no screen updates */
5606         if (!character_generated) return;
5607
5608
5609         /* Character is in "icky" mode, no screen updates */
5610         if (character_icky) return;
5611
5612
5613
5614         /* Hack -- clear the screen */
5615         if (p_ptr->redraw & (PR_WIPE))
5616         {
5617                 p_ptr->redraw &= ~(PR_WIPE);
5618                 msg_print(NULL);
5619                 Term_clear();
5620         }
5621
5622
5623         if (p_ptr->redraw & (PR_MAP))
5624         {
5625                 p_ptr->redraw &= ~(PR_MAP);
5626                 prt_map();
5627         }
5628
5629
5630         if (p_ptr->redraw & (PR_BASIC))
5631         {
5632                 p_ptr->redraw &= ~(PR_BASIC);
5633                 p_ptr->redraw &= ~(PR_MISC | PR_TITLE | PR_STATS);
5634                 p_ptr->redraw &= ~(PR_LEV | PR_EXP | PR_GOLD);
5635                 p_ptr->redraw &= ~(PR_ARMOR | PR_HP | PR_MANA);
5636                 p_ptr->redraw &= ~(PR_DEPTH | PR_HEALTH | PR_UHEALTH);
5637                 prt_frame_basic();
5638                 prt_time();
5639                 prt_dungeon();
5640         }
5641
5642         if (p_ptr->redraw & (PR_DUNGEON))
5643         {
5644                 p_ptr->redraw &= ~(PR_DUNGEON);
5645         }
5646
5647         if (p_ptr->redraw & (PR_EQUIPPY))
5648         {
5649                 p_ptr->redraw &= ~(PR_EQUIPPY);
5650                 print_equippy(); /* To draw / delete equippy chars */
5651         }
5652
5653         if (p_ptr->redraw & (PR_MISC))
5654         {
5655                 p_ptr->redraw &= ~(PR_MISC);
5656                 prt_field(rp_ptr->title, ROW_RACE, COL_RACE);
5657 /*              prt_field(cp_ptr->title, ROW_CLASS, COL_CLASS); */
5658
5659         }
5660
5661         if (p_ptr->redraw & (PR_TITLE))
5662         {
5663                 p_ptr->redraw &= ~(PR_TITLE);
5664                 prt_title();
5665         }
5666
5667         if (p_ptr->redraw & (PR_LEV))
5668         {
5669                 p_ptr->redraw &= ~(PR_LEV);
5670                 prt_level();
5671         }
5672
5673         if (p_ptr->redraw & (PR_EXP))
5674         {
5675                 p_ptr->redraw &= ~(PR_EXP);
5676                 prt_exp();
5677         }
5678
5679         if (p_ptr->redraw & (PR_STATS))
5680         {
5681                 p_ptr->redraw &= ~(PR_STATS);
5682                 prt_stat(A_STR);
5683                 prt_stat(A_INT);
5684                 prt_stat(A_WIS);
5685                 prt_stat(A_DEX);
5686                 prt_stat(A_CON);
5687                 prt_stat(A_CHR);
5688         }
5689
5690         if (p_ptr->redraw & (PR_STATUS))
5691         {
5692                 p_ptr->redraw &= ~(PR_STATUS);
5693                 prt_status();
5694         }
5695
5696         if (p_ptr->redraw & (PR_ARMOR))
5697         {
5698                 p_ptr->redraw &= ~(PR_ARMOR);
5699                 prt_ac();
5700         }
5701
5702         if (p_ptr->redraw & (PR_HP))
5703         {
5704                 p_ptr->redraw &= ~(PR_HP);
5705                 prt_hp();
5706         }
5707
5708         if (p_ptr->redraw & (PR_MANA))
5709         {
5710                 p_ptr->redraw &= ~(PR_MANA);
5711                 prt_sp();
5712         }
5713
5714         if (p_ptr->redraw & (PR_GOLD))
5715         {
5716                 p_ptr->redraw &= ~(PR_GOLD);
5717                 prt_gold();
5718         }
5719
5720         if (p_ptr->redraw & (PR_DEPTH))
5721         {
5722                 p_ptr->redraw &= ~(PR_DEPTH);
5723                 prt_depth();
5724         }
5725
5726         if (p_ptr->redraw & (PR_HEALTH))
5727         {
5728                 p_ptr->redraw &= ~(PR_HEALTH);
5729                 health_redraw();
5730         }
5731
5732         if (p_ptr->redraw & (PR_UHEALTH))
5733         {
5734                 p_ptr->redraw &= ~(PR_UHEALTH);
5735                 riding_health_redraw();
5736         }
5737
5738
5739         if (p_ptr->redraw & (PR_EXTRA))
5740         {
5741                 p_ptr->redraw &= ~(PR_EXTRA);
5742                 p_ptr->redraw &= ~(PR_CUT | PR_STUN);
5743                 p_ptr->redraw &= ~(PR_HUNGER);
5744                 p_ptr->redraw &= ~(PR_STATE | PR_SPEED | PR_STUDY | PR_MANE | PR_STATUS);
5745                 prt_frame_extra();
5746         }
5747
5748         if (p_ptr->redraw & (PR_CUT))
5749         {
5750                 p_ptr->redraw &= ~(PR_CUT);
5751                 prt_cut();
5752         }
5753
5754         if (p_ptr->redraw & (PR_STUN))
5755         {
5756                 p_ptr->redraw &= ~(PR_STUN);
5757                 prt_stun();
5758         }
5759
5760         if (p_ptr->redraw & (PR_HUNGER))
5761         {
5762                 p_ptr->redraw &= ~(PR_HUNGER);
5763                 prt_hunger();
5764         }
5765
5766         if (p_ptr->redraw & (PR_STATE))
5767         {
5768                 p_ptr->redraw &= ~(PR_STATE);
5769                 prt_state();
5770         }
5771
5772         if (p_ptr->redraw & (PR_SPEED))
5773         {
5774                 p_ptr->redraw &= ~(PR_SPEED);
5775                 prt_speed();
5776         }
5777
5778         if (p_ptr->pclass == CLASS_IMITATOR)
5779         {
5780                 if (p_ptr->redraw & (PR_MANE))
5781                 {
5782                         p_ptr->redraw &= ~(PR_MANE);
5783                         prt_mane();
5784                 }
5785         }
5786         else if (p_ptr->redraw & (PR_STUDY))
5787         {
5788                 p_ptr->redraw &= ~(PR_STUDY);
5789                 prt_study();
5790         }
5791 }
5792
5793
5794 /*
5795  * Handle "p_ptr->window"
5796  */
5797 void window_stuff(void)
5798 {
5799         int j;
5800
5801         u32b mask = 0L;
5802
5803
5804         /* Nothing to do */
5805         if (!p_ptr->window) return;
5806
5807         /* Scan windows */
5808         for (j = 0; j < 8; j++)
5809         {
5810                 /* Save usable flags */
5811                 if (angband_term[j]) mask |= window_flag[j];
5812         }
5813
5814         /* Apply usable flags */
5815         p_ptr->window &= mask;
5816
5817         /* Nothing to do */
5818         if (!p_ptr->window) return;
5819
5820
5821         /* Display inventory */
5822         if (p_ptr->window & (PW_INVEN))
5823         {
5824                 p_ptr->window &= ~(PW_INVEN);
5825                 fix_inven();
5826         }
5827
5828         /* Display equipment */
5829         if (p_ptr->window & (PW_EQUIP))
5830         {
5831                 p_ptr->window &= ~(PW_EQUIP);
5832                 fix_equip();
5833         }
5834
5835         /* Display spell list */
5836         if (p_ptr->window & (PW_SPELL))
5837         {
5838                 p_ptr->window &= ~(PW_SPELL);
5839                 fix_spell();
5840         }
5841
5842         /* Display player */
5843         if (p_ptr->window & (PW_PLAYER))
5844         {
5845                 p_ptr->window &= ~(PW_PLAYER);
5846                 fix_player();
5847         }
5848
5849         /* Display overhead view */
5850         if (p_ptr->window & (PW_MESSAGE))
5851         {
5852                 p_ptr->window &= ~(PW_MESSAGE);
5853                 fix_message();
5854         }
5855
5856         /* Display overhead view */
5857         if (p_ptr->window & (PW_OVERHEAD))
5858         {
5859                 p_ptr->window &= ~(PW_OVERHEAD);
5860                 fix_overhead();
5861         }
5862
5863         /* Display overhead view */
5864         if (p_ptr->window & (PW_DUNGEON))
5865         {
5866                 p_ptr->window &= ~(PW_DUNGEON);
5867                 fix_dungeon();
5868         }
5869
5870         /* Display monster recall */
5871         if (p_ptr->window & (PW_MONSTER))
5872         {
5873                 p_ptr->window &= ~(PW_MONSTER);
5874                 fix_monster();
5875         }
5876
5877         /* Display object recall */
5878         if (p_ptr->window & (PW_OBJECT))
5879         {
5880                 p_ptr->window &= ~(PW_OBJECT);
5881                 fix_object();
5882         }
5883 }
5884
5885
5886 /*
5887  * Handle "p_ptr->update" and "p_ptr->redraw" and "p_ptr->window"
5888  */
5889 void handle_stuff(void)
5890 {
5891         /* Update stuff */
5892         if (p_ptr->update) update_stuff();
5893
5894         /* Redraw stuff */
5895         if (p_ptr->redraw) redraw_stuff();
5896
5897         /* Window stuff */
5898         if (p_ptr->window) window_stuff();
5899 }
5900
5901
5902 s16b empty_hands(bool is_monk)
5903 {
5904         s16b kaerichi = 0;
5905         if (is_monk && (p_ptr->pclass != CLASS_MONK) && (p_ptr->pclass != CLASS_FORCETRAINER) && (p_ptr->pclass != CLASS_BERSERKER)) return FALSE;
5906
5907         if (!(inventory[INVEN_RARM].k_idx)) kaerichi +=2;
5908         if (!(inventory[INVEN_LARM].k_idx)) kaerichi +=1;
5909         return kaerichi;
5910 }
5911
5912
5913 bool heavy_armor(void)
5914 {
5915         u16b monk_arm_wgt = 0;
5916
5917         if ((p_ptr->pclass != CLASS_MONK) && (p_ptr->pclass != CLASS_FORCETRAINER) && (p_ptr->pclass != CLASS_NINJA)) return FALSE;
5918
5919         /* Weight the armor */
5920         if(inventory[INVEN_RARM].tval > TV_SWORD) monk_arm_wgt += inventory[INVEN_RARM].weight;
5921         if(inventory[INVEN_LARM].tval > TV_SWORD) monk_arm_wgt += inventory[INVEN_LARM].weight;
5922         monk_arm_wgt += inventory[INVEN_BODY].weight;
5923         monk_arm_wgt += inventory[INVEN_HEAD].weight;
5924         monk_arm_wgt += inventory[INVEN_OUTER].weight;
5925         monk_arm_wgt += inventory[INVEN_HANDS].weight;
5926         monk_arm_wgt += inventory[INVEN_FEET].weight;
5927
5928         return (monk_arm_wgt > (100 + (p_ptr->lev * 4)));
5929 }
5930
5931 int number_of_quests(void)
5932 {
5933         int i, j;
5934
5935         /* Clear the counter */
5936         i = 0;
5937
5938         for (j = MIN_RANDOM_QUEST; j < MAX_RANDOM_QUEST+1; j++)
5939         {
5940                 if (quest[j].status != QUEST_STATUS_UNTAKEN)
5941                 {
5942                         /* Increment count of quests taken. */
5943                         i++;
5944                 }
5945         }
5946
5947         /* Return the number of quests taken */
5948         return (i);
5949 }