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