src/player-effects.c

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