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