src/player-effects.c

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