src/player-effects.c

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