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