src/xtra1.c

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