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