src/effects.c

   1 /*!
   2  * @file effects.c
   3  * @brief プレイヤーのステータス管理 / effects of various "objects"
   4  * @date 2014/01/01
   5  * @author
   6  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n
   7  *\n
   8  * This software may be copied and distributed for educational, research,\n
   9  * and not for profit purposes provided that this copyright and statement\n
  10  * are included in all such copies.  Other copyrights may also apply.\n
  11  *\n
  12  * 2013 Deskull rearranged comment for Doxygen.\n
  13  */
  14
  15 #include "angband.h"
  16 #include "mutation.h"
  17 #include "quest.h"
  18 #include "avatar.h"
  19 #include "player-status.h"
  20 #include "spells-status.h"
  21
  22 /*!
  23  * @brief プレイヤーの継続行動を設定する。
  24  * @param typ 継続行動のID\n
  25  * #ACTION_NONE / #ACTION_SEARCH / #ACTION_REST / #ACTION_LEARN / #ACTION_FISH / #ACTION_KAMAE / #ACTION_KATA / #ACTION_SING / #ACTION_HAYAGAKE / #ACTION_SPELL から選択。
  26  * @return なし
  27  */
  28 void set_action(ACTION_IDX typ)
  29 {
  30         int prev_typ = p_ptr->action;
  31
  32         if (typ == prev_typ)
  33         {
  34                 return;
  35         }
  36         else
  37         {
  38                 switch (prev_typ)
  39                 {
  40                         case ACTION_SEARCH:
  41                         {
  42                                 msg_print(_("探索をやめた。", "You no longer walk carefully."));
  43                                 p_ptr->redraw |= (PR_SPEED);
  44                                 break;
  45                         }
  46                         case ACTION_REST:
  47                         {
  48                                 resting = 0;
  49                                 break;
  50                         }
  51                         case ACTION_LEARN:
  52                         {
  53                                 msg_print(_("学習をやめた。", "You stop Learning"));
  54                                 new_mane = FALSE;
  55                                 break;
  56                         }
  57                         case ACTION_KAMAE:
  58                         {
  59                                 msg_print(_("構えをといた。", "You stop assuming the posture."));
  60                                 p_ptr->special_defense &= ~(KAMAE_MASK);
  61                                 break;
  62                         }
  63                         case ACTION_KATA:
  64                         {
  65                                 msg_print(_("型を崩した。", "You stop assuming the posture."));
  66                                 p_ptr->special_defense &= ~(KATA_MASK);
  67                                 p_ptr->update |= (PU_MONSTERS);
  68                                 p_ptr->redraw |= (PR_STATUS);
  69                                 break;
  70                         }
  71                         case ACTION_SING:
  72                         {
  73                                 msg_print(_("歌うのをやめた。", "You stop singing."));
  74                                 break;
  75                         }
  76                         case ACTION_HAYAGAKE:
  77                         {
  78                                 msg_print(_("足が重くなった。", "You are no longer walking extremely fast."));
  79                                 p_ptr->energy_use = 100;
  80                                 break;
  81                         }
  82                         case ACTION_SPELL:
  83                         {
  84                                 msg_print(_("呪文の詠唱を中断した。", "You stopped spelling all spells."));
  85                                 break;
  86                         }
  87                 }
  88         }
  89
  90         p_ptr->action = typ;
  91
  92         /* If we are requested other action, stop singing */
  93         if (prev_typ == ACTION_SING) stop_singing();
  94         if (prev_typ == ACTION_SPELL) stop_hex_spell();
  95
  96         switch (p_ptr->action)
  97         {
  98                 case ACTION_SEARCH:
  99                 {
 100                         msg_print(_("注意深く歩き始めた。", "You begin to walk carefully."));
 101                         p_ptr->redraw |= (PR_SPEED);
 102                         break;
 103                 }
 104                 case ACTION_LEARN:
 105                 {
 106                         msg_print(_("学習を始めた。", "You begin Learning"));
 107                         break;
 108                 }
 109                 case ACTION_FISH:
 110                 {
 111                         msg_print(_("水面に糸を垂らした．．．", "You begin fishing..."));
 112                         break;
 113                 }
 114                 case ACTION_HAYAGAKE:
 115                 {
 116                         msg_print(_("足が羽のように軽くなった。", "You begin to walk extremely fast."));
 117                         break;
 118                 }
 119                 default:
 120                 {
 121                         break;
 122                 }
 123         }
 124         p_ptr->update |= (PU_BONUS);
 125         p_ptr->redraw |= (PR_STATE);
 126 }
 127
 128 /*!
 129  * @brief プレイヤーの全ての時限効果をリセットする。 / reset timed flags
 130  * @return なし
 131  */
 132 void reset_tim_flags(void)
 133 {
 134         p_ptr->fast = 0;            /* Timed -- Fast */
 135         p_ptr->lightspeed = 0;
 136         p_ptr->slow = 0;            /* Timed -- Slow */
 137         p_ptr->blind = 0;           /* Timed -- Blindness */
 138         p_ptr->paralyzed = 0;       /* Timed -- Paralysis */
 139         p_ptr->confused = 0;        /* Timed -- Confusion */
 140         p_ptr->afraid = 0;          /* Timed -- Fear */
 141         p_ptr->image = 0;           /* Timed -- Hallucination */
 142         p_ptr->poisoned = 0;        /* Timed -- Poisoned */
 143         p_ptr->cut = 0;             /* Timed -- Cut */
 144         p_ptr->stun = 0;            /* Timed -- Stun */
 145
 146         p_ptr->protevil = 0;        /* Timed -- Protection */
 147         p_ptr->invuln = 0;          /* Timed -- Invulnerable */
 148         p_ptr->ult_res = 0;
 149         p_ptr->hero = 0;            /* Timed -- Heroism */
 150         p_ptr->shero = 0;           /* Timed -- Super Heroism */
 151         p_ptr->shield = 0;          /* Timed -- Shield Spell */
 152         p_ptr->blessed = 0;         /* Timed -- Blessed */
 153         p_ptr->tim_invis = 0;       /* Timed -- Invisibility */
 154         p_ptr->tim_infra = 0;       /* Timed -- Infra Vision */
 155         p_ptr->tim_regen = 0;       /* Timed -- Regeneration */
 156         p_ptr->tim_stealth = 0;     /* Timed -- Stealth */
 157         p_ptr->tim_esp = 0;
 158         p_ptr->wraith_form = 0;     /* Timed -- Wraith Form */
 159         p_ptr->tim_levitation = 0;
 160         p_ptr->tim_sh_touki = 0;
 161         p_ptr->tim_sh_fire = 0;
 162         p_ptr->tim_sh_holy = 0;
 163         p_ptr->tim_eyeeye = 0;
 164         p_ptr->magicdef = 0;
 165         p_ptr->resist_magic = 0;
 166         p_ptr->tsuyoshi = 0;
 167         p_ptr->kabenuke = 0;
 168         p_ptr->tim_res_nether = 0;
 169         p_ptr->tim_res_time = 0;
 170         p_ptr->tim_mimic = 0;
 171         p_ptr->mimic_form = 0;
 172         p_ptr->tim_reflect = 0;
 173         p_ptr->multishadow = 0;
 174         p_ptr->dustrobe = 0;
 175         p_ptr->action = ACTION_NONE;
 176
 177         p_ptr->oppose_acid = 0;     /* Timed -- oppose acid */
 178         p_ptr->oppose_elec = 0;     /* Timed -- oppose lightning */
 179         p_ptr->oppose_fire = 0;     /* Timed -- oppose heat */
 180         p_ptr->oppose_cold = 0;     /* Timed -- oppose cold */
 181         p_ptr->oppose_pois = 0;     /* Timed -- oppose poison */
 182
 183         p_ptr->word_recall = 0;
 184         p_ptr->alter_reality = 0;
 185         p_ptr->sutemi = FALSE;
 186         p_ptr->counter = FALSE;
 187         p_ptr->ele_attack = 0;
 188         p_ptr->ele_immune = 0;
 189         p_ptr->special_attack = 0L;
 190         p_ptr->special_defense = 0L;
 191
 192         while(p_ptr->energy_need < 0) p_ptr->energy_need += ENERGY_NEED();
 193         world_player = FALSE;
 194
 195         if (prace_is_(RACE_DEMON) && (p_ptr->lev > 44)) p_ptr->oppose_fire = 1;
 196         if ((p_ptr->pclass == CLASS_NINJA) && (p_ptr->lev > 44)) p_ptr->oppose_pois = 1;
 197         if (p_ptr->pclass == CLASS_BERSERKER) p_ptr->shero = 1;
 198
 199         if (p_ptr->riding)
 200         {
 201                 (void)set_monster_fast(p_ptr->riding, 0);
 202                 (void)set_monster_slow(p_ptr->riding, 0);
 203                 (void)set_monster_invulner(p_ptr->riding, 0, FALSE);
 204         }
 205
 206         if (p_ptr->pclass == CLASS_BARD)
 207         {
 208                 SINGING_SONG_EFFECT(p_ptr) = 0;
 209                 SINGING_SONG_ID(p_ptr) = 0;
 210         }
 211 }
 212
 213 /*!
 214  * @brief プレイヤーに魔力消去効果を与える。
 215  * @return なし
 216  */
 217 void dispel_player(void)
 218 {
 219         (void)set_fast(0, TRUE);
 220         (void)set_lightspeed(0, TRUE);
 221         (void)set_slow(0, TRUE);
 222         (void)set_shield(0, TRUE);
 223         (void)set_blessed(0, TRUE);
 224         (void)set_tsuyoshi(0, TRUE);
 225         (void)set_hero(0, TRUE);
 226         (void)set_shero(0, TRUE);
 227         (void)set_protevil(0, TRUE);
 228         (void)set_invuln(0, TRUE);
 229         (void)set_wraith_form(0, TRUE);
 230         (void)set_kabenuke(0, TRUE);
 231         (void)set_tim_res_nether(0, TRUE);
 232         (void)set_tim_res_time(0, TRUE);
 233         /* by henkma */
 234         (void)set_tim_reflect(0,TRUE);
 235         (void)set_multishadow(0,TRUE);
 236         (void)set_dustrobe(0,TRUE);
 237
 238         (void)set_tim_invis(0, TRUE);
 239         (void)set_tim_infra(0, TRUE);
 240         (void)set_tim_esp(0, TRUE);
 241         (void)set_tim_regen(0, TRUE);
 242         (void)set_tim_stealth(0, TRUE);
 243         (void)set_tim_levitation(0, TRUE);
 244         (void)set_tim_sh_touki(0, TRUE);
 245         (void)set_tim_sh_fire(0, TRUE);
 246         (void)set_tim_sh_holy(0, TRUE);
 247         (void)set_tim_eyeeye(0, TRUE);
 248         (void)set_magicdef(0, TRUE);
 249         (void)set_resist_magic(0, TRUE);
 250         (void)set_oppose_acid(0, TRUE);
 251         (void)set_oppose_elec(0, TRUE);
 252         (void)set_oppose_fire(0, TRUE);
 253         (void)set_oppose_cold(0, TRUE);
 254         (void)set_oppose_pois(0, TRUE);
 255         (void)set_ultimate_res(0, TRUE);
 256         (void)set_mimic(0, 0, TRUE);
 257         (void)set_ele_attack(0, 0);
 258         (void)set_ele_immune(0, 0);
 259
 260         /* Cancel glowing hands */
 261         if (p_ptr->special_attack & ATTACK_CONFUSE)
 262         {
 263                 p_ptr->special_attack &= ~(ATTACK_CONFUSE);
 264                 msg_print(_("手の輝きがなくなった。", "Your hands stop glowing."));
 265         }
 266
 267         if (music_singing_any() || hex_spelling_any())
 268         {
 269                 concptr str = (music_singing_any()) ? _("歌", "singing") : _("呪文", "spelling");
 270                 INTERUPTING_SONG_EFFECT(p_ptr) = SINGING_SONG_EFFECT(p_ptr);
 271                 SINGING_SONG_EFFECT(p_ptr) = MUSIC_NONE;
 272                 msg_format(_("%sが途切れた。", "Your %s is interrupted."), str);
 273
 274                 p_ptr->action = ACTION_NONE;
 275                 p_ptr->update |= (PU_BONUS | PU_HP | PU_MONSTERS);
 276                 p_ptr->redraw |= (PR_MAP | PR_STATUS | PR_STATE);
 277                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 278                 p_ptr->energy_need += ENERGY_NEED();
 279         }
 280 }
 281
 282
 283 /*!
 284  * @brief 変身効果の継続時間と変身先をセットする / Set "p_ptr->tim_mimic", and "p_ptr->mimic_form", notice observable changes
 285  * @param v 継続時間
 286  * @param p 変身内容
 287  * @param do_dec 現在の継続時間より長い値のみ上書きする
 288  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 289  */
 290 bool set_mimic(TIME_EFFECT v, IDX p, bool do_dec)
 291 {
 292         bool notice = FALSE;
 293
 294         /* Hack -- Force good values */
 295         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 296
 297         if (p_ptr->is_dead) return FALSE;
 298
 299         /* Open */
 300         if (v)
 301         {
 302                 if (p_ptr->tim_mimic && (p_ptr->mimic_form == p) && !do_dec)
 303                 {
 304                         if (p_ptr->tim_mimic > v) return FALSE;
 305                 }
 306                 else if ((!p_ptr->tim_mimic) || (p_ptr->mimic_form != p))
 307                 {
 308                         msg_print(_("自分の体が変わってゆくのを感じた。", "You feel that your body changes."));
 309                         p_ptr->mimic_form = p;
 310                         notice = TRUE;
 311                 }
 312         }
 313
 314         /* Shut */
 315         else
 316         {
 317                 if (p_ptr->tim_mimic)
 318                 {
 319                         msg_print(_("変身が解けた。", "You are no longer transformed."));
 320                         if (p_ptr->mimic_form == MIMIC_DEMON) set_oppose_fire(0, TRUE);
 321                         p_ptr->mimic_form=0;
 322                         notice = TRUE;
 323                         p = 0;
 324                 }
 325         }
 326
 327         /* Use the value */
 328         p_ptr->tim_mimic = v;
 329
 330         /* Nothing to notice */
 331         if (!notice)
 332                 return (FALSE);
 333
 334         if (disturb_state) disturb(FALSE, TRUE);
 335
 336         /* Redraw title */
 337         p_ptr->redraw |= (PR_BASIC | PR_STATUS);
 338         p_ptr->update |= (PU_BONUS | PU_HP);
 339
 340         handle_stuff();
 341         return (TRUE);
 342 }
 343
 344 /*!
 345  * @brief 盲目の継続時間をセットする / Set "p_ptr->blind", notice observable changes
 346  * @param v 継続時間
 347  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 348  * @details
 349  * Note the use of "PU_UN_LITE" and "PU_UN_VIEW", which is needed to\n
 350  * memorize any terrain features which suddenly become "visible".\n
 351  * Note that blindness is currently the only thing which can affect\n
 352  * "player_can_see_bold()".\n
 353  */
 354 bool set_blind(TIME_EFFECT v)
 355 {
 356         bool notice = FALSE;
 357
 358         /* Hack -- Force good values */
 359         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 360
 361         if (p_ptr->is_dead) return FALSE;
 362
 363         /* Open */
 364         if (v)
 365         {
 366                 if (!p_ptr->blind)
 367                 {
 368                         if (p_ptr->prace == RACE_ANDROID)
 369                         {
 370                                 msg_print(_("センサーをやられた！", "You are blind!"));
 371                         }
 372                         else
 373                         {
 374                                 msg_print(_("目が見えなくなってしまった！", "You are blind!"));
 375                         }
 376
 377                         notice = TRUE;
 378                         chg_virtue(V_ENLIGHTEN, -1);
 379                 }
 380         }
 381
 382         /* Shut */
 383         else
 384         {
 385                 if (p_ptr->blind)
 386                 {
 387                         if (p_ptr->prace == RACE_ANDROID)
 388                         {
 389                                 msg_print(_("センサーが復旧した。", "You can see again."));
 390                         }
 391                         else
 392                         {
 393                                 msg_print(_("やっと目が見えるようになった。", "You can see again."));
 394                         }
 395
 396                         notice = TRUE;
 397                 }
 398         }
 399
 400         /* Use the value */
 401         p_ptr->blind = v;
 402         p_ptr->redraw |= (PR_STATUS);
 403
 404         /* Nothing to notice */
 405         if (!notice) return (FALSE);
 406
 407         if (disturb_state) disturb(FALSE, FALSE);
 408
 409         /* Fully update the visuals */
 410         p_ptr->update |= (PU_UN_VIEW | PU_UN_LITE | PU_VIEW | PU_LITE | PU_MONSTERS | PU_MON_LITE);
 411
 412         p_ptr->redraw |= (PR_MAP);
 413
 414         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 415         handle_stuff();
 416         return (TRUE);
 417 }
 418
 419
 420 /*!
 421  * @brief 混乱の継続時間をセットする / Set "p_ptr->confused", notice observable changes
 422  * @param v 継続時間
 423  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 424  */
 425 bool set_confused(TIME_EFFECT v)
 426 {
 427         bool notice = FALSE;
 428
 429         /* Hack -- Force good values */
 430         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 431
 432         if (p_ptr->is_dead) return FALSE;
 433
 434         /* Open */
 435         if (v)
 436         {
 437                 if (!p_ptr->confused)
 438                 {
 439                         msg_print(_("あなたは混乱した！", "You are confused!"));
 440
 441                         if (p_ptr->action == ACTION_LEARN)
 442                         {
 443                                 msg_print(_("学習が続けられない！", "You cannot continue Learning!"));
 444                                 new_mane = FALSE;
 445
 446                                 p_ptr->redraw |= (PR_STATE);
 447                                 p_ptr->action = ACTION_NONE;
 448                         }
 449                         if (p_ptr->action == ACTION_KAMAE)
 450                         {
 451                                 msg_print(_("構えがとけた。", "Your posture gets loose."));
 452                                 p_ptr->special_defense &= ~(KAMAE_MASK);
 453                                 p_ptr->update |= (PU_BONUS);
 454                                 p_ptr->redraw |= (PR_STATE);
 455                                 p_ptr->action = ACTION_NONE;
 456                         }
 457                         else if (p_ptr->action == ACTION_KATA)
 458                         {
 459                                 msg_print(_("型が崩れた。", "Your posture gets loose."));
 460                                 p_ptr->special_defense &= ~(KATA_MASK);
 461                                 p_ptr->update |= (PU_BONUS);
 462                                 p_ptr->update |= (PU_MONSTERS);
 463                                 p_ptr->redraw |= (PR_STATE);
 464                                 p_ptr->redraw |= (PR_STATUS);
 465                                 p_ptr->action = ACTION_NONE;
 466                         }
 467
 468                         /* Sniper */
 469                         if (p_ptr->concent) reset_concentration(TRUE);
 470
 471                         /* Hex */
 472                         if (hex_spelling_any()) stop_hex_spell_all();
 473
 474                         notice = TRUE;
 475                         p_ptr->counter = FALSE;
 476                         chg_virtue(V_HARMONY, -1);
 477                 }
 478         }
 479
 480         /* Shut */
 481         else
 482         {
 483                 if (p_ptr->confused)
 484                 {
 485                         msg_print(_("やっと混乱がおさまった。", "You feel less confused now."));
 486                         p_ptr->special_attack &= ~(ATTACK_SUIKEN);
 487                         notice = TRUE;
 488                 }
 489         }
 490
 491         /* Use the value */
 492         p_ptr->confused = v;
 493         p_ptr->redraw |= (PR_STATUS);
 494
 495         /* Nothing to notice */
 496         if (!notice) return (FALSE);
 497
 498         if (disturb_state) disturb(FALSE, FALSE);
 499         handle_stuff();
 500         return (TRUE);
 501 }
 502
 503
 504 /*!
 505  * @brief 毒の継続時間をセットする / Set "p_ptr->poisoned", notice observable changes
 506  * @param v 継続時間
 507  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 508  */
 509 bool set_poisoned(TIME_EFFECT v)
 510 {
 511         bool notice = FALSE;
 512
 513         /* Hack -- Force good values */
 514         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 515
 516         if (p_ptr->is_dead) return FALSE;
 517
 518         /* Open */
 519         if (v)
 520         {
 521                 if (!p_ptr->poisoned)
 522                 {
 523                         msg_print(_("毒に侵されてしまった！", "You are poisoned!"));
 524                         notice = TRUE;
 525                 }
 526         }
 527
 528         /* Shut */
 529         else
 530         {
 531                 if (p_ptr->poisoned)
 532                 {
 533                         msg_print(_("やっと毒の痛みがなくなった。", "You are no longer poisoned."));
 534                         notice = TRUE;
 535                 }
 536         }
 537
 538         /* Use the value */
 539         p_ptr->poisoned = v;
 540         p_ptr->redraw |= (PR_STATUS);
 541
 542         /* Nothing to notice */
 543         if (!notice) return (FALSE);
 544
 545         if (disturb_state) disturb(FALSE, FALSE);
 546         handle_stuff();
 547         return (TRUE);
 548 }
 549
 550
 551 /*!
 552  * @brief 恐怖の継続時間をセットする / Set "p_ptr->afraid", notice observable changes
 553  * @param v 継続時間
 554  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 555  */
 556 bool set_afraid(TIME_EFFECT v)
 557 {
 558         bool notice = FALSE;
 559
 560         /* Hack -- Force good values */
 561         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 562
 563         if (p_ptr->is_dead) return FALSE;
 564
 565         /* Open */
 566         if (v)
 567         {
 568                 if (!p_ptr->afraid)
 569                 {
 570                         msg_print(_("何もかも恐くなってきた！", "You are terrified!"));
 571
 572                         if (p_ptr->special_defense & KATA_MASK)
 573                         {
 574                                 msg_print(_("型が崩れた。", "Your posture gets loose."));
 575                                 p_ptr->special_defense &= ~(KATA_MASK);
 576                                 p_ptr->update |= (PU_BONUS);
 577                                 p_ptr->update |= (PU_MONSTERS);
 578                                 p_ptr->redraw |= (PR_STATE);
 579                                 p_ptr->redraw |= (PR_STATUS);
 580                                 p_ptr->action = ACTION_NONE;
 581                         }
 582
 583                         notice = TRUE;
 584                         p_ptr->counter = FALSE;
 585                         chg_virtue(V_VALOUR, -1);
 586                 }
 587         }
 588
 589         /* Shut */
 590         else
 591         {
 592                 if (p_ptr->afraid)
 593                 {
 594                         msg_print(_("やっと恐怖を振り払った。", "You feel bolder now."));
 595                         notice = TRUE;
 596                 }
 597         }
 598
 599         /* Use the value */
 600         p_ptr->afraid = v;
 601         p_ptr->redraw |= (PR_STATUS);
 602
 603         /* Nothing to notice */
 604         if (!notice) return (FALSE);
 605
 606         if (disturb_state) disturb(FALSE, FALSE);
 607         handle_stuff();
 608         return (TRUE);
 609 }
 610
 611 /*!
 612  * @brief 麻痺の継続時間をセットする / Set "p_ptr->paralyzed", notice observable changes
 613  * @param v 継続時間
 614  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 615  */
 616 bool set_paralyzed(TIME_EFFECT v)
 617 {
 618         bool notice = FALSE;
 619
 620         /* Hack -- Force good values */
 621         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 622
 623         if (p_ptr->is_dead) return FALSE;
 624
 625         /* Open */
 626         if (v)
 627         {
 628                 if (!p_ptr->paralyzed)
 629                 {
 630                         msg_print(_("体が麻痺してしまった！", "You are paralyzed!"));
 631                         /* Sniper */
 632                         if (p_ptr->concent) reset_concentration(TRUE);
 633
 634                         /* Hex */
 635                         if (hex_spelling_any()) stop_hex_spell_all();
 636
 637                         p_ptr->counter = FALSE;
 638                         notice = TRUE;
 639                 }
 640         }
 641
 642         /* Shut */
 643         else
 644         {
 645                 if (p_ptr->paralyzed)
 646                 {
 647                         msg_print(_("やっと動けるようになった。", "You can move again."));
 648                         notice = TRUE;
 649                 }
 650         }
 651
 652         /* Use the value */
 653         p_ptr->paralyzed = v;
 654         p_ptr->redraw |= (PR_STATUS);
 655
 656         /* Nothing to notice */
 657         if (!notice) return (FALSE);
 658
 659         if (disturb_state) disturb(FALSE, FALSE);
 660         p_ptr->redraw |= (PR_STATE);
 661         handle_stuff();
 662         return (TRUE);
 663 }
 664
 665 /*!
 666  * @brief 幻覚の継続時間をセットする / Set "p_ptr->image", notice observable changes
 667  * @param v 継続時間
 668  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 669  * @details Note that we must redraw the map when hallucination changes.
 670  */
 671 bool set_image(TIME_EFFECT v)
 672 {
 673         bool notice = FALSE;
 674
 675         /* Hack -- Force good values */
 676         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 677
 678         if (p_ptr->is_dead) return FALSE;
 679         if (p_ptr->pseikaku == SEIKAKU_CHARGEMAN) v = 0;
 680
 681
 682         /* Open */
 683         if (v)
 684         {
 685                 set_tsuyoshi(0, TRUE);
 686                 if (!p_ptr->image)
 687                 {
 688                         msg_print(_("ワーオ！何もかも虹色に見える！", "Oh, wow! Everything looks so cosmic now!"));
 689
 690                         /* Sniper */
 691                         if (p_ptr->concent) reset_concentration(TRUE);
 692
 693                         p_ptr->counter = FALSE;
 694                         notice = TRUE;
 695                 }
 696         }
 697
 698         /* Shut */
 699         else
 700         {
 701                 if (p_ptr->image)
 702                 {
 703                         msg_print(_("やっとはっきりと物が見えるようになった。", "You can see clearly again."));
 704                         notice = TRUE;
 705                 }
 706         }
 707
 708         /* Use the value */
 709         p_ptr->image = v;
 710         p_ptr->redraw |= (PR_STATUS);
 711
 712         /* Nothing to notice */
 713         if (!notice) return (FALSE);
 714
 715         if (disturb_state) disturb(FALSE, TRUE);
 716
 717         p_ptr->redraw |= (PR_MAP);
 718
 719         /* Update the health bar */
 720         p_ptr->redraw |= (PR_HEALTH | PR_UHEALTH);
 721         p_ptr->update |= (PU_MONSTERS);
 722
 723         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 724         handle_stuff();
 725         return (TRUE);
 726 }
 727
 728 /*!
 729  * @brief 加速の継続時間をセットする / Set "p_ptr->fast", notice observable changes
 730  * @param v 継続時間
 731  * @param do_dec 現在の継続時間より長い値のみ上書きする
 732  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 733  */
 734 bool set_fast(TIME_EFFECT v, bool do_dec)
 735 {
 736         bool notice = FALSE;
 737
 738         /* Hack -- Force good values */
 739         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 740
 741         if (p_ptr->is_dead) return FALSE;
 742
 743         /* Open */
 744         if (v)
 745         {
 746                 if (p_ptr->fast && !do_dec)
 747                 {
 748                         if (p_ptr->fast > v) return FALSE;
 749                 }
 750                 else if (!IS_FAST() && !p_ptr->lightspeed)
 751                 {
 752                         msg_print(_("素早く動けるようになった！", "You feel yourself moving much faster!"));
 753                         notice = TRUE;
 754                         chg_virtue(V_PATIENCE, -1);
 755                         chg_virtue(V_DILIGENCE, 1);
 756                 }
 757         }
 758
 759         /* Shut */
 760         else
 761         {
 762                 if (p_ptr->fast && !p_ptr->lightspeed && !music_singing(MUSIC_SPEED) && !music_singing(MUSIC_SHERO))
 763                 {
 764                         msg_print(_("動きの素早さがなくなったようだ。", "You feel yourself slow down."));
 765                         notice = TRUE;
 766                 }
 767         }
 768
 769         /* Use the value */
 770         p_ptr->fast = v;
 771
 772         /* Nothing to notice */
 773         if (!notice) return (FALSE);
 774
 775         if (disturb_state) disturb(FALSE, FALSE);
 776         p_ptr->update |= (PU_BONUS);
 777         handle_stuff();
 778         return (TRUE);
 779 }
 780
 781 /*!
 782  * @brief 光速移動の継続時間をセットする / Set "p_ptr->lightspeed", notice observable changes
 783  * @param v 継続時間
 784  * @param do_dec 現在の継続時間より長い値のみ上書きする
 785  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 786  */
 787 bool set_lightspeed(TIME_EFFECT v, bool do_dec)
 788 {
 789         bool notice = FALSE;
 790
 791         /* Hack -- Force good values */
 792         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 793
 794         if (p_ptr->is_dead) return FALSE;
 795
 796         if (p_ptr->wild_mode) v = 0;
 797
 798         /* Open */
 799         if (v)
 800         {
 801                 if (p_ptr->lightspeed && !do_dec)
 802                 {
 803                         if (p_ptr->lightspeed > v) return FALSE;
 804                 }
 805                 else if (!p_ptr->lightspeed)
 806                 {
 807                         msg_print(_("非常に素早く動けるようになった！", "You feel yourself moving extremely faster!"));
 808                         notice = TRUE;
 809                         chg_virtue(V_PATIENCE, -1);
 810                         chg_virtue(V_DILIGENCE, 1);
 811                 }
 812         }
 813
 814         /* Shut */
 815         else
 816         {
 817                 if (p_ptr->lightspeed)
 818                 {
 819                         msg_print(_("動きの素早さがなくなったようだ。", "You feel yourself slow down."));
 820                         notice = TRUE;
 821                 }
 822         }
 823
 824         /* Use the value */
 825         p_ptr->lightspeed = v;
 826
 827         /* Nothing to notice */
 828         if (!notice) return (FALSE);
 829
 830         if (disturb_state) disturb(FALSE, FALSE);
 831         p_ptr->update |= (PU_BONUS);
 832         handle_stuff();
 833         return (TRUE);
 834 }
 835
 836 /*!
 837  * @brief 減速の継続時間をセットする / Set "p_ptr->slow", notice observable changes
 838  * @param v 継続時間
 839  * @param do_dec 現在の継続時間より長い値のみ上書きする
 840  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 841  */
 842 bool set_slow(TIME_EFFECT v, bool do_dec)
 843 {
 844         bool notice = FALSE;
 845
 846         /* Hack -- Force good values */
 847         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 848
 849         if (p_ptr->is_dead) return FALSE;
 850
 851         /* Open */
 852         if (v)
 853         {
 854                 if (p_ptr->slow && !do_dec)
 855                 {
 856                         if (p_ptr->slow > v) return FALSE;
 857                 }
 858                 else if (!p_ptr->slow)
 859                 {
 860                         msg_print(_("体の動きが遅くなってしまった！", "You feel yourself moving slower!"));
 861                         notice = TRUE;
 862                 }
 863         }
 864
 865         /* Shut */
 866         else
 867         {
 868                 if (p_ptr->slow)
 869                 {
 870                         msg_print(_("動きの遅さがなくなったようだ。", "You feel yourself speed up."));
 871                         notice = TRUE;
 872                 }
 873         }
 874
 875         /* Use the value */
 876         p_ptr->slow = v;
 877
 878         /* Nothing to notice */
 879         if (!notice) return (FALSE);
 880
 881         if (disturb_state) disturb(FALSE, FALSE);
 882         p_ptr->update |= (PU_BONUS);
 883         handle_stuff();
 884         return (TRUE);
 885 }
 886
 887
 888 /*!
 889  * @brief 肌石化の継続時間をセットする / Set "p_ptr->shield", notice observable changes
 890  * @param v 継続時間
 891  * @param do_dec 現在の継続時間より長い値のみ上書きする
 892  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 893  */
 894 bool set_shield(TIME_EFFECT v, bool do_dec)
 895 {
 896         bool notice = FALSE;
 897
 898         /* Hack -- Force good values */
 899         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 900
 901         if (p_ptr->is_dead) return FALSE;
 902
 903         /* Open */
 904         if (v)
 905         {
 906                 if (p_ptr->shield && !do_dec)
 907                 {
 908                         if (p_ptr->shield > v) return FALSE;
 909                 }
 910                 else if (!p_ptr->shield)
 911                 {
 912                         msg_print(_("肌が石になった。", "Your skin turns to stone."));
 913                         notice = TRUE;
 914                 }
 915         }
 916
 917         /* Shut */
 918         else
 919         {
 920                 if (p_ptr->shield)
 921                 {
 922                         msg_print(_("肌が元に戻った。", "Your skin returns to normal."));
 923                         notice = TRUE;
 924                 }
 925         }
 926
 927         /* Use the value */
 928         p_ptr->shield = v;
 929         p_ptr->redraw |= (PR_STATUS);
 930
 931         /* Nothing to notice */
 932         if (!notice) return (FALSE);
 933
 934         if (disturb_state) disturb(FALSE, FALSE);
 935         p_ptr->update |= (PU_BONUS);
 936         handle_stuff();
 937         return (TRUE);
 938 }
 939
 940
 941 /*!
 942  * @brief つぶれるの継続時間をセットする / Set "p_ptr->tsubureru", notice observable changes
 943  * @param v 継続時間
 944  * @param do_dec 現在の継続時間より長い値のみ上書きする
 945  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 946  */
 947 bool set_tsubureru(TIME_EFFECT v, bool do_dec)
 948 {
 949         bool notice = FALSE;
 950
 951         /* Hack -- Force good values */
 952         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
 953
 954         if (p_ptr->is_dead) return FALSE;
 955
 956         /* Open */
 957         if (v)
 958         {
 959                 if (p_ptr->tsubureru && !do_dec)
 960                 {
 961                         if (p_ptr->tsubureru > v) return FALSE;
 962                 }
 963                 else if (!p_ptr->tsubureru)
 964                 {
 965                         msg_print(_("横に伸びた。", "Your body expands horizontally."));
 966                         notice = TRUE;
 967                 }
 968         }
 969
 970         /* Shut */
 971         else
 972         {
 973                 if (p_ptr->tsubureru)
 974                 {
 975                         msg_print(_("もう横に伸びていない。", "Your body returns to normal."));
 976                         notice = TRUE;
 977                 }
 978         }
 979
 980         /* Use the value */
 981         p_ptr->tsubureru = v;
 982         p_ptr->redraw |= (PR_STATUS);
 983
 984         /* Nothing to notice */
 985         if (!notice) return (FALSE);
 986
 987         if (disturb_state) disturb(FALSE, FALSE);
 988         p_ptr->update |= (PU_BONUS);
 989         handle_stuff();
 990         return (TRUE);
 991 }
 992
 993
 994 /*!
 995  * @brief 魔法の鎧の継続時間をセットする / Set "p_ptr->magicdef", notice observable changes
 996  * @param v 継続時間
 997  * @param do_dec 現在の継続時間より長い値のみ上書きする
 998  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
 999  */
1000 bool set_magicdef(TIME_EFFECT v, bool do_dec)
1001 {
1002         bool notice = FALSE;
1003
1004         /* Hack -- Force good values */
1005         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1006
1007         if (p_ptr->is_dead) return FALSE;
1008
1009         /* Open */
1010         if (v)
1011         {
1012                 if (p_ptr->magicdef && !do_dec)
1013                 {
1014                         if (p_ptr->magicdef > v) return FALSE;
1015                 }
1016                 else if (!p_ptr->magicdef)
1017                 {
1018                         msg_print(_("魔法の防御力が増したような気がする。", "You feel more resistant to magic."));
1019                         notice = TRUE;
1020                 }
1021         }
1022
1023         /* Shut */
1024         else
1025         {
1026                 if (p_ptr->magicdef)
1027                 {
1028                         msg_print(_("魔法の防御力が元に戻った。", "You feel less resistant to magic."));
1029                         notice = TRUE;
1030                 }
1031         }
1032
1033         /* Use the value */
1034         p_ptr->magicdef = v;
1035         p_ptr->redraw |= (PR_STATUS);
1036
1037         /* Nothing to notice */
1038         if (!notice) return (FALSE);
1039
1040         if (disturb_state) disturb(FALSE, FALSE);
1041         p_ptr->update |= (PU_BONUS);
1042         handle_stuff();
1043         return (TRUE);
1044 }
1045
1046 /*!
1047  * @brief 祝福の継続時間をセットする / Set "p_ptr->blessed", notice observable changes
1048  * @param v 継続時間
1049  * @param do_dec 現在の継続時間より長い値のみ上書きする
1050  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1051  */
1052 bool set_blessed(TIME_EFFECT v, bool do_dec)
1053 {
1054         bool notice = FALSE;
1055
1056         /* Hack -- Force good values */
1057         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1058
1059         if (p_ptr->is_dead) return FALSE;
1060
1061         /* Open */
1062         if (v)
1063         {
1064                 if (p_ptr->blessed && !do_dec)
1065                 {
1066                         if (p_ptr->blessed > v) return FALSE;
1067                 }
1068                 else if (!IS_BLESSED())
1069                 {
1070                         msg_print(_("高潔な気分になった！", "You feel righteous!"));
1071                         notice = TRUE;
1072                 }
1073         }
1074
1075         /* Shut */
1076         else
1077         {
1078                 if (p_ptr->blessed && !music_singing(MUSIC_BLESS))
1079                 {
1080                         msg_print(_("高潔な気分が消え失せた。", "The prayer has expired."));
1081                         notice = TRUE;
1082                 }
1083         }
1084
1085         /* Use the value */
1086         p_ptr->blessed = v;
1087         p_ptr->redraw |= (PR_STATUS);
1088
1089         /* Nothing to notice */
1090         if (!notice) return (FALSE);
1091
1092         if (disturb_state) disturb(FALSE, FALSE);
1093         p_ptr->update |= (PU_BONUS);
1094         handle_stuff();
1095         return (TRUE);
1096 }
1097
1098
1099 /*!
1100  * @brief 士気高揚の継続時間をセットする / Set "p_ptr->hero", notice observable changes
1101  * @param v 継続時間
1102  * @param do_dec 現在の継続時間より長い値のみ上書きする
1103  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1104  */
1105 bool set_hero(TIME_EFFECT v, bool do_dec)
1106 {
1107         bool notice = FALSE;
1108
1109         /* Hack -- Force good values */
1110         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1111
1112         if (p_ptr->is_dead) return FALSE;
1113
1114         /* Open */
1115         if (v)
1116         {
1117                 if (p_ptr->hero && !do_dec)
1118                 {
1119                         if (p_ptr->hero > v) return FALSE;
1120                 }
1121                 else if (!IS_HERO())
1122                 {
1123                         msg_print(_("ヒーローになった気がする！", "You feel like a hero!"));
1124                         notice = TRUE;
1125                 }
1126         }
1127
1128         /* Shut */
1129         else
1130         {
1131                 if (p_ptr->hero && !music_singing(MUSIC_HERO) && !music_singing(MUSIC_SHERO))
1132                 {
1133                         msg_print(_("ヒーローの気分が消え失せた。", "The heroism wears off."));
1134                         notice = TRUE;
1135                 }
1136         }
1137
1138         /* Use the value */
1139         p_ptr->hero = v;
1140         p_ptr->redraw |= (PR_STATUS);
1141
1142         /* Nothing to notice */
1143         if (!notice) return (FALSE);
1144
1145         if (disturb_state) disturb(FALSE, FALSE);
1146         p_ptr->update |= (PU_BONUS);
1147
1148         /* Recalculate hitpoints */
1149         p_ptr->update |= (PU_HP);
1150         handle_stuff();
1151         return (TRUE);
1152 }
1153
1154 /*!
1155  * @brief 狂戦士化の継続時間をセットする / Set "p_ptr->shero", notice observable changes
1156  * @param v 継続時間/ 0ならば無条件にリセット
1157  * @param do_dec FALSEの場合現在の継続時間より長い値のみ上書きする
1158  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1159  */
1160 bool set_shero(TIME_EFFECT v, bool do_dec)
1161 {
1162         bool notice = FALSE;
1163
1164         /* Hack -- Force good values */
1165         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1166
1167         if (p_ptr->is_dead) return FALSE;
1168
1169         if (p_ptr->pclass == CLASS_BERSERKER) v = 1;
1170         /* Open */
1171         if (v)
1172         {
1173                 if (p_ptr->shero && !do_dec)
1174                 {
1175                         if (p_ptr->shero > v) return FALSE;
1176                 }
1177                 else if (!p_ptr->shero)
1178                 {
1179                         msg_print(_("殺戮マシーンになった気がする！", "You feel like a killing machine!"));
1180                         notice = TRUE;
1181                 }
1182         }
1183
1184         /* Shut */
1185         else
1186         {
1187                 if (p_ptr->shero)
1188                 {
1189                         msg_print(_("野蛮な気持ちが消え失せた。", "You feel less Berserk."));
1190                         notice = TRUE;
1191                 }
1192         }
1193
1194         /* Use the value */
1195         p_ptr->shero = v;
1196         p_ptr->redraw |= (PR_STATUS);
1197
1198         /* Nothing to notice */
1199         if (!notice) return (FALSE);
1200
1201         if (disturb_state) disturb(FALSE, FALSE);
1202         p_ptr->update |= (PU_BONUS);
1203
1204         /* Recalculate hitpoints */
1205         p_ptr->update |= (PU_HP);
1206         handle_stuff();
1207         return (TRUE);
1208 }
1209
1210 /*!
1211  * @brief 対邪悪結界の継続時間をセットする / Set "p_ptr->protevil", notice observable changes
1212  * @param v 継続時間
1213  * @param do_dec 現在の継続時間より長い値のみ上書きする
1214  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1215  */
1216 bool set_protevil(TIME_EFFECT v, bool do_dec)
1217 {
1218         bool notice = FALSE;
1219
1220         /* Hack -- Force good values */
1221         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1222
1223         if (p_ptr->is_dead) return FALSE;
1224
1225         /* Open */
1226         if (v)
1227         {
1228                 if (p_ptr->protevil && !do_dec)
1229                 {
1230                         if (p_ptr->protevil > v) return FALSE;
1231                 }
1232                 else if (!p_ptr->protevil)
1233                 {
1234                         msg_print(_("邪悪なる存在から守られているような感じがする！", "You feel safe from evil!"));
1235                         notice = TRUE;
1236                 }
1237         }
1238
1239         /* Shut */
1240         else
1241         {
1242                 if (p_ptr->protevil)
1243                 {
1244                         msg_print(_("邪悪なる存在から守られている感じがなくなった。", "You no longer feel safe from evil."));
1245                         notice = TRUE;
1246                 }
1247         }
1248
1249         /* Use the value */
1250         p_ptr->protevil = v;
1251         p_ptr->redraw |= (PR_STATUS);
1252
1253         /* Nothing to notice */
1254         if (!notice) return (FALSE);
1255
1256         if (disturb_state) disturb(FALSE, FALSE);
1257         handle_stuff();
1258         return (TRUE);
1259 }
1260
1261 /*!
1262  * @brief 幽体化の継続時間をセットする / Set "p_ptr->wraith_form", notice observable changes
1263  * @param v 継続時間
1264  * @param do_dec 現在の継続時間より長い値のみ上書きする
1265  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1266  */
1267 bool set_wraith_form(TIME_EFFECT v, bool do_dec)
1268 {
1269         bool notice = FALSE;
1270
1271         /* Hack -- Force good values */
1272         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1273
1274         if (p_ptr->is_dead) return FALSE;
1275
1276         /* Open */
1277         if (v)
1278         {
1279                 if (p_ptr->wraith_form && !do_dec)
1280                 {
1281                         if (p_ptr->wraith_form > v) return FALSE;
1282                 }
1283                 else if (!p_ptr->wraith_form)
1284                 {
1285                         msg_print(_("物質界を離れて幽鬼のような存在になった！", "You leave the physical world and turn into a wraith-being!"));
1286                         notice = TRUE;
1287                         chg_virtue(V_UNLIFE, 3);
1288                         chg_virtue(V_HONOUR, -2);
1289                         chg_virtue(V_SACRIFICE, -2);
1290                         chg_virtue(V_VALOUR, -5);
1291
1292                         p_ptr->redraw |= (PR_MAP);
1293                         p_ptr->update |= (PU_MONSTERS);
1294
1295                         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1296                 }
1297         }
1298
1299         /* Shut */
1300         else
1301         {
1302                 if (p_ptr->wraith_form)
1303                 {
1304                         msg_print(_("不透明になった感じがする。", "You feel opaque."));
1305                         notice = TRUE;
1306
1307                         p_ptr->redraw |= (PR_MAP);
1308                         p_ptr->update |= (PU_MONSTERS);
1309
1310                         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1311                 }
1312         }
1313
1314         /* Use the value */
1315         p_ptr->wraith_form = v;
1316         p_ptr->redraw |= (PR_STATUS);
1317
1318         /* Nothing to notice */
1319         if (!notice) return (FALSE);
1320
1321         if (disturb_state) disturb(FALSE, FALSE);
1322         p_ptr->update |= (PU_BONUS);
1323         handle_stuff();
1324         return (TRUE);
1325
1326 }
1327
1328 /*!
1329  * @brief 無傷球の継続時間をセットする / Set "p_ptr->invuln", notice observable changes
1330  * @param v 継続時間
1331  * @param do_dec 現在の継続時間より長い値のみ上書きする
1332  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1333  */
1334 bool set_invuln(TIME_EFFECT v, bool do_dec)
1335 {
1336         bool notice = FALSE;
1337
1338         /* Hack -- Force good values */
1339         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1340
1341         if (p_ptr->is_dead) return FALSE;
1342
1343         /* Open */
1344         if (v)
1345         {
1346                 if (p_ptr->invuln && !do_dec)
1347                 {
1348                         if (p_ptr->invuln > v) return FALSE;
1349                 }
1350                 else if (!IS_INVULN())
1351                 {
1352                         msg_print(_("無敵だ！", "Invulnerability!"));
1353                         notice = TRUE;
1354
1355                         chg_virtue(V_UNLIFE, -2);
1356                         chg_virtue(V_HONOUR, -2);
1357                         chg_virtue(V_SACRIFICE, -3);
1358                         chg_virtue(V_VALOUR, -5);
1359
1360                         p_ptr->redraw |= (PR_MAP);
1361                         p_ptr->update |= (PU_MONSTERS);
1362
1363                         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1364                 }
1365         }
1366
1367         /* Shut */
1368         else
1369         {
1370                 if (p_ptr->invuln && !music_singing(MUSIC_INVULN))
1371                 {
1372                         msg_print(_("無敵ではなくなった。", "The invulnerability wears off."));
1373                         notice = TRUE;
1374
1375                         p_ptr->redraw |= (PR_MAP);
1376                         p_ptr->update |= (PU_MONSTERS);
1377
1378                         p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
1379
1380                         p_ptr->energy_need += ENERGY_NEED();
1381                 }
1382         }
1383
1384         /* Use the value */
1385         p_ptr->invuln = v;
1386         p_ptr->redraw |= (PR_STATUS);
1387
1388         /* Nothing to notice */
1389         if (!notice) return (FALSE);
1390
1391         if (disturb_state) disturb(FALSE, FALSE);
1392         p_ptr->update |= (PU_BONUS);
1393         handle_stuff();
1394         return (TRUE);
1395 }
1396
1397 /*!
1398  * @brief 時限ESPの継続時間をセットする / Set "p_ptr->tim_esp", notice observable changes
1399  * @param v 継続時間
1400  * @param do_dec 現在の継続時間より長い値のみ上書きする
1401  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1402  */
1403 bool set_tim_esp(TIME_EFFECT v, bool do_dec)
1404 {
1405         bool notice = FALSE;
1406
1407         /* Hack -- Force good values */
1408         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1409
1410         if (p_ptr->is_dead) return FALSE;
1411
1412         /* Open */
1413         if (v)
1414         {
1415                 if (p_ptr->tim_esp && !do_dec)
1416                 {
1417                         if (p_ptr->tim_esp > v) return FALSE;
1418                 }
1419                 else if (!IS_TIM_ESP())
1420                 {
1421                         msg_print(_("意識が広がった気がする！", "You feel your consciousness expand!"));
1422                         notice = TRUE;
1423                 }
1424         }
1425
1426         /* Shut */
1427         else
1428         {
1429                 if (p_ptr->tim_esp && !music_singing(MUSIC_MIND))
1430                 {
1431                         msg_print(_("意識は元に戻った。", "Your consciousness contracts again."));
1432                         notice = TRUE;
1433                 }
1434         }
1435
1436         /* Use the value */
1437         p_ptr->tim_esp = v;
1438         p_ptr->redraw |= (PR_STATUS);
1439
1440         /* Nothing to notice */
1441         if (!notice) return (FALSE);
1442
1443         if (disturb_state) disturb(FALSE, FALSE);
1444         p_ptr->update |= (PU_BONUS);
1445         p_ptr->update |= (PU_MONSTERS);
1446         handle_stuff();
1447         return (TRUE);
1448 }
1449
1450 /*!
1451  * @brief 時限透明視の継続時間をセットする / Set "p_ptr->tim_invis", notice observable changes
1452  * @param v 継続時間
1453  * @param do_dec 現在の継続時間より長い値のみ上書きする
1454  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1455  */
1456 bool set_tim_invis(TIME_EFFECT v, bool do_dec)
1457 {
1458         bool notice = FALSE;
1459
1460         /* Hack -- Force good values */
1461         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1462
1463         if (p_ptr->is_dead) return FALSE;
1464
1465         /* Open */
1466         if (v)
1467         {
1468                 if (p_ptr->tim_invis && !do_dec)
1469                 {
1470                         if (p_ptr->tim_invis > v) return FALSE;
1471                 }
1472                 else if (!p_ptr->tim_invis)
1473                 {
1474                         msg_print(_("目が非常に敏感になった気がする！", "Your eyes feel very sensitive!"));
1475                         notice = TRUE;
1476                 }
1477         }
1478
1479         /* Shut */
1480         else
1481         {
1482                 if (p_ptr->tim_invis)
1483                 {
1484                         msg_print(_("目の敏感さがなくなったようだ。", "Your eyes feel less sensitive."));
1485                         notice = TRUE;
1486                 }
1487         }
1488
1489         /* Use the value */
1490         p_ptr->tim_invis = v;
1491         p_ptr->redraw |= (PR_STATUS);
1492
1493         /* Nothing to notice */
1494         if (!notice) return (FALSE);
1495
1496         if (disturb_state) disturb(FALSE, FALSE);
1497         p_ptr->update |= (PU_BONUS);
1498
1499         /* Update the monsters */
1500         p_ptr->update |= (PU_MONSTERS);
1501         handle_stuff();
1502         return (TRUE);
1503 }
1504
1505 /*!
1506  * @brief 時限赤外線視力の継続時間をセットする / Set "p_ptr->tim_infra", notice observable changes
1507  * @param v 継続時間
1508  * @param do_dec 現在の継続時間より長い値のみ上書きする
1509  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1510  */
1511 bool set_tim_infra(TIME_EFFECT v, bool do_dec)
1512 {
1513         bool notice = FALSE;
1514
1515         /* Hack -- Force good values */
1516         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1517
1518         if (p_ptr->is_dead) return FALSE;
1519
1520         /* Open */
1521         if (v)
1522         {
1523                 if (p_ptr->tim_infra && !do_dec)
1524                 {
1525                         if (p_ptr->tim_infra > v) return FALSE;
1526                 }
1527                 else if (!p_ptr->tim_infra)
1528                 {
1529                         msg_print(_("目がランランと輝き始めた！", "Your eyes begin to tingle!"));
1530                         notice = TRUE;
1531                 }
1532         }
1533
1534         /* Shut */
1535         else
1536         {
1537                 if (p_ptr->tim_infra)
1538                 {
1539                         msg_print(_("目の輝きがなくなった。", "Your eyes stop tingling."));
1540                         notice = TRUE;
1541                 }
1542         }
1543
1544         /* Use the value */
1545         p_ptr->tim_infra = v;
1546         p_ptr->redraw |= (PR_STATUS);
1547
1548         /* Nothing to notice */
1549         if (!notice) return (FALSE);
1550
1551         if (disturb_state) disturb(FALSE, FALSE);
1552         p_ptr->update |= (PU_BONUS);
1553
1554         /* Update the monsters */
1555         p_ptr->update |= (PU_MONSTERS);
1556         handle_stuff();
1557         return (TRUE);
1558 }
1559
1560 /*!
1561  * @brief 時限急回復の継続時間をセットする / Set "p_ptr->tim_regen", notice observable changes
1562  * @param v 継続時間
1563  * @param do_dec 現在の継続時間より長い値のみ上書きする
1564  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1565  */
1566 bool set_tim_regen(TIME_EFFECT v, bool do_dec)
1567 {
1568         bool notice = FALSE;
1569
1570         /* Hack -- Force good values */
1571         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1572
1573         if (p_ptr->is_dead) return FALSE;
1574
1575         /* Open */
1576         if (v)
1577         {
1578                 if (p_ptr->tim_regen && !do_dec)
1579                 {
1580                         if (p_ptr->tim_regen > v) return FALSE;
1581                 }
1582                 else if (!p_ptr->tim_regen)
1583                 {
1584                         msg_print(_("回復力が上がった！", "You feel yourself regenerating quickly!"));
1585                         notice = TRUE;
1586                 }
1587         }
1588
1589         /* Shut */
1590         else
1591         {
1592                 if (p_ptr->tim_regen)
1593                 {
1594                         msg_print(_("素早く回復する感じがなくなった。", "You feel yourself regenerating slowly."));
1595                         notice = TRUE;
1596                 }
1597         }
1598
1599         /* Use the value */
1600         p_ptr->tim_regen = v;
1601         p_ptr->redraw |= (PR_STATUS);
1602
1603         /* Nothing to notice */
1604         if (!notice) return (FALSE);
1605
1606         if (disturb_state) disturb(FALSE, FALSE);
1607         p_ptr->update |= (PU_BONUS);
1608         handle_stuff();
1609         return (TRUE);
1610 }
1611
1612 /*!
1613  * @brief 隠密の歌の継続時間をセットする / Set "p_ptr->tim_stealth", notice observable changes
1614  * @param v 継続時間
1615  * @param do_dec 現在の継続時間より長い値のみ上書きする
1616  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1617  */
1618 bool set_tim_stealth(TIME_EFFECT v, bool do_dec)
1619 {
1620         bool notice = FALSE;
1621
1622         /* Hack -- Force good values */
1623         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1624
1625         if (p_ptr->is_dead) return FALSE;
1626
1627         /* Open */
1628         if (v)
1629         {
1630                 if (p_ptr->tim_stealth && !do_dec)
1631                 {
1632                         if (p_ptr->tim_stealth > v) return FALSE;
1633                 }
1634                 else if (!IS_TIM_STEALTH())
1635                 {
1636                         msg_print(_("足音が小さくなった！", "You begin to walk silently!"));
1637                         notice = TRUE;
1638                 }
1639         }
1640
1641         /* Shut */
1642         else
1643         {
1644                 if (p_ptr->tim_stealth && !music_singing(MUSIC_STEALTH))
1645                 {
1646                         msg_print(_("足音が大きくなった。", "You no longer walk silently."));
1647                         notice = TRUE;
1648                 }
1649         }
1650
1651         /* Use the value */
1652         p_ptr->tim_stealth = v;
1653         p_ptr->redraw |= (PR_STATUS);
1654
1655         /* Nothing to notice */
1656         if (!notice) return (FALSE);
1657
1658         if (disturb_state) disturb(FALSE, FALSE);
1659         p_ptr->update |= (PU_BONUS);
1660         handle_stuff();
1661         return (TRUE);
1662 }
1663
1664 /*!
1665  * @brief 超隠密状態をセットする
1666  * @param set TRUEならば超隠密状態になる。
1667  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1668  */
1669 bool set_superstealth(bool set)
1670 {
1671         bool notice = FALSE;
1672
1673         if (p_ptr->is_dead) return FALSE;
1674
1675         /* Open */
1676         if (set)
1677         {
1678                 if (!(p_ptr->special_defense & NINJA_S_STEALTH))
1679                 {
1680                         if (cave[p_ptr->y][p_ptr->x].info & CAVE_MNLT)
1681                         {
1682                                 msg_print(_("敵の目から薄い影の中に覆い隠された。", "You are mantled in weak shadow from ordinary eyes."));
1683                                 p_ptr->monlite = p_ptr->old_monlite = TRUE;
1684                         }
1685                         else
1686                         {
1687                                 msg_print(_("敵の目から影の中に覆い隠された！", "You are mantled in shadow from ordinary eyes!"));
1688                                 p_ptr->monlite = p_ptr->old_monlite = FALSE;
1689                         }
1690
1691                         notice = TRUE;
1692
1693                         /* Use the value */
1694                         p_ptr->special_defense |= NINJA_S_STEALTH;
1695                 }
1696         }
1697
1698         /* Shut */
1699         else
1700         {
1701                 if (p_ptr->special_defense & NINJA_S_STEALTH)
1702                 {
1703                         msg_print(_("再び敵の目にさらされるようになった。", "You are exposed to common sight once more."));
1704                         notice = TRUE;
1705
1706                         /* Use the value */
1707                         p_ptr->special_defense &= ~(NINJA_S_STEALTH);
1708                 }
1709         }
1710
1711         /* Nothing to notice */
1712         if (!notice) return (FALSE);
1713         p_ptr->redraw |= (PR_STATUS);
1714
1715         if (disturb_state) disturb(FALSE, FALSE);
1716         return (TRUE);
1717 }
1718
1719 /*!
1720  * @brief 一時的浮遊の継続時間をセットする / Set "p_ptr->tim_levitation", notice observable changes
1721  * @param v 継続時間
1722  * @param do_dec 現在の継続時間より長い値のみ上書きする
1723  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1724  */
1725 bool set_tim_levitation(TIME_EFFECT v, bool do_dec)
1726 {
1727         bool notice = FALSE;
1728
1729         /* Hack -- Force good values */
1730         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1731
1732         if (p_ptr->is_dead) return FALSE;
1733
1734         /* Open */
1735         if (v)
1736         {
1737                 if (p_ptr->tim_levitation && !do_dec)
1738                 {
1739                         if (p_ptr->tim_levitation > v) return FALSE;
1740                 }
1741                 else if (!p_ptr->tim_levitation)
1742                 {
1743                         msg_print(_("体が宙に浮き始めた。", "You begin to fly!"));
1744                         notice = TRUE;
1745                 }
1746         }
1747
1748         /* Shut */
1749         else
1750         {
1751                 if (p_ptr->tim_levitation)
1752                 {
1753                         msg_print(_("もう宙に浮かべなくなった。", "You stop flying."));
1754                         notice = TRUE;
1755                 }
1756         }
1757
1758         /* Use the value */
1759         p_ptr->tim_levitation = v;
1760         p_ptr->redraw |= (PR_STATUS);
1761
1762         /* Nothing to notice */
1763         if (!notice) return (FALSE);
1764
1765         if (disturb_state) disturb(FALSE, FALSE);
1766         p_ptr->update |= (PU_BONUS);
1767         handle_stuff();
1768         return (TRUE);
1769 }
1770
1771 /*!
1772  * @brief 一時的闘気のオーラの継続時間をセットする / Set "p_ptr->tim_sh_touki", notice observable changes
1773  * @param v 継続時間
1774  * @param do_dec 現在の継続時間より長い値のみ上書きする
1775  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1776  */
1777 bool set_tim_sh_touki(TIME_EFFECT v, bool do_dec)
1778 {
1779         bool notice = FALSE;
1780
1781         /* Hack -- Force good values */
1782         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1783
1784         if (p_ptr->is_dead) return FALSE;
1785
1786         /* Open */
1787         if (v)
1788         {
1789                 if (p_ptr->tim_sh_touki && !do_dec)
1790                 {
1791                         if (p_ptr->tim_sh_touki > v) return FALSE;
1792                 }
1793                 else if (!p_ptr->tim_sh_touki)
1794                 {
1795                         msg_print(_("体が闘気のオーラで覆われた。", "You have enveloped by the aura of the Force!"));
1796                         notice = TRUE;
1797                 }
1798         }
1799
1800         /* Shut */
1801         else
1802         {
1803                 if (p_ptr->tim_sh_touki)
1804                 {
1805                         msg_print(_("闘気が消えた。", "Aura of the Force disappeared."));
1806                         notice = TRUE;
1807                 }
1808         }
1809
1810         /* Use the value */
1811         p_ptr->tim_sh_touki = v;
1812         p_ptr->redraw |= (PR_STATUS);
1813
1814         /* Nothing to notice */
1815         if (!notice) return (FALSE);
1816
1817         if (disturb_state) disturb(FALSE, FALSE);
1818         handle_stuff();
1819         return (TRUE);
1820 }
1821
1822 /*!
1823  * @brief 一時的火炎のオーラの継続時間をセットする / Set "p_ptr->tim_sh_fire", notice observable changes
1824  * @param v 継続時間
1825  * @param do_dec 現在の継続時間より長い値のみ上書きする
1826  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1827  */
1828 bool set_tim_sh_fire(TIME_EFFECT v, bool do_dec)
1829 {
1830         bool notice = FALSE;
1831
1832         /* Hack -- Force good values */
1833         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1834
1835         if (p_ptr->is_dead) return FALSE;
1836
1837         /* Open */
1838         if (v)
1839         {
1840                 if (p_ptr->tim_sh_fire && !do_dec)
1841                 {
1842                         if (p_ptr->tim_sh_fire > v) return FALSE;
1843                 }
1844                 else if (!p_ptr->tim_sh_fire)
1845                 {
1846                         msg_print(_("体が炎のオーラで覆われた。", "You have enveloped by fiery aura!"));
1847                         notice = TRUE;
1848                 }
1849         }
1850
1851         /* Shut */
1852         else
1853         {
1854                 if (p_ptr->tim_sh_fire)
1855                 {
1856                         msg_print(_("炎のオーラが消えた。", "Fiery aura disappeared."));
1857                         notice = TRUE;
1858                 }
1859         }
1860
1861         /* Use the value */
1862         p_ptr->tim_sh_fire = v;
1863         p_ptr->redraw |= (PR_STATUS);
1864
1865         /* Nothing to notice */
1866         if (!notice) return (FALSE);
1867
1868         if (disturb_state) disturb(FALSE, FALSE);
1869         p_ptr->update |= (PU_BONUS);
1870         handle_stuff();
1871         return (TRUE);
1872 }
1873
1874 /*!
1875  * @brief 一時的聖なるのオーラの継続時間をセットする / Set "p_ptr->tim_sh_holy", notice observable changes
1876  * @param v 継続時間
1877  * @param do_dec 現在の継続時間より長い値のみ上書きする
1878  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1879  */
1880 bool set_tim_sh_holy(TIME_EFFECT v, bool do_dec)
1881 {
1882         bool notice = FALSE;
1883
1884         /* Hack -- Force good values */
1885         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1886
1887         if (p_ptr->is_dead) return FALSE;
1888
1889         /* Open */
1890         if (v)
1891         {
1892                 if (p_ptr->tim_sh_holy && !do_dec)
1893                 {
1894                         if (p_ptr->tim_sh_holy > v) return FALSE;
1895                 }
1896                 else if (!p_ptr->tim_sh_holy)
1897                 {
1898                         msg_print(_("体が聖なるオーラで覆われた。", "You have enveloped by holy aura!"));
1899                         notice = TRUE;
1900                 }
1901         }
1902
1903         /* Shut */
1904         else
1905         {
1906                 if (p_ptr->tim_sh_holy)
1907                 {
1908                         msg_print(_("聖なるオーラが消えた。", "Holy aura disappeared."));
1909                         notice = TRUE;
1910                 }
1911         }
1912
1913         /* Use the value */
1914         p_ptr->tim_sh_holy = v;
1915         p_ptr->redraw |= (PR_STATUS);
1916
1917         /* Nothing to notice */
1918         if (!notice) return (FALSE);
1919
1920         if (disturb_state) disturb(FALSE, FALSE);
1921         p_ptr->update |= (PU_BONUS);
1922         handle_stuff();
1923         return (TRUE);
1924 }
1925
1926 /*!
1927  * @brief 目には目をの残り時間をセットする / Set "p_ptr->tim_eyeeye", notice observable changes
1928  * @param v 継続時間
1929  * @param do_dec 現在の継続時間より長い値のみ上書きする
1930  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1931  */
1932 bool set_tim_eyeeye(TIME_EFFECT v, bool do_dec)
1933 {
1934         bool notice = FALSE;
1935
1936         /* Hack -- Force good values */
1937         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1938
1939         if (p_ptr->is_dead) return FALSE;
1940
1941         /* Open */
1942         if (v)
1943         {
1944                 if (p_ptr->tim_eyeeye && !do_dec)
1945                 {
1946                         if (p_ptr->tim_eyeeye > v) return FALSE;
1947                 }
1948                 else if (!p_ptr->tim_eyeeye)
1949                 {
1950                         msg_print(_("法の守り手になった気がした！", "You feel like a keeper of commandments!"));
1951                         notice = TRUE;
1952                 }
1953         }
1954
1955         /* Shut */
1956         else
1957         {
1958                 if (p_ptr->tim_eyeeye)
1959                 {
1960                         msg_print(_("懲罰を執行することができなくなった。", "You no longer feel like a keeper."));
1961                         notice = TRUE;
1962                 }
1963         }
1964
1965         /* Use the value */
1966         p_ptr->tim_eyeeye = v;
1967         p_ptr->redraw |= (PR_STATUS);
1968
1969         /* Nothing to notice */
1970         if (!notice) return (FALSE);
1971
1972         if (disturb_state) disturb(FALSE, FALSE);
1973         p_ptr->update |= (PU_BONUS);
1974         handle_stuff();
1975         return (TRUE);
1976 }
1977
1978
1979 /*!
1980  * @brief 一時的魔法防御の継続時間をセットする / Set "p_ptr->resist_magic", notice observable changes
1981  * @param v 継続時間
1982  * @param do_dec 現在の継続時間より長い値のみ上書きする
1983  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
1984  */
1985 bool set_resist_magic(TIME_EFFECT v, bool do_dec)
1986 {
1987         bool notice = FALSE;
1988
1989         /* Hack -- Force good values */
1990         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
1991
1992         if (p_ptr->is_dead) return FALSE;
1993
1994         /* Open */
1995         if (v)
1996         {
1997                 if (p_ptr->resist_magic && !do_dec)
1998                 {
1999                         if (p_ptr->resist_magic > v) return FALSE;
2000                 }
2001                 else if (!p_ptr->resist_magic)
2002                 {
2003                         msg_print(_("魔法への耐性がついた。", "You have been protected from magic!"));
2004                         notice = TRUE;
2005                 }
2006         }
2007
2008         /* Shut */
2009         else
2010         {
2011                 if (p_ptr->resist_magic)
2012                 {
2013                         msg_print(_("魔法に弱くなった。", "You are no longer protected from magic."));
2014                         notice = TRUE;
2015                 }
2016         }
2017
2018         /* Use the value */
2019         p_ptr->resist_magic = v;
2020         p_ptr->redraw |= (PR_STATUS);
2021
2022         /* Nothing to notice */
2023         if (!notice) return (FALSE);
2024
2025         if (disturb_state) disturb(FALSE, FALSE);
2026         p_ptr->update |= (PU_BONUS);
2027         handle_stuff();
2028         return (TRUE);
2029 }
2030
2031 /*!
2032  * @brief 一時的反射の継続時間をセットする / Set "p_ptr->tim_reflect", notice observable changes
2033  * @param v 継続時間
2034  * @param do_dec 現在の継続時間より長い値のみ上書きする
2035  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2036  */
2037 bool set_tim_reflect(TIME_EFFECT v, bool do_dec)
2038 {
2039         bool notice = FALSE;
2040
2041         /* Hack -- Force good values */
2042         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2043
2044         if (p_ptr->is_dead) return FALSE;
2045
2046         /* Open */
2047         if (v)
2048         {
2049                 if (p_ptr->tim_reflect && !do_dec)
2050                 {
2051                         if (p_ptr->tim_reflect > v) return FALSE;
2052                 }
2053                 else if (!p_ptr->tim_reflect)
2054                 {
2055                         msg_print(_("体の表面が滑かになった気がする。", "Your body becames smooth."));
2056                         notice = TRUE;
2057                 }
2058         }
2059
2060         /* Shut */
2061         else
2062         {
2063                 if (p_ptr->tim_reflect)
2064                 {
2065                         msg_print(_("体の表面が滑かでなくなった。", "Your body is no longer smooth."));
2066                         notice = TRUE;
2067                 }
2068         }
2069
2070         /* Use the value */
2071         p_ptr->tim_reflect = v;
2072         p_ptr->redraw |= (PR_STATUS);
2073
2074         /* Nothing to notice */
2075         if (!notice) return (FALSE);
2076
2077         if (disturb_state) disturb(FALSE, FALSE);
2078         p_ptr->update |= (PU_BONUS);
2079         handle_stuff();
2080         return (TRUE);
2081 }
2082
2083
2084 /*
2085  * Set "p_ptr->multishadow", notice observable changes
2086  */
2087 bool set_multishadow(TIME_EFFECT v, bool do_dec)
2088 {
2089         bool notice = FALSE;
2090
2091         /* Hack -- Force good values */
2092         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2093
2094         if (p_ptr->is_dead) return FALSE;
2095
2096         /* Open */
2097         if (v)
2098         {
2099                 if (p_ptr->multishadow && !do_dec)
2100                 {
2101                         if (p_ptr->multishadow > v) return FALSE;
2102                 }
2103                 else if (!p_ptr->multishadow)
2104                 {
2105                         msg_print(_("あなたの周りに幻影が生まれた。", "Your Shadow enveloped you."));
2106                         notice = TRUE;
2107                 }
2108         }
2109
2110         /* Shut */
2111         else
2112         {
2113                 if (p_ptr->multishadow)
2114                 {
2115                         msg_print(_("幻影が消えた。", "Your Shadow disappears."));
2116                         notice = TRUE;
2117                 }
2118         }
2119
2120         /* Use the value */
2121         p_ptr->multishadow = v;
2122         p_ptr->redraw |= (PR_STATUS);
2123
2124         /* Nothing to notice */
2125         if (!notice) return (FALSE);
2126
2127         if (disturb_state) disturb(FALSE, FALSE);
2128         p_ptr->update |= (PU_BONUS);
2129         handle_stuff();
2130         return (TRUE);
2131 }
2132
2133 /*!
2134  * @brief 一時的破片のオーラの継続時間をセットする / Set "p_ptr->dustrobe", notice observable changes
2135  * @param v 継続時間
2136  * @param do_dec 現在の継続時間より長い値のみ上書きする
2137  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2138  */
2139 bool set_dustrobe(TIME_EFFECT v, bool do_dec)
2140 {
2141         bool notice = FALSE;
2142
2143         /* Hack -- Force good values */
2144         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2145
2146         if (p_ptr->is_dead) return FALSE;
2147
2148         /* Open */
2149         if (v)
2150         {
2151                 if (p_ptr->dustrobe && !do_dec)
2152                 {
2153                         if (p_ptr->dustrobe > v) return FALSE;
2154                 }
2155                 else if (!p_ptr->dustrobe)
2156                 {
2157                         msg_print(_("体が鏡のオーラで覆われた。", "You were enveloped by mirror shards."));
2158                         notice = TRUE;
2159                 }
2160         }
2161
2162         /* Shut */
2163         else
2164         {
2165                 if (p_ptr->dustrobe)
2166                 {
2167                         msg_print(_("鏡のオーラが消えた。", "The mirror shards disappear."));
2168                         notice = TRUE;
2169                 }
2170         }
2171
2172         /* Use the value */
2173         p_ptr->dustrobe = v;
2174         p_ptr->redraw |= (PR_STATUS);
2175
2176         /* Nothing to notice */
2177         if (!notice) return (FALSE);
2178
2179         if (disturb_state) disturb(FALSE, FALSE);
2180         p_ptr->update |= (PU_BONUS);
2181         handle_stuff();
2182         return (TRUE);
2183 }
2184
2185 /*!
2186  * @brief 一時的壁抜けの継続時間をセットする / Set "p_ptr->kabenuke", notice observable changes
2187  * @param v 継続時間
2188  * @param do_dec 現在の継続時間より長い値のみ上書きする
2189  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2190  */
2191 bool set_kabenuke(TIME_EFFECT v, bool do_dec)
2192 {
2193         bool notice = FALSE;
2194
2195         /* Hack -- Force good values */
2196         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2197
2198         if (p_ptr->is_dead) return FALSE;
2199
2200         /* Open */
2201         if (v)
2202         {
2203                 if (p_ptr->kabenuke && !do_dec)
2204                 {
2205                         if (p_ptr->kabenuke > v) return FALSE;
2206                 }
2207                 else if (!p_ptr->kabenuke)
2208                 {
2209                         msg_print(_("体が半物質の状態になった。", "You became ethereal form."));
2210                         notice = TRUE;
2211                 }
2212         }
2213
2214         /* Shut */
2215         else
2216         {
2217                 if (p_ptr->kabenuke)
2218                 {
2219                         msg_print(_("体が物質化した。", "You are no longer in an ethereal form."));
2220                         notice = TRUE;
2221                 }
2222         }
2223
2224         /* Use the value */
2225         p_ptr->kabenuke = v;
2226         p_ptr->redraw |= (PR_STATUS);
2227
2228         /* Nothing to notice */
2229         if (!notice) return (FALSE);
2230
2231         if (disturb_state) disturb(FALSE, FALSE);
2232         p_ptr->update |= (PU_BONUS);
2233         handle_stuff();
2234         return (TRUE);
2235 }
2236
2237 /*!
2238  * @brief オクレ兄さんの継続時間をセットする / Set "p_ptr->tsuyoshi", notice observable changes
2239  * @param v 継続時間
2240  * @param do_dec 現在の継続時間より長い値のみ上書きする
2241  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2242  */
2243 bool set_tsuyoshi(TIME_EFFECT v, bool do_dec)
2244 {
2245         bool notice = FALSE;
2246
2247         /* Hack -- Force good values */
2248         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2249
2250         if (p_ptr->is_dead) return FALSE;
2251
2252         /* Open */
2253         if (v)
2254         {
2255                 if (p_ptr->tsuyoshi && !do_dec)
2256                 {
2257                         if (p_ptr->tsuyoshi > v) return FALSE;
2258                 }
2259                 else if (!p_ptr->tsuyoshi)
2260                 {
2261                         msg_print(_("「オクレ兄さん！」", "Brother OKURE!"));
2262                         notice = TRUE;
2263                         chg_virtue(V_VITALITY, 2);
2264                 }
2265         }
2266
2267         /* Shut */
2268         else
2269         {
2270                 if (p_ptr->tsuyoshi)
2271                 {
2272                         msg_print(_("肉体が急速にしぼんでいった。", "Your body had quickly shriveled."));
2273
2274                         (void)dec_stat(A_CON, 20, TRUE);
2275                         (void)dec_stat(A_STR, 20, TRUE);
2276
2277                         notice = TRUE;
2278                         chg_virtue(V_VITALITY, -3);
2279                 }
2280         }
2281
2282         /* Use the value */
2283         p_ptr->tsuyoshi = v;
2284         p_ptr->redraw |= (PR_STATUS);
2285
2286         /* Nothing to notice */
2287         if (!notice) return (FALSE);
2288
2289         if (disturb_state) disturb(FALSE, FALSE);
2290         p_ptr->update |= (PU_BONUS);
2291
2292         /* Recalculate hitpoints */
2293         p_ptr->update |= (PU_HP);
2294         handle_stuff();
2295         return (TRUE);
2296 }
2297
2298 /*!
2299  * @brief 一時的元素スレイの継続時間をセットする / Set a temporary elemental brand. Clear all other brands. Print status messages. -LM-
2300  * @param attack_type スレイのタイプID
2301  * @param v 継続時間
2302  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2303  */
2304 bool set_ele_attack(u32b attack_type, TIME_EFFECT v)
2305 {
2306         /* Hack -- Force good values */
2307         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2308
2309         /* Clear all elemental attacks (only one is allowed at a time). */
2310         if ((p_ptr->special_attack & (ATTACK_ACID)) && (attack_type != ATTACK_ACID))
2311         {
2312                 p_ptr->special_attack &= ~(ATTACK_ACID);
2313                 msg_print(_("酸で攻撃できなくなった。", "Your temporary acidic brand fades away."));
2314         }
2315         if ((p_ptr->special_attack & (ATTACK_ELEC)) && (attack_type != ATTACK_ELEC))
2316         {
2317                 p_ptr->special_attack &= ~(ATTACK_ELEC);
2318                 msg_print(_("電撃で攻撃できなくなった。", "Your temporary electrical brand fades away."));
2319         }
2320         if ((p_ptr->special_attack & (ATTACK_FIRE)) && (attack_type != ATTACK_FIRE))
2321         {
2322                 p_ptr->special_attack &= ~(ATTACK_FIRE);
2323                 msg_print(_("火炎で攻撃できなくなった。", "Your temporary fiery brand fades away."));
2324         }
2325         if ((p_ptr->special_attack & (ATTACK_COLD)) && (attack_type != ATTACK_COLD))
2326         {
2327                 p_ptr->special_attack &= ~(ATTACK_COLD);
2328                 msg_print(_("冷気で攻撃できなくなった。", "Your temporary frost brand fades away."));
2329         }
2330         if ((p_ptr->special_attack & (ATTACK_POIS)) && (attack_type != ATTACK_POIS))
2331         {
2332                 p_ptr->special_attack &= ~(ATTACK_POIS);
2333                 msg_print(_("毒で攻撃できなくなった。", "Your temporary poison brand fades away."));
2334         }
2335
2336         if ((v) && (attack_type))
2337         {
2338                 /* Set attack type. */
2339                 p_ptr->special_attack |= (attack_type);
2340
2341                 /* Set duration. */
2342                 p_ptr->ele_attack = v;
2343
2344                 /* Message. */
2345 #ifdef JP
2346                 msg_format("%sで攻撃できるようになった！",
2347                              ((attack_type == ATTACK_ACID) ? "酸" :
2348                               ((attack_type == ATTACK_ELEC) ? "電撃" :
2349                                ((attack_type == ATTACK_FIRE) ? "火炎" :
2350                                 ((attack_type == ATTACK_COLD) ? "冷気" :
2351                                  ((attack_type == ATTACK_POIS) ? "毒" :
2352                                         "(なし)"))))));
2353 #else
2354                 msg_format("For a while, the blows you deal will %s",
2355                              ((attack_type == ATTACK_ACID) ? "melt with acid!" :
2356                               ((attack_type == ATTACK_ELEC) ? "shock your foes!" :
2357                                ((attack_type == ATTACK_FIRE) ? "burn with fire!" :
2358                                 ((attack_type == ATTACK_COLD) ? "chill to the bone!" :
2359                                  ((attack_type == ATTACK_POIS) ? "poison your enemies!" :
2360                                         "do nothing special."))))));
2361 #endif
2362         }
2363
2364         if (disturb_state) disturb(FALSE, FALSE);
2365         p_ptr->redraw |= (PR_STATUS);
2366
2367         p_ptr->update |= (PU_BONUS);
2368         handle_stuff();
2369
2370         return (TRUE);
2371 }
2372
2373 /*!
2374  * @brief 一時的元素免疫の継続時間をセットする / Set a temporary elemental brand.  Clear all other brands.  Print status messages. -LM-
2375  * @param immune_type 免疫のタイプID
2376  * @param v 継続時間
2377  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2378  */
2379 bool set_ele_immune(u32b immune_type, TIME_EFFECT v)
2380 {
2381         /* Hack -- Force good values */
2382         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2383
2384         /* Clear all elemental attacks (only one is allowed at a time). */
2385         if ((p_ptr->special_defense & (DEFENSE_ACID)) && (immune_type != DEFENSE_ACID))
2386         {
2387                 p_ptr->special_defense &= ~(DEFENSE_ACID);
2388                 msg_print(_("酸の攻撃で傷つけられるようになった。。", "You are no longer immune to acid."));
2389         }
2390         if ((p_ptr->special_defense & (DEFENSE_ELEC)) && (immune_type != DEFENSE_ELEC))
2391         {
2392                 p_ptr->special_defense &= ~(DEFENSE_ELEC);
2393                 msg_print(_("電撃の攻撃で傷つけられるようになった。。", "You are no longer immune to electricity."));
2394         }
2395         if ((p_ptr->special_defense & (DEFENSE_FIRE)) && (immune_type != DEFENSE_FIRE))
2396         {
2397                 p_ptr->special_defense &= ~(DEFENSE_FIRE);
2398                 msg_print(_("火炎の攻撃で傷つけられるようになった。。", "You are no longer immune to fire."));
2399         }
2400         if ((p_ptr->special_defense & (DEFENSE_COLD)) && (immune_type != DEFENSE_COLD))
2401         {
2402                 p_ptr->special_defense &= ~(DEFENSE_COLD);
2403                 msg_print(_("冷気の攻撃で傷つけられるようになった。。", "You are no longer immune to cold."));
2404         }
2405         if ((p_ptr->special_defense & (DEFENSE_POIS)) && (immune_type != DEFENSE_POIS))
2406         {
2407                 p_ptr->special_defense &= ~(DEFENSE_POIS);
2408                 msg_print(_("毒の攻撃で傷つけられるようになった。。", "You are no longer immune to poison."));
2409         }
2410
2411         if ((v) && (immune_type))
2412         {
2413                 /* Set attack type. */
2414                 p_ptr->special_defense |= (immune_type);
2415
2416                 /* Set duration. */
2417                 p_ptr->ele_immune = v;
2418
2419                 /* Message. */
2420 #ifdef JP
2421                 msg_format("%sの攻撃を受けつけなくなった！",
2422                              ((immune_type == DEFENSE_ACID) ? "酸" :
2423                               ((immune_type == DEFENSE_ELEC) ? "電撃" :
2424                                ((immune_type == DEFENSE_FIRE) ? "火炎" :
2425                                 ((immune_type == DEFENSE_COLD) ? "冷気" :
2426                                  ((immune_type == DEFENSE_POIS) ? "毒" :
2427                                         "(なし)"))))));
2428 #else
2429                 msg_format("For a while, You are immune to %s",
2430                              ((immune_type == DEFENSE_ACID) ? "acid!" :
2431                               ((immune_type == DEFENSE_ELEC) ? "electricity!" :
2432                                ((immune_type == DEFENSE_FIRE) ? "fire!" :
2433                                 ((immune_type == DEFENSE_COLD) ? "cold!" :
2434                                  ((immune_type == DEFENSE_POIS) ? "poison!" :
2435                                         "do nothing special."))))));
2436 #endif
2437         }
2438
2439         if (disturb_state) disturb(FALSE, FALSE);
2440         p_ptr->redraw |= (PR_STATUS);
2441
2442         p_ptr->update |= (PU_BONUS);
2443         handle_stuff();
2444
2445         return (TRUE);
2446 }
2447
2448 /*!
2449  * @brief 一時的酸耐性の継続時間をセットする / Set "p_ptr->oppose_acid", notice observable changes
2450  * @param v 継続時間
2451  * @param do_dec 現在の継続時間より長い値のみ上書きする
2452  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2453  */
2454 bool set_oppose_acid(TIME_EFFECT v, bool do_dec)
2455 {
2456         bool notice = FALSE;
2457
2458         /* Hack -- Force good values */
2459         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2460
2461         if (p_ptr->is_dead) return FALSE;
2462
2463         /* Open */
2464         if (v)
2465         {
2466                 if (p_ptr->oppose_acid && !do_dec)
2467                 {
2468                         if (p_ptr->oppose_acid > v) return FALSE;
2469                 }
2470                 else if (!IS_OPPOSE_ACID())
2471                 {
2472                         msg_print(_("酸への耐性がついた気がする！", "You feel resistant to acid!"));
2473                         notice = TRUE;
2474                 }
2475         }
2476
2477         /* Shut */
2478         else
2479         {
2480                 if (p_ptr->oppose_acid && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
2481                 {
2482                         msg_print(_("酸への耐性が薄れた気がする。", "You feel less resistant to acid."));
2483                         notice = TRUE;
2484                 }
2485         }
2486
2487         /* Use the value */
2488         p_ptr->oppose_acid = v;
2489
2490         /* Nothing to notice */
2491         if (!notice) return (FALSE);
2492         p_ptr->redraw |= (PR_STATUS);
2493
2494         if (disturb_state) disturb(FALSE, FALSE);
2495         handle_stuff();
2496         return (TRUE);
2497 }
2498
2499 /*!
2500  * @brief 一時的電撃耐性の継続時間をセットする / Set "p_ptr->oppose_elec", notice observable changes
2501  * @param v 継続時間
2502  * @param do_dec 現在の継続時間より長い値のみ上書きする
2503  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2504  */
2505 bool set_oppose_elec(TIME_EFFECT v, bool do_dec)
2506 {
2507         bool notice = FALSE;
2508
2509         /* Hack -- Force good values */
2510         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2511
2512         if (p_ptr->is_dead) return FALSE;
2513
2514         /* Open */
2515         if (v)
2516         {
2517                 if (p_ptr->oppose_elec && !do_dec)
2518                 {
2519                         if (p_ptr->oppose_elec > v) return FALSE;
2520                 }
2521                 else if (!IS_OPPOSE_ELEC())
2522                 {
2523                         msg_print(_("電撃への耐性がついた気がする！", "You feel resistant to electricity!"));
2524                         notice = TRUE;
2525                 }
2526         }
2527
2528         /* Shut */
2529         else
2530         {
2531                 if (p_ptr->oppose_elec && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
2532                 {
2533                         msg_print(_("電撃への耐性が薄れた気がする。", "You feel less resistant to electricity."));
2534                         notice = TRUE;
2535                 }
2536         }
2537
2538         /* Use the value */
2539         p_ptr->oppose_elec = v;
2540
2541         /* Nothing to notice */
2542         if (!notice) return (FALSE);
2543         p_ptr->redraw |= (PR_STATUS);
2544
2545         if (disturb_state) disturb(FALSE, FALSE);
2546         handle_stuff();
2547         return (TRUE);
2548 }
2549
2550 /*!
2551  * @brief 一時的火炎耐性の継続時間をセットする / Set "p_ptr->oppose_fire", notice observable changes
2552  * @param v 継続時間
2553  * @param do_dec 現在の継続時間より長い値のみ上書きする
2554  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2555  */
2556 bool set_oppose_fire(TIME_EFFECT v, bool do_dec)
2557 {
2558         bool notice = FALSE;
2559
2560         /* Hack -- Force good values */
2561         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2562
2563         if (p_ptr->is_dead) return FALSE;
2564
2565         if ((prace_is_(RACE_DEMON) && (p_ptr->lev > 44)) || (p_ptr->mimic_form == MIMIC_DEMON)) v = 1;
2566         /* Open */
2567         if (v)
2568         {
2569                 if (p_ptr->oppose_fire && !do_dec)
2570                 {
2571                         if (p_ptr->oppose_fire > v) return FALSE;
2572                 }
2573                 else if (!IS_OPPOSE_FIRE())
2574                 {
2575                         msg_print(_("火への耐性がついた気がする！", "You feel resistant to fire!"));
2576                         notice = TRUE;
2577                 }
2578         }
2579
2580         /* Shut */
2581         else
2582         {
2583                 if (p_ptr->oppose_fire && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
2584                 {
2585                         msg_print(_("火への耐性が薄れた気がする。", "You feel less resistant to fire."));
2586                         notice = TRUE;
2587                 }
2588         }
2589
2590         /* Use the value */
2591         p_ptr->oppose_fire = v;
2592
2593         /* Nothing to notice */
2594         if (!notice) return (FALSE);
2595         p_ptr->redraw |= (PR_STATUS);
2596
2597         if (disturb_state) disturb(FALSE, FALSE);
2598         handle_stuff();
2599         return (TRUE);
2600 }
2601
2602 /*!
2603  * @brief 一時的冷気耐性の継続時間をセットする / Set "p_ptr->oppose_cold", notice observable changes
2604  * @param v 継続時間
2605  * @param do_dec 現在の継続時間より長い値のみ上書きする
2606  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2607  */
2608 bool set_oppose_cold(TIME_EFFECT v, bool do_dec)
2609 {
2610         bool notice = FALSE;
2611
2612         /* Hack -- Force good values */
2613         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2614
2615         if (p_ptr->is_dead) return FALSE;
2616
2617         /* Open */
2618         if (v)
2619         {
2620                 if (p_ptr->oppose_cold && !do_dec)
2621                 {
2622                         if (p_ptr->oppose_cold > v) return FALSE;
2623                 }
2624                 else if (!IS_OPPOSE_COLD())
2625                 {
2626                         msg_print(_("冷気への耐性がついた気がする！", "You feel resistant to cold!"));
2627                         notice = TRUE;
2628                 }
2629         }
2630
2631         /* Shut */
2632         else
2633         {
2634                 if (p_ptr->oppose_cold && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
2635                 {
2636                         msg_print(_("冷気への耐性が薄れた気がする。", "You feel less resistant to cold."));
2637                         notice = TRUE;
2638                 }
2639         }
2640
2641         /* Use the value */
2642         p_ptr->oppose_cold = v;
2643
2644         /* Nothing to notice */
2645         if (!notice) return (FALSE);
2646         p_ptr->redraw |= (PR_STATUS);
2647
2648         if (disturb_state) disturb(FALSE, FALSE);
2649         handle_stuff();
2650         return (TRUE);
2651 }
2652
2653 /*!
2654  * @brief 一時的毒耐性の継続時間をセットする / Set "p_ptr->oppose_pois", notice observable changes
2655  * @param v 継続時間
2656  * @param do_dec 現在の継続時間より長い値のみ上書きする
2657  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2658  */
2659 bool set_oppose_pois(TIME_EFFECT v, bool do_dec)
2660 {
2661         bool notice = FALSE;
2662
2663         /* Hack -- Force good values */
2664         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2665
2666         if ((p_ptr->pclass == CLASS_NINJA) && (p_ptr->lev > 44)) v = 1;
2667         if (p_ptr->is_dead) return FALSE;
2668
2669         /* Open */
2670         if (v)
2671         {
2672                 if (p_ptr->oppose_pois && !do_dec)
2673                 {
2674                         if (p_ptr->oppose_pois > v) return FALSE;
2675                 }
2676                 else if (!IS_OPPOSE_POIS())
2677                 {
2678                         msg_print(_("毒への耐性がついた気がする！", "You feel resistant to poison!"));
2679                         notice = TRUE;
2680                 }
2681         }
2682
2683         /* Shut */
2684         else
2685         {
2686                 if (p_ptr->oppose_pois && !music_singing(MUSIC_RESIST) && !(p_ptr->special_defense & KATA_MUSOU))
2687                 {
2688                         msg_print(_("毒への耐性が薄れた気がする。", "You feel less resistant to poison."));
2689                         notice = TRUE;
2690                 }
2691         }
2692
2693         /* Use the value */
2694         p_ptr->oppose_pois = v;
2695
2696         /* Nothing to notice */
2697         if (!notice) return (FALSE);
2698         p_ptr->redraw |= (PR_STATUS);
2699
2700         if (disturb_state) disturb(FALSE, FALSE);
2701         handle_stuff();
2702         return (TRUE);
2703 }
2704
2705 /*!
2706  * @brief 朦朧の継続時間をセットする / Set "p_ptr->stun", notice observable changes
2707  * @param v 継続時間
2708  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2709  * @details
2710  * Note the special code to only notice "range" changes.
2711  */
2712 bool set_stun(TIME_EFFECT v)
2713 {
2714         int old_aux, new_aux;
2715         bool notice = FALSE;
2716
2717
2718         /* Hack -- Force good values */
2719         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2720
2721         if (p_ptr->is_dead) return FALSE;
2722
2723         if (prace_is_(RACE_GOLEM) || ((p_ptr->pclass == CLASS_BERSERKER) && (p_ptr->lev > 34))) v = 0;
2724
2725         /* Knocked out */
2726         if (p_ptr->stun > 100)
2727         {
2728                 old_aux = 3;
2729         }
2730
2731         /* Heavy stun */
2732         else if (p_ptr->stun > 50)
2733         {
2734                 old_aux = 2;
2735         }
2736
2737         /* Stun */
2738         else if (p_ptr->stun > 0)
2739         {
2740                 old_aux = 1;
2741         }
2742
2743         /* None */
2744         else
2745         {
2746                 old_aux = 0;
2747         }
2748
2749         /* Knocked out */
2750         if (v > 100)
2751         {
2752                 new_aux = 3;
2753         }
2754
2755         /* Heavy stun */
2756         else if (v > 50)
2757         {
2758                 new_aux = 2;
2759         }
2760
2761         /* Stun */
2762         else if (v > 0)
2763         {
2764                 new_aux = 1;
2765         }
2766
2767         /* None */
2768         else
2769         {
2770                 new_aux = 0;
2771         }
2772
2773         /* Increase cut */
2774         if (new_aux > old_aux)
2775         {
2776                 /* Describe the state */
2777                 switch (new_aux)
2778                 {
2779                         /* Stun */
2780                         case 1: msg_print(_("意識がもうろうとしてきた。", "You have been stunned.")); break;
2781
2782                         /* Heavy stun */
2783                         case 2: msg_print(_("意識がひどくもうろうとしてきた。", "You have been heavily stunned.")); break;
2784
2785                         /* Knocked out */
2786                         case 3: msg_print(_("頭がクラクラして意識が遠のいてきた。", "You have been knocked out.")); break;
2787                 }
2788
2789                 if (randint1(1000) < v || one_in_(16))
2790                 {
2791                         msg_print(_("割れるような頭痛がする。", "A vicious blow hits your head."));
2792
2793                         if (one_in_(3))
2794                         {
2795                                 if (!p_ptr->sustain_int) (void)do_dec_stat(A_INT);
2796                                 if (!p_ptr->sustain_wis) (void)do_dec_stat(A_WIS);
2797                         }
2798                         else if (one_in_(2))
2799                         {
2800                                 if (!p_ptr->sustain_int) (void)do_dec_stat(A_INT);
2801                         }
2802                         else
2803                         {
2804                                 if (!p_ptr->sustain_wis) (void)do_dec_stat(A_WIS);
2805                         }
2806                 }
2807                 if (p_ptr->special_defense & KATA_MASK)
2808                 {
2809                         msg_print(_("型が崩れた。", "Your posture gets loose."));
2810                         p_ptr->special_defense &= ~(KATA_MASK);
2811                         p_ptr->update |= (PU_BONUS);
2812                         p_ptr->update |= (PU_MONSTERS);
2813                         p_ptr->redraw |= (PR_STATE);
2814                         p_ptr->redraw |= (PR_STATUS);
2815                         p_ptr->action = ACTION_NONE;
2816                 }
2817
2818                 /* Sniper */
2819                 if (p_ptr->concent) reset_concentration(TRUE);
2820
2821                 /* Hex */
2822                 if (hex_spelling_any()) stop_hex_spell_all();
2823
2824                 notice = TRUE;
2825         }
2826
2827         /* Decrease cut */
2828         else if (new_aux < old_aux)
2829         {
2830                 /* Describe the state */
2831                 switch (new_aux)
2832                 {
2833                         /* None */
2834                 case 0:
2835                         msg_print(_("やっと朦朧状態から回復した。", "You are no longer stunned."));
2836
2837                         if (disturb_state) disturb(FALSE, FALSE);
2838                         break;
2839                 }
2840
2841                 notice = TRUE;
2842         }
2843
2844         /* Use the value */
2845         p_ptr->stun = v;
2846
2847         /* No change */
2848         if (!notice) return (FALSE);
2849
2850         if (disturb_state) disturb(FALSE, FALSE);
2851         p_ptr->update |= (PU_BONUS);
2852
2853         /* Redraw the "stun" */
2854         p_ptr->redraw |= (PR_STUN);
2855         handle_stuff();
2856         return (TRUE);
2857 }
2858
2859
2860 /*!
2861  * @brief 出血の継続時間をセットする / Set "p_ptr->cut", notice observable changes
2862  * @param v 継続時間
2863  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
2864  * @details
2865  * Note the special code to only notice "range" changes.
2866  */
2867 bool set_cut(TIME_EFFECT v)
2868 {
2869         int old_aux, new_aux;
2870         bool notice = FALSE;
2871
2872         /* Hack -- Force good values */
2873         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
2874
2875         if (p_ptr->is_dead) return FALSE;
2876
2877         if ((p_ptr->prace == RACE_GOLEM ||
2878             p_ptr->prace == RACE_SKELETON ||
2879             p_ptr->prace == RACE_SPECTRE ||
2880                 (p_ptr->prace == RACE_ZOMBIE && p_ptr->lev > 11)) &&
2881             !p_ptr->mimic_form)
2882                 v = 0;
2883
2884         /* Mortal wound */
2885         if (p_ptr->cut > 1000)
2886         {
2887                 old_aux = 7;
2888         }
2889
2890         /* Deep gash */
2891         else if (p_ptr->cut > 200)
2892         {
2893                 old_aux = 6;
2894         }
2895
2896         /* Severe cut */
2897         else if (p_ptr->cut > 100)
2898         {
2899                 old_aux = 5;
2900         }
2901
2902         /* Nasty cut */
2903         else if (p_ptr->cut > 50)
2904         {
2905                 old_aux = 4;
2906         }
2907
2908         /* Bad cut */
2909         else if (p_ptr->cut > 25)
2910         {
2911                 old_aux = 3;
2912         }
2913
2914         /* Light cut */
2915         else if (p_ptr->cut > 10)
2916         {
2917                 old_aux = 2;
2918         }
2919
2920         /* Graze */
2921         else if (p_ptr->cut > 0)
2922         {
2923                 old_aux = 1;
2924         }
2925
2926         /* None */
2927         else
2928         {
2929                 old_aux = 0;
2930         }
2931
2932         /* Mortal wound */
2933         if (v > 1000)
2934         {
2935                 new_aux = 7;
2936         }
2937
2938         /* Deep gash */
2939         else if (v > 200)
2940         {
2941                 new_aux = 6;
2942         }
2943
2944         /* Severe cut */
2945         else if (v > 100)
2946         {
2947                 new_aux = 5;
2948         }
2949
2950         /* Nasty cut */
2951         else if (v > 50)
2952         {
2953                 new_aux = 4;
2954         }
2955
2956         /* Bad cut */
2957         else if (v > 25)
2958         {
2959                 new_aux = 3;
2960         }
2961
2962         /* Light cut */
2963         else if (v > 10)
2964         {
2965                 new_aux = 2;
2966         }
2967
2968         /* Graze */
2969         else if (v > 0)
2970         {
2971                 new_aux = 1;
2972         }
2973
2974         /* None */
2975         else
2976         {
2977                 new_aux = 0;
2978         }
2979
2980         /* Increase cut */
2981         if (new_aux > old_aux)
2982         {
2983                 /* Describe the state */
2984                 switch (new_aux)
2985                 {
2986                         /* Graze */
2987                         case 1: msg_print(_("かすり傷を負ってしまった。", "You have been given a graze.")); break;
2988
2989                         /* Light cut */
2990                         case 2: msg_print(_("軽い傷を負ってしまった。", "You have been given a light cut.")); break;
2991
2992                         /* Bad cut */
2993                         case 3: msg_print(_("ひどい傷を負ってしまった。", "You have been given a bad cut.")); break;
2994
2995                         /* Nasty cut */
2996                         case 4: msg_print(_("大変な傷を負ってしまった。", "You have been given a nasty cut.")); break;
2997
2998                         /* Severe cut */
2999                         case 5: msg_print(_("重大な傷を負ってしまった。", "You have been given a severe cut.")); break;
3000
3001                         /* Deep gash */
3002                         case 6: msg_print(_("ひどい深手を負ってしまった。", "You have been given a deep gash.")); break;
3003
3004                         /* Mortal wound */
3005                         case 7: msg_print(_("致命的な傷を負ってしまった。", "You have been given a mortal wound.")); break;
3006                 }
3007
3008                 notice = TRUE;
3009
3010                 if (randint1(1000) < v || one_in_(16))
3011                 {
3012                         if (!p_ptr->sustain_chr)
3013                         {
3014                                 msg_print(_("ひどい傷跡が残ってしまった。", "You have been horribly scarred."));
3015                                 do_dec_stat(A_CHR);
3016                         }
3017                 }
3018         }
3019
3020         /* Decrease cut */
3021         else if (new_aux < old_aux)
3022         {
3023                 /* Describe the state */
3024                 switch (new_aux)
3025                 {
3026                         /* None */
3027                         case 0:
3028                         msg_format(_("やっと%s。", "You are no longer bleeding."), p_ptr->prace == RACE_ANDROID ? "怪我が直った" : "出血が止まった");
3029
3030                         if (disturb_state) disturb(FALSE, FALSE);
3031                         break;
3032                 }
3033
3034                 notice = TRUE;
3035         }
3036
3037         /* Use the value */
3038         p_ptr->cut = v;
3039
3040         /* No change */
3041         if (!notice) return (FALSE);
3042
3043         if (disturb_state) disturb(FALSE, FALSE);
3044         p_ptr->update |= (PU_BONUS);
3045
3046         /* Redraw the "cut" */
3047         p_ptr->redraw |= (PR_CUT);
3048         handle_stuff();
3049         return (TRUE);
3050 }
3051
3052 /*!
3053  * @brief 空腹状態をセットする / Set "p_ptr->food", notice observable changes
3054  * @param v 継続時間
3055  * @return ステータスに影響を及ぼす変化があった場合TRUEを返す。
3056  * @details
3057  * Set "", notice observable changes\n
3058  *\n
3059  * The "p_ptr->food" variable can get as large as 20000, allowing the
3060  * addition of the most "filling" item, Elvish Waybread, which adds
3061  * 7500 food units, without overflowing the 32767 maximum limit.\n
3062  *\n
3063  * Perhaps we should disturb the player with various messages,
3064  * especially messages about hunger status changes.  \n
3065  *\n
3066  * Digestion of food is handled in "dungeon.c", in which, normally,
3067  * the player digests about 20 food units per 100 game turns, more
3068  * when "fast", more when "regenerating", less with "slow digestion",
3069  * but when the player is "gorged", he digests 100 food units per 10
3070  * game turns, or a full 1000 food units per 100 game turns.\n
3071  *\n
3072  * Note that the player's speed is reduced by 10 units while gorged,
3073  * so if the player eats a single food ration (5000 food units) when
3074  * full (15000 food units), he will be gorged for (5000/100)*10 = 500
3075  * game turns, or 500/(100/5) = 25 player turns (if nothing else is
3076  * affecting the player speed).\n
3077  */
3078 bool set_food(TIME_EFFECT v)
3079 {
3080         int old_aux, new_aux;
3081
3082         bool notice = FALSE;
3083
3084         /* Hack -- Force good values */
3085         v = (v > 20000) ? 20000 : (v < 0) ? 0 : v;
3086
3087         /* Fainting / Starving */
3088         if (p_ptr->food < PY_FOOD_FAINT)
3089         {
3090                 old_aux = 0;
3091         }
3092
3093         /* Weak */
3094         else if (p_ptr->food < PY_FOOD_WEAK)
3095         {
3096                 old_aux = 1;
3097         }
3098
3099         /* Hungry */
3100         else if (p_ptr->food < PY_FOOD_ALERT)
3101         {
3102                 old_aux = 2;
3103         }
3104
3105         /* Normal */
3106         else if (p_ptr->food < PY_FOOD_FULL)
3107         {
3108                 old_aux = 3;
3109         }
3110
3111         /* Full */
3112         else if (p_ptr->food < PY_FOOD_MAX)
3113         {
3114                 old_aux = 4;
3115         }
3116
3117         /* Gorged */
3118         else
3119         {
3120                 old_aux = 5;
3121         }
3122
3123         /* Fainting / Starving */
3124         if (v < PY_FOOD_FAINT)
3125         {
3126                 new_aux = 0;
3127         }
3128
3129         /* Weak */
3130         else if (v < PY_FOOD_WEAK)
3131         {
3132                 new_aux = 1;
3133         }
3134
3135         /* Hungry */
3136         else if (v < PY_FOOD_ALERT)
3137         {
3138                 new_aux = 2;
3139         }
3140
3141         /* Normal */
3142         else if (v < PY_FOOD_FULL)
3143         {
3144                 new_aux = 3;
3145         }
3146
3147         /* Full */
3148         else if (v < PY_FOOD_MAX)
3149         {
3150                 new_aux = 4;
3151         }
3152
3153         /* Gorged */
3154         else
3155         {
3156                 new_aux = 5;
3157         }
3158
3159         if (old_aux < 1 && new_aux > 0)
3160                 chg_virtue(V_PATIENCE, 2);
3161         else if (old_aux < 3 && (old_aux != new_aux))
3162                 chg_virtue(V_PATIENCE, 1);
3163         if (old_aux == 2)
3164                 chg_virtue(V_TEMPERANCE, 1);
3165         if (old_aux == 0)
3166                 chg_virtue(V_TEMPERANCE, -1);
3167
3168         /* Food increase */
3169         if (new_aux > old_aux)
3170         {
3171                 /* Describe the state */
3172                 switch (new_aux)
3173                 {
3174                         /* Weak */
3175                         case 1: msg_print(_("まだ空腹で倒れそうだ。", "You are still weak.")); break;
3176
3177                         /* Hungry */
3178                         case 2: msg_print(_("まだ空腹だ。", "You are still hungry.")); break;
3179
3180                         /* Normal */
3181                         case 3: msg_print(_("空腹感がおさまった。", "You are no longer hungry.")); break;
3182
3183                         /* Full */
3184                         case 4: msg_print(_("満腹だ！", "You are full!")); break;
3185
3186                         /* Bloated */
3187                         case 5:
3188                         msg_print(_("食べ過ぎだ！", "You have gorged yourself!"));
3189                         chg_virtue(V_HARMONY, -1);
3190                         chg_virtue(V_PATIENCE, -1);
3191                         chg_virtue(V_TEMPERANCE, -2);
3192
3193                         break;
3194                 }
3195
3196                 /* Change */
3197                 notice = TRUE;
3198         }
3199
3200         /* Food decrease */
3201         else if (new_aux < old_aux)
3202         {
3203                 /* Describe the state */
3204                 switch (new_aux)
3205                 {
3206                         /* Fainting / Starving */
3207                         case 0: msg_print(_("あまりにも空腹で気を失ってしまった！", "You are getting faint from hunger!")); break;
3208
3209                         /* Weak */
3210                         case 1: msg_print(_("お腹が空いて倒れそうだ。", "You are getting weak from hunger!")); break;
3211
3212                         /* Hungry */
3213                         case 2: msg_print(_("お腹が空いてきた。", "You are getting hungry.")); break;
3214
3215                         /* Normal */
3216                         case 3: msg_print(_("満腹感がなくなった。", "You are no longer full.")); break;
3217
3218                         /* Full */
3219                         case 4: msg_print(_("やっとお腹がきつくなくなった。", "You are no longer gorged.")); break;
3220                 }
3221
3222                 if (p_ptr->wild_mode && (new_aux < 2))
3223                 {
3224                         change_wild_mode();
3225                 }
3226
3227                 /* Change */
3228                 notice = TRUE;
3229         }
3230
3231         /* Use the value */
3232         p_ptr->food = v;
3233
3234         /* Nothing to notice */
3235         if (!notice) return (FALSE);
3236
3237         if (disturb_state) disturb(FALSE, FALSE);
3238         p_ptr->update |= (PU_BONUS);
3239
3240         /* Redraw hunger */
3241         p_ptr->redraw |= (PR_HUNGER);
3242         handle_stuff();
3243         return (TRUE);
3244 }
3245
3246 /*!
3247  * @brief プレイヤーの基本能力値を増加させる / Increases a stat by one randomized level -RAK-
3248  * @param stat 上昇させるステータスID
3249  * @return 実際に上昇した場合TRUEを返す。
3250  * @details
3251  * Note that this function (used by stat potions) now restores\n
3252  * the stat BEFORE increasing it.\n
3253  */
3254 bool inc_stat(int stat)
3255 {
3256         BASE_STATUS value, gain;
3257
3258         /* Then augment the current/max stat */
3259         value = p_ptr->stat_cur[stat];
3260
3261         /* Cannot go above 18/100 */
3262         if (value < p_ptr->stat_max_max[stat])
3263         {
3264                 /* Gain one (sometimes two) points */
3265                 if (value < 18)
3266                 {
3267                         gain = ((randint0(100) < 75) ? 1 : 2);
3268                         value += gain;
3269                 }
3270
3271                 /* Gain 1/6 to 1/3 of distance to 18/100 */
3272                 else if (value < (p_ptr->stat_max_max[stat]-2))
3273                 {
3274                         /* Approximate gain value */
3275                         gain = (((p_ptr->stat_max_max[stat]) - value) / 2 + 3) / 2;
3276
3277                         /* Paranoia */
3278                         if (gain < 1) gain = 1;
3279
3280                         /* Apply the bonus */
3281                         value += randint1(gain) + gain / 2;
3282
3283                         /* Maximal value */
3284                         if (value > (p_ptr->stat_max_max[stat]-1)) value = p_ptr->stat_max_max[stat]-1;
3285                 }
3286
3287                 /* Gain one point at a time */
3288                 else
3289                 {
3290                         value++;
3291                 }
3292
3293                 /* Save the new value */
3294                 p_ptr->stat_cur[stat] = value;
3295
3296                 /* Bring up the maximum too */
3297                 if (value > p_ptr->stat_max[stat])
3298                 {
3299                         p_ptr->stat_max[stat] = value;
3300                 }
3301                 p_ptr->update |= (PU_BONUS);
3302
3303                 /* Success */
3304                 return (TRUE);
3305         }
3306
3307         /* Nothing to gain */
3308         return (FALSE);
3309 }
3310
3311 /*!
3312  * @brief プレイヤーの基本能力値を減少させる / Decreases a stat by an amount indended to vary from 0 to 100 percent.
3313  * @param stat 減少させるステータスID
3314  * @param amount 減少させる基本量
3315  * @param permanent TRUEならば現在の最大値を減少させる
3316  * @return 実際に減少した場合TRUEを返す。
3317  * @details
3318  *\n
3319  * Amount could be a little higher in extreme cases to mangle very high\n
3320  * stats from massive assaults.  -CWS\n
3321  *\n
3322  * Note that "permanent" means that the *given* amount is permanent,\n
3323  * not that the new value becomes permanent.  This may not work exactly\n
3324  * as expected, due to "weirdness" in the algorithm, but in general,\n
3325  * if your stat is already drained, the "max" value will not drop all\n
3326  * the way down to the "cur" value.\n
3327  */
3328 bool dec_stat(int stat, int amount, int permanent)
3329 {
3330         BASE_STATUS cur, max;
3331         int loss, same;
3332         bool res = FALSE;
3333
3334
3335         /* Acquire current value */
3336         cur = p_ptr->stat_cur[stat];
3337         max = p_ptr->stat_max[stat];
3338
3339         /* Note when the values are identical */
3340         same = (cur == max);
3341
3342         /* Damage "current" value */
3343         if (cur > 3)
3344         {
3345                 /* Handle "low" values */
3346                 if (cur <= 18)
3347                 {
3348                         if (amount > 90) cur--;
3349                         if (amount > 50) cur--;
3350                         if (amount > 20) cur--;
3351                         cur--;
3352                 }
3353
3354                 /* Handle "high" values */
3355                 else
3356                 {
3357                         /* Hack -- Decrement by a random amount between one-quarter */
3358                         /* and one-half of the stat bonus times the percentage, with a */
3359                         /* minimum damage of half the percentage. -CWS */
3360                         loss = (((cur-18) / 2 + 1) / 2 + 1);
3361
3362                         /* Paranoia */
3363                         if (loss < 1) loss = 1;
3364
3365                         /* Randomize the loss */
3366                         loss = ((randint1(loss) + loss) * amount) / 100;
3367
3368                         /* Maximal loss */
3369                         if (loss < amount/2) loss = amount/2;
3370
3371                         /* Lose some points */
3372                         cur = cur - loss;
3373
3374                         /* Hack -- Only reduce stat to 17 sometimes */
3375                         if (cur < 18) cur = (amount <= 20) ? 18 : 17;
3376                 }
3377
3378                 /* Prevent illegal values */
3379                 if (cur < 3) cur = 3;
3380
3381                 /* Something happened */
3382                 if (cur != p_ptr->stat_cur[stat]) res = TRUE;
3383         }
3384
3385         /* Damage "max" value */
3386         if (permanent && (max > 3))
3387         {
3388                 chg_virtue(V_SACRIFICE, 1);
3389                 if (stat == A_WIS || stat == A_INT)
3390                         chg_virtue(V_ENLIGHTEN, -2);
3391
3392                 /* Handle "low" values */
3393                 if (max <= 18)
3394                 {
3395                         if (amount > 90) max--;
3396                         if (amount > 50) max--;
3397                         if (amount > 20) max--;
3398                         max--;
3399                 }
3400
3401                 /* Handle "high" values */
3402                 else
3403                 {
3404                         /* Hack -- Decrement by a random amount between one-quarter */
3405                         /* and one-half of the stat bonus times the percentage, with a */
3406                         /* minimum damage of half the percentage. -CWS */
3407                         loss = (((max-18) / 2 + 1) / 2 + 1);
3408                         loss = ((randint1(loss) + loss) * amount) / 100;
3409                         if (loss < amount/2) loss = amount/2;
3410
3411                         /* Lose some points */
3412                         max = max - loss;
3413
3414                         /* Hack -- Only reduce stat to 17 sometimes */
3415                         if (max < 18) max = (amount <= 20) ? 18 : 17;
3416                 }
3417
3418                 /* Hack -- keep it clean */
3419                 if (same || (max < cur)) max = cur;
3420
3421                 /* Something happened */
3422                 if (max != p_ptr->stat_max[stat]) res = TRUE;
3423         }
3424
3425         /* Apply changes */
3426         if (res)
3427         {
3428                 /* Actually set the stat to its new value. */
3429                 p_ptr->stat_cur[stat] = cur;
3430                 p_ptr->stat_max[stat] = max;
3431
3432                 p_ptr->redraw |= (PR_STATS);
3433                 p_ptr->update |= (PU_BONUS);
3434         }
3435
3436         return (res);
3437 }
3438
3439
3440 /*!
3441  * @brief プレイヤーの基本能力値を回復させる / Restore a stat.  Return TRUE only if this actually makes a difference.
3442  * @param stat 回復ステータスID
3443  * @return 実際に回復した場合TRUEを返す。
3444  */
3445 bool res_stat(int stat)
3446 {
3447         /* Restore if needed */
3448         if (p_ptr->stat_cur[stat] != p_ptr->stat_max[stat])
3449         {
3450                 p_ptr->stat_cur[stat] = p_ptr->stat_max[stat];
3451                 p_ptr->update |= (PU_BONUS);
3452                 p_ptr->redraw |= (PR_STATS);
3453
3454                 /* Success */
3455                 return (TRUE);
3456         }
3457
3458         /* Nothing to restore */
3459         return (FALSE);
3460 }
3461
3462
3463 /*
3464  * Increase players hit points, notice effects
3465  */
3466 bool hp_player(int num)
3467 {
3468         int vir;
3469         vir = virtue_number(V_VITALITY);
3470
3471         if(num <= 0) return (FALSE);
3472
3473         if(vir)
3474         {
3475                 num = num * (p_ptr->virtues[vir - 1] + 1250) / 1250;
3476         }
3477         /* Healing needed */
3478         if (p_ptr->chp < p_ptr->mhp)
3479         {
3480                 if ((num > 0) && (p_ptr->chp < (p_ptr->mhp/3)))
3481                         chg_virtue(V_TEMPERANCE, 1);
3482                 /* Gain hitpoints */
3483                 p_ptr->chp += num;
3484
3485                 /* Enforce maximum */
3486                 if (p_ptr->chp >= p_ptr->mhp)
3487                 {
3488                         p_ptr->chp = p_ptr->mhp;
3489                         p_ptr->chp_frac = 0;
3490                 }
3491
3492                 p_ptr->redraw |= (PR_HP);
3493
3494                 p_ptr->window |= (PW_PLAYER);
3495
3496                 /* Heal 0-4 */
3497                 if (num < 5)
3498                 {
3499                         msg_print(_("少し気分が良くなった。", "You feel a little better."));
3500                 }
3501
3502                 /* Heal 5-14 */
3503                 else if (num < 15)
3504                 {
3505                         msg_print(_("気分が良くなった。", "You feel better."));
3506                 }
3507
3508                 /* Heal 15-34 */
3509                 else if (num < 35)
3510                 {
3511                         msg_print(_("とても気分が良くなった。", "You feel much better."));
3512                 }
3513
3514                 /* Heal 35+ */
3515                 else
3516                 {
3517                         msg_print(_("ひじょうに気分が良くなった。", "You feel very good."));
3518                 }
3519
3520                 return (TRUE);
3521         }
3522
3523         /* Ignore */
3524         return (FALSE);
3525 }
3526
3527
3528 /*
3529  * Array of stat "descriptions"
3530  */
3531 static concptr desc_stat_pos[] =
3532 {
3533         _("強く", "strong"),
3534         _("知的に", "smart"),
3535         _("賢く", "wise"),
3536         _("器用に", "dextrous"),
3537         _("健康に", "healthy"),
3538         _("美しく", "cute")
3539 };
3540
3541
3542 /*
3543  * Array of stat "descriptions"
3544  */
3545 static concptr desc_stat_neg[] =
3546 {
3547         _("弱く", "weak"),
3548         _("無知に", "stupid"),
3549         _("愚かに", "naive"),
3550         _("不器用に", "clumsy"),
3551         _("不健康に", "sickly"),
3552         _("醜く", "ugly")
3553 };
3554
3555
3556 /*
3557  * Lose a "point"
3558  */
3559 bool do_dec_stat(int stat)
3560 {
3561         bool sust = FALSE;
3562
3563         /* Access the "sustain" */
3564         switch (stat)
3565         {
3566                 case A_STR: if (p_ptr->sustain_str) sust = TRUE; break;
3567                 case A_INT: if (p_ptr->sustain_int) sust = TRUE; break;
3568                 case A_WIS: if (p_ptr->sustain_wis) sust = TRUE; break;
3569                 case A_DEX: if (p_ptr->sustain_dex) sust = TRUE; break;
3570                 case A_CON: if (p_ptr->sustain_con) sust = TRUE; break;
3571                 case A_CHR: if (p_ptr->sustain_chr) sust = TRUE; break;
3572         }
3573
3574         /* Sustain */
3575         if (sust && (!ironman_nightmare || randint0(13)))
3576         {
3577                 msg_format(_("%sなった気がしたが、すぐに元に戻った。", "You feel %s for a moment, but the feeling passes."),
3578                                         desc_stat_neg[stat]);
3579
3580                 /* Notice effect */
3581                 return (TRUE);
3582         }
3583
3584         /* Attempt to reduce the stat */
3585         if (dec_stat(stat, 10, (ironman_nightmare && !randint0(13))))
3586         {
3587                 msg_format(_("ひどく%sなった気がする。", "You feel very %s."), desc_stat_neg[stat]);
3588
3589                 /* Notice effect */
3590                 return (TRUE);
3591         }
3592
3593         /* Nothing obvious */
3594         return (FALSE);
3595 }
3596
3597
3598 /*
3599  * Restore lost "points" in a stat
3600  */
3601 bool do_res_stat(int stat)
3602 {
3603         /* Attempt to increase */
3604         if (res_stat(stat))
3605         {
3606                 msg_format(_("元通りに%sなった気がする。", "You feel less %s."), desc_stat_pos[stat]);
3607
3608                 return (TRUE);
3609         }
3610
3611         /* Nothing obvious */
3612         return (FALSE);
3613 }
3614
3615
3616 /*
3617  * Gain a "point" in a stat
3618  */
3619 bool do_inc_stat(int stat)
3620 {
3621         bool res;
3622
3623         /* Restore strength */
3624         res = res_stat(stat);
3625
3626         /* Attempt to increase */
3627         if (inc_stat(stat))
3628         {
3629                 if (stat == A_WIS)
3630                 {
3631                         chg_virtue(V_ENLIGHTEN, 1);
3632                         chg_virtue(V_FAITH, 1);
3633                 }
3634                 else if (stat == A_INT)
3635                 {
3636                         chg_virtue(V_KNOWLEDGE, 1);
3637                         chg_virtue(V_ENLIGHTEN, 1);
3638                 }
3639                 else if (stat == A_CON)
3640                         chg_virtue(V_VITALITY, 1);
3641
3642                 msg_format(_("ワーオ！とても%sなった！", "Wow!  You feel very %s!"), desc_stat_pos[stat]);
3643
3644                 return (TRUE);
3645         }
3646
3647         /* Restoration worked */
3648         if (res)
3649         {
3650                 msg_format(_("元通りに%sなった気がする。", "You feel less %s."), desc_stat_pos[stat]);
3651
3652                 return (TRUE);
3653         }
3654
3655         /* Nothing obvious */
3656         return (FALSE);
3657 }
3658
3659
3660 /*
3661  * Restores any drained experience
3662  */
3663 bool restore_level(void)
3664 {
3665         /* Restore experience */
3666         if (p_ptr->exp < p_ptr->max_exp)
3667         {
3668                 msg_print(_("経験値が戻ってきた気がする。", "You feel your experience returning."));
3669
3670                 /* Restore the experience */
3671                 p_ptr->exp = p_ptr->max_exp;
3672
3673                 /* Check the experience */
3674                 check_experience();
3675
3676                 /* Did something */
3677                 return (TRUE);
3678         }
3679
3680         /* No effect */
3681         return (FALSE);
3682 }
3683
3684 /*
3685  * Forget everything
3686  */
3687 bool lose_all_info(void)
3688 {
3689         int i;
3690
3691         chg_virtue(V_KNOWLEDGE, -5);
3692         chg_virtue(V_ENLIGHTEN, -5);
3693
3694         /* Forget info about objects */
3695         for (i = 0; i < INVEN_TOTAL; i++)
3696         {
3697                 object_type *o_ptr = &inventory[i];
3698
3699                 /* Skip non-objects */
3700                 if (!o_ptr->k_idx) continue;
3701
3702                 /* Allow "protection" by the MENTAL flag */
3703                 if (o_ptr->ident & (IDENT_MENTAL)) continue;
3704
3705                 /* Remove "default inscriptions" */
3706                 o_ptr->feeling = FEEL_NONE;
3707
3708                 /* Hack -- Clear the "empty" flag */
3709                 o_ptr->ident &= ~(IDENT_EMPTY);
3710
3711                 /* Hack -- Clear the "known" flag */
3712                 o_ptr->ident &= ~(IDENT_KNOWN);
3713
3714                 /* Hack -- Clear the "felt" flag */
3715                 o_ptr->ident &= ~(IDENT_SENSE);
3716         }
3717         p_ptr->update |= (PU_BONUS);
3718         p_ptr->update |= (PU_COMBINE | PU_REORDER);
3719
3720         p_ptr->window |= (PW_INVEN | PW_EQUIP | PW_PLAYER);
3721
3722         /* Mega-Hack -- Forget the map */
3723         wiz_dark();
3724
3725         /* It worked */
3726         return (TRUE);
3727 }
3728
3729
3730 void do_poly_wounds(void)
3731 {
3732         /* Changed to always provide at least _some_ healing */
3733         s16b wounds = p_ptr->cut;
3734         s16b hit_p = (p_ptr->mhp - p_ptr->chp);
3735         s16b change = damroll(p_ptr->lev, 5);
3736         bool Nasty_effect = one_in_(5);
3737
3738         if (!(wounds || hit_p || Nasty_effect)) return;
3739
3740         msg_print(_("傷がより軽いものに変化した。", "Your wounds are polymorphed into less serious ones."));
3741         hp_player(change);
3742         if (Nasty_effect)
3743         {
3744                 msg_print(_("新たな傷ができた！", "A new wound was created!"));
3745                 take_hit(DAMAGE_LOSELIFE, change / 2, _("変化した傷", "a polymorphed wound"), -1);
3746                 set_cut(change);
3747         }
3748         else
3749         {
3750                 set_cut(p_ptr->cut - (change / 2));
3751         }
3752 }
3753
3754
3755 /*
3756  * Change player race
3757  */
3758 void change_race(CHARACTER_IDX new_race, concptr effect_msg)
3759 {
3760         concptr title = race_info[new_race].title;
3761         int  old_race = p_ptr->prace;
3762
3763 #ifdef JP
3764         msg_format("あなたは%s%sに変化した！", effect_msg, title);
3765 #else
3766         msg_format("You turn into %s %s%s!", (!effect_msg[0] && is_a_vowel(title[0]) ? "an" : "a"), effect_msg, title);
3767 #endif
3768
3769         chg_virtue(V_CHANCE, 2);
3770
3771         if (p_ptr->prace < 32)
3772         {
3773                 p_ptr->old_race1 |= 1L << p_ptr->prace;
3774         }
3775         else
3776         {
3777                 p_ptr->old_race2 |= 1L << (p_ptr->prace - 32);
3778         }
3779         p_ptr->prace = new_race;
3780         rp_ptr = &race_info[p_ptr->prace];
3781
3782         /* Experience factor */
3783         p_ptr->expfact = rp_ptr->r_exp + cp_ptr->c_exp;
3784
3785         /*
3786          * The speed bonus of Klackons and Sprites are disabled
3787          * and the experience penalty is decreased.
3788          */
3789         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)))
3790                 p_ptr->expfact -= 15;
3791
3792         /* Get character's height and weight */
3793         get_height_weight();
3794
3795         /* Hitdice */
3796         if (p_ptr->pclass == CLASS_SORCERER)
3797                 p_ptr->hitdie = rp_ptr->r_mhp/2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
3798         else
3799                 p_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
3800
3801         do_cmd_rerate(FALSE);
3802
3803         /* The experience level may be modified */
3804         check_experience();
3805
3806         p_ptr->redraw |= (PR_BASIC);
3807
3808         p_ptr->update |= (PU_BONUS);
3809
3810         handle_stuff();
3811
3812         /* Load an autopick preference file */
3813         if (old_race != p_ptr->prace) autopick_load_pref(FALSE);
3814
3815         /* Player's graphic tile may change */
3816         lite_spot(p_ptr->y, p_ptr->x);
3817 }
3818
3819
3820 void do_poly_self(void)
3821 {
3822         int power = p_ptr->lev;
3823
3824         msg_print(_("あなたは変化の訪れを感じた...", "You feel a change coming over you..."));
3825         chg_virtue(V_CHANCE, 1);
3826
3827         if ((power > randint0(20)) && one_in_(3) && (p_ptr->prace != RACE_ANDROID))
3828         {
3829                 char effect_msg[80] = "";
3830                 CHARACTER_IDX new_race;
3831
3832                 /* Some form of racial polymorph... */
3833                 power -= 10;
3834
3835                 if ((power > randint0(5)) && one_in_(4))
3836                 {
3837                         /* sex change */
3838                         power -= 2;
3839
3840                         if (p_ptr->psex == SEX_MALE)
3841                         {
3842                                 p_ptr->psex = SEX_FEMALE;
3843                                 sp_ptr = &sex_info[p_ptr->psex];
3844                                 sprintf(effect_msg, _("女性の", "female "));
3845                         }
3846                         else
3847                         {
3848                                 p_ptr->psex = SEX_MALE;
3849                                 sp_ptr = &sex_info[p_ptr->psex];
3850                                 sprintf(effect_msg, _("男性の", "male "));
3851                         }
3852                 }
3853
3854                 if ((power > randint0(30)) && one_in_(5))
3855                 {
3856                         int tmp = 0;
3857
3858                         /* Harmful deformity */
3859                         power -= 15;
3860
3861                         while (tmp < A_MAX)
3862                         {
3863                                 if (one_in_(2))
3864                                 {
3865                                         (void)dec_stat(tmp, randint1(6) + 6, one_in_(3));
3866                                         power -= 1;
3867                                 }
3868                                 tmp++;
3869                         }
3870
3871                         /* Deformities are discriminated against! */
3872                         (void)dec_stat(A_CHR, randint1(6), TRUE);
3873
3874                         if (effect_msg[0])
3875                         {
3876                                 char tmp_msg[10];
3877                                 sprintf(tmp_msg,_("%s", "%s "),effect_msg);
3878                                 sprintf(effect_msg,_("奇形の%s", "deformed %s "),tmp_msg);
3879                         }
3880                         else
3881                         {
3882                                 sprintf(effect_msg,_("奇形の", "deformed "));
3883                         }
3884                 }
3885
3886                 while ((power > randint0(20)) && one_in_(10))
3887                 {
3888                         /* Polymorph into a less mutated form */
3889                         power -= 10;
3890
3891                         if (!lose_mutation(0))
3892                         msg_print(_("奇妙なくらい普通になった気がする。", "You feel oddly normal."));
3893                 }
3894
3895                 do
3896                 {
3897                         new_race = (CHARACTER_IDX)randint0(MAX_RACES);
3898                 }
3899                 while ((new_race == p_ptr->prace) || (new_race == RACE_ANDROID));
3900
3901                 change_race(new_race, effect_msg);
3902         }
3903
3904         if ((power > randint0(30)) && one_in_(6))
3905         {
3906                 int tmp = 0;
3907
3908                 /* Abomination! */
3909                 power -= 20;
3910                 msg_format(_("%sの構成が変化した！", "Your internal organs are rearranged!"), p_ptr->prace == RACE_ANDROID ? "機械" : "内臓");
3911
3912                 while (tmp < A_MAX)
3913                 {
3914                         (void)dec_stat(tmp, randint1(6) + 6, one_in_(3));
3915                         tmp++;
3916                 }
3917                 if (one_in_(6))
3918                 {
3919                         msg_print(_("現在の姿で生きていくのは困難なようだ！", "You find living difficult in your present form!"));
3920                         take_hit(DAMAGE_LOSELIFE, damroll(randint1(10), p_ptr->lev), _("致命的な突然変異", "a lethal mutation"), -1);
3921
3922                         power -= 10;
3923                 }
3924         }
3925
3926         if ((power > randint0(20)) && one_in_(4))
3927         {
3928                 power -= 10;
3929
3930                 get_max_stats();
3931                 do_cmd_rerate(FALSE);
3932         }
3933
3934         while ((power > randint0(15)) && one_in_(3))
3935         {
3936                 power -= 7;
3937                 (void)gain_random_mutation(0);
3938         }
3939
3940         if (power > randint0(5))
3941         {
3942                 power -= 5;
3943                 do_poly_wounds();
3944         }
3945
3946         /* Note: earlier deductions may have left power < 0 already. */
3947         while (power > 0)
3948         {
3949                 mutate_player();
3950                 power--;
3951         }
3952 }
3953
3954
3955 /*
3956  * Decreases players hit points and sets death flag if necessary
3957  *
3958  * Invulnerability needs to be changed into a "shield"
3959  *
3960  * Hack -- this function allows the user to save (or quit)
3961  * the game when he dies, since the "You die." message is shown before
3962  * setting the player to "dead".
3963  */
3964
3965 int take_hit(int damage_type, HIT_POINT damage, concptr hit_from, int monspell)
3966 {
3967         int old_chp = p_ptr->chp;
3968
3969         char death_message[1024];
3970         char tmp[1024];
3971
3972         int warning = (p_ptr->mhp * hitpoint_warn / 10);
3973
3974         /* Paranoia */
3975         if (p_ptr->is_dead) return 0;
3976
3977         if (p_ptr->sutemi) damage *= 2;
3978         if (p_ptr->special_defense & KATA_IAI) damage += (damage + 4) / 5;
3979
3980         if (easy_band) damage = (damage+1)/2;
3981
3982         if (damage_type != DAMAGE_USELIFE)
3983         {
3984                 disturb(TRUE, TRUE);
3985                 if (auto_more)
3986                 {
3987                         now_damaged = TRUE;
3988                 }
3989         }
3990
3991         if (monspell >= 0) learn_spell(monspell);
3992
3993         /* Mega-Hack -- Apply "invulnerability" */
3994         if ((damage_type != DAMAGE_USELIFE) && (damage_type != DAMAGE_LOSELIFE))
3995         {
3996                 if (IS_INVULN() && (damage < 9000))
3997                 {
3998                         if (damage_type == DAMAGE_FORCE)
3999                         {
4000                                 msg_print(_("バリアが切り裂かれた！", "The attack cuts your shield of invulnerability open!"));
4001                         }
4002                         else if (one_in_(PENETRATE_INVULNERABILITY))
4003                         {
4004                                 msg_print(_("無敵のバリアを破って攻撃された！", "The attack penetrates your shield of invulnerability!"));
4005                         }
4006                         else
4007                         {
4008                                 return 0;
4009                         }
4010                 }
4011
4012                 if (CHECK_MULTISHADOW())
4013                 {
4014                         if (damage_type == DAMAGE_FORCE)
4015                         {
4016                                 msg_print(_("幻影もろとも体が切り裂かれた！", "The attack hits Shadow together with you!"));
4017                         }
4018                         else if (damage_type == DAMAGE_ATTACK)
4019                         {
4020                                 msg_print(_("攻撃は幻影に命中し、あなたには届かなかった。", "The attack hits Shadow, you are unharmed!"));
4021                                 return 0;
4022                         }
4023                 }
4024
4025                 if (p_ptr->wraith_form)
4026                 {
4027                         if (damage_type == DAMAGE_FORCE)
4028                         {
4029                                 msg_print(_("半物質の体が切り裂かれた！", "The attack cuts through your ethereal body!"));
4030                         }
4031                         else
4032                         {
4033                                 damage /= 2;
4034                                 if ((damage == 0) && one_in_(2)) damage = 1;
4035                         }
4036                 }
4037
4038                 if (p_ptr->special_defense & KATA_MUSOU)
4039                 {
4040                         damage /= 2;
4041                         if ((damage == 0) && one_in_(2)) damage = 1;
4042                 }
4043         } /* not if LOSELIFE USELIFE */
4044
4045         /* Hurt the player */
4046         p_ptr->chp -= damage;
4047         if(damage_type == DAMAGE_GENO && p_ptr->chp < 0)
4048         {
4049                 damage += p_ptr->chp;
4050                 p_ptr->chp = 0;
4051         }
4052
4053         /* Display the hitpoints */
4054         p_ptr->redraw |= (PR_HP);
4055
4056         p_ptr->window |= (PW_PLAYER);
4057
4058         if (damage_type != DAMAGE_GENO && p_ptr->chp == 0)
4059         {
4060                 chg_virtue(V_SACRIFICE, 1);
4061                 chg_virtue(V_CHANCE, 2);
4062         }
4063
4064         /* Dead player */
4065         if (p_ptr->chp < 0)
4066         {
4067                 bool android = (p_ptr->prace == RACE_ANDROID ? TRUE : FALSE);
4068
4069 #ifdef JP       /* 死んだ時に強制終了して死を回避できなくしてみた by Habu */
4070                 if (!cheat_save)
4071                         if(!save_player()) msg_print("セーブ失敗！");
4072 #endif
4073
4074                 sound(SOUND_DEATH);
4075
4076                 chg_virtue(V_SACRIFICE, 10);
4077
4078                 handle_stuff();
4079
4080                 /* Leaving */
4081                 p_ptr->leaving = TRUE;
4082
4083                 /* Note death */
4084                 p_ptr->is_dead = TRUE;
4085
4086                 if (p_ptr->inside_arena)
4087                 {
4088                         concptr m_name = r_name+r_info[arena_info[p_ptr->arena_number].r_idx].name;
4089                         msg_format(_("あなたは%sの前に敗れ去った。", "You are beaten by %s."), m_name);
4090                         msg_print(NULL);
4091                         if (record_arena) do_cmd_write_nikki(NIKKI_ARENA, -1 - p_ptr->arena_number, m_name);
4092                 }
4093                 else
4094                 {
4095                         QUEST_IDX q_idx = quest_number(dun_level);
4096                         bool seppuku = streq(hit_from, "Seppuku");
4097                         bool winning_seppuku = p_ptr->total_winner && seppuku;
4098
4099                         play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_GAMEOVER);
4100
4101 #ifdef WORLD_SCORE
4102                         /* Make screen dump */
4103                         screen_dump = make_screen_dump();
4104 #endif
4105
4106                         /* Note cause of death */
4107                         if (seppuku)
4108                         {
4109                                 strcpy(p_ptr->died_from, hit_from);
4110 #ifdef JP
4111                                 if (!winning_seppuku) strcpy(p_ptr->died_from, "切腹");
4112 #endif
4113                         }
4114                         else
4115                         {
4116                                 char dummy[1024];
4117 #ifdef JP
4118                                 sprintf(dummy, "%s%s%s", !p_ptr->paralyzed ? "" : p_ptr->free_act ? "彫像状態で" : "麻痺状態で", p_ptr->image ? "幻覚に歪んだ" : "", hit_from);
4119 #else
4120                                 sprintf(dummy, "%s%s", hit_from, !p_ptr->paralyzed ? "" : " while helpless");
4121 #endif
4122                                 my_strcpy(p_ptr->died_from, dummy, sizeof p_ptr->died_from);
4123                         }
4124
4125                         /* No longer a winner */
4126                         p_ptr->total_winner = FALSE;
4127
4128                         if (winning_seppuku)
4129                         {
4130                                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, _("勝利の後切腹した。", "did Seppuku after the winning."));
4131                         }
4132                         else
4133                         {
4134                                 char buf[20];
4135
4136                                 if (p_ptr->inside_arena)
4137                                         strcpy(buf,_("アリーナ", "in the Arena"));
4138                                 else if (!dun_level)
4139                                         strcpy(buf,_("地上", "on the surface"));
4140                                 else if (q_idx && (is_fixed_quest_idx(q_idx) &&
4141                                          !((q_idx == QUEST_OBERON) || (q_idx == QUEST_SERPENT))))
4142                                         strcpy(buf,_("クエスト", "in a quest"));
4143                                 else
4144                                         sprintf(buf,_("%d階", "level %d"), (int)dun_level);
4145
4146                                 sprintf(tmp, _("%sで%sに殺された。", "killed by %s %s."), buf, p_ptr->died_from);
4147                                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, tmp);
4148                         }
4149
4150                         do_cmd_write_nikki(NIKKI_GAMESTART, 1, _("-------- ゲームオーバー --------", "--------   Game  Over   --------"));
4151                         do_cmd_write_nikki(NIKKI_BUNSHOU, 1, "\n\n\n\n");
4152
4153                         flush();
4154
4155                         if (get_check_strict(_("画面を保存しますか？", "Dump the screen? "), CHECK_NO_HISTORY))
4156                         {
4157                                 do_cmd_save_screen();
4158                         }
4159
4160                         flush();
4161
4162                         /* Initialize "last message" buffer */
4163                         if (p_ptr->last_message) string_free(p_ptr->last_message);
4164                         p_ptr->last_message = NULL;
4165
4166                         /* Hack -- Note death */
4167                         if (!last_words)
4168                         {
4169 #ifdef JP
4170                                 msg_format("あなたは%sました。", android ? "壊れ" : "死に");
4171 #else
4172                                 msg_print(android ? "You are broken." : "You die.");
4173 #endif
4174
4175                                 msg_print(NULL);
4176                         }
4177                         else
4178                         {
4179                                 if (winning_seppuku)
4180                                 {
4181                                         get_rnd_line(_("seppuku_j.txt", "seppuku.txt"), 0, death_message);
4182                                 }
4183                                 else
4184                                 {
4185                                         get_rnd_line(_("death_j.txt", "death.txt"), 0, death_message);
4186                                 }
4187
4188                                 do
4189                                 {
4190 #ifdef JP
4191                                         while (!get_string(winning_seppuku ? "辞世の句: " : "断末魔の叫び: ", death_message, 1024)) ;
4192 #else
4193                                         while (!get_string("Last word: ", death_message, 1024)) ;
4194 #endif
4195                                 }
4196                                 while (winning_seppuku && !get_check_strict(_("よろしいですか？", "Are you sure? "), CHECK_NO_HISTORY));
4197
4198                                 if (death_message[0] == '\0')
4199                                 {
4200 #ifdef JP
4201                                         strcpy(death_message, format("あなたは%sました。", android ? "壊れ" : "死に"));
4202 #else
4203                                         strcpy(death_message, android ? "You are broken." : "You die.");
4204 #endif
4205                                 }
4206                                 else p_ptr->last_message = string_make(death_message);
4207
4208 #ifdef JP
4209                                 if (winning_seppuku)
4210                                 {
4211                                         int i, len;
4212                                         int w = Term->wid;
4213                                         int h = Term->hgt;
4214                                         int msg_pos_x[9] = {  5,  7,  9, 12,  14,  17,  19,  21, 23};
4215                                         int msg_pos_y[9] = {  3,  4,  5,  4,   5,   4,   5,   6,  4};
4216                                         concptr str;
4217                                         char* str2;
4218
4219                                         Term_clear();
4220
4221                                         /* 桜散る */
4222                                         for (i = 0; i < 40; i++)
4223                                                 Term_putstr(randint0(w / 2) * 2, randint0(h), 2, TERM_VIOLET, "υ");
4224
4225                                         str = death_message;
4226                                         if (strncmp(str, "「", 2) == 0) str += 2;
4227
4228                                         str2 = my_strstr(str, "」");
4229                                         if (str2 != NULL) *str2 = '\0';
4230
4231                                         i = 0;
4232                                         while (i < 9)
4233                                         {
4234                                                 str2 = my_strstr(str, " ");
4235                                                 if (str2 == NULL) len = strlen(str);
4236                                                 else len = str2 - str;
4237
4238                                                 if (len != 0)
4239                                                 {
4240                                                         Term_putstr_v(w * 3 / 4 - 2 - msg_pos_x[i] * 2, msg_pos_y[i], len,
4241                                                         TERM_WHITE, str);
4242                                                         if (str2 == NULL) break;
4243                                                         i++;
4244                                                 }
4245                                                 str = str2 + 1;
4246                                                 if (*str == 0) break;
4247                                         }
4248
4249                                         /* Hide cursor */
4250                                         Term_putstr(w-1, h-1, 1, TERM_WHITE, " ");
4251
4252                                         flush();
4253 #ifdef WORLD_SCORE
4254                                         /* Make screen dump */
4255                                         screen_dump = make_screen_dump();
4256 #endif
4257
4258                                         /* Wait a key press */
4259                                         (void)inkey();
4260                                 }
4261                                 else
4262 #endif
4263                                         msg_print(death_message);
4264                         }
4265                 }
4266
4267                 /* Dead */
4268                 return damage;
4269         }
4270
4271         handle_stuff();
4272
4273         /* Hitpoint warning */
4274         if (p_ptr->chp < warning)
4275         {
4276                 /* Hack -- bell on first notice */
4277                 if (old_chp > warning) bell();
4278
4279                 sound(SOUND_WARN);
4280
4281                 if (record_danger && (old_chp > warning))
4282                 {
4283                         if (p_ptr->image && damage_type == DAMAGE_ATTACK)
4284                                 hit_from = _("何か", "something");
4285
4286                         sprintf(tmp,_("%sによってピンチに陥った。", "A critical situation because of %s."),hit_from);
4287                         do_cmd_write_nikki(NIKKI_BUNSHOU, 0, tmp);
4288                 }
4289
4290                 if (auto_more)
4291                 {
4292                         /* stop auto_more even if DAMAGE_USELIFE */
4293                         now_damaged = TRUE;
4294                 }
4295
4296                 msg_print(_("*** 警告:低ヒット・ポイント！ ***", "*** LOW HITPOINT WARNING! ***"));
4297                 msg_print(NULL);
4298                 flush();
4299         }
4300         if (p_ptr->wild_mode && !p_ptr->leaving && (p_ptr->chp < MAX(warning, p_ptr->mhp/5)))
4301         {
4302                 change_wild_mode();
4303         }
4304         return damage;
4305 }
4306
4307
4308 /*
4309  * Gain experience
4310  */
4311 void gain_exp_64(s32b amount, u32b amount_frac)
4312 {
4313         if (p_ptr->is_dead) return;
4314
4315         if (p_ptr->prace == RACE_ANDROID) return;
4316
4317         /* Gain some experience */
4318         s64b_add(&(p_ptr->exp), &(p_ptr->exp_frac), amount, amount_frac);
4319
4320         /* Slowly recover from experience drainage */
4321         if (p_ptr->exp < p_ptr->max_exp)
4322         {
4323                 /* Gain max experience (20%) (was 10%) */
4324                 p_ptr->max_exp += amount / 5;
4325         }
4326
4327         /* Check Experience */
4328         check_experience();
4329 }
4330
4331
4332 /*
4333  * Gain experience
4334  */
4335 void gain_exp(s32b amount)
4336 {
4337         gain_exp_64(amount, 0L);
4338 }
4339
4340
4341 void calc_android_exp(void)
4342 {
4343         int i;
4344         u32b total_exp = 0;
4345         if (p_ptr->is_dead) return;
4346
4347         if (p_ptr->prace != RACE_ANDROID) return;
4348
4349         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
4350         {
4351                 object_type *o_ptr = &inventory[i];
4352                 object_type forge;
4353                 object_type *q_ptr = &forge;
4354                 u32b value, exp;
4355                 DEPTH level = MAX(k_info[o_ptr->k_idx].level - 8, 1);
4356
4357                 if ((i == INVEN_RIGHT) || (i == INVEN_LEFT) || (i == INVEN_NECK) || (i == INVEN_LITE)) continue;
4358                 if (!o_ptr->k_idx) continue;
4359                 object_wipe(q_ptr);
4360
4361                 object_copy(q_ptr, o_ptr);
4362                 q_ptr->discount = 0;
4363                 q_ptr->curse_flags = 0L;
4364
4365                 if (object_is_fixed_artifact(o_ptr))
4366                 {
4367                         level = (level + MAX(a_info[o_ptr->name1].level - 8, 5)) / 2;
4368                         level += MIN(20, a_info[o_ptr->name1].rarity/(a_info[o_ptr->name1].gen_flags & TRG_INSTA_ART ? 10 : 3));
4369                 }
4370                 else if (object_is_ego(o_ptr))
4371                 {
4372                         level += MAX(3, (e_info[o_ptr->name2].rating - 5)/2);
4373                 }
4374                 else if (o_ptr->art_name)
4375                 {
4376                         s32b total_flags = flag_cost(o_ptr, o_ptr->pval);
4377                         int fake_level;
4378
4379                         if (!object_is_weapon_ammo(o_ptr))
4380                         {
4381                                 /* For armors */
4382                                 if (total_flags < 15000) fake_level = 10;
4383                                 else if (total_flags < 35000) fake_level = 25;
4384                                 else fake_level = 40;
4385                         }
4386                         else
4387                         {
4388                                 /* For weapons */
4389                                 if (total_flags < 20000) fake_level = 10;
4390                                 else if (total_flags < 45000) fake_level = 25;
4391                                 else fake_level = 40;
4392                         }
4393
4394                         level = MAX(level, (level + MAX(fake_level - 8, 5)) / 2 + 3);
4395                 }
4396
4397                 value = object_value_real(q_ptr);
4398
4399                 if (value <= 0) continue;
4400                 if ((o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->sval == SV_ABUNAI_MIZUGI) && (p_ptr->pseikaku != SEIKAKU_SEXY)) value /= 32;
4401                 if (value > 5000000L) value = 5000000L;
4402                 if ((o_ptr->tval == TV_DRAG_ARMOR) || (o_ptr->tval == TV_CARD)) level /= 2;
4403
4404                 if (object_is_artifact(o_ptr) || object_is_ego(o_ptr) ||
4405                     (o_ptr->tval == TV_DRAG_ARMOR) ||
4406                     ((o_ptr->tval == TV_HELM) && (o_ptr->sval == SV_DRAGON_HELM)) ||
4407                     ((o_ptr->tval == TV_SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) ||
4408                     ((o_ptr->tval == TV_GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) ||
4409                     ((o_ptr->tval == TV_BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)) ||
4410                     ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DIAMOND_EDGE)))
4411                 {
4412                         if (level > 65) level = 35 + (level - 65) / 5;
4413                         else if (level > 35) level = 25 + (level - 35) / 3;
4414                         else if (level > 15) level = 15 + (level - 15) / 2;
4415                         exp = MIN(100000L, value) / 2 * level * level;
4416                         if (value > 100000L)
4417                                 exp += (value - 100000L) / 8 * level * level;
4418                 }
4419                 else
4420                 {
4421                         exp = MIN(100000L, value) * level;
4422                         if (value > 100000L)
4423                                 exp += (value - 100000L) / 4  * level;
4424                 }
4425                 if ((((i == INVEN_RARM) || (i == INVEN_LARM)) && (has_melee_weapon(i))) || (i == INVEN_BOW)) total_exp += exp / 48;
4426                 else total_exp += exp / 16;
4427                 if (i == INVEN_BODY) total_exp += exp / 32;
4428         }
4429         p_ptr->exp = p_ptr->max_exp = total_exp;
4430
4431         /* Check Experience */
4432         check_experience();
4433 }
4434
4435
4436 /*
4437  * Lose experience
4438  */
4439 void lose_exp(s32b amount)
4440 {
4441         if (p_ptr->prace == RACE_ANDROID) return;
4442
4443         /* Never drop below zero experience */
4444         if (amount > p_ptr->exp) amount = p_ptr->exp;
4445
4446         /* Lose some experience */
4447         p_ptr->exp -= amount;
4448
4449         /* Check Experience */
4450         check_experience();
4451 }
4452
4453
4454 /*
4455  * Drain experience
4456  * If resisted to draining, return FALSE
4457  */
4458 bool drain_exp(s32b drain, s32b slip, int hold_exp_prob)
4459 {
4460         /* Androids and their mimics are never drained */
4461         if (p_ptr->prace == RACE_ANDROID) return FALSE;
4462
4463         if (p_ptr->hold_exp && (randint0(100) < hold_exp_prob))
4464         {
4465                 /* Hold experience */
4466                 msg_print(_("しかし自己の経験値を守りきった！", "You keep hold of your experience!"));
4467                 return FALSE;
4468         }
4469
4470         /* Hold experience failed */
4471         if (p_ptr->hold_exp)
4472         {
4473                 msg_print(_("経験値を少し吸い取られた気がする！", "You feel your experience slipping away!"));
4474                 lose_exp(slip);
4475         }
4476         else
4477         {
4478                 msg_print(_("経験値が体から吸い取られた気がする！", "You feel your experience draining away!"));
4479                 lose_exp(drain);
4480         }
4481
4482         return TRUE;
4483 }
4484
4485
4486 bool set_ultimate_res(TIME_EFFECT v, bool do_dec)
4487 {
4488         bool notice = FALSE;
4489
4490         /* Hack -- Force good values */
4491         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
4492
4493         if (p_ptr->is_dead) return FALSE;
4494
4495         /* Open */
4496         if (v)
4497         {
4498                 if (p_ptr->ult_res && !do_dec)
4499                 {
4500                         if (p_ptr->ult_res > v) return FALSE;
4501                 }
4502                 else if (!p_ptr->ult_res)
4503                 {
4504                         msg_print(_("あらゆることに対して耐性がついた気がする！", "You feel resistant!"));
4505                         notice = TRUE;
4506                 }
4507         }
4508
4509         /* Shut */
4510         else
4511         {
4512                 if (p_ptr->ult_res)
4513                 {
4514                         msg_print(_("あらゆることに対する耐性が薄れた気がする。", "You feel less resistant"));
4515                         notice = TRUE;
4516                 }
4517         }
4518
4519         /* Use the value */
4520         p_ptr->ult_res = v;
4521         p_ptr->redraw |= (PR_STATUS);
4522
4523         /* Nothing to notice */
4524         if (!notice) return (FALSE);
4525
4526         if (disturb_state) disturb(FALSE, FALSE);
4527         p_ptr->update |= (PU_BONUS);
4528         handle_stuff();
4529         return (TRUE);
4530 }
4531
4532 bool set_tim_res_nether(TIME_EFFECT v, bool do_dec)
4533 {
4534         bool notice = FALSE;
4535
4536         /* Hack -- Force good values */
4537         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
4538
4539         if (p_ptr->is_dead) return FALSE;
4540
4541         /* Open */
4542         if (v)
4543         {
4544                 if (p_ptr->tim_res_nether && !do_dec)
4545                 {
4546                         if (p_ptr->tim_res_nether > v) return FALSE;
4547                 }
4548                 else if (!p_ptr->tim_res_nether)
4549                 {
4550                         msg_print(_("地獄の力に対して耐性がついた気がする！", "You feel nether resistant!"));
4551                         notice = TRUE;
4552                 }
4553         }
4554
4555         /* Shut */
4556         else
4557         {
4558                 if (p_ptr->tim_res_nether)
4559                 {
4560                         msg_print(_("地獄の力に対する耐性が薄れた気がする。", "You feel less nether resistant"));
4561                         notice = TRUE;
4562                 }
4563         }
4564
4565         /* Use the value */
4566         p_ptr->tim_res_nether = v;
4567         p_ptr->redraw |= (PR_STATUS);
4568
4569         /* Nothing to notice */
4570         if (!notice) return (FALSE);
4571
4572         if (disturb_state) disturb(FALSE, FALSE);
4573         p_ptr->update |= (PU_BONUS);
4574         handle_stuff();
4575         return (TRUE);
4576 }
4577
4578 bool set_tim_res_time(TIME_EFFECT v, bool do_dec)
4579 {
4580         bool notice = FALSE;
4581
4582         /* Hack -- Force good values */
4583         v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
4584
4585         if (p_ptr->is_dead) return FALSE;
4586
4587         /* Open */
4588         if (v)
4589         {
4590                 if (p_ptr->tim_res_time && !do_dec)
4591                 {
4592                         if (p_ptr->tim_res_time > v) return FALSE;
4593                 }
4594                 else if (!p_ptr->tim_res_time)
4595                 {
4596                         msg_print(_("時間逆転の力に対して耐性がついた気がする！", "You feel time resistant!"));
4597                         notice = TRUE;
4598                 }
4599         }
4600
4601         /* Shut */
4602         else
4603         {
4604                 if (p_ptr->tim_res_time)
4605                 {
4606                         msg_print(_("時間逆転の力に対する耐性が薄れた気がする。", "You feel less time resistant"));
4607                         notice = TRUE;
4608                 }
4609         }
4610
4611         /* Use the value */
4612         p_ptr->tim_res_time = v;
4613         p_ptr->redraw |= (PR_STATUS);
4614
4615         /* Nothing to notice */
4616         if (!notice) return (FALSE);
4617
4618         if (disturb_state) disturb(FALSE, FALSE);
4619         p_ptr->update |= (PU_BONUS);
4620         handle_stuff();
4621         return (TRUE);
4622 }
4623
4624
4625 /*
4626  * Choose a warrior-mage elemental attack. -LM-
4627  */
4628 bool choose_ele_attack(void)
4629 {
4630         int num;
4631
4632         char choice;
4633
4634         if (!has_melee_weapon(INVEN_RARM) && !has_melee_weapon(INVEN_LARM))
4635         {
4636                 msg_format(_("武器を持たないと魔法剣は使えない。", "You cannot use temporary branding with no weapon."));
4637                 return FALSE;
4638         }
4639         screen_save();
4640
4641         num = (p_ptr->lev - 20) / 5;
4642         c_prt(TERM_RED,    _("        a) 焼棄", "        a) Fire Brand"), 2, 14);
4643
4644         if (num >= 2)
4645                 c_prt(TERM_L_WHITE,_("        b) 凍結", "        b) Cold Brand"), 3, 14);
4646         else
4647                 prt("", 3, 14);
4648
4649         if (num >= 3)
4650                 c_prt(TERM_GREEN,  _("        c) 毒殺", "        c) Poison Brand"), 4, 14);
4651         else
4652                 prt("", 4, 14);
4653
4654         if (num >= 4)
4655                 c_prt(TERM_L_DARK, _("        d) 溶解", "        d) Acid Brand"), 5, 14);
4656         else
4657                 prt("", 5, 14);
4658
4659         if (num >= 5)
4660                 c_prt(TERM_BLUE,   _("        e) 電撃", "        e) Elec Brand"), 6, 14);
4661         else
4662                 prt("", 6, 14);
4663
4664         prt("", 7, 14);
4665         prt("", 8, 14);
4666         prt("", 9, 14);
4667
4668         prt("", 1, 0);
4669         prt(_("        どの元素攻撃をしますか？", "        Choose a temporary elemental brand "), 1, 14);
4670
4671         choice = inkey();
4672
4673         if ((choice == 'a') || (choice == 'A'))
4674                 set_ele_attack(ATTACK_FIRE, p_ptr->lev/2 + randint1(p_ptr->lev/2));
4675         else if (((choice == 'b') || (choice == 'B')) && (num >= 2))
4676                 set_ele_attack(ATTACK_COLD, p_ptr->lev/2 + randint1(p_ptr->lev/2));
4677         else if (((choice == 'c') || (choice == 'C')) && (num >= 3))
4678                 set_ele_attack(ATTACK_POIS, p_ptr->lev/2 + randint1(p_ptr->lev/2));
4679         else if (((choice == 'd') || (choice == 'D')) && (num >= 4))
4680                 set_ele_attack(ATTACK_ACID, p_ptr->lev/2 + randint1(p_ptr->lev/2));
4681         else if (((choice == 'e') || (choice == 'E')) && (num >= 5))
4682                 set_ele_attack(ATTACK_ELEC, p_ptr->lev/2 + randint1(p_ptr->lev/2));
4683         else
4684         {
4685                 msg_print(_("魔法剣を使うのをやめた。", "You cancel the temporary branding."));
4686                 screen_load();
4687                 return FALSE;
4688         }
4689         screen_load();
4690         return TRUE;
4691 }
4692
4693
4694 /*
4695  * Choose a elemental immune. -LM-
4696  */
4697 bool choose_ele_immune(TIME_EFFECT immune_turn)
4698 {
4699         char choice;
4700         screen_save();
4701
4702         c_prt(TERM_RED,    _("        a) 火炎", "        a) Immune Fire"), 2, 14);
4703         c_prt(TERM_L_WHITE,_("        b) 冷気", "        b) Immune Cold"), 3, 14);
4704         c_prt(TERM_L_DARK, _("        c) 酸", "        c) Immune Acid"), 4, 14);
4705         c_prt(TERM_BLUE,   _("        d) 電撃", "        d) Immune Elec"), 5, 14);
4706
4707         prt("", 6, 14);
4708         prt("", 7, 14);
4709         prt("", 8, 14);
4710         prt("", 9, 14);
4711
4712         prt("", 1, 0);
4713         prt(_("        どの元素の免疫をつけますか？", "        Choose a temporary elemental immune "), 1, 14);
4714
4715         choice = inkey();
4716
4717         if ((choice == 'a') || (choice == 'A'))
4718                 set_ele_immune(DEFENSE_FIRE, immune_turn);
4719         else if ((choice == 'b') || (choice == 'B'))
4720                 set_ele_immune(DEFENSE_COLD, immune_turn);
4721         else if ((choice == 'c') || (choice == 'C'))
4722                 set_ele_immune(DEFENSE_ACID, immune_turn);
4723         else if ((choice == 'd') || (choice == 'D'))
4724                 set_ele_immune(DEFENSE_ELEC, immune_turn);
4725         else
4726         {
4727                 msg_print(_("免疫を付けるのをやめた。", "You cancel the temporary immune."));
4728                 screen_load();
4729                 return FALSE;
4730         }
4731         screen_load();
4732         return TRUE;
4733 }
4734