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