src/spells2.c

   1 /*!
   2  * @file spells2.c
   3  * @brief 魔法効果の実装/ Spell code (part 2)
   4  * @date 2014/07/15
   5  * @author
   6  * <pre>
   7  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   8  * This software may be copied and distributed for educational, research,
   9  * and not for profit purposes provided that this copyright and statement
  10  * are included in all such copies.  Other copyrights may also apply.
  11  * </pre>
  12  */
  13
  14 #include "angband.h"
  15 #include "core.h"
  16 #include "util.h"
  17
  18 #include "creature.h"
  19
  20 #include "artifact.h"
  21 #include "cmd-pet.h"
  22 #include "cmd-dump.h"
  23 #include "floor.h"
  24 #include "grid.h"
  25 #include "trap.h"
  26 #include "monsterrace-hook.h"
  27 #include "melee.h"
  28 #include "world.h"
  29 #include "spells.h"
  30 #include "spells-summon.h"
  31 #include "mutation.h"
  32 #include "quest.h"
  33 #include "avatar.h"
  34
  35 #include "spells-status.h"
  36 #include "spells-floor.h"
  37 #include "realm-hex.h"
  38 #include "autopick.h"
  39 #include "object-flavor.h"
  40 #include "object-hook.h"
  41 #include "monster-status.h"
  42 #include "player-move.h"
  43 #include "player-status.h"
  44 #include "player-effects.h"
  45 #include "player-skill.h"
  46 #include "player-class.h"
  47 #include "player-damage.h"
  48 #include "player-inventory.h"
  49
  50 #include "dungeon.h"
  51 #include "floor-events.h"
  52 #include "feature.h"
  53 #include "view-mainwindow.h"
  54 #include "objectkind.h"
  55 #include "monsterrace.h"
  56 #include "targeting.h"
  57 #include "realm-song.h"
  58 #include "english.h"
  59
  60 /*!
  61  * @brief プレイヤー周辺の地形を感知する
  62  * @param range 効果範囲
  63  * @param flag 特定地形ID
  64  * @param known 地形から危険フラグを外すならTRUE
  65  * @return 効力があった場合TRUEを返す
  66  */
  67 static bool detect_feat_flag(POSITION range, int flag, bool known)
  68 {
  69         POSITION x, y;
  70         bool detect = FALSE;
  71         grid_type *g_ptr;
  72
  73         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
  74
  75         /* Scan the current panel */
  76         for (y = 1; y < p_ptr->current_floor_ptr->height - 1; y++)
  77         {
  78                 for (x = 1; x <= p_ptr->current_floor_ptr->width - 1; x++)
  79                 {
  80                         int dist = distance(p_ptr->y, p_ptr->x, y, x);
  81                         if (dist > range) continue;
  82                         g_ptr = &p_ptr->current_floor_ptr->grid_array[y][x];
  83
  84                         /* Hack -- Safe */
  85                         if (flag == FF_TRAP)
  86                         {
  87                                 /* Mark as detected */
  88                                 if (dist <= range && known)
  89                                 {
  90                                         if (dist <= range - 1) g_ptr->info |= (CAVE_IN_DETECT);
  91
  92                                         g_ptr->info &= ~(CAVE_UNSAFE);
  93
  94                                         lite_spot(y, x);
  95                                 }
  96                         }
  97
  98                         if (cave_have_flag_grid(g_ptr, flag))
  99                         {
 100                                 disclose_grid(y, x);
 101                                 g_ptr->info |= (CAVE_MARK);
 102                                 lite_spot(y, x);
 103                                 detect = TRUE;
 104                         }
 105                 }
 106         }
 107         return detect;
 108 }
 109
 110
 111 /*!
 112  * @brief プレイヤー周辺のトラップを感知する / Detect all traps on current panel
 113  * @param range 効果範囲
 114  * @param known 感知外範囲を超える警告フラグを立てる場合TRUEを返す
 115  * @return 効力があった場合TRUEを返す
 116  */
 117 bool detect_traps(POSITION range, bool known)
 118 {
 119         bool detect = detect_feat_flag(range, FF_TRAP, known);
 120
 121         if (known) p_ptr->dtrap = TRUE;
 122
 123         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 0) detect = FALSE;
 124         if (detect)
 125         {
 126                 msg_print(_("トラップの存在を感じとった！", "You sense the presence of traps!"));
 127         }
 128         return detect;
 129 }
 130
 131
 132 /*!
 133  * @brief プレイヤー周辺のドアを感知する / Detect all doors on current panel
 134  * @param range 効果範囲
 135  * @return 効力があった場合TRUEを返す
 136  */
 137 bool detect_doors(POSITION range)
 138 {
 139         bool detect = detect_feat_flag(range, FF_DOOR, TRUE);
 140
 141         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 0) detect = FALSE;
 142         if (detect)
 143         {
 144                 msg_print(_("ドアの存在を感じとった！", "You sense the presence of doors!"));
 145         }
 146         return detect;
 147 }
 148
 149
 150 /*!
 151  * @brief プレイヤー周辺の階段を感知する / Detect all stairs on current panel
 152  * @param range 効果範囲
 153  * @return 効力があった場合TRUEを返す
 154  */
 155 bool detect_stairs(POSITION range)
 156 {
 157         bool detect = detect_feat_flag(range, FF_STAIRS, TRUE);
 158
 159         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 0) detect = FALSE;
 160         if (detect)
 161         {
 162                 msg_print(_("階段の存在を感じとった！", "You sense the presence of stairs!"));
 163         }
 164         return detect;
 165 }
 166
 167
 168 /*!
 169  * @brief プレイヤー周辺の地形財宝を感知する / Detect any treasure on the current panel
 170  * @param range 効果範囲
 171  * @return 効力があった場合TRUEを返す
 172  */
 173 bool detect_treasure(POSITION range)
 174 {
 175         bool detect = detect_feat_flag(range, FF_HAS_GOLD, TRUE);
 176
 177         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 6) detect = FALSE;
 178         if (detect)
 179         {
 180                 msg_print(_("埋蔵された財宝の存在を感じとった！", "You sense the presence of buried treasure!"));
 181         }
 182         return detect;
 183 }
 184
 185
 186 /*!
 187  * @brief プレイヤー周辺のアイテム財宝を感知する / Detect all "gold" objects on the current panel
 188  * @param range 効果範囲
 189  * @return 効力があった場合TRUEを返す
 190  */
 191 bool detect_objects_gold(POSITION range)
 192 {
 193         OBJECT_IDX i;
 194         POSITION y, x;
 195         POSITION range2 = range;
 196
 197         bool detect = FALSE;
 198
 199         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range2 /= 3;
 200
 201         /* Scan objects */
 202         for (i = 1; i < p_ptr->current_floor_ptr->o_max; i++)
 203         {
 204                 object_type *o_ptr = &p_ptr->current_floor_ptr->o_list[i];
 205
 206                 if (!OBJECT_IS_VALID(o_ptr)) continue;
 207                 if (OBJECT_IS_HELD_MONSTER(o_ptr)) continue;
 208
 209                 y = o_ptr->iy;
 210                 x = o_ptr->ix;
 211
 212                 /* Only detect nearby objects */
 213                 if (distance(p_ptr->y, p_ptr->x, y, x) > range2) continue;
 214
 215                 /* Detect "gold" objects */
 216                 if (o_ptr->tval == TV_GOLD)
 217                 {
 218                         o_ptr->marked |= OM_FOUND;
 219                         lite_spot(y, x);
 220                         detect = TRUE;
 221                 }
 222         }
 223
 224         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 6) detect = FALSE;
 225         if (detect)
 226         {
 227                 msg_print(_("財宝の存在を感じとった！", "You sense the presence of treasure!"));
 228         }
 229
 230         if (detect_monsters_string(range, "$"))
 231         {
 232                 detect = TRUE;
 233         }
 234         return (detect);
 235 }
 236
 237
 238 /*!
 239  * @brief 通常のアイテムオブジェクトを感知する / Detect all "normal" objects on the current panel
 240  * @param range 効果範囲
 241  * @return 効力があった場合TRUEを返す
 242  */
 243 bool detect_objects_normal(POSITION range)
 244 {
 245         OBJECT_IDX i;
 246         POSITION y, x;
 247         POSITION range2 = range;
 248
 249         bool detect = FALSE;
 250
 251         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range2 /= 3;
 252
 253         /* Scan objects */
 254         for (i = 1; i < p_ptr->current_floor_ptr->o_max; i++)
 255         {
 256                 object_type *o_ptr = &p_ptr->current_floor_ptr->o_list[i];
 257
 258                 if (!OBJECT_IS_VALID(o_ptr)) continue;
 259                 if (OBJECT_IS_HELD_MONSTER(o_ptr)) continue;
 260
 261                 y = o_ptr->iy;
 262                 x = o_ptr->ix;
 263
 264                 /* Only detect nearby objects */
 265                 if (distance(p_ptr->y, p_ptr->x, y, x) > range2) continue;
 266
 267                 /* Detect "real" objects */
 268                 if (o_ptr->tval != TV_GOLD)
 269                 {
 270                         o_ptr->marked |= OM_FOUND;
 271                         lite_spot(y, x);
 272                         detect = TRUE;
 273                 }
 274         }
 275
 276         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 6) detect = FALSE;
 277         if (detect)
 278         {
 279                 msg_print(_("アイテムの存在を感じとった！", "You sense the presence of objects!"));
 280         }
 281
 282         if (detect_monsters_string(range, "!=?|/`"))
 283         {
 284                 detect = TRUE;
 285         }
 286         return (detect);
 287 }
 288
 289
 290 /*!
 291  * @brief 魔法効果のあるのアイテムオブジェクトを感知する / Detect all "magic" objects on the current panel.
 292  * @param range 効果範囲
 293  * @return 効力があった場合TRUEを返す
 294  * @details
 295  * <pre>
 296  * This will light up all spaces with "magic" items, including artifacts,
 297  * ego-items, potions, scrolls, books, rods, wands, staves, amulets, rings,
 298  * and "enchanted" items of the "good" variety.
 299  *
 300  * It can probably be argued that this function is now too powerful.
 301  * </pre>
 302  */
 303 bool detect_objects_magic(POSITION range)
 304 {
 305         OBJECT_TYPE_VALUE tv;
 306         OBJECT_IDX i;
 307         POSITION y, x;
 308
 309         bool detect = FALSE;
 310
 311         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
 312
 313         /* Scan all objects */
 314         for (i = 1; i < p_ptr->current_floor_ptr->o_max; i++)
 315         {
 316                 object_type *o_ptr = &p_ptr->current_floor_ptr->o_list[i];
 317
 318                 if (!OBJECT_IS_VALID(o_ptr)) continue;
 319                 if (OBJECT_IS_HELD_MONSTER(o_ptr)) continue;
 320
 321                 y = o_ptr->iy;
 322                 x = o_ptr->ix;
 323
 324                 /* Only detect nearby objects */
 325                 if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue;
 326
 327                 /* Examine the tval */
 328                 tv = o_ptr->tval;
 329
 330                 /* Artifacts, misc magic items, or enchanted wearables */
 331                 if (object_is_artifact(o_ptr) ||
 332                         object_is_ego(o_ptr) ||
 333                     (tv == TV_WHISTLE) ||
 334                     (tv == TV_AMULET) ||
 335                         (tv == TV_RING) ||
 336                     (tv == TV_STAFF) ||
 337                         (tv == TV_WAND) ||
 338                         (tv == TV_ROD) ||
 339                     (tv == TV_SCROLL) ||
 340                         (tv == TV_POTION) ||
 341                     (tv == TV_LIFE_BOOK) ||
 342                         (tv == TV_SORCERY_BOOK) ||
 343                     (tv == TV_NATURE_BOOK) ||
 344                         (tv == TV_CHAOS_BOOK) ||
 345                     (tv == TV_DEATH_BOOK) ||
 346                     (tv == TV_TRUMP_BOOK) ||
 347                         (tv == TV_ARCANE_BOOK) ||
 348                         (tv == TV_CRAFT_BOOK) ||
 349                         (tv == TV_DAEMON_BOOK) ||
 350                         (tv == TV_CRUSADE_BOOK) ||
 351                         (tv == TV_MUSIC_BOOK) ||
 352                         (tv == TV_HISSATSU_BOOK) ||
 353                         (tv == TV_HEX_BOOK) ||
 354                     ((o_ptr->to_a > 0) || (o_ptr->to_h + o_ptr->to_d > 0)))
 355                 {
 356                         /* Memorize the item */
 357                         o_ptr->marked |= OM_FOUND;
 358                         lite_spot(y, x);
 359                         detect = TRUE;
 360                 }
 361         }
 362         if (detect)
 363         {
 364                 msg_print(_("魔法のアイテムの存在を感じとった！", "You sense the presence of magic objects!"));
 365         }
 366
 367         /* Return result */
 368         return (detect);
 369 }
 370
 371
 372 /*!
 373  * @brief 一般のモンスターを感知する / Detect all "normal" monsters on the current panel
 374  * @param range 効果範囲
 375  * @return 効力があった場合TRUEを返す
 376  */
 377 bool detect_monsters_normal(POSITION range)
 378 {
 379         MONSTER_IDX i;
 380         POSITION y, x;
 381         bool flag = FALSE;
 382
 383         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
 384
 385         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 386         {
 387                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 388                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
 389                 if (!monster_is_valid(m_ptr)) continue;
 390
 391                 y = m_ptr->fy;
 392                 x = m_ptr->fx;
 393
 394                 /* Only detect nearby monsters */
 395                 if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue;
 396
 397                 /* Detect all non-invisible monsters */
 398                 if (!(r_ptr->flags2 & RF2_INVISIBLE) || p_ptr->see_inv)
 399                 {
 400                         /* Repair visibility later */
 401                         repair_monsters = TRUE;
 402
 403                         m_ptr->mflag2 |= (MFLAG2_MARK | MFLAG2_SHOW);
 404                         update_monster(p_ptr, i, FALSE);
 405                         flag = TRUE;
 406                 }
 407         }
 408
 409         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 3) flag = FALSE;
 410         if (flag)
 411         {
 412                 msg_print(_("モンスターの存在を感じとった！", "You sense the presence of monsters!"));
 413         }
 414         return (flag);
 415 }
 416
 417
 418 /*!
 419  * @brief 不可視のモンスターを感知する / Detect all "invisible" monsters around the player
 420  * @param range 効果範囲
 421  * @return 効力があった場合TRUEを返す
 422  */
 423 bool detect_monsters_invis(POSITION range)
 424 {
 425         MONSTER_IDX i;
 426         POSITION y, x;
 427         bool flag = FALSE;
 428
 429         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
 430
 431         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 432         {
 433                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 434                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
 435
 436                 if (!monster_is_valid(m_ptr)) continue;
 437
 438                 y = m_ptr->fy;
 439                 x = m_ptr->fx;
 440
 441                 /* Only detect nearby monsters */
 442                 if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue;
 443
 444                 /* Detect invisible monsters */
 445                 if (r_ptr->flags2 & RF2_INVISIBLE)
 446                 {
 447                         /* Update monster recall window */
 448                         if (p_ptr->monster_race_idx == m_ptr->r_idx)
 449                         {
 450                                 p_ptr->window |= (PW_MONSTER);
 451                         }
 452
 453                         /* Repair visibility later */
 454                         repair_monsters = TRUE;
 455
 456                         m_ptr->mflag2 |= (MFLAG2_MARK | MFLAG2_SHOW);
 457                         update_monster(p_ptr, i, FALSE);
 458                         flag = TRUE;
 459                 }
 460         }
 461
 462         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 3) flag = FALSE;
 463         if (flag)
 464         {
 465                 msg_print(_("透明な生物の存在を感じとった！", "You sense the presence of invisible creatures!"));
 466         }
 467         return (flag);
 468 }
 469
 470 /*!
 471  * @brief 邪悪なモンスターを感知する / Detect all "evil" monsters on current panel
 472  * @param range 効果範囲
 473  * @return 効力があった場合TRUEを返す
 474  */
 475 bool detect_monsters_evil(POSITION range)
 476 {
 477         MONSTER_IDX i;
 478         POSITION y, x;
 479         bool flag = FALSE;
 480
 481         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
 482
 483         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 484         {
 485                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 486                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
 487                 if (!monster_is_valid(m_ptr)) continue;
 488
 489                 y = m_ptr->fy;
 490                 x = m_ptr->fx;
 491
 492                 /* Only detect nearby monsters */
 493                 if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue;
 494
 495                 /* Detect evil monsters */
 496                 if (r_ptr->flags3 & RF3_EVIL)
 497                 {
 498                         if (is_original_ap(m_ptr))
 499                         {
 500                                 /* Take note that they are evil */
 501                                 r_ptr->r_flags3 |= (RF3_EVIL);
 502
 503                                 /* Update monster recall window */
 504                                 if (p_ptr->monster_race_idx == m_ptr->r_idx)
 505                                 {
 506                                         p_ptr->window |= (PW_MONSTER);
 507                                 }
 508                         }
 509
 510                         /* Repair visibility later */
 511                         repair_monsters = TRUE;
 512
 513                         m_ptr->mflag2 |= (MFLAG2_MARK | MFLAG2_SHOW);
 514                         update_monster(p_ptr, i, FALSE);
 515                         flag = TRUE;
 516                 }
 517         }
 518         if (flag)
 519         {
 520                 msg_print(_("邪悪なる生物の存在を感じとった！", "You sense the presence of evil creatures!"));
 521         }
 522         return (flag);
 523 }
 524
 525 /*!
 526  * @brief 無生命のモンスターを感知する(アンデッド、悪魔系を含む) / Detect all "nonliving", "undead" or "demonic" monsters on current panel
 527  * @param range 効果範囲
 528  * @return 効力があった場合TRUEを返す
 529  */
 530 bool detect_monsters_nonliving(POSITION range)
 531 {
 532         MONSTER_IDX i;
 533         POSITION y, x;
 534         bool flag = FALSE;
 535
 536         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
 537
 538         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 539         {
 540                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 541                 if (!monster_is_valid(m_ptr)) continue;
 542
 543                 y = m_ptr->fy;
 544                 x = m_ptr->fx;
 545
 546                 /* Only detect nearby monsters */
 547                 if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue;
 548
 549                 /* Detect non-living monsters */
 550                 if (!monster_living(m_ptr->r_idx))
 551                 {
 552                         /* Update monster recall window */
 553                         if (p_ptr->monster_race_idx == m_ptr->r_idx)
 554                         {
 555                                 p_ptr->window |= (PW_MONSTER);
 556                         }
 557
 558                         /* Repair visibility later */
 559                         repair_monsters = TRUE;
 560
 561                         m_ptr->mflag2 |= (MFLAG2_MARK | MFLAG2_SHOW);
 562                         update_monster(p_ptr, i, FALSE);
 563                         flag = TRUE;
 564                 }
 565         }
 566         if (flag)
 567         {
 568                 msg_print(_("自然でないモンスターの存在を感じた！", "You sense the presence of unnatural beings!"));
 569         }
 570         return (flag);
 571 }
 572
 573 /*!
 574  * @brief 精神のあるモンスターを感知する / Detect all monsters it has mind on current panel
 575  * @param range 効果範囲
 576  * @return 効力があった場合TRUEを返す
 577  */
 578 bool detect_monsters_mind(POSITION range)
 579 {
 580         MONSTER_IDX i;
 581         POSITION y, x;
 582         bool flag = FALSE;
 583
 584         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
 585
 586         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 587         {
 588                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 589                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
 590                 if (!monster_is_valid(m_ptr)) continue;
 591
 592                 y = m_ptr->fy;
 593                 x = m_ptr->fx;
 594
 595                 /* Only detect nearby monsters */
 596                 if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue;
 597
 598                 /* Detect non-living monsters */
 599                 if (!(r_ptr->flags2 & RF2_EMPTY_MIND))
 600                 {
 601                         /* Update monster recall window */
 602                         if (p_ptr->monster_race_idx == m_ptr->r_idx)
 603                         {
 604                                 p_ptr->window |= (PW_MONSTER);
 605                         }
 606
 607                         /* Repair visibility later */
 608                         repair_monsters = TRUE;
 609
 610                         m_ptr->mflag2 |= (MFLAG2_MARK | MFLAG2_SHOW);
 611                         update_monster(p_ptr, i, FALSE);
 612                         flag = TRUE;
 613                 }
 614         }
 615         if (flag)
 616         {
 617                 msg_print(_("殺気を感じとった！", "You sense the presence of someone's mind!"));
 618         }
 619         return (flag);
 620 }
 621
 622
 623 /*!
 624  * @brief 該当シンボルのモンスターを感知する / Detect all (string) monsters on current panel
 625  * @param range 効果範囲
 626  * @param Match 対応シンボルの混じったモンスター文字列(複数指定化)
 627  * @return 効力があった場合TRUEを返す
 628  */
 629 bool detect_monsters_string(POSITION range, concptr Match)
 630 {
 631         MONSTER_IDX i;
 632         POSITION y, x;
 633         bool flag = FALSE;
 634
 635         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
 636
 637         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 638         {
 639                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 640                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
 641                 if (!monster_is_valid(m_ptr)) continue;
 642
 643                 y = m_ptr->fy;
 644                 x = m_ptr->fx;
 645
 646                 /* Only detect nearby monsters */
 647                 if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue;
 648
 649                 /* Detect monsters with the same symbol */
 650                 if (my_strchr(Match, r_ptr->d_char))
 651                 {
 652                         /* Update monster recall window */
 653                         if (p_ptr->monster_race_idx == m_ptr->r_idx)
 654                         {
 655                                 p_ptr->window |= (PW_MONSTER);
 656                         }
 657
 658                         /* Repair visibility later */
 659                         repair_monsters = TRUE;
 660
 661                         m_ptr->mflag2 |= (MFLAG2_MARK | MFLAG2_SHOW);
 662                         update_monster(p_ptr, i, FALSE);
 663                         flag = TRUE;
 664                 }
 665         }
 666
 667         if (music_singing(p_ptr, MUSIC_DETECT) && SINGING_COUNT(p_ptr) > 3) flag = FALSE;
 668         if (flag)
 669         {
 670                 msg_print(_("モンスターの存在を感じとった！", "You sense the presence of monsters!"));
 671         }
 672         return (flag);
 673 }
 674
 675 /*!
 676  * @brief flags3に対応するモンスターを感知する / A "generic" detect monsters routine, tagged to flags3
 677  * @param range 効果範囲
 678  * @param match_flag 感知フラグ
 679  * @return 効力があった場合TRUEを返す
 680  */
 681 bool detect_monsters_xxx(POSITION range, u32b match_flag)
 682 {
 683         MONSTER_IDX i;
 684         POSITION y, x;
 685         bool flag = FALSE;
 686         concptr desc_monsters = _("変なモンスター", "weird monsters");
 687
 688         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS) range /= 3;
 689
 690         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 691         {
 692                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 693                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
 694                 if (!monster_is_valid(m_ptr)) continue;
 695
 696                 y = m_ptr->fy;
 697                 x = m_ptr->fx;
 698
 699                 /* Only detect nearby monsters */
 700                 if (distance(p_ptr->y, p_ptr->x, y, x) > range) continue;
 701
 702                 /* Detect evil monsters */
 703                 if (r_ptr->flags3 & (match_flag))
 704                 {
 705                         if (is_original_ap(m_ptr))
 706                         {
 707                                 /* Take note that they are something */
 708                                 r_ptr->r_flags3 |= (match_flag);
 709
 710                                 /* Update monster recall window */
 711                                 if (p_ptr->monster_race_idx == m_ptr->r_idx)
 712                                 {
 713                                         p_ptr->window |= (PW_MONSTER);
 714                                 }
 715                         }
 716
 717                         /* Repair visibility later */
 718                         repair_monsters = TRUE;
 719
 720                         m_ptr->mflag2 |= (MFLAG2_MARK | MFLAG2_SHOW);
 721                         update_monster(p_ptr, i, FALSE);
 722                         flag = TRUE;
 723                 }
 724         }
 725         if (flag)
 726         {
 727                 switch (match_flag)
 728                 {
 729                         case RF3_DEMON:
 730                         desc_monsters = _("デーモン", "demons");
 731                                 break;
 732                         case RF3_UNDEAD:
 733                         desc_monsters = _("アンデッド", "the undead");
 734                                 break;
 735                 }
 736
 737                 msg_format(_("%sの存在を感じとった！", "You sense the presence of %s!"), desc_monsters);
 738                 msg_print(NULL);
 739         }
 740         return (flag);
 741 }
 742
 743
 744 /*!
 745  * @brief 全感知処理 / Detect everything
 746  * @param range 効果範囲
 747  * @return 効力があった場合TRUEを返す
 748  */
 749 bool detect_all(POSITION range)
 750 {
 751         bool detect = FALSE;
 752
 753         /* Detect everything */
 754         if (detect_traps(range, TRUE)) detect = TRUE;
 755         if (detect_doors(range)) detect = TRUE;
 756         if (detect_stairs(range)) detect = TRUE;
 757
 758         /* There are too many hidden treasure.  So... */
 759         /* if (detect_treasure(range)) detect = TRUE; */
 760
 761         if (detect_objects_gold(range)) detect = TRUE;
 762         if (detect_objects_normal(range)) detect = TRUE;
 763         if (detect_monsters_invis(range)) detect = TRUE;
 764         if (detect_monsters_normal(range)) detect = TRUE;
 765         return (detect);
 766 }
 767
 768
 769 /*!
 770  * @brief 視界内モンスターに魔法効果を与える / Apply a "project()" directly to all viewable monsters
 771  * @param typ 属性効果
 772  * @param dam 効果量
 773  * @return 効力があった場合TRUEを返す
 774  * @details
 775  * <pre>
 776  * Note that affected monsters are NOT auto-tracked by this usage.
 777  *
 778  * To avoid misbehavior when monster deaths have side-effects,
 779  * this is done in two passes. -- JDL
 780  * </pre>
 781  */
 782 bool project_all_los(EFFECT_ID typ, HIT_POINT dam)
 783 {
 784         MONSTER_IDX i;
 785         POSITION x, y;
 786         BIT_FLAGS flg = PROJECT_JUMP | PROJECT_KILL | PROJECT_HIDE;
 787         bool obvious = FALSE;
 788
 789         /* Mark all (nearby) monsters */
 790         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 791         {
 792                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 793                 if (!monster_is_valid(m_ptr)) continue;
 794
 795                 y = m_ptr->fy;
 796                 x = m_ptr->fx;
 797
 798                 /* Require line of sight */
 799                 if (!player_has_los_bold(p_ptr, y, x) || !projectable(p_ptr->current_floor_ptr, p_ptr->y, p_ptr->x, y, x)) continue;
 800
 801                 /* Mark the monster */
 802                 m_ptr->mflag |= (MFLAG_LOS);
 803         }
 804
 805         /* Affect all marked monsters */
 806         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 807         {
 808                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 809
 810                 /* Skip unmarked monsters */
 811                 if (!(m_ptr->mflag & (MFLAG_LOS))) continue;
 812
 813                 /* Remove mark */
 814                 m_ptr->mflag &= ~(MFLAG_LOS);
 815
 816                 y = m_ptr->fy;
 817                 x = m_ptr->fx;
 818
 819                 /* Jump directly to the target monster */
 820                 if (project(0, 0, y, x, dam, typ, flg, -1)) obvious = TRUE;
 821         }
 822         return (obvious);
 823 }
 824
 825
 826 /*!
 827  * @brief 視界内モンスターを加速する処理 / Speed monsters
 828  * @return 効力があった場合TRUEを返す
 829  */
 830 bool speed_monsters(void)
 831 {
 832         return (project_all_los(GF_OLD_SPEED, p_ptr->lev));
 833 }
 834
 835 /*!
 836  * @brief 視界内モンスターを加速する処理 / Slow monsters
 837  * @return 効力があった場合TRUEを返す
 838  */
 839 bool slow_monsters(int power)
 840 {
 841         return (project_all_los(GF_OLD_SLOW, power));
 842 }
 843
 844 /*!
 845  * @brief 視界内モンスターを眠らせる処理 / Sleep monsters
 846  * @return 効力があった場合TRUEを返す
 847  */
 848 bool sleep_monsters(int power)
 849 {
 850         return (project_all_los(GF_OLD_SLEEP, power));
 851 }
 852
 853 /*!
 854  * @brief 視界内の邪悪なモンスターをテレポート・アウェイさせる処理 / Banish evil monsters
 855  * @return 効力があった場合TRUEを返す
 856  */
 857 bool banish_evil(int dist)
 858 {
 859         return (project_all_los(GF_AWAY_EVIL, dist));
 860 }
 861
 862 /*!
 863  * @brief 視界内のアンデッド・モンスターを恐怖させる処理 / Turn undead
 864  * @return 効力があった場合TRUEを返す
 865  */
 866 bool turn_undead(void)
 867 {
 868         bool tester = (project_all_los(GF_TURN_UNDEAD, p_ptr->lev));
 869         if (tester)
 870                 chg_virtue(p_ptr, V_UNLIFE, -1);
 871         return tester;
 872 }
 873
 874 /*!
 875  * @brief 視界内のアンデッド・モンスターにダメージを与える処理 / Dispel undead monsters
 876  * @return 効力があった場合TRUEを返す
 877  */
 878 bool dispel_undead(HIT_POINT dam)
 879 {
 880         bool tester = (project_all_los(GF_DISP_UNDEAD, dam));
 881         if (tester)
 882                 chg_virtue(p_ptr, V_UNLIFE, -2);
 883         return tester;
 884 }
 885
 886 /*!
 887  * @brief 視界内の邪悪なモンスターにダメージを与える処理 / Dispel evil monsters
 888  * @return 効力があった場合TRUEを返す
 889  */
 890 bool dispel_evil(HIT_POINT dam)
 891 {
 892         return (project_all_los(GF_DISP_EVIL, dam));
 893 }
 894
 895 /*!
 896  * @brief 視界内の善良なモンスターにダメージを与える処理 / Dispel good monsters
 897  * @return 効力があった場合TRUEを返す
 898  */
 899 bool dispel_good(HIT_POINT dam)
 900 {
 901         return (project_all_los(GF_DISP_GOOD, dam));
 902 }
 903
 904 /*!
 905  * @brief 視界内のあらゆるモンスターにダメージを与える処理 / Dispel all monsters
 906  * @return 効力があった場合TRUEを返す
 907  */
 908 bool dispel_monsters(HIT_POINT dam)
 909 {
 910         return (project_all_los(GF_DISP_ALL, dam));
 911 }
 912
 913 bool cleansing_nova(player_type *creature_ptr, bool magic, bool powerful)
 914 {
 915         bool ident = FALSE;
 916         if (dispel_evil(powerful ? 225 : 150)) ident = TRUE;
 917         int k = 3 * creature_ptr->lev;
 918         if (set_protevil(p_ptr, (magic ? 0 : creature_ptr->protevil) + randint1(25) + k, FALSE)) ident = TRUE;
 919         if (set_poisoned(p_ptr, 0)) ident = TRUE;
 920         if (set_afraid(p_ptr, 0)) ident = TRUE;
 921         if (hp_player(p_ptr, 50)) ident = TRUE;
 922         if (set_stun(p_ptr, 0)) ident = TRUE;
 923         if (set_cut(p_ptr,0)) ident = TRUE;
 924         return ident;
 925 }
 926
 927 bool unleash_mana_storm(player_type *creature_ptr, bool powerful)
 928 {
 929         msg_print(_("強力な魔力が敵を引き裂いた！", "Mighty magics rend your enemies!"));
 930         project(0, (powerful ? 7 : 5), creature_ptr->y, creature_ptr->x,
 931         (randint1(200) + (powerful ? 500 : 300)) * 2, GF_MANA, PROJECT_KILL | PROJECT_ITEM | PROJECT_GRID, -1);
 932         if ((creature_ptr->pclass != CLASS_MAGE) && (creature_ptr->pclass != CLASS_HIGH_MAGE) && (creature_ptr->pclass != CLASS_SORCERER) && (creature_ptr->pclass != CLASS_MAGIC_EATER) && (creature_ptr->pclass != CLASS_BLUE_MAGE))
 933         {
 934                 (void)take_hit(p_ptr, DAMAGE_NOESCAPE, 50, _("コントロールし難い強力な魔力の解放", "unleashing magics too mighty to control"), -1);
 935         }
 936         return TRUE;
 937 }
 938
 939 /*!
 940  * @brief 視界内の生命のあるモンスターにダメージを与える処理 / Dispel 'living' monsters
 941  * @return 効力があった場合TRUEを返す
 942  */
 943 bool dispel_living(HIT_POINT dam)
 944 {
 945         return (project_all_los(GF_DISP_LIVING, dam));
 946 }
 947
 948 /*!
 949  * @brief 視界内の悪魔系モンスターにダメージを与える処理 / Dispel 'living' monsters
 950  * @return 効力があった場合TRUEを返す
 951  */
 952 bool dispel_demons(HIT_POINT dam)
 953 {
 954         return (project_all_los(GF_DISP_DEMON, dam));
 955 }
 956
 957 /*!
 958  * @brief 視界内のモンスターに「聖戦」効果を与える処理
 959  * @return 効力があった場合TRUEを返す
 960  */
 961 bool crusade(void)
 962 {
 963         return (project_all_los(GF_CRUSADE, p_ptr->lev*4));
 964 }
 965
 966 /*!
 967  * @brief 視界内モンスターを怒らせる処理 / Wake up all monsters, and speed up "los" monsters.
 968  * @param who 怒らせる原因を起こしたモンスター(0ならばプレイヤー)
 969  * @return なし
 970  */
 971 void aggravate_monsters(MONSTER_IDX who)
 972 {
 973         MONSTER_IDX i;
 974         bool sleep = FALSE;
 975         bool speed = FALSE;
 976
 977         /* Aggravate everyone nearby */
 978         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
 979         {
 980                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
 981                 if (!monster_is_valid(m_ptr)) continue;
 982
 983                 /* Skip aggravating monster (or player) */
 984                 if (i == who) continue;
 985
 986                 /* Wake up nearby sleeping monsters */
 987                 if (m_ptr->cdis < MAX_SIGHT * 2)
 988                 {
 989                         /* Wake up */
 990                         if (MON_CSLEEP(m_ptr))
 991                         {
 992                                 (void)set_monster_csleep(i, 0);
 993                                 sleep = TRUE;
 994                         }
 995                         if (!is_pet(m_ptr)) m_ptr->mflag2 |= MFLAG2_NOPET;
 996                 }
 997
 998                 /* Speed up monsters in line of sight */
 999                 if (player_has_los_bold(p_ptr, m_ptr->fy, m_ptr->fx))
1000                 {
1001                         if (!is_pet(m_ptr))
1002                         {
1003                                 (void)set_monster_fast(i, MON_FAST(m_ptr) + 100);
1004                                 speed = TRUE;
1005                         }
1006                 }
1007         }
1008
1009         if (speed) msg_print(_("付近で何かが突如興奮したような感じを受けた！", "You feel a sudden stirring nearby!"));
1010         else if (sleep) msg_print(_("何かが突如興奮したような騒々しい音が遠くに聞こえた！", "You hear a sudden stirring in the distance!"));
1011         if (p_ptr->riding) p_ptr->update |= PU_BONUS;
1012 }
1013
1014
1015 /*!
1016  * @brief モンスターへの単体抹殺処理サブルーチン / Delete a non-unique/non-quest monster
1017  * @param m_idx 抹殺するモンスターID
1018  * @param power 抹殺の威力
1019  * @param player_cast プレイヤーの魔法によるものならば TRUE
1020  * @param dam_side プレイヤーへの負担ダメージ量(1d(dam_side))
1021  * @param spell_name 抹殺効果を起こした魔法の名前
1022  * @return 効力があった場合TRUEを返す
1023  */
1024 bool genocide_aux(MONSTER_IDX m_idx, int power, bool player_cast, int dam_side, concptr spell_name)
1025 {
1026         int          msec = delay_factor * delay_factor * delay_factor;
1027         monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[m_idx];
1028         monster_race *r_ptr = &r_info[m_ptr->r_idx];
1029         bool         resist = FALSE;
1030
1031         if (is_pet(m_ptr) && !player_cast) return FALSE;
1032
1033         /* Hack -- Skip Unique Monsters or Quest Monsters */
1034         if (r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR)) resist = TRUE;
1035         else if (r_ptr->flags7 & RF7_UNIQUE2) resist = TRUE;
1036         else if (m_idx == p_ptr->riding) resist = TRUE;
1037         else if ((p_ptr->current_floor_ptr->inside_quest && !random_quest_number(p_ptr->current_floor_ptr->dun_level)) || p_ptr->inside_arena || p_ptr->phase_out) resist = TRUE;
1038         else if (player_cast && (r_ptr->level > randint0(power))) resist = TRUE;
1039         else if (player_cast && (m_ptr->mflag2 & MFLAG2_NOGENO)) resist = TRUE;
1040
1041         else
1042         {
1043                 if (record_named_pet && is_pet(m_ptr) && m_ptr->nickname)
1044                 {
1045                         GAME_TEXT m_name[MAX_NLEN];
1046
1047                         monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
1048                         exe_write_diary(p_ptr, NIKKI_NAMED_PET, RECORD_NAMED_PET_GENOCIDE, m_name);
1049                 }
1050
1051                 delete_monster_idx(m_idx);
1052         }
1053
1054         if (resist && player_cast)
1055         {
1056                 bool see_m = is_seen(m_ptr);
1057                 GAME_TEXT m_name[MAX_NLEN];
1058
1059                 monster_desc(m_name, m_ptr, 0);
1060                 if (see_m)
1061                 {
1062                         msg_format(_("%^sには効果がなかった。", "%^s is unaffected."), m_name);
1063                 }
1064                 if (MON_CSLEEP(m_ptr))
1065                 {
1066                         (void)set_monster_csleep(m_idx, 0);
1067                         if (m_ptr->ml)
1068                         {
1069                                 msg_format(_("%^sが目を覚ました。", "%^s wakes up."), m_name);
1070                         }
1071                 }
1072                 if (is_friendly(m_ptr) && !is_pet(m_ptr))
1073                 {
1074                         if (see_m)
1075                         {
1076                                 msg_format(_("%sは怒った！", "%^s gets angry!"), m_name);
1077                         }
1078                         set_hostile(m_ptr);
1079                 }
1080                 if (one_in_(13)) m_ptr->mflag2 |= MFLAG2_NOGENO;
1081         }
1082
1083         if (player_cast)
1084         {
1085                 take_hit(p_ptr, DAMAGE_GENO, randint1(dam_side), format(_("%^sの呪文を唱えた疲労", "the strain of casting %^s"), spell_name), -1);
1086         }
1087
1088         /* Visual feedback */
1089         move_cursor_relative(p_ptr->y, p_ptr->x);
1090
1091         p_ptr->redraw |= (PR_HP);
1092         p_ptr->window |= (PW_PLAYER);
1093
1094         handle_stuff();
1095         Term_fresh();
1096
1097         Term_xtra(TERM_XTRA_DELAY, msec);
1098
1099         return !resist;
1100 }
1101
1102
1103 /*!
1104  * @brief モンスターへのシンボル抹殺処理ルーチン / Delete all non-unique/non-quest monsters of a given "type" from the level
1105  * @param power 抹殺の威力
1106  * @param player_cast プレイヤーの魔法によるものならば TRUE
1107  * @return 効力があった場合TRUEを返す
1108  */
1109 bool symbol_genocide(int power, bool player_cast)
1110 {
1111         MONSTER_IDX i;
1112         char typ;
1113         bool result = FALSE;
1114
1115         /* Prevent genocide in quest levels */
1116         if ((p_ptr->current_floor_ptr->inside_quest && !random_quest_number(p_ptr->current_floor_ptr->dun_level)) || p_ptr->inside_arena || p_ptr->phase_out)
1117         {
1118                 msg_print(_("何も起きないようだ……", "It seems nothing happen here..."));
1119                 return (FALSE);
1120         }
1121
1122         /* Mega-Hack -- Get a monster symbol */
1123         while (!get_com(_("どの種類(文字)のモンスターを抹殺しますか: ", "Choose a monster race (by symbol) to genocide: "), &typ, FALSE)) ;
1124
1125         /* Delete the monsters of that "type" */
1126         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
1127         {
1128                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
1129                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
1130                 if (!monster_is_valid(m_ptr)) continue;
1131
1132                 /* Skip "wrong" monsters */
1133                 if (r_ptr->d_char != typ) continue;
1134
1135                 result |= genocide_aux(i, power, player_cast, 4, _("抹殺", "Genocide"));
1136         }
1137
1138         if (result)
1139         {
1140                 chg_virtue(p_ptr, V_VITALITY, -2);
1141                 chg_virtue(p_ptr, V_CHANCE, -1);
1142         }
1143
1144         return result;
1145 }
1146
1147
1148 /*!
1149  * @brief モンスターへの周辺抹殺処理ルーチン / Delete all nearby (non-unique) monsters
1150  * @param power 抹殺の威力
1151  * @param player_cast プレイヤーの魔法によるものならば TRUE
1152  * @return 効力があった場合TRUEを返す
1153  */
1154 bool mass_genocide(int power, bool player_cast)
1155 {
1156         MONSTER_IDX i;
1157         bool result = FALSE;
1158
1159         /* Prevent mass genocide in quest levels */
1160         if ((p_ptr->current_floor_ptr->inside_quest && !random_quest_number(p_ptr->current_floor_ptr->dun_level)) || p_ptr->inside_arena || p_ptr->phase_out)
1161         {
1162                 return (FALSE);
1163         }
1164
1165         /* Delete the (nearby) monsters */
1166         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
1167         {
1168                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
1169                 if (!monster_is_valid(m_ptr)) continue;
1170
1171                 /* Skip distant monsters */
1172                 if (m_ptr->cdis > MAX_SIGHT) continue;
1173
1174                 /* Note effect */
1175                 result |= genocide_aux(i, power, player_cast, 3, _("周辺抹殺", "Mass Genocide"));
1176         }
1177
1178         if (result)
1179         {
1180                 chg_virtue(p_ptr, V_VITALITY, -2);
1181                 chg_virtue(p_ptr, V_CHANCE, -1);
1182         }
1183
1184         return result;
1185 }
1186
1187
1188 /*!
1189  * @brief アンデッド・モンスターへの周辺抹殺処理ルーチン / Delete all nearby (non-unique) undead
1190  * @param power 抹殺の威力
1191  * @param player_cast プレイヤーの魔法によるものならば TRUE
1192  * @return 効力があった場合TRUEを返す
1193  */
1194 bool mass_genocide_undead(int power, bool player_cast)
1195 {
1196         MONSTER_IDX i;
1197         bool result = FALSE;
1198
1199         /* Prevent mass genocide in quest levels */
1200         if ((p_ptr->current_floor_ptr->inside_quest && !random_quest_number(p_ptr->current_floor_ptr->dun_level)) || p_ptr->inside_arena || p_ptr->phase_out)
1201         {
1202                 return (FALSE);
1203         }
1204
1205         /* Delete the (nearby) monsters */
1206         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
1207         {
1208                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
1209                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
1210                 if (!monster_is_valid(m_ptr)) continue;
1211
1212                 if (!(r_ptr->flags3 & RF3_UNDEAD)) continue;
1213
1214                 /* Skip distant monsters */
1215                 if (m_ptr->cdis > MAX_SIGHT) continue;
1216
1217                 /* Note effect */
1218                 result |= genocide_aux(i, power, player_cast, 3, _("アンデッド消滅", "Annihilate Undead"));
1219         }
1220
1221         if (result)
1222         {
1223                 chg_virtue(p_ptr, V_UNLIFE, -2);
1224                 chg_virtue(p_ptr, V_CHANCE, -1);
1225         }
1226
1227         return result;
1228 }
1229
1230
1231 /*!
1232  * @brief 周辺モンスターを調査する / Probe nearby monsters
1233  * @return 効力があった場合TRUEを返す
1234  */
1235 bool probing(void)
1236 {
1237         int i;
1238         int speed; /* TODO */
1239         bool_hack cu, cv;
1240         bool probe = FALSE;
1241         char buf[256];
1242         concptr align;
1243
1244         cu = Term->scr->cu;
1245         cv = Term->scr->cv;
1246         Term->scr->cu = 0;
1247         Term->scr->cv = 1;
1248
1249         /* Probe all (nearby) monsters */
1250         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
1251         {
1252                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
1253                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
1254                 if (!monster_is_valid(m_ptr)) continue;
1255
1256                 /* Require line of sight */
1257                 if (!player_has_los_bold(p_ptr, m_ptr->fy, m_ptr->fx)) continue;
1258
1259                 /* Probe visible monsters */
1260                 if (m_ptr->ml)
1261                 {
1262                         GAME_TEXT m_name[MAX_NLEN];
1263
1264                         /* Start the message */
1265                         if (!probe)
1266                         {
1267                                 msg_print(_("調査中...", "Probing..."));
1268                         }
1269
1270                         msg_print(NULL);
1271
1272                         if (!is_original_ap(m_ptr))
1273                         {
1274                                 if (m_ptr->mflag2 & MFLAG2_KAGE)
1275                                         m_ptr->mflag2 &= ~(MFLAG2_KAGE);
1276
1277                                 m_ptr->ap_r_idx = m_ptr->r_idx;
1278                                 lite_spot(m_ptr->fy, m_ptr->fx);
1279                         }
1280                         /* Get "the monster" or "something" */
1281                         monster_desc(m_name, m_ptr, MD_IGNORE_HALLU | MD_INDEF_HIDDEN);
1282
1283                         speed = m_ptr->mspeed - 110;
1284                         if (MON_FAST(m_ptr)) speed += 10;
1285                         if (MON_SLOW(m_ptr)) speed -= 10;
1286                         if (ironman_nightmare) speed += 5;
1287
1288                         /* Get the monster's alignment */
1289                         if ((r_ptr->flags3 & (RF3_EVIL | RF3_GOOD)) == (RF3_EVIL | RF3_GOOD)) align = _("善悪", "good&evil");
1290                         else if (r_ptr->flags3 & RF3_EVIL) align = _("邪悪", "evil");
1291                         else if (r_ptr->flags3 & RF3_GOOD) align = _("善良", "good");
1292                         else if ((m_ptr->sub_align & (SUB_ALIGN_EVIL | SUB_ALIGN_GOOD)) == (SUB_ALIGN_EVIL | SUB_ALIGN_GOOD)) align = _("中立(善悪)", "neutral(good&evil)");
1293                         else if (m_ptr->sub_align & SUB_ALIGN_EVIL) align = _("中立(邪悪)", "neutral(evil)");
1294                         else if (m_ptr->sub_align & SUB_ALIGN_GOOD) align = _("中立(善良)", "neutral(good)");
1295                         else align = _("中立", "neutral");
1296
1297                         sprintf(buf,_("%s ... 属性:%s HP:%d/%d AC:%d 速度:%s%d 経験:", "%s ... align:%s HP:%d/%d AC:%d speed:%s%d exp:"),
1298                                 m_name, align, (int)m_ptr->hp, (int)m_ptr->maxhp, r_ptr->ac, (speed > 0) ? "+" : "", speed);
1299
1300                         if (r_ptr->next_r_idx)
1301                         {
1302                                 strcat(buf, format("%d/%d ", m_ptr->exp, r_ptr->next_exp));
1303                         }
1304                         else
1305                         {
1306                                 strcat(buf, "xxx ");
1307                         }
1308
1309                         if (MON_CSLEEP(m_ptr)) strcat(buf,_("睡眠 ", "sleeping "));
1310                         if (MON_STUNNED(m_ptr)) strcat(buf, _("朦朧 ", "stunned "));
1311                         if (MON_MONFEAR(m_ptr)) strcat(buf, _("恐怖 ", "scared "));
1312                         if (MON_CONFUSED(m_ptr)) strcat(buf, _("混乱 ", "confused "));
1313                         if (MON_INVULNER(m_ptr)) strcat(buf, _("無敵 ", "invulnerable "));
1314                         buf[strlen(buf)-1] = '\0';
1315                         prt(buf, 0, 0);
1316
1317                         /* HACK : Add the line to message buffer */
1318                         message_add(buf);
1319
1320                         p_ptr->window |= (PW_MESSAGE);
1321                         handle_stuff();
1322
1323                         if (m_ptr->ml) move_cursor_relative(m_ptr->fy, m_ptr->fx);
1324                         inkey();
1325
1326                         Term_erase(0, 0, 255);
1327
1328                         /* Learn everything about this monster */
1329                         if (lore_do_probe(m_ptr->r_idx))
1330                         {
1331                                 /* Get base name of monster */
1332                                 strcpy(buf, (r_name + r_ptr->name));
1333
1334 #ifdef JP
1335                                 /* Note that we learnt some new flags  -Mogami- */
1336                                 msg_format("%sについてさらに詳しくなった気がする。", buf);
1337 #else
1338                                 /* Pluralize it */
1339                                 plural_aux(buf);
1340
1341                                 /* Note that we learnt some new flags  -Mogami- */
1342                                 msg_format("You now know more about %s.", buf);
1343 #endif
1344                                 /* Clear -more- prompt */
1345                                 msg_print(NULL);
1346                         }
1347
1348                         /* Probe worked */
1349                         probe = TRUE;
1350                 }
1351         }
1352
1353         Term->scr->cu = cu;
1354         Term->scr->cv = cv;
1355         Term_fresh();
1356
1357         if (probe)
1358         {
1359                 chg_virtue(p_ptr, V_KNOWLEDGE, 1);
1360                 msg_print(_("これで全部です。", "That's all."));
1361         }
1362         return (probe);
1363 }
1364
1365 /*!
1366  * @brief ペット爆破処理 /
1367  * @return なし
1368  */
1369 void discharge_minion(void)
1370 {
1371         MONSTER_IDX i;
1372         bool okay = TRUE;
1373
1374         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
1375         {
1376                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
1377                 if (!m_ptr->r_idx || !is_pet(m_ptr)) continue;
1378                 if (m_ptr->nickname) okay = FALSE;
1379         }
1380         if (!okay || p_ptr->riding)
1381         {
1382                 if (!get_check(_("本当に全ペットを爆破しますか？", "You will blast all pets. Are you sure? ")))
1383                         return;
1384         }
1385         for (i = 1; i < p_ptr->current_floor_ptr->m_max; i++)
1386         {
1387                 HIT_POINT dam;
1388                 monster_type *m_ptr = &p_ptr->current_floor_ptr->m_list[i];
1389                 monster_race *r_ptr;
1390
1391                 if (!m_ptr->r_idx || !is_pet(m_ptr)) continue;
1392                 r_ptr = &r_info[m_ptr->r_idx];
1393
1394                 /* Uniques resist discharging */
1395                 if (r_ptr->flags1 & RF1_UNIQUE)
1396                 {
1397                         GAME_TEXT m_name[MAX_NLEN];
1398                         monster_desc(m_name, m_ptr, 0x00);
1399                         msg_format(_("%sは爆破されるのを嫌がり、勝手に自分の世界へと帰った。", "%^s resists to be blasted, and run away."), m_name);
1400                         delete_monster_idx(i);
1401                         continue;
1402                 }
1403                 dam = m_ptr->maxhp / 2;
1404                 if (dam > 100) dam = (dam - 100) / 2 + 100;
1405                 if (dam > 400) dam = (dam - 400) / 2 + 400;
1406                 if (dam > 800) dam = 800;
1407                 project(i, 2 + (r_ptr->level / 20), m_ptr->fy, m_ptr->fx, dam, GF_PLASMA,
1408                         PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL, -1);
1409
1410                 if (record_named_pet && m_ptr->nickname)
1411                 {
1412                         GAME_TEXT m_name[MAX_NLEN];
1413
1414                         monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
1415                         exe_write_diary(p_ptr, NIKKI_NAMED_PET, RECORD_NAMED_PET_BLAST, m_name);
1416                 }
1417
1418                 delete_monster_idx(i);
1419         }
1420 }
1421
1422
1423 /*!
1424  * @brief 部屋全体を照らすサブルーチン
1425  * @return なし
1426  * @details
1427  * <pre>
1428  * This routine clears the entire "temp" set.
1429  * This routine will Perma-Lite all "temp" grids.
1430  * This routine is used (only) by "lite_room()"
1431  * Dark grids are illuminated.
1432  * Also, process all affected monsters.
1433  *
1434  * SMART monsters always wake up when illuminated
1435  * NORMAL monsters wake up 1/4 the time when illuminated
1436  * STUPID monsters wake up 1/10 the time when illuminated
1437  * </pre>
1438  */
1439 static void cave_temp_room_lite(void)
1440 {
1441         int i;
1442
1443         /* Clear them all */
1444         for (i = 0; i < tmp_pos.n; i++)
1445         {
1446                 POSITION y = tmp_pos.y[i];
1447                 POSITION x = tmp_pos.x[i];
1448
1449                 grid_type *g_ptr = &p_ptr->current_floor_ptr->grid_array[y][x];
1450
1451                 /* No longer in the array */
1452                 g_ptr->info &= ~(CAVE_TEMP);
1453
1454                 /* Update only non-CAVE_GLOW grids */
1455                 /* if (g_ptr->info & (CAVE_GLOW)) continue; */
1456
1457                 /* Perma-Lite */
1458                 g_ptr->info |= (CAVE_GLOW);
1459
1460                 /* Process affected monsters */
1461                 if (g_ptr->m_idx)
1462                 {
1463                         PERCENTAGE chance = 25;
1464                         monster_type    *m_ptr = &p_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
1465                         monster_race    *r_ptr = &r_info[m_ptr->r_idx];
1466                         update_monster(p_ptr, g_ptr->m_idx, FALSE);
1467
1468                         /* Stupid monsters rarely wake up */
1469                         if (r_ptr->flags2 & (RF2_STUPID)) chance = 10;
1470
1471                         /* Smart monsters always wake up */
1472                         if (r_ptr->flags2 & (RF2_SMART)) chance = 100;
1473
1474                         /* Sometimes monsters wake up */
1475                         if (MON_CSLEEP(m_ptr) && (randint0(100) < chance))
1476                         {
1477                                 /* Wake up! */
1478                                 (void)set_monster_csleep(g_ptr->m_idx, 0);
1479
1480                                 /* Notice the "waking up" */
1481                                 if (m_ptr->ml)
1482                                 {
1483                                         GAME_TEXT m_name[MAX_NLEN];
1484                                         monster_desc(m_name, m_ptr, 0);
1485                                         msg_format(_("%^sが目を覚ました。", "%^s wakes up."), m_name);
1486                                 }
1487                         }
1488                 }
1489
1490                 note_spot(y, x);
1491                 lite_spot(y, x);
1492                 update_local_illumination(p_ptr, y, x);
1493         }
1494
1495         /* None left */
1496         tmp_pos.n = 0;
1497 }
1498
1499
1500
1501 /*!
1502  * @brief 部屋全体を暗くするサブルーチン
1503  * @return なし
1504  * @details
1505  * <pre>
1506  * This routine clears the entire "temp" set.
1507  * This routine will "darken" all "temp" grids.
1508  * In addition, some of these grids will be "unmarked".
1509  * This routine is used (only) by "unlite_room()"
1510  * Also, process all affected monsters
1511  * </pre>
1512  */
1513 static void cave_temp_room_unlite(void)
1514 {
1515         int i;
1516
1517         /* Clear them all */
1518         for (i = 0; i < tmp_pos.n; i++)
1519         {
1520                 POSITION y = tmp_pos.y[i];
1521                 POSITION x = tmp_pos.x[i];
1522                 int j;
1523
1524                 grid_type *g_ptr = &p_ptr->current_floor_ptr->grid_array[y][x];
1525                 bool do_dark = !is_mirror_grid(g_ptr);
1526
1527                 /* No longer in the array */
1528                 g_ptr->info &= ~(CAVE_TEMP);
1529
1530                 /* Darken the grid */
1531                 if (do_dark)
1532                 {
1533                         if (p_ptr->current_floor_ptr->dun_level || !is_daytime())
1534                         {
1535                                 for (j = 0; j < 9; j++)
1536                                 {
1537                                         POSITION by = y + ddy_ddd[j];
1538                                         POSITION bx = x + ddx_ddd[j];
1539
1540                                         if (in_bounds2(p_ptr->current_floor_ptr, by, bx))
1541                                         {
1542                                                 grid_type *cc_ptr = &p_ptr->current_floor_ptr->grid_array[by][bx];
1543
1544                                                 if (have_flag(f_info[get_feat_mimic(cc_ptr)].flags, FF_GLOW))
1545                                                 {
1546                                                         do_dark = FALSE;
1547                                                         break;
1548                                                 }
1549                                         }
1550                                 }
1551
1552                                 if (!do_dark) continue;
1553                         }
1554
1555                         g_ptr->info &= ~(CAVE_GLOW);
1556
1557                         /* Hack -- Forget "boring" grids */
1558                         if (!have_flag(f_info[get_feat_mimic(g_ptr)].flags, FF_REMEMBER))
1559                         {
1560                                 /* Forget the grid */
1561                                 if (!view_torch_grids) g_ptr->info &= ~(CAVE_MARK);
1562                                 note_spot(y, x);
1563                         }
1564
1565                         /* Process affected monsters */
1566                         if (g_ptr->m_idx)
1567                         {
1568                                 update_monster(p_ptr, g_ptr->m_idx, FALSE);
1569                         }
1570
1571                         lite_spot(y, x);
1572                         update_local_illumination(p_ptr, y, x);
1573                 }
1574         }
1575
1576         /* None left */
1577         tmp_pos.n = 0;
1578 }
1579
1580
1581 /*!
1582  * @brief 周辺に関数ポインタの条件に該当する地形がいくつあるかを計算する / Determine how much contiguous open space this grid is next to
1583  * @param cy Y座標
1584  * @param cx X座標
1585  * @param pass_bold 地形条件を返す関数ポインタ
1586  * @return 該当地形の数
1587  */
1588 static int next_to_open(POSITION cy, POSITION cx, bool (*pass_bold)(POSITION, POSITION))
1589 {
1590         int i;
1591         POSITION y, x;
1592         int len = 0;
1593         int blen = 0;
1594
1595         for (i = 0; i < 16; i++)
1596         {
1597                 y = cy + ddy_cdd[i % 8];
1598                 x = cx + ddx_cdd[i % 8];
1599
1600                 /* Found a wall, break the length */
1601                 if (!pass_bold(y, x))
1602                 {
1603                         /* Track best length */
1604                         if (len > blen)
1605                         {
1606                                 blen = len;
1607                         }
1608
1609                         len = 0;
1610                 }
1611                 else
1612                 {
1613                         len++;
1614                 }
1615         }
1616
1617         return (MAX(len, blen));
1618 }
1619
1620 /*!
1621  * @brief 周辺に関数ポインタの条件に該当する地形がいくつあるかを計算する / Determine how much contiguous open space this grid is next to
1622  * @param cy Y座標
1623  * @param cx X座標
1624  * @param pass_bold 地形条件を返す関数ポインタ
1625  * @return 該当地形の数
1626  */
1627 static int next_to_walls_adj(POSITION cy, POSITION cx, bool (*pass_bold)(POSITION, POSITION))
1628 {
1629         DIRECTION i;
1630         POSITION y, x;
1631         int c = 0;
1632
1633         for (i = 0; i < 8; i++)
1634         {
1635                 y = cy + ddy_ddd[i];
1636                 x = cx + ddx_ddd[i];
1637
1638                 if (!pass_bold(y, x)) c++;
1639         }
1640
1641         return c;
1642 }
1643
1644
1645 /*!
1646  * @brief 部屋内にある一点の周囲に該当する地形数かいくつあるかをグローバル変数tmp_pos.nに返す / Aux function -- see below
1647  * @param y 部屋内のy座標1点
1648  * @param x 部屋内のx座標1点
1649  * @param only_room 部屋内地形のみをチェック対象にするならば TRUE
1650  * @param pass_bold 地形条件を返す関数ポインタ
1651  * @return 該当地形の数
1652  */
1653 static void cave_temp_room_aux(POSITION y, POSITION x, bool only_room, bool (*pass_bold)(POSITION, POSITION))
1654 {
1655         grid_type *g_ptr;
1656         g_ptr = &p_ptr->current_floor_ptr->grid_array[y][x];
1657
1658         /* Avoid infinite recursion */
1659         if (g_ptr->info & (CAVE_TEMP)) return;
1660
1661         /* Do not "leave" the current room */
1662         if (!(g_ptr->info & (CAVE_ROOM)))
1663         {
1664                 if (only_room) return;
1665
1666                 /* Verify */
1667                 if (!in_bounds2(p_ptr->current_floor_ptr, y, x)) return;
1668
1669                 /* Do not exceed the maximum spell range */
1670                 if (distance(p_ptr->y, p_ptr->x, y, x) > MAX_RANGE) return;
1671
1672                 /* Verify this grid */
1673                 /*
1674                  * The reason why it is ==6 instead of >5 is that 8 is impossible
1675                  * due to the check for cave_bold above.
1676                  * 7 lights dead-end corridors (you need to do this for the
1677                  * checkboard interesting rooms, so that the boundary is lit
1678                  * properly.
1679                  * This leaves only a check for 6 bounding walls!
1680                  */
1681                 if (in_bounds(p_ptr->current_floor_ptr, y, x) && pass_bold(y, x) &&
1682                     (next_to_walls_adj(y, x, pass_bold) == 6) && (next_to_open(y, x, pass_bold) <= 1)) return;
1683         }
1684
1685         /* Paranoia -- verify space */
1686         if (tmp_pos.n == TEMP_MAX) return;
1687
1688         /* Mark the grid as "seen" */
1689         g_ptr->info |= (CAVE_TEMP);
1690
1691         /* Add it to the "seen" set */
1692         tmp_pos.y[tmp_pos.n] = y;
1693         tmp_pos.x[tmp_pos.n] = x;
1694         tmp_pos.n++;
1695 }
1696
1697 /*!
1698  * @brief 指定のマスが光を通すか(LOSフラグを持つか)を返す。 / Aux function -- see below
1699  * @param y 指定Y座標
1700  * @param x 指定X座標
1701  * @return 光を通すならばtrueを返す。
1702  */
1703 static bool cave_pass_lite_bold(POSITION y, POSITION x)
1704 {
1705         return cave_los_bold(p_ptr->current_floor_ptr, y, x);
1706 }
1707
1708 /*!
1709  * @brief 部屋内にある一点の周囲がいくつ光を通すかをグローバル変数tmp_pos.nに返す / Aux function -- see below
1710  * @param y 指定Y座標
1711  * @param x 指定X座標
1712  * @return なし
1713  */
1714 static void cave_temp_lite_room_aux(POSITION y, POSITION x)
1715 {
1716         cave_temp_room_aux(y, x, FALSE, cave_pass_lite_bold);
1717 }
1718
1719 /*!
1720  * @brief 指定のマスが光を通さず射線のみを通すかを返す。 / Aux function -- see below
1721  * @param y 指定Y座標
1722  * @param x 指定X座標
1723  * @return 射線を通すならばtrueを返す。
1724  */
1725 static bool cave_pass_dark_bold(POSITION y, POSITION x)
1726 {
1727         return cave_have_flag_bold(y, x, FF_PROJECT);
1728 }
1729
1730
1731 /*!
1732  * @brief 部屋内にある一点の周囲がいくつ射線を通すかをグローバル変数tmp_pos.nに返す / Aux function -- see below
1733  * @param y 指定Y座標
1734  * @param x 指定X座標
1735  * @return なし
1736  */
1737 static void cave_temp_unlite_room_aux(POSITION y, POSITION x)
1738 {
1739         cave_temp_room_aux(y, x, TRUE, cave_pass_dark_bold);
1740 }
1741
1742
1743 /*!
1744  * @brief 指定された部屋内を照らす / Illuminate any room containing the given location.
1745  * @param y1 指定Y座標
1746  * @param x1 指定X座標
1747  * @return なし
1748  */
1749 void lite_room(POSITION y1, POSITION x1)
1750 {
1751         int i;
1752         POSITION x, y;
1753
1754         /* Add the initial grid */
1755         cave_temp_lite_room_aux(y1, x1);
1756
1757         /* While grids are in the queue, add their neighbors */
1758         for (i = 0; i < tmp_pos.n; i++)
1759         {
1760                 x = tmp_pos.x[i], y = tmp_pos.y[i];
1761
1762                 /* Walls get lit, but stop light */
1763                 if (!cave_pass_lite_bold(y, x)) continue;
1764
1765                 /* Spread adjacent */
1766                 cave_temp_lite_room_aux(y + 1, x);
1767                 cave_temp_lite_room_aux(y - 1, x);
1768                 cave_temp_lite_room_aux(y, x + 1);
1769                 cave_temp_lite_room_aux(y, x - 1);
1770
1771                 /* Spread diagonal */
1772                 cave_temp_lite_room_aux(y + 1, x + 1);
1773                 cave_temp_lite_room_aux(y - 1, x - 1);
1774                 cave_temp_lite_room_aux(y - 1, x + 1);
1775                 cave_temp_lite_room_aux(y + 1, x - 1);
1776         }
1777
1778         /* Now, lite them all up at once */
1779         cave_temp_room_lite();
1780
1781         if (p_ptr->special_defense & NINJA_S_STEALTH)
1782         {
1783                 if (p_ptr->current_floor_ptr->grid_array[p_ptr->y][p_ptr->x].info & CAVE_GLOW) set_superstealth(p_ptr, FALSE);
1784         }
1785 }
1786
1787
1788 /*!
1789  * @brief 指定された部屋内を暗くする / Darken all rooms containing the given location
1790  * @param y1 指定Y座標
1791  * @param x1 指定X座標
1792  * @return なし
1793  */
1794 void unlite_room(POSITION y1, POSITION x1)
1795 {
1796         int i;
1797         POSITION x, y;
1798
1799         /* Add the initial grid */
1800         cave_temp_unlite_room_aux(y1, x1);
1801
1802         /* Spread, breadth first */
1803         for (i = 0; i < tmp_pos.n; i++)
1804         {
1805                 x = tmp_pos.x[i], y = tmp_pos.y[i];
1806
1807                 /* Walls get dark, but stop darkness */
1808                 if (!cave_pass_dark_bold(y, x)) continue;
1809
1810                 /* Spread adjacent */
1811                 cave_temp_unlite_room_aux(y + 1, x);
1812                 cave_temp_unlite_room_aux(y - 1, x);
1813                 cave_temp_unlite_room_aux(y, x + 1);
1814                 cave_temp_unlite_room_aux(y, x - 1);
1815
1816                 /* Spread diagonal */
1817                 cave_temp_unlite_room_aux(y + 1, x + 1);
1818                 cave_temp_unlite_room_aux(y - 1, x - 1);
1819                 cave_temp_unlite_room_aux(y - 1, x + 1);
1820                 cave_temp_unlite_room_aux(y + 1, x - 1);
1821         }
1822
1823         /* Now, darken them all at once */
1824         cave_temp_room_unlite();
1825 }
1826
1827 bool starlight(bool magic)
1828 {
1829         HIT_POINT num = damroll(5, 3);
1830         POSITION y = 0, x = 0;
1831         int k;
1832         int attempts;
1833
1834         if (!p_ptr->blind && !magic)
1835         {
1836                 msg_print(_("杖の先が明るく輝いた...", "The end of the staff glows brightly..."));
1837         }
1838         for (k = 0; k < num; k++)
1839         {
1840                 attempts = 1000;
1841
1842                 while (attempts--)
1843                 {
1844                         scatter(&y, &x, p_ptr->y, p_ptr->x, 4, PROJECT_LOS);
1845                         if (!cave_have_flag_bold(y, x, FF_PROJECT)) continue;
1846                         if (!player_bold(p_ptr, y, x)) break;
1847                 }
1848
1849                 project(0, 0, y, x, damroll(6 + p_ptr->lev / 8, 10), GF_LITE_WEAK,
1850                         (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_KILL | PROJECT_LOS), -1);
1851         }
1852         return TRUE;
1853 }
1854
1855
1856
1857 /*!
1858  * @brief プレイヤー位置を中心にLITE_WEAK属性を通じた照明処理を行う / Hack -- call light around the player Affect all monsters in the projection radius
1859  * @param dam 威力
1860  * @param rad 効果半径
1861  * @return 作用が実際にあった場合TRUEを返す
1862  */
1863 bool lite_area(HIT_POINT dam, POSITION rad)
1864 {
1865         BIT_FLAGS flg = PROJECT_GRID | PROJECT_KILL;
1866
1867         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS)
1868         {
1869                 msg_print(_("ダンジョンが光を吸収した。", "The darkness of this dungeon absorb your light."));
1870                 return FALSE;
1871         }
1872
1873         if (!p_ptr->blind)
1874         {
1875                 msg_print(_("白い光が辺りを覆った。", "You are surrounded by a white light."));
1876         }
1877
1878         /* Hook into the "project()" function */
1879         (void)project(0, rad, p_ptr->y, p_ptr->x, dam, GF_LITE_WEAK, flg, -1);
1880
1881         lite_room(p_ptr->y, p_ptr->x);
1882
1883         /* Assume seen */
1884         return (TRUE);
1885 }
1886
1887
1888 /*!
1889  * @brief プレイヤー位置を中心にLITE_DARK属性を通じた消灯処理を行う / Hack -- call light around the player Affect all monsters in the projection radius
1890  * @param dam 威力
1891  * @param rad 効果半径
1892  * @return 作用が実際にあった場合TRUEを返す
1893  */
1894 bool unlite_area(HIT_POINT dam, POSITION rad)
1895 {
1896         BIT_FLAGS flg = PROJECT_GRID | PROJECT_KILL;
1897
1898         if (!p_ptr->blind)
1899         {
1900                 msg_print(_("暗闇が辺りを覆った。", "Darkness surrounds you."));
1901         }
1902
1903         /* Hook into the "project()" function */
1904         (void)project(0, rad, p_ptr->y, p_ptr->x, dam, GF_DARK_WEAK, flg, -1);
1905
1906         unlite_room(p_ptr->y, p_ptr->x);
1907
1908         /* Assume seen */
1909         return (TRUE);
1910 }
1911
1912
1913
1914 /*!
1915  * @brief ボール系スペルの発動 / Cast a ball spell
1916  * @param typ 効果属性
1917  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
1918  * @param dam 威力
1919  * @param rad 半径
1920  * @return 作用が実際にあった場合TRUEを返す
1921  * @details
1922  * <pre>
1923  * Stop if we hit a monster, act as a "ball"
1924  * Allow "target" mode to pass over monsters
1925  * Affect grids, objects, and monsters
1926  * </pre>
1927  */
1928 bool fire_ball(EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
1929 {
1930         POSITION tx, ty;
1931
1932         BIT_FLAGS flg = PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
1933
1934         if (typ == GF_CHARM_LIVING) flg|= PROJECT_HIDE;
1935         /* Use the given direction */
1936         tx = p_ptr->x + 99 * ddx[dir];
1937         ty = p_ptr->y + 99 * ddy[dir];
1938
1939         /* Hack -- Use an actual "target" */
1940         if ((dir == 5) && target_okay())
1941         {
1942                 flg &= ~(PROJECT_STOP);
1943                 tx = target_col;
1944                 ty = target_row;
1945         }
1946
1947         /* Analyze the "dir" and the "target".  Hurt items on floor. */
1948         return (project(0, rad, ty, tx, dam, typ, flg, -1));
1949 }
1950
1951 /*!
1952 * @brief ブレス系スペルの発動 / Cast a breath spell
1953 * @param typ 効果属性
1954 * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
1955 * @param dam 威力
1956 * @param rad 半径
1957 * @return 作用が実際にあった場合TRUEを返す
1958 * @details
1959 * <pre>
1960 * Stop if we hit a monster, act as a "ball"
1961 * Allow "target" mode to pass over monsters
1962 * Affect grids, objects, and monsters
1963 * </pre>
1964 */
1965 bool fire_breath(EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
1966 {
1967         return fire_ball(typ, dir, dam, -rad);
1968 }
1969
1970
1971 /*!
1972  * @brief ロケット系スペルの発動(詳細な差は確認中) / Cast a ball spell
1973  * @param typ 効果属性
1974  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
1975  * @param dam 威力
1976  * @param rad 半径
1977  * @return 作用が実際にあった場合TRUEを返す
1978  * @details
1979  * <pre>
1980  * Stop if we hit a monster, act as a "ball"
1981  * Allow "target" mode to pass over monsters
1982  * Affect grids, objects, and monsters
1983  * </pre>
1984  */
1985 bool fire_rocket(EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
1986 {
1987         POSITION tx, ty;
1988         BIT_FLAGS flg = PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
1989
1990         /* Use the given direction */
1991         tx = p_ptr->x + 99 * ddx[dir];
1992         ty = p_ptr->y + 99 * ddy[dir];
1993
1994         /* Hack -- Use an actual "target" */
1995         if ((dir == 5) && target_okay())
1996         {
1997                 tx = target_col;
1998                 ty = target_row;
1999         }
2000
2001         /* Analyze the "dir" and the "target".  Hurt items on floor. */
2002         return (project(0, rad, ty, tx, dam, typ, flg, -1));
2003 }
2004
2005
2006 /*!
2007  * @brief ボール(ハイド)系スペルの発動 / Cast a ball spell
2008  * @param typ 効果属性
2009  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2010  * @param dam 威力
2011  * @param rad 半径
2012  * @return 作用が実際にあった場合TRUEを返す
2013  * @details
2014  * <pre>
2015  * Stop if we hit a monster, act as a "ball"
2016  * Allow "target" mode to pass over monsters
2017  * Affect grids, objects, and monsters
2018  * </pre>
2019  */
2020 bool fire_ball_hide(EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, POSITION rad)
2021 {
2022         POSITION tx, ty;
2023         BIT_FLAGS flg = PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_HIDE;
2024
2025         /* Use the given direction */
2026         tx = p_ptr->x + 99 * ddx[dir];
2027         ty = p_ptr->y + 99 * ddy[dir];
2028
2029         /* Hack -- Use an actual "target" */
2030         if ((dir == 5) && target_okay())
2031         {
2032                 flg &= ~(PROJECT_STOP);
2033                 tx = target_col;
2034                 ty = target_row;
2035         }
2036
2037         /* Analyze the "dir" and the "target".  Hurt items on floor. */
2038         return (project(0, rad, ty, tx, dam, typ, flg, -1));
2039 }
2040
2041
2042 /*!
2043  * @brief メテオ系スペルの発動 / Cast a meteor spell
2044  * @param who スぺル詠唱者のモンスターID(0=プレイヤー)
2045  * @param typ 効果属性
2046  * @param dam 威力
2047  * @param rad 半径
2048  * @param y 中心点Y座標
2049  * @param x 中心点X座標
2050  * @return 作用が実際にあった場合TRUEを返す
2051  * @details
2052  * <pre>
2053  * Cast a meteor spell, defined as a ball spell cast by an arbitary monster,
2054  * player, or outside source, that starts out at an arbitrary location, and
2055  * leaving no trail from the "caster" to the target.  This function is
2056  * especially useful for bombardments and similar. -LM-
2057  * Option to hurt the player.
2058  * </pre>
2059  */
2060 bool fire_meteor(MONSTER_IDX who, EFFECT_ID typ, POSITION y, POSITION x, HIT_POINT dam, POSITION rad)
2061 {
2062         BIT_FLAGS flg = PROJECT_STOP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
2063
2064         /* Analyze the "target" and the caster. */
2065         return (project(who, rad, y, x, dam, typ, flg, -1));
2066 }
2067
2068
2069 /*!
2070  * @brief ブラスト系スペルの発動 / Cast a blast spell
2071  * @param typ 効果属性
2072  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2073  * @param dd 威力ダイス数
2074  * @param ds 威力ダイス目
2075  * @param num 基本回数
2076  * @param dev 回数分散
2077  * @return 作用が実際にあった場合TRUEを返す
2078  */
2079 bool fire_blast(EFFECT_ID typ, DIRECTION dir, DICE_NUMBER dd, DICE_SID ds, int num, int dev)
2080 {
2081         POSITION ly, lx;
2082         int ld;
2083         POSITION ty, tx, y, x;
2084         int i;
2085
2086         BIT_FLAGS flg = PROJECT_FAST | PROJECT_THRU | PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE | PROJECT_GRID;
2087
2088         /* Assume okay */
2089         bool result = TRUE;
2090
2091         /* Use the given direction */
2092         if (dir != 5)
2093         {
2094                 ly = ty = p_ptr->y + 20 * ddy[dir];
2095                 lx = tx = p_ptr->x + 20 * ddx[dir];
2096         }
2097
2098         /* Use an actual "target" */
2099         else /* if (dir == 5) */
2100         {
2101                 tx = target_col;
2102                 ty = target_row;
2103
2104                 lx = 20 * (tx - p_ptr->x) + p_ptr->x;
2105                 ly = 20 * (ty - p_ptr->y) + p_ptr->y;
2106         }
2107
2108         ld = distance(p_ptr->y, p_ptr->x, ly, lx);
2109
2110         /* Blast */
2111         for (i = 0; i < num; i++)
2112         {
2113                 while (1)
2114                 {
2115                         /* Get targets for some bolts */
2116                         y = rand_spread(ly, ld * dev / 20);
2117                         x = rand_spread(lx, ld * dev / 20);
2118
2119                         if (distance(ly, lx, y, x) <= ld * dev / 20) break;
2120                 }
2121
2122                 /* Analyze the "dir" and the "target". */
2123                 if (!project(0, 0, y, x, damroll(dd, ds), typ, flg, -1))
2124                 {
2125                         result = FALSE;
2126                 }
2127         }
2128
2129         return (result);
2130 }
2131
2132
2133 /*!
2134  * @brief モンスターとの位置交換処理 / Switch position with a monster.
2135  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2136  * @return 作用が実際にあった場合TRUEを返す
2137  */
2138 bool teleport_swap(DIRECTION dir)
2139 {
2140         POSITION tx, ty;
2141         grid_type* g_ptr;
2142         monster_type* m_ptr;
2143         monster_race* r_ptr;
2144
2145         if ((dir == 5) && target_okay())
2146         {
2147                 tx = target_col;
2148                 ty = target_row;
2149         }
2150         else
2151         {
2152                 tx = p_ptr->x + ddx[dir];
2153                 ty = p_ptr->y + ddy[dir];
2154         }
2155         g_ptr = &p_ptr->current_floor_ptr->grid_array[ty][tx];
2156
2157         if (p_ptr->anti_tele)
2158         {
2159                 msg_print(_("不思議な力がテレポートを防いだ！", "A mysterious force prevents you from teleporting!"));
2160                 return FALSE;
2161         }
2162
2163         if (!g_ptr->m_idx || (g_ptr->m_idx == p_ptr->riding))
2164         {
2165                 msg_print(_("それとは場所を交換できません。", "You can't trade places with that!"));
2166                 return FALSE;
2167         }
2168
2169         if ((g_ptr->info & CAVE_ICKY) || (distance(ty, tx, p_ptr->y, p_ptr->x) > p_ptr->lev * 3 / 2 + 10))
2170         {
2171                 msg_print(_("失敗した。", "Failed to swap."));
2172                 return FALSE;
2173         }
2174
2175         m_ptr = &p_ptr->current_floor_ptr->m_list[g_ptr->m_idx];
2176         r_ptr = &r_info[m_ptr->r_idx];
2177
2178         (void)set_monster_csleep(g_ptr->m_idx, 0);
2179
2180         if (r_ptr->flagsr & RFR_RES_TELE)
2181         {
2182                 msg_print(_("テレポートを邪魔された！", "Your teleportation is blocked!"));
2183                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flagsr |= RFR_RES_TELE;
2184                 return FALSE;
2185         }
2186
2187         sound(SOUND_TELEPORT);
2188
2189         /* Swap the player and monster */
2190         (void)move_player_effect(p_ptr, ty, tx, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
2191
2192         /* Success */
2193         return TRUE;
2194 }
2195
2196
2197 /*!
2198  * @brief 指定方向に飛び道具を飛ばす（フラグ任意指定） / Hack -- apply a "project()" in a direction (or at the target)
2199  * @param typ 効果属性
2200  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2201  * @param dam 威力
2202  * @param flg フラグ
2203  * @return 作用が実際にあった場合TRUEを返す
2204  */
2205 bool project_hook(EFFECT_ID typ, DIRECTION dir, HIT_POINT dam, BIT_FLAGS flg)
2206 {
2207         POSITION tx, ty;
2208
2209         /* Pass through the target if needed */
2210         flg |= (PROJECT_THRU);
2211
2212         /* Use the given direction */
2213         tx = p_ptr->x + ddx[dir];
2214         ty = p_ptr->y + ddy[dir];
2215
2216         /* Hack -- Use an actual "target" */
2217         if ((dir == 5) && target_okay())
2218         {
2219                 tx = target_col;
2220                 ty = target_row;
2221         }
2222
2223         /* Analyze the "dir" and the "target", do NOT explode */
2224         return (project(0, 0, ty, tx, dam, typ, flg, -1));
2225 }
2226
2227
2228 /*!
2229  * @brief ボルト系スペルの発動 / Cast a bolt spell.
2230  * @param typ 効果属性
2231  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2232  * @param dam 威力
2233  * @return 作用が実際にあった場合TRUEを返す
2234  * @details
2235  * <pre>
2236  * Stop if we hit a monster, as a "bolt".
2237  * Affect monsters and grids (not objects).
2238  * </pre>
2239  */
2240 bool fire_bolt(EFFECT_ID typ, DIRECTION dir, HIT_POINT dam)
2241 {
2242         BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_GRID;
2243         if (typ != GF_ARROW) flg |= PROJECT_REFLECTABLE;
2244         return (project_hook(typ, dir, dam, flg));
2245 }
2246
2247
2248 /*!
2249  * @brief ビーム系スペルの発動 / Cast a beam spell.
2250  * @param typ 効果属性
2251  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2252  * @param dam 威力
2253  * @return 作用が実際にあった場合TRUEを返す
2254  * @details
2255  * <pre>
2256  * Pass through monsters, as a "beam".
2257  * Affect monsters, grids and objects.
2258  * </pre>
2259  */
2260 bool fire_beam(EFFECT_ID typ, DIRECTION dir, HIT_POINT dam)
2261 {
2262         BIT_FLAGS flg = PROJECT_BEAM | PROJECT_KILL | PROJECT_GRID | PROJECT_ITEM;
2263         return (project_hook(typ, dir, dam, flg));
2264 }
2265
2266
2267 /*!
2268  * @brief 確率に応じたボルト系/ビーム系スペルの発動 / Cast a bolt spell, or rarely, a beam spell.
2269  * @param prob ビーム化する確率(%)
2270  * @param typ 効果属性
2271  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2272  * @param dam 威力
2273  * @return 作用が実際にあった場合TRUEを返す
2274  * @details
2275  * <pre>
2276  * Pass through monsters, as a "beam".
2277  * Affect monsters, grids and objects.
2278  * </pre>
2279  */
2280 bool fire_bolt_or_beam(PERCENTAGE prob, EFFECT_ID typ, DIRECTION dir, HIT_POINT dam)
2281 {
2282         if (randint0(100) < prob)
2283         {
2284                 return (fire_beam(typ, dir, dam));
2285         }
2286         else
2287         {
2288                 return (fire_bolt(typ, dir, dam));
2289         }
2290 }
2291
2292 /*!
2293  * @brief LITE_WEAK属性による光源ビーム処理
2294  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2295  * @param dam 威力
2296  * @return 作用が実際にあった場合TRUEを返す
2297  */
2298 bool lite_line(DIRECTION dir, HIT_POINT dam)
2299 {
2300         BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_KILL;
2301         return (project_hook(GF_LITE_WEAK, dir, dam, flg));
2302 }
2303
2304 /*!
2305  * @brief 衰弱ボルト処理
2306  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2307  * @param dam 威力
2308  * @return 作用が実際にあった場合TRUEを返す
2309  */
2310 bool hypodynamic_bolt(DIRECTION dir, HIT_POINT dam)
2311 {
2312         BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
2313         return (project_hook(GF_HYPODYNAMIA, dir, dam, flg));
2314 }
2315
2316 /*!
2317  * @brief 岩石溶解処理
2318  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2319  * @param dam 威力
2320  * @return 作用が実際にあった場合TRUEを返す
2321  */
2322 bool wall_to_mud(DIRECTION dir, HIT_POINT dam)
2323 {
2324         BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
2325         return (project_hook(GF_KILL_WALL, dir, dam, flg));
2326 }
2327
2328 /*!
2329  * @brief 魔法の施錠処理
2330  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2331  * @return 作用が実際にあった場合TRUEを返す
2332  */
2333 bool wizard_lock(DIRECTION dir)
2334 {
2335         BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;
2336         return (project_hook(GF_JAM_DOOR, dir, 20 + randint1(30), flg));
2337 }
2338
2339 /*!
2340  * @brief ドア破壊処理
2341  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2342  * @return 作用が実際にあった場合TRUEを返す
2343  */
2344 bool destroy_door(DIRECTION dir)
2345 {
2346         BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_ITEM;
2347         return (project_hook(GF_KILL_DOOR, dir, 0, flg));
2348 }
2349
2350 /*!
2351  * @brief トラップ解除処理
2352  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2353  * @return 作用が実際にあった場合TRUEを返す
2354  */
2355 bool disarm_trap(DIRECTION dir)
2356 {
2357         BIT_FLAGS flg = PROJECT_BEAM | PROJECT_GRID | PROJECT_ITEM;
2358         return (project_hook(GF_KILL_TRAP, dir, 0, flg));
2359 }
2360
2361
2362 /*!
2363  * @brief 死の光線処理
2364  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2365  * @param plev プレイヤーレベル(効力はplev*200)
2366  * @return 作用が実際にあった場合TRUEを返す
2367  */
2368 bool death_ray(DIRECTION dir, PLAYER_LEVEL plev)
2369 {
2370         BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL | PROJECT_REFLECTABLE;
2371         return (project_hook(GF_DEATH_RAY, dir, plev * 200, flg));
2372 }
2373
2374 /*!
2375  * @brief モンスター用テレポート処理
2376  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2377  * @param distance 移動距離
2378  * @return 作用が実際にあった場合TRUEを返す
2379  */
2380 bool teleport_monster(DIRECTION dir, int distance)
2381 {
2382         BIT_FLAGS flg = PROJECT_BEAM | PROJECT_KILL;
2383         return (project_hook(GF_AWAY_ALL, dir, distance, flg));
2384 }
2385
2386 /*!
2387  * @brief ドア生成処理(プレイヤー中心に周囲1マス) / Hooks -- affect adjacent grids (radius 1 ball attack)
2388  * @return 作用が実際にあった場合TRUEを返す
2389  */
2390 bool door_creation(void)
2391 {
2392         BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
2393         return (project(0, 1, p_ptr->y, p_ptr->x, 0, GF_MAKE_DOOR, flg, -1));
2394 }
2395
2396 /*!
2397  * @brief トラップ生成処理(起点から周囲1マス)
2398  * @param y 起点Y座標
2399  * @param x 起点X座標
2400  * @return 作用が実際にあった場合TRUEを返す
2401  */
2402 bool trap_creation(POSITION y, POSITION x)
2403 {
2404         BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
2405         return (project(0, 1, y, x, 0, GF_MAKE_TRAP, flg, -1));
2406 }
2407
2408 /*!
2409  * @brief 森林生成処理(プレイヤー中心に周囲1マス)
2410  * @return 作用が実際にあった場合TRUEを返す
2411  */
2412 bool tree_creation(void)
2413 {
2414         BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
2415         return (project(0, 1, p_ptr->y, p_ptr->x, 0, GF_MAKE_TREE, flg, -1));
2416 }
2417
2418 /*!
2419  * @brief 魔法のルーン生成処理(プレイヤー中心に周囲1マス)
2420  * @return 作用が実際にあった場合TRUEを返す
2421  */
2422 bool glyph_creation(void)
2423 {
2424         BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM;
2425         return (project(0, 1, p_ptr->y, p_ptr->x, 0, GF_MAKE_GLYPH, flg, -1));
2426 }
2427
2428 /*!
2429  * @brief 壁生成処理(プレイヤー中心に周囲1マス)
2430  * @return 作用が実際にあった場合TRUEを返す
2431  */
2432 bool wall_stone(void)
2433 {
2434         BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
2435         bool dummy = (project(0, 1, p_ptr->y, p_ptr->x, 0, GF_STONE_WALL, flg, -1));
2436         p_ptr->update |= (PU_FLOW);
2437         p_ptr->redraw |= (PR_MAP);
2438         return dummy;
2439 }
2440
2441 /*!
2442  * @brief ドア破壊処理(プレイヤー中心に周囲1マス)
2443  * @return 作用が実際にあった場合TRUEを返す
2444  */
2445 bool destroy_doors_touch(void)
2446 {
2447         BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
2448         return (project(0, 1, p_ptr->y, p_ptr->x, 0, GF_KILL_DOOR, flg, -1));
2449 }
2450
2451 /*!
2452  * @brief トラップ解除処理(プレイヤー中心に周囲1マス)
2453  * @return 作用が実際にあった場合TRUEを返す
2454  */
2455 bool disarm_traps_touch(void)
2456 {
2457         BIT_FLAGS flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_HIDE;
2458         return (project(0, 1, p_ptr->y, p_ptr->x, 0, GF_KILL_TRAP, flg, -1));
2459 }
2460
2461 /*!
2462  * @brief スリープモンスター処理(プレイヤー中心に周囲1マス)
2463  * @return 作用が実際にあった場合TRUEを返す
2464  */
2465 bool sleep_monsters_touch(void)
2466 {
2467         BIT_FLAGS flg = PROJECT_KILL | PROJECT_HIDE;
2468         return (project(0, 1, p_ptr->y, p_ptr->x, p_ptr->lev, GF_OLD_SLEEP, flg, -1));
2469 }
2470
2471
2472 /*!
2473  * @brief 死者復活処理(起点より周囲5マス)
2474  * @param who 術者モンスターID(0ならばプレイヤー)
2475  * @param y 起点Y座標
2476  * @param x 起点X座標
2477  * @return 作用が実際にあった場合TRUEを返す
2478  */
2479 bool animate_dead(MONSTER_IDX who, POSITION y, POSITION x)
2480 {
2481         BIT_FLAGS flg = PROJECT_ITEM | PROJECT_HIDE;
2482         return (project(who, 5, y, x, 0, GF_ANIM_DEAD, flg, -1));
2483 }
2484
2485 /*!
2486  * @brief 混沌招来処理
2487  * @return 作用が実際にあった場合TRUEを返す
2488  */
2489 void call_chaos(void)
2490 {
2491         int Chaos_type, dummy, dir;
2492         PLAYER_LEVEL plev = p_ptr->lev;
2493         bool line_chaos = FALSE;
2494
2495         int hurt_types[31] =
2496         {
2497                 GF_ELEC,      GF_POIS,    GF_ACID,    GF_COLD,
2498                 GF_FIRE,      GF_MISSILE, GF_ARROW,   GF_PLASMA,
2499                 GF_HOLY_FIRE, GF_WATER,   GF_LITE,    GF_DARK,
2500                 GF_FORCE,     GF_INERTIAL, GF_MANA,    GF_METEOR,
2501                 GF_ICE,       GF_CHAOS,   GF_NETHER,  GF_DISENCHANT,
2502                 GF_SHARDS,    GF_SOUND,   GF_NEXUS,   GF_CONFUSION,
2503                 GF_TIME,      GF_GRAVITY, GF_ROCKET,  GF_NUKE,
2504                 GF_HELL_FIRE, GF_DISINTEGRATE, GF_PSY_SPEAR
2505         };
2506
2507         Chaos_type = hurt_types[randint0(31)];
2508         if (one_in_(4)) line_chaos = TRUE;
2509
2510         if (one_in_(6))
2511         {
2512                 for (dummy = 1; dummy < 10; dummy++)
2513                 {
2514                         if (dummy - 5)
2515                         {
2516                                 if (line_chaos)
2517                                         fire_beam(Chaos_type, dummy, 150);
2518                                 else
2519                                         fire_ball(Chaos_type, dummy, 150, 2);
2520                         }
2521                 }
2522         }
2523         else if (one_in_(3))
2524         {
2525                 fire_ball(Chaos_type, 0, 500, 8);
2526         }
2527         else
2528         {
2529                 if (!get_aim_dir(&dir)) return;
2530                 if (line_chaos)
2531                         fire_beam(Chaos_type, dir, 250);
2532                 else
2533                         fire_ball(Chaos_type, dir, 250, 3 + (plev / 35));
2534         }
2535 }
2536
2537 /*!
2538  * @brief TY_CURSE処理発動 / Activate the evil Topi Ylinen curse
2539  * @param stop_ty 再帰処理停止フラグ
2540  * @param count 発動回数
2541  * @return 作用が実際にあった場合TRUEを返す
2542  * @details
2543  * <pre>
2544  * rr9: Stop the nasty things when a Cyberdemon is summoned
2545  * or the player gets paralyzed.
2546  * </pre>
2547  */
2548 bool activate_ty_curse(bool stop_ty, int *count)
2549 {
2550         int i = 0;
2551         BIT_FLAGS flg = (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP);
2552
2553         do
2554         {
2555                 switch (randint1(34))
2556                 {
2557                 case 28: case 29:
2558                         if (!(*count))
2559                         {
2560                                 msg_print(_("地面が揺れた...", "The ground trembles..."));
2561                                 earthquake(p_ptr, p_ptr->y, p_ptr->x, 5 + randint0(10), 0);
2562                                 if (!one_in_(6)) break;
2563                         }
2564                 case 30: case 31:
2565                         if (!(*count))
2566                         {
2567                                 HIT_POINT dam = damroll(10, 10);
2568                                 msg_print(_("純粋な魔力の次元への扉が開いた！", "A portal opens to a plane of raw mana!"));
2569                                 project(0, 8, p_ptr->y, p_ptr->x, dam, GF_MANA, flg, -1);
2570                                 take_hit(p_ptr, DAMAGE_NOESCAPE, dam, _("純粋な魔力の解放", "released pure mana"), -1);
2571                                 if (!one_in_(6)) break;
2572                         }
2573                 case 32: case 33:
2574                         if (!(*count))
2575                         {
2576                                 msg_print(_("周囲の空間が歪んだ！", "Space warps about you!"));
2577                                 teleport_player(damroll(10, 10), TELEPORT_PASSIVE);
2578                                 if (randint0(13)) (*count) += activate_hi_summon(p_ptr->y, p_ptr->x, FALSE);
2579                                 if (!one_in_(6)) break;
2580                         }
2581                 case 34:
2582                         msg_print(_("エネルギーのうねりを感じた！", "You feel a surge of energy!"));
2583                         wall_breaker();
2584                         if (!randint0(7))
2585                         {
2586                                 project(0, 7, p_ptr->y, p_ptr->x, 50, GF_KILL_WALL, flg, -1);
2587                                 take_hit(p_ptr, DAMAGE_NOESCAPE, 50, _("エネルギーのうねり", "surge of energy"), -1);
2588                         }
2589                         if (!one_in_(6)) break;
2590                 case 1: case 2: case 3: case 16: case 17:
2591                         aggravate_monsters(0);
2592                         if (!one_in_(6)) break;
2593                 case 4: case 5: case 6:
2594                         (*count) += activate_hi_summon(p_ptr->y, p_ptr->x, FALSE);
2595                         if (!one_in_(6)) break;
2596                 case 7: case 8: case 9: case 18:
2597                         (*count) += summon_specific(0, p_ptr->y, p_ptr->x, p_ptr->current_floor_ptr->dun_level, 0, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE | PM_NO_PET));
2598                         if (!one_in_(6)) break;
2599                 case 10: case 11: case 12:
2600                         msg_print(_("経験値が体から吸い取られた気がする！", "You feel your experience draining away..."));
2601                         lose_exp(p_ptr, p_ptr->exp / 16);
2602                         if (!one_in_(6)) break;
2603                 case 13: case 14: case 15: case 19: case 20:
2604                         if (stop_ty || (p_ptr->free_act && (randint1(125) < p_ptr->skill_sav)) || (p_ptr->pclass == CLASS_BERSERKER))
2605                         {
2606                                 /* Do nothing */ ;
2607                         }
2608                         else
2609                         {
2610                                 msg_print(_("彫像になった気分だ！", "You feel like a statue!"));
2611                                 if (p_ptr->free_act)
2612                                         set_paralyzed(p_ptr, p_ptr->paralyzed + randint1(3));
2613                                 else
2614                                         set_paralyzed(p_ptr, p_ptr->paralyzed + randint1(13));
2615                                 stop_ty = TRUE;
2616                         }
2617                         if (!one_in_(6)) break;
2618                 case 21: case 22: case 23:
2619                         (void)do_dec_stat(p_ptr, randint0(6));
2620                         if (!one_in_(6)) break;
2621                 case 24:
2622                         msg_print(_("ほえ？私は誰？ここで何してる？", "Huh? Who am I? What am I doing here?"));
2623                         lose_all_info(p_ptr);
2624                         if (!one_in_(6)) break;
2625                 case 25:
2626                         /*
2627                          * Only summon Cyberdemons deep in the dungeon.
2628                          */
2629                         if ((p_ptr->current_floor_ptr->dun_level > 65) && !stop_ty)
2630                         {
2631                                 (*count) += summon_cyber(-1, p_ptr->y, p_ptr->x);
2632                                 stop_ty = TRUE;
2633                                 break;
2634                         }
2635                         if (!one_in_(6)) break;
2636                 default:
2637                         while (i < A_MAX)
2638                         {
2639                                 do
2640                                 {
2641                                         (void)do_dec_stat(p_ptr, i);
2642                                 }
2643                                 while (one_in_(2));
2644
2645                                 i++;
2646                         }
2647                 }
2648         }
2649         while (one_in_(3) && !stop_ty);
2650
2651         return stop_ty;
2652 }
2653
2654 /*!
2655  * @brief HI_SUMMON(上級召喚)処理発動
2656  * @param y 召喚位置Y座標
2657  * @param x 召喚位置X座標
2658  * @param can_pet プレイヤーのペットとなる可能性があるならばTRUEにする
2659  * @return 作用が実際にあった場合TRUEを返す
2660  */
2661 int activate_hi_summon(POSITION y, POSITION x, bool can_pet)
2662 {
2663         int i;
2664         int count = 0;
2665         DEPTH summon_lev;
2666         BIT_FLAGS mode = PM_ALLOW_GROUP;
2667         bool pet = FALSE;
2668
2669         if (can_pet)
2670         {
2671                 if (one_in_(4))
2672                 {
2673                         mode |= PM_FORCE_FRIENDLY;
2674                 }
2675                 else
2676                 {
2677                         mode |= PM_FORCE_PET;
2678                         pet = TRUE;
2679                 }
2680         }
2681
2682         if (!pet) mode |= PM_NO_PET;
2683
2684         summon_lev = (pet ? p_ptr->lev * 2 / 3 + randint1(p_ptr->lev / 2) : p_ptr->current_floor_ptr->dun_level);
2685
2686         for (i = 0; i < (randint1(7) + (p_ptr->current_floor_ptr->dun_level / 40)); i++)
2687         {
2688                 switch (randint1(25) + (p_ptr->current_floor_ptr->dun_level / 20))
2689                 {
2690                         case 1: case 2:
2691                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_ANT, mode);
2692                                 break;
2693                         case 3: case 4:
2694                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_SPIDER, mode);
2695                                 break;
2696                         case 5: case 6:
2697                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_HOUND, mode);
2698                                 break;
2699                         case 7: case 8:
2700                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_HYDRA, mode);
2701                                 break;
2702                         case 9: case 10:
2703                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_ANGEL, mode);
2704                                 break;
2705                         case 11: case 12:
2706                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_UNDEAD, mode);
2707                                 break;
2708                         case 13: case 14:
2709                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_DRAGON, mode);
2710                                 break;
2711                         case 15: case 16:
2712                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_DEMON, mode);
2713                                 break;
2714                         case 17:
2715                                 if (can_pet) break;
2716                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_AMBERITES, (mode | PM_ALLOW_UNIQUE));
2717                                 break;
2718                         case 18: case 19:
2719                                 if (can_pet) break;
2720                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_UNIQUE, (mode | PM_ALLOW_UNIQUE));
2721                                 break;
2722                         case 20: case 21:
2723                                 if (!can_pet) mode |= PM_ALLOW_UNIQUE;
2724                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_HI_UNDEAD, mode);
2725                                 break;
2726                         case 22: case 23:
2727                                 if (!can_pet) mode |= PM_ALLOW_UNIQUE;
2728                                 count += summon_specific((pet ? -1 : 0), y, x, summon_lev, SUMMON_HI_DRAGON, mode);
2729                                 break;
2730                         case 24:
2731                                 count += summon_specific((pet ? -1 : 0), y, x, 100, SUMMON_CYBER, mode);
2732                                 break;
2733                         default:
2734                                 if (!can_pet) mode |= PM_ALLOW_UNIQUE;
2735                                 count += summon_specific((pet ? -1 : 0), y, x,pet ? summon_lev : (((summon_lev * 3) / 2) + 5), 0, mode);
2736                 }
2737         }
2738
2739         return count;
2740 }
2741
2742 /*!
2743  * @brief 周辺破壊効果(プレイヤー中心)
2744  * @return 作用が実際にあった場合TRUEを返す
2745  */
2746 void wall_breaker(void)
2747 {
2748         int i;
2749         POSITION y = 0, x = 0;
2750         int attempts = 1000;
2751
2752         if (randint1(80 + p_ptr->lev) < 70)
2753         {
2754                 while (attempts--)
2755                 {
2756                         scatter(&y, &x, p_ptr->y, p_ptr->x, 4, 0);
2757
2758                         if (!cave_have_flag_bold(y, x, FF_PROJECT)) continue;
2759
2760                         if (!player_bold(p_ptr, y, x)) break;
2761                 }
2762
2763                 project(0, 0, y, x, 20 + randint1(30), GF_KILL_WALL,
2764                                   (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL), -1);
2765         }
2766         else if (randint1(100) > 30)
2767         {
2768                 earthquake(p_ptr, p_ptr->y, p_ptr->x, 1, 0);
2769         }
2770         else
2771         {
2772                 int num = damroll(5, 3);
2773
2774                 for (i = 0; i < num; i++)
2775                 {
2776                         while (1)
2777                         {
2778                                 scatter(&y, &x, p_ptr->y, p_ptr->x, 10, 0);
2779
2780                                 if (!player_bold(p_ptr, y, x)) break;
2781                         }
2782
2783                         project(0, 0, y, x, 20 + randint1(30), GF_KILL_WALL,
2784                                           (PROJECT_BEAM | PROJECT_THRU | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL), -1);
2785                 }
2786         }
2787 }
2788
2789
2790 /*!
2791  * @brief パニック・モンスター効果(プレイヤー視界範囲内) / Confuse monsters
2792  * @param dam 効力
2793  * @return 作用が実際にあった場合TRUEを返す
2794  */
2795 bool confuse_monsters(HIT_POINT dam)
2796 {
2797         return (project_all_los(GF_OLD_CONF, dam));
2798 }
2799
2800
2801 /*!
2802  * @brief チャーム・モンスター効果(プレイヤー視界範囲内) / Charm monsters
2803  * @param dam 効力
2804  * @return 作用が実際にあった場合TRUEを返す
2805  */
2806 bool charm_monsters(HIT_POINT dam)
2807 {
2808         return (project_all_los(GF_CHARM, dam));
2809 }
2810
2811
2812 /*!
2813  * @brief 動物魅了効果(プレイヤー視界範囲内) / Charm Animals
2814  * @param dam 効力
2815  * @return 作用が実際にあった場合TRUEを返す
2816  */
2817 bool charm_animals(HIT_POINT dam)
2818 {
2819         return (project_all_los(GF_CONTROL_ANIMAL, dam));
2820 }
2821
2822
2823 /*!
2824  * @brief モンスター朦朧効果(プレイヤー視界範囲内) / Stun monsters
2825  * @param dam 効力
2826  * @return 作用が実際にあった場合TRUEを返す
2827  */
2828 bool stun_monsters(HIT_POINT dam)
2829 {
2830         return (project_all_los(GF_STUN, dam));
2831 }
2832
2833
2834 /*!
2835  * @brief モンスター停止効果(プレイヤー視界範囲内) / Stasis monsters
2836  * @param dam 効力
2837  * @return 作用が実際にあった場合TRUEを返す
2838  */
2839 bool stasis_monsters(HIT_POINT dam)
2840 {
2841         return (project_all_los(GF_STASIS, dam));
2842 }
2843
2844
2845 /*!
2846  * @brief モンスター精神攻撃効果(プレイヤー視界範囲内) / Mindblast monsters
2847  * @param dam 効力
2848  * @return 作用が実際にあった場合TRUEを返す
2849  */
2850 bool mindblast_monsters(HIT_POINT dam)
2851 {
2852         return (project_all_los(GF_PSI, dam));
2853 }
2854
2855
2856 /*!
2857  * @brief モンスター追放効果(プレイヤー視界範囲内) / Banish all monsters
2858  * @param dist 効力（距離）
2859  * @return 作用が実際にあった場合TRUEを返す
2860  */
2861 bool banish_monsters(int dist)
2862 {
2863         return (project_all_los(GF_AWAY_ALL, dist));
2864 }
2865
2866
2867 /*!
2868  * @brief 邪悪退散効果(プレイヤー視界範囲内) / Turn evil
2869  * @param dam 効力
2870  * @return 作用が実際にあった場合TRUEを返す
2871  */
2872 bool turn_evil(HIT_POINT dam)
2873 {
2874         return (project_all_los(GF_TURN_EVIL, dam));
2875 }
2876
2877
2878 /*!
2879  * @brief 全モンスター退散効果(プレイヤー視界範囲内) / Turn everyone
2880  * @param dam 効力
2881  * @return 作用が実際にあった場合TRUEを返す
2882  */
2883 bool turn_monsters(HIT_POINT dam)
2884 {
2885         return (project_all_los(GF_TURN_ALL, dam));
2886 }
2887
2888
2889 /*!
2890  * @brief 死の光線(プレイヤー視界範囲内) / Death-ray all monsters (note: OBSCENELY powerful)
2891  * @return 作用が実際にあった場合TRUEを返す
2892  */
2893 bool deathray_monsters(void)
2894 {
2895         return (project_all_los(GF_DEATH_RAY, p_ptr->lev * 200));
2896 }
2897
2898 /*!
2899  * @brief チャーム・モンスター(1体)
2900  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2901  * @param plev パワー
2902  * @return 作用が実際にあった場合TRUEを返す
2903  */
2904 bool charm_monster(DIRECTION dir, PLAYER_LEVEL plev)
2905 {
2906         BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL;
2907         return (project_hook(GF_CHARM, dir, plev, flg));
2908 }
2909
2910 /*!
2911  * @brief アンデッド支配(1体)
2912  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2913  * @param plev パワー
2914  * @return 作用が実際にあった場合TRUEを返す
2915  */
2916 bool control_one_undead(DIRECTION dir, PLAYER_LEVEL plev)
2917 {
2918         BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL;
2919         return (project_hook(GF_CONTROL_UNDEAD, dir, plev, flg));
2920 }
2921
2922 /*!
2923  * @brief 悪魔支配(1体)
2924  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2925  * @param plev パワー
2926  * @return 作用が実際にあった場合TRUEを返す
2927  */
2928 bool control_one_demon(DIRECTION dir, PLAYER_LEVEL plev)
2929 {
2930         BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL;
2931         return (project_hook(GF_CONTROL_DEMON, dir, plev, flg));
2932 }
2933
2934 /*!
2935  * @brief 動物支配(1体)
2936  * @param dir 方向(5ならばグローバル変数 target_col/target_row の座標を目標にする)
2937  * @param plev パワー
2938  * @return 作用が実際にあった場合TRUEを返す
2939  */
2940 bool charm_animal(DIRECTION dir, PLAYER_LEVEL plev)
2941 {
2942         BIT_FLAGS flg = PROJECT_STOP | PROJECT_KILL;
2943         return (project_hook(GF_CONTROL_ANIMAL, dir, plev, flg));
2944 }
2945
2946
2947 /*!
2948  * @brief 変わり身処理
2949  * @param success 判定成功上の処理ならばTRUE
2950  * @return 作用が実際にあった場合TRUEを返す
2951  */
2952 bool kawarimi(bool success)
2953 {
2954         object_type forge;
2955         object_type *q_ptr = &forge;
2956         POSITION y, x;
2957
2958         if (p_ptr->is_dead) return FALSE;
2959         if (p_ptr->confused || p_ptr->blind || p_ptr->paralyzed || p_ptr->image) return FALSE;
2960         if (randint0(200) < p_ptr->stun) return FALSE;
2961
2962         if (!success && one_in_(3))
2963         {
2964                 msg_print(_("失敗！逃げられなかった。", "Failed! You couldn't run away."));
2965                 p_ptr->special_defense &= ~(NINJA_KAWARIMI);
2966                 p_ptr->redraw |= (PR_STATUS);
2967                 return FALSE;
2968         }
2969
2970         y = p_ptr->y;
2971         x = p_ptr->x;
2972
2973         teleport_player(10 + randint1(90), 0L);
2974         object_wipe(q_ptr);
2975         object_prep(q_ptr, lookup_kind(TV_STATUE, SV_WOODEN_STATUE));
2976
2977         q_ptr->pval = MON_NINJA;
2978         (void)drop_near(q_ptr, -1, y, x);
2979
2980         if (success) msg_print(_("攻撃を受ける前に素早く身をひるがえした。", "You have turned around just before the attack hit you."));
2981         else msg_print(_("失敗！攻撃を受けてしまった。", "Failed! You are hit by the attack."));
2982
2983         p_ptr->special_defense &= ~(NINJA_KAWARIMI);
2984         p_ptr->redraw |= (PR_STATUS);
2985
2986         /* Teleported */
2987         return TRUE;
2988 }
2989
2990
2991 /*!
2992  * @brief 入身処理 / "Rush Attack" routine for Samurai or Ninja
2993  * @param mdeath 目標モンスターが死亡したかを返す
2994  * @return 作用が実際にあった場合TRUEを返す /  Return value is for checking "done"
2995  */
2996 bool rush_attack(bool *mdeath)
2997 {
2998         DIRECTION dir;
2999         int tx, ty;
3000         int tm_idx = 0;
3001         u16b path_g[32];
3002         int path_n, i;
3003         bool tmp_mdeath = FALSE;
3004         bool moved = FALSE;
3005
3006         if (mdeath) *mdeath = FALSE;
3007
3008         project_length = 5;
3009         if (!get_aim_dir(&dir)) return FALSE;
3010
3011         /* Use the given direction */
3012         tx = p_ptr->x + project_length * ddx[dir];
3013         ty = p_ptr->y + project_length * ddy[dir];
3014
3015         /* Hack -- Use an actual "target" */
3016         if ((dir == 5) && target_okay())
3017         {
3018                 tx = target_col;
3019                 ty = target_row;
3020         }
3021
3022         if (in_bounds(p_ptr->current_floor_ptr, ty, tx)) tm_idx = p_ptr->current_floor_ptr->grid_array[ty][tx].m_idx;
3023
3024         path_n = project_path(path_g, project_length, p_ptr->y, p_ptr->x, ty, tx, PROJECT_STOP | PROJECT_KILL);
3025         project_length = 0;
3026
3027         /* No need to move */
3028         if (!path_n) return TRUE;
3029
3030         /* Use ty and tx as to-move point */
3031         ty = p_ptr->y;
3032         tx = p_ptr->x;
3033
3034         /* Project along the path */
3035         for (i = 0; i < path_n; i++)
3036         {
3037                 monster_type *m_ptr;
3038
3039                 int ny = GRID_Y(path_g[i]);
3040                 int nx = GRID_X(path_g[i]);
3041
3042                 if (cave_empty_bold(p_ptr->current_floor_ptr, ny, nx) && player_can_enter(p_ptr->current_floor_ptr->grid_array[ny][nx].feat, 0))
3043                 {
3044                         ty = ny;
3045                         tx = nx;
3046
3047                         /* Go to next grid */
3048                         continue;
3049                 }
3050
3051                 if (!p_ptr->current_floor_ptr->grid_array[ny][nx].m_idx)
3052                 {
3053                         if (tm_idx)
3054                         {
3055                                 msg_print(_("失敗！", "Failed!"));
3056                         }
3057                         else
3058                         {
3059                                 msg_print(_("ここには入身では入れない。", "You can't move to that place."));
3060                         }
3061
3062                         /* Exit loop */
3063                         break;
3064                 }
3065
3066                 /* Move player before updating the monster */
3067                 if (!player_bold(p_ptr, ty, tx)) teleport_player_to(p_ptr, ty, tx, TELEPORT_NONMAGICAL);
3068                 update_monster(p_ptr, p_ptr->current_floor_ptr->grid_array[ny][nx].m_idx, TRUE);
3069
3070                 /* Found a monster */
3071                 m_ptr = &p_ptr->current_floor_ptr->m_list[p_ptr->current_floor_ptr->grid_array[ny][nx].m_idx];
3072
3073                 if (tm_idx != p_ptr->current_floor_ptr->grid_array[ny][nx].m_idx)
3074                 {
3075 #ifdef JP
3076                         msg_format("%s%sが立ちふさがっている！", tm_idx ? "別の" : "", m_ptr->ml ? "モンスター" : "何か");
3077 #else
3078                         msg_format("There is %s in the way!", m_ptr->ml ? (tm_idx ? "another monster" : "a monster") : "someone");
3079 #endif
3080                 }
3081                 else if (!player_bold(p_ptr, ty, tx))
3082                 {
3083                         /* Hold the monster name */
3084                         GAME_TEXT m_name[MAX_NLEN];
3085
3086                         /* Get the monster name (BEFORE polymorphing) */
3087                         monster_desc(m_name, m_ptr, 0);
3088                         msg_format(_("素早く%sの懐に入り込んだ！", "You quickly jump in and attack %s!"), m_name);
3089                 }
3090
3091                 if (!player_bold(p_ptr, ty, tx)) teleport_player_to(p_ptr, ty, tx, TELEPORT_NONMAGICAL);
3092                 moved = TRUE;
3093                 tmp_mdeath = py_attack(p_ptr, ny, nx, HISSATSU_NYUSIN);
3094
3095                 break;
3096         }
3097
3098         if (!moved && !player_bold(p_ptr, ty, tx)) teleport_player_to(p_ptr, ty, tx, TELEPORT_NONMAGICAL);
3099
3100         if (mdeath) *mdeath = tmp_mdeath;
3101         return TRUE;
3102 }
3103
3104
3105 /*!
3106  * @brief 全鏡の消去 / Remove all mirrors in this floor
3107  * @param explode 爆発処理を伴うならばTRUE
3108  * @return なし
3109  */
3110 void remove_all_mirrors(bool explode)
3111 {
3112         POSITION x, y;
3113
3114         for (x = 0; x < p_ptr->current_floor_ptr->width; x++)
3115         {
3116                 for (y = 0; y < p_ptr->current_floor_ptr->height; y++)
3117                 {
3118                         if (is_mirror_grid(&p_ptr->current_floor_ptr->grid_array[y][x]))
3119                         {
3120                                 remove_mirror(y, x);
3121                                 if (explode)
3122                                         project(0, 2, y, x, p_ptr->lev / 2 + 5, GF_SHARDS,
3123                                                 (PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL | PROJECT_JUMP | PROJECT_NO_HANGEKI), -1);
3124                         }
3125                 }
3126         }
3127 }
3128
3129 /*!
3130  * @brief 『一つの指輪』の効果処理 /
3131  * Hack -- activate the ring of power
3132  * @param dir 発動の方向ID
3133  * @return なし
3134  */
3135 void ring_of_power(DIRECTION dir)
3136 {
3137         /* Pick a random effect */
3138         switch (randint1(10))
3139         {
3140         case 1:
3141         case 2:
3142         {
3143                 msg_print(_("あなたは悪性のオーラに包み込まれた。", "You are surrounded by a malignant aura."));
3144                 sound(SOUND_EVIL);
3145
3146                 /* Decrease all stats (permanently) */
3147                 (void)dec_stat(p_ptr, A_STR, 50, TRUE);
3148                 (void)dec_stat(p_ptr, A_INT, 50, TRUE);
3149                 (void)dec_stat(p_ptr, A_WIS, 50, TRUE);
3150                 (void)dec_stat(p_ptr, A_DEX, 50, TRUE);
3151                 (void)dec_stat(p_ptr, A_CON, 50, TRUE);
3152                 (void)dec_stat(p_ptr, A_CHR, 50, TRUE);
3153
3154                 /* Lose some experience (permanently) */
3155                 p_ptr->exp -= (p_ptr->exp / 4);
3156                 p_ptr->max_exp -= (p_ptr->exp / 4);
3157                 check_experience(p_ptr);
3158
3159                 break;
3160         }
3161
3162         case 3:
3163         {
3164                 msg_print(_("あなたは強力なオーラに包み込まれた。", "You are surrounded by a powerful aura."));
3165                 dispel_monsters(1000);
3166                 break;
3167         }
3168
3169         case 4:
3170         case 5:
3171         case 6:
3172         {
3173                 fire_ball(GF_MANA, dir, 600, 3);
3174                 break;
3175         }
3176
3177         case 7:
3178         case 8:
3179         case 9:
3180         case 10:
3181         {
3182                 fire_bolt(GF_MANA, dir, 500);
3183                 break;
3184         }
3185         }
3186 }
3187
3188 /*!
3189 * @brief 運命の輪、並びにカオス的な効果の発動
3190 * @param spell ランダムな効果を選択するための基準ID
3191 * @return なし
3192 */
3193 void wild_magic(int spell)
3194 {
3195         int counter = 0;
3196         int type = SUMMON_MOLD + randint0(6);
3197
3198         if (type < SUMMON_MOLD) type = SUMMON_MOLD;
3199         else if (type > SUMMON_MIMIC) type = SUMMON_MIMIC;
3200
3201         switch (randint1(spell) + randint1(8) + 1)
3202         {
3203         case 1:
3204         case 2:
3205         case 3:
3206                 teleport_player(10, TELEPORT_PASSIVE);
3207                 break;
3208         case 4:
3209         case 5:
3210         case 6:
3211                 teleport_player(100, TELEPORT_PASSIVE);
3212                 break;
3213         case 7:
3214         case 8:
3215                 teleport_player(200, TELEPORT_PASSIVE);
3216                 break;
3217         case 9:
3218         case 10:
3219         case 11:
3220                 unlite_area(10, 3);
3221                 break;
3222         case 12:
3223         case 13:
3224         case 14:
3225                 lite_area(damroll(2, 3), 2);
3226                 break;
3227         case 15:
3228                 destroy_doors_touch();
3229                 break;
3230         case 16: case 17:
3231                 wall_breaker();
3232         case 18:
3233                 sleep_monsters_touch();
3234                 break;
3235         case 19:
3236         case 20:
3237                 trap_creation(p_ptr->y, p_ptr->x);
3238                 break;
3239         case 21:
3240         case 22:
3241                 door_creation();
3242                 break;
3243         case 23:
3244         case 24:
3245         case 25:
3246                 aggravate_monsters(0);
3247                 break;
3248         case 26:
3249                 earthquake(p_ptr, p_ptr->y, p_ptr->x, 5, 0);
3250                 break;
3251         case 27:
3252         case 28:
3253                 (void)gain_mutation(p_ptr, 0);
3254                 break;
3255         case 29:
3256         case 30:
3257                 apply_disenchant(p_ptr, 1);
3258                 break;
3259         case 31:
3260                 lose_all_info(p_ptr);
3261                 break;
3262         case 32:
3263                 fire_ball(GF_CHAOS, 0, spell + 5, 1 + (spell / 10));
3264                 break;
3265         case 33:
3266                 wall_stone();
3267                 break;
3268         case 34:
3269         case 35:
3270                 while (counter++ < 8)
3271                 {
3272                         (void)summon_specific(0, p_ptr->y, p_ptr->x, (p_ptr->current_floor_ptr->dun_level * 3) / 2, type, (PM_ALLOW_GROUP | PM_NO_PET));
3273                 }
3274                 break;
3275         case 36:
3276         case 37:
3277                 activate_hi_summon(p_ptr->y, p_ptr->x, FALSE);
3278                 break;
3279         case 38:
3280                 (void)summon_cyber(-1, p_ptr->y, p_ptr->x);
3281                 break;
3282         default:
3283         {
3284                 int count = 0;
3285                 (void)activate_ty_curse(FALSE, &count);
3286                 break;
3287         }
3288         }
3289
3290         return;
3291 }
3292
3293 /*!
3294 * @brief カオス魔法「流星群」の処理としてプレイヤーを中心に隕石落下処理を10+1d10回繰り返す。
3295 * / Drop 10+1d10 meteor ball at random places near the player
3296 * @param dam ダメージ
3297 * @param rad 効力の半径
3298 * @return なし
3299 */
3300 void cast_meteor(HIT_POINT dam, POSITION rad)
3301 {
3302         int i;
3303         int b = 10 + randint1(10);
3304
3305         for (i = 0; i < b; i++)
3306         {
3307                 POSITION y = 0, x = 0;
3308                 int count;
3309
3310                 for (count = 0; count <= 20; count++)
3311                 {
3312                         int dy, dx, d;
3313
3314                         x = p_ptr->x - 8 + randint0(17);
3315                         y = p_ptr->y - 8 + randint0(17);
3316
3317                         dx = (p_ptr->x > x) ? (p_ptr->x - x) : (x - p_ptr->x);
3318                         dy = (p_ptr->y > y) ? (p_ptr->y - y) : (y - p_ptr->y);
3319
3320                         /* Approximate distance */
3321                         d = (dy > dx) ? (dy + (dx >> 1)) : (dx + (dy >> 1));
3322
3323                         if (d >= 9) continue;
3324
3325                         if (!in_bounds(p_ptr->current_floor_ptr, y, x) || !projectable(p_ptr->current_floor_ptr, p_ptr->y, p_ptr->x, y, x)
3326                                 || !cave_have_flag_bold(y, x, FF_PROJECT)) continue;
3327
3328                         /* Valid position */
3329                         break;
3330                 }
3331
3332                 if (count > 20) continue;
3333
3334                 project(0, rad, y, x, dam, GF_METEOR, PROJECT_KILL | PROJECT_JUMP | PROJECT_ITEM, -1);
3335         }
3336 }
3337
3338
3339 /*!
3340 * @brief 破邪魔法「神の怒り」の処理としてターゲットを指定した後分解のボールを最大20回発生させる。
3341 * @param dam ダメージ
3342 * @param rad 効力の半径
3343 * @return ターゲットを指定し、実行したならばTRUEを返す。
3344 */
3345 bool cast_wrath_of_the_god(HIT_POINT dam, POSITION rad)
3346 {
3347         POSITION x, y, tx, ty;
3348         POSITION nx, ny;
3349         DIRECTION dir;
3350         int i;
3351         int b = 10 + randint1(10);
3352
3353         if (!get_aim_dir(&dir)) return FALSE;
3354
3355         /* Use the given direction */
3356         tx = p_ptr->x + 99 * ddx[dir];
3357         ty = p_ptr->y + 99 * ddy[dir];
3358
3359         /* Hack -- Use an actual "target" */
3360         if ((dir == 5) && target_okay())
3361         {
3362                 tx = target_col;
3363                 ty = target_row;
3364         }
3365
3366         x = p_ptr->x;
3367         y = p_ptr->y;
3368
3369         while (1)
3370         {
3371                 /* Hack -- Stop at the target */
3372                 if ((y == ty) && (x == tx)) break;
3373
3374                 ny = y;
3375                 nx = x;
3376                 mmove2(&ny, &nx, p_ptr->y, p_ptr->x, ty, tx);
3377
3378                 /* Stop at maximum range */
3379                 if (MAX_RANGE <= distance(p_ptr->y, p_ptr->x, ny, nx)) break;
3380
3381                 /* Stopped by walls/doors */
3382                 if (!cave_have_flag_bold(ny, nx, FF_PROJECT)) break;
3383
3384                 /* Stopped by monsters */
3385                 if ((dir != 5) && p_ptr->current_floor_ptr->grid_array[ny][nx].m_idx != 0) break;
3386
3387                 /* Save the new location */
3388                 x = nx;
3389                 y = ny;
3390         }
3391         tx = x;
3392         ty = y;
3393
3394         for (i = 0; i < b; i++)
3395         {
3396                 int count = 20, d = 0;
3397
3398                 while (count--)
3399                 {
3400                         int dx, dy;
3401
3402                         x = tx - 5 + randint0(11);
3403                         y = ty - 5 + randint0(11);
3404
3405                         dx = (tx > x) ? (tx - x) : (x - tx);
3406                         dy = (ty > y) ? (ty - y) : (y - ty);
3407
3408                         /* Approximate distance */
3409                         d = (dy > dx) ? (dy + (dx >> 1)) : (dx + (dy >> 1));
3410                         /* Within the radius */
3411                         if (d < 5) break;
3412                 }
3413
3414                 if (count < 0) continue;
3415
3416                 /* Cannot penetrate perm walls */
3417                 if (!in_bounds(p_ptr->current_floor_ptr, y, x) ||
3418                         cave_stop_disintegration(y, x) ||
3419                         !in_disintegration_range(ty, tx, y, x))
3420                         continue;
3421
3422                 project(0, rad, y, x, dam, GF_DISINTEGRATE, PROJECT_JUMP | PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL, -1);
3423         }
3424
3425         return TRUE;
3426 }
3427
3428 /*!
3429 * @brief 「ワンダー」のランダムな効果を決定して処理する。
3430 * @param dir 方向ID
3431 * @return なし
3432 * @details
3433 * This spell should become more useful (more controlled) as the\n
3434 * player gains experience levels.  Thus, add 1/5 of the player's\n
3435 * level to the die roll.  This eliminates the worst effects later on,\n
3436 * while keeping the results quite random.  It also allows some potent\n
3437 * effects only at high level.
3438 */
3439 void cast_wonder(DIRECTION dir)
3440 {
3441         PLAYER_LEVEL plev = p_ptr->lev;
3442         int die = randint1(100) + plev / 5;
3443         int vir = virtue_number(p_ptr, V_CHANCE);
3444
3445         if (vir)
3446         {
3447                 if (p_ptr->virtues[vir - 1] > 0)
3448                 {
3449                         while (randint1(400) < p_ptr->virtues[vir - 1]) die++;
3450                 }
3451                 else
3452                 {
3453                         while (randint1(400) < (0 - p_ptr->virtues[vir - 1])) die--;
3454                 }
3455         }
3456
3457         if (die < 26)
3458                 chg_virtue(p_ptr, V_CHANCE, 1);
3459
3460         if (die > 100)
3461         {
3462                 msg_print(_("あなたは力がみなぎるのを感じた！", "You feel a surge of power!"));
3463         }
3464
3465         if (die < 8) clone_monster(dir);
3466         else if (die < 14) speed_monster(dir, plev);
3467         else if (die < 26) heal_monster(dir, damroll(4, 6));
3468         else if (die < 31) poly_monster(dir, plev);
3469         else if (die < 36)
3470                 fire_bolt_or_beam(beam_chance() - 10, GF_MISSILE, dir,
3471                         damroll(3 + ((plev - 1) / 5), 4));
3472         else if (die < 41) confuse_monster(dir, plev);
3473         else if (die < 46) fire_ball(GF_POIS, dir, 20 + (plev / 2), 3);
3474         else if (die < 51) (void)lite_line(dir, damroll(6, 8));
3475         else if (die < 56)
3476                 fire_bolt_or_beam(beam_chance() - 10, GF_ELEC, dir,
3477                         damroll(3 + ((plev - 5) / 4), 8));
3478         else if (die < 61)
3479                 fire_bolt_or_beam(beam_chance() - 10, GF_COLD, dir,
3480                         damroll(5 + ((plev - 5) / 4), 8));
3481         else if (die < 66)
3482                 fire_bolt_or_beam(beam_chance(), GF_ACID, dir,
3483                         damroll(6 + ((plev - 5) / 4), 8));
3484         else if (die < 71)
3485                 fire_bolt_or_beam(beam_chance(), GF_FIRE, dir,
3486                         damroll(8 + ((plev - 5) / 4), 8));
3487         else if (die < 76) hypodynamic_bolt(dir, 75);
3488         else if (die < 81) fire_ball(GF_ELEC, dir, 30 + plev / 2, 2);
3489         else if (die < 86) fire_ball(GF_ACID, dir, 40 + plev, 2);
3490         else if (die < 91) fire_ball(GF_ICE, dir, 70 + plev, 3);
3491         else if (die < 96) fire_ball(GF_FIRE, dir, 80 + plev, 3);
3492         else if (die < 101) hypodynamic_bolt(dir, 100 + plev);
3493         else if (die < 104)
3494         {
3495                 earthquake(p_ptr, p_ptr->y, p_ptr->x, 12, 0);
3496         }
3497         else if (die < 106)
3498         {
3499                 (void)destroy_area(p_ptr->current_floor_ptr, p_ptr->y, p_ptr->x, 13 + randint0(5), FALSE);
3500         }
3501         else if (die < 108)
3502         {
3503                 symbol_genocide(plev + 50, TRUE);
3504         }
3505         else if (die < 110) dispel_monsters(120);
3506         else /* RARE */
3507         {
3508                 dispel_monsters(150);
3509                 slow_monsters(plev);
3510                 sleep_monsters(plev);
3511                 hp_player(p_ptr, 300);
3512         }
3513 }
3514
3515
3516 /*!
3517 * @brief 「悪霊召喚」のランダムな効果を決定して処理する。
3518 * @param dir 方向ID
3519 * @return なし
3520 */
3521 void cast_invoke_spirits(DIRECTION dir)
3522 {
3523         PLAYER_LEVEL plev = p_ptr->lev;
3524         int die = randint1(100) + plev / 5;
3525         int vir = virtue_number(p_ptr, V_CHANCE);
3526
3527         if (vir)
3528         {
3529                 if (p_ptr->virtues[vir - 1] > 0)
3530                 {
3531                         while (randint1(400) < p_ptr->virtues[vir - 1]) die++;
3532                 }
3533                 else
3534                 {
3535                         while (randint1(400) < (0 - p_ptr->virtues[vir - 1])) die--;
3536                 }
3537         }
3538
3539         msg_print(_("あなたは死者たちの力を招集した...", "You call on the power of the dead..."));
3540         if (die < 26)
3541                 chg_virtue(p_ptr, V_CHANCE, 1);
3542
3543         if (die > 100)
3544         {
3545                 msg_print(_("あなたはおどろおどろしい力のうねりを感じた！", "You feel a surge of eldritch force!"));
3546         }
3547
3548         if (die < 8)
3549         {
3550                 msg_print(_("なんてこった！あなたの周りの地面から朽ちた人影が立ち上がってきた！",
3551                         "Oh no! Mouldering forms rise from the earth around you!"));
3552
3553                 (void)summon_specific(0, p_ptr->y, p_ptr->x, p_ptr->current_floor_ptr->dun_level, SUMMON_UNDEAD, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE | PM_NO_PET));
3554                 chg_virtue(p_ptr, V_UNLIFE, 1);
3555         }
3556         else if (die < 14)
3557         {
3558                 msg_print(_("名状し難い邪悪な存在があなたの心を通り過ぎて行った...", "An unnamable evil brushes against your mind..."));
3559
3560                 set_afraid(p_ptr, p_ptr->afraid + randint1(4) + 4);
3561         }
3562         else if (die < 26)
3563         {
3564                 msg_print(_("あなたの頭に大量の幽霊たちの騒々しい声が押し寄せてきた...",
3565                         "Your head is invaded by a horde of gibbering spectral voices..."));
3566
3567                 set_confused(p_ptr, p_ptr->confused + randint1(4) + 4);
3568         }
3569         else if (die < 31)
3570         {
3571                 poly_monster(dir, plev);
3572         }
3573         else if (die < 36)
3574         {
3575                 fire_bolt_or_beam(beam_chance() - 10, GF_MISSILE, dir,
3576                         damroll(3 + ((plev - 1) / 5), 4));
3577         }
3578         else if (die < 41)
3579         {
3580                 confuse_monster(dir, plev);
3581         }
3582         else if (die < 46)
3583         {
3584                 fire_ball(GF_POIS, dir, 20 + (plev / 2), 3);
3585         }
3586         else if (die < 51)
3587         {
3588                 (void)lite_line(dir, damroll(6, 8));
3589         }
3590         else if (die < 56)
3591         {
3592                 fire_bolt_or_beam(beam_chance() - 10, GF_ELEC, dir,
3593                         damroll(3 + ((plev - 5) / 4), 8));
3594         }
3595         else if (die < 61)
3596         {
3597                 fire_bolt_or_beam(beam_chance() - 10, GF_COLD, dir,
3598                         damroll(5 + ((plev - 5) / 4), 8));
3599         }
3600         else if (die < 66)
3601         {
3602                 fire_bolt_or_beam(beam_chance(), GF_ACID, dir,
3603                         damroll(6 + ((plev - 5) / 4), 8));
3604         }
3605         else if (die < 71)
3606         {
3607                 fire_bolt_or_beam(beam_chance(), GF_FIRE, dir,
3608                         damroll(8 + ((plev - 5) / 4), 8));
3609         }
3610         else if (die < 76)
3611         {
3612                 hypodynamic_bolt(dir, 75);
3613         }
3614         else if (die < 81)
3615         {
3616                 fire_ball(GF_ELEC, dir, 30 + plev / 2, 2);
3617         }
3618         else if (die < 86)
3619         {
3620                 fire_ball(GF_ACID, dir, 40 + plev, 2);
3621         }
3622         else if (die < 91)
3623         {
3624                 fire_ball(GF_ICE, dir, 70 + plev, 3);
3625         }
3626         else if (die < 96)
3627         {
3628                 fire_ball(GF_FIRE, dir, 80 + plev, 3);
3629         }
3630         else if (die < 101)
3631         {
3632                 hypodynamic_bolt(dir, 100 + plev);
3633         }
3634         else if (die < 104)
3635         {
3636                 earthquake(p_ptr, p_ptr->y, p_ptr->x, 12, 0);
3637         }
3638         else if (die < 106)
3639         {
3640                 (void)destroy_area(p_ptr->current_floor_ptr, p_ptr->y, p_ptr->x, 13 + randint0(5), FALSE);
3641         }
3642         else if (die < 108)
3643         {
3644                 symbol_genocide(plev + 50, TRUE);
3645         }
3646         else if (die < 110)
3647         {
3648                 dispel_monsters(120);
3649         }
3650         else
3651         { /* RARE */
3652                 dispel_monsters(150);
3653                 slow_monsters(plev);
3654                 sleep_monsters(plev);
3655                 hp_player(p_ptr, 300);
3656         }
3657
3658         if (die < 31)
3659         {
3660                 msg_print(_("陰欝な声がクスクス笑う。「もうすぐおまえは我々の仲間になるだろう。弱き者よ。」",
3661                         "Sepulchral voices chuckle. 'Soon you will join us, mortal.'"));
3662         }
3663 }
3664
3665 /*!
3666 * @brief トランプ領域の「シャッフル」の効果をランダムに決めて処理する。
3667 * @return なし
3668 */
3669 void cast_shuffle(player_type *caster_ptr)
3670 {
3671         PLAYER_LEVEL plev = caster_ptr->lev;
3672         DIRECTION dir;
3673         int die;
3674         int vir = virtue_number(caster_ptr, V_CHANCE);
3675         int i;
3676
3677         /* Card sharks and high mages get a level bonus */
3678         if ((caster_ptr->pclass == CLASS_ROGUE) ||
3679                 (caster_ptr->pclass == CLASS_HIGH_MAGE) ||
3680                 (caster_ptr->pclass == CLASS_SORCERER))
3681                 die = (randint1(110)) + plev / 5;
3682         else
3683                 die = randint1(120);
3684
3685
3686         if (vir)
3687         {
3688                 if (caster_ptr->virtues[vir - 1] > 0)
3689                 {
3690                         while (randint1(400) < caster_ptr->virtues[vir - 1]) die++;
3691                 }
3692                 else
3693                 {
3694                         while (randint1(400) < (0 - caster_ptr->virtues[vir - 1])) die--;
3695                 }
3696         }
3697
3698         msg_print(_("あなたはカードを切って一枚引いた...", "You shuffle the deck and draw a card..."));
3699
3700         if (die < 30)
3701                 chg_virtue(caster_ptr, V_CHANCE, 1);
3702
3703         if (die < 7)
3704         {
3705                 msg_print(_("なんてこった！《死》だ！", "Oh no! It's Death!"));
3706
3707                 for (i = 0; i < randint1(3); i++)
3708                         activate_hi_summon(caster_ptr->y, caster_ptr->x, FALSE);
3709         }
3710         else if (die < 14)
3711         {
3712                 msg_print(_("なんてこった！《悪魔》だ！", "Oh no! It's the Devil!"));
3713                 summon_specific(0, caster_ptr->y, caster_ptr->x, caster_ptr->current_floor_ptr->dun_level, SUMMON_DEMON, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE | PM_NO_PET));
3714         }
3715         else if (die < 18)
3716         {
3717                 int count = 0;
3718                 msg_print(_("なんてこった！《吊られた男》だ！", "Oh no! It's the Hanged Man."));
3719                 activate_ty_curse(FALSE, &count);
3720         }
3721         else if (die < 22)
3722         {
3723                 msg_print(_("《不調和の剣》だ。", "It's the swords of discord."));
3724                 aggravate_monsters(0);
3725         }
3726         else if (die < 26)
3727         {
3728                 msg_print(_("《愚者》だ。", "It's the Fool."));
3729                 do_dec_stat(caster_ptr, A_INT);
3730                 do_dec_stat(caster_ptr, A_WIS);
3731         }
3732         else if (die < 30)
3733         {
3734                 msg_print(_("奇妙なモンスターの絵だ。", "It's the picture of a strange monster."));
3735                 trump_summoning(1, FALSE, caster_ptr->y, caster_ptr->x, (caster_ptr->current_floor_ptr->dun_level * 3 / 2), (32 + randint1(6)), PM_ALLOW_GROUP | PM_ALLOW_UNIQUE);
3736         }
3737         else if (die < 33)
3738         {
3739                 msg_print(_("《月》だ。", "It's the Moon."));
3740                 unlite_area(10, 3);
3741         }
3742         else if (die < 38)
3743         {
3744                 msg_print(_("《運命の輪》だ。", "It's the Wheel of Fortune."));
3745                 wild_magic(randint0(32));
3746         }
3747         else if (die < 40)
3748         {
3749                 msg_print(_("テレポート・カードだ。", "It's a teleport trump card."));
3750                 teleport_player(10, TELEPORT_PASSIVE);
3751         }
3752         else if (die < 42)
3753         {
3754                 msg_print(_("《正義》だ。", "It's Justice."));
3755                 set_blessed(caster_ptr, caster_ptr->lev, FALSE);
3756         }
3757         else if (die < 47)
3758         {
3759                 msg_print(_("テレポート・カードだ。", "It's a teleport trump card."));
3760                 teleport_player(100, TELEPORT_PASSIVE);
3761         }
3762         else if (die < 52)
3763         {
3764                 msg_print(_("テレポート・カードだ。", "It's a teleport trump card."));
3765                 teleport_player(200, TELEPORT_PASSIVE);
3766         }
3767         else if (die < 60)
3768         {
3769                 msg_print(_("《塔》だ。", "It's the Tower."));
3770                 wall_breaker();
3771         }
3772         else if (die < 72)
3773         {
3774                 msg_print(_("《節制》だ。", "It's Temperance."));
3775                 sleep_monsters_touch();
3776         }
3777         else if (die < 80)
3778         {
3779                 msg_print(_("《塔》だ。", "It's the Tower."));
3780
3781                 earthquake(caster_ptr, caster_ptr->y, caster_ptr->x, 5, 0);
3782         }
3783         else if (die < 82)
3784         {
3785                 msg_print(_("友好的なモンスターの絵だ。", "It's the picture of a friendly monster."));
3786                 trump_summoning(1, TRUE, caster_ptr->y, caster_ptr->x, (caster_ptr->current_floor_ptr->dun_level * 3 / 2), SUMMON_MOLD, 0L);
3787         }
3788         else if (die < 84)
3789         {
3790                 msg_print(_("友好的なモンスターの絵だ。", "It's the picture of a friendly monster."));
3791                 trump_summoning(1, TRUE, caster_ptr->y, caster_ptr->x, (caster_ptr->current_floor_ptr->dun_level * 3 / 2), SUMMON_BAT, 0L);
3792         }
3793         else if (die < 86)
3794         {
3795                 msg_print(_("友好的なモンスターの絵だ。", "It's the picture of a friendly monster."));
3796                 trump_summoning(1, TRUE, caster_ptr->y, caster_ptr->x, (caster_ptr->current_floor_ptr->dun_level * 3 / 2), SUMMON_VORTEX, 0L);
3797         }
3798         else if (die < 88)
3799         {
3800                 msg_print(_("友好的なモンスターの絵だ。", "It's the picture of a friendly monster."));
3801                 trump_summoning(1, TRUE, caster_ptr->y, caster_ptr->x, (caster_ptr->current_floor_ptr->dun_level * 3 / 2), SUMMON_COIN_MIMIC, 0L);
3802         }
3803         else if (die < 96)
3804         {
3805                 msg_print(_("《恋人》だ。", "It's the Lovers."));
3806
3807                 if (get_aim_dir(&dir))
3808                         charm_monster(dir, MIN(caster_ptr->lev, 20));
3809         }
3810         else if (die < 101)
3811         {
3812                 msg_print(_("《隠者》だ。", "It's the Hermit."));
3813                 wall_stone();
3814         }
3815         else if (die < 111)
3816         {
3817                 msg_print(_("《審判》だ。", "It's the Judgement."));
3818                 roll_hitdice(caster_ptr, 0L);
3819                 lose_all_mutations(caster_ptr);
3820         }
3821         else if (die < 120)
3822         {
3823                 msg_print(_("《太陽》だ。", "It's the Sun."));
3824                 chg_virtue(caster_ptr, V_KNOWLEDGE, 1);
3825                 chg_virtue(caster_ptr, V_ENLIGHTEN, 1);
3826                 wiz_lite(caster_ptr, FALSE);
3827         }
3828         else
3829         {
3830                 msg_print(_("《世界》だ。", "It's the World."));
3831                 if (caster_ptr->exp < PY_MAX_EXP)
3832                 {
3833                         s32b ee = (caster_ptr->exp / 25) + 1;
3834                         if (ee > 5000) ee = 5000;
3835                         msg_print(_("更に経験を積んだような気がする。", "You feel more experienced."));
3836                         gain_exp(caster_ptr, ee);
3837                 }
3838         }
3839 }
3840
3841 /*!
3842  * @brief 口を使う継続的な処理を中断する
3843  * @return なし
3844  */
3845 void stop_mouth(void)
3846 {
3847         if (music_singing_any(p_ptr)) stop_singing(p_ptr);
3848         if (hex_spelling_any(p_ptr)) stop_hex_spell_all();
3849 }
3850
3851
3852 bool_hack vampirism(void)
3853 {
3854         DIRECTION dir;
3855         POSITION x, y;
3856         int dummy;
3857         grid_type *g_ptr;
3858
3859         if (d_info[p_ptr->dungeon_idx].flags1 & DF1_NO_MELEE)
3860         {
3861                 msg_print(_("なぜか攻撃することができない。", "Something prevent you from attacking."));
3862                 return FALSE;
3863         }
3864
3865         /* Only works on adjacent monsters */
3866         if (!get_direction(&dir, FALSE, FALSE)) return FALSE;
3867         y = p_ptr->y + ddy[dir];
3868         x = p_ptr->x + ddx[dir];
3869         g_ptr = &p_ptr->current_floor_ptr->grid_array[y][x];
3870
3871         stop_mouth();
3872
3873         if (!(g_ptr->m_idx))
3874         {
3875                 msg_print(_("何もない場所に噛みついた！", "You bite into thin air!"));
3876                 return FALSE;
3877         }
3878
3879         msg_print(_("あなたはニヤリとして牙をむいた...", "You grin and bare your fangs..."));
3880
3881         dummy = p_ptr->lev * 2;
3882
3883         if (hypodynamic_bolt(dir, dummy))
3884         {
3885                 if (p_ptr->food < PY_FOOD_FULL)
3886                         /* No heal if we are "full" */
3887                         (void)hp_player(p_ptr, dummy);
3888                 else
3889                         msg_print(_("あなたは空腹ではありません。", "You were not hungry."));
3890
3891                 /* Gain nutritional sustenance: 150/hp drained */
3892                 /* A Food ration gives 5000 food points (by contrast) */
3893                 /* Don't ever get more than "Full" this way */
3894                 /* But if we ARE Gorged,  it won't cure us */
3895                 dummy = p_ptr->food + MIN(5000, 100 * dummy);
3896                 if (p_ptr->food < PY_FOOD_MAX)   /* Not gorged already */
3897                         (void)set_food(p_ptr, dummy >= PY_FOOD_MAX ? PY_FOOD_MAX - 1 : dummy);
3898         }
3899         else
3900                 msg_print(_("げぇ！ひどい味だ。", "Yechh. That tastes foul."));
3901         return TRUE;
3902 }
3903
3904 bool panic_hit(void)
3905 {
3906         DIRECTION dir;
3907         POSITION x, y;
3908
3909         if (!get_direction(&dir, FALSE, FALSE)) return FALSE;
3910         y = p_ptr->y + ddy[dir];
3911         x = p_ptr->x + ddx[dir];
3912         if (p_ptr->current_floor_ptr->grid_array[y][x].m_idx)
3913         {
3914                 py_attack(p_ptr, y, x, 0);
3915                 if (randint0(p_ptr->skill_dis) < 7)
3916                         msg_print(_("うまく逃げられなかった。", "You failed to run away."));
3917                 else
3918                         teleport_player(30, 0L);
3919                 return TRUE;
3920         }
3921         else
3922         {
3923                 msg_print(_("その方向にはモンスターはいません。", "You don't see any monster in this direction"));
3924                 msg_print(NULL);
3925                 return FALSE;
3926         }
3927
3928 }
3929
3930 /*!
3931 * @brief 超能力者のサイコメトリー処理/ Forcibly pseudo-identify an object in the p_ptr->inventory_list (or on the floor)
3932 * @return なし
3933 * @note
3934 * currently this function allows pseudo-id of any object,
3935 * including silly ones like potions & scrolls, which always
3936 * get '{average}'. This should be changed, either to stop such
3937 * items from being pseudo-id'd, or to allow psychometry to
3938 * detect whether the unidentified potion/scroll/etc is
3939 * good (Cure Light Wounds, Restore Strength, etc) or
3940 * bad (Poison, Weakness etc) or 'useless' (Slime Mold Juice, etc).
3941 */
3942 bool psychometry(void)
3943 {
3944         OBJECT_IDX      item;
3945         object_type *o_ptr;
3946         GAME_TEXT o_name[MAX_NLEN];
3947         byte            feel;
3948         concptr            q, s;
3949         bool okay = FALSE;
3950
3951         q = _("どのアイテムを調べますか？", "Meditate on which item? ");
3952         s = _("調べるアイテムがありません。", "You have nothing appropriate.");
3953
3954         o_ptr = choose_object(p_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), 0);
3955         if (!o_ptr) return (FALSE);
3956
3957         /* It is fully known, no information needed */
3958         if (object_is_known(o_ptr))
3959         {
3960                 msg_print(_("何も新しいことは判らなかった。", "You cannot find out anything more about that."));
3961                 return TRUE;
3962         }
3963
3964         /* Check for a feeling */
3965         feel = value_check_aux1(o_ptr);
3966
3967         /* Get an object description */
3968         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
3969
3970         /* Skip non-feelings */
3971         if (!feel)
3972         {
3973                 msg_format(_("%sからは特に変わった事は感じとれなかった。", "You do not perceive anything unusual about the %s."), o_name);
3974                 return TRUE;
3975         }
3976
3977 #ifdef JP
3978         msg_format("%sは%sという感じがする...", o_name, game_inscriptions[feel]);
3979 #else
3980         msg_format("You feel that the %s %s %s...",
3981                 o_name, ((o_ptr->number == 1) ? "is" : "are"), game_inscriptions[feel]);
3982 #endif
3983
3984
3985         o_ptr->ident |= (IDENT_SENSE);
3986         o_ptr->feeling = feel;
3987         o_ptr->marked |= OM_TOUCHED;
3988
3989         p_ptr->update |= (PU_COMBINE | PU_REORDER);
3990         p_ptr->window |= (PW_INVEN | PW_EQUIP | PW_PLAYER);
3991
3992         /* Valid "tval" codes */
3993         switch (o_ptr->tval)
3994         {
3995         case TV_SHOT:
3996         case TV_ARROW:
3997         case TV_BOLT:
3998         case TV_BOW:
3999         case TV_DIGGING:
4000         case TV_HAFTED:
4001         case TV_POLEARM:
4002         case TV_SWORD:
4003         case TV_BOOTS:
4004         case TV_GLOVES:
4005         case TV_HELM:
4006         case TV_CROWN:
4007         case TV_SHIELD:
4008         case TV_CLOAK:
4009         case TV_SOFT_ARMOR:
4010         case TV_HARD_ARMOR:
4011         case TV_DRAG_ARMOR:
4012         case TV_CARD:
4013         case TV_RING:
4014         case TV_AMULET:
4015         case TV_LITE:
4016         case TV_FIGURINE:
4017                 okay = TRUE;
4018                 break;
4019         }
4020
4021         /* Auto-inscription/destroy */
4022         autopick_alter_item(item, (bool)(okay && destroy_feeling));
4023
4024         /* Something happened */
4025         return (TRUE);
4026 }
4027
4028
4029 bool draconian_breath(player_type *creature_ptr)
4030 {
4031         DIRECTION dir;
4032         int Type = (one_in_(3) ? GF_COLD : GF_FIRE);
4033         concptr Type_desc = ((Type == GF_COLD) ? _("冷気", "cold") : _("炎", "fire"));
4034
4035         if (!get_aim_dir(&dir)) return FALSE;
4036
4037         if (randint1(100) < creature_ptr->lev)
4038         {
4039                 switch (creature_ptr->pclass)
4040                 {
4041                 case CLASS_WARRIOR:
4042                 case CLASS_BERSERKER:
4043                 case CLASS_RANGER:
4044                 case CLASS_TOURIST:
4045                 case CLASS_IMITATOR:
4046                 case CLASS_ARCHER:
4047                 case CLASS_SMITH:
4048                         if (one_in_(3))
4049                         {
4050                                 Type = GF_MISSILE;
4051                                 Type_desc = _("エレメント", "the elements");
4052                         }
4053                         else
4054                         {
4055                                 Type = GF_SHARDS;
4056                                 Type_desc = _("破片", "shards");
4057                         }
4058                         break;
4059                 case CLASS_MAGE:
4060                 case CLASS_WARRIOR_MAGE:
4061                 case CLASS_HIGH_MAGE:
4062                 case CLASS_SORCERER:
4063                 case CLASS_MAGIC_EATER:
4064                 case CLASS_RED_MAGE:
4065                 case CLASS_BLUE_MAGE:
4066                 case CLASS_MIRROR_MASTER:
4067                         if (one_in_(3))
4068                         {
4069                                 Type = GF_MANA;
4070                                 Type_desc = _("魔力", "mana");
4071                         }
4072                         else
4073                         {
4074                                 Type = GF_DISENCHANT;
4075                                 Type_desc = _("劣化", "disenchantment");
4076                         }
4077                         break;
4078                 case CLASS_CHAOS_WARRIOR:
4079                         if (!one_in_(3))
4080                         {
4081                                 Type = GF_CONFUSION;
4082                                 Type_desc = _("混乱", "confusion");
4083                         }
4084                         else
4085                         {
4086                                 Type = GF_CHAOS;
4087                                 Type_desc = _("カオス", "chaos");
4088                         }
4089                         break;
4090                 case CLASS_MONK:
4091                 case CLASS_SAMURAI:
4092                 case CLASS_FORCETRAINER:
4093                         if (!one_in_(3))
4094                         {
4095                                 Type = GF_CONFUSION;
4096                                 Type_desc = _("混乱", "confusion");
4097                         }
4098                         else
4099                         {
4100                                 Type = GF_SOUND;
4101                                 Type_desc = _("轟音", "sound");
4102                         }
4103                         break;
4104                 case CLASS_MINDCRAFTER:
4105                         if (!one_in_(3))
4106                         {
4107                                 Type = GF_CONFUSION;
4108                                 Type_desc = _("混乱", "confusion");
4109                         }
4110                         else
4111                         {
4112                                 Type = GF_PSI;
4113                                 Type_desc = _("精神エネルギー", "mental energy");
4114                         }
4115                         break;
4116                 case CLASS_PRIEST:
4117                 case CLASS_PALADIN:
4118                         if (one_in_(3))
4119                         {
4120                                 Type = GF_HELL_FIRE;
4121                                 Type_desc = _("地獄の劫火", "hellfire");
4122                         }
4123                         else
4124                         {
4125                                 Type = GF_HOLY_FIRE;
4126                                 Type_desc = _("聖なる炎", "holy fire");
4127                         }
4128                         break;
4129                 case CLASS_ROGUE:
4130                 case CLASS_NINJA:
4131                         if (one_in_(3))
4132                         {
4133                                 Type = GF_DARK;
4134                                 Type_desc = _("暗黒", "darkness");
4135                         }
4136                         else
4137                         {
4138                                 Type = GF_POIS;
4139                                 Type_desc = _("毒", "poison");
4140                         }
4141                         break;
4142                 case CLASS_BARD:
4143                         if (!one_in_(3))
4144                         {
4145                                 Type = GF_SOUND;
4146                                 Type_desc = _("轟音", "sound");
4147                         }
4148                         else
4149                         {
4150                                 Type = GF_CONFUSION;
4151                                 Type_desc = _("混乱", "confusion");
4152                         }
4153                         break;
4154                 }
4155         }
4156
4157         stop_mouth();
4158         msg_format(_("あなたは%sのブレスを吐いた。", "You breathe %s."), Type_desc);
4159
4160         fire_breath(Type, dir, creature_ptr->lev * 2, (creature_ptr->lev / 15) + 1);
4161         return TRUE;
4162 }
4163
4164 bool android_inside_weapon(player_type *creature_ptr)
4165 {
4166         DIRECTION dir;
4167         if (!get_aim_dir(&dir)) return FALSE;
4168         if (creature_ptr->lev < 10)
4169         {
4170                 msg_print(_("レイガンを発射した。", "You fire your ray gun."));
4171                 fire_bolt(GF_MISSILE, dir, (creature_ptr->lev + 1) / 2);
4172         }
4173         else if (creature_ptr->lev < 25)
4174         {
4175                 msg_print(_("ブラスターを発射した。", "You fire your blaster."));
4176                 fire_bolt(GF_MISSILE, dir, creature_ptr->lev);
4177         }
4178         else if (creature_ptr->lev < 35)
4179         {
4180                 msg_print(_("バズーカを発射した。", "You fire your bazooka."));
4181                 fire_ball(GF_MISSILE, dir, creature_ptr->lev * 2, 2);
4182         }
4183         else if (creature_ptr->lev < 45)
4184         {
4185                 msg_print(_("ビームキャノンを発射した。", "You fire a beam cannon."));
4186                 fire_beam(GF_MISSILE, dir, creature_ptr->lev * 2);
4187         }
4188         else
4189         {
4190                 msg_print(_("ロケットを発射した。", "You fire a rocket."));
4191                 fire_rocket(GF_ROCKET, dir, creature_ptr->lev * 5, 2);
4192         }
4193         return TRUE;
4194 }
4195
4196 bool create_ration(player_type *crature_ptr)
4197 {
4198         object_type *q_ptr;
4199         object_type forge;
4200         q_ptr = &forge;
4201
4202         /* Create the food ration */
4203         object_prep(q_ptr, lookup_kind(TV_FOOD, SV_FOOD_RATION));
4204
4205         /* Drop the object from heaven */
4206         (void)drop_near(q_ptr, -1, crature_ptr->y, crature_ptr->x);
4207         msg_print(_("食事を料理して作った。", "You cook some food."));
4208         return TRUE;
4209 }
4210
4211 void hayagake(player_type *creature_ptr)
4212 {
4213         if (creature_ptr->action == ACTION_HAYAGAKE)
4214         {
4215                 set_action(creature_ptr, ACTION_NONE);
4216         }
4217         else
4218         {
4219                 grid_type *g_ptr = &creature_ptr->current_floor_ptr->grid_array[creature_ptr->y][creature_ptr->x];
4220                 feature_type *f_ptr = &f_info[g_ptr->feat];
4221
4222                 if (!have_flag(f_ptr->flags, FF_PROJECT) ||
4223                         (!creature_ptr->levitation && have_flag(f_ptr->flags, FF_DEEP)))
4224                 {
4225                         msg_print(_("ここでは素早く動けない。", "You cannot run in here."));
4226                 }
4227                 else
4228                 {
4229                         set_action(creature_ptr, ACTION_HAYAGAKE);
4230                 }
4231         }
4232         creature_ptr->energy_use = 0;
4233 }
4234
4235 bool double_attack(player_type *creature_ptr)
4236 {
4237         DIRECTION dir;
4238         POSITION x, y;
4239
4240         if (!get_rep_dir(&dir, FALSE)) return FALSE;
4241         y = creature_ptr->y + ddy[dir];
4242         x = creature_ptr->x + ddx[dir];
4243         if (creature_ptr->current_floor_ptr->grid_array[y][x].m_idx)
4244         {
4245                 if (one_in_(3))
4246                         msg_print(_("あーたたたたたたたたたたたたたたたたたたたたたた！！！",
4247                                 "Ahhhtatatatatatatatatatatatatatataatatatatattaaaaa!!!!"));
4248                 else if(one_in_(2))
4249                         msg_print(_("無駄無駄無駄無駄無駄無駄無駄無駄無駄無駄無駄無駄！！！",
4250                                 "Mudamudamudamudamudamudamudamudamudamudamudamudamuda!!!!"));
4251                 else
4252                         msg_print(_("オラオラオラオラオラオラオラオラオラオラオラオラ！！！",
4253                                 "Oraoraoraoraoraoraoraoraoraoraoraoraoraoraoraoraora!!!!"));
4254
4255                 py_attack(creature_ptr, y, x, 0);
4256                 if (creature_ptr->current_floor_ptr->grid_array[y][x].m_idx)
4257                 {
4258                         handle_stuff();
4259                         py_attack(creature_ptr, y, x, 0);
4260                 }
4261                 creature_ptr->energy_need += ENERGY_NEED();
4262         }
4263         else
4264         {
4265                 msg_print(_("その方向にはモンスターはいません。", "You don't see any monster in this direction"));
4266                 msg_print(NULL);
4267         }
4268         return TRUE;
4269 }
4270
4271 bool comvert_hp_to_mp(player_type *creature_ptr)
4272 {
4273         int gain_sp = take_hit(p_ptr, DAMAGE_USELIFE, creature_ptr->lev, _("ＨＰからＭＰへの無謀な変換", "thoughtless convertion from HP to SP"), -1) / 5;
4274         if (gain_sp)
4275         {
4276                 creature_ptr->csp += gain_sp;
4277                 if (creature_ptr->csp > creature_ptr->msp)
4278                 {
4279                         creature_ptr->csp = creature_ptr->msp;
4280                         creature_ptr->csp_frac = 0;
4281                 }
4282         }
4283         else
4284         {
4285                 msg_print(_("変換に失敗した。", "You failed to convert."));
4286         }
4287         creature_ptr->redraw |= (PR_HP | PR_MANA);
4288         return TRUE;
4289 }
4290
4291 bool comvert_mp_to_hp(player_type *creature_ptr)
4292 {
4293         if (creature_ptr->csp >= creature_ptr->lev / 5)
4294         {
4295                 creature_ptr->csp -= creature_ptr->lev / 5;
4296                 hp_player(p_ptr, creature_ptr->lev);
4297         }
4298         else
4299         {
4300                 msg_print(_("変換に失敗した。", "You failed to convert."));
4301         }
4302         creature_ptr->redraw |= (PR_HP | PR_MANA);
4303         return TRUE;
4304 }
4305
4306 bool demonic_breath(player_type *creature_ptr)
4307 {
4308         DIRECTION dir;
4309         int type = (one_in_(2) ? GF_NETHER : GF_FIRE);
4310         if (!get_aim_dir(&dir)) return FALSE;
4311         stop_mouth();
4312         msg_format(_("あなたは%sのブレスを吐いた。", "You breathe %s."), ((type == GF_NETHER) ? _("地獄", "nether") : _("火炎", "fire")));
4313         fire_breath(type, dir, creature_ptr->lev * 3, (creature_ptr->lev / 15) + 1);
4314         return TRUE;
4315 }
4316
4317 bool mirror_concentration(player_type *creature_ptr)
4318 {
4319         if (total_friends)
4320         {
4321                 msg_print(_("今はペットを操ることに集中していないと。", "You need concentration on the pets now."));
4322                 return FALSE;
4323         }
4324         if (is_mirror_grid(&p_ptr->current_floor_ptr->grid_array[creature_ptr->y][creature_ptr->x]))
4325         {
4326                 msg_print(_("少し頭がハッキリした。", "You feel your head clear a little."));
4327
4328                 creature_ptr->csp += (5 + creature_ptr->lev * creature_ptr->lev / 100);
4329                 if (creature_ptr->csp >= creature_ptr->msp)
4330                 {
4331                         creature_ptr->csp = creature_ptr->msp;
4332                         creature_ptr->csp_frac = 0;
4333                 }
4334                 creature_ptr->redraw |= (PR_MANA);
4335         }
4336         else
4337         {
4338                 msg_print(_("鏡の上でないと集中できない！", "Here are not any mirrors!"));
4339         }
4340         return TRUE;
4341 }
4342
4343 bool sword_dancing(player_type *creature_ptr)
4344 {
4345         DIRECTION dir;
4346         POSITION y = 0, x = 0;
4347         int i;
4348         grid_type *g_ptr;
4349
4350         for (i = 0; i < 6; i++)
4351         {
4352                 dir = randint0(8);
4353                 y = creature_ptr->y + ddy_ddd[dir];
4354                 x = creature_ptr->x + ddx_ddd[dir];
4355                 g_ptr = &p_ptr->current_floor_ptr->grid_array[y][x];
4356
4357                 /* Hack -- attack monsters */
4358                 if (g_ptr->m_idx)
4359                         py_attack(p_ptr, y, x, 0);
4360                 else
4361                 {
4362                         msg_print(_("攻撃が空をきった。", "You attack the empty air."));
4363                 }
4364         }
4365         return TRUE;
4366 }
4367
4368 bool confusing_light(player_type *creature_ptr)
4369 {
4370         msg_print(_("辺りを睨んだ...", "You glare nearby monsters..."));
4371         slow_monsters(creature_ptr->lev);
4372         stun_monsters(creature_ptr->lev * 4);
4373         confuse_monsters(creature_ptr->lev * 4);
4374         turn_monsters(creature_ptr->lev * 4);
4375         stasis_monsters(creature_ptr->lev * 4);
4376         return TRUE;
4377 }
4378
4379 bool rodeo(player_type *creature_ptr)
4380 {
4381         GAME_TEXT m_name[MAX_NLEN];
4382         monster_type *m_ptr;
4383         monster_race *r_ptr;
4384         int rlev;
4385
4386         if (creature_ptr->riding)
4387         {
4388                 msg_print(_("今は乗馬中だ。", "You ARE riding."));
4389                 return FALSE;
4390         }
4391         if (!do_cmd_riding(creature_ptr, TRUE)) return TRUE;
4392
4393         m_ptr = &p_ptr->current_floor_ptr->m_list[creature_ptr->riding];
4394         r_ptr = &r_info[m_ptr->r_idx];
4395         monster_desc(m_name, m_ptr, 0);
4396         msg_format(_("%sに乗った。", "You ride on %s."), m_name);
4397
4398         if (is_pet(m_ptr)) return TRUE;
4399
4400         rlev = r_ptr->level;
4401
4402         if (r_ptr->flags1 & RF1_UNIQUE) rlev = rlev * 3 / 2;
4403         if (rlev > 60) rlev = 60 + (rlev - 60) / 2;
4404         if ((randint1(creature_ptr->skill_exp[GINOU_RIDING] / 120 + creature_ptr->lev * 2 / 3) > rlev)
4405                 && one_in_(2) && !creature_ptr->inside_arena && !creature_ptr->phase_out
4406                 && !(r_ptr->flags7 & (RF7_GUARDIAN)) && !(r_ptr->flags1 & (RF1_QUESTOR))
4407                 && (rlev < creature_ptr->lev * 3 / 2 + randint0(creature_ptr->lev / 5)))
4408         {
4409                 msg_format(_("%sを手なずけた。", "You tame %s."), m_name);
4410                 set_pet(m_ptr);
4411         }
4412         else
4413         {
4414                 msg_format(_("%sに振り落とされた！", "You have thrown off by %s."), m_name);
4415                 rakuba(p_ptr, 1, TRUE);
4416                 /* 落馬処理に失敗してもとにかく乗馬解除 */
4417                 creature_ptr->riding = 0;
4418         }
4419         return TRUE;
4420 }
4421
4422 bool clear_mind(player_type *creature_ptr)
4423 {
4424         if (total_friends)
4425         {
4426                 msg_print(_("今はペットを操ることに集中していないと。", "You need concentration on the pets now."));
4427                 return FALSE;
4428         }
4429         msg_print(_("少し頭がハッキリした。", "You feel your head clear a little."));
4430
4431         creature_ptr->csp += (3 + creature_ptr->lev / 20);
4432         if (creature_ptr->csp >= creature_ptr->msp)
4433         {
4434                 creature_ptr->csp = creature_ptr->msp;
4435                 creature_ptr->csp_frac = 0;
4436         }
4437         creature_ptr->redraw |= (PR_MANA);
4438         return TRUE;
4439 }
4440
4441 bool concentration(player_type *creature_ptr)
4442 {
4443         int max_csp = MAX(creature_ptr->msp * 4, creature_ptr->lev * 5 + 5);
4444
4445         if (total_friends)
4446         {
4447                 msg_print(_("今はペットを操ることに集中していないと。", "You need concentration on the pets now."));
4448                 return FALSE;
4449         }
4450         if (creature_ptr->special_defense & KATA_MASK)
4451         {
4452                 msg_print(_("今は構えに集中している。", "You need concentration on your form."));
4453                 return FALSE;
4454         }
4455         msg_print(_("精神を集中して気合いを溜めた。", "You concentrate to charge your power."));
4456
4457         creature_ptr->csp += creature_ptr->msp / 2;
4458         if (creature_ptr->csp >= max_csp)
4459         {
4460                 creature_ptr->csp = max_csp;
4461                 creature_ptr->csp_frac = 0;
4462         }
4463         creature_ptr->redraw |= (PR_MANA);
4464         return TRUE;
4465 }