src/effects.c

   1 /* File: effects.c */
   2
   3 /*
   4  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   5  *
   6  * This software may be copied and distributed for educational, research,
   7  * and not for profit purposes provided that this copyright and statement
   8  * are included in all such copies.  Other copyrights may also apply.
   9  */
  10
  11 /* Purpose: effects of various "objects" */
  12
  13 #include "angband.h"
  14
  15 void set_action(int typ)
  16 {
  17         int prev_typ = p_ptr->action;
  18
  19         if (typ == prev_typ)
  20         {
  21                 return;
  22         }
  23         else
  24         {
  25                 switch (prev_typ)
  26                 {
  27                         case ACTION_SEARCH:
  28                         {
  29 #ifdef JP
  30                                 msg_print("Ãµº÷¤ò¤ä¤á¤¿¡£");
  31 #else
  32                                 msg_print("You no longer walk carefully.");
  33 #endif
  34                                 p_ptr->redraw |= (PR_SPEED);
  35                                 break;
  36                         }
  37                         case ACTION_REST:
  38                         {
  39                                 resting = 0;
  40                                 break;
  41                         }
  42                         case ACTION_LEARN:
  43                         {
  44 #ifdef JP
  45                                 msg_print("³Ø½¬¤ò¤ä¤á¤¿¡£");
  46 #else
  47                                 msg_print("You stop Learning");
  48 #endif
  49                                 new_mane = FALSE;
  50                                 break;
  51                         }
  52                         case ACTION_KAMAE:
  53                         {
  54 #ifdef JP
  55                                 msg_print("¹½¤¨¤ò¤È¤¤¤¿¡£");
  56 #else
  57                                 msg_print("You stop assuming the posture.");
  58 #endif
  59                                 p_ptr->special_defense &= ~(KAMAE_MASK);
  60                                 break;
  61                         }
  62                         case ACTION_KATA:
  63                         {
  64 #ifdef JP
  65                                 msg_print("·¿¤òÊø¤·¤¿¡£");
  66 #else
  67                                 msg_print("You stop assuming the posture.");
  68 #endif
  69                                 p_ptr->special_defense &= ~(KATA_MASK);
  70                                 p_ptr->update |= (PU_MONSTERS);
  71                                 p_ptr->redraw |= (PR_STATUS);
  72                                 break;
  73                         }
  74                         case ACTION_SING:
  75                         {
  76 #ifdef JP
  77                                 msg_print("²Î¤¦¤Î¤ò¤ä¤á¤¿¡£");
  78 #else
  79                                 msg_print("You stop singing.");
  80 #endif
  81                                 break;
  82                         }
  83                         case ACTION_HAYAGAKE:
  84                         {
  85 #ifdef JP
  86                                 msg_print("Â¤¬½Å¤¯¤Ê¤Ã¤¿¡£");
  87 #else
  88                                 msg_print("You are no longer walking extremely fast.");
  89 #endif
  90                                 energy_use = 100;
  91                                 break;
  92                         }
  93                         case ACTION_SPELL:
  94                         {
  95 #ifdef JP
  96                                 msg_print("¼öÊ¸¤Î±Ó¾§¤òÃæÃÇ¤·¤¿¡£");
  97 #else
  98                                 msg_print("You stopped spelling all spells.");
  99 #endif
 100                                 break;
 101                         }
 102                 }
 103         }
 104
 105         p_ptr->action = typ;
 106
 107         /* If we are requested other action, stop singing */
 108         if (prev_typ == ACTION_SING) stop_singing();
 109         if (prev_typ == ACTION_SPELL) stop_hex_spell();
 110
 111         switch (p_ptr->action)
 112         {
 113                 case ACTION_SEARCH:
 114                 {
 115 #ifdef JP
 116                         msg_print("Ãí°Õ¿¼¤¯Êâ¤»Ï¤á¤¿¡£");
 117 #else
 118                         msg_print("You begin to walk carefully.");
 119 #endif
 120                         p_ptr->redraw |= (PR_SPEED);
 121                         break;
 122                 }
 123                 case ACTION_LEARN:
 124                 {
 125 #ifdef JP
 126                         msg_print("³Ø½¬¤ò»Ï¤á¤¿¡£");
 127 #else
 128                         msg_print("You begin Learning");
 129 #endif
 130                         break;
 131                 }
 132                 case ACTION_FISH:
 133                 {
 134 #ifdef JP
 135                         msg_print("¿åÌÌ¤Ë»å¤ò¿â¤é¤·¤¿¡¥¡¥¡¥");
 136 #else
 137                         msg_print("You begin fishing...");
 138 #endif
 139                         break;
 140                 }
 141                 case ACTION_HAYAGAKE:
 142                 {
 143 #ifdef JP
 144                         msg_print("Â¤¬±©¤Î¤è¤¦¤Ë·Ú¤¯¤Ê¤Ã¤¿¡£");
 145 #else
 146                         msg_print("You begin to walk extremely fast.");
 147 #endif
 148                         break;
 149                 }
 150                 default:
 151                 {
 152                         break;
 153                 }
 154         }
 155
 156         /* Recalculate bonuses */
 157         p_ptr->update |= (PU_BONUS);
 158
 159         /* Redraw the state */
 160         p_ptr->redraw |= (PR_STATE);
 161 }
 162
 163 /* reset timed flags */
 164 void reset_tim_flags(void)
 165 {
 166         p_ptr->fast = 0;            /* Timed -- Fast */
 167         p_ptr->lightspeed = 0;
 168         p_ptr->slow = 0;            /* Timed -- Slow */
 169         p_ptr->blind = 0;           /* Timed -- Blindness */
 170         p_ptr->paralyzed = 0;       /* Timed -- Paralysis */
 171         p_ptr->confused = 0;        /* Timed -- Confusion */
 172         p_ptr->afraid = 0;          /* Timed -- Fear */
 173         p_ptr->image = 0;           /* Timed -- Hallucination */
 174         p_ptr->poisoned = 0;        /* Timed -- Poisoned */
 175         p_ptr->cut = 0;             /* Timed -- Cut */
 176         p_ptr->stun = 0;            /* Timed -- Stun */
 177
 178         p_ptr->protevil = 0;        /* Timed -- Protection */
 179         p_ptr->invuln = 0;          /* Timed -- Invulnerable */
 180         p_ptr->ult_res = 0;
 181         p_ptr->hero = 0;            /* Timed -- Heroism */
 182         p_ptr->shero = 0;           /* Timed -- Super Heroism */
 183         p_ptr->shield = 0;          /* Timed -- Shield Spell */
 184         p_ptr->blessed = 0;         /* Timed -- Blessed */
 185         p_ptr->tim_invis = 0;       /* Timed -- Invisibility */
 186         p_ptr->tim_infra = 0;       /* Timed -- Infra Vision */
 187         p_ptr->tim_regen = 0;       /* Timed -- Regeneration */
 188         p_ptr->tim_stealth = 0;     /* Timed -- Stealth */
 189         p_ptr->tim_esp = 0;
 190         p_ptr->wraith_form = 0;     /* Timed -- Wraith Form */
 191         p_ptr->tim_levitation = 0;
 192         p_ptr->tim_sh_touki = 0;
 193         p_ptr->tim_sh_fire = 0;
 194         p_ptr->tim_sh_holy = 0;
 195         p_ptr->tim_eyeeye = 0;
 196         p_ptr->magicdef = 0;
 197         p_ptr->resist_magic = 0;
 198         p_ptr->tsuyoshi = 0;
 199         p_ptr->kabenuke = 0;
 200         p_ptr->tim_res_nether = 0;
 201         p_ptr->tim_res_time = 0;
 202         p_ptr->tim_mimic = 0;
 203         p_ptr->mimic_form = 0;
 204         p_ptr->tim_reflect = 0;
 205         p_ptr->multishadow = 0;
 206         p_ptr->dustrobe = 0;
 207         p_ptr->action = ACTION_NONE;
 208
 209
 210         p_ptr->oppose_acid = 0;     /* Timed -- oppose acid */
 211         p_ptr->oppose_elec = 0;     /* Timed -- oppose lightning */
 212         p_ptr->oppose_fire = 0;     /* Timed -- oppose heat */
 213         p_ptr->oppose_cold = 0;     /* Timed -- oppose cold */
 214         p_ptr->oppose_pois = 0;     /* Timed -- oppose poison */
 215
 216         p_ptr->word_recall = 0;
 217         p_ptr->alter_reality = 0;
 218         p_ptr->sutemi = FALSE;
 219         p_ptr->counter = FALSE;
 220         p_ptr->ele_attack = 0;
 221         p_ptr->ele_immune = 0;
 222         p_ptr->special_attack = 0L;
 223         p_ptr->special_defense = 0L;
 224
 225         while(p_ptr->energy_need < 0) p_ptr->energy_need += ENERGY_NEED();
 226         world_player = FALSE;
 227
 228         if (prace_is_(RACE_DEMON) && (p_ptr->lev > 44)) p_ptr->oppose_fire = 1;
 229         if ((p_ptr->pclass == CLASS_NINJA) && (p_ptr->lev > 44)) p_ptr->oppose_pois = 1;
 230         if (p_ptr->pclass == CLASS_BERSERKER) p_ptr->shero = 1;
 231
 232         if (p_ptr->riding)
 233         {
 234                 (void)set_monster_fast(p_ptr->riding, 0);
 235                 (void)set_monster_slow(p_ptr->riding, 0);
 236                 (void)set_monster_invulner(p_ptr->riding, 0, FALSE);
 237         }
 238
 239         if (p_ptr->pclass == CLASS_BARD)
 240         {
 241                 p_ptr->magic_num1[0] = 0;
 242                 p_ptr->magic_num2[0] = 0;
 243         }
 244 }
 245
 246
 247 void dispel_player(void)
 248 {
 249         (void)set_fast(0, TRUE);
 250         (void)set_lightspeed(0, TRUE);
 251         (void)set_slow(0, TRUE);
 252         (void)set_shield(0, TRUE);
 253         (void)set_blessed(0, TRUE);
 254         (void)set_tsuyoshi(0, TRUE);
 255         (void)set_hero(0, TRUE);
 256         (void)set_shero(0, TRUE);
 257         (void)set_protevil(0, TRUE);
 258         (void)set_invuln(0, TRUE);
 259         (void)set_wraith_form(0, TRUE);
 260         (void)set_kabenuke(0, TRUE);
 261         (void)set_tim_res_nether(0, TRUE);
 262         (void)set_tim_res_time(0, TRUE);
 263         /* by henkma */
 264         (void)set_tim_reflect(0,TRUE);
 265         (void)set_multishadow(0,TRUE);
 266         (void)set_dustrobe(0,TRUE);
 267
 268         (void)set_tim_invis(0, TRUE);
 269         (void)set_tim_infra(0, TRUE);
 270         (void)set_tim_esp(0, TRUE);
 271         (void)set_tim_regen(0, TRUE);
 272         (void)set_tim_stealth(0, TRUE);
 273         (void)set_tim_levitation(0, TRUE);
 274         (void)set_tim_sh_touki(0, TRUE);
 275         (void)set_tim_sh_fire(0, TRUE);
 276         (void)set_tim_sh_holy(0, TRUE);
 277         (void)set_tim_eyeeye(0, TRUE);
 278         (void)set_magicdef(0, TRUE);
 279         (void)set_resist_magic(0, TRUE);
 280         (void)set_oppose_acid(0, TRUE);
 281         (void)set_oppose_elec(0, TRUE);
 282         (void)set_oppose_fire(0, TRUE);
 283         (void)set_oppose_cold(0, TRUE);
 284         (void)set_oppose_pois(0, TRUE);
 285         (void)set_ultimate_res(0, TRUE);
 286         (void)set_mimic(0, 0, TRUE);
 287         (void)set_ele_attack(0, 0);
 288         (void)set_ele_immune(0, 0);
 289
 290         /* Cancel glowing hands */
 291         if (p_ptr->special_attack & ATTACK_CONFUSE)
 292         {
 293                 p_ptr->special_attack &= ~(ATTACK_CONFUSE);
 294 #ifdef JP
 295                 msg_print("¼ê¤Îµ±¤¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
 296 #else
 297                 msg_print("Your hands stop glowing.");
 298 #endif
 299         }
 300
 301         if (music_singing_any() || hex_spelling_any())
 302         {
 303 #ifdef JP
 304                 cptr str = (music_singing_any()) ? "²Î" : "¼öÊ¸";
 305 #else
 306                 cptr str = (music_singing_any()) ? "singing" : "spelling";
 307 #endif
 308                 p_ptr->magic_num1[1] = p_ptr->magic_num1[0];
 309                 p_ptr->magic_num1[0] = 0;
 310 #ifdef JP
 311                 msg_format("%s¤¬ÅÓÀÚ¤ì¤¿¡£", str);
 312 #else
 313                 msg_format("Your %s is interrupted.", str);
 314 #endif
 315                 p_ptr->action = ACTION_NONE;
 316
 317                 /* Recalculate bonuses */
 318                 p_ptr->update |= (PU_BONUS | PU_HP);
 319
 320                 /* Redraw map */
 321                 p_ptr->redraw |= (PR_MAP | PR_STATUS | PR_STATE);
 322
 323                 /* Update monsters */
 324                 p_ptr->update |= (PU_MONSTERS);
 325
 326                 /* Window stuff */
 327                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 328
 329                 p_ptr->energy_need += ENERGY_NEED();
 330         }
 331 }
 332
 333
 334 /*
 335  * Set "p_ptr->tim_mimic", and "p_ptr->mimic_form",
 336  * notice observable changes
 337  */
 338 bool set_mimic(int v, int p, bool do_dec)
 339 {
 340         bool notice = FALSE;
 341
 342         /* Hack -- Force good values */
 343         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 344
 345         if (p_ptr->is_dead) return FALSE;
 346
 347         /* Open */
 348         if (v)
 349         {
 350                 if (p_ptr->tim_mimic && (p_ptr->mimic_form == p) && !do_dec)
 351                 {
 352                         if (p_ptr->tim_mimic > v) return FALSE;
 353                 }
 354                 else if ((!p_ptr->tim_mimic) || (p_ptr->mimic_form != p))
 355                 {
 356 #ifdef JP
 357                         msg_print("¼«Ê¬¤ÎÂÎ¤¬ÊÑ¤ï¤Ã¤Æ¤æ¤¯¤Î¤ò´¶¤¸¤¿¡£");
 358 #else
 359                         msg_print("You feel that your body changes.");
 360 #endif
 361                         p_ptr->mimic_form=p;
 362                         notice = TRUE;
 363                 }
 364         }
 365
 366         /* Shut */
 367         else
 368         {
 369                 if (p_ptr->tim_mimic)
 370                 {
 371 #ifdef JP
 372                         msg_print("ÊÑ¿È¤¬²ò¤±¤¿¡£");
 373 #else
 374                         msg_print("You are no longer transformed.");
 375 #endif
 376                         if (p_ptr->mimic_form == MIMIC_DEMON) set_oppose_fire(0, TRUE);
 377                         p_ptr->mimic_form=0;
 378                         notice = TRUE;
 379                         p = 0;
 380                 }
 381         }
 382
 383         /* Use the value */
 384         p_ptr->tim_mimic = v;
 385
 386         /* Nothing to notice */
 387         if (!notice)
 388                 return (FALSE);
 389
 390         /* Disturb */
 391         if (disturb_state) disturb(0, 1);
 392
 393         /* Redraw title */
 394         p_ptr->redraw |= (PR_BASIC | PR_STATUS);
 395
 396         /* Recalculate bonuses */
 397         p_ptr->update |= (PU_BONUS | PU_HP);
 398
 399         handle_stuff();
 400
 401         /* Result */
 402         return (TRUE);
 403 }
 404
 405 /*
 406  * Set "p_ptr->blind", notice observable changes
 407  *
 408  * Note the use of "PU_UN_LITE" and "PU_UN_VIEW", which is needed to
 409  * memorize any terrain features which suddenly become "visible".
 410  * Note that blindness is currently the only thing which can affect
 411  * "player_can_see_bold()".
 412  */
 413 bool set_blind(int v)
 414 {
 415         bool notice = FALSE;
 416
 417         /* Hack -- Force good values */
 418         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 419
 420         if (p_ptr->is_dead) return FALSE;
 421
 422         /* Open */
 423         if (v)
 424         {
 425                 if (!p_ptr->blind)
 426                 {
 427                         if (p_ptr->prace == RACE_ANDROID)
 428                         {
 429 #ifdef JP
 430 msg_print("¥»¥ó¥µ¡¼¤ò¤ä¤é¤ì¤¿¡ª");
 431 #else
 432                                 msg_print("You are blind!");
 433 #endif
 434                         }
 435                         else
 436                         {
 437 #ifdef JP
 438 msg_print("ÌÜ¤¬¸«¤¨¤Ê¤¯¤Ê¤Ã¤Æ¤·¤Þ¤Ã¤¿¡ª");
 439 #else
 440                                 msg_print("You are blind!");
 441 #endif
 442                         }
 443
 444                         notice = TRUE;
 445                         chg_virtue(V_ENLIGHTEN, -1);
 446                 }
 447         }
 448
 449         /* Shut */
 450         else
 451         {
 452                 if (p_ptr->blind)
 453                 {
 454                         if (p_ptr->prace == RACE_ANDROID)
 455                         {
 456 #ifdef JP
 457 msg_print("¥»¥ó¥µ¡¼¤¬Éüµì¤·¤¿¡£");
 458 #else
 459                                 msg_print("You can see again.");
 460 #endif
 461                         }
 462                         else
 463                         {
 464 #ifdef JP
 465 msg_print("¤ä¤Ã¤ÈÌÜ¤¬¸«¤¨¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£");
 466 #else
 467                                 msg_print("You can see again.");
 468 #endif
 469                         }
 470
 471                         notice = TRUE;
 472                 }
 473         }
 474
 475         /* Use the value */
 476         p_ptr->blind = v;
 477
 478         /* Redraw status bar */
 479         p_ptr->redraw |= (PR_STATUS);
 480
 481         /* Nothing to notice */
 482         if (!notice) return (FALSE);
 483
 484         /* Disturb */
 485         if (disturb_state) disturb(0, 0);
 486
 487         /* Fully update the visuals */
 488         p_ptr->update |= (PU_UN_VIEW | PU_UN_LITE | PU_VIEW | PU_LITE | PU_MONSTERS | PU_MON_LITE);
 489
 490         /* Redraw map */
 491         p_ptr->redraw |= (PR_MAP);
 492
 493         /* Window stuff */
 494         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 495
 496         /* Handle stuff */
 497         handle_stuff();
 498
 499         /* Result */
 500         return (TRUE);
 501 }
 502
 503
 504 /*
 505  * Set "p_ptr->confused", notice observable changes
 506  */
 507 bool set_confused(int v)
 508 {
 509         bool notice = FALSE;
 510
 511         /* Hack -- Force good values */
 512         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 513
 514         if (p_ptr->is_dead) return FALSE;
 515
 516         /* Open */
 517         if (v)
 518         {
 519                 if (!p_ptr->confused)
 520                 {
 521 #ifdef JP
 522 msg_print("¤¢¤Ê¤¿¤Ïº®Íð¤·¤¿¡ª");
 523 #else
 524                         msg_print("You are confused!");
 525 #endif
 526
 527                         if (p_ptr->action == ACTION_LEARN)
 528                         {
 529 #ifdef JP
 530                                 msg_print("³Ø½¬¤¬Â³¤±¤é¤ì¤Ê¤¤¡ª");
 531 #else
 532                                 msg_print("You cannot continue Learning!");
 533 #endif
 534                                 new_mane = FALSE;
 535
 536                                 p_ptr->redraw |= (PR_STATE);
 537                                 p_ptr->action = ACTION_NONE;
 538                         }
 539                         if (p_ptr->action == ACTION_KAMAE)
 540                         {
 541 #ifdef JP
 542                                 msg_print("¹½¤¨¤¬¤È¤±¤¿¡£");
 543 #else
 544                                 msg_print("Your posture gets loose.");
 545 #endif
 546                                 p_ptr->special_defense &= ~(KAMAE_MASK);
 547                                 p_ptr->update |= (PU_BONUS);
 548                                 p_ptr->redraw |= (PR_STATE);
 549                                 p_ptr->action = ACTION_NONE;
 550                         }
 551                         else if (p_ptr->action == ACTION_KATA)
 552                         {
 553 #ifdef JP
 554                                 msg_print("·¿¤¬Êø¤ì¤¿¡£");
 555 #else
 556                                 msg_print("Your posture gets loose.");
 557 #endif
 558                                 p_ptr->special_defense &= ~(KATA_MASK);
 559                                 p_ptr->update |= (PU_BONUS);
 560                                 p_ptr->update |= (PU_MONSTERS);
 561                                 p_ptr->redraw |= (PR_STATE);
 562                                 p_ptr->redraw |= (PR_STATUS);
 563                                 p_ptr->action = ACTION_NONE;
 564                         }
 565
 566                         /* Sniper */
 567                         if (p_ptr->concent) reset_concentration(TRUE);
 568
 569                         /* Hex */
 570                         if (hex_spelling_any()) stop_hex_spell_all();
 571
 572                         notice = TRUE;
 573                         p_ptr->counter = FALSE;
 574                         chg_virtue(V_HARMONY, -1);
 575                 }
 576         }
 577
 578         /* Shut */
 579         else
 580         {
 581                 if (p_ptr->confused)
 582                 {
 583 #ifdef JP
 584 msg_print("¤ä¤Ã¤Èº®Íð¤¬¤ª¤µ¤Þ¤Ã¤¿¡£");
 585 #else
 586                         msg_print("You feel less confused now.");
 587 #endif
 588
 589                         p_ptr->special_attack &= ~(ATTACK_SUIKEN);
 590                         notice = TRUE;
 591                 }
 592         }
 593
 594         /* Use the value */
 595         p_ptr->confused = v;
 596
 597         /* Redraw status bar */
 598         p_ptr->redraw |= (PR_STATUS);
 599
 600         /* Nothing to notice */
 601         if (!notice) return (FALSE);
 602
 603         /* Disturb */
 604         if (disturb_state) disturb(0, 0);
 605
 606         /* Handle stuff */
 607         handle_stuff();
 608
 609         /* Result */
 610         return (TRUE);
 611 }
 612
 613
 614 /*
 615  * Set "p_ptr->poisoned", notice observable changes
 616  */
 617 bool set_poisoned(int v)
 618 {
 619         bool notice = FALSE;
 620
 621         /* Hack -- Force good values */
 622         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 623
 624         if (p_ptr->is_dead) return FALSE;
 625
 626         /* Open */
 627         if (v)
 628         {
 629                 if (!p_ptr->poisoned)
 630                 {
 631 #ifdef JP
 632 msg_print("ÆÇ¤Ë¿¯¤µ¤ì¤Æ¤·¤Þ¤Ã¤¿¡ª");
 633 #else
 634                         msg_print("You are poisoned!");
 635 #endif
 636
 637                         notice = TRUE;
 638                 }
 639         }
 640
 641         /* Shut */
 642         else
 643         {
 644                 if (p_ptr->poisoned)
 645                 {
 646 #ifdef JP
 647 msg_print("¤ä¤Ã¤ÈÆÇ¤ÎÄË¤ß¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
 648 #else
 649                         msg_print("You are no longer poisoned.");
 650 #endif
 651
 652                         notice = TRUE;
 653                 }
 654         }
 655
 656         /* Use the value */
 657         p_ptr->poisoned = v;
 658
 659         /* Redraw status bar */
 660         p_ptr->redraw |= (PR_STATUS);
 661
 662         /* Nothing to notice */
 663         if (!notice) return (FALSE);
 664
 665         /* Disturb */
 666         if (disturb_state) disturb(0, 0);
 667
 668         /* Handle stuff */
 669         handle_stuff();
 670
 671         /* Result */
 672         return (TRUE);
 673 }
 674
 675
 676 /*
 677  * Set "p_ptr->afraid", notice observable changes
 678  */
 679 bool set_afraid(int v)
 680 {
 681         bool notice = FALSE;
 682
 683         /* Hack -- Force good values */
 684         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 685
 686         if (p_ptr->is_dead) return FALSE;
 687
 688         /* Open */
 689         if (v)
 690         {
 691                 if (!p_ptr->afraid)
 692                 {
 693 #ifdef JP
 694 msg_print("²¿¤â¤«¤â¶²¤¯¤Ê¤Ã¤Æ¤¤¿¡ª");
 695 #else
 696                         msg_print("You are terrified!");
 697 #endif
 698
 699                         if (p_ptr->special_defense & KATA_MASK)
 700                         {
 701 #ifdef JP
 702                                 msg_print("·¿¤¬Êø¤ì¤¿¡£");
 703 #else
 704                                 msg_print("Your posture gets loose.");
 705 #endif
 706                                 p_ptr->special_defense &= ~(KATA_MASK);
 707                                 p_ptr->update |= (PU_BONUS);
 708                                 p_ptr->update |= (PU_MONSTERS);
 709                                 p_ptr->redraw |= (PR_STATE);
 710                                 p_ptr->redraw |= (PR_STATUS);
 711                                 p_ptr->action = ACTION_NONE;
 712                         }
 713
 714                         notice = TRUE;
 715                         p_ptr->counter = FALSE;
 716                         chg_virtue(V_VALOUR, -1);
 717                 }
 718         }
 719
 720         /* Shut */
 721         else
 722         {
 723                 if (p_ptr->afraid)
 724                 {
 725 #ifdef JP
 726 msg_print("¤ä¤Ã¤È¶²ÉÝ¤ò¿¶¤êÊ§¤Ã¤¿¡£");
 727 #else
 728                         msg_print("You feel bolder now.");
 729 #endif
 730
 731                         notice = TRUE;
 732                 }
 733         }
 734
 735         /* Use the value */
 736         p_ptr->afraid = v;
 737
 738         /* Redraw status bar */
 739         p_ptr->redraw |= (PR_STATUS);
 740
 741         /* Nothing to notice */
 742         if (!notice) return (FALSE);
 743
 744         /* Disturb */
 745         if (disturb_state) disturb(0, 0);
 746
 747         /* Handle stuff */
 748         handle_stuff();
 749
 750         /* Result */
 751         return (TRUE);
 752 }
 753
 754
 755 /*
 756  * Set "p_ptr->paralyzed", notice observable changes
 757  */
 758 bool set_paralyzed(int v)
 759 {
 760         bool notice = FALSE;
 761
 762         /* Hack -- Force good values */
 763         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 764
 765         if (p_ptr->is_dead) return FALSE;
 766
 767         /* Open */
 768         if (v)
 769         {
 770                 if (!p_ptr->paralyzed)
 771                 {
 772 #ifdef JP
 773 msg_print("ÂÎ¤¬Ëãáã¤·¤Æ¤·¤Þ¤Ã¤¿¡ª");
 774 #else
 775                         msg_print("You are paralyzed!");
 776 #endif
 777
 778                         /* Sniper */
 779                         if (p_ptr->concent) reset_concentration(TRUE);
 780
 781                         /* Hex */
 782                         if (hex_spelling_any()) stop_hex_spell_all();
 783
 784                         p_ptr->counter = FALSE;
 785                         notice = TRUE;
 786                 }
 787         }
 788
 789         /* Shut */
 790         else
 791         {
 792                 if (p_ptr->paralyzed)
 793                 {
 794 #ifdef JP
 795 msg_print("¤ä¤Ã¤ÈÆ°¤±¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£");
 796 #else
 797                         msg_print("You can move again.");
 798 #endif
 799
 800                         notice = TRUE;
 801                 }
 802         }
 803
 804         /* Use the value */
 805         p_ptr->paralyzed = v;
 806
 807         /* Redraw status bar */
 808         p_ptr->redraw |= (PR_STATUS);
 809
 810         /* Nothing to notice */
 811         if (!notice) return (FALSE);
 812
 813         /* Disturb */
 814         if (disturb_state) disturb(0, 0);
 815
 816         /* Redraw the state */
 817         p_ptr->redraw |= (PR_STATE);
 818
 819         /* Handle stuff */
 820         handle_stuff();
 821
 822         /* Result */
 823         return (TRUE);
 824 }
 825
 826
 827 /*
 828  * Set "p_ptr->image", notice observable changes
 829  *
 830  * Note that we must redraw the map when hallucination changes.
 831  */
 832 bool set_image(int v)
 833 {
 834         bool notice = FALSE;
 835
 836         /* Hack -- Force good values */
 837         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 838
 839         if (p_ptr->is_dead) return FALSE;
 840
 841
 842         /* Open */
 843         if (v)
 844         {
 845                 set_tsuyoshi(0, TRUE);
 846                 if (!p_ptr->image)
 847                 {
 848 #ifdef JP
 849 msg_print("¥ï¡¼¥ª¡ª²¿¤â¤«¤âÆú¿§¤Ë¸«¤¨¤ë¡ª");
 850 #else
 851                         msg_print("Oh, wow! Everything looks so cosmic now!");
 852 #endif
 853
 854                         /* Sniper */
 855                         if (p_ptr->concent) reset_concentration(TRUE);
 856
 857                         p_ptr->counter = FALSE;
 858                         notice = TRUE;
 859                 }
 860         }
 861
 862         /* Shut */
 863         else
 864         {
 865                 if (p_ptr->image)
 866                 {
 867 #ifdef JP
 868 msg_print("¤ä¤Ã¤È¤Ï¤Ã¤¤ê¤ÈÊª¤¬¸«¤¨¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£");
 869 #else
 870                         msg_print("You can see clearly again.");
 871 #endif
 872
 873                         notice = TRUE;
 874                 }
 875         }
 876
 877         /* Use the value */
 878         p_ptr->image = v;
 879
 880         /* Redraw status bar */
 881         p_ptr->redraw |= (PR_STATUS);
 882
 883         /* Nothing to notice */
 884         if (!notice) return (FALSE);
 885
 886         /* Disturb */
 887         if (disturb_state) disturb(0, 1);
 888
 889         /* Redraw map */
 890         p_ptr->redraw |= (PR_MAP);
 891
 892         /* Update the health bar */
 893         p_ptr->redraw |= (PR_HEALTH | PR_UHEALTH);
 894
 895         /* Update monsters */
 896         p_ptr->update |= (PU_MONSTERS);
 897
 898         /* Window stuff */
 899         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 900
 901         /* Handle stuff */
 902         handle_stuff();
 903
 904         /* Result */
 905         return (TRUE);
 906 }
 907
 908
 909 /*
 910  * Set "p_ptr->fast", notice observable changes
 911  */
 912 bool set_fast(int v, bool do_dec)
 913 {
 914         bool notice = FALSE;
 915
 916         /* Hack -- Force good values */
 917         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 918
 919         if (p_ptr->is_dead) return FALSE;
 920
 921         /* Open */
 922         if (v)
 923         {
 924                 if (p_ptr->fast && !do_dec)
 925                 {
 926                         if (p_ptr->fast > v) return FALSE;
 927                 }
 928                 else if (!IS_FAST() && !p_ptr->lightspeed)
 929                 {
 930 #ifdef JP
 931 msg_print("ÁÇÁá¤¯Æ°¤±¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡ª");
 932 #else
 933                         msg_print("You feel yourself moving much faster!");
 934 #endif
 935
 936                         notice = TRUE;
 937                         chg_virtue(V_PATIENCE, -1);
 938                         chg_virtue(V_DILIGENCE, 1);
 939                 }
 940         }
 941
 942         /* Shut */
 943         else
 944         {
 945                 if (p_ptr->fast && !p_ptr->lightspeed && !music_singing(MUSIC_SPEED) && !music_singing(MUSIC_SHERO))
 946                 {
 947 #ifdef JP
 948 msg_print("Æ°¤¤ÎÁÇÁá¤µ¤¬¤Ê¤¯¤Ê¤Ã¤¿¤è¤¦¤À¡£");
 949 #else
 950                         msg_print("You feel yourself slow down.");
 951 #endif
 952
 953                         notice = TRUE;
 954                 }
 955         }
 956
 957         /* Use the value */
 958         p_ptr->fast = v;
 959
 960         /* Nothing to notice */
 961         if (!notice) return (FALSE);
 962
 963         /* Disturb */
 964         if (disturb_state) disturb(0, 0);
 965
 966         /* Recalculate bonuses */
 967         p_ptr->update |= (PU_BONUS);
 968
 969         /* Handle stuff */
 970         handle_stuff();
 971
 972         /* Result */
 973         return (TRUE);
 974 }
 975
 976
 977 /*
 978  * Set "p_ptr->lightspeed", notice observable changes
 979  */
 980 bool set_lightspeed(int v, bool do_dec)
 981 {
 982         bool notice = FALSE;
 983
 984         /* Hack -- Force good values */
 985         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 986
 987         if (p_ptr->is_dead) return FALSE;
 988
 989         if (p_ptr->wild_mode) v = 0;
 990
 991         /* Open */
 992         if (v)
 993         {
 994                 if (p_ptr->lightspeed && !do_dec)
 995                 {
 996                         if (p_ptr->lightspeed > v) return FALSE;
 997                 }
 998                 else if (!p_ptr->lightspeed)
 999                 {
1000 #ifdef JP
1001 msg_print("Èó¾ï¤ËÁÇÁá¤¯Æ°¤±¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡ª");
1002 #else
1003                         msg_print("You feel yourself moving extremely faster!");
1004 #endif
1005
1006                         notice = TRUE;
1007                         chg_virtue(V_PATIENCE, -1);
1008                         chg_virtue(V_DILIGENCE, 1);
1009                 }
1010         }
1011
1012         /* Shut */
1013         else
1014         {
1015                 if (p_ptr->lightspeed)
1016                 {
1017 #ifdef JP
1018 msg_print("Æ°¤¤ÎÁÇÁá¤µ¤¬¤Ê¤¯¤Ê¤Ã¤¿¤è¤¦¤À¡£");
1019 #else
1020                         msg_print("You feel yourself slow down.");
1021 #endif
1022
1023                         notice = TRUE;
1024                 }
1025         }
1026
1027         /* Use the value */
1028         p_ptr->lightspeed = v;
1029
1030         /* Nothing to notice */
1031         if (!notice) return (FALSE);
1032
1033         /* Disturb */
1034         if (disturb_state) disturb(0, 0);
1035
1036         /* Recalculate bonuses */
1037         p_ptr->update |= (PU_BONUS);
1038
1039         /* Handle stuff */
1040         handle_stuff();
1041
1042         /* Result */
1043         return (TRUE);
1044 }
1045
1046
1047 /*
1048  * Set "p_ptr->slow", notice observable changes
1049  */
1050 bool set_slow(int v, bool do_dec)
1051 {
1052         bool notice = FALSE;
1053
1054         /* Hack -- Force good values */
1055         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1056
1057         if (p_ptr->is_dead) return FALSE;
1058
1059         /* Open */
1060         if (v)
1061         {
1062                 if (p_ptr->slow && !do_dec)
1063                 {
1064                         if (p_ptr->slow > v) return FALSE;
1065                 }
1066                 else if (!p_ptr->slow)
1067                 {
1068 #ifdef JP
1069 msg_print("ÂÎ¤ÎÆ°¤¤¬ÃÙ¤¯¤Ê¤Ã¤Æ¤·¤Þ¤Ã¤¿¡ª");
1070 #else
1071                         msg_print("You feel yourself moving slower!");
1072 #endif
1073
1074                         notice = TRUE;
1075                 }
1076         }
1077
1078         /* Shut */
1079         else
1080         {
1081                 if (p_ptr->slow)
1082                 {
1083 #ifdef JP
1084 msg_print("Æ°¤¤ÎÃÙ¤µ¤¬¤Ê¤¯¤Ê¤Ã¤¿¤è¤¦¤À¡£");
1085 #else
1086                         msg_print("You feel yourself speed up.");
1087 #endif
1088
1089                         notice = TRUE;
1090                 }
1091         }
1092
1093         /* Use the value */
1094         p_ptr->slow = v;
1095
1096         /* Nothing to notice */
1097         if (!notice) return (FALSE);
1098
1099         /* Disturb */
1100         if (disturb_state) disturb(0, 0);
1101
1102         /* Recalculate bonuses */
1103         p_ptr->update |= (PU_BONUS);
1104
1105         /* Handle stuff */
1106         handle_stuff();
1107
1108         /* Result */
1109         return (TRUE);
1110 }
1111
1112
1113 /*
1114  * Set "p_ptr->shield", notice observable changes
1115  */
1116 bool set_shield(int v, bool do_dec)
1117 {
1118         bool notice = FALSE;
1119
1120         /* Hack -- Force good values */
1121         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1122
1123         if (p_ptr->is_dead) return FALSE;
1124
1125         /* Open */
1126         if (v)
1127         {
1128                 if (p_ptr->shield && !do_dec)
1129                 {
1130                         if (p_ptr->shield > v) return FALSE;
1131                 }
1132                 else if (!p_ptr->shield)
1133                 {
1134 #ifdef JP
1135 msg_print("È©¤¬ÀÐ¤Ë¤Ê¤Ã¤¿¡£");
1136 #else
1137                         msg_print("Your skin turns to stone.");
1138 #endif
1139
1140                         notice = TRUE;
1141                 }
1142         }
1143
1144         /* Shut */
1145         else
1146         {
1147                 if (p_ptr->shield)
1148                 {
1149 #ifdef JP
1150 msg_print("È©¤¬¸µ¤ËÌá¤Ã¤¿¡£");
1151 #else
1152                         msg_print("Your skin returns to normal.");
1153 #endif
1154
1155                         notice = TRUE;
1156                 }
1157         }
1158
1159         /* Use the value */
1160         p_ptr->shield = v;
1161
1162         /* Redraw status bar */
1163         p_ptr->redraw |= (PR_STATUS);
1164
1165         /* Nothing to notice */
1166         if (!notice) return (FALSE);
1167
1168         /* Disturb */
1169         if (disturb_state) disturb(0, 0);
1170
1171         /* Recalculate bonuses */
1172         p_ptr->update |= (PU_BONUS);
1173
1174         /* Handle stuff */
1175         handle_stuff();
1176
1177         /* Result */
1178         return (TRUE);
1179 }
1180
1181
1182
1183 /*
1184  * Set "p_ptr->tsubureru", notice observable changes
1185  */
1186 bool set_tsubureru(int v, bool do_dec)
1187 {
1188         bool notice = FALSE;
1189
1190         /* Hack -- Force good values */
1191         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1192
1193         if (p_ptr->is_dead) return FALSE;
1194
1195         /* Open */
1196         if (v)
1197         {
1198                 if (p_ptr->tsubureru && !do_dec)
1199                 {
1200                         if (p_ptr->tsubureru > v) return FALSE;
1201                 }
1202                 else if (!p_ptr->tsubureru)
1203                 {
1204 #ifdef JP
1205 msg_print("²£¤Ë¿¤Ó¤¿¡£");
1206 #else
1207                         msg_print("Your body expands horizontally.");
1208 #endif
1209
1210                         notice = TRUE;
1211                 }
1212         }
1213
1214         /* Shut */
1215         else
1216         {
1217                 if (p_ptr->tsubureru)
1218                 {
1219 #ifdef JP
1220 msg_print("¤â¤¦²£¤Ë¿¤Ó¤Æ¤¤¤Ê¤¤¡£");
1221 #else
1222                         msg_print("Your body returns to normal.");
1223 #endif
1224
1225                         notice = TRUE;
1226                 }
1227         }
1228
1229         /* Use the value */
1230         p_ptr->tsubureru = v;
1231
1232         /* Redraw status bar */
1233         p_ptr->redraw |= (PR_STATUS);
1234
1235         /* Nothing to notice */
1236         if (!notice) return (FALSE);
1237
1238         /* Disturb */
1239         if (disturb_state) disturb(0, 0);
1240
1241         /* Recalculate bonuses */
1242         p_ptr->update |= (PU_BONUS);
1243
1244         /* Handle stuff */
1245         handle_stuff();
1246
1247         /* Result */
1248         return (TRUE);
1249 }
1250
1251
1252
1253 /*
1254  * Set "p_ptr->magicdef", notice observable changes
1255  */
1256 bool set_magicdef(int v, bool do_dec)
1257 {
1258         bool notice = FALSE;
1259
1260         /* Hack -- Force good values */
1261         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1262
1263         if (p_ptr->is_dead) return FALSE;
1264
1265         /* Open */
1266         if (v)
1267         {
1268                 if (p_ptr->magicdef && !do_dec)
1269                 {
1270                         if (p_ptr->magicdef > v) return FALSE;
1271                 }
1272                 else if (!p_ptr->magicdef)
1273                 {
1274 #ifdef JP
1275                         msg_print("ËâË¡¤ÎËÉ¸æÎÏ¤¬Áý¤·¤¿¤è¤¦¤Êµ¤¤¬¤¹¤ë¡£");
1276 #else
1277                         msg_print("You feel more resistant to magic.");
1278 #endif
1279
1280                         notice = TRUE;
1281                 }
1282         }
1283
1284         /* Shut */
1285         else
1286         {
1287                 if (p_ptr->magicdef)
1288                 {
1289 #ifdef JP
1290                         msg_print("ËâË¡¤ÎËÉ¸æÎÏ¤¬¸µ¤ËÌá¤Ã¤¿¡£");
1291 #else
1292                         msg_print("You feel less resistant to magic.");
1293 #endif
1294
1295                         notice = TRUE;
1296                 }
1297         }
1298
1299         /* Use the value */
1300         p_ptr->magicdef = v;
1301
1302         /* Redraw status bar */
1303         p_ptr->redraw |= (PR_STATUS);
1304
1305         /* Nothing to notice */
1306         if (!notice) return (FALSE);
1307
1308         /* Disturb */
1309         if (disturb_state) disturb(0, 0);
1310
1311         /* Recalculate bonuses */
1312         p_ptr->update |= (PU_BONUS);
1313
1314         /* Handle stuff */
1315         handle_stuff();
1316
1317         /* Result */
1318         return (TRUE);
1319 }
1320
1321
1322
1323 /*
1324  * Set "p_ptr->blessed", notice observable changes
1325  */
1326 bool set_blessed(int v, bool do_dec)
1327 {
1328         bool notice = FALSE;
1329
1330         /* Hack -- Force good values */
1331         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1332
1333         if (p_ptr->is_dead) return FALSE;
1334
1335         /* Open */
1336         if (v)
1337         {
1338                 if (p_ptr->blessed && !do_dec)
1339                 {
1340                         if (p_ptr->blessed > v) return FALSE;
1341                 }
1342                 else if (!IS_BLESSED())
1343                 {
1344 #ifdef JP
1345 msg_print("¹â·é¤Êµ¤Ê¬¤Ë¤Ê¤Ã¤¿¡ª");
1346 #else
1347                         msg_print("You feel righteous!");
1348 #endif
1349
1350                         notice = TRUE;
1351                 }
1352         }
1353
1354         /* Shut */
1355         else
1356         {
1357                 if (p_ptr->blessed && !music_singing(MUSIC_BLESS))
1358                 {
1359 #ifdef JP
1360 msg_print("¹â·é¤Êµ¤Ê¬¤¬¾Ã¤¨¼º¤»¤¿¡£");
1361 #else
1362                         msg_print("The prayer has expired.");
1363 #endif
1364
1365                         notice = TRUE;
1366                 }
1367         }
1368
1369         /* Use the value */
1370         p_ptr->blessed = v;
1371
1372         /* Redraw status bar */
1373         p_ptr->redraw |= (PR_STATUS);
1374
1375         /* Nothing to notice */
1376         if (!notice) return (FALSE);
1377
1378         /* Disturb */
1379         if (disturb_state) disturb(0, 0);
1380
1381         /* Recalculate bonuses */
1382         p_ptr->update |= (PU_BONUS);
1383
1384         /* Handle stuff */
1385         handle_stuff();
1386
1387         /* Result */
1388         return (TRUE);
1389 }
1390
1391
1392 /*
1393  * Set "p_ptr->hero", notice observable changes
1394  */
1395 bool set_hero(int v, bool do_dec)
1396 {
1397         bool notice = FALSE;
1398
1399         /* Hack -- Force good values */
1400         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1401
1402         if (p_ptr->is_dead) return FALSE;
1403
1404         /* Open */
1405         if (v)
1406         {
1407                 if (p_ptr->hero && !do_dec)
1408                 {
1409                         if (p_ptr->hero > v) return FALSE;
1410                 }
1411                 else if (!IS_HERO())
1412                 {
1413 #ifdef JP
1414 msg_print("¥Ò¡¼¥í¡¼¤Ë¤Ê¤Ã¤¿µ¤¤¬¤¹¤ë¡ª");
1415 #else
1416                         msg_print("You feel like a hero!");
1417 #endif
1418
1419                         notice = TRUE;
1420                 }
1421         }
1422
1423         /* Shut */
1424         else
1425         {
1426                 if (p_ptr->hero && !music_singing(MUSIC_HERO) && !music_singing(MUSIC_SHERO))
1427                 {
1428 #ifdef JP
1429 msg_print("¥Ò¡¼¥í¡¼¤Îµ¤Ê¬¤¬¾Ã¤¨¼º¤»¤¿¡£");
1430 #else
1431                         msg_print("The heroism wears off.");
1432 #endif
1433
1434                         notice = TRUE;
1435                 }
1436         }
1437
1438         /* Use the value */
1439         p_ptr->hero = v;
1440
1441         /* Redraw status bar */
1442         p_ptr->redraw |= (PR_STATUS);
1443
1444         /* Nothing to notice */
1445         if (!notice) return (FALSE);
1446
1447         /* Disturb */
1448         if (disturb_state) disturb(0, 0);
1449
1450         /* Recalculate bonuses */
1451         p_ptr->update |= (PU_BONUS);
1452
1453         /* Recalculate hitpoints */
1454         p_ptr->update |= (PU_HP);
1455
1456         /* Handle stuff */
1457         handle_stuff();
1458
1459         /* Result */
1460         return (TRUE);
1461 }
1462
1463
1464 /*
1465  * Set "p_ptr->shero", notice observable changes
1466  */
1467 bool set_shero(int v, bool do_dec)
1468 {
1469         bool notice = FALSE;
1470
1471         /* Hack -- Force good values */
1472         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1473
1474         if (p_ptr->is_dead) return FALSE;
1475
1476         if (p_ptr->pclass == CLASS_BERSERKER) v = 1;
1477         /* Open */
1478         if (v)
1479         {
1480                 if (p_ptr->shero && !do_dec)
1481                 {
1482                         if (p_ptr->shero > v) return FALSE;
1483                 }
1484                 else if (!p_ptr->shero)
1485                 {
1486 #ifdef JP
1487 msg_print("»¦Ù¤¥Þ¥·¡¼¥ó¤Ë¤Ê¤Ã¤¿µ¤¤¬¤¹¤ë¡ª");
1488 #else
1489                         msg_print("You feel like a killing machine!");
1490 #endif
1491
1492                         notice = TRUE;
1493                 }
1494         }
1495
1496         /* Shut */
1497         else
1498         {
1499                 if (p_ptr->shero)
1500                 {
1501 #ifdef JP
1502 msg_print("ÌîÈÚ¤Êµ¤»ý¤Á¤¬¾Ã¤¨¼º¤»¤¿¡£");
1503 #else
1504                         msg_print("You feel less Berserk.");
1505 #endif
1506
1507                         notice = TRUE;
1508                 }
1509         }
1510
1511         /* Use the value */
1512         p_ptr->shero = v;
1513
1514         /* Redraw status bar */
1515         p_ptr->redraw |= (PR_STATUS);
1516
1517         /* Nothing to notice */
1518         if (!notice) return (FALSE);
1519
1520         /* Disturb */
1521         if (disturb_state) disturb(0, 0);
1522
1523         /* Recalculate bonuses */
1524         p_ptr->update |= (PU_BONUS);
1525
1526         /* Recalculate hitpoints */
1527         p_ptr->update |= (PU_HP);
1528
1529         /* Handle stuff */
1530         handle_stuff();
1531
1532         /* Result */
1533         return (TRUE);
1534 }
1535
1536
1537 /*
1538  * Set "p_ptr->protevil", notice observable changes
1539  */
1540 bool set_protevil(int v, bool do_dec)
1541 {
1542         bool notice = FALSE;
1543
1544         /* Hack -- Force good values */
1545         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1546
1547         if (p_ptr->is_dead) return FALSE;
1548
1549         /* Open */
1550         if (v)
1551         {
1552                 if (p_ptr->protevil && !do_dec)
1553                 {
1554                         if (p_ptr->protevil > v) return FALSE;
1555                 }
1556                 else if (!p_ptr->protevil)
1557                 {
1558 #ifdef JP
1559 msg_print("¼Ù°¤Ê¤ëÂ¸ºß¤«¤é¼é¤é¤ì¤Æ¤¤¤ë¤è¤¦¤Ê´¶¤¸¤¬¤¹¤ë¡ª");
1560 #else
1561                         msg_print("You feel safe from evil!");
1562 #endif
1563
1564                         notice = TRUE;
1565                 }
1566         }
1567
1568         /* Shut */
1569         else
1570         {
1571                 if (p_ptr->protevil)
1572                 {
1573 #ifdef JP
1574 msg_print("¼Ù°¤Ê¤ëÂ¸ºß¤«¤é¼é¤é¤ì¤Æ¤¤¤ë´¶¤¸¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
1575 #else
1576                         msg_print("You no longer feel safe from evil.");
1577 #endif
1578
1579                         notice = TRUE;
1580                 }
1581         }
1582
1583         /* Use the value */
1584         p_ptr->protevil = v;
1585
1586         /* Redraw status bar */
1587         p_ptr->redraw |= (PR_STATUS);
1588
1589         /* Nothing to notice */
1590         if (!notice) return (FALSE);
1591
1592         /* Disturb */
1593         if (disturb_state) disturb(0, 0);
1594
1595         /* Handle stuff */
1596         handle_stuff();
1597
1598         /* Result */
1599         return (TRUE);
1600 }
1601
1602 /*
1603  * Set "p_ptr->wraith_form", notice observable changes
1604  */
1605 bool set_wraith_form(int v, bool do_dec)
1606 {
1607         bool notice = FALSE;
1608
1609         /* Hack -- Force good values */
1610         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1611
1612         if (p_ptr->is_dead) return FALSE;
1613
1614         /* Open */
1615         if (v)
1616         {
1617                 if (p_ptr->wraith_form && !do_dec)
1618                 {
1619                         if (p_ptr->wraith_form > v) return FALSE;
1620                 }
1621                 else if (!p_ptr->wraith_form)
1622                 {
1623 #ifdef JP
1624 msg_print("Êª¼Á³¦¤òÎ¥¤ì¤ÆÍ©µ´¤Î¤è¤¦¤ÊÂ¸ºß¤Ë¤Ê¤Ã¤¿¡ª");
1625 #else
1626                         msg_print("You leave the physical world and turn into a wraith-being!");
1627 #endif
1628
1629                         notice = TRUE;
1630
1631                         chg_virtue(V_UNLIFE, 3);
1632                         chg_virtue(V_HONOUR, -2);
1633                         chg_virtue(V_SACRIFICE, -2);
1634                         chg_virtue(V_VALOUR, -5);
1635
1636                         /* Redraw map */
1637                         p_ptr->redraw |= (PR_MAP);
1638
1639                         /* Update monsters */
1640                         p_ptr->update |= (PU_MONSTERS);
1641
1642                         /* Window stuff */
1643                         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1644                 }
1645         }
1646
1647         /* Shut */
1648         else
1649         {
1650                 if (p_ptr->wraith_form)
1651                 {
1652 #ifdef JP
1653 msg_print("ÉÔÆ©ÌÀ¤Ë¤Ê¤Ã¤¿´¶¤¸¤¬¤¹¤ë¡£");
1654 #else
1655                         msg_print("You feel opaque.");
1656 #endif
1657
1658                         notice = TRUE;
1659
1660                         /* Redraw map */
1661                         p_ptr->redraw |= (PR_MAP);
1662
1663                         /* Update monsters */
1664                         p_ptr->update |= (PU_MONSTERS);
1665
1666                         /* Window stuff */
1667                         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1668                 }
1669         }
1670
1671         /* Use the value */
1672         p_ptr->wraith_form = v;
1673
1674         /* Redraw status bar */
1675         p_ptr->redraw |= (PR_STATUS);
1676
1677         /* Nothing to notice */
1678         if (!notice) return (FALSE);
1679
1680         /* Disturb */
1681         if (disturb_state) disturb(0, 0);
1682
1683         /* Recalculate bonuses */
1684         p_ptr->update |= (PU_BONUS);
1685
1686         /* Handle stuff */
1687         handle_stuff();
1688
1689         /* Result */
1690         return (TRUE);
1691
1692 }
1693
1694
1695 /*
1696  * Set "p_ptr->invuln", notice observable changes
1697  */
1698 bool set_invuln(int v, bool do_dec)
1699 {
1700         bool notice = FALSE;
1701
1702         /* Hack -- Force good values */
1703         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1704
1705         if (p_ptr->is_dead) return FALSE;
1706
1707         /* Open */
1708         if (v)
1709         {
1710                 if (p_ptr->invuln && !do_dec)
1711                 {
1712                         if (p_ptr->invuln > v) return FALSE;
1713                 }
1714                 else if (!IS_INVULN())
1715                 {
1716 #ifdef JP
1717 msg_print("ÌµÅ¨¤À¡ª");
1718 #else
1719                         msg_print("Invulnerability!");
1720 #endif
1721
1722                         notice = TRUE;
1723
1724                         chg_virtue(V_UNLIFE, -2);
1725                         chg_virtue(V_HONOUR, -2);
1726                         chg_virtue(V_SACRIFICE, -3);
1727                         chg_virtue(V_VALOUR, -5);
1728
1729                         /* Redraw map */
1730                         p_ptr->redraw |= (PR_MAP);
1731
1732                         /* Update monsters */
1733                         p_ptr->update |= (PU_MONSTERS);
1734
1735                         /* Window stuff */
1736                         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1737                 }
1738         }
1739
1740         /* Shut */
1741         else
1742         {
1743                 if (p_ptr->invuln && !music_singing(MUSIC_INVULN))
1744                 {
1745 #ifdef JP
1746 msg_print("ÌµÅ¨¤Ç¤Ï¤Ê¤¯¤Ê¤Ã¤¿¡£");
1747 #else
1748                         msg_print("The invulnerability wears off.");
1749 #endif
1750
1751                         notice = TRUE;
1752
1753                         /* Redraw map */
1754                         p_ptr->redraw |= (PR_MAP);
1755
1756                         /* Update monsters */
1757                         p_ptr->update |= (PU_MONSTERS);
1758
1759                         /* Window stuff */
1760                         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1761
1762                         p_ptr->energy_need += ENERGY_NEED();
1763                 }
1764         }
1765
1766         /* Use the value */
1767         p_ptr->invuln = v;
1768
1769         /* Redraw status bar */
1770         p_ptr->redraw |= (PR_STATUS);
1771
1772         /* Nothing to notice */
1773         if (!notice) return (FALSE);
1774
1775         /* Disturb */
1776         if (disturb_state) disturb(0, 0);
1777
1778         /* Recalculate bonuses */
1779         p_ptr->update |= (PU_BONUS);
1780
1781         /* Handle stuff */
1782         handle_stuff();
1783
1784         /* Result */
1785         return (TRUE);
1786 }
1787
1788
1789 /*
1790  * Set "p_ptr->tim_esp", notice observable changes
1791  */
1792 bool set_tim_esp(int v, bool do_dec)
1793 {
1794         bool notice = FALSE;
1795
1796         /* Hack -- Force good values */
1797         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1798
1799         if (p_ptr->is_dead) return FALSE;
1800
1801         /* Open */
1802         if (v)
1803         {
1804                 if (p_ptr->tim_esp && !do_dec)
1805                 {
1806                         if (p_ptr->tim_esp > v) return FALSE;
1807                 }
1808                 else if (!IS_TIM_ESP())
1809                 {
1810 #ifdef JP
1811 msg_print("°Õ¼±¤¬¹¤¬¤Ã¤¿µ¤¤¬¤¹¤ë¡ª");
1812 #else
1813                         msg_print("You feel your consciousness expand!");
1814 #endif
1815
1816                         notice = TRUE;
1817                 }
1818         }
1819
1820         /* Shut */
1821         else
1822         {
1823                 if (p_ptr->tim_esp && !music_singing(MUSIC_MIND))
1824                 {
1825 #ifdef JP
1826 msg_print("°Õ¼±¤Ï¸µ¤ËÌá¤Ã¤¿¡£");
1827 #else
1828                         msg_print("Your consciousness contracts again.");
1829 #endif
1830
1831                         notice = TRUE;
1832                 }
1833         }
1834
1835         /* Use the value */
1836         p_ptr->tim_esp = v;
1837
1838         /* Redraw status bar */
1839         p_ptr->redraw |= (PR_STATUS);
1840
1841         /* Nothing to notice */
1842         if (!notice) return (FALSE);
1843
1844         /* Disturb */
1845         if (disturb_state) disturb(0, 0);
1846
1847         /* Recalculate bonuses */
1848         p_ptr->update |= (PU_BONUS);
1849
1850         /* Update the monsters */
1851         p_ptr->update |= (PU_MONSTERS);
1852
1853         /* Handle stuff */
1854         handle_stuff();
1855
1856         /* Result */
1857         return (TRUE);
1858 }
1859
1860
1861 /*
1862  * Set "p_ptr->tim_invis", notice observable changes
1863  */
1864 bool set_tim_invis(int v, bool do_dec)
1865 {
1866         bool notice = FALSE;
1867
1868         /* Hack -- Force good values */
1869         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1870
1871         if (p_ptr->is_dead) return FALSE;
1872
1873         /* Open */
1874         if (v)
1875         {
1876                 if (p_ptr->tim_invis && !do_dec)
1877                 {
1878                         if (p_ptr->tim_invis > v) return FALSE;
1879                 }
1880                 else if (!p_ptr->tim_invis)
1881                 {
1882 #ifdef JP
1883 msg_print("ÌÜ¤¬Èó¾ï¤ËÉÒ´¶¤Ë¤Ê¤Ã¤¿µ¤¤¬¤¹¤ë¡ª");
1884 #else
1885                         msg_print("Your eyes feel very sensitive!");
1886 #endif
1887
1888                         notice = TRUE;
1889                 }
1890         }
1891
1892         /* Shut */
1893         else
1894         {
1895                 if (p_ptr->tim_invis)
1896                 {
1897 #ifdef JP
1898 msg_print("ÌÜ¤ÎÉÒ´¶¤µ¤¬¤Ê¤¯¤Ê¤Ã¤¿¤è¤¦¤À¡£");
1899 #else
1900                         msg_print("Your eyes feel less sensitive.");
1901 #endif
1902
1903                         notice = TRUE;
1904                 }
1905         }
1906
1907         /* Use the value */
1908         p_ptr->tim_invis = v;
1909
1910         /* Redraw status bar */
1911         p_ptr->redraw |= (PR_STATUS);
1912
1913         /* Nothing to notice */
1914         if (!notice) return (FALSE);
1915
1916         /* Disturb */
1917         if (disturb_state) disturb(0, 0);
1918
1919         /* Recalculate bonuses */
1920         p_ptr->update |= (PU_BONUS);
1921
1922         /* Update the monsters */
1923         p_ptr->update |= (PU_MONSTERS);
1924
1925         /* Handle stuff */
1926         handle_stuff();
1927
1928         /* Result */
1929         return (TRUE);
1930 }
1931
1932
1933 /*
1934  * Set "p_ptr->tim_infra", notice observable changes
1935  */
1936 bool set_tim_infra(int v, bool do_dec)
1937 {
1938         bool notice = FALSE;
1939
1940         /* Hack -- Force good values */
1941         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1942
1943         if (p_ptr->is_dead) return FALSE;
1944
1945         /* Open */
1946         if (v)
1947         {
1948                 if (p_ptr->tim_infra && !do_dec)
1949                 {
1950                         if (p_ptr->tim_infra > v) return FALSE;
1951                 }
1952                 else if (!p_ptr->tim_infra)
1953                 {
1954 #ifdef JP
1955 msg_print("ÌÜ¤¬¥é¥ó¥é¥ó¤Èµ±¤»Ï¤á¤¿¡ª");
1956 #else
1957                         msg_print("Your eyes begin to tingle!");
1958 #endif
1959
1960                         notice = TRUE;
1961                 }
1962         }
1963
1964         /* Shut */
1965         else
1966         {
1967                 if (p_ptr->tim_infra)
1968                 {
1969 #ifdef JP
1970 msg_print("ÌÜ¤Îµ±¤¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
1971 #else
1972                         msg_print("Your eyes stop tingling.");
1973 #endif
1974
1975                         notice = TRUE;
1976                 }
1977         }
1978
1979         /* Use the value */
1980         p_ptr->tim_infra = v;
1981
1982         /* Redraw status bar */
1983         p_ptr->redraw |= (PR_STATUS);
1984
1985         /* Nothing to notice */
1986         if (!notice) return (FALSE);
1987
1988         /* Disturb */
1989         if (disturb_state) disturb(0, 0);
1990
1991         /* Recalculate bonuses */
1992         p_ptr->update |= (PU_BONUS);
1993
1994         /* Update the monsters */
1995         p_ptr->update |= (PU_MONSTERS);
1996
1997         /* Handle stuff */
1998         handle_stuff();
1999
2000         /* Result */
2001         return (TRUE);
2002 }
2003
2004
2005 /*
2006  * Set "p_ptr->tim_regen", notice observable changes
2007  */
2008 bool set_tim_regen(int v, bool do_dec)
2009 {
2010         bool notice = FALSE;
2011
2012         /* Hack -- Force good values */
2013         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2014
2015         if (p_ptr->is_dead) return FALSE;
2016
2017         /* Open */
2018         if (v)
2019         {
2020                 if (p_ptr->tim_regen && !do_dec)
2021                 {
2022                         if (p_ptr->tim_regen > v) return FALSE;
2023                 }
2024                 else if (!p_ptr->tim_regen)
2025                 {
2026 #ifdef JP
2027 msg_print("²óÉüÎÏ¤¬¾å¤¬¤Ã¤¿¡ª");
2028 #else
2029                         msg_print("You feel yourself regenerating quickly!");
2030 #endif
2031
2032                         notice = TRUE;
2033                 }
2034         }
2035
2036         /* Shut */
2037         else
2038         {
2039                 if (p_ptr->tim_regen)
2040                 {
2041 #ifdef JP
2042 msg_print("ÁÇÁá¤¯²óÉü¤¹¤ë´¶¤¸¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
2043 #else
2044                         msg_print("You feel yourself regenerating slowly.");
2045 #endif
2046
2047                         notice = TRUE;
2048                 }
2049         }
2050
2051         /* Use the value */
2052         p_ptr->tim_regen = v;
2053
2054         /* Redraw status bar */
2055         p_ptr->redraw |= (PR_STATUS);
2056
2057         /* Nothing to notice */
2058         if (!notice) return (FALSE);
2059
2060         /* Disturb */
2061         if (disturb_state) disturb(0, 0);
2062
2063         /* Recalculate bonuses */
2064         p_ptr->update |= (PU_BONUS);
2065
2066         /* Handle stuff */
2067         handle_stuff();
2068
2069         /* Result */
2070         return (TRUE);
2071 }
2072
2073
2074 /*
2075  * Set "p_ptr->tim_stealth", notice observable changes
2076  */
2077 bool set_tim_stealth(int v, bool do_dec)
2078 {
2079         bool notice = FALSE;
2080
2081         /* Hack -- Force good values */
2082         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2083
2084         if (p_ptr->is_dead) return FALSE;
2085
2086         /* Open */
2087         if (v)
2088         {
2089                 if (p_ptr->tim_stealth && !do_dec)
2090                 {
2091                         if (p_ptr->tim_stealth > v) return FALSE;
2092                 }
2093                 else if (!IS_TIM_STEALTH())
2094                 {
2095 #ifdef JP
2096 msg_print("Â²»¤¬¾®¤µ¤¯¤Ê¤Ã¤¿¡ª");
2097 #else
2098                         msg_print("You begin to walk silently!");
2099 #endif
2100
2101                         notice = TRUE;
2102                 }
2103         }
2104
2105         /* Shut */
2106         else
2107         {
2108                 if (p_ptr->tim_stealth && !music_singing(MUSIC_STEALTH))
2109                 {
2110 #ifdef JP
2111 msg_print("Â²»¤¬Âç¤¤¯¤Ê¤Ã¤¿¡£");
2112 #else
2113                         msg_print("You no longer walk silently.");
2114 #endif
2115
2116                         notice = TRUE;
2117                 }
2118         }
2119
2120         /* Use the value */
2121         p_ptr->tim_stealth = v;
2122
2123         /* Redraw status bar */
2124         p_ptr->redraw |= (PR_STATUS);
2125
2126         /* Nothing to notice */
2127         if (!notice) return (FALSE);
2128
2129         /* Disturb */
2130         if (disturb_state) disturb(0, 0);
2131
2132         /* Recalculate bonuses */
2133         p_ptr->update |= (PU_BONUS);
2134
2135         /* Handle stuff */
2136         handle_stuff();
2137
2138         /* Result */
2139         return (TRUE);
2140 }
2141
2142
2143 bool set_superstealth(bool set)
2144 {
2145         bool notice = FALSE;
2146
2147         if (p_ptr->is_dead) return FALSE;
2148
2149         /* Open */
2150         if (set)
2151         {
2152                 if (!(p_ptr->special_defense & NINJA_S_STEALTH))
2153                 {
2154                         if (cave[py][px].info & CAVE_MNLT)
2155                         {
2156 #ifdef JP
2157                                 msg_print("Å¨¤ÎÌÜ¤«¤éÇö¤¤±Æ¤ÎÃæ¤ËÊ¤¤¤±£¤µ¤ì¤¿¡£");
2158 #else
2159                                 msg_print("You are mantled in weak shadow from ordinary eyes.");
2160 #endif
2161                                 p_ptr->monlite = p_ptr->old_monlite = TRUE;
2162                         }
2163                         else
2164                         {
2165 #ifdef JP
2166                                 msg_print("Å¨¤ÎÌÜ¤«¤é±Æ¤ÎÃæ¤ËÊ¤¤¤±£¤µ¤ì¤¿¡ª");
2167 #else
2168                                 msg_print("You are mantled in shadow from ordinary eyes!");
2169 #endif
2170                                 p_ptr->monlite = p_ptr->old_monlite = FALSE;
2171                         }
2172
2173                         notice = TRUE;
2174
2175                         /* Use the value */
2176                         p_ptr->special_defense |= NINJA_S_STEALTH;
2177                 }
2178         }
2179
2180         /* Shut */
2181         else
2182         {
2183                 if (p_ptr->special_defense & NINJA_S_STEALTH)
2184                 {
2185 #ifdef JP
2186                         msg_print("ºÆ¤ÓÅ¨¤ÎÌÜ¤Ë¤µ¤é¤µ¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£");
2187 #else
2188                         msg_print("You are exposed to common sight once more.");
2189 #endif
2190
2191                         notice = TRUE;
2192
2193                         /* Use the value */
2194                         p_ptr->special_defense &= ~(NINJA_S_STEALTH);
2195                 }
2196         }
2197
2198         /* Nothing to notice */
2199         if (!notice) return (FALSE);
2200
2201         /* Redraw status bar */
2202         p_ptr->redraw |= (PR_STATUS);
2203
2204         /* Disturb */
2205         if (disturb_state) disturb(0, 0);
2206
2207         /* Result */
2208         return (TRUE);
2209 }
2210
2211
2212 /*
2213  * Set "p_ptr->tim_levitation", notice observable changes
2214  */
2215 bool set_tim_levitation(int v, bool do_dec)
2216 {
2217         bool notice = FALSE;
2218
2219         /* Hack -- Force good values */
2220         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2221
2222         if (p_ptr->is_dead) return FALSE;
2223
2224         /* Open */
2225         if (v)
2226         {
2227                 if (p_ptr->tim_levitation && !do_dec)
2228                 {
2229                         if (p_ptr->tim_levitation > v) return FALSE;
2230                 }
2231                 else if (!p_ptr->tim_levitation)
2232                 {
2233 #ifdef JP
2234 msg_print("ÂÎ¤¬Ãè¤ËÉâ¤»Ï¤á¤¿¡£");
2235 #else
2236                         msg_print("You begin to fly!");
2237 #endif
2238
2239                         notice = TRUE;
2240                 }
2241         }
2242
2243         /* Shut */
2244         else
2245         {
2246                 if (p_ptr->tim_levitation)
2247                 {
2248 #ifdef JP
2249 msg_print("¤â¤¦Ãè¤ËÉâ¤«¤Ù¤Ê¤¯¤Ê¤Ã¤¿¡£");
2250 #else
2251                         msg_print("You stop flying.");
2252 #endif
2253
2254                         notice = TRUE;
2255                 }
2256         }
2257
2258         /* Use the value */
2259         p_ptr->tim_levitation = v;
2260
2261         /* Redraw status bar */
2262         p_ptr->redraw |= (PR_STATUS);
2263
2264         /* Nothing to notice */
2265         if (!notice) return (FALSE);
2266
2267         /* Disturb */
2268         if (disturb_state) disturb(0, 0);
2269
2270         /* Recalculate bonuses */
2271         p_ptr->update |= (PU_BONUS);
2272
2273         /* Handle stuff */
2274         handle_stuff();
2275
2276         /* Result */
2277         return (TRUE);
2278 }
2279
2280
2281 /*
2282  * Set "p_ptr->tim_sh_touki", notice observable changes
2283  */
2284 bool set_tim_sh_touki(int v, bool do_dec)
2285 {
2286         bool notice = FALSE;
2287
2288         /* Hack -- Force good values */
2289         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2290
2291         if (p_ptr->is_dead) return FALSE;
2292
2293         /* Open */
2294         if (v)
2295         {
2296                 if (p_ptr->tim_sh_touki && !do_dec)
2297                 {
2298                         if (p_ptr->tim_sh_touki > v) return FALSE;
2299                 }
2300                 else if (!p_ptr->tim_sh_touki)
2301                 {
2302 #ifdef JP
2303 msg_print("ÂÎ¤¬Æ®µ¤¤Î¥ª¡¼¥é¤ÇÊ¤¤ï¤ì¤¿¡£");
2304 #else
2305                         msg_print("You have enveloped by the aura of the Force!");
2306 #endif
2307
2308                         notice = TRUE;
2309                 }
2310         }
2311
2312         /* Shut */
2313         else
2314         {
2315                 if (p_ptr->tim_sh_touki)
2316                 {
2317 #ifdef JP
2318 msg_print("Æ®µ¤¤¬¾Ã¤¨¤¿¡£");
2319 #else
2320                         msg_print("Aura of the Force disappeared.");
2321 #endif
2322
2323                         notice = TRUE;
2324                 }
2325         }
2326
2327         /* Use the value */
2328         p_ptr->tim_sh_touki = v;
2329
2330         /* Redraw status bar */
2331         p_ptr->redraw |= (PR_STATUS);
2332
2333         /* Nothing to notice */
2334         if (!notice) return (FALSE);
2335
2336         /* Disturb */
2337         if (disturb_state) disturb(0, 0);
2338
2339         /* Handle stuff */
2340         handle_stuff();
2341
2342         /* Result */
2343         return (TRUE);
2344 }
2345
2346
2347 /*
2348  * Set "p_ptr->tim_sh_fire", notice observable changes
2349  */
2350 bool set_tim_sh_fire(int v, bool do_dec)
2351 {
2352         bool notice = FALSE;
2353
2354         /* Hack -- Force good values */
2355         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2356
2357         if (p_ptr->is_dead) return FALSE;
2358
2359         /* Open */
2360         if (v)
2361         {
2362                 if (p_ptr->tim_sh_fire && !do_dec)
2363                 {
2364                         if (p_ptr->tim_sh_fire > v) return FALSE;
2365                 }
2366                 else if (!p_ptr->tim_sh_fire)
2367                 {
2368 #ifdef JP
2369 msg_print("ÂÎ¤¬±ê¤Î¥ª¡¼¥é¤ÇÊ¤¤ï¤ì¤¿¡£");
2370 #else
2371                         msg_print("You have enveloped by fiery aura!");
2372 #endif
2373
2374                         notice = TRUE;
2375                 }
2376         }
2377
2378         /* Shut */
2379         else
2380         {
2381                 if (p_ptr->tim_sh_fire)
2382                 {
2383 #ifdef JP
2384 msg_print("±ê¤Î¥ª¡¼¥é¤¬¾Ã¤¨¤¿¡£");
2385 #else
2386                         msg_print("Fiery aura disappeared.");
2387 #endif
2388
2389                         notice = TRUE;
2390                 }
2391         }
2392
2393         /* Use the value */
2394         p_ptr->tim_sh_fire = v;
2395
2396         /* Redraw status bar */
2397         p_ptr->redraw |= (PR_STATUS);
2398
2399         /* Nothing to notice */
2400         if (!notice) return (FALSE);
2401
2402         /* Disturb */
2403         if (disturb_state) disturb(0, 0);
2404
2405         /* Recalculate bonuses */
2406         p_ptr->update |= (PU_BONUS);
2407
2408         /* Handle stuff */
2409         handle_stuff();
2410
2411         /* Result */
2412         return (TRUE);
2413 }
2414
2415
2416 /*
2417  * Set "p_ptr->tim_sh_holy", notice observable changes
2418  */
2419 bool set_tim_sh_holy(int v, bool do_dec)
2420 {
2421         bool notice = FALSE;
2422
2423         /* Hack -- Force good values */
2424         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2425
2426         if (p_ptr->is_dead) return FALSE;
2427
2428         /* Open */
2429         if (v)
2430         {
2431                 if (p_ptr->tim_sh_holy && !do_dec)
2432                 {
2433                         if (p_ptr->tim_sh_holy > v) return FALSE;
2434                 }
2435                 else if (!p_ptr->tim_sh_holy)
2436                 {
2437 #ifdef JP
2438 msg_print("ÂÎ¤¬À»¤Ê¤ë¥ª¡¼¥é¤ÇÊ¤¤ï¤ì¤¿¡£");
2439 #else
2440                         msg_print("You have enveloped by holy aura!");
2441 #endif
2442
2443                         notice = TRUE;
2444                 }
2445         }
2446
2447         /* Shut */
2448         else
2449         {
2450                 if (p_ptr->tim_sh_holy)
2451                 {
2452 #ifdef JP
2453 msg_print("À»¤Ê¤ë¥ª¡¼¥é¤¬¾Ã¤¨¤¿¡£");
2454 #else
2455                         msg_print("Holy aura disappeared.");
2456 #endif
2457
2458                         notice = TRUE;
2459                 }
2460         }
2461
2462         /* Use the value */
2463         p_ptr->tim_sh_holy = v;
2464
2465         /* Redraw status bar */
2466         p_ptr->redraw |= (PR_STATUS);
2467
2468         /* Nothing to notice */
2469         if (!notice) return (FALSE);
2470
2471         /* Disturb */
2472         if (disturb_state) disturb(0, 0);
2473
2474         /* Recalculate bonuses */
2475         p_ptr->update |= (PU_BONUS);
2476
2477         /* Handle stuff */
2478         handle_stuff();
2479
2480         /* Result */
2481         return (TRUE);
2482 }
2483
2484
2485
2486 /*
2487  * Set "p_ptr->tim_eyeeye", notice observable changes
2488  */
2489 bool set_tim_eyeeye(int v, bool do_dec)
2490 {
2491         bool notice = FALSE;
2492
2493         /* Hack -- Force good values */
2494         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2495
2496         if (p_ptr->is_dead) return FALSE;
2497
2498         /* Open */
2499         if (v)
2500         {
2501                 if (p_ptr->tim_eyeeye && !do_dec)
2502                 {
2503                         if (p_ptr->tim_eyeeye > v) return FALSE;
2504                 }
2505                 else if (!p_ptr->tim_eyeeye)
2506                 {
2507 #ifdef JP
2508 msg_print("Ë¡¤Î¼é¤ê¼ê¤Ë¤Ê¤Ã¤¿µ¤¤¬¤·¤¿¡ª");
2509 #else
2510                         msg_print("You feel like a keeper of commandments!");
2511 #endif
2512
2513                         notice = TRUE;
2514                 }
2515         }
2516
2517         /* Shut */
2518         else
2519         {
2520                 if (p_ptr->tim_eyeeye)
2521                 {
2522 #ifdef JP
2523 msg_print("Ä¨È³¤ò¼¹¹Ô¤¹¤ë¤³¤È¤¬¤Ç¤¤Ê¤¯¤Ê¤Ã¤¿¡£");
2524 #else
2525                         msg_print("You no longer feel like a keeper.");
2526 #endif
2527
2528                         notice = TRUE;
2529                 }
2530         }
2531
2532         /* Use the value */
2533         p_ptr->tim_eyeeye = v;
2534
2535         /* Redraw status bar */
2536         p_ptr->redraw |= (PR_STATUS);
2537
2538         /* Nothing to notice */
2539         if (!notice) return (FALSE);
2540
2541         /* Disturb */
2542         if (disturb_state) disturb(0, 0);
2543
2544         /* Recalculate bonuses */
2545         p_ptr->update |= (PU_BONUS);
2546
2547         /* Handle stuff */
2548         handle_stuff();
2549
2550         /* Result */
2551         return (TRUE);
2552 }
2553
2554
2555
2556 /*
2557  * Set "p_ptr->resist_magic", notice observable changes
2558  */
2559 bool set_resist_magic(int v, bool do_dec)
2560 {
2561         bool notice = FALSE;
2562
2563         /* Hack -- Force good values */
2564         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2565
2566         if (p_ptr->is_dead) return FALSE;
2567
2568         /* Open */
2569         if (v)
2570         {
2571                 if (p_ptr->resist_magic && !do_dec)
2572                 {
2573                         if (p_ptr->resist_magic > v) return FALSE;
2574                 }
2575                 else if (!p_ptr->resist_magic)
2576                 {
2577 #ifdef JP
2578 msg_print("ËâË¡¤Ø¤ÎÂÑÀ¤¬¤Ä¤¤¤¿¡£");
2579 #else
2580                         msg_print("You have been protected from magic!");
2581 #endif
2582
2583                         notice = TRUE;
2584                 }
2585         }
2586
2587         /* Shut */
2588         else
2589         {
2590                 if (p_ptr->resist_magic)
2591                 {
2592 #ifdef JP
2593 msg_print("ËâË¡¤Ë¼å¤¯¤Ê¤Ã¤¿¡£");
2594 #else
2595 msg_print("You are no longer protected from magic.");
2596 #endif
2597
2598                         notice = TRUE;
2599                 }
2600         }
2601
2602         /* Use the value */
2603         p_ptr->resist_magic = v;
2604
2605         /* Redraw status bar */
2606         p_ptr->redraw |= (PR_STATUS);
2607
2608         /* Nothing to notice */
2609         if (!notice) return (FALSE);
2610
2611         /* Disturb */
2612         if (disturb_state) disturb(0, 0);
2613
2614         /* Recalculate bonuses */
2615         p_ptr->update |= (PU_BONUS);
2616
2617         /* Handle stuff */
2618         handle_stuff();
2619
2620         /* Result */
2621         return (TRUE);
2622 }
2623
2624
2625 /*
2626  * Set "p_ptr->tim_reflect", notice observable changes
2627  */
2628 bool set_tim_reflect(int v, bool do_dec)
2629 {
2630         bool notice = FALSE;
2631
2632         /* Hack -- Force good values */
2633         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2634
2635         if (p_ptr->is_dead) return FALSE;
2636
2637         /* Open */
2638         if (v)
2639         {
2640                 if (p_ptr->tim_reflect && !do_dec)
2641                 {
2642                         if (p_ptr->tim_reflect > v) return FALSE;
2643                 }
2644                 else if (!p_ptr->tim_reflect)
2645                 {
2646 #ifdef JP
2647 msg_print("ÂÎ¤ÎÉ½ÌÌ¤¬³ê¤«¤Ë¤Ê¤Ã¤¿µ¤¤¬¤¹¤ë¡£");
2648 #else
2649                         msg_print("Your body becames smooth.");
2650 #endif
2651
2652                         notice = TRUE;
2653                 }
2654         }
2655
2656         /* Shut */
2657         else
2658         {
2659                 if (p_ptr->tim_reflect)
2660                 {
2661 #ifdef JP
2662 msg_print("ÂÎ¤ÎÉ½ÌÌ¤¬³ê¤«¤Ç¤Ê¤¯¤Ê¤Ã¤¿¡£");
2663 #else
2664                         msg_print("Your body is no longer smooth.");
2665 #endif
2666
2667                         notice = TRUE;
2668                 }
2669         }
2670
2671         /* Use the value */
2672         p_ptr->tim_reflect = v;
2673
2674         /* Redraw status bar */
2675         p_ptr->redraw |= (PR_STATUS);
2676
2677         /* Nothing to notice */
2678         if (!notice) return (FALSE);
2679
2680         /* Disturb */
2681         if (disturb_state) disturb(0, 0);
2682
2683         /* Recalculate bonuses */
2684         p_ptr->update |= (PU_BONUS);
2685
2686         /* Handle stuff */
2687         handle_stuff();
2688
2689         /* Result */
2690         return (TRUE);
2691 }
2692
2693
2694 /*
2695  * Set "p_ptr->multishadow", notice observable changes
2696  */
2697 bool set_multishadow(int v, bool do_dec)
2698 {
2699         bool notice = FALSE;
2700
2701         /* Hack -- Force good values */
2702         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2703
2704         if (p_ptr->is_dead) return FALSE;
2705
2706         /* Open */
2707         if (v)
2708         {
2709                 if (p_ptr->multishadow && !do_dec)
2710                 {
2711                         if (p_ptr->multishadow > v) return FALSE;
2712                 }
2713                 else if (!p_ptr->multishadow)
2714                 {
2715 #ifdef JP
2716 msg_print("¤¢¤Ê¤¿¤Î¼þ¤ê¤Ë¸¸±Æ¤¬À¸¤Þ¤ì¤¿¡£");
2717 #else
2718                         msg_print("Your Shadow enveloped you.");
2719 #endif
2720
2721                         notice = TRUE;
2722                 }
2723         }
2724
2725         /* Shut */
2726         else
2727         {
2728                 if (p_ptr->multishadow)
2729                 {
2730 #ifdef JP
2731 msg_print("¸¸±Æ¤¬¾Ã¤¨¤¿¡£");
2732 #else
2733                         msg_print("Your Shadow disappears.");
2734 #endif
2735
2736                         notice = TRUE;
2737                 }
2738         }
2739
2740         /* Use the value */
2741         p_ptr->multishadow = v;
2742
2743         /* Redraw status bar */
2744         p_ptr->redraw |= (PR_STATUS);
2745
2746         /* Nothing to notice */
2747         if (!notice) return (FALSE);
2748
2749         /* Disturb */
2750         if (disturb_state) disturb(0, 0);
2751
2752         /* Recalculate bonuses */
2753         p_ptr->update |= (PU_BONUS);
2754
2755         /* Handle stuff */
2756         handle_stuff();
2757
2758         /* Result */
2759         return (TRUE);
2760 }
2761
2762
2763 /*
2764  * Set "p_ptr->dustrobe", notice observable changes
2765  */
2766 bool set_dustrobe(int v, bool do_dec)
2767 {
2768         bool notice = FALSE;
2769
2770         /* Hack -- Force good values */
2771         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2772
2773         if (p_ptr->is_dead) return FALSE;
2774
2775         /* Open */
2776         if (v)
2777         {
2778                 if (p_ptr->dustrobe && !do_dec)
2779                 {
2780                         if (p_ptr->dustrobe > v) return FALSE;
2781                 }
2782                 else if (!p_ptr->dustrobe)
2783                 {
2784 #ifdef JP
2785 msg_print("ÂÎ¤¬¶À¤Î¥ª¡¼¥é¤ÇÊ¤¤ï¤ì¤¿¡£");
2786 #else
2787                         msg_print("You were enveloped by mirror shards.");
2788 #endif
2789
2790                         notice = TRUE;
2791                 }
2792         }
2793
2794         /* Shut */
2795         else
2796         {
2797                 if (p_ptr->dustrobe)
2798                 {
2799 #ifdef JP
2800 msg_print("¶À¤Î¥ª¡¼¥é¤¬¾Ã¤¨¤¿¡£");
2801 #else
2802                         msg_print("The mirror shards disappear.");
2803 #endif
2804
2805                         notice = TRUE;
2806                 }
2807         }
2808
2809         /* Use the value */
2810         p_ptr->dustrobe = v;
2811
2812         /* Redraw status bar */
2813         p_ptr->redraw |= (PR_STATUS);
2814
2815         /* Nothing to notice */
2816         if (!notice) return (FALSE);
2817
2818         /* Disturb */
2819         if (disturb_state) disturb(0, 0);
2820
2821         /* Recalculate bonuses */
2822         p_ptr->update |= (PU_BONUS);
2823
2824         /* Handle stuff */
2825         handle_stuff();
2826
2827         /* Result */
2828         return (TRUE);
2829 }
2830
2831
2832 /*
2833  * Set "p_ptr->tim_regen", notice observable changes
2834  */
2835 bool set_kabenuke(int v, bool do_dec)
2836 {
2837         bool notice = FALSE;
2838
2839         /* Hack -- Force good values */
2840         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2841
2842         if (p_ptr->is_dead) return FALSE;
2843
2844         /* Open */
2845         if (v)
2846         {
2847                 if (p_ptr->kabenuke && !do_dec)
2848                 {
2849                         if (p_ptr->kabenuke > v) return FALSE;
2850                 }
2851                 else if (!p_ptr->kabenuke)
2852                 {
2853 #ifdef JP
2854 msg_print("ÂÎ¤¬È¾Êª¼Á¤Î¾õÂÖ¤Ë¤Ê¤Ã¤¿¡£");
2855 #else
2856                         msg_print("You became ethereal form.");
2857 #endif
2858
2859                         notice = TRUE;
2860                 }
2861         }
2862
2863         /* Shut */
2864         else
2865         {
2866                 if (p_ptr->kabenuke)
2867                 {
2868 #ifdef JP
2869 msg_print("ÂÎ¤¬Êª¼Á²½¤·¤¿¡£");
2870 #else
2871                         msg_print("You are no longer in an ethereal form.");
2872 #endif
2873
2874                         notice = TRUE;
2875                 }
2876         }
2877
2878         /* Use the value */
2879         p_ptr->kabenuke = v;
2880
2881         /* Redraw status bar */
2882         p_ptr->redraw |= (PR_STATUS);
2883
2884         /* Nothing to notice */
2885         if (!notice) return (FALSE);
2886
2887         /* Disturb */
2888         if (disturb_state) disturb(0, 0);
2889
2890         /* Recalculate bonuses */
2891         p_ptr->update |= (PU_BONUS);
2892
2893         /* Handle stuff */
2894         handle_stuff();
2895
2896         /* Result */
2897         return (TRUE);
2898 }
2899
2900
2901 bool set_tsuyoshi(int v, bool do_dec)
2902 {
2903         bool notice = FALSE;
2904
2905         /* Hack -- Force good values */
2906         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2907
2908         if (p_ptr->is_dead) return FALSE;
2909
2910         /* Open */
2911         if (v)
2912         {
2913                 if (p_ptr->tsuyoshi && !do_dec)
2914                 {
2915                         if (p_ptr->tsuyoshi > v) return FALSE;
2916                 }
2917                 else if (!p_ptr->tsuyoshi)
2918                 {
2919 #ifdef JP
2920 msg_print("¡Ö¥ª¥¯¥ì·»¤µ¤ó¡ª¡×");
2921 #else
2922                         msg_print("Brother OKURE!");
2923 #endif
2924
2925                         notice = TRUE;
2926                         chg_virtue(V_VITALITY, 2);
2927                 }
2928         }
2929
2930         /* Shut */
2931         else
2932         {
2933                 if (p_ptr->tsuyoshi)
2934                 {
2935 #ifdef JP
2936 msg_print("ÆùÂÎ¤¬µÞÂ®¤Ë¤·¤Ü¤ó¤Ç¤¤¤Ã¤¿¡£");
2937 #else
2938                         msg_print("Your body had quickly shriveled.");
2939 #endif
2940
2941                         (void)dec_stat(A_CON, 20, TRUE);
2942                         (void)dec_stat(A_STR, 20, TRUE);
2943
2944                         notice = TRUE;
2945                         chg_virtue(V_VITALITY, -3);
2946                 }
2947         }
2948
2949         /* Use the value */
2950         p_ptr->tsuyoshi = v;
2951
2952         /* Redraw status bar */
2953         p_ptr->redraw |= (PR_STATUS);
2954
2955         /* Nothing to notice */
2956         if (!notice) return (FALSE);
2957
2958         /* Disturb */
2959         if (disturb_state) disturb(0, 0);
2960
2961         /* Recalculate bonuses */
2962         p_ptr->update |= (PU_BONUS);
2963
2964         /* Recalculate hitpoints */
2965         p_ptr->update |= (PU_HP);
2966
2967         /* Handle stuff */
2968         handle_stuff();
2969
2970         /* Result */
2971         return (TRUE);
2972 }
2973
2974
2975 /*
2976  * Set a temporary elemental brand.  Clear all other brands.  Print status
2977  * messages. -LM-
2978  */
2979 bool set_ele_attack(u32b attack_type, int v)
2980 {
2981         /* Hack -- Force good values */
2982         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2983
2984         /* Clear all elemental attacks (only one is allowed at a time). */
2985         if ((p_ptr->special_attack & (ATTACK_ACID)) && (attack_type != ATTACK_ACID))
2986         {
2987                 p_ptr->special_attack &= ~(ATTACK_ACID);
2988 #ifdef JP
2989                 msg_print("»À¤Ç¹¶·â¤Ç¤¤Ê¤¯¤Ê¤Ã¤¿¡£");
2990 #else
2991                 msg_print("Your temporary acidic brand fades away.");
2992 #endif
2993         }
2994         if ((p_ptr->special_attack & (ATTACK_ELEC)) && (attack_type != ATTACK_ELEC))
2995         {
2996                 p_ptr->special_attack &= ~(ATTACK_ELEC);
2997 #ifdef JP
2998                 msg_print("ÅÅ·â¤Ç¹¶·â¤Ç¤¤Ê¤¯¤Ê¤Ã¤¿¡£");
2999 #else
3000                 msg_print("Your temporary electrical brand fades away.");
3001 #endif
3002         }
3003         if ((p_ptr->special_attack & (ATTACK_FIRE)) && (attack_type != ATTACK_FIRE))
3004         {
3005                 p_ptr->special_attack &= ~(ATTACK_FIRE);
3006 #ifdef JP
3007                 msg_print("²Ð±ê¤Ç¹¶·â¤Ç¤¤Ê¤¯¤Ê¤Ã¤¿¡£");
3008 #else
3009                 msg_print("Your temporary fiery brand fades away.");
3010 #endif
3011         }
3012         if ((p_ptr->special_attack & (ATTACK_COLD)) && (attack_type != ATTACK_COLD))
3013         {
3014                 p_ptr->special_attack &= ~(ATTACK_COLD);
3015 #ifdef JP
3016                 msg_print("Îäµ¤¤Ç¹¶·â¤Ç¤¤Ê¤¯¤Ê¤Ã¤¿¡£");
3017 #else
3018                 msg_print("Your temporary frost brand fades away.");
3019 #endif
3020         }
3021         if ((p_ptr->special_attack & (ATTACK_POIS)) && (attack_type != ATTACK_POIS))
3022         {
3023                 p_ptr->special_attack &= ~(ATTACK_POIS);
3024 #ifdef JP
3025                 msg_print("ÆÇ¤Ç¹¶·â¤Ç¤¤Ê¤¯¤Ê¤Ã¤¿¡£");
3026 #else
3027                 msg_print("Your temporary poison brand fades away.");
3028 #endif
3029         }
3030
3031         if ((v) && (attack_type))
3032         {
3033                 /* Set attack type. */
3034                 p_ptr->special_attack |= (attack_type);
3035
3036                 /* Set duration. */
3037                 p_ptr->ele_attack = v;
3038
3039                 /* Message. */
3040 #ifdef JP
3041                 msg_format("%s¤Ç¹¶·â¤Ç¤¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡ª",
3042                              ((attack_type == ATTACK_ACID) ? "»À" :
3043                               ((attack_type == ATTACK_ELEC) ? "ÅÅ·â" :
3044                                ((attack_type == ATTACK_FIRE) ? "²Ð±ê" :
3045                                 ((attack_type == ATTACK_COLD) ? "Îäµ¤" :
3046                                  ((attack_type == ATTACK_POIS) ? "ÆÇ" :
3047                                         "(¤Ê¤·)"))))));
3048 #else
3049                 msg_format("For a while, the blows you deal will %s",
3050                              ((attack_type == ATTACK_ACID) ? "melt with acid!" :
3051                               ((attack_type == ATTACK_ELEC) ? "shock your foes!" :
3052                                ((attack_type == ATTACK_FIRE) ? "burn with fire!" :
3053                                 ((attack_type == ATTACK_COLD) ? "chill to the bone!" :
3054                                  ((attack_type == ATTACK_POIS) ? "poison your enemies!" :
3055                                         "do nothing special."))))));
3056 #endif
3057         }
3058
3059         /* Disturb */
3060         if (disturb_state) disturb(0, 0);
3061
3062         /* Redraw status bar */
3063         p_ptr->redraw |= (PR_STATUS);
3064
3065         p_ptr->update |= (PU_BONUS);
3066
3067         /* Handle stuff */
3068         handle_stuff();
3069
3070         return (TRUE);
3071 }
3072
3073
3074 /*
3075  * Set a temporary elemental brand.  Clear all other brands.  Print status
3076  * messages. -LM-
3077  */
3078 bool set_ele_immune(u32b immune_type, int v)
3079 {
3080         /* Hack -- Force good values */
3081         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
3082
3083         /* Clear all elemental attacks (only one is allowed at a time). */
3084         if ((p_ptr->special_defense & (DEFENSE_ACID)) && (immune_type != DEFENSE_ACID))
3085         {
3086                 p_ptr->special_defense &= ~(DEFENSE_ACID);
3087 #ifdef JP
3088                 msg_print("»À¤Î¹¶·â¤Ç½ý¤Ä¤±¤é¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£¡£");
3089 #else
3090                 msg_print("You are no longer immune to acid.");
3091 #endif
3092         }
3093         if ((p_ptr->special_defense & (DEFENSE_ELEC)) && (immune_type != DEFENSE_ELEC))
3094         {
3095                 p_ptr->special_defense &= ~(DEFENSE_ELEC);
3096 #ifdef JP
3097                 msg_print("ÅÅ·â¤Î¹¶·â¤Ç½ý¤Ä¤±¤é¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£¡£");
3098 #else
3099                 msg_print("You are no longer immune to electricity.");
3100 #endif
3101         }
3102         if ((p_ptr->special_defense & (DEFENSE_FIRE)) && (immune_type != DEFENSE_FIRE))
3103         {
3104                 p_ptr->special_defense &= ~(DEFENSE_FIRE);
3105 #ifdef JP
3106                 msg_print("²Ð±ê¤Î¹¶·â¤Ç½ý¤Ä¤±¤é¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£¡£");
3107 #else
3108                 msg_print("You are no longer immune to fire.");
3109 #endif
3110         }
3111         if ((p_ptr->special_defense & (DEFENSE_COLD)) && (immune_type != DEFENSE_COLD))
3112         {
3113                 p_ptr->special_defense &= ~(DEFENSE_COLD);
3114 #ifdef JP
3115                 msg_print("Îäµ¤¤Î¹¶·â¤Ç½ý¤Ä¤±¤é¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£¡£");
3116 #else
3117                 msg_print("You are no longer immune to cold.");
3118 #endif
3119         }
3120         if ((p_ptr->special_defense & (DEFENSE_POIS)) && (immune_type != DEFENSE_POIS))
3121         {
3122                 p_ptr->special_defense &= ~(DEFENSE_POIS);
3123 #ifdef JP
3124                 msg_print("ÆÇ¤Î¹¶·â¤Ç½ý¤Ä¤±¤é¤ì¤ë¤è¤¦¤Ë¤Ê¤Ã¤¿¡£¡£");
3125 #else
3126                 msg_print("You are no longer immune to poison.");
3127 #endif
3128         }
3129
3130         if ((v) && (immune_type))
3131         {
3132                 /* Set attack type. */
3133                 p_ptr->special_defense |= (immune_type);
3134
3135                 /* Set duration. */
3136                 p_ptr->ele_immune = v;
3137
3138                 /* Message. */
3139 #ifdef JP
3140                 msg_format("%s¤Î¹¶·â¤ò¼õ¤±¤Ä¤±¤Ê¤¯¤Ê¤Ã¤¿¡ª",
3141                              ((immune_type == DEFENSE_ACID) ? "»À" :
3142                               ((immune_type == DEFENSE_ELEC) ? "ÅÅ·â" :
3143                                ((immune_type == DEFENSE_FIRE) ? "²Ð±ê" :
3144                                 ((immune_type == DEFENSE_COLD) ? "Îäµ¤" :
3145                                  ((immune_type == DEFENSE_POIS) ? "ÆÇ" :
3146                                         "(¤Ê¤·)"))))));
3147 #else
3148                 msg_format("For a while, You are immune to %s",
3149                              ((immune_type == DEFENSE_ACID) ? "acid!" :
3150                               ((immune_type == DEFENSE_ELEC) ? "electricity!" :
3151                                ((immune_type == DEFENSE_FIRE) ? "fire!" :
3152                                 ((immune_type == DEFENSE_COLD) ? "cold!" :
3153                                  ((immune_type == DEFENSE_POIS) ? "poison!" :
3154                                         "do nothing special."))))));
3155 #endif
3156         }
3157
3158         /* Disturb */
3159         if (disturb_state) disturb(0, 0);
3160
3161         /* Redraw status bar */
3162         p_ptr->redraw |= (PR_STATUS);
3163
3164         p_ptr->update |= (PU_BONUS);
3165
3166         /* Handle stuff */
3167         handle_stuff();
3168
3169         return (TRUE);
3170 }
3171
3172
3173 /*
3174  * Set "p_ptr->oppose_acid", notice observable changes
3175  */
3176 bool set_oppose_acid(int v, bool do_dec)
3177 {
3178         bool notice = FALSE;
3179
3180         /* Hack -- Force good values */
3181         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
3182
3183         if (p_ptr->is_dead) return FALSE;
3184
3185         /* Open */
3186         if (v)
3187         {
3188                 if (p_ptr->oppose_acid && !do_dec)
3189                 {
3190                         if (p_ptr->oppose_acid > v) return FALSE;
3191                 }
3192                 else if (!IS_OPPOSE_ACID())
3193                 {
3194 #ifdef JP
3195 msg_print("»À¤Ø¤ÎÂÑÀ¤¬¤Ä¤¤¤¿µ¤¤¬¤¹¤ë¡ª");
3196 #else
3197                         msg_print("You feel resistant to acid!");
3198 #endif
3199
3200                         notice = TRUE;
3201                 }
3202         }
3203
3204         /* Shut */
3205         else
3206         {
3207                 if (p_ptr->oppose_acid && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
3208                 {
3209 #ifdef JP
3210 msg_print("»À¤Ø¤ÎÂÑÀ¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£");
3211 #else
3212                         msg_print("You feel less resistant to acid.");
3213 #endif
3214
3215                         notice = TRUE;
3216                 }
3217         }
3218
3219         /* Use the value */
3220         p_ptr->oppose_acid = v;
3221
3222         /* Nothing to notice */
3223         if (!notice) return (FALSE);
3224
3225         /* Redraw status bar */
3226         p_ptr->redraw |= (PR_STATUS);
3227
3228         /* Disturb */
3229         if (disturb_state) disturb(0, 0);
3230
3231         /* Handle stuff */
3232         handle_stuff();
3233
3234         /* Result */
3235         return (TRUE);
3236 }
3237
3238
3239 /*
3240  * Set "p_ptr->oppose_elec", notice observable changes
3241  */
3242 bool set_oppose_elec(int v, bool do_dec)
3243 {
3244         bool notice = FALSE;
3245
3246         /* Hack -- Force good values */
3247         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
3248
3249         if (p_ptr->is_dead) return FALSE;
3250
3251         /* Open */
3252         if (v)
3253         {
3254                 if (p_ptr->oppose_elec && !do_dec)
3255                 {
3256                         if (p_ptr->oppose_elec > v) return FALSE;
3257                 }
3258                 else if (!IS_OPPOSE_ELEC())
3259                 {
3260 #ifdef JP
3261 msg_print("ÅÅ·â¤Ø¤ÎÂÑÀ¤¬¤Ä¤¤¤¿µ¤¤¬¤¹¤ë¡ª");
3262 #else
3263                         msg_print("You feel resistant to electricity!");
3264 #endif
3265
3266                         notice = TRUE;
3267                 }
3268         }
3269
3270         /* Shut */
3271         else
3272         {
3273                 if (p_ptr->oppose_elec && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
3274                 {
3275 #ifdef JP
3276 msg_print("ÅÅ·â¤Ø¤ÎÂÑÀ¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£");
3277 #else
3278                         msg_print("You feel less resistant to electricity.");
3279 #endif
3280
3281                         notice = TRUE;
3282                 }
3283         }
3284
3285         /* Use the value */
3286         p_ptr->oppose_elec = v;
3287
3288         /* Nothing to notice */
3289         if (!notice) return (FALSE);
3290
3291         /* Redraw status bar */
3292         p_ptr->redraw |= (PR_STATUS);
3293
3294         /* Disturb */
3295         if (disturb_state) disturb(0, 0);
3296
3297         /* Handle stuff */
3298         handle_stuff();
3299
3300         /* Result */
3301         return (TRUE);
3302 }
3303
3304
3305 /*
3306  * Set "p_ptr->oppose_fire", notice observable changes
3307  */
3308 bool set_oppose_fire(int v, bool do_dec)
3309 {
3310         bool notice = FALSE;
3311
3312         /* Hack -- Force good values */
3313         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
3314
3315         if (p_ptr->is_dead) return FALSE;
3316
3317         if ((prace_is_(RACE_DEMON) && (p_ptr->lev > 44)) || (p_ptr->mimic_form == MIMIC_DEMON)) v = 1;
3318         /* Open */
3319         if (v)
3320         {
3321                 if (p_ptr->oppose_fire && !do_dec)
3322                 {
3323                         if (p_ptr->oppose_fire > v) return FALSE;
3324                 }
3325                 else if (!IS_OPPOSE_FIRE())
3326                 {
3327 #ifdef JP
3328 msg_print("²Ð¤Ø¤ÎÂÑÀ¤¬¤Ä¤¤¤¿µ¤¤¬¤¹¤ë¡ª");
3329 #else
3330                         msg_print("You feel resistant to fire!");
3331 #endif
3332
3333                         notice = TRUE;
3334                 }
3335         }
3336
3337         /* Shut */
3338         else
3339         {
3340                 if (p_ptr->oppose_fire && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
3341                 {
3342 #ifdef JP
3343 msg_print("²Ð¤Ø¤ÎÂÑÀ¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£");
3344 #else
3345                         msg_print("You feel less resistant to fire.");
3346 #endif
3347
3348                         notice = TRUE;
3349                 }
3350         }
3351
3352         /* Use the value */
3353         p_ptr->oppose_fire = v;
3354
3355         /* Nothing to notice */
3356         if (!notice) return (FALSE);
3357
3358         /* Redraw status bar */
3359         p_ptr->redraw |= (PR_STATUS);
3360
3361         /* Disturb */
3362         if (disturb_state) disturb(0, 0);
3363
3364         /* Handle stuff */
3365         handle_stuff();
3366
3367         /* Result */
3368         return (TRUE);
3369 }
3370
3371
3372 /*
3373  * Set "p_ptr->oppose_cold", notice observable changes
3374  */
3375 bool set_oppose_cold(int v, bool do_dec)
3376 {
3377         bool notice = FALSE;
3378
3379         /* Hack -- Force good values */
3380         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
3381
3382         if (p_ptr->is_dead) return FALSE;
3383
3384         /* Open */
3385         if (v)
3386         {
3387                 if (p_ptr->oppose_cold && !do_dec)
3388                 {
3389                         if (p_ptr->oppose_cold > v) return FALSE;
3390                 }
3391                 else if (!IS_OPPOSE_COLD())
3392                 {
3393 #ifdef JP
3394 msg_print("Îäµ¤¤Ø¤ÎÂÑÀ¤¬¤Ä¤¤¤¿µ¤¤¬¤¹¤ë¡ª");
3395 #else
3396                         msg_print("You feel resistant to cold!");
3397 #endif
3398
3399                         notice = TRUE;
3400                 }
3401         }
3402
3403         /* Shut */
3404         else
3405         {
3406                 if (p_ptr->oppose_cold && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
3407                 {
3408 #ifdef JP
3409 msg_print("Îäµ¤¤Ø¤ÎÂÑÀ¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£");
3410 #else
3411                         msg_print("You feel less resistant to cold.");
3412 #endif
3413
3414                         notice = TRUE;
3415                 }
3416         }
3417
3418         /* Use the value */
3419         p_ptr->oppose_cold = v;
3420
3421         /* Nothing to notice */
3422         if (!notice) return (FALSE);
3423
3424         /* Redraw status bar */
3425         p_ptr->redraw |= (PR_STATUS);
3426
3427         /* Disturb */
3428         if (disturb_state) disturb(0, 0);
3429
3430         /* Handle stuff */
3431         handle_stuff();
3432
3433         /* Result */
3434         return (TRUE);
3435 }
3436
3437
3438 /*
3439  * Set "p_ptr->oppose_pois", notice observable changes
3440  */
3441 bool set_oppose_pois(int v, bool do_dec)
3442 {
3443         bool notice = FALSE;
3444
3445         /* Hack -- Force good values */
3446         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
3447
3448         if ((p_ptr->pclass == CLASS_NINJA) && (p_ptr->lev > 44)) v = 1;
3449         if (p_ptr->is_dead) return FALSE;
3450
3451         /* Open */
3452         if (v)
3453         {
3454                 if (p_ptr->oppose_pois && !do_dec)
3455                 {
3456                         if (p_ptr->oppose_pois > v) return FALSE;
3457                 }
3458                 else if (!IS_OPPOSE_POIS())
3459                 {
3460 #ifdef JP
3461 msg_print("ÆÇ¤Ø¤ÎÂÑÀ¤¬¤Ä¤¤¤¿µ¤¤¬¤¹¤ë¡ª");
3462 #else
3463                         msg_print("You feel resistant to poison!");
3464 #endif
3465
3466                         notice = TRUE;
3467                 }
3468         }
3469
3470         /* Shut */
3471         else
3472         {
3473                 if (p_ptr->oppose_pois && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
3474                 {
3475 #ifdef JP
3476 msg_print("ÆÇ¤Ø¤ÎÂÑÀ¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£");
3477 #else
3478                         msg_print("You feel less resistant to poison.");
3479 #endif
3480
3481                         notice = TRUE;
3482                 }
3483         }
3484
3485         /* Use the value */
3486         p_ptr->oppose_pois = v;
3487
3488         /* Nothing to notice */
3489         if (!notice) return (FALSE);
3490
3491         /* Redraw status bar */
3492         p_ptr->redraw |= (PR_STATUS);
3493
3494         /* Disturb */
3495         if (disturb_state) disturb(0, 0);
3496
3497         /* Handle stuff */
3498         handle_stuff();
3499
3500         /* Result */
3501         return (TRUE);
3502 }
3503
3504
3505 /*
3506  * Set "p_ptr->stun", notice observable changes
3507  *
3508  * Note the special code to only notice "range" changes.
3509  */
3510 bool set_stun(int v)
3511 {
3512         int old_aux, new_aux;
3513         bool notice = FALSE;
3514
3515
3516         /* Hack -- Force good values */
3517         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
3518
3519         if (p_ptr->is_dead) return FALSE;
3520
3521         if (prace_is_(RACE_GOLEM) || ((p_ptr->pclass == CLASS_BERSERKER) && (p_ptr->lev > 34))) v = 0;
3522
3523         /* Knocked out */
3524         if (p_ptr->stun > 100)
3525         {
3526                 old_aux = 3;
3527         }
3528
3529         /* Heavy stun */
3530         else if (p_ptr->stun > 50)
3531         {
3532                 old_aux = 2;
3533         }
3534
3535         /* Stun */
3536         else if (p_ptr->stun > 0)
3537         {
3538                 old_aux = 1;
3539         }
3540
3541         /* None */
3542         else
3543         {
3544                 old_aux = 0;
3545         }
3546
3547         /* Knocked out */
3548         if (v > 100)
3549         {
3550                 new_aux = 3;
3551         }
3552
3553         /* Heavy stun */
3554         else if (v > 50)
3555         {
3556                 new_aux = 2;
3557         }
3558
3559         /* Stun */
3560         else if (v > 0)
3561         {
3562                 new_aux = 1;
3563         }
3564
3565         /* None */
3566         else
3567         {
3568                 new_aux = 0;
3569         }
3570
3571         /* Increase cut */
3572         if (new_aux > old_aux)
3573         {
3574                 /* Describe the state */
3575                 switch (new_aux)
3576                 {
3577                         /* Stun */
3578                         case 1:
3579 #ifdef JP
3580 msg_print("°Õ¼±¤¬¤â¤¦¤í¤¦¤È¤·¤Æ¤¤¿¡£");
3581 #else
3582                         msg_print("You have been stunned.");
3583 #endif
3584
3585                         break;
3586
3587                         /* Heavy stun */
3588                         case 2:
3589 #ifdef JP
3590 msg_print("°Õ¼±¤¬¤Ò¤É¤¯¤â¤¦¤í¤¦¤È¤·¤Æ¤¤¿¡£");
3591 #else
3592                         msg_print("You have been heavily stunned.");
3593 #endif
3594
3595                         break;
3596
3597                         /* Knocked out */
3598                         case 3:
3599 #ifdef JP
3600 msg_print("Æ¬¤¬¥¯¥é¥¯¥é¤·¤Æ°Õ¼±¤¬±ó¤Î¤¤¤Æ¤¤¿¡£");
3601 #else
3602                         msg_print("You have been knocked out.");
3603 #endif
3604
3605                         break;
3606                 }
3607
3608                 if (randint1(1000) < v || one_in_(16))
3609                 {
3610 #ifdef JP
3611 msg_print("³ä¤ì¤ë¤è¤¦¤ÊÆ¬ÄË¤¬¤¹¤ë¡£");
3612 #else
3613                         msg_print("A vicious blow hits your head.");
3614 #endif
3615
3616                         if (one_in_(3))
3617                         {
3618                                 if (!p_ptr->sustain_int) (void)do_dec_stat(A_INT);
3619                                 if (!p_ptr->sustain_wis) (void)do_dec_stat(A_WIS);
3620                         }
3621                         else if (one_in_(2))
3622                         {
3623                                 if (!p_ptr->sustain_int) (void)do_dec_stat(A_INT);
3624                         }
3625                         else
3626                         {
3627                                 if (!p_ptr->sustain_wis) (void)do_dec_stat(A_WIS);
3628                         }
3629                 }
3630                 if (p_ptr->special_defense & KATA_MASK)
3631                 {
3632 #ifdef JP
3633                         msg_print("·¿¤¬Êø¤ì¤¿¡£");
3634 #else
3635                         msg_print("Your posture gets loose.");
3636 #endif
3637                         p_ptr->special_defense &= ~(KATA_MASK);
3638                         p_ptr->update |= (PU_BONUS);
3639                         p_ptr->update |= (PU_MONSTERS);
3640                         p_ptr->redraw |= (PR_STATE);
3641                         p_ptr->redraw |= (PR_STATUS);
3642                         p_ptr->action = ACTION_NONE;
3643                 }
3644
3645                 /* Sniper */
3646                 if (p_ptr->concent) reset_concentration(TRUE);
3647
3648                 /* Hex */
3649                 if (hex_spelling_any()) stop_hex_spell_all();
3650
3651                 /* Notice */
3652                 notice = TRUE;
3653         }
3654
3655         /* Decrease cut */
3656         else if (new_aux < old_aux)
3657         {
3658                 /* Describe the state */
3659                 switch (new_aux)
3660                 {
3661                         /* None */
3662                         case 0:
3663 #ifdef JP
3664 msg_print("¤ä¤Ã¤ÈÛ¯Û°¾õÂÖ¤«¤é²óÉü¤·¤¿¡£");
3665 #else
3666                         msg_print("You are no longer stunned.");
3667 #endif
3668
3669                         if (disturb_state) disturb(0, 0);
3670                         break;
3671                 }
3672
3673                 /* Notice */
3674                 notice = TRUE;
3675         }
3676
3677         /* Use the value */
3678         p_ptr->stun = v;
3679
3680         /* No change */
3681         if (!notice) return (FALSE);
3682
3683         /* Disturb */
3684         if (disturb_state) disturb(0, 0);
3685
3686         /* Recalculate bonuses */
3687         p_ptr->update |= (PU_BONUS);
3688
3689         /* Redraw the "stun" */
3690         p_ptr->redraw |= (PR_STUN);
3691
3692         /* Handle stuff */
3693         handle_stuff();
3694
3695         /* Result */
3696         return (TRUE);
3697 }
3698
3699
3700 /*
3701  * Set "p_ptr->cut", notice observable changes
3702  *
3703  * Note the special code to only notice "range" changes.
3704  */
3705 bool set_cut(int v)
3706 {
3707         int old_aux, new_aux;
3708         bool notice = FALSE;
3709
3710         /* Hack -- Force good values */
3711         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
3712
3713         if (p_ptr->is_dead) return FALSE;
3714
3715         if ((p_ptr->prace == RACE_GOLEM ||
3716             p_ptr->prace == RACE_SKELETON ||
3717             p_ptr->prace == RACE_SPECTRE ||
3718                 (p_ptr->prace == RACE_ZOMBIE && p_ptr->lev > 11)) &&
3719             !p_ptr->mimic_form)
3720                 v = 0;
3721
3722         /* Mortal wound */
3723         if (p_ptr->cut > 1000)
3724         {
3725                 old_aux = 7;
3726         }
3727
3728         /* Deep gash */
3729         else if (p_ptr->cut > 200)
3730         {
3731                 old_aux = 6;
3732         }
3733
3734         /* Severe cut */
3735         else if (p_ptr->cut > 100)
3736         {
3737                 old_aux = 5;
3738         }
3739
3740         /* Nasty cut */
3741         else if (p_ptr->cut > 50)
3742         {
3743                 old_aux = 4;
3744         }
3745
3746         /* Bad cut */
3747         else if (p_ptr->cut > 25)
3748         {
3749                 old_aux = 3;
3750         }
3751
3752         /* Light cut */
3753         else if (p_ptr->cut > 10)
3754         {
3755                 old_aux = 2;
3756         }
3757
3758         /* Graze */
3759         else if (p_ptr->cut > 0)
3760         {
3761                 old_aux = 1;
3762         }
3763
3764         /* None */
3765         else
3766         {
3767                 old_aux = 0;
3768         }
3769
3770         /* Mortal wound */
3771         if (v > 1000)
3772         {
3773                 new_aux = 7;
3774         }
3775
3776         /* Deep gash */
3777         else if (v > 200)
3778         {
3779                 new_aux = 6;
3780         }
3781
3782         /* Severe cut */
3783         else if (v > 100)
3784         {
3785                 new_aux = 5;
3786         }
3787
3788         /* Nasty cut */
3789         else if (v > 50)
3790         {
3791                 new_aux = 4;
3792         }
3793
3794         /* Bad cut */
3795         else if (v > 25)
3796         {
3797                 new_aux = 3;
3798         }
3799
3800         /* Light cut */
3801         else if (v > 10)
3802         {
3803                 new_aux = 2;
3804         }
3805
3806         /* Graze */
3807         else if (v > 0)
3808         {
3809                 new_aux = 1;
3810         }
3811
3812         /* None */
3813         else
3814         {
3815                 new_aux = 0;
3816         }
3817
3818         /* Increase cut */
3819         if (new_aux > old_aux)
3820         {
3821                 /* Describe the state */
3822                 switch (new_aux)
3823                 {
3824                         /* Graze */
3825                         case 1:
3826 #ifdef JP
3827 msg_print("¤«¤¹¤ê½ý¤òÉé¤Ã¤Æ¤·¤Þ¤Ã¤¿¡£");
3828 #else
3829                         msg_print("You have been given a graze.");
3830 #endif
3831
3832                         break;
3833
3834                         /* Light cut */
3835                         case 2:
3836 #ifdef JP
3837 msg_print("·Ú¤¤½ý¤òÉé¤Ã¤Æ¤·¤Þ¤Ã¤¿¡£");
3838 #else
3839                         msg_print("You have been given a light cut.");
3840 #endif
3841
3842                         break;
3843
3844                         /* Bad cut */
3845                         case 3:
3846 #ifdef JP
3847 msg_print("¤Ò¤É¤¤½ý¤òÉé¤Ã¤Æ¤·¤Þ¤Ã¤¿¡£");
3848 #else
3849                         msg_print("You have been given a bad cut.");
3850 #endif
3851
3852                         break;
3853
3854                         /* Nasty cut */
3855                         case 4:
3856 #ifdef JP
3857 msg_print("ÂçÊÑ¤Ê½ý¤òÉé¤Ã¤Æ¤·¤Þ¤Ã¤¿¡£");
3858 #else
3859                         msg_print("You have been given a nasty cut.");
3860 #endif
3861
3862                         break;
3863
3864                         /* Severe cut */
3865                         case 5:
3866 #ifdef JP
3867 msg_print("½ÅÂç¤Ê½ý¤òÉé¤Ã¤Æ¤·¤Þ¤Ã¤¿¡£");
3868 #else
3869                         msg_print("You have been given a severe cut.");
3870 #endif
3871
3872                         break;
3873
3874                         /* Deep gash */
3875                         case 6:
3876 #ifdef JP
3877 msg_print("¤Ò¤É¤¤¿¼¼ê¤òÉé¤Ã¤Æ¤·¤Þ¤Ã¤¿¡£");
3878 #else
3879                         msg_print("You have been given a deep gash.");
3880 #endif
3881
3882                         break;
3883
3884                         /* Mortal wound */
3885                         case 7:
3886 #ifdef JP
3887 msg_print("Ã×Ì¿Åª¤Ê½ý¤òÉé¤Ã¤Æ¤·¤Þ¤Ã¤¿¡£");
3888 #else
3889                         msg_print("You have been given a mortal wound.");
3890 #endif
3891
3892                         break;
3893                 }
3894
3895                 /* Notice */
3896                 notice = TRUE;
3897
3898                 if (randint1(1000) < v || one_in_(16))
3899                 {
3900                         if (!p_ptr->sustain_chr)
3901                         {
3902 #ifdef JP
3903 msg_print("¤Ò¤É¤¤½ýÀ×¤¬»Ä¤Ã¤Æ¤·¤Þ¤Ã¤¿¡£");
3904 #else
3905                                 msg_print("You have been horribly scarred.");
3906 #endif
3907
3908
3909                                 do_dec_stat(A_CHR);
3910                         }
3911                 }
3912         }
3913
3914         /* Decrease cut */
3915         else if (new_aux < old_aux)
3916         {
3917                 /* Describe the state */
3918                 switch (new_aux)
3919                 {
3920                         /* None */
3921                         case 0:
3922 #ifdef JP
3923 msg_format("¤ä¤Ã¤È%s¡£", p_ptr->prace == RACE_ANDROID ? "²ø²æ¤¬Ä¾¤Ã¤¿" : "½Ð·ì¤¬»ß¤Þ¤Ã¤¿");
3924 #else
3925                         msg_print("You are no longer bleeding.");
3926 #endif
3927
3928                         if (disturb_state) disturb(0, 0);
3929                         break;
3930                 }
3931
3932                 /* Notice */
3933                 notice = TRUE;
3934         }
3935
3936         /* Use the value */
3937         p_ptr->cut = v;
3938
3939         /* No change */
3940         if (!notice) return (FALSE);
3941
3942         /* Disturb */
3943         if (disturb_state) disturb(0, 0);
3944
3945         /* Recalculate bonuses */
3946         p_ptr->update |= (PU_BONUS);
3947
3948         /* Redraw the "cut" */
3949         p_ptr->redraw |= (PR_CUT);
3950
3951         /* Handle stuff */
3952         handle_stuff();
3953
3954         /* Result */
3955         return (TRUE);
3956 }
3957
3958
3959 /*
3960  * Set "p_ptr->food", notice observable changes
3961  *
3962  * The "p_ptr->food" variable can get as large as 20000, allowing the
3963  * addition of the most "filling" item, Elvish Waybread, which adds
3964  * 7500 food units, without overflowing the 32767 maximum limit.
3965  *
3966  * Perhaps we should disturb the player with various messages,
3967  * especially messages about hunger status changes.  XXX XXX XXX
3968  *
3969  * Digestion of food is handled in "dungeon.c", in which, normally,
3970  * the player digests about 20 food units per 100 game turns, more
3971  * when "fast", more when "regenerating", less with "slow digestion",
3972  * but when the player is "gorged", he digests 100 food units per 10
3973  * game turns, or a full 1000 food units per 100 game turns.
3974  *
3975  * Note that the player's speed is reduced by 10 units while gorged,
3976  * so if the player eats a single food ration (5000 food units) when
3977  * full (15000 food units), he will be gorged for (5000/100)*10 = 500
3978  * game turns, or 500/(100/5) = 25 player turns (if nothing else is
3979  * affecting the player speed).
3980  */
3981 bool set_food(int v)
3982 {
3983         int old_aux, new_aux;
3984
3985         bool notice = FALSE;
3986
3987         /* Hack -- Force good values */
3988         v = (v > 20000) ? 20000 : (v < 0) ? 0 : v;
3989
3990         /* Fainting / Starving */
3991         if (p_ptr->food < PY_FOOD_FAINT)
3992         {
3993                 old_aux = 0;
3994         }
3995
3996         /* Weak */
3997         else if (p_ptr->food < PY_FOOD_WEAK)
3998         {
3999                 old_aux = 1;
4000         }
4001
4002         /* Hungry */
4003         else if (p_ptr->food < PY_FOOD_ALERT)
4004         {
4005                 old_aux = 2;
4006         }
4007
4008         /* Normal */
4009         else if (p_ptr->food < PY_FOOD_FULL)
4010         {
4011                 old_aux = 3;
4012         }
4013
4014         /* Full */
4015         else if (p_ptr->food < PY_FOOD_MAX)
4016         {
4017                 old_aux = 4;
4018         }
4019
4020         /* Gorged */
4021         else
4022         {
4023                 old_aux = 5;
4024         }
4025
4026         /* Fainting / Starving */
4027         if (v < PY_FOOD_FAINT)
4028         {
4029                 new_aux = 0;
4030         }
4031
4032         /* Weak */
4033         else if (v < PY_FOOD_WEAK)
4034         {
4035                 new_aux = 1;
4036         }
4037
4038         /* Hungry */
4039         else if (v < PY_FOOD_ALERT)
4040         {
4041                 new_aux = 2;
4042         }
4043
4044         /* Normal */
4045         else if (v < PY_FOOD_FULL)
4046         {
4047                 new_aux = 3;
4048         }
4049
4050         /* Full */
4051         else if (v < PY_FOOD_MAX)
4052         {
4053                 new_aux = 4;
4054         }
4055
4056         /* Gorged */
4057         else
4058         {
4059                 new_aux = 5;
4060         }
4061
4062         if (old_aux < 1 && new_aux > 0)
4063                 chg_virtue(V_PATIENCE, 2);
4064         else if (old_aux < 3 && (old_aux != new_aux))
4065                 chg_virtue(V_PATIENCE, 1);
4066         if (old_aux == 2)
4067                 chg_virtue(V_TEMPERANCE, 1);
4068         if (old_aux == 0)
4069                 chg_virtue(V_TEMPERANCE, -1);
4070
4071         /* Food increase */
4072         if (new_aux > old_aux)
4073         {
4074                 /* Describe the state */
4075                 switch (new_aux)
4076                 {
4077                         /* Weak */
4078                         case 1:
4079 #ifdef JP
4080 msg_print("¤Þ¤À¶õÊ¢¤ÇÅÝ¤ì¤½¤¦¤À¡£");
4081 #else
4082                         msg_print("You are still weak.");
4083 #endif
4084
4085                         break;
4086
4087                         /* Hungry */
4088                         case 2:
4089 #ifdef JP
4090 msg_print("¤Þ¤À¶õÊ¢¤À¡£");
4091 #else
4092                         msg_print("You are still hungry.");
4093 #endif
4094
4095                         break;
4096
4097                         /* Normal */
4098                         case 3:
4099 #ifdef JP
4100 msg_print("¶õÊ¢´¶¤¬¤ª¤µ¤Þ¤Ã¤¿¡£");
4101 #else
4102                         msg_print("You are no longer hungry.");
4103 #endif
4104
4105                         break;
4106
4107                         /* Full */
4108                         case 4:
4109 #ifdef JP
4110 msg_print("ËþÊ¢¤À¡ª");
4111 #else
4112                         msg_print("You are full!");
4113 #endif
4114
4115                         break;
4116
4117                         /* Bloated */
4118                         case 5:
4119 #ifdef JP
4120 msg_print("¿©¤Ù²á¤®¤À¡ª");
4121 #else
4122                         msg_print("You have gorged yourself!");
4123 #endif
4124                         chg_virtue(V_HARMONY, -1);
4125                         chg_virtue(V_PATIENCE, -1);
4126                         chg_virtue(V_TEMPERANCE, -2);
4127
4128                         break;
4129                 }
4130
4131                 /* Change */
4132                 notice = TRUE;
4133         }
4134
4135         /* Food decrease */
4136         else if (new_aux < old_aux)
4137         {
4138                 /* Describe the state */
4139                 switch (new_aux)
4140                 {
4141                         /* Fainting / Starving */
4142                         case 0:
4143 #ifdef JP
4144 msg_print("¤¢¤Þ¤ê¤Ë¤â¶õÊ¢¤Çµ¤¤ò¼º¤Ã¤Æ¤·¤Þ¤Ã¤¿¡ª");
4145 #else
4146                         msg_print("You are getting faint from hunger!");
4147 #endif
4148
4149                         break;
4150
4151                         /* Weak */
4152                         case 1:
4153 #ifdef JP
4154 msg_print("¤ªÊ¢¤¬¶õ¤¤¤ÆÅÝ¤ì¤½¤¦¤À¡£");
4155 #else
4156                         msg_print("You are getting weak from hunger!");
4157 #endif
4158
4159                         break;
4160
4161                         /* Hungry */
4162                         case 2:
4163 #ifdef JP
4164 msg_print("¤ªÊ¢¤¬¶õ¤¤¤Æ¤¤¿¡£");
4165 #else
4166                         msg_print("You are getting hungry.");
4167 #endif
4168
4169                         break;
4170
4171                         /* Normal */
4172                         case 3:
4173 #ifdef JP
4174 msg_print("ËþÊ¢´¶¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
4175 #else
4176                         msg_print("You are no longer full.");
4177 #endif
4178
4179                         break;
4180
4181                         /* Full */
4182                         case 4:
4183 #ifdef JP
4184 msg_print("¤ä¤Ã¤È¤ªÊ¢¤¬¤¤Ä¤¯¤Ê¤¯¤Ê¤Ã¤¿¡£");
4185 #else
4186                         msg_print("You are no longer gorged.");
4187 #endif
4188
4189                         break;
4190                 }
4191
4192                 if (p_ptr->wild_mode && (new_aux < 2))
4193                 {
4194                         change_wild_mode();
4195                 }
4196
4197                 /* Change */
4198                 notice = TRUE;
4199         }
4200
4201         /* Use the value */
4202         p_ptr->food = v;
4203
4204         /* Nothing to notice */
4205         if (!notice) return (FALSE);
4206
4207         /* Disturb */
4208         if (disturb_state) disturb(0, 0);
4209
4210         /* Recalculate bonuses */
4211         p_ptr->update |= (PU_BONUS);
4212
4213         /* Redraw hunger */
4214         p_ptr->redraw |= (PR_HUNGER);
4215
4216         /* Handle stuff */
4217         handle_stuff();
4218
4219         /* Result */
4220         return (TRUE);
4221 }
4222
4223 /*
4224  * Increases a stat by one randomized level             -RAK-
4225  *
4226  * Note that this function (used by stat potions) now restores
4227  * the stat BEFORE increasing it.
4228  */
4229 bool inc_stat(int stat)
4230 {
4231         int value, gain;
4232
4233         /* Then augment the current/max stat */
4234         value = p_ptr->stat_cur[stat];
4235
4236         /* Cannot go above 18/100 */
4237         if (value < p_ptr->stat_max_max[stat])
4238         {
4239                 /* Gain one (sometimes two) points */
4240                 if (value < 18)
4241                 {
4242                         gain = ((randint0(100) < 75) ? 1 : 2);
4243                         value += gain;
4244                 }
4245
4246                 /* Gain 1/6 to 1/3 of distance to 18/100 */
4247                 else if (value < (p_ptr->stat_max_max[stat]-2))
4248                 {
4249                         /* Approximate gain value */
4250                         gain = (((p_ptr->stat_max_max[stat]) - value) / 2 + 3) / 2;
4251
4252                         /* Paranoia */
4253                         if (gain < 1) gain = 1;
4254
4255                         /* Apply the bonus */
4256                         value += randint1(gain) + gain / 2;
4257
4258                         /* Maximal value */
4259                         if (value > (p_ptr->stat_max_max[stat]-1)) value = p_ptr->stat_max_max[stat]-1;
4260                 }
4261
4262                 /* Gain one point at a time */
4263                 else
4264                 {
4265                         value++;
4266                 }
4267
4268                 /* Save the new value */
4269                 p_ptr->stat_cur[stat] = value;
4270
4271                 /* Bring up the maximum too */
4272                 if (value > p_ptr->stat_max[stat])
4273                 {
4274                         p_ptr->stat_max[stat] = value;
4275                 }
4276
4277                 /* Recalculate bonuses */
4278                 p_ptr->update |= (PU_BONUS);
4279
4280                 /* Success */
4281                 return (TRUE);
4282         }
4283
4284         /* Nothing to gain */
4285         return (FALSE);
4286 }
4287
4288
4289
4290 /*
4291  * Decreases a stat by an amount indended to vary from 0 to 100 percent.
4292  *
4293  * Amount could be a little higher in extreme cases to mangle very high
4294  * stats from massive assaults.  -CWS
4295  *
4296  * Note that "permanent" means that the *given* amount is permanent,
4297  * not that the new value becomes permanent.  This may not work exactly
4298  * as expected, due to "weirdness" in the algorithm, but in general,
4299  * if your stat is already drained, the "max" value will not drop all
4300  * the way down to the "cur" value.
4301  */
4302 bool dec_stat(int stat, int amount, int permanent)
4303 {
4304         int cur, max, loss, same, res = FALSE;
4305
4306
4307         /* Acquire current value */
4308         cur = p_ptr->stat_cur[stat];
4309         max = p_ptr->stat_max[stat];
4310
4311         /* Note when the values are identical */
4312         same = (cur == max);
4313
4314         /* Damage "current" value */
4315         if (cur > 3)
4316         {
4317                 /* Handle "low" values */
4318                 if (cur <= 18)
4319                 {
4320                         if (amount > 90) cur--;
4321                         if (amount > 50) cur--;
4322                         if (amount > 20) cur--;
4323                         cur--;
4324                 }
4325
4326                 /* Handle "high" values */
4327                 else
4328                 {
4329                         /* Hack -- Decrement by a random amount between one-quarter */
4330                         /* and one-half of the stat bonus times the percentage, with a */
4331                         /* minimum damage of half the percentage. -CWS */
4332                         loss = (((cur-18) / 2 + 1) / 2 + 1);
4333
4334                         /* Paranoia */
4335                         if (loss < 1) loss = 1;
4336
4337                         /* Randomize the loss */
4338                         loss = ((randint1(loss) + loss) * amount) / 100;
4339
4340                         /* Maximal loss */
4341                         if (loss < amount/2) loss = amount/2;
4342
4343                         /* Lose some points */
4344                         cur = cur - loss;
4345
4346                         /* Hack -- Only reduce stat to 17 sometimes */
4347                         if (cur < 18) cur = (amount <= 20) ? 18 : 17;
4348                 }
4349
4350                 /* Prevent illegal values */
4351                 if (cur < 3) cur = 3;
4352
4353                 /* Something happened */
4354                 if (cur != p_ptr->stat_cur[stat]) res = TRUE;
4355         }
4356
4357         /* Damage "max" value */
4358         if (permanent && (max > 3))
4359         {
4360                 chg_virtue(V_SACRIFICE, 1);
4361                 if (stat == A_WIS || stat == A_INT)
4362                         chg_virtue(V_ENLIGHTEN, -2);
4363
4364                 /* Handle "low" values */
4365                 if (max <= 18)
4366                 {
4367                         if (amount > 90) max--;
4368                         if (amount > 50) max--;
4369                         if (amount > 20) max--;
4370                         max--;
4371                 }
4372
4373                 /* Handle "high" values */
4374                 else
4375                 {
4376                         /* Hack -- Decrement by a random amount between one-quarter */
4377                         /* and one-half of the stat bonus times the percentage, with a */
4378                         /* minimum damage of half the percentage. -CWS */
4379                         loss = (((max-18) / 2 + 1) / 2 + 1);
4380                         loss = ((randint1(loss) + loss) * amount) / 100;
4381                         if (loss < amount/2) loss = amount/2;
4382
4383                         /* Lose some points */
4384                         max = max - loss;
4385
4386                         /* Hack -- Only reduce stat to 17 sometimes */
4387                         if (max < 18) max = (amount <= 20) ? 18 : 17;
4388                 }
4389
4390                 /* Hack -- keep it clean */
4391                 if (same || (max < cur)) max = cur;
4392
4393                 /* Something happened */
4394                 if (max != p_ptr->stat_max[stat]) res = TRUE;
4395         }
4396
4397         /* Apply changes */
4398         if (res)
4399         {
4400                 /* Actually set the stat to its new value. */
4401                 p_ptr->stat_cur[stat] = cur;
4402                 p_ptr->stat_max[stat] = max;
4403
4404                 /* Redisplay the stats later */
4405                 p_ptr->redraw |= (PR_STATS);
4406
4407                 /* Recalculate bonuses */
4408                 p_ptr->update |= (PU_BONUS);
4409         }
4410
4411         /* Done */
4412         return (res);
4413 }
4414
4415
4416 /*
4417  * Restore a stat.  Return TRUE only if this actually makes a difference.
4418  */
4419 bool res_stat(int stat)
4420 {
4421         /* Restore if needed */
4422         if (p_ptr->stat_cur[stat] != p_ptr->stat_max[stat])
4423         {
4424                 /* Restore */
4425                 p_ptr->stat_cur[stat] = p_ptr->stat_max[stat];
4426
4427                 /* Recalculate bonuses */
4428                 p_ptr->update |= (PU_BONUS);
4429
4430                 /* Redisplay the stats later */
4431                 p_ptr->redraw |= (PR_STATS);
4432
4433                 /* Success */
4434                 return (TRUE);
4435         }
4436
4437         /* Nothing to restore */
4438         return (FALSE);
4439 }
4440
4441
4442 /*
4443  * Increase players hit points, notice effects
4444  */
4445 bool hp_player(int num)
4446 {
4447         int vir;
4448         vir = virtue_number(V_VITALITY);
4449         if (vir)
4450         {
4451                 num = num * (p_ptr->virtues[vir - 1] + 1250) / 1250;
4452         }
4453         /* Healing needed */
4454         if (p_ptr->chp < p_ptr->mhp)
4455         {
4456                 if ((num > 0) && (p_ptr->chp < (p_ptr->mhp/3)))
4457                         chg_virtue(V_TEMPERANCE, 1);
4458                 /* Gain hitpoints */
4459                 p_ptr->chp += num;
4460
4461                 /* Enforce maximum */
4462                 if (p_ptr->chp >= p_ptr->mhp)
4463                 {
4464                         p_ptr->chp = p_ptr->mhp;
4465                         p_ptr->chp_frac = 0;
4466                 }
4467
4468                 /* Redraw */
4469                 p_ptr->redraw |= (PR_HP);
4470
4471                 /* Window stuff */
4472                 p_ptr->window |= (PW_PLAYER);
4473
4474                 /* Heal 0-4 */
4475                 if (num < 5)
4476                 {
4477 #ifdef JP
4478 msg_print("¾¯¤·µ¤Ê¬¤¬ÎÉ¤¯¤Ê¤Ã¤¿¡£");
4479 #else
4480                         msg_print("You feel a little better.");
4481 #endif
4482
4483                 }
4484
4485                 /* Heal 5-14 */
4486                 else if (num < 15)
4487                 {
4488 #ifdef JP
4489 msg_print("µ¤Ê¬¤¬ÎÉ¤¯¤Ê¤Ã¤¿¡£");
4490 #else
4491                         msg_print("You feel better.");
4492 #endif
4493
4494                 }
4495
4496                 /* Heal 15-34 */
4497                 else if (num < 35)
4498                 {
4499 #ifdef JP
4500 msg_print("¤È¤Æ¤âµ¤Ê¬¤¬ÎÉ¤¯¤Ê¤Ã¤¿¡£");
4501 #else
4502                         msg_print("You feel much better.");
4503 #endif
4504
4505                 }
4506
4507                 /* Heal 35+ */
4508                 else
4509                 {
4510 #ifdef JP
4511 msg_print("¤Ò¤¸¤ç¤¦¤Ëµ¤Ê¬¤¬ÎÉ¤¯¤Ê¤Ã¤¿¡£");
4512 #else
4513                         msg_print("You feel very good.");
4514 #endif
4515
4516                 }
4517
4518                 /* Notice */
4519                 return (TRUE);
4520         }
4521
4522         /* Ignore */
4523         return (FALSE);
4524 }
4525
4526
4527 /*
4528  * Array of stat "descriptions"
4529  */
4530 static cptr desc_stat_pos[] =
4531 {
4532 #ifdef JP
4533 "¶¯¤¯",
4534 #else
4535         "strong",
4536 #endif
4537
4538 #ifdef JP
4539 "ÃÎÅª¤Ë",
4540 #else
4541         "smart",
4542 #endif
4543
4544 #ifdef JP
4545 "¸¤¯",
4546 #else
4547         "wise",
4548 #endif
4549
4550 #ifdef JP
4551 "´ïÍÑ¤Ë",
4552 #else
4553         "dextrous",
4554 #endif
4555
4556 #ifdef JP
4557 "·ò¹¯¤Ë",
4558 #else
4559         "healthy",
4560 #endif
4561
4562 #ifdef JP
4563 "Èþ¤·¤¯"
4564 #else
4565         "cute"
4566 #endif
4567
4568 };
4569
4570
4571 /*
4572  * Array of stat "descriptions"
4573  */
4574 static cptr desc_stat_neg[] =
4575 {
4576 #ifdef JP
4577 "¼å¤¯",
4578 "ÌµÃÎ¤Ë",
4579 "¶ò¤«¤Ë",
4580 "ÉÔ´ïÍÑ¤Ë",
4581 "ÉÔ·ò¹¯¤Ë",
4582 "½¹¤¯"
4583 #else
4584         "weak",
4585         "stupid",
4586         "naive",
4587         "clumsy",
4588         "sickly",
4589         "ugly"
4590 #endif
4591
4592 };
4593
4594
4595 /*
4596  * Lose a "point"
4597  */
4598 bool do_dec_stat(int stat)
4599 {
4600         bool sust = FALSE;
4601
4602         /* Access the "sustain" */
4603         switch (stat)
4604         {
4605                 case A_STR: if (p_ptr->sustain_str) sust = TRUE; break;
4606                 case A_INT: if (p_ptr->sustain_int) sust = TRUE; break;
4607                 case A_WIS: if (p_ptr->sustain_wis) sust = TRUE; break;
4608                 case A_DEX: if (p_ptr->sustain_dex) sust = TRUE; break;
4609                 case A_CON: if (p_ptr->sustain_con) sust = TRUE; break;
4610                 case A_CHR: if (p_ptr->sustain_chr) sust = TRUE; break;
4611         }
4612
4613         /* Sustain */
4614         if (sust && (!ironman_nightmare || randint0(13)))
4615         {
4616                 /* Message */
4617 #ifdef JP
4618 msg_format("%s¤Ê¤Ã¤¿µ¤¤¬¤·¤¿¤¬¡¢¤¹¤°¤Ë¸µ¤ËÌá¤Ã¤¿¡£",
4619 #else
4620                 msg_format("You feel %s for a moment, but the feeling passes.",
4621 #endif
4622
4623                                 desc_stat_neg[stat]);
4624
4625                 /* Notice effect */
4626                 return (TRUE);
4627         }
4628
4629         /* Attempt to reduce the stat */
4630         if (dec_stat(stat, 10, (ironman_nightmare && !randint0(13))))
4631         {
4632                 /* Message */
4633 #ifdef JP
4634 msg_format("¤Ò¤É¤¯%s¤Ê¤Ã¤¿µ¤¤¬¤¹¤ë¡£", desc_stat_neg[stat]);
4635 #else
4636                 msg_format("You feel very %s.", desc_stat_neg[stat]);
4637 #endif
4638
4639
4640                 /* Notice effect */
4641                 return (TRUE);
4642         }
4643
4644         /* Nothing obvious */
4645         return (FALSE);
4646 }
4647
4648
4649 /*
4650  * Restore lost "points" in a stat
4651  */
4652 bool do_res_stat(int stat)
4653 {
4654         /* Attempt to increase */
4655         if (res_stat(stat))
4656         {
4657                 /* Message */
4658 #ifdef JP
4659 msg_format("¸µÄÌ¤ê¤Ë%s¤Ê¤Ã¤¿µ¤¤¬¤¹¤ë¡£", desc_stat_pos[stat]);
4660 #else
4661                 msg_format("You feel less %s.", desc_stat_neg[stat]);
4662 #endif
4663
4664
4665                 /* Notice */
4666                 return (TRUE);
4667         }
4668
4669         /* Nothing obvious */
4670         return (FALSE);
4671 }
4672
4673
4674 /*
4675  * Gain a "point" in a stat
4676  */
4677 bool do_inc_stat(int stat)
4678 {
4679         bool res;
4680
4681         /* Restore strength */
4682         res = res_stat(stat);
4683
4684         /* Attempt to increase */
4685         if (inc_stat(stat))
4686         {
4687                 if (stat == A_WIS)
4688                 {
4689                         chg_virtue(V_ENLIGHTEN, 1);
4690                         chg_virtue(V_FAITH, 1);
4691                 }
4692                 else if (stat == A_INT)
4693                 {
4694                         chg_virtue(V_KNOWLEDGE, 1);
4695                         chg_virtue(V_ENLIGHTEN, 1);
4696                 }
4697                 else if (stat == A_CON)
4698                         chg_virtue(V_VITALITY, 1);
4699
4700                 /* Message */
4701 #ifdef JP
4702 msg_format("¥ï¡¼¥ª¡ª¤È¤Æ¤â%s¤Ê¤Ã¤¿¡ª", desc_stat_pos[stat]);
4703 #else
4704                 msg_format("Wow!  You feel very %s!", desc_stat_pos[stat]);
4705 #endif
4706
4707
4708                 /* Notice */
4709                 return (TRUE);
4710         }
4711
4712         /* Restoration worked */
4713         if (res)
4714         {
4715                 /* Message */
4716 #ifdef JP
4717 msg_format("¸µÄÌ¤ê¤Ë%s¤Ê¤Ã¤¿µ¤¤¬¤¹¤ë¡£", desc_stat_pos[stat]);
4718 #else
4719                 msg_format("You feel less %s.", desc_stat_neg[stat]);
4720 #endif
4721
4722
4723                 /* Notice */
4724                 return (TRUE);
4725         }
4726
4727         /* Nothing obvious */
4728         return (FALSE);
4729 }
4730
4731
4732 /*
4733  * Restores any drained experience
4734  */
4735 bool restore_level(void)
4736 {
4737         /* Restore experience */
4738         if (p_ptr->exp < p_ptr->max_exp)
4739         {
4740                 /* Message */
4741 #ifdef JP
4742 msg_print("À¸Ì¿ÎÏ¤¬Ìá¤Ã¤Æ¤¤¿µ¤¤¬¤¹¤ë¡£");
4743 #else
4744                 msg_print("You feel your life energies returning.");
4745 #endif
4746
4747
4748                 /* Restore the experience */
4749                 p_ptr->exp = p_ptr->max_exp;
4750
4751                 /* Check the experience */
4752                 check_experience();
4753
4754                 /* Did something */
4755                 return (TRUE);
4756         }
4757
4758         /* No effect */
4759         return (FALSE);
4760 }
4761
4762
4763 /*
4764  * Forget everything
4765  */
4766 bool lose_all_info(void)
4767 {
4768         int i;
4769
4770         chg_virtue(V_KNOWLEDGE, -5);
4771         chg_virtue(V_ENLIGHTEN, -5);
4772
4773         /* Forget info about objects */
4774         for (i = 0; i < INVEN_TOTAL; i++)
4775         {
4776                 object_type *o_ptr = &inventory[i];
4777
4778                 /* Skip non-objects */
4779                 if (!o_ptr->k_idx) continue;
4780
4781                 /* Allow "protection" by the MENTAL flag */
4782                 if (o_ptr->ident & (IDENT_MENTAL)) continue;
4783
4784                 /* Remove "default inscriptions" */
4785                 o_ptr->feeling = FEEL_NONE;
4786
4787                 /* Hack -- Clear the "empty" flag */
4788                 o_ptr->ident &= ~(IDENT_EMPTY);
4789
4790                 /* Hack -- Clear the "known" flag */
4791                 o_ptr->ident &= ~(IDENT_KNOWN);
4792
4793                 /* Hack -- Clear the "felt" flag */
4794                 o_ptr->ident &= ~(IDENT_SENSE);
4795         }
4796
4797         /* Recalculate bonuses */
4798         p_ptr->update |= (PU_BONUS);
4799
4800         /* Combine / Reorder the pack (later) */
4801         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
4802
4803         /* Window stuff */
4804         p_ptr->window |= (PW_INVEN | PW_EQUIP | PW_PLAYER);
4805
4806         /* Mega-Hack -- Forget the map */
4807         wiz_dark();
4808
4809         /* It worked */
4810         return (TRUE);
4811 }
4812
4813
4814 void do_poly_wounds(void)
4815 {
4816         /* Changed to always provide at least _some_ healing */
4817         s16b wounds = p_ptr->cut;
4818         s16b hit_p = (p_ptr->mhp - p_ptr->chp);
4819         s16b change = damroll(p_ptr->lev, 5);
4820         bool Nasty_effect = one_in_(5);
4821
4822         if (!(wounds || hit_p || Nasty_effect)) return;
4823
4824 #ifdef JP
4825 msg_print("½ý¤¬¤è¤ê·Ú¤¤¤â¤Î¤ËÊÑ²½¤·¤¿¡£");
4826 #else
4827         msg_print("Your wounds are polymorphed into less serious ones.");
4828 #endif
4829
4830         hp_player(change);
4831         if (Nasty_effect)
4832         {
4833 #ifdef JP
4834 msg_print("¿·¤¿¤Ê½ý¤¬¤Ç¤¤¿¡ª");
4835 take_hit(DAMAGE_LOSELIFE, change / 2, "ÊÑ²½¤·¤¿½ý", -1);
4836 #else
4837                 msg_print("A new wound was created!");
4838                 take_hit(DAMAGE_LOSELIFE, change / 2, "a polymorphed wound", -1);
4839 #endif
4840
4841                 set_cut(change);
4842         }
4843         else
4844         {
4845                 set_cut(p_ptr->cut - (change / 2));
4846         }
4847 }
4848
4849
4850 /*
4851  * Change player race
4852  */
4853 void change_race(int new_race, cptr effect_msg)
4854 {
4855         cptr title = race_info[new_race].title;
4856         int  old_race = p_ptr->prace;
4857
4858 #ifdef JP
4859         msg_format("¤¢¤Ê¤¿¤Ï%s%s¤ËÊÑ²½¤·¤¿¡ª", effect_msg, title);
4860 #else
4861         msg_format("You turn into %s %s%s!", (!effect_msg[0] && is_a_vowel(title[0]) ? "an" : "a"), effect_msg, title);
4862 #endif
4863
4864         chg_virtue(V_CHANCE, 2);
4865
4866         if (p_ptr->prace < 32)
4867         {
4868                 p_ptr->old_race1 |= 1L << p_ptr->prace;
4869         }
4870         else
4871         {
4872                 p_ptr->old_race2 |= 1L << (p_ptr->prace-32);
4873         }
4874         p_ptr->prace = new_race;
4875         rp_ptr = &race_info[p_ptr->prace];
4876
4877         /* Experience factor */
4878         p_ptr->expfact = rp_ptr->r_exp + cp_ptr->c_exp;
4879
4880         /*
4881          * The speed bonus of Klackons and Sprites are disabled
4882          * and the experience penalty is decreased.
4883          */
4884         if (((p_ptr->pclass == CLASS_MONK) || (p_ptr->pclass == CLASS_FORCETRAINER) || (p_ptr->pclass == CLASS_NINJA)) && ((p_ptr->prace == RACE_KLACKON) || (p_ptr->prace == RACE_SPRITE)))
4885                 p_ptr->expfact -= 15;
4886
4887         /* Get character's height and weight */
4888         get_height_weight();
4889
4890         /* Hitdice */
4891         if (p_ptr->pclass == CLASS_SORCERER)
4892                 p_ptr->hitdie = rp_ptr->r_mhp/2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
4893         else
4894                 p_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
4895
4896         do_cmd_rerate(FALSE);
4897
4898         /* The experience level may be modified */
4899         check_experience();
4900
4901         p_ptr->redraw |= (PR_BASIC);
4902
4903         p_ptr->update |= (PU_BONUS);
4904
4905         handle_stuff();
4906
4907         /* Load an autopick preference file */
4908         if (old_race != p_ptr->prace) autopick_load_pref(FALSE);
4909
4910         /* Player's graphic tile may change */
4911         lite_spot(py, px);
4912 }
4913
4914
4915 void do_poly_self(void)
4916 {
4917         int power = p_ptr->lev;
4918
4919 #ifdef JP
4920 msg_print("¤¢¤Ê¤¿¤ÏÊÑ²½¤ÎË¬¤ì¤ò´¶¤¸¤¿...");
4921 #else
4922         msg_print("You feel a change coming over you...");
4923 #endif
4924
4925         chg_virtue(V_CHANCE, 1);
4926
4927         if ((power > randint0(20)) && one_in_(3) && (p_ptr->prace != RACE_ANDROID))
4928         {
4929                 char effect_msg[80] = "";
4930                 int new_race;
4931
4932                 /* Some form of racial polymorph... */
4933                 power -= 10;
4934
4935                 if ((power > randint0(5)) && one_in_(4))
4936                 {
4937                         /* sex change */
4938                         power -= 2;
4939
4940                         if (p_ptr->psex == SEX_MALE)
4941                         {
4942                                 p_ptr->psex = SEX_FEMALE;
4943                                 sp_ptr = &sex_info[p_ptr->psex];
4944 #ifdef JP
4945 sprintf(effect_msg, "½÷À¤Î");
4946 #else
4947                                 sprintf(effect_msg, "female ");
4948 #endif
4949
4950                         }
4951                         else
4952                         {
4953                                 p_ptr->psex = SEX_MALE;
4954                                 sp_ptr = &sex_info[p_ptr->psex];
4955 #ifdef JP
4956 sprintf(effect_msg, "ÃËÀ¤Î");
4957 #else
4958                                 sprintf(effect_msg, "male ");
4959 #endif
4960
4961                         }
4962                 }
4963
4964                 if ((power > randint0(30)) && one_in_(5))
4965                 {
4966                         int tmp = 0;
4967
4968                         /* Harmful deformity */
4969                         power -= 15;
4970
4971                         while (tmp < 6)
4972                         {
4973                                 if (one_in_(2))
4974                                 {
4975                                         (void)dec_stat(tmp, randint1(6) + 6, one_in_(3));
4976                                         power -= 1;
4977                                 }
4978                                 tmp++;
4979                         }
4980
4981                         /* Deformities are discriminated against! */
4982                         (void)dec_stat(A_CHR, randint1(6), TRUE);
4983
4984                         if (effect_msg[0])
4985                         {
4986                                 char tmp_msg[10];
4987 #ifdef JP
4988                                 sprintf(tmp_msg,"%s",effect_msg);
4989                                 sprintf(effect_msg,"´ñ·Á¤Î%s",tmp_msg);
4990 #else
4991                                 sprintf(tmp_msg,"%s ",effect_msg);
4992                                 sprintf(effect_msg,"deformed %s ",tmp_msg);
4993 #endif
4994
4995                         }
4996                         else
4997                         {
4998 #ifdef JP
4999                                 sprintf(effect_msg,"´ñ·Á¤Î");
5000 #else
5001                                 sprintf(effect_msg,"deformed ");
5002 #endif
5003
5004                         }
5005                 }
5006
5007                 while ((power > randint0(20)) && one_in_(10))
5008                 {
5009                         /* Polymorph into a less mutated form */
5010                         power -= 10;
5011
5012                         if (!lose_mutation(0))
5013 #ifdef JP
5014 msg_print("´ñÌ¯¤Ê¤¯¤é¤¤ÉáÄÌ¤Ë¤Ê¤Ã¤¿µ¤¤¬¤¹¤ë¡£");
5015 #else
5016                                 msg_print("You feel oddly normal.");
5017 #endif
5018
5019                 }
5020
5021                 do
5022                 {
5023                         new_race = randint0(MAX_RACES);
5024                 }
5025                 while ((new_race == p_ptr->prace) || (new_race == RACE_ANDROID));
5026
5027                 change_race(new_race, effect_msg);
5028         }
5029
5030         if ((power > randint0(30)) && one_in_(6))
5031         {
5032                 int tmp = 0;
5033
5034                 /* Abomination! */
5035                 power -= 20;
5036
5037 #ifdef JP
5038 msg_format("%s¤Î¹½À®¤¬ÊÑ²½¤·¤¿¡ª", p_ptr->prace == RACE_ANDROID ? "µ¡³£" : "ÆâÂ¡");
5039 #else
5040                 msg_print("Your internal organs are rearranged!");
5041 #endif
5042
5043                 while (tmp < 6)
5044                 {
5045                         (void)dec_stat(tmp, randint1(6) + 6, one_in_(3));
5046                         tmp++;
5047                 }
5048                 if (one_in_(6))
5049                 {
5050 #ifdef JP
5051                         msg_print("¸½ºß¤Î»Ñ¤ÇÀ¸¤¤Æ¤¤¤¯¤Î¤Ïº¤Æñ¤Ê¤è¤¦¤À¡ª");
5052                         take_hit(DAMAGE_LOSELIFE, damroll(randint1(10), p_ptr->lev), "Ã×Ì¿Åª¤ÊÆÍÁ³ÊÑ°Û", -1);
5053 #else
5054                         msg_print("You find living difficult in your present form!");
5055                         take_hit(DAMAGE_LOSELIFE, damroll(randint1(10), p_ptr->lev), "a lethal mutation", -1);
5056 #endif
5057
5058                         power -= 10;
5059                 }
5060         }
5061
5062         if ((power > randint0(20)) && one_in_(4))
5063         {
5064                 power -= 10;
5065
5066                 get_max_stats();
5067                 do_cmd_rerate(FALSE);
5068         }
5069
5070         while ((power > randint0(15)) && one_in_(3))
5071         {
5072                 power -= 7;
5073                 (void)gain_random_mutation(0);
5074         }
5075
5076         if (power > randint0(5))
5077         {
5078                 power -= 5;
5079                 do_poly_wounds();
5080         }
5081
5082         /* Note: earlier deductions may have left power < 0 already. */
5083         while (power > 0)
5084         {
5085                 mutate_player();
5086                 power--;
5087         }
5088 }
5089
5090
5091 /*
5092  * Decreases players hit points and sets death flag if necessary
5093  *
5094  * XXX XXX XXX Invulnerability needs to be changed into a "shield"
5095  *
5096  * XXX XXX XXX Hack -- this function allows the user to save (or quit)
5097  * the game when he dies, since the "You die." message is shown before
5098  * setting the player to "dead".
5099  */
5100
5101 int take_hit(int damage_type, int damage, cptr hit_from, int monspell)
5102 {
5103         int old_chp = p_ptr->chp;
5104
5105         char death_message[1024];
5106         char tmp[80];
5107
5108         int warning = (p_ptr->mhp * hitpoint_warn / 10);
5109
5110         /* Paranoia */
5111         if (p_ptr->is_dead) return 0;
5112
5113         if (p_ptr->sutemi) damage *= 2;
5114         if (p_ptr->special_defense & KATA_IAI) damage += (damage + 4) / 5;
5115
5116         if (easy_band) damage = (damage+1)/2;
5117
5118         if (damage_type != DAMAGE_USELIFE)
5119         {
5120                 /* Disturb */
5121                 disturb(1, 1);
5122                 if (auto_more)
5123                 {
5124                         now_damaged = TRUE;
5125                 }
5126         }
5127
5128         if (monspell >= 0) learn_spell(monspell);
5129
5130         /* Mega-Hack -- Apply "invulnerability" */
5131         if ((damage_type != DAMAGE_USELIFE) && (damage_type != DAMAGE_LOSELIFE))
5132         {
5133                 if (IS_INVULN() && (damage < 9000))
5134                 {
5135                         if (damage_type == DAMAGE_FORCE)
5136                         {
5137 #ifdef JP
5138                                 msg_print("¥Ð¥ê¥¢¤¬ÀÚ¤êÎö¤«¤ì¤¿¡ª");
5139 #else
5140                                 msg_print("The attack cuts your shield of invulnerability open!");
5141 #endif
5142                         }
5143                         else if (one_in_(PENETRATE_INVULNERABILITY))
5144                         {
5145 #ifdef JP
5146                                 msg_print("ÌµÅ¨¤Î¥Ð¥ê¥¢¤òÇË¤Ã¤Æ¹¶·â¤µ¤ì¤¿¡ª");
5147 #else
5148                                 msg_print("The attack penetrates your shield of invulnerability!");
5149 #endif
5150                         }
5151                         else
5152                         {
5153                                 return 0;
5154                         }
5155                 }
5156
5157                 if (CHECK_MULTISHADOW())
5158                 {
5159                         if (damage_type == DAMAGE_FORCE)
5160                         {
5161 #ifdef JP
5162                                 msg_print("¸¸±Æ¤â¤í¤È¤âÂÎ¤¬ÀÚ¤êÎö¤«¤ì¤¿¡ª");
5163 #else
5164                                 msg_print("The attack hits Shadow together with you!");
5165 #endif
5166                         }
5167                         else if (damage_type == DAMAGE_ATTACK)
5168                         {
5169 #ifdef JP
5170                                 msg_print("¹¶·â¤Ï¸¸±Æ¤ËÌ¿Ãæ¤·¡¢¤¢¤Ê¤¿¤Ë¤ÏÆÏ¤«¤Ê¤«¤Ã¤¿¡£");
5171 #else
5172                                 msg_print("The attack hits Shadow, you are unharmed!");
5173 #endif
5174                                 return 0;
5175                         }
5176                 }
5177
5178                 if (p_ptr->wraith_form)
5179                 {
5180                         if (damage_type == DAMAGE_FORCE)
5181                         {
5182 #ifdef JP
5183                                 msg_print("È¾Êª¼Á¤ÎÂÎ¤¬ÀÚ¤êÎö¤«¤ì¤¿¡ª");
5184 #else
5185                                 msg_print("The attack cuts through your ethereal body!");
5186 #endif
5187                         }
5188                         else
5189                         {
5190                                 damage /= 2;
5191                                 if ((damage == 0) && one_in_(2)) damage = 1;
5192                         }
5193                 }
5194
5195                 if (p_ptr->special_defense & KATA_MUSOU)
5196                 {
5197                         damage /= 2;
5198                         if ((damage == 0) && one_in_(2)) damage = 1;
5199                 }
5200         } /* not if LOSELIFE USELIFE */
5201
5202         /* Hurt the player */
5203         p_ptr->chp -= damage;
5204         if(damage_type == DAMAGE_GENO && p_ptr->chp < 0)
5205         {
5206                 damage += p_ptr->chp;
5207                 p_ptr->chp = 0;
5208         }
5209
5210         /* Display the hitpoints */
5211         p_ptr->redraw |= (PR_HP);
5212
5213         /* Window stuff */
5214         p_ptr->window |= (PW_PLAYER);
5215
5216         if (damage_type != DAMAGE_GENO && p_ptr->chp == 0)
5217         {
5218                 chg_virtue(V_SACRIFICE, 1);
5219                 chg_virtue(V_CHANCE, 2);
5220         }
5221
5222         /* Dead player */
5223         if (p_ptr->chp < 0)
5224         {
5225                 bool android = (p_ptr->prace == RACE_ANDROID ? TRUE : FALSE);
5226
5227 #ifdef JP       /* »à¤ó¤À»þ¤Ë¶¯À©½ªÎ»¤·¤Æ»à¤ò²óÈò¤Ç¤¤Ê¤¯¤·¤Æ¤ß¤¿ by Habu */
5228                 if (!cheat_save)
5229                         if(!save_player()) msg_print("¥»¡¼¥Ö¼ºÇÔ¡ª");
5230 #endif
5231
5232                 /* Sound */
5233                 sound(SOUND_DEATH);
5234
5235                 chg_virtue(V_SACRIFICE, 10);
5236
5237                 handle_stuff();
5238
5239                 /* Leaving */
5240                 p_ptr->leaving = TRUE;
5241
5242                 /* Note death */
5243                 p_ptr->is_dead = TRUE;
5244
5245                 if (p_ptr->inside_arena)
5246                 {
5247                         cptr m_name = r_name+r_info[arena_info[p_ptr->arena_number].r_idx].name;
5248 #ifdef JP
5249                         msg_format("¤¢¤Ê¤¿¤Ï%s¤ÎÁ°¤ËÇÔ¤ìµî¤Ã¤¿¡£", m_name);
5250 #else
5251                         msg_format("You are beaten by %s.", m_name);
5252 #endif
5253                         msg_print(NULL);
5254                         if (record_arena) do_cmd_write_nikki(NIKKI_ARENA, -1 - p_ptr->arena_number, m_name);
5255                 }
5256                 else
5257                 {
5258                         int q_idx = quest_number(dun_level);
5259                         bool seppuku = streq(hit_from, "Seppuku");
5260                         bool winning_seppuku = p_ptr->total_winner && seppuku;
5261
5262 #ifdef WORLD_SCORE
5263                         /* Make screen dump */
5264                         screen_dump = make_screen_dump();
5265 #endif
5266
5267                         /* Note cause of death */
5268                         if (seppuku)
5269                         {
5270                                 strcpy(p_ptr->died_from, hit_from);
5271 #ifdef JP
5272                                 if (!winning_seppuku) strcpy(p_ptr->died_from, "ÀÚÊ¢");
5273 #endif
5274                         }
5275                         else
5276                         {
5277                                 char dummy[1024];
5278 #ifdef JP
5279                                 sprintf(dummy, "%s%s%s", !p_ptr->paralyzed ? "" : p_ptr->free_act ? "Ä¦Áü¾õÂÖ¤Ç" : "Ëãáã¾õÂÖ¤Ç", p_ptr->image ? "¸¸³Ð¤ËÏÄ¤ó¤À" : "", hit_from);
5280 #else
5281                                 sprintf(dummy, "%s%s", hit_from, !p_ptr->paralyzed ? "" : " while helpless");
5282 #endif
5283                                 my_strcpy(p_ptr->died_from, dummy, sizeof p_ptr->died_from);
5284                         }
5285
5286                         /* No longer a winner */
5287                         p_ptr->total_winner = FALSE;
5288
5289                         if (winning_seppuku)
5290                         {
5291 #ifdef JP
5292                                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, "¾¡Íø¤Î¸åÀÚÊ¢¤·¤¿¡£");
5293 #else
5294                                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, "did Seppuku after the winning.");
5295 #endif
5296                         }
5297                         else
5298                         {
5299                                 char buf[20];
5300
5301                                 if (p_ptr->inside_arena)
5302 #ifdef JP
5303                                         strcpy(buf,"¥¢¥ê¡¼¥Ê");
5304 #else
5305                                         strcpy(buf,"in the Arena");
5306 #endif
5307                                 else if (!dun_level)
5308 #ifdef JP
5309                                         strcpy(buf,"ÃÏ¾å");
5310 #else
5311                                         strcpy(buf,"on the surface");
5312 #endif
5313                                 else if (q_idx && (is_fixed_quest_idx(q_idx) &&
5314                                          !((q_idx == QUEST_OBERON) || (q_idx == QUEST_SERPENT))))
5315 #ifdef JP
5316                                         strcpy(buf,"¥¯¥¨¥¹¥È");
5317 #else
5318                                         strcpy(buf,"in a quest");
5319 #endif
5320                                 else
5321 #ifdef JP
5322                                         sprintf(buf,"%d³¬", dun_level);
5323 #else
5324                                         sprintf(buf,"level %d", dun_level);
5325 #endif
5326
5327 #ifdef JP
5328                                 sprintf(tmp, "%s¤Ç%s¤Ë»¦¤µ¤ì¤¿¡£", buf, p_ptr->died_from);
5329 #else
5330                                 sprintf(tmp, "killed by %s %s.", p_ptr->died_from, buf);
5331 #endif
5332                                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, tmp);
5333                         }
5334
5335 #ifdef JP
5336                         do_cmd_write_nikki(NIKKI_GAMESTART, 1, "-------- ¥²¡¼¥à¥ª¡¼¥Ð¡¼ --------");
5337 #else
5338                         do_cmd_write_nikki(NIKKI_GAMESTART, 1, "--------   Game  Over   --------");
5339 #endif
5340                         do_cmd_write_nikki(NIKKI_BUNSHOU, 1, "\n\n\n\n");
5341
5342                         flush();
5343
5344 #ifdef JP
5345                         if (get_check_strict("²èÌÌ¤òÊÝÂ¸¤·¤Þ¤¹¤«¡©", CHECK_NO_HISTORY))
5346 #else
5347                         if (get_check_strict("Dump the screen? ", CHECK_NO_HISTORY))
5348 #endif
5349                         {
5350                                 do_cmd_save_screen();
5351                         }
5352
5353                         flush();
5354
5355                         /* Initialize "last message" buffer */
5356                         if (p_ptr->last_message) string_free(p_ptr->last_message);
5357                         p_ptr->last_message = NULL;
5358
5359                         /* Hack -- Note death */
5360                         if (!last_words)
5361                         {
5362 #ifdef JP
5363                                 msg_format("¤¢¤Ê¤¿¤Ï%s¤Þ¤·¤¿¡£", android ? "²õ¤ì" : "»à¤Ë");
5364 #else
5365                                 msg_print(android ? "You are broken." : "You die.");
5366 #endif
5367
5368                                 msg_print(NULL);
5369                         }
5370                         else
5371                         {
5372                                 if (winning_seppuku)
5373                                 {
5374 #ifdef JP
5375                                         get_rnd_line("seppuku_j.txt", 0, death_message);
5376 #else
5377                                         get_rnd_line("seppuku.txt", 0, death_message);
5378 #endif
5379                                 }
5380                                 else
5381                                 {
5382 #ifdef JP
5383                                         get_rnd_line("death_j.txt", 0, death_message);
5384 #else
5385                                         get_rnd_line("death.txt", 0, death_message);
5386 #endif
5387                                 }
5388
5389                                 do
5390                                 {
5391 #ifdef JP
5392                                         while (!get_string(winning_seppuku ? "¼À¤¤Î¶ç: " : "ÃÇËöËâ¤Î¶«¤Ó: ", death_message, 1024)) ;
5393 #else
5394                                         while (!get_string("Last word: ", death_message, 1024)) ;
5395 #endif
5396                                 }
5397 #ifdef JP
5398                                 while (winning_seppuku && !get_check_strict("¤è¤í¤·¤¤¤Ç¤¹¤«¡©", CHECK_NO_HISTORY));
5399 #else
5400                                 while (winning_seppuku && !get_check_strict("Are you sure? ", CHECK_NO_HISTORY));
5401 #endif
5402
5403                                 if (death_message[0] == '\0')
5404                                 {
5405 #ifdef JP
5406                                         strcpy(death_message, format("¤¢¤Ê¤¿¤Ï%s¤Þ¤·¤¿¡£", android ? "²õ¤ì" : "»à¤Ë"));
5407 #else
5408                                         strcpy(death_message, android ? "You are broken." : "You die.");
5409 #endif
5410                                 }
5411                                 else p_ptr->last_message = string_make(death_message);
5412
5413 #ifdef JP
5414                                 if (winning_seppuku)
5415                                 {
5416                                         int i, len;
5417                                         int w = Term->wid;
5418                                         int h = Term->hgt;
5419                                         int msg_pos_x[9] = {  5,  7,  9, 12,  14,  17,  19,  21, 23};
5420                                         int msg_pos_y[9] = {  3,  4,  5,  4,   5,   4,   5,   6,  4};
5421                                         cptr str;
5422                                         char* str2;
5423
5424                                         Term_clear();
5425
5426                                         /* ºù»¶¤ë */
5427                                         for (i = 0; i < 40; i++)
5428                                                 Term_putstr(randint0(w / 2) * 2, randint0(h), 2, TERM_VIOLET, "¦Ô");
5429
5430                                         str = death_message;
5431                                         if (strncmp(str, "¡Ö", 2) == 0) str += 2;
5432
5433                                         str2 = my_strstr(str, "¡×");
5434                                         if (str2 != NULL) *str2 = '\0';
5435
5436                                         i = 0;
5437                                         while (i < 9)
5438                                         {
5439                                                 str2 = my_strstr(str, " ");
5440                                                 if (str2 == NULL) len = strlen(str);
5441                                                 else len = str2 - str;
5442
5443                                                 if (len != 0)
5444                                                 {
5445                                                         Term_putstr_v(w * 3 / 4 - 2 - msg_pos_x[i] * 2, msg_pos_y[i], len,
5446                                                         TERM_WHITE, str);
5447                                                         if (str2 == NULL) break;
5448                                                         i++;
5449                                                 }
5450                                                 str = str2 + 1;
5451                                                 if (*str == 0) break;
5452                                         }
5453
5454                                         /* Hide cursor */
5455                                         Term_putstr(w-1, h-1, 1, TERM_WHITE, " ");
5456
5457                                         flush();
5458 #ifdef WORLD_SCORE
5459                                         /* Make screen dump */
5460                                         screen_dump = make_screen_dump();
5461 #endif
5462
5463                                         /* Wait a key press */
5464                                         (void)inkey();
5465                                 }
5466                                 else
5467 #endif
5468                                         msg_print(death_message);
5469                         }
5470                 }
5471
5472                 /* Dead */
5473                 return damage;
5474         }
5475
5476         handle_stuff();
5477
5478         /* Hitpoint warning */
5479         if (p_ptr->chp < warning)
5480         {
5481                 /* Hack -- bell on first notice */
5482                 if (old_chp > warning) bell();
5483
5484                 sound(SOUND_WARN);
5485
5486                 if (record_danger && (old_chp > warning))
5487                 {
5488                         if (p_ptr->image && damage_type == DAMAGE_ATTACK)
5489 #ifdef JP
5490                                 hit_from = "²¿¤«";
5491 #else
5492                                 hit_from = "something";
5493 #endif
5494
5495 #ifdef JP
5496                         sprintf(tmp,"%s¤Ë¤è¤Ã¤Æ¥Ô¥ó¥Á¤Ë´Ù¤Ã¤¿¡£",hit_from);
5497 #else
5498                         sprintf(tmp,"A critical situation because of %s.",hit_from);
5499 #endif
5500                         do_cmd_write_nikki(NIKKI_BUNSHOU, 0, tmp);
5501                 }
5502
5503                 if (auto_more)
5504                 {
5505                         /* stop auto_more even if DAMAGE_USELIFE */
5506                         now_damaged = TRUE;
5507                 }
5508
5509                 /* Message */
5510 #ifdef JP
5511 msg_print("*** ·Ù¹ð:Äã¥Ò¥Ã¥È¡¦¥Ý¥¤¥ó¥È¡ª ***");
5512 #else
5513                 msg_print("*** LOW HITPOINT WARNING! ***");
5514 #endif
5515
5516                 msg_print(NULL);
5517                 flush();
5518         }
5519         if (p_ptr->wild_mode && !p_ptr->leaving && (p_ptr->chp < MAX(warning, p_ptr->mhp/5)))
5520         {
5521                 change_wild_mode();
5522         }
5523         return damage;
5524 }
5525
5526
5527 /*
5528  * Gain experience
5529  */
5530 void gain_exp_64(s32b amount, u32b amount_frac)
5531 {
5532         if (p_ptr->is_dead) return;
5533
5534         if (p_ptr->prace == RACE_ANDROID) return;
5535
5536         /* Gain some experience */
5537         s64b_add(&(p_ptr->exp), &(p_ptr->exp_frac), amount, amount_frac);
5538
5539         /* Slowly recover from experience drainage */
5540         if (p_ptr->exp < p_ptr->max_exp)
5541         {
5542                 /* Gain max experience (20%) (was 10%) */
5543                 p_ptr->max_exp += amount / 5;
5544         }
5545
5546         /* Check Experience */
5547         check_experience();
5548 }
5549
5550
5551 /*
5552  * Gain experience
5553  */
5554 void gain_exp(s32b amount)
5555 {
5556         gain_exp_64(amount, 0L);
5557 }
5558
5559
5560 void calc_android_exp(void)
5561 {
5562         int i;
5563         u32b total_exp = 0;
5564         if (p_ptr->is_dead) return;
5565
5566         if (p_ptr->prace != RACE_ANDROID) return;
5567
5568         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
5569         {
5570                 object_type *o_ptr = &inventory[i];
5571                 object_type forge;
5572                 object_type *q_ptr = &forge;
5573                 u32b value, exp;
5574                 int level = MAX(k_info[o_ptr->k_idx].level - 8, 1);
5575
5576                 if ((i == INVEN_RIGHT) || (i == INVEN_LEFT) || (i == INVEN_NECK) || (i == INVEN_LITE)) continue;
5577                 if (!o_ptr->k_idx) continue;
5578
5579                 /* Wipe the object */
5580                 object_wipe(q_ptr);
5581
5582                 object_copy(q_ptr, o_ptr);
5583                 q_ptr->discount = 0;
5584                 q_ptr->curse_flags = 0L;
5585
5586                 if (object_is_fixed_artifact(o_ptr))
5587                 {
5588                         level = (level + MAX(a_info[o_ptr->name1].level - 8, 5)) / 2;
5589                         level += MIN(20, a_info[o_ptr->name1].rarity/(a_info[o_ptr->name1].gen_flags & TRG_INSTA_ART ? 10 : 3));
5590                 }
5591                 else if (object_is_ego(o_ptr))
5592                 {
5593                         level += MAX(3, (e_info[o_ptr->name2].rating - 5)/2);
5594                 }
5595                 else if (o_ptr->art_name)
5596                 {
5597                         s32b total_flags = flag_cost(o_ptr, o_ptr->pval);
5598                         int fake_level;
5599
5600                         if (!object_is_weapon_ammo(o_ptr))
5601                         {
5602                                 /* For armors */
5603                                 if (total_flags < 15000) fake_level = 10;
5604                                 else if (total_flags < 35000) fake_level = 25;
5605                                 else fake_level = 40;
5606                         }
5607                         else
5608                         {
5609                                 /* For weapons */
5610                                 if (total_flags < 20000) fake_level = 10;
5611                                 else if (total_flags < 45000) fake_level = 25;
5612                                 else fake_level = 40;
5613                         }
5614
5615                         level = MAX(level, (level + MAX(fake_level - 8, 5)) / 2 + 3);
5616                 }
5617
5618                 value = object_value_real(q_ptr);
5619
5620                 if (value <= 0) continue;
5621                 if ((o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->sval == SV_ABUNAI_MIZUGI) && (p_ptr->pseikaku != SEIKAKU_SEXY)) value /= 32;
5622                 if (value > 5000000L) value = 5000000L;
5623                 if ((o_ptr->tval == TV_DRAG_ARMOR) || (o_ptr->tval == TV_CARD)) level /= 2;
5624
5625                 if (object_is_artifact(o_ptr) || object_is_ego(o_ptr) ||
5626                     (o_ptr->tval == TV_DRAG_ARMOR) ||
5627                     ((o_ptr->tval == TV_HELM) && (o_ptr->sval == SV_DRAGON_HELM)) ||
5628                     ((o_ptr->tval == TV_SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) ||
5629                     ((o_ptr->tval == TV_GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) ||
5630                     ((o_ptr->tval == TV_BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)) ||
5631                     ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DIAMOND_EDGE)))
5632                 {
5633                         if (level > 65) level = 35 + (level - 65) / 5;
5634                         else if (level > 35) level = 25 + (level - 35) / 3;
5635                         else if (level > 15) level = 15 + (level - 15) / 2;
5636                         exp = MIN(100000L, value) * level * level / 2;
5637                         if (value > 100000L)
5638                                 exp += (value - 100000L) * level * level / 8;
5639                 }
5640                 else
5641                 {
5642                         exp = MIN(100000L, value) * level;
5643                         if (value > 100000L)
5644                                 exp += (value - 100000L) * level / 4;
5645                 }
5646                 if ((((i == INVEN_RARM) || (i == INVEN_LARM)) && (buki_motteruka(i))) || (i == INVEN_BOW)) total_exp += exp / 48;
5647                 else total_exp += exp / 16;
5648                 if (i == INVEN_BODY) total_exp += exp / 32;
5649         }
5650         p_ptr->exp = p_ptr->max_exp = total_exp;
5651
5652         /* Check Experience */
5653         check_experience();
5654 }
5655
5656
5657 /*
5658  * Lose experience
5659  */
5660 void lose_exp(s32b amount)
5661 {
5662         if (p_ptr->prace == RACE_ANDROID) return;
5663
5664         /* Never drop below zero experience */
5665         if (amount > p_ptr->exp) amount = p_ptr->exp;
5666
5667         /* Lose some experience */
5668         p_ptr->exp -= amount;
5669
5670         /* Check Experience */
5671         check_experience();
5672 }
5673
5674
5675 /*
5676  * Drain experience
5677  * If resisted to draining, return FALSE
5678  */
5679 bool drain_exp(s32b drain, s32b slip, int hold_life_prob)
5680 {
5681         /* Androids and their mimics are never drained */
5682         if (p_ptr->prace == RACE_ANDROID) return FALSE;
5683
5684         if (p_ptr->hold_life && (randint0(100) < hold_life_prob))
5685         {
5686                 /* Hold experience */
5687 #ifdef JP
5688                 msg_print("¤·¤«¤·¼«¸Ê¤ÎÀ¸Ì¿ÎÏ¤ò¼é¤ê¤¤Ã¤¿¡ª");
5689 #else
5690                 msg_print("You keep hold of your life force!");
5691 #endif
5692                 return FALSE;
5693         }
5694
5695         /* Hold experience failed */
5696         if (p_ptr->hold_life)
5697         {
5698 #ifdef JP
5699                 msg_print("À¸Ì¿ÎÏ¤ò¾¯¤·µÛ¤¤¼è¤é¤ì¤¿µ¤¤¬¤¹¤ë¡ª");
5700 #else
5701                 msg_print("You feel your life slipping away!");
5702 #endif
5703                 lose_exp(slip);
5704         }
5705         else
5706         {
5707 #ifdef JP
5708                 msg_print("À¸Ì¿ÎÏ¤¬ÂÎ¤«¤éµÛ¤¤¼è¤é¤ì¤¿µ¤¤¬¤¹¤ë¡ª");
5709 #else
5710                 msg_print("You feel your life draining away!");
5711 #endif
5712                 lose_exp(drain);
5713         }
5714
5715         return TRUE;
5716 }
5717
5718
5719 bool set_ultimate_res(int v, bool do_dec)
5720 {
5721         bool notice = FALSE;
5722
5723         /* Hack -- Force good values */
5724         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
5725
5726         if (p_ptr->is_dead) return FALSE;
5727
5728         /* Open */
5729         if (v)
5730         {
5731                 if (p_ptr->ult_res && !do_dec)
5732                 {
5733                         if (p_ptr->ult_res > v) return FALSE;
5734                 }
5735                 else if (!p_ptr->ult_res)
5736                 {
5737 #ifdef JP
5738 msg_print("¤¢¤é¤æ¤ë¤³¤È¤ËÂÐ¤·¤ÆÂÑÀ¤¬¤Ä¤¤¤¿µ¤¤¬¤¹¤ë¡ª");
5739 #else
5740                         msg_print("You feel resistant!");
5741 #endif
5742
5743                         notice = TRUE;
5744                 }
5745         }
5746
5747         /* Shut */
5748         else
5749         {
5750                 if (p_ptr->ult_res)
5751                 {
5752 #ifdef JP
5753 msg_print("¤¢¤é¤æ¤ë¤³¤È¤ËÂÐ¤¹¤ëÂÑÀ¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£");
5754 #else
5755                         msg_print("You feel less resistant");
5756 #endif
5757
5758                         notice = TRUE;
5759                 }
5760         }
5761
5762         /* Use the value */
5763         p_ptr->ult_res = v;
5764
5765         /* Redraw status bar */
5766         p_ptr->redraw |= (PR_STATUS);
5767
5768         /* Nothing to notice */
5769         if (!notice) return (FALSE);
5770
5771         /* Disturb */
5772         if (disturb_state) disturb(0, 0);
5773
5774         /* Recalculate bonuses */
5775         p_ptr->update |= (PU_BONUS);
5776
5777         /* Handle stuff */
5778         handle_stuff();
5779
5780         /* Result */
5781         return (TRUE);
5782 }
5783
5784 bool set_tim_res_nether(int v, bool do_dec)
5785 {
5786         bool notice = FALSE;
5787
5788         /* Hack -- Force good values */
5789         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
5790
5791         if (p_ptr->is_dead) return FALSE;
5792
5793         /* Open */
5794         if (v)
5795         {
5796                 if (p_ptr->tim_res_nether && !do_dec)
5797                 {
5798                         if (p_ptr->tim_res_nether > v) return FALSE;
5799                 }
5800                 else if (!p_ptr->tim_res_nether)
5801                 {
5802 #ifdef JP
5803 msg_print("ÃÏ¹ö¤ÎÎÏ¤ËÂÐ¤·¤ÆÂÑÀ¤¬¤Ä¤¤¤¿µ¤¤¬¤¹¤ë¡ª");
5804 #else
5805                         msg_print("You feel nether resistant!");
5806 #endif
5807
5808                         notice = TRUE;
5809                 }
5810         }
5811
5812         /* Shut */
5813         else
5814         {
5815                 if (p_ptr->tim_res_nether)
5816                 {
5817 #ifdef JP
5818 msg_print("ÃÏ¹ö¤ÎÎÏ¤ËÂÐ¤¹¤ëÂÑÀ¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£");
5819 #else
5820                         msg_print("You feel less nether resistant");
5821 #endif
5822
5823                         notice = TRUE;
5824                 }
5825         }
5826
5827         /* Use the value */
5828         p_ptr->tim_res_nether = v;
5829
5830         /* Redraw status bar */
5831         p_ptr->redraw |= (PR_STATUS);
5832
5833         /* Nothing to notice */
5834         if (!notice) return (FALSE);
5835
5836         /* Disturb */
5837         if (disturb_state) disturb(0, 0);
5838
5839         /* Recalculate bonuses */
5840         p_ptr->update |= (PU_BONUS);
5841
5842         /* Handle stuff */
5843         handle_stuff();
5844
5845         /* Result */
5846         return (TRUE);
5847 }
5848
5849 bool set_tim_res_time(int v, bool do_dec)
5850 {
5851         bool notice = FALSE;
5852
5853         /* Hack -- Force good values */
5854         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
5855
5856         if (p_ptr->is_dead) return FALSE;
5857
5858         /* Open */
5859         if (v)
5860         {
5861                 if (p_ptr->tim_res_time && !do_dec)
5862                 {
5863                         if (p_ptr->tim_res_time > v) return FALSE;
5864                 }
5865                 else if (!p_ptr->tim_res_time)
5866                 {
5867 #ifdef JP
5868 msg_print("»þ´ÖµÕÅ¾¤ÎÎÏ¤ËÂÐ¤·¤ÆÂÑÀ¤¬¤Ä¤¤¤¿µ¤¤¬¤¹¤ë¡ª");
5869 #else
5870                         msg_print("You feel time resistant!");
5871 #endif
5872
5873                         notice = TRUE;
5874                 }
5875         }
5876
5877         /* Shut */
5878         else
5879         {
5880                 if (p_ptr->tim_res_time)
5881                 {
5882 #ifdef JP
5883 msg_print("»þ´ÖµÕÅ¾¤ÎÎÏ¤ËÂÐ¤¹¤ëÂÑÀ¤¬Çö¤ì¤¿µ¤¤¬¤¹¤ë¡£");
5884 #else
5885                         msg_print("You feel less time resistant");
5886 #endif
5887
5888                         notice = TRUE;
5889                 }
5890         }
5891
5892         /* Use the value */
5893         p_ptr->tim_res_time = v;
5894
5895         /* Redraw status bar */
5896         p_ptr->redraw |= (PR_STATUS);
5897
5898         /* Nothing to notice */
5899         if (!notice) return (FALSE);
5900
5901         /* Disturb */
5902         if (disturb_state) disturb(0, 0);
5903
5904         /* Recalculate bonuses */
5905         p_ptr->update |= (PU_BONUS);
5906
5907         /* Handle stuff */
5908         handle_stuff();
5909
5910         /* Result */
5911         return (TRUE);
5912 }
5913
5914
5915 /*
5916  * Choose a warrior-mage elemental attack. -LM-
5917  */
5918 bool choose_ele_attack(void)
5919 {
5920         int num;
5921
5922         char choice;
5923
5924         if (!buki_motteruka(INVEN_RARM) && !buki_motteruka(INVEN_LARM))
5925         {
5926 #ifdef JP
5927                 msg_format("Éð´ï¤ò»ý¤¿¤Ê¤¤¤ÈËâË¡·õ¤Ï»È¤¨¤Ê¤¤¡£");
5928 #else
5929                 msg_format("You cannot use temporary branding with no weapon.");
5930 #endif
5931                 return FALSE;
5932         }
5933
5934         /* Save screen */
5935         screen_save();
5936
5937         num = (p_ptr->lev - 20) / 5;
5938
5939 #ifdef JP
5940                       c_prt(TERM_RED,    "        a) ¾Æ´þ", 2, 14);
5941 #else
5942                       c_prt(TERM_RED,    "        a) Fire Brand", 2, 14);
5943 #endif
5944
5945 #ifdef JP
5946         if (num >= 2) c_prt(TERM_L_WHITE,"        b) Åà·ë", 3, 14);
5947 #else
5948         if (num >= 2) c_prt(TERM_L_WHITE,"        b) Cold Brand", 3, 14);
5949 #endif
5950         else prt("", 3, 14);
5951
5952 #ifdef JP
5953         if (num >= 3) c_prt(TERM_GREEN,  "        c) ÆÇ»¦", 4, 14);
5954 #else
5955         if (num >= 3) c_prt(TERM_GREEN,  "        c) Poison Brand", 4, 14);
5956 #endif
5957         else prt("", 4, 14);
5958
5959 #ifdef JP
5960         if (num >= 4) c_prt(TERM_L_DARK, "        d) ÍÏ²ò", 5, 14);
5961 #else
5962         if (num >= 4) c_prt(TERM_L_DARK, "        d) Acid Brand", 5, 14);
5963 #endif
5964         else prt("", 5, 14);
5965
5966 #ifdef JP
5967         if (num >= 5) c_prt(TERM_BLUE,   "        e) ÅÅ·â", 6, 14);
5968 #else
5969         if (num >= 5) c_prt(TERM_BLUE,   "        e) Elec Brand", 6, 14);
5970 #endif
5971         else prt("", 6, 14);
5972
5973         prt("", 7, 14);
5974         prt("", 8, 14);
5975         prt("", 9, 14);
5976
5977         prt("", 1, 0);
5978 #ifdef JP
5979         prt("        ¤É¤Î¸µÁÇ¹¶·â¤ò¤·¤Þ¤¹¤«¡©", 1, 14);
5980 #else
5981         prt("        Choose a temporary elemental brand ", 1, 14);
5982 #endif
5983
5984         choice = inkey();
5985
5986         if ((choice == 'a') || (choice == 'A'))
5987                 set_ele_attack(ATTACK_FIRE, p_ptr->lev/2 + randint1(p_ptr->lev/2));
5988         else if (((choice == 'b') || (choice == 'B')) && (num >= 2))
5989                 set_ele_attack(ATTACK_COLD, p_ptr->lev/2 + randint1(p_ptr->lev/2));
5990         else if (((choice == 'c') || (choice == 'C')) && (num >= 3))
5991                 set_ele_attack(ATTACK_POIS, p_ptr->lev/2 + randint1(p_ptr->lev/2));
5992         else if (((choice == 'd') || (choice == 'D')) && (num >= 4))
5993                 set_ele_attack(ATTACK_ACID, p_ptr->lev/2 + randint1(p_ptr->lev/2));
5994         else if (((choice == 'e') || (choice == 'E')) && (num >= 5))
5995                 set_ele_attack(ATTACK_ELEC, p_ptr->lev/2 + randint1(p_ptr->lev/2));
5996         else
5997         {
5998 #ifdef JP
5999                 msg_print("ËâË¡·õ¤ò»È¤¦¤Î¤ò¤ä¤á¤¿¡£");
6000 #else
6001                 msg_print("You cancel the temporary branding.");
6002 #endif
6003                 screen_load();
6004                 return FALSE;
6005         }
6006         /* Load screen */
6007         screen_load();
6008         return TRUE;
6009 }
6010
6011
6012 /*
6013  * Choose a elemental immune. -LM-
6014  */
6015 bool choose_ele_immune(int turn)
6016 {
6017         char choice;
6018
6019         /* Save screen */
6020         screen_save();
6021
6022 #ifdef JP
6023         c_prt(TERM_RED,    "        a) ²Ð±ê", 2, 14);
6024 #else
6025         c_prt(TERM_RED,    "        a) Immune Fire", 2, 14);
6026 #endif
6027
6028 #ifdef JP
6029         c_prt(TERM_L_WHITE,"        b) Îäµ¤", 3, 14);
6030 #else
6031         c_prt(TERM_L_WHITE,"        b) Immune Cold", 3, 14);
6032 #endif
6033
6034 #ifdef JP
6035         c_prt(TERM_L_DARK, "        c) »À", 4, 14);
6036 #else
6037         c_prt(TERM_L_DARK, "        c) Immune Acid", 4, 14);
6038 #endif
6039
6040 #ifdef JP
6041         c_prt(TERM_BLUE,   "        d) ÅÅ·â", 5, 14);
6042 #else
6043         c_prt(TERM_BLUE,   "        d) Immune Elec", 5, 14);
6044 #endif
6045
6046
6047         prt("", 6, 14);
6048         prt("", 7, 14);
6049         prt("", 8, 14);
6050         prt("", 9, 14);
6051
6052         prt("", 1, 0);
6053 #ifdef JP
6054         prt("        ¤É¤Î¸µÁÇ¤ÎÌÈ±Ö¤ò¤Ä¤±¤Þ¤¹¤«¡©", 1, 14);
6055 #else
6056         prt("        Choose a temporary elemental immune ", 1, 14);
6057 #endif
6058
6059         choice = inkey();
6060
6061         if ((choice == 'a') || (choice == 'A'))
6062                 set_ele_immune(DEFENSE_FIRE, turn);
6063         else if ((choice == 'b') || (choice == 'B'))
6064                 set_ele_immune(DEFENSE_COLD, turn);
6065         else if ((choice == 'c') || (choice == 'C'))
6066                 set_ele_immune(DEFENSE_ACID, turn);
6067         else if ((choice == 'd') || (choice == 'D'))
6068                 set_ele_immune(DEFENSE_ELEC, turn);
6069         else
6070         {
6071 #ifdef JP
6072                 msg_print("ÌÈ±Ö¤òÉÕ¤±¤ë¤Î¤ò¤ä¤á¤¿¡£");
6073 #else
6074                 msg_print("You cancel the temporary immune.");
6075 #endif
6076                 screen_load();
6077                 return FALSE;
6078         }
6079         /* Load screen */
6080         screen_load();
6081         return TRUE;
6082 }