src/player-effects.c

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