src/cmd1.c

   1 /* File: cmd1.c */
   2
   3 /*
   4  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   5  *
   6  * This software may be copied and distributed for educational, research,
   7  * and not for profit purposes provided that this copyright and statement
   8  * are included in all such copies.  Other copyrights may also apply.
   9  */
  10
  11 /* Purpose: Movement commands (part 1) */
  12
  13 #include "angband.h"
  14 #define MAX_VAMPIRIC_DRAIN 50
  15
  16
  17 /*
  18  * Determine if the player "hits" a monster (normal combat).
  19  * Note -- Always miss 5%, always hit 5%, otherwise random.
  20  */
  21 bool test_hit_fire(int chance, int ac, int vis)
  22 {
  23         int k;
  24
  25         /* Percentile dice */
  26         k = randint0(100);
  27
  28         /* Hack -- Instant miss or hit */
  29         if (k < 10) return (k < 5);
  30
  31         if (p_ptr->pseikaku == SEIKAKU_NAMAKE)
  32                 if (one_in_(20)) return (FALSE);
  33
  34         /* Never hit */
  35         if (chance <= 0) return (FALSE);
  36
  37         /* Invisible monsters are harder to hit */
  38         if (!vis) chance = (chance + 1) / 2;
  39
  40         /* Power competes against armor */
  41         if (randint0(chance) < (ac * 3 / 4)) return (FALSE);
  42
  43         /* Assume hit */
  44         return (TRUE);
  45 }
  46
  47
  48
  49 /*
  50  * Determine if the player "hits" a monster (normal combat).
  51  *
  52  * Note -- Always miss 5%, always hit 5%, otherwise random.
  53  */
  54 bool test_hit_norm(int chance, int ac, int vis)
  55 {
  56         int k;
  57
  58         /* Percentile dice */
  59         k = randint0(100);
  60
  61         /* Hack -- Instant miss or hit */
  62         if (k < 10) return (k < 5);
  63
  64         if (p_ptr->pseikaku == SEIKAKU_NAMAKE)
  65                 if (one_in_(20)) return (FALSE);
  66
  67         /* Wimpy attack never hits */
  68         if (chance <= 0) return (FALSE);
  69
  70         /* Penalize invisible targets */
  71         if (!vis) chance = (chance + 1) / 2;
  72
  73         /* Power must defeat armor */
  74         if (randint0(chance) < (ac * 3 / 4)) return (FALSE);
  75
  76         /* Assume hit */
  77         return (TRUE);
  78 }
  79
  80
  81
  82 /*
  83  * Critical hits (from objects thrown by player)
  84  * Factor in item weight, total plusses, and player level.
  85  */
  86 s16b critical_shot(int weight, int plus, int dam)
  87 {
  88         int i, k;
  89
  90         /* Extract "shot" power */
  91         i = ((p_ptr->to_h_b + plus) * 4) + (p_ptr->lev * 2);
  92
  93         /* Snipers can shot more critically with crossbows */
  94         if (p_ptr->concent) i += ((i * p_ptr->concent) / 5);
  95         if ((p_ptr->pclass == CLASS_SNIPER) && (p_ptr->tval_ammo == TV_BOLT)) i *= 2;
  96
  97         /* Critical hit */
  98         if (randint1(5000) <= i)
  99         {
 100                 k = weight * randint1(500);
 101
 102                 if (k < 900)
 103                 {
 104 #ifdef JP
 105                         msg_print("¼ê¤´¤¿¤¨¤¬¤¢¤Ã¤¿¡ª");
 106 #else
 107                         msg_print("It was a good hit!");
 108 #endif
 109
 110                         dam += (dam / 2);
 111                 }
 112                 else if (k < 1350)
 113                 {
 114 #ifdef JP
 115                         msg_print("¤«¤Ê¤ê¤Î¼ê¤´¤¿¤¨¤¬¤¢¤Ã¤¿¡ª");
 116 #else
 117                         msg_print("It was a great hit!");
 118 #endif
 119
 120                         dam *= 2;
 121                 }
 122                 else
 123                 {
 124 #ifdef JP
 125                         msg_print("²ñ¿´¤Î°ì·â¤À¡ª");
 126 #else
 127                         msg_print("It was a superb hit!");
 128 #endif
 129
 130                         dam *= 3;
 131                 }
 132         }
 133
 134         return (dam);
 135 }
 136
 137
 138
 139 /*
 140  * Critical hits (by player)
 141  *
 142  * Factor in weapon weight, total plusses, player level.
 143  */
 144 s16b critical_norm(int weight, int plus, int dam, s16b meichuu, int mode)
 145 {
 146         int i, k;
 147
 148         /* Extract "blow" power */
 149         i = (weight + (meichuu * 3 + plus * 5) + (p_ptr->lev * 3));
 150
 151         /* Chance */
 152         if ((randint1((p_ptr->pclass == CLASS_NINJA) ? 4444 : 5000) <= i) || (mode == HISSATSU_MAJIN) || (mode == HISSATSU_3DAN))
 153         {
 154                 k = weight + randint1(650);
 155                 if ((mode == HISSATSU_MAJIN) || (mode == HISSATSU_3DAN)) k+= randint1(650);
 156
 157                 if (k < 400)
 158                 {
 159 #ifdef JP
 160                         msg_print("¼ê¤´¤¿¤¨¤¬¤¢¤Ã¤¿¡ª");
 161 #else
 162                         msg_print("It was a good hit!");
 163 #endif
 164
 165                         dam = 2 * dam + 5;
 166                 }
 167                 else if (k < 700)
 168                 {
 169 #ifdef JP
 170                         msg_print("¤«¤Ê¤ê¤Î¼ê¤´¤¿¤¨¤¬¤¢¤Ã¤¿¡ª");
 171 #else
 172                         msg_print("It was a great hit!");
 173 #endif
 174
 175                         dam = 2 * dam + 10;
 176                 }
 177                 else if (k < 900)
 178                 {
 179 #ifdef JP
 180                         msg_print("²ñ¿´¤Î°ì·â¤À¡ª");
 181 #else
 182                         msg_print("It was a superb hit!");
 183 #endif
 184
 185                         dam = 3 * dam + 15;
 186                 }
 187                 else if (k < 1300)
 188                 {
 189 #ifdef JP
 190                         msg_print("ºÇ¹â¤Î²ñ¿´¤Î°ì·â¤À¡ª");
 191 #else
 192                         msg_print("It was a *GREAT* hit!");
 193 #endif
 194
 195                         dam = 3 * dam + 20;
 196                 }
 197                 else
 198                 {
 199 #ifdef JP
 200                         msg_print("ÈæÎà¤Ê¤ºÇ¹â¤Î²ñ¿´¤Î°ì·â¤À¡ª");
 201 #else
 202                         msg_print("It was a *SUPERB* hit!");
 203 #endif
 204
 205                         dam = ((7 * dam) / 2) + 25;
 206                 }
 207         }
 208
 209         return (dam);
 210 }
 211
 212
 213
 214 /*
 215  * Extract the "total damage" from a given object hitting a given monster.
 216  *
 217  * Note that "flasks of oil" do NOT do fire damage, although they
 218  * certainly could be made to do so.  XXX XXX
 219  *
 220  * Note that most brands and slays are x3, except Slay Animal (x2),
 221  * Slay Evil (x2), and Kill dragon (x5).
 222  */
 223 s16b tot_dam_aux(object_type *o_ptr, int tdam, monster_type *m_ptr, int mode, bool thrown)
 224 {
 225         int mult = 10;
 226
 227         monster_race *r_ptr = &r_info[m_ptr->r_idx];
 228
 229         u32b flgs[TR_FLAG_SIZE];
 230
 231         /* Extract the flags */
 232         object_flags(o_ptr, flgs);
 233
 234         if (!thrown)
 235         {
 236                 /* Magical Swords */
 237                 if (p_ptr->special_attack & (ATTACK_ACID)) add_flag(flgs, TR_BRAND_ACID);
 238                 if (p_ptr->special_attack & (ATTACK_COLD)) add_flag(flgs, TR_BRAND_COLD);
 239                 if (p_ptr->special_attack & (ATTACK_ELEC)) add_flag(flgs, TR_BRAND_ELEC);
 240                 if (p_ptr->special_attack & (ATTACK_FIRE)) add_flag(flgs, TR_BRAND_FIRE);
 241                 if (p_ptr->special_attack & (ATTACK_POIS)) add_flag(flgs, TR_BRAND_POIS);
 242         }
 243
 244         /* Some "weapons" and "ammo" do extra damage */
 245         switch (o_ptr->tval)
 246         {
 247                 case TV_SHOT:
 248                 case TV_ARROW:
 249                 case TV_BOLT:
 250                 case TV_HAFTED:
 251                 case TV_POLEARM:
 252                 case TV_SWORD:
 253                 case TV_DIGGING:
 254                 {
 255                         /* Slay Animal */
 256                         if ((have_flag(flgs, TR_SLAY_ANIMAL)) &&
 257                             (r_ptr->flags3 & RF3_ANIMAL))
 258                         {
 259                                 if (is_original_ap_and_seen(m_ptr))
 260                                 {
 261                                         r_ptr->r_flags3 |= RF3_ANIMAL;
 262                                 }
 263
 264                                 if (mult < 25) mult = 25;
 265                         }
 266
 267                         /* Execute Animal */
 268                         if ((have_flag(flgs, TR_KILL_ANIMAL)) &&
 269                             (r_ptr->flags3 & RF3_ANIMAL))
 270                         {
 271                                 if (is_original_ap_and_seen(m_ptr))
 272                                 {
 273                                         r_ptr->r_flags3 |= RF3_ANIMAL;
 274                                 }
 275
 276                                 if (mult < 40) mult = 40;
 277                         }
 278
 279                         /* Slay Evil */
 280                         if ((have_flag(flgs, TR_SLAY_EVIL)) &&
 281                             (r_ptr->flags3 & RF3_EVIL))
 282                         {
 283                                 if (is_original_ap_and_seen(m_ptr))
 284                                 {
 285                                         r_ptr->r_flags3 |= RF3_EVIL;
 286                                 }
 287
 288                                 if (mult < 20) mult = 20;
 289                         }
 290
 291                         /* Execute Evil */
 292                         if ((have_flag(flgs, TR_KILL_EVIL)) &&
 293                             (r_ptr->flags3 & RF3_EVIL))
 294                         {
 295                                 if (is_original_ap_and_seen(m_ptr))
 296                                 {
 297                                         r_ptr->r_flags3 |= RF3_EVIL;
 298                                 }
 299
 300                                 if (mult < 35) mult = 35;
 301                         }
 302
 303                         /* Slay Human */
 304                         if ((have_flag(flgs, TR_SLAY_HUMAN)) &&
 305                             (r_ptr->flags2 & RF2_HUMAN))
 306                         {
 307                                 if (is_original_ap_and_seen(m_ptr))
 308                                 {
 309                                         r_ptr->r_flags2 |= RF2_HUMAN;
 310                                 }
 311
 312                                 if (mult < 25) mult = 25;
 313                         }
 314
 315                         /* Execute Human */
 316                         if ((have_flag(flgs, TR_KILL_HUMAN)) &&
 317                             (r_ptr->flags2 & RF2_HUMAN))
 318                         {
 319                                 if (is_original_ap_and_seen(m_ptr))
 320                                 {
 321                                         r_ptr->r_flags2 |= RF2_HUMAN;
 322                                 }
 323
 324                                 if (mult < 40) mult = 40;
 325                         }
 326
 327                         /* Slay Undead */
 328                         if ((have_flag(flgs, TR_SLAY_UNDEAD)) &&
 329                             (r_ptr->flags3 & RF3_UNDEAD))
 330                         {
 331                                 if (is_original_ap_and_seen(m_ptr))
 332                                 {
 333                                         r_ptr->r_flags3 |= RF3_UNDEAD;
 334                                 }
 335
 336                                 if (mult < 30) mult = 30;
 337                         }
 338
 339                         /* Execute Undead */
 340                         if ((have_flag(flgs, TR_KILL_UNDEAD)) &&
 341                             (r_ptr->flags3 & RF3_UNDEAD))
 342                         {
 343                                 if (is_original_ap_and_seen(m_ptr))
 344                                 {
 345                                         r_ptr->r_flags3 |= RF3_UNDEAD;
 346                                 }
 347
 348                                 if (mult < 50) mult = 50;
 349                         }
 350
 351                         /* Slay Demon */
 352                         if ((have_flag(flgs, TR_SLAY_DEMON)) &&
 353                             (r_ptr->flags3 & RF3_DEMON))
 354                         {
 355                                 if (is_original_ap_and_seen(m_ptr))
 356                                 {
 357                                         r_ptr->r_flags3 |= RF3_DEMON;
 358                                 }
 359
 360                                 if (mult < 30) mult = 30;
 361                         }
 362
 363                         /* Execute Demon */
 364                         if ((have_flag(flgs, TR_KILL_DEMON)) &&
 365                             (r_ptr->flags3 & RF3_DEMON))
 366                         {
 367                                 if (is_original_ap_and_seen(m_ptr))
 368                                 {
 369                                         r_ptr->r_flags3 |= RF3_DEMON;
 370                                 }
 371
 372                                 if (mult < 50) mult = 50;
 373                         }
 374
 375                         /* Slay Orc */
 376                         if ((have_flag(flgs, TR_SLAY_ORC)) &&
 377                             (r_ptr->flags3 & RF3_ORC))
 378                         {
 379                                 if (is_original_ap_and_seen(m_ptr))
 380                                 {
 381                                         r_ptr->r_flags3 |= RF3_ORC;
 382                                 }
 383
 384                                 if (mult < 30) mult = 30;
 385                         }
 386
 387                         /* Execute Orc */
 388                         if ((have_flag(flgs, TR_KILL_ORC)) &&
 389                             (r_ptr->flags3 & RF3_ORC))
 390                         {
 391                                 if (is_original_ap_and_seen(m_ptr))
 392                                 {
 393                                         r_ptr->r_flags3 |= RF3_ORC;
 394                                 }
 395
 396                                 if (mult < 50) mult = 50;
 397                         }
 398
 399                         /* Slay Troll */
 400                         if ((have_flag(flgs, TR_SLAY_TROLL)) &&
 401                             (r_ptr->flags3 & RF3_TROLL))
 402                         {
 403                                 if (is_original_ap_and_seen(m_ptr))
 404                                 {
 405                                         r_ptr->r_flags3 |= RF3_TROLL;
 406                                 }
 407
 408                                 if (mult < 30) mult = 30;
 409                         }
 410
 411                         /* Execute Troll */
 412                         if ((have_flag(flgs, TR_KILL_TROLL)) &&
 413                             (r_ptr->flags3 & RF3_TROLL))
 414                         {
 415                                 if (is_original_ap_and_seen(m_ptr))
 416                                 {
 417                                         r_ptr->r_flags3 |= RF3_TROLL;
 418                                 }
 419
 420                                 if (mult < 50) mult = 50;
 421                         }
 422
 423                         /* Slay Giant */
 424                         if ((have_flag(flgs, TR_SLAY_GIANT)) &&
 425                             (r_ptr->flags3 & RF3_GIANT))
 426                         {
 427                                 if (is_original_ap_and_seen(m_ptr))
 428                                 {
 429                                         r_ptr->r_flags3 |= RF3_GIANT;
 430                                 }
 431
 432                                 if (mult < 30) mult = 30;
 433                         }
 434
 435                         /* Execute Giant */
 436                         if ((have_flag(flgs, TR_KILL_GIANT)) &&
 437                             (r_ptr->flags3 & RF3_GIANT))
 438                         {
 439                                 if (is_original_ap_and_seen(m_ptr))
 440                                 {
 441                                         r_ptr->r_flags3 |= RF3_GIANT;
 442                                 }
 443
 444                                 if (mult < 50) mult = 50;
 445                         }
 446
 447                         /* Slay Dragon  */
 448                         if ((have_flag(flgs, TR_SLAY_DRAGON)) &&
 449                             (r_ptr->flags3 & RF3_DRAGON))
 450                         {
 451                                 if (is_original_ap_and_seen(m_ptr))
 452                                 {
 453                                         r_ptr->r_flags3 |= RF3_DRAGON;
 454                                 }
 455
 456                                 if (mult < 30) mult = 30;
 457                         }
 458
 459                         /* Execute Dragon */
 460                         if ((have_flag(flgs, TR_KILL_DRAGON)) &&
 461                             (r_ptr->flags3 & RF3_DRAGON))
 462                         {
 463                                 if (is_original_ap_and_seen(m_ptr))
 464                                 {
 465                                         r_ptr->r_flags3 |= RF3_DRAGON;
 466                                 }
 467
 468                                 if (mult < 50) mult = 50;
 469
 470                                 if ((o_ptr->name1 == ART_NOTHUNG) && (m_ptr->r_idx == MON_FAFNER))
 471                                         mult *= 3;
 472                         }
 473
 474                         /* Hex - Slay Good (Runesword) */
 475                         if (hex_spelling(HEX_RUNESWORD) &&
 476                             (r_ptr->flags3 & RF3_GOOD))
 477                         {
 478                                 if (is_original_ap_and_seen(m_ptr))
 479                                 {
 480                                         r_ptr->r_flags3 |= RF3_GOOD;
 481                                 }
 482
 483                                 if (mult < 20) mult = 20;
 484                         }
 485
 486                         /* Brand (Acid) */
 487                         if (have_flag(flgs, TR_BRAND_ACID))
 488                         {
 489                                 /* Notice immunity */
 490                                 if (r_ptr->flagsr & RFR_EFF_IM_ACID_MASK)
 491                                 {
 492                                         if (is_original_ap_and_seen(m_ptr))
 493                                         {
 494                                                 r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_ACID_MASK);
 495                                         }
 496                                 }
 497
 498                                 /* Otherwise, take the damage */
 499                                 else
 500                                 {
 501                                         if (mult < 25) mult = 25;
 502                                 }
 503                         }
 504
 505                         /* Brand (Elec) */
 506                         if (have_flag(flgs, TR_BRAND_ELEC))
 507                         {
 508                                 /* Notice immunity */
 509                                 if (r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK)
 510                                 {
 511                                         if (is_original_ap_and_seen(m_ptr))
 512                                         {
 513                                                 r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_ELEC_MASK);
 514                                         }
 515                                 }
 516
 517                                 /* Otherwise, take the damage */
 518                                 else
 519                                 {
 520                                         if (mult < 25) mult = 25;
 521                                 }
 522                         }
 523
 524                         /* Brand (Fire) */
 525                         if (have_flag(flgs, TR_BRAND_FIRE))
 526                         {
 527                                 /* Notice immunity */
 528                                 if (r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK)
 529                                 {
 530                                         if (is_original_ap_and_seen(m_ptr))
 531                                         {
 532                                                 r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK);
 533                                         }
 534                                 }
 535
 536                                 /* Otherwise, take the damage */
 537                                 else
 538                                 {
 539                                         if (r_ptr->flags3 & RF3_HURT_FIRE)
 540                                         {
 541                                                 if (mult < 50) mult = 50;
 542                                                 if (is_original_ap_and_seen(m_ptr))
 543                                                 {
 544                                                         r_ptr->r_flags3 |= RF3_HURT_FIRE;
 545                                                 }
 546                                         }
 547                                         else if (mult < 25) mult = 25;
 548                                 }
 549                         }
 550
 551                         /* Brand (Cold) */
 552                         if (have_flag(flgs, TR_BRAND_COLD))
 553                         {
 554                                 /* Notice immunity */
 555                                 if (r_ptr->flagsr & RFR_EFF_IM_COLD_MASK)
 556                                 {
 557                                         if (is_original_ap_and_seen(m_ptr))
 558                                         {
 559                                                 r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_COLD_MASK);
 560                                         }
 561                                 }
 562                                 /* Otherwise, take the damage */
 563                                 else
 564                                 {
 565                                         if (r_ptr->flags3 & RF3_HURT_COLD)
 566                                         {
 567                                                 if (mult < 50) mult = 50;
 568                                                 if (is_original_ap_and_seen(m_ptr))
 569                                                 {
 570                                                         r_ptr->r_flags3 |= RF3_HURT_COLD;
 571                                                 }
 572                                         }
 573                                         else if (mult < 25) mult = 25;
 574                                 }
 575                         }
 576
 577                         /* Brand (Poison) */
 578                         if (have_flag(flgs, TR_BRAND_POIS))
 579                         {
 580                                 /* Notice immunity */
 581                                 if (r_ptr->flagsr & RFR_EFF_IM_POIS_MASK)
 582                                 {
 583                                         if (is_original_ap_and_seen(m_ptr))
 584                                         {
 585                                                 r_ptr->r_flagsr |= (r_ptr->flagsr & RFR_EFF_IM_POIS_MASK);
 586                                         }
 587                                 }
 588
 589                                 /* Otherwise, take the damage */
 590                                 else
 591                                 {
 592                                         if (mult < 25) mult = 25;
 593                                 }
 594                         }
 595
 596                         /* Hissatsu */
 597                         if (p_ptr->pclass == CLASS_SAMURAI)
 598                         {
 599                                 mult = mult_hissatsu(mult, flgs, m_ptr, mode);
 600 plog(format("mult = %d", mult));
 601                         }
 602
 603                         if ((p_ptr->pclass != CLASS_SAMURAI) && (have_flag(flgs, TR_FORCE_WEAPON)) && (p_ptr->csp > (o_ptr->dd * o_ptr->ds / 5)))
 604                         {
 605                                 p_ptr->csp -= (1+(o_ptr->dd * o_ptr->ds / 5));
 606                                 p_ptr->redraw |= (PR_MANA);
 607                                 mult = mult * 3 / 2 + 20;
 608                         }
 609                         break;
 610                 }
 611         }
 612         if (mult > 150) mult = 150;
 613
 614         /* Return the total damage */
 615         return (tdam * mult / 10);
 616 }
 617
 618
 619 /*
 620  * Search for hidden things
 621  */
 622 void search(void)
 623 {
 624         int y, x, chance;
 625
 626         s16b this_o_idx, next_o_idx = 0;
 627
 628         cave_type *c_ptr;
 629
 630
 631         /* Start with base search ability */
 632         chance = p_ptr->skill_srh;
 633
 634         /* Penalize various conditions */
 635         if (p_ptr->blind || no_lite()) chance = chance / 10;
 636         if (p_ptr->confused || p_ptr->image) chance = chance / 10;
 637
 638         /* Search the nearby grids, which are always in bounds */
 639         for (y = (py - 1); y <= (py + 1); y++)
 640         {
 641                 for (x = (px - 1); x <= (px + 1); x++)
 642                 {
 643                         /* Sometimes, notice things */
 644                         if (randint0(100) < chance)
 645                         {
 646                                 /* Access the grid */
 647                                 c_ptr = &cave[y][x];
 648
 649                                 /* Invisible trap */
 650                                 if (c_ptr->mimic && is_trap(c_ptr->feat))
 651                                 {
 652                                         /* Pick a trap */
 653                                         disclose_grid(y, x);
 654
 655                                         /* Message */
 656 #ifdef JP
 657                                         msg_print("¥È¥é¥Ã¥×¤òÈ¯¸«¤·¤¿¡£");
 658 #else
 659                                         msg_print("You have found a trap.");
 660 #endif
 661
 662                                         /* Disturb */
 663                                         disturb(0, 1);
 664                                 }
 665
 666                                 /* Secret door */
 667                                 if (is_hidden_door(c_ptr))
 668                                 {
 669                                         /* Message */
 670 #ifdef JP
 671                                         msg_print("±£¤·¥É¥¢¤òÈ¯¸«¤·¤¿¡£");
 672 #else
 673                                         msg_print("You have found a secret door.");
 674 #endif
 675
 676                                         /* Disclose */
 677                                         disclose_grid(y, x);
 678
 679                                         /* Disturb */
 680                                         disturb(0, 0);
 681                                 }
 682
 683                                 /* Scan all objects in the grid */
 684                                 for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 685                                 {
 686                                         object_type *o_ptr;
 687
 688                                         /* Acquire object */
 689                                         o_ptr = &o_list[this_o_idx];
 690
 691                                         /* Acquire next object */
 692                                         next_o_idx = o_ptr->next_o_idx;
 693
 694                                         /* Skip non-chests */
 695                                         if (o_ptr->tval != TV_CHEST) continue;
 696
 697                                         /* Skip non-trapped chests */
 698                                         if (!chest_traps[o_ptr->pval]) continue;
 699
 700                                         /* Identify once */
 701                                         if (!object_is_known(o_ptr))
 702                                         {
 703                                                 /* Message */
 704 #ifdef JP
 705                                                 msg_print("È¢¤Ë»Å³Ý¤±¤é¤ì¤¿¥È¥é¥Ã¥×¤òÈ¯¸«¤·¤¿¡ª");
 706 #else
 707                                                 msg_print("You have discovered a trap on the chest!");
 708 #endif
 709
 710                                                 /* Know the trap */
 711                                                 object_known(o_ptr);
 712
 713                                                 /* Notice it */
 714                                                 disturb(0, 0);
 715                                         }
 716                                 }
 717                         }
 718                 }
 719         }
 720 }
 721
 722
 723 /*
 724  * Helper routine for py_pickup() and py_pickup_floor().
 725  *
 726  * Add the given dungeon object to the character's inventory.
 727  *
 728  * Delete the object afterwards.
 729  */
 730 void py_pickup_aux(int o_idx)
 731 {
 732         int slot, i;
 733
 734 #ifdef JP
 735 /*
 736  * ¥¢¥¤¥Æ¥à¤ò½¦¤Ã¤¿ºÝ¤Ë¡Ö£²¤Ä¤Î¥±¡¼¥¤ò»ý¤Ã¤Æ¤¤¤ë¡×
 737  * "You have two cakes." ¤È¥¢¥¤¥Æ¥à¤ò½¦¤Ã¤¿¸å¤Î¹ç·×¤Î¤ß¤ÎÉ½¼¨¤¬¥ª¥ê¥¸¥Ê¥ë
 738  * ¤À¤¬¡¢°ãÏÂ´¶¤¬
 739  * ¤¢¤ë¤È¤¤¤¦»ØÅ¦¤ò¤¦¤±¤¿¤Î¤Ç¡¢¡Ö¡Á¤ò½¦¤Ã¤¿¡¢¡Á¤ò»ý¤Ã¤Æ¤¤¤ë¡×¤È¤¤¤¦É½¼¨
 740  * ¤Ë¤«¤¨¤Æ¤¢¤ë¡£¤½¤Î¤¿¤á¤ÎÇÛÎó¡£
 741  */
 742         char o_name[MAX_NLEN];
 743         char old_name[MAX_NLEN];
 744         char kazu_str[80];
 745         int hirottakazu;
 746 #else
 747         char o_name[MAX_NLEN];
 748 #endif
 749
 750         object_type *o_ptr;
 751
 752         o_ptr = &o_list[o_idx];
 753
 754 #ifdef JP
 755         /* Describe the object */
 756         object_desc(old_name, o_ptr, OD_NAME_ONLY);
 757         object_desc_kosuu(kazu_str, o_ptr);
 758         hirottakazu = o_ptr->number;
 759 #endif
 760         /* Carry the object */
 761         slot = inven_carry(o_ptr);
 762
 763         /* Get the object again */
 764         o_ptr = &inventory[slot];
 765
 766         /* Delete the object */
 767         delete_object_idx(o_idx);
 768
 769         if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN)
 770         {
 771                 bool old_known = identify_item(o_ptr);
 772
 773                 /* Auto-inscription/destroy */
 774                 autopick_alter_item(slot, (bool)(destroy_identify && !old_known));
 775
 776                 /* If it is destroyed, don't pick it up */
 777                 if (o_ptr->marked & OM_AUTODESTROY) return;
 778         }
 779
 780         /* Describe the object */
 781         object_desc(o_name, o_ptr, 0);
 782
 783         /* Message */
 784 #ifdef JP
 785         if ((o_ptr->name1 == ART_CRIMSON) && (p_ptr->pseikaku == SEIKAKU_COMBAT))
 786         {
 787                 msg_format("¤³¤¦¤·¤Æ¡¢%s¤Ï¡Ø¥¯¥ê¥à¥¾¥ó¡Ù¤ò¼ê¤ËÆþ¤ì¤¿¡£", player_name);
 788                 msg_print("¤·¤«¤·º£¡¢¡Øº®ÆÙ¤Î¥µ¡¼¥Ú¥ó¥È¡Ù¤ÎÊü¤Ã¤¿¥â¥ó¥¹¥¿¡¼¤¬¡¢");
 789                 msg_format("%s¤Ë½±¤¤¤«¤«¤ë¡¥¡¥¡¥", player_name);
 790         }
 791         else
 792         {
 793                 if (plain_pickup)
 794                 {
 795                         msg_format("%s(%c)¤ò»ý¤Ã¤Æ¤¤¤ë¡£",o_name, index_to_label(slot));
 796                 }
 797                 else
 798                 {
 799                         if (o_ptr->number > hirottakazu) {
 800                             msg_format("%s½¦¤Ã¤Æ¡¢%s(%c)¤ò»ý¤Ã¤Æ¤¤¤ë¡£",
 801                                kazu_str, o_name, index_to_label(slot));
 802                         } else {
 803                                 msg_format("%s(%c)¤ò½¦¤Ã¤¿¡£", o_name, index_to_label(slot));
 804                         }
 805                 }
 806         }
 807         strcpy(record_o_name, old_name);
 808 #else
 809         msg_format("You have %s (%c).", o_name, index_to_label(slot));
 810         strcpy(record_o_name, o_name);
 811 #endif
 812         record_turn = turn;
 813
 814
 815         /* Check if completed a quest */
 816         for (i = 0; i < max_quests; i++)
 817         {
 818                 if ((quest[i].type == QUEST_TYPE_FIND_ARTIFACT) &&
 819                     (quest[i].status == QUEST_STATUS_TAKEN) &&
 820                            (quest[i].k_idx == o_ptr->name1))
 821                 {
 822                         if (record_fix_quest) do_cmd_write_nikki(NIKKI_FIX_QUEST_C, i, NULL);
 823                         quest[i].status = QUEST_STATUS_COMPLETED;
 824                         quest[i].complev = (byte)p_ptr->lev;
 825 #ifdef JP
 826                         msg_print("¥¯¥¨¥¹¥È¤òÃ£À®¤·¤¿¡ª");
 827 #else
 828                         msg_print("You completed your quest!");
 829 #endif
 830
 831                         msg_print(NULL);
 832                 }
 833         }
 834 }
 835
 836
 837 /*
 838  * Player "wants" to pick up an object or gold.
 839  * Note that we ONLY handle things that can be picked up.
 840  * See "move_player()" for handling of other things.
 841  */
 842 void carry(bool pickup)
 843 {
 844         cave_type *c_ptr = &cave[py][px];
 845
 846         s16b this_o_idx, next_o_idx = 0;
 847
 848         char    o_name[MAX_NLEN];
 849
 850         /* Recenter the map around the player */
 851         verify_panel();
 852
 853         /* Update stuff */
 854         p_ptr->update |= (PU_MONSTERS);
 855
 856         /* Redraw map */
 857         p_ptr->redraw |= (PR_MAP);
 858
 859         /* Window stuff */
 860         p_ptr->window |= (PW_OVERHEAD);
 861
 862         /* Handle stuff */
 863         handle_stuff();
 864
 865         /* Automatically pickup/destroy/inscribe items */
 866         autopick_pickup_items(c_ptr);
 867
 868
 869 #ifdef ALLOW_EASY_FLOOR
 870
 871         if (easy_floor)
 872         {
 873                 py_pickup_floor(pickup);
 874                 return;
 875         }
 876
 877 #endif /* ALLOW_EASY_FLOOR */
 878
 879         /* Scan the pile of objects */
 880         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 881         {
 882                 object_type *o_ptr;
 883
 884                 /* Acquire object */
 885                 o_ptr = &o_list[this_o_idx];
 886
 887 #ifdef ALLOW_EASY_SENSE /* TNB */
 888
 889                 /* Option: Make item sensing easy */
 890                 if (easy_sense)
 891                 {
 892                         /* Sense the object */
 893                         (void)sense_object(o_ptr);
 894                 }
 895
 896 #endif /* ALLOW_EASY_SENSE -- TNB */
 897
 898                 /* Describe the object */
 899                 object_desc(o_name, o_ptr, 0);
 900
 901                 /* Acquire next object */
 902                 next_o_idx = o_ptr->next_o_idx;
 903
 904                 /* Hack -- disturb */
 905                 disturb(0, 0);
 906
 907                 /* Pick up gold */
 908                 if (o_ptr->tval == TV_GOLD)
 909                 {
 910                         int value = (long)o_ptr->pval;
 911
 912                         /* Delete the gold */
 913                         delete_object_idx(this_o_idx);
 914
 915                         /* Message */
 916 #ifdef JP
 917                 msg_format(" $%ld ¤Î²ÁÃÍ¤¬¤¢¤ë%s¤ò¸«¤Ä¤±¤¿¡£",
 918                            (long)value, o_name);
 919 #else
 920                         msg_format("You collect %ld gold pieces worth of %s.",
 921                                    (long)value, o_name);
 922 #endif
 923
 924
 925                         sound(SOUND_SELL);
 926
 927                         /* Collect the gold */
 928                         p_ptr->au += value;
 929
 930                         /* Redraw gold */
 931                         p_ptr->redraw |= (PR_GOLD);
 932
 933                         /* Window stuff */
 934                         p_ptr->window |= (PW_PLAYER);
 935                 }
 936
 937                 /* Pick up objects */
 938                 else
 939                 {
 940                         /* Hack - some objects were handled in autopick_pickup_items(). */
 941                         if (o_ptr->marked & OM_NOMSG)
 942                         {
 943                                 /* Clear the flag. */
 944                                 o_ptr->marked &= ~OM_NOMSG;
 945                         }
 946                         /* Describe the object */
 947                         else if (!pickup)
 948                         {
 949 #ifdef JP
 950                                 msg_format("%s¤¬¤¢¤ë¡£", o_name);
 951 #else
 952                                 msg_format("You see %s.", o_name);
 953 #endif
 954
 955                         }
 956
 957                         /* Note that the pack is too full */
 958                         else if (!inven_carry_okay(o_ptr))
 959                         {
 960 #ifdef JP
 961                                 msg_format("¥¶¥Ã¥¯¤Ë¤Ï%s¤òÆþ¤ì¤ë·ä´Ö¤¬¤Ê¤¤¡£", o_name);
 962 #else
 963                                 msg_format("You have no room for %s.", o_name);
 964 #endif
 965
 966                         }
 967
 968                         /* Pick up the item (if requested and allowed) */
 969                         else
 970                         {
 971                                 int okay = TRUE;
 972
 973                                 /* Hack -- query every item */
 974                                 if (carry_query_flag)
 975                                 {
 976                                         char out_val[MAX_NLEN+20];
 977 #ifdef JP
 978                                         sprintf(out_val, "%s¤ò½¦¤¤¤Þ¤¹¤«? ", o_name);
 979 #else
 980                                         sprintf(out_val, "Pick up %s? ", o_name);
 981 #endif
 982
 983                                         okay = get_check(out_val);
 984                                 }
 985
 986                                 /* Attempt to pick up an object. */
 987                                 if (okay)
 988                                 {
 989                                         /* Pick up the object */
 990                                         py_pickup_aux(this_o_idx);
 991                                 }
 992                         }
 993                 }
 994         }
 995 }
 996
 997
 998 /*
 999  * Determine if a trap affects the player.
1000  * Always miss 5% of the time, Always hit 5% of the time.
1001  * Otherwise, match trap power against player armor.
1002  */
1003 static int check_hit(int power)
1004 {
1005         int k, ac;
1006
1007         /* Percentile dice */
1008         k = randint0(100);
1009
1010         /* Hack -- 5% hit, 5% miss */
1011         if (k < 10) return (k < 5);
1012
1013         if (p_ptr->pseikaku == SEIKAKU_NAMAKE)
1014                 if (one_in_(20)) return (TRUE);
1015
1016         /* Paranoia -- No power */
1017         if (power <= 0) return (FALSE);
1018
1019         /* Total armor */
1020         ac = p_ptr->ac + p_ptr->to_a;
1021
1022         /* Power competes against Armor */
1023         if (randint1(power) > ((ac * 3) / 4)) return (TRUE);
1024
1025         /* Assume miss */
1026         return (FALSE);
1027 }
1028
1029
1030
1031 /*
1032  * Handle player hitting a real trap
1033  */
1034 static void hit_trap(bool break_trap)
1035 {
1036         int i, num, dam;
1037         int x = px, y = py;
1038
1039         /* Get the cave grid */
1040         cave_type *c_ptr = &cave[y][x];
1041         feature_type *f_ptr = &f_info[c_ptr->feat];
1042         int trap_feat_type = have_flag(f_ptr->flags, FF_TRAP) ? f_ptr->subtype : NOT_TRAP;
1043
1044 #ifdef JP
1045         cptr name = "¥È¥é¥Ã¥×";
1046 #else
1047         cptr name = "a trap";
1048 #endif
1049
1050         /* Disturb the player */
1051         disturb(0, 1);
1052
1053         cave_alter_feat(y, x, FF_HIT_TRAP);
1054
1055         /* Analyze XXX XXX XXX */
1056         switch (trap_feat_type)
1057         {
1058                 case TRAP_TRAPDOOR:
1059                 {
1060                         if (p_ptr->levitation)
1061                         {
1062 #ifdef JP
1063                                 msg_print("Íî¤È¤·¸Í¤òÈô¤Ó±Û¤¨¤¿¡£");
1064 #else
1065                                 msg_print("You fly over a trap door.");
1066 #endif
1067
1068                         }
1069                         else
1070                         {
1071 #ifdef JP
1072                                 msg_print("Íî¤È¤·¸Í¤ËÍî¤Á¤¿¡ª");
1073                                 if ((p_ptr->pseikaku == SEIKAKU_COMBAT) || (inventory[INVEN_BOW].name1 == ART_CRIMSON))
1074                                         msg_print("¤¯¤Ã¤½¡Á¡ª");
1075 #else
1076                                 msg_print("You have fallen through a trap door!");
1077 #endif
1078
1079                                 sound(SOUND_FALL);
1080                                 dam = damroll(2, 8);
1081 #ifdef JP
1082                                 name = "Íî¤È¤·¸Í";
1083 #else
1084                                 name = "a trap door";
1085 #endif
1086
1087                                 take_hit(DAMAGE_NOESCAPE, dam, name, -1);
1088
1089                                 /* Still alive and autosave enabled */
1090                                 if (autosave_l && (p_ptr->chp >= 0))
1091                                         do_cmd_save_game(TRUE);
1092
1093 #ifdef JP
1094                                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, "Íî¤È¤·¸Í¤ËÍî¤Á¤¿");
1095 #else
1096                                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, "You have fallen through a trap door!");
1097 #endif
1098                                 prepare_change_floor_mode(CFM_SAVE_FLOORS | CFM_DOWN | CFM_RAND_PLACE | CFM_RAND_CONNECT);
1099
1100                                 /* Leaving */
1101                                 p_ptr->leaving = TRUE;
1102                         }
1103                         break;
1104                 }
1105
1106                 case TRAP_PIT:
1107                 {
1108                         if (p_ptr->levitation)
1109                         {
1110 #ifdef JP
1111                                 msg_print("Íî¤È¤··ê¤òÈô¤Ó±Û¤¨¤¿¡£");
1112 #else
1113                                 msg_print("You fly over a pit trap.");
1114 #endif
1115
1116                         }
1117                         else
1118                         {
1119 #ifdef JP
1120                                 msg_print("Íî¤È¤··ê¤ËÍî¤Á¤Æ¤·¤Þ¤Ã¤¿¡ª");
1121 #else
1122                                 msg_print("You have fallen into a pit!");
1123 #endif
1124
1125                                 dam = damroll(2, 6);
1126 #ifdef JP
1127                                 name = "Íî¤È¤··ê";
1128 #else
1129                                 name = "a pit trap";
1130 #endif
1131
1132                                 take_hit(DAMAGE_NOESCAPE, dam, name, -1);
1133                         }
1134                         break;
1135                 }
1136
1137                 case TRAP_SPIKED_PIT:
1138                 {
1139                         if (p_ptr->levitation)
1140                         {
1141 #ifdef JP
1142                                 msg_print("¥È¥²¤Î¤¢¤ëÍî¤È¤··ê¤òÈô¤Ó±Û¤¨¤¿¡£");
1143 #else
1144                                 msg_print("You fly over a spiked pit.");
1145 #endif
1146
1147                         }
1148                         else
1149                         {
1150 #ifdef JP
1151                                 msg_print("¥¹¥Ñ¥¤¥¯¤¬Éß¤«¤ì¤¿Íî¤È¤··ê¤ËÍî¤Á¤Æ¤·¤Þ¤Ã¤¿¡ª");
1152 #else
1153                                 msg_print("You fall into a spiked pit!");
1154 #endif
1155
1156
1157                                 /* Base damage */
1158 #ifdef JP
1159                                 name = "Íî¤È¤··ê";
1160 #else
1161                                 name = "a pit trap";
1162 #endif
1163
1164                                 dam = damroll(2, 6);
1165
1166                                 /* Extra spike damage */
1167                                 if (randint0(100) < 50)
1168                                 {
1169 #ifdef JP
1170                                         msg_print("¥¹¥Ñ¥¤¥¯¤¬»É¤µ¤Ã¤¿¡ª");
1171 #else
1172                                         msg_print("You are impaled!");
1173 #endif
1174
1175
1176 #ifdef JP
1177                                         name = "¥È¥²¤Î¤¢¤ëÍî¤È¤··ê";
1178 #else
1179                                         name = "a spiked pit";
1180 #endif
1181
1182                                         dam = dam * 2;
1183                                         (void)set_cut(p_ptr->cut + randint1(dam));
1184                                 }
1185
1186                                 /* Take the damage */
1187                                 take_hit(DAMAGE_NOESCAPE, dam, name, -1);
1188                         }
1189                         break;
1190                 }
1191
1192                 case TRAP_POISON_PIT:
1193                 {
1194                         if (p_ptr->levitation)
1195                         {
1196 #ifdef JP
1197                                 msg_print("¥È¥²¤Î¤¢¤ëÍî¤È¤··ê¤òÈô¤Ó±Û¤¨¤¿¡£");
1198 #else
1199                                 msg_print("You fly over a spiked pit.");
1200 #endif
1201
1202                         }
1203                         else
1204                         {
1205 #ifdef JP
1206                         msg_print("¥¹¥Ñ¥¤¥¯¤¬Éß¤«¤ì¤¿Íî¤È¤··ê¤ËÍî¤Á¤Æ¤·¤Þ¤Ã¤¿¡ª");
1207 #else
1208                                 msg_print("You fall into a spiked pit!");
1209 #endif
1210
1211
1212                                 /* Base damage */
1213                                 dam = damroll(2, 6);
1214
1215 #ifdef JP
1216                                 name = "Íî¤È¤··ê";
1217 #else
1218                                 name = "a pit trap";
1219 #endif
1220
1221
1222                                 /* Extra spike damage */
1223                                 if (randint0(100) < 50)
1224                                 {
1225 #ifdef JP
1226                                         msg_print("ÆÇ¤òÅÉ¤é¤ì¤¿¥¹¥Ñ¥¤¥¯¤¬»É¤µ¤Ã¤¿¡ª");
1227 #else
1228                                         msg_print("You are impaled on poisonous spikes!");
1229 #endif
1230
1231
1232 #ifdef JP
1233                                         name = "¥È¥²¤Î¤¢¤ëÍî¤È¤··ê";
1234 #else
1235                                         name = "a spiked pit";
1236 #endif
1237
1238
1239                                         dam = dam * 2;
1240                                         (void)set_cut(p_ptr->cut + randint1(dam));
1241
1242                                         if (p_ptr->resist_pois || IS_OPPOSE_POIS())
1243                                         {
1244 #ifdef JP
1245                                                 msg_print("¤·¤«¤·ÆÇ¤Î±Æ¶Á¤Ï¤Ê¤«¤Ã¤¿¡ª");
1246 #else
1247                                                 msg_print("The poison does not affect you!");
1248 #endif
1249
1250                                         }
1251
1252                                         else
1253                                         {
1254                                                 dam = dam * 2;
1255                                                 (void)set_poisoned(p_ptr->poisoned + randint1(dam));
1256                                         }
1257                                 }
1258
1259                                 /* Take the damage */
1260                                 take_hit(DAMAGE_NOESCAPE, dam, name, -1);
1261                         }
1262
1263                         break;
1264                 }
1265
1266                 case TRAP_TY_CURSE:
1267                 {
1268 #ifdef JP
1269                         msg_print("²¿¤«¤¬¥Ô¥«¥Ã¤È¸÷¤Ã¤¿¡ª");
1270 #else
1271                         msg_print("There is a flash of shimmering light!");
1272 #endif
1273
1274                         num = 2 + randint1(3);
1275                         for (i = 0; i < num; i++)
1276                         {
1277                                 (void)summon_specific(0, y, x, dun_level, 0, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE | PM_NO_PET));
1278                         }
1279
1280                         if (dun_level > randint1(100)) /* No nasty effect for low levels */
1281                         {
1282                                 bool stop_ty = FALSE;
1283                                 int count = 0;
1284
1285                                 do
1286                                 {
1287                                         stop_ty = activate_ty_curse(stop_ty, &count);
1288                                 }
1289                                 while (one_in_(6));
1290                         }
1291                         break;
1292                 }
1293
1294                 case TRAP_TELEPORT:
1295                 {
1296 #ifdef JP
1297                         msg_print("¥Æ¥ì¥Ý¡¼¥È¡¦¥È¥é¥Ã¥×¤Ë¤Ò¤Ã¤«¤«¤Ã¤¿¡ª");
1298 #else
1299                         msg_print("You hit a teleport trap!");
1300 #endif
1301
1302                         teleport_player(100, TELEPORT_PASSIVE);
1303                         break;
1304                 }
1305
1306                 case TRAP_FIRE:
1307                 {
1308 #ifdef JP
1309                         msg_print("±ê¤ËÊñ¤Þ¤ì¤¿¡ª");
1310 #else
1311                         msg_print("You are enveloped in flames!");
1312 #endif
1313
1314                         dam = damroll(4, 6);
1315 #ifdef JP
1316                         (void)fire_dam(dam, "±ê¤Î¥È¥é¥Ã¥×", -1);
1317 #else
1318                         (void)fire_dam(dam, "a fire trap", -1);
1319 #endif
1320
1321                         break;
1322                 }
1323
1324                 case TRAP_ACID:
1325                 {
1326 #ifdef JP
1327                         msg_print("»À¤¬¿á¤¤«¤±¤é¤ì¤¿¡ª");
1328 #else
1329                         msg_print("You are splashed with acid!");
1330 #endif
1331
1332                         dam = damroll(4, 6);
1333 #ifdef JP
1334                         (void)acid_dam(dam, "»À¤Î¥È¥é¥Ã¥×", -1);
1335 #else
1336                         (void)acid_dam(dam, "an acid trap", -1);
1337 #endif
1338
1339                         break;
1340                 }
1341
1342                 case TRAP_SLOW:
1343                 {
1344                         if (check_hit(125))
1345                         {
1346 #ifdef JP
1347                                 msg_print("¾®¤µ¤Ê¥À¡¼¥Ä¤¬Èô¤ó¤Ç¤¤Æ»É¤µ¤Ã¤¿¡ª");
1348 #else
1349                                 msg_print("A small dart hits you!");
1350 #endif
1351
1352                                 dam = damroll(1, 4);
1353 #ifdef JP
1354                                 take_hit(DAMAGE_ATTACK, dam, "¥À¡¼¥Ä¤Îæ«", -1);
1355 #else
1356                                 take_hit(DAMAGE_ATTACK, dam, "a dart trap", -1);
1357 #endif
1358
1359                                 if (!CHECK_MULTISHADOW()) (void)set_slow(p_ptr->slow + randint0(20) + 20, FALSE);
1360                         }
1361                         else
1362                         {
1363 #ifdef JP
1364                                 msg_print("¾®¤µ¤Ê¥À¡¼¥Ä¤¬Èô¤ó¤Ç¤¤¿¡ª¤¬¡¢±¿ÎÉ¤¯Åö¤¿¤é¤Ê¤«¤Ã¤¿¡£");
1365 #else
1366                                 msg_print("A small dart barely misses you.");
1367 #endif
1368
1369                         }
1370                         break;
1371                 }
1372
1373                 case TRAP_LOSE_STR:
1374                 {
1375                         if (check_hit(125))
1376                         {
1377 #ifdef JP
1378                                 msg_print("¾®¤µ¤Ê¥À¡¼¥Ä¤¬Èô¤ó¤Ç¤¤Æ»É¤µ¤Ã¤¿¡ª");
1379 #else
1380                                 msg_print("A small dart hits you!");
1381 #endif
1382
1383                                 dam = damroll(1, 4);
1384 #ifdef JP
1385                                 take_hit(DAMAGE_ATTACK, dam, "¥À¡¼¥Ä¤Îæ«", -1);
1386 #else
1387                                 take_hit(DAMAGE_ATTACK, dam, "a dart trap", -1);
1388 #endif
1389
1390                                 if (!CHECK_MULTISHADOW()) (void)do_dec_stat(A_STR);
1391                         }
1392                         else
1393                         {
1394 #ifdef JP
1395                                 msg_print("¾®¤µ¤Ê¥À¡¼¥Ä¤¬Èô¤ó¤Ç¤¤¿¡ª¤¬¡¢±¿ÎÉ¤¯Åö¤¿¤é¤Ê¤«¤Ã¤¿¡£");
1396 #else
1397                                 msg_print("A small dart barely misses you.");
1398 #endif
1399
1400                         }
1401                         break;
1402                 }
1403
1404                 case TRAP_LOSE_DEX:
1405                 {
1406                         if (check_hit(125))
1407                         {
1408 #ifdef JP
1409                                 msg_print("¾®¤µ¤Ê¥À¡¼¥Ä¤¬Èô¤ó¤Ç¤¤Æ»É¤µ¤Ã¤¿¡ª");
1410 #else
1411                                 msg_print("A small dart hits you!");
1412 #endif
1413
1414                                 dam = damroll(1, 4);
1415 #ifdef JP
1416                                 take_hit(DAMAGE_ATTACK, dam, "¥À¡¼¥Ä¤Îæ«", -1);
1417 #else
1418                                 take_hit(DAMAGE_ATTACK, dam, "a dart trap", -1);
1419 #endif
1420
1421                                 if (!CHECK_MULTISHADOW()) (void)do_dec_stat(A_DEX);
1422                         }
1423                         else
1424                         {
1425 #ifdef JP
1426                                 msg_print("¾®¤µ¤Ê¥À¡¼¥Ä¤¬Èô¤ó¤Ç¤¤¿¡ª¤¬¡¢±¿ÎÉ¤¯Åö¤¿¤é¤Ê¤«¤Ã¤¿¡£");
1427 #else
1428                                 msg_print("A small dart barely misses you.");
1429 #endif
1430
1431                         }
1432                         break;
1433                 }
1434
1435                 case TRAP_LOSE_CON:
1436                 {
1437                         if (check_hit(125))
1438                         {
1439 #ifdef JP
1440                                 msg_print("¾®¤µ¤Ê¥À¡¼¥Ä¤¬Èô¤ó¤Ç¤¤Æ»É¤µ¤Ã¤¿¡ª");
1441 #else
1442                                 msg_print("A small dart hits you!");
1443 #endif
1444
1445                                 dam = damroll(1, 4);
1446 #ifdef JP
1447                                 take_hit(DAMAGE_ATTACK, dam, "¥À¡¼¥Ä¤Îæ«", -1);
1448 #else
1449                                 take_hit(DAMAGE_ATTACK, dam, "a dart trap", -1);
1450 #endif
1451
1452                                 if (!CHECK_MULTISHADOW()) (void)do_dec_stat(A_CON);
1453                         }
1454                         else
1455                         {
1456 #ifdef JP
1457                                 msg_print("¾®¤µ¤Ê¥À¡¼¥Ä¤¬Èô¤ó¤Ç¤¤¿¡ª¤¬¡¢±¿ÎÉ¤¯Åö¤¿¤é¤Ê¤«¤Ã¤¿¡£");
1458 #else
1459                                 msg_print("A small dart barely misses you.");
1460 #endif
1461
1462                         }
1463                         break;
1464                 }
1465
1466                 case TRAP_BLIND:
1467                 {
1468 #ifdef JP
1469                         msg_print("¹õ¤¤¥¬¥¹¤ËÊñ¤ß¹þ¤Þ¤ì¤¿¡ª");
1470 #else
1471                         msg_print("A black gas surrounds you!");
1472 #endif
1473
1474                         if (!p_ptr->resist_blind)
1475                         {
1476                                 (void)set_blind(p_ptr->blind + randint0(50) + 25);
1477                         }
1478                         break;
1479                 }
1480
1481                 case TRAP_CONFUSE:
1482                 {
1483 #ifdef JP
1484                         msg_print("¤¤é¤á¤¯¥¬¥¹¤ËÊñ¤ß¹þ¤Þ¤ì¤¿¡ª");
1485 #else
1486                         msg_print("A gas of scintillating colors surrounds you!");
1487 #endif
1488
1489                         if (!p_ptr->resist_conf)
1490                         {
1491                                 (void)set_confused(p_ptr->confused + randint0(20) + 10);
1492                         }
1493                         break;
1494                 }
1495
1496                 case TRAP_POISON:
1497                 {
1498 #ifdef JP
1499                         msg_print("»É·ãÅª¤ÊÎÐ¿§¤Î¥¬¥¹¤ËÊñ¤ß¹þ¤Þ¤ì¤¿¡ª");
1500 #else
1501                         msg_print("A pungent green gas surrounds you!");
1502 #endif
1503
1504                         if (!p_ptr->resist_pois && !IS_OPPOSE_POIS())
1505                         {
1506                                 (void)set_poisoned(p_ptr->poisoned + randint0(20) + 10);
1507                         }
1508                         break;
1509                 }
1510
1511                 case TRAP_SLEEP:
1512                 {
1513 #ifdef JP
1514                         msg_print("´ñÌ¯¤ÊÇò¤¤Ì¸¤ËÊñ¤Þ¤ì¤¿¡ª");
1515 #else
1516                         msg_print("A strange white mist surrounds you!");
1517 #endif
1518
1519                         if (!p_ptr->free_act)
1520                         {
1521 #ifdef JP
1522 msg_print("¤¢¤Ê¤¿¤ÏÌ²¤ê¤Ë½¢¤¤¤¿¡£");
1523 #else
1524                                 msg_print("You fall asleep.");
1525 #endif
1526
1527
1528                                 if (ironman_nightmare)
1529                                 {
1530 #ifdef JP
1531 msg_print("¿È¤ÎÌÓ¤â¤è¤À¤Ä¸÷·Ê¤¬Æ¬¤ËÉâ¤«¤ó¤À¡£");
1532 #else
1533                                         msg_print("A horrible vision enters your mind.");
1534 #endif
1535
1536
1537                                         /* Pick a nightmare */
1538                                         get_mon_num_prep(get_nightmare, NULL);
1539
1540                                         /* Have some nightmares */
1541                                         have_nightmare(get_mon_num(MAX_DEPTH));
1542
1543                                         /* Remove the monster restriction */
1544                                         get_mon_num_prep(NULL, NULL);
1545                                 }
1546                                 (void)set_paralyzed(p_ptr->paralyzed + randint0(10) + 5);
1547                         }
1548                         break;
1549                 }
1550
1551                 case TRAP_TRAPS:
1552                 {
1553 #ifdef JP
1554 msg_print("¤Þ¤Ð¤æ¤¤Á®¸÷¤¬Áö¤Ã¤¿¡ª");
1555 #else
1556                         msg_print("There is a bright flash of light!");
1557 #endif
1558
1559                         /* Make some new traps */
1560                         project(0, 1, y, x, 0, GF_MAKE_TRAP, PROJECT_HIDE | PROJECT_JUMP | PROJECT_GRID, -1);
1561
1562                         break;
1563                 }
1564
1565                 case TRAP_ALARM:
1566                 {
1567 #ifdef JP
1568                         msg_print("¤±¤¿¤¿¤Þ¤·¤¤²»¤¬ÌÄ¤ê¶Á¤¤¤¿¡ª");
1569 #else
1570                         msg_print("An alarm sounds!");
1571 #endif
1572
1573                         aggravate_monsters(0);
1574
1575                         break;
1576                 }
1577
1578                 case TRAP_OPEN:
1579                 {
1580 #ifdef JP
1581                         msg_print("Âç²»¶Á¤È¶¦¤Ë¤Þ¤ï¤ê¤ÎÊÉ¤¬Êø¤ì¤¿¡ª");
1582 #else
1583                         msg_print("Suddenly, surrounding walls are opened!");
1584 #endif
1585                         (void)project(0, 3, y, x, 0, GF_DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE, -1);
1586                         (void)project(0, 3, y, x - 4, 0, GF_DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE, -1);
1587                         (void)project(0, 3, y, x + 4, 0, GF_DISINTEGRATE, PROJECT_GRID | PROJECT_HIDE, -1);
1588                         aggravate_monsters(0);
1589
1590                         break;
1591                 }
1592
1593                 case TRAP_ARMAGEDDON:
1594                 {
1595                         static int levs[10] = {0, 0, 20, 10, 5, 3, 2, 1, 1, 1};
1596                         int evil_idx = 0, good_idx = 0;
1597
1598                         int lev;
1599 #ifdef JP
1600                         msg_print("ÆÍÁ³Å·³¦¤ÎÀïÁè¤Ë´¬¤¹þ¤Þ¤ì¤¿¡ª");
1601 #else
1602                         msg_print("Suddenly, you are surrounded by immotal beings!");
1603 #endif
1604
1605                         /* Summon Demons and Angels */
1606                         for (lev = dun_level; lev >= 20; lev -= 1 + lev/16)
1607                         {
1608                                 num = levs[MIN(lev/10, 9)];
1609                                 for (i = 0; i < num; i++)
1610                                 {
1611                                         int x1 = rand_spread(x, 7);
1612                                         int y1 = rand_spread(y, 5);
1613
1614                                         /* Skip illegal grids */
1615                                         if (!in_bounds(y1, x1)) continue;
1616
1617                                         /* Require line of projection */
1618                                         if (!projectable(py, px, y1, x1)) continue;
1619
1620                                         if (summon_specific(0, y1, x1, lev, SUMMON_ARMAGE_EVIL, (PM_NO_PET)))
1621                                                 evil_idx = hack_m_idx_ii;
1622
1623                                         if (summon_specific(0, y1, x1, lev, SUMMON_ARMAGE_GOOD, (PM_NO_PET)))
1624                                         {
1625                                                 good_idx = hack_m_idx_ii;
1626                                         }
1627
1628                                         /* Let them fight each other */
1629                                         if (evil_idx && good_idx)
1630                                         {
1631                                                 monster_type *evil_ptr = &m_list[evil_idx];
1632                                                 monster_type *good_ptr = &m_list[good_idx];
1633                                                 evil_ptr->target_y = good_ptr->fy;
1634                                                 evil_ptr->target_x = good_ptr->fx;
1635                                                 good_ptr->target_y = evil_ptr->fy;
1636                                                 good_ptr->target_x = evil_ptr->fx;
1637                                         }
1638                                 }
1639                         }
1640                         break;
1641                 }
1642
1643                 case TRAP_PIRANHA:
1644                 {
1645 #ifdef JP
1646                         msg_print("ÆÍÁ³ÊÉ¤«¤é¿å¤¬°î¤ì½Ð¤·¤¿¡ª¥Ô¥é¥Ë¥¢¤¬¤¤¤ë¡ª");
1647 #else
1648                         msg_print("Suddenly, the room is filled with water with piranhas!");
1649 #endif
1650
1651                         /* Water fills room */
1652                         fire_ball_hide(GF_WATER_FLOW, 0, 1, 10);
1653
1654                         /* Summon Piranhas */
1655                         num = 1 + dun_level/20;
1656                         for (i = 0; i < num; i++)
1657                         {
1658                                 (void)summon_specific(0, y, x, dun_level, SUMMON_PIRANHAS, (PM_ALLOW_GROUP | PM_NO_PET));
1659                         }
1660                         break;
1661                 }
1662         }
1663
1664         if (break_trap && is_trap(c_ptr->feat))
1665         {
1666                 cave_alter_feat(y, x, FF_DISARM);
1667 #ifdef JP
1668                 msg_print("¥È¥é¥Ã¥×¤òÊ´ºÕ¤·¤¿¡£");
1669 #else
1670                 msg_print("You destroyed the trap.");
1671 #endif
1672         }
1673 }
1674
1675
1676 static void touch_zap_player(monster_type *m_ptr)
1677 {
1678         int aura_damage = 0;
1679         monster_race *r_ptr = &r_info[m_ptr->r_idx];
1680
1681         if (r_ptr->flags2 & RF2_AURA_FIRE)
1682         {
1683                 if (!p_ptr->immune_fire)
1684                 {
1685                         char aura_dam[80];
1686
1687                         aura_damage = damroll(1 + (r_ptr->level / 26), 1 + (r_ptr->level / 17));
1688
1689                         /* Hack -- Get the "died from" name */
1690                         monster_desc(aura_dam, m_ptr, MD_IGNORE_HALLU | MD_ASSUME_VISIBLE | MD_INDEF_VISIBLE);
1691
1692 #ifdef JP
1693                         msg_print("ÆÍÁ³¤È¤Æ¤âÇ®¤¯¤Ê¤Ã¤¿¡ª");
1694 #else
1695                         msg_print("You are suddenly very hot!");
1696 #endif
1697
1698                         if (prace_is_(RACE_ENT)) aura_damage += aura_damage / 3;
1699                         if (IS_OPPOSE_FIRE()) aura_damage = (aura_damage + 2) / 3;
1700                         if (p_ptr->resist_fire) aura_damage = (aura_damage + 2) / 3;
1701
1702                         take_hit(DAMAGE_NOESCAPE, aura_damage, aura_dam, -1);
1703                         if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= RF2_AURA_FIRE;
1704                         handle_stuff();
1705                 }
1706         }
1707
1708         if (r_ptr->flags3 & RF3_AURA_COLD)
1709         {
1710                 if (!p_ptr->immune_cold)
1711                 {
1712                         char aura_dam[80];
1713
1714                         aura_damage = damroll(1 + (r_ptr->level / 26), 1 + (r_ptr->level / 17));
1715
1716                         /* Hack -- Get the "died from" name */
1717                         monster_desc(aura_dam, m_ptr, MD_IGNORE_HALLU | MD_ASSUME_VISIBLE | MD_INDEF_VISIBLE);
1718
1719 #ifdef JP
1720                         msg_print("ÆÍÁ³¤È¤Æ¤â´¨¤¯¤Ê¤Ã¤¿¡ª");
1721 #else
1722                         msg_print("You are suddenly very cold!");
1723 #endif
1724
1725                         if (IS_OPPOSE_COLD()) aura_damage = (aura_damage + 2) / 3;
1726                         if (p_ptr->resist_cold) aura_damage = (aura_damage + 2) / 3;
1727
1728                         take_hit(DAMAGE_NOESCAPE, aura_damage, aura_dam, -1);
1729                         if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags3 |= RF3_AURA_COLD;
1730                         handle_stuff();
1731                 }
1732         }
1733
1734         if (r_ptr->flags2 & RF2_AURA_ELEC)
1735         {
1736                 if (!p_ptr->immune_elec)
1737                 {
1738                         char aura_dam[80];
1739
1740                         aura_damage = damroll(1 + (r_ptr->level / 26), 1 + (r_ptr->level / 17));
1741
1742                         /* Hack -- Get the "died from" name */
1743                         monster_desc(aura_dam, m_ptr, MD_IGNORE_HALLU | MD_ASSUME_VISIBLE | MD_INDEF_VISIBLE);
1744
1745                         if (prace_is_(RACE_ANDROID)) aura_damage += aura_damage / 3;
1746                         if (IS_OPPOSE_ELEC()) aura_damage = (aura_damage + 2) / 3;
1747                         if (p_ptr->resist_elec) aura_damage = (aura_damage + 2) / 3;
1748
1749 #ifdef JP
1750                         msg_print("ÅÅ·â¤ò¤¯¤é¤Ã¤¿¡ª");
1751 #else
1752                         msg_print("You get zapped!");
1753 #endif
1754
1755                         take_hit(DAMAGE_NOESCAPE, aura_damage, aura_dam, -1);
1756                         if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= RF2_AURA_ELEC;
1757                         handle_stuff();
1758                 }
1759         }
1760 }
1761
1762
1763 static void natural_attack(s16b m_idx, int attack, bool *fear, bool *mdeath)
1764 {
1765         int             k, bonus, chance;
1766         int             n_weight = 0;
1767         monster_type    *m_ptr = &m_list[m_idx];
1768         monster_race    *r_ptr = &r_info[m_ptr->r_idx];
1769         char            m_name[80];
1770
1771         int             dss, ddd;
1772
1773         cptr            atk_desc;
1774
1775         switch (attack)
1776         {
1777                 case MUT2_SCOR_TAIL:
1778                         dss = 3;
1779                         ddd = 7;
1780                         n_weight = 5;
1781 #ifdef JP
1782                         atk_desc = "¿¬Èø";
1783 #else
1784                         atk_desc = "tail";
1785 #endif
1786
1787                         break;
1788                 case MUT2_HORNS:
1789                         dss = 2;
1790                         ddd = 6;
1791                         n_weight = 15;
1792 #ifdef JP
1793                         atk_desc = "³Ñ";
1794 #else
1795                         atk_desc = "horns";
1796 #endif
1797
1798                         break;
1799                 case MUT2_BEAK:
1800                         dss = 2;
1801                         ddd = 4;
1802                         n_weight = 5;
1803 #ifdef JP
1804                         atk_desc = "¥¯¥Á¥Ð¥·";
1805 #else
1806                         atk_desc = "beak";
1807 #endif
1808
1809                         break;
1810                 case MUT2_TRUNK:
1811                         dss = 1;
1812                         ddd = 4;
1813                         n_weight = 35;
1814 #ifdef JP
1815                         atk_desc = "¾Ý¤ÎÉ¡";
1816 #else
1817                         atk_desc = "trunk";
1818 #endif
1819
1820                         break;
1821                 case MUT2_TENTACLES:
1822                         dss = 2;
1823                         ddd = 5;
1824                         n_weight = 5;
1825 #ifdef JP
1826                         atk_desc = "¿¨¼ê";
1827 #else
1828                         atk_desc = "tentacles";
1829 #endif
1830
1831                         break;
1832                 default:
1833                         dss = ddd = n_weight = 1;
1834 #ifdef JP
1835                         atk_desc = "Ì¤ÄêµÁ¤ÎÉô°Ì";
1836 #else
1837                         atk_desc = "undefined body part";
1838 #endif
1839
1840         }
1841
1842         /* Extract monster name (or "it") */
1843         monster_desc(m_name, m_ptr, 0);
1844
1845
1846         /* Calculate the "attack quality" */
1847         bonus = p_ptr->to_h_m;
1848         bonus += (p_ptr->lev * 6 / 5);
1849         chance = (p_ptr->skill_thn + (bonus * BTH_PLUS_ADJ));
1850
1851         /* Test for hit */
1852         if ((!(r_ptr->flags2 & RF2_QUANTUM) || !randint0(2)) && test_hit_norm(chance, r_ptr->ac, m_ptr->ml))
1853         {
1854                 /* Sound */
1855                 sound(SOUND_HIT);
1856
1857 #ifdef JP
1858                 msg_format("%s¤ò%s¤Ç¹¶·â¤·¤¿¡£", m_name, atk_desc);
1859 #else
1860                 msg_format("You hit %s with your %s.", m_name, atk_desc);
1861 #endif
1862
1863
1864                 k = damroll(ddd, dss);
1865                 k = critical_norm(n_weight, bonus, k, (s16b)bonus, 0);
1866
1867                 /* Apply the player damage bonuses */
1868                 k += p_ptr->to_d_m;
1869
1870                 /* No negative damage */
1871                 if (k < 0) k = 0;
1872
1873                 /* Modify the damage */
1874                 k = mon_damage_mod(m_ptr, k, FALSE);
1875
1876                 /* Complex message */
1877                 if (p_ptr->wizard)
1878                 {
1879 #ifdef JP
1880                                 msg_format("%d/%d ¤Î¥À¥á¡¼¥¸¤òÍ¿¤¨¤¿¡£", k, m_ptr->hp);
1881 #else
1882                         msg_format("You do %d (out of %d) damage.", k, m_ptr->hp);
1883 #endif
1884
1885                 }
1886
1887                 /* Anger the monster */
1888                 if (k > 0) anger_monster(m_ptr);
1889
1890                 /* Damage, check for fear and mdeath */
1891                 switch (attack)
1892                 {
1893                         case MUT2_SCOR_TAIL:
1894                                 project(0, 0, m_ptr->fy, m_ptr->fx, k, GF_POIS, PROJECT_KILL, -1);
1895                                 *mdeath = (m_ptr->r_idx == 0);
1896                                 break;
1897                         case MUT2_HORNS:
1898                                 *mdeath = mon_take_hit(m_idx, k, fear, NULL);
1899                                 break;
1900                         case MUT2_BEAK:
1901                                 *mdeath = mon_take_hit(m_idx, k, fear, NULL);
1902                                 break;
1903                         case MUT2_TRUNK:
1904                                 *mdeath = mon_take_hit(m_idx, k, fear, NULL);
1905                                 break;
1906                         case MUT2_TENTACLES:
1907                                 *mdeath = mon_take_hit(m_idx, k, fear, NULL);
1908                                 break;
1909                         default:
1910                                 *mdeath = mon_take_hit(m_idx, k, fear, NULL);
1911                 }
1912
1913                 touch_zap_player(m_ptr);
1914         }
1915         /* Player misses */
1916         else
1917         {
1918                 /* Sound */
1919                 sound(SOUND_MISS);
1920
1921                 /* Message */
1922 #ifdef JP
1923                         msg_format("¥ß¥¹¡ª %s¤Ë¤«¤ï¤µ¤ì¤¿¡£", m_name);
1924 #else
1925                 msg_format("You miss %s.", m_name);
1926 #endif
1927
1928         }
1929 }
1930
1931
1932
1933 /*
1934  * Player attacks a (poor, defenseless) creature        -RAK-
1935  *
1936  * If no "weapon" is available, then "punch" the monster one time.
1937  */
1938 static void py_attack_aux(int y, int x, bool *fear, bool *mdeath, s16b hand, int mode)
1939 {
1940         int             num = 0, k, bonus, chance, vir;
1941
1942         cave_type       *c_ptr = &cave[y][x];
1943
1944         monster_type    *m_ptr = &m_list[c_ptr->m_idx];
1945         monster_race    *r_ptr = &r_info[m_ptr->r_idx];
1946
1947         /* Access the weapon */
1948         object_type     *o_ptr = &inventory[INVEN_RARM + hand];
1949
1950         char            m_name[80];
1951
1952         bool            success_hit = FALSE;
1953         bool            backstab = FALSE;
1954         bool            vorpal_cut = FALSE;
1955         int             chaos_effect = 0;
1956         bool            stab_fleeing = FALSE;
1957         bool            fuiuchi = FALSE;
1958         bool            monk_attack = FALSE;
1959         bool            do_quake = FALSE;
1960         bool            weak = FALSE;
1961         bool            drain_msg = TRUE;
1962         int             drain_result = 0, drain_heal = 0;
1963         bool            can_drain = FALSE;
1964         int             num_blow;
1965         int             drain_left = MAX_VAMPIRIC_DRAIN;
1966         u32b flgs[TR_FLAG_SIZE]; /* A massive hack -- life-draining weapons */
1967         bool            is_human = (r_ptr->d_char == 'p');
1968         bool            is_lowlevel = (r_ptr->level < (p_ptr->lev - 15));
1969         bool            zantetsu_mukou, e_j_mukou;
1970
1971         switch (p_ptr->pclass)
1972         {
1973         case CLASS_ROGUE:
1974         case CLASS_NINJA:
1975                 if (buki_motteruka(INVEN_RARM + hand) && !p_ptr->icky_wield[hand])
1976                 {
1977                         int tmp = p_ptr->lev * 6 + (p_ptr->skill_stl + 10) * 4;
1978                         if (p_ptr->monlite && (mode != HISSATSU_NYUSIN)) tmp /= 3;
1979                         if (p_ptr->cursed & TRC_AGGRAVATE) tmp /= 2;
1980                         if (r_ptr->level > (p_ptr->lev * p_ptr->lev / 20 + 10)) tmp /= 3;
1981                         if (MON_CSLEEP(m_ptr) && m_ptr->ml)
1982                         {
1983                                 /* Can't backstab creatures that we can't see, right? */
1984                                 backstab = TRUE;
1985                         }
1986                         else if ((p_ptr->special_defense & NINJA_S_STEALTH) && (randint0(tmp) > (r_ptr->level+20)) && m_ptr->ml && !(r_ptr->flagsr & RFR_RES_ALL))
1987                         {
1988                                 fuiuchi = TRUE;
1989                         }
1990                         else if (MON_MONFEAR(m_ptr) && m_ptr->ml)
1991                         {
1992                                 stab_fleeing = TRUE;
1993                         }
1994                 }
1995                 break;
1996
1997         case CLASS_MONK:
1998         case CLASS_FORCETRAINER:
1999         case CLASS_BERSERKER:
2000                 if ((empty_hands(TRUE) & EMPTY_HAND_RARM) && !p_ptr->riding) monk_attack = TRUE;
2001                 break;
2002         }
2003
2004         if (!o_ptr->k_idx) /* Empty hand */
2005         {
2006                 if ((r_ptr->level + 10) > p_ptr->lev)
2007                 {
2008                         if (p_ptr->skill_exp[GINOU_SUDE] < s_info[p_ptr->pclass].s_max[GINOU_SUDE])
2009                         {
2010                                 if (p_ptr->skill_exp[GINOU_SUDE] < WEAPON_EXP_BEGINNER)
2011                                         p_ptr->skill_exp[GINOU_SUDE] += 40;
2012                                 else if ((p_ptr->skill_exp[GINOU_SUDE] < WEAPON_EXP_SKILLED))
2013                                         p_ptr->skill_exp[GINOU_SUDE] += 5;
2014                                 else if ((p_ptr->skill_exp[GINOU_SUDE] < WEAPON_EXP_EXPERT) && (p_ptr->lev > 19))
2015                                         p_ptr->skill_exp[GINOU_SUDE] += 1;
2016                                 else if ((p_ptr->lev > 34))
2017                                         if (one_in_(3)) p_ptr->skill_exp[GINOU_SUDE] += 1;
2018                                 p_ptr->update |= (PU_BONUS);
2019                         }
2020                 }
2021         }
2022         else if (object_is_melee_weapon(o_ptr))
2023         {
2024                 if ((r_ptr->level + 10) > p_ptr->lev)
2025                 {
2026                         int tval = inventory[INVEN_RARM+hand].tval - TV_WEAPON_BEGIN;
2027                         int sval = inventory[INVEN_RARM+hand].sval;
2028                         int now_exp = p_ptr->weapon_exp[tval][sval];
2029                         if (now_exp < s_info[p_ptr->pclass].w_max[tval][sval])
2030                         {
2031                                 int amount = 0;
2032                                 if (now_exp < WEAPON_EXP_BEGINNER) amount = 80;
2033                                 else if (now_exp < WEAPON_EXP_SKILLED) amount = 10;
2034                                 else if ((now_exp < WEAPON_EXP_EXPERT) && (p_ptr->lev > 19)) amount = 1;
2035                                 else if ((p_ptr->lev > 34) && one_in_(2)) amount = 1;
2036                                 p_ptr->weapon_exp[tval][sval] += amount;
2037                                 p_ptr->update |= (PU_BONUS);
2038                         }
2039                 }
2040         }
2041
2042         /* Disturb the monster */
2043         (void)set_monster_csleep(c_ptr->m_idx, 0);
2044
2045         /* Extract monster name (or "it") */
2046         monster_desc(m_name, m_ptr, 0);
2047
2048         /* Calculate the "attack quality" */
2049         bonus = p_ptr->to_h[hand] + o_ptr->to_h;
2050         chance = (p_ptr->skill_thn + (bonus * BTH_PLUS_ADJ));
2051         if (mode == HISSATSU_IAI) chance += 60;
2052         if (p_ptr->special_defense & KATA_KOUKIJIN) chance += 150;
2053
2054         if (p_ptr->sutemi) chance = MAX(chance * 3 / 2, chance + 60);
2055
2056         vir = virtue_number(V_VALOUR);
2057         if (vir)
2058         {
2059                 chance += (p_ptr->virtues[vir - 1]/10);
2060         }
2061
2062         zantetsu_mukou = ((o_ptr->name1 == ART_ZANTETSU) && (r_ptr->d_char == 'j'));
2063         e_j_mukou = ((o_ptr->name1 == ART_EXCALIBUR_J) && (r_ptr->d_char == 'S'));
2064
2065         if ((mode == HISSATSU_KYUSHO) || (mode == HISSATSU_MINEUCHI) || (mode == HISSATSU_3DAN) || (mode == HISSATSU_IAI)) num_blow = 1;
2066         else if (mode == HISSATSU_COLD) num_blow = p_ptr->num_blow[hand]+2;
2067         else num_blow = p_ptr->num_blow[hand];
2068
2069         /* Hack -- DOKUBARI always hit once */
2070         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DOKUBARI)) num_blow = 1;
2071
2072         /* Attack once for each legal blow */
2073         while ((num++ < num_blow) && !p_ptr->is_dead)
2074         {
2075                 if (((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DOKUBARI)) || (mode == HISSATSU_KYUSHO))
2076                 {
2077                         int n = 1;
2078
2079                         if (p_ptr->migite && p_ptr->hidarite)
2080                         {
2081                                 n *= 2;
2082                         }
2083                         if (mode == HISSATSU_3DAN)
2084                         {
2085                                 n *= 2;
2086                         }
2087
2088                         success_hit = one_in_(n);
2089                 }
2090                 else if ((p_ptr->pclass == CLASS_NINJA) && ((backstab || fuiuchi) && !(r_ptr->flagsr & RFR_RES_ALL))) success_hit = TRUE;
2091                 else success_hit = test_hit_norm(chance, r_ptr->ac, m_ptr->ml);
2092
2093                 if (mode == HISSATSU_MAJIN)
2094                 {
2095                         if (one_in_(2))
2096                                 success_hit = FALSE;
2097                 }
2098
2099                 /* Test for hit */
2100                 if (success_hit)
2101                 {
2102                         int vorpal_chance = ((o_ptr->name1 == ART_VORPAL_BLADE) || (o_ptr->name1 == ART_CHAINSWORD)) ? 2 : 4;
2103
2104                         /* Sound */
2105                         sound(SOUND_HIT);
2106
2107                         /* Message */
2108 #ifdef JP
2109                         if (backstab) msg_format("¤¢¤Ê¤¿¤ÏÎä¹ó¤Ë¤âÌ²¤Ã¤Æ¤¤¤ëÌµÎÏ¤Ê%s¤òÆÍ¤»É¤·¤¿¡ª", m_name);
2110                         else if (fuiuchi) msg_format("ÉÔ°Õ¤òÆÍ¤¤¤Æ%s¤Ë¶¯Îõ¤Ê°ì·â¤ò¶ô¤é¤ï¤»¤¿¡ª", m_name);
2111                         else if (stab_fleeing) msg_format("Æ¨¤²¤ë%s¤òÇØÃæ¤«¤éÆÍ¤»É¤·¤¿¡ª", m_name);
2112                         else if (!monk_attack) msg_format("%s¤ò¹¶·â¤·¤¿¡£", m_name);
2113 #else
2114                         if (backstab) msg_format("You cruelly stab the helpless, sleeping %s!", m_name);
2115                         else if (fuiuchi) msg_format("You make surprise attack, and hit %s with a powerful blow!", m_name);
2116                         else if (stab_fleeing) msg_format("You backstab the fleeing %s!",  m_name);
2117                         else if (!monk_attack) msg_format("You hit %s.", m_name);
2118 #endif
2119
2120                         /* Hack -- bare hands do one damage */
2121                         k = 1;
2122
2123                         object_flags(o_ptr, flgs);
2124
2125                         /* Select a chaotic effect (50% chance) */
2126                         if ((have_flag(flgs, TR_CHAOTIC)) && one_in_(2))
2127                         {
2128                                 if (one_in_(10))
2129                                 chg_virtue(V_CHANCE, 1);
2130
2131                                 if (randint1(5) < 3)
2132                                 {
2133                                         /* Vampiric (20%) */
2134                                         chaos_effect = 1;
2135                                 }
2136                                 else if (one_in_(250))
2137                                 {
2138                                         /* Quake (0.12%) */
2139                                         chaos_effect = 2;
2140                                 }
2141                                 else if (!one_in_(10))
2142                                 {
2143                                         /* Confusion (26.892%) */
2144                                         chaos_effect = 3;
2145                                 }
2146                                 else if (one_in_(2))
2147                                 {
2148                                         /* Teleport away (1.494%) */
2149                                         chaos_effect = 4;
2150                                 }
2151                                 else
2152                                 {
2153                                         /* Polymorph (1.494%) */
2154                                         chaos_effect = 5;
2155                                 }
2156                         }
2157
2158                         /* Vampiric drain */
2159                         if ((have_flag(flgs, TR_VAMPIRIC)) || (chaos_effect == 1) || (mode == HISSATSU_DRAIN) || hex_spelling(HEX_VAMP_BLADE))
2160                         {
2161                                 /* Only drain "living" monsters */
2162                                 if (monster_living(r_ptr))
2163                                         can_drain = TRUE;
2164                                 else
2165                                         can_drain = FALSE;
2166                         }
2167
2168                         if ((have_flag(flgs, TR_VORPAL) || hex_spelling(HEX_RUNESWORD)) && (randint1(vorpal_chance*3/2) == 1) && !zantetsu_mukou)
2169                                 vorpal_cut = TRUE;
2170                         else vorpal_cut = FALSE;
2171
2172                         if (monk_attack)
2173                         {
2174                                 int special_effect = 0, stun_effect = 0, times = 0, max_times;
2175                                 int min_level = 1;
2176                                 const martial_arts *ma_ptr = &ma_blows[0], *old_ptr = &ma_blows[0];
2177                                 int resist_stun = 0;
2178                                 int weight = 8;
2179
2180                                 if (r_ptr->flags1 & RF1_UNIQUE) resist_stun += 88;
2181                                 if (r_ptr->flags3 & RF3_NO_STUN) resist_stun += 66;
2182                                 if (r_ptr->flags3 & RF3_NO_CONF) resist_stun += 33;
2183                                 if (r_ptr->flags3 & RF3_NO_SLEEP) resist_stun += 33;
2184                                 if ((r_ptr->flags3 & RF3_UNDEAD) || (r_ptr->flags3 & RF3_NONLIVING))
2185                                         resist_stun += 66;
2186
2187                                 if (p_ptr->special_defense & KAMAE_BYAKKO)
2188                                         max_times = (p_ptr->lev < 3 ? 1 : p_ptr->lev / 3);
2189                                 else if (p_ptr->special_defense & KAMAE_SUZAKU)
2190                                         max_times = 1;
2191                                 else if (p_ptr->special_defense & KAMAE_GENBU)
2192                                         max_times = 1;
2193                                 else
2194                                         max_times = (p_ptr->lev < 7 ? 1 : p_ptr->lev / 7);
2195                                 /* Attempt 'times' */
2196                                 for (times = 0; times < max_times; times++)
2197                                 {
2198                                         do
2199                                         {
2200                                                 ma_ptr = &ma_blows[randint0(MAX_MA)];
2201                                                 if ((p_ptr->pclass == CLASS_FORCETRAINER) && (ma_ptr->min_level > 1)) min_level = ma_ptr->min_level + 3;
2202                                                 else min_level = ma_ptr->min_level;
2203                                         }
2204                                         while ((min_level > p_ptr->lev) ||
2205                                                (randint1(p_ptr->lev) < ma_ptr->chance));
2206
2207                                         /* keep the highest level attack available we found */
2208                                         if ((ma_ptr->min_level > old_ptr->min_level) &&
2209                                             !p_ptr->stun && !p_ptr->confused)
2210                                         {
2211                                                 old_ptr = ma_ptr;
2212
2213                                                 if (p_ptr->wizard && cheat_xtra)
2214                                                 {
2215 #ifdef JP
2216                                                         msg_print("¹¶·â¤òºÆÁªÂò¤·¤Þ¤·¤¿¡£");
2217 #else
2218                                                         msg_print("Attack re-selected.");
2219 #endif
2220                                                 }
2221                                         }
2222                                         else
2223                                         {
2224                                                 ma_ptr = old_ptr;
2225                                         }
2226                                 }
2227
2228                                 if (p_ptr->pclass == CLASS_FORCETRAINER) min_level = MAX(1, ma_ptr->min_level - 3);
2229                                 else min_level = ma_ptr->min_level;
2230                                 k = damroll(ma_ptr->dd + p_ptr->to_dd[hand], ma_ptr->ds + p_ptr->to_ds[hand]);
2231                                 if (p_ptr->special_attack & ATTACK_SUIKEN) k *= 2;
2232
2233                                 if (ma_ptr->effect == MA_KNEE)
2234                                 {
2235                                         if (r_ptr->flags1 & RF1_MALE)
2236                                         {
2237 #ifdef JP
2238                                                 msg_format("%s¤Ë¶âÅªÉ¨½³¤ê¤ò¤¯¤é¤ï¤·¤¿¡ª", m_name);
2239 #else
2240                                                 msg_format("You hit %s in the groin with your knee!", m_name);
2241 #endif
2242
2243                                                 sound(SOUND_PAIN);
2244                                                 special_effect = MA_KNEE;
2245                                         }
2246                                         else
2247                                                 msg_format(ma_ptr->desc, m_name);
2248                                 }
2249
2250                                 else if (ma_ptr->effect == MA_SLOW)
2251                                 {
2252                                         if (!((r_ptr->flags1 & RF1_NEVER_MOVE) ||
2253                                             my_strchr("~#{}.UjmeEv$,DdsbBFIJQSXclnw!=?", r_ptr->d_char)))
2254                                         {
2255 #ifdef JP
2256                                                 msg_format("%s¤ÎÂ¼ó¤Ë´ØÀá½³¤ê¤ò¤¯¤é¤ï¤·¤¿¡ª", m_name);
2257 #else
2258                                                 msg_format("You kick %s in the ankle.", m_name);
2259 #endif
2260
2261                                                 special_effect = MA_SLOW;
2262                                         }
2263                                         else msg_format(ma_ptr->desc, m_name);
2264                                 }
2265                                 else
2266                                 {
2267                                         if (ma_ptr->effect)
2268                                         {
2269                                                 stun_effect = (ma_ptr->effect / 2) + randint1(ma_ptr->effect / 2);
2270                                         }
2271
2272                                         msg_format(ma_ptr->desc, m_name);
2273                                 }
2274
2275                                 if (p_ptr->special_defense & KAMAE_SUZAKU) weight = 4;
2276                                 if ((p_ptr->pclass == CLASS_FORCETRAINER) && (p_ptr->magic_num1[0]))
2277                                 {
2278                                         weight += (p_ptr->magic_num1[0]/30);
2279                                         if (weight > 20) weight = 20;
2280                                 }
2281
2282                                 k = critical_norm(p_ptr->lev * weight, min_level, k, p_ptr->to_h[0], 0);
2283
2284                                 if ((special_effect == MA_KNEE) && ((k + p_ptr->to_d[hand]) < m_ptr->hp))
2285                                 {
2286 #ifdef JP
2287                                         msg_format("%^s¤Ï¶ìÄË¤Ë¤¦¤á¤¤¤Æ¤¤¤ë¡ª", m_name);
2288 #else
2289                                         msg_format("%^s moans in agony!", m_name);
2290 #endif
2291
2292                                         stun_effect = 7 + randint1(13);
2293                                         resist_stun /= 3;
2294                                 }
2295
2296                                 else if ((special_effect == MA_SLOW) && ((k + p_ptr->to_d[hand]) < m_ptr->hp))
2297                                 {
2298                                         if (!(r_ptr->flags1 & RF1_UNIQUE) &&
2299                                             (randint1(p_ptr->lev) > r_ptr->level) &&
2300                                             m_ptr->mspeed > 60)
2301                                         {
2302 #ifdef JP
2303                                                 msg_format("%^s¤ÏÂ¤ò¤Ò¤¤º¤ê»Ï¤á¤¿¡£", m_name);
2304 #else
2305                                                 msg_format("%^s starts limping slower.", m_name);
2306 #endif
2307
2308                                                 m_ptr->mspeed -= 10;
2309                                         }
2310                                 }
2311
2312                                 if (stun_effect && ((k + p_ptr->to_d[hand]) < m_ptr->hp))
2313                                 {
2314                                         if (p_ptr->lev > randint1(r_ptr->level + resist_stun + 10))
2315                                         {
2316                                                 if (set_monster_stunned(c_ptr->m_idx, stun_effect + MON_STUNNED(m_ptr)))
2317                                                 {
2318 #ifdef JP
2319                                                         msg_format("%^s¤Ï¥Õ¥é¥Õ¥é¤Ë¤Ê¤Ã¤¿¡£", m_name);
2320 #else
2321                                                         msg_format("%^s is stunned.", m_name);
2322 #endif
2323                                                 }
2324                                                 else
2325                                                 {
2326 #ifdef JP
2327                                                         msg_format("%^s¤Ï¤µ¤é¤Ë¥Õ¥é¥Õ¥é¤Ë¤Ê¤Ã¤¿¡£", m_name);
2328 #else
2329                                                         msg_format("%^s is more stunned.", m_name);
2330 #endif
2331                                                 }
2332                                         }
2333                                 }
2334                         }
2335
2336                         /* Handle normal weapon */
2337                         else if (o_ptr->k_idx)
2338                         {
2339                                 k = damroll(o_ptr->dd + p_ptr->to_dd[hand], o_ptr->ds + p_ptr->to_ds[hand]);
2340                                 k = tot_dam_aux(o_ptr, k, m_ptr, mode, FALSE);
2341
2342                                 if (backstab)
2343                                 {
2344                                         k *= (3 + (p_ptr->lev / 20));
2345                                 }
2346                                 else if (fuiuchi)
2347                                 {
2348                                         k = k*(5+(p_ptr->lev*2/25))/2;
2349                                 }
2350                                 else if (stab_fleeing)
2351                                 {
2352                                         k = (3 * k) / 2;
2353                                 }
2354
2355                                 if ((p_ptr->impact[hand] && ((k > 50) || one_in_(7))) ||
2356                                          (chaos_effect == 2) || (mode == HISSATSU_QUAKE))
2357                                 {
2358                                         do_quake = TRUE;
2359                                 }
2360
2361                                 if ((!(o_ptr->tval == TV_SWORD) || !(o_ptr->sval == SV_DOKUBARI)) && !(mode == HISSATSU_KYUSHO))
2362                                         k = critical_norm(o_ptr->weight, o_ptr->to_h, k, p_ptr->to_h[hand], mode);
2363
2364                                 drain_result = k;
2365
2366                                 if (vorpal_cut)
2367                                 {
2368                                         int mult = 2;
2369
2370                                         if ((o_ptr->name1 == ART_CHAINSWORD) && !one_in_(2))
2371                                         {
2372                                                 char chainsword_noise[1024];
2373 #ifdef JP
2374                                                 if (!get_rnd_line("chainswd_j.txt", 0, chainsword_noise))
2375 #else
2376                                                 if (!get_rnd_line("chainswd.txt", 0, chainsword_noise))
2377 #endif
2378                                                 {
2379                                                         msg_print(chainsword_noise);
2380                                                 }
2381                                         }
2382
2383                                         if (o_ptr->name1 == ART_VORPAL_BLADE)
2384                                         {
2385 #ifdef JP
2386                                                 msg_print("ÌÜ¤Ë¤â»ß¤Þ¤é¤Ì¥ô¥©¡¼¥Ñ¥ë¥Ö¥ì¡¼¥É¡¢¼êÏ£¤ÎÁá¶È¡ª");
2387 #else
2388                                                 msg_print("Your Vorpal Blade goes snicker-snack!");
2389 #endif
2390                                         }
2391                                         else
2392                                         {
2393 #ifdef JP
2394                                                 msg_format("%s¤ò¥°¥Ã¥µ¥êÀÚ¤êÎö¤¤¤¿¡ª", m_name);
2395 #else
2396                                                 msg_format("Your weapon cuts deep into %s!", m_name);
2397 #endif
2398                                         }
2399
2400                                         /* Try to increase the damage */
2401                                         while (one_in_(vorpal_chance))
2402                                         {
2403                                                 mult++;
2404                                         }
2405
2406                                         k *= mult;
2407
2408                                         /* Ouch! */
2409                                         if (((r_ptr->flagsr & RFR_RES_ALL) ? k/100 : k) > m_ptr->hp)
2410                                         {
2411 #ifdef JP
2412                                                 msg_format("%s¤ò¿¿¤ÃÆó¤Ä¤Ë¤·¤¿¡ª", m_name);
2413 #else
2414                                                 msg_format("You cut %s in half!", m_name);
2415 #endif
2416                                         }
2417                                         else
2418                                         {
2419                                                 switch (mult)
2420                                                 {
2421 #ifdef JP
2422                                                 case 2: msg_format("%s¤ò»Â¤Ã¤¿¡ª", m_name); break;
2423                                                 case 3: msg_format("%s¤ò¤Ö¤Ã¤¿»Â¤Ã¤¿¡ª", m_name); break;
2424                                                 case 4: msg_format("%s¤ò¥á¥Ã¥¿»Â¤ê¤Ë¤·¤¿¡ª", m_name); break;
2425                                                 case 5: msg_format("%s¤ò¥á¥Ã¥¿¥á¥¿¤Ë»Â¤Ã¤¿¡ª", m_name); break;
2426                                                 case 6: msg_format("%s¤ò»É¿È¤Ë¤·¤¿¡ª", m_name); break;
2427                                                 case 7: msg_format("%s¤ò»Â¤Ã¤Æ»Â¤Ã¤Æ»Â¤ê¤Þ¤¯¤Ã¤¿¡ª", m_name); break;
2428                                                 default: msg_format("%s¤òºÙÀÚ¤ì¤Ë¤·¤¿¡ª", m_name); break;
2429 #else
2430                                                 case 2: msg_format("You gouge %s!", m_name); break;
2431                                                 case 3: msg_format("You maim %s!", m_name); break;
2432                                                 case 4: msg_format("You carve %s!", m_name); break;
2433                                                 case 5: msg_format("You cleave %s!", m_name); break;
2434                                                 case 6: msg_format("You smite %s!", m_name); break;
2435                                                 case 7: msg_format("You eviscerate %s!", m_name); break;
2436                                                 default: msg_format("You shred %s!", m_name); break;
2437 #endif
2438                                                 }
2439                                         }
2440                                         drain_result = drain_result * 3 / 2;
2441                                 }
2442
2443                                 k += o_ptr->to_d;
2444                                 drain_result += o_ptr->to_d;
2445                         }
2446
2447                         /* Apply the player damage bonuses */
2448                         k += p_ptr->to_d[hand];
2449                         drain_result += p_ptr->to_d[hand];
2450
2451                         if ((mode == HISSATSU_SUTEMI) || (mode == HISSATSU_3DAN)) k *= 2;
2452                         if ((mode == HISSATSU_SEKIRYUKA) && !monster_living(r_ptr)) k = 0;
2453                         if ((mode == HISSATSU_SEKIRYUKA) && !p_ptr->cut) k /= 2;
2454
2455                         /* No negative damage */
2456                         if (k < 0) k = 0;
2457
2458                         if ((mode == HISSATSU_ZANMA) && !(!monster_living(r_ptr) && (r_ptr->flags3 & RF3_EVIL)))
2459                         {
2460                                 k = 0;
2461                         }
2462
2463                         if (zantetsu_mukou)
2464                         {
2465 #ifdef JP
2466                                 msg_print("¤³¤ó¤ÊÆð¤é¤«¤¤¤â¤Î¤ÏÀÚ¤ì¤ó¡ª");
2467 #else
2468                                 msg_print("You cannot cut such a elastic thing!");
2469 #endif
2470                                 k = 0;
2471                         }
2472
2473                         if (e_j_mukou)
2474                         {
2475 #ifdef JP
2476                                 msg_print("ÃØéá¤Ï¶ì¼ê¤À¡ª");
2477 #else
2478                                 msg_print("Spiders are difficult for you to deal with!");
2479 #endif
2480                                 k /= 2;
2481                         }
2482
2483                         if (mode == HISSATSU_MINEUCHI)
2484                         {
2485                                 int tmp = (10 + randint1(15) + p_ptr->lev / 5);
2486
2487                                 k = 0;
2488                                 anger_monster(m_ptr);
2489
2490                                 if (!(r_ptr->flags3 & (RF3_NO_STUN)))
2491                                 {
2492                                         /* Get stunned */
2493                                         if (MON_STUNNED(m_ptr))
2494                                         {
2495 #ifdef JP
2496                                                 msg_format("%s¤Ï¤Ò¤É¤¯¤â¤¦¤í¤¦¤È¤·¤¿¡£", m_name);
2497 #else
2498                                                 msg_format("%s is more dazed.", m_name);
2499 #endif
2500
2501                                                 tmp /= 2;
2502                                         }
2503                                         else
2504                                         {
2505 #ifdef JP
2506                                                 msg_format("%s ¤Ï¤â¤¦¤í¤¦¤È¤·¤¿¡£", m_name);
2507 #else
2508                                                 msg_format("%s is dazed.", m_name);
2509 #endif
2510                                         }
2511
2512                                         /* Apply stun */
2513                                         (void)set_monster_stunned(c_ptr->m_idx, MON_STUNNED(m_ptr) + tmp);
2514                                 }
2515                                 else
2516                                 {
2517 #ifdef JP
2518                                         msg_format("%s ¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", m_name);
2519 #else
2520                                         msg_format("%s is not effected.", m_name);
2521 #endif
2522                                 }
2523                         }
2524
2525                         /* Modify the damage */
2526                         k = mon_damage_mod(m_ptr, k, (bool)(((o_ptr->tval == TV_POLEARM) && (o_ptr->sval == SV_DEATH_SCYTHE)) || ((p_ptr->pclass == CLASS_BERSERKER) && one_in_(2))));
2527                         if (((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DOKUBARI)) || (mode == HISSATSU_KYUSHO))
2528                         {
2529                                 if ((randint1(randint1(r_ptr->level/7)+5) == 1) && !(r_ptr->flags1 & RF1_UNIQUE) && !(r_ptr->flags7 & RF7_UNIQUE2))
2530                                 {
2531                                         k = m_ptr->hp + 1;
2532 #ifdef JP
2533                                         msg_format("%s¤ÎµÞ½ê¤òÆÍ¤»É¤·¤¿¡ª", m_name);
2534 #else
2535                                         msg_format("You hit %s on a fatal spot!", m_name);
2536 #endif
2537                                 }
2538                                 else k = 1;
2539                         }
2540                         else if ((p_ptr->pclass == CLASS_NINJA) && buki_motteruka(INVEN_RARM + hand) && !p_ptr->icky_wield[hand] && ((p_ptr->cur_lite <= 0) || one_in_(7)))
2541                         {
2542                                 int maxhp = maxroll(r_ptr->hdice, r_ptr->hside);
2543                                 if (one_in_(backstab ? 13 : (stab_fleeing || fuiuchi) ? 15 : 27))
2544                                 {
2545                                         k *= 5;
2546                                         drain_result *= 2;
2547 #ifdef JP
2548                                         msg_format("¿Ï¤¬%s¤Ë¿¼¡¹¤ÈÆÍ¤»É¤µ¤Ã¤¿¡ª", m_name);
2549 #else
2550                                         msg_format("You critically injured %s!", m_name);
2551 #endif
2552                                 }
2553                                 else if (((m_ptr->hp < maxhp/2) && one_in_((p_ptr->num_blow[0]+p_ptr->num_blow[1]+1)*10)) || ((one_in_(666) || ((backstab || fuiuchi) && one_in_(11))) && !(r_ptr->flags1 & RF1_UNIQUE) && !(r_ptr->flags7 & RF7_UNIQUE2)))
2554                                 {
2555                                         if ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->flags7 & RF7_UNIQUE2) || (m_ptr->hp >= maxhp/2))
2556                                         {
2557                                                 k = MAX(k*5, m_ptr->hp/2);
2558                                                 drain_result *= 2;
2559 #ifdef JP
2560                                                 msg_format("%s¤ËÃ×Ì¿½ý¤òÉé¤ï¤»¤¿¡ª", m_name);
2561 #else
2562                                                 msg_format("You fatally injured %s!", m_name);
2563 #endif
2564                                         }
2565                                         else
2566                                         {
2567                                                 k = m_ptr->hp + 1;
2568 #ifdef JP
2569                                                 msg_format("¿Ï¤¬%s¤ÎµÞ½ê¤ò´Ó¤¤¤¿¡ª", m_name);
2570 #else
2571                                                 msg_format("You hit %s on a fatal spot!", m_name);
2572 #endif
2573                                         }
2574                                 }
2575                         }
2576
2577                         /* Complex message */
2578                         if (p_ptr->wizard || cheat_xtra)
2579                         {
2580 #ifdef JP
2581                                 msg_format("%d/%d ¤Î¥À¥á¡¼¥¸¤òÍ¿¤¨¤¿¡£", k, m_ptr->hp);
2582 #else
2583                                 msg_format("You do %d (out of %d) damage.", k, m_ptr->hp);
2584 #endif
2585                         }
2586
2587                         if (k <= 0) can_drain = FALSE;
2588
2589                         if (drain_result > m_ptr->hp)
2590                                 drain_result = m_ptr->hp;
2591
2592                         /* Damage, check for fear and death */
2593                         if (mon_take_hit(c_ptr->m_idx, k, fear, NULL))
2594                         {
2595                                 *mdeath = TRUE;
2596                                 if ((p_ptr->pclass == CLASS_BERSERKER) && energy_use)
2597                                 {
2598                                         if (p_ptr->migite && p_ptr->hidarite)
2599                                         {
2600                                                 if (hand) energy_use = energy_use*3/5+energy_use*num*2/(p_ptr->num_blow[hand]*5);
2601                                                 else energy_use = energy_use*num*3/(p_ptr->num_blow[hand]*5);
2602                                         }
2603                                         else
2604                                         {
2605                                                 energy_use = energy_use*num/p_ptr->num_blow[hand];
2606                                         }
2607                                 }
2608                                 if ((o_ptr->name1 == ART_ZANTETSU) && is_lowlevel)
2609 #ifdef JP
2610                                         msg_print("¤Þ¤¿¤Ä¤Þ¤é¤Ì¤â¤Î¤ò»Â¤Ã¤Æ¤·¤Þ¤Ã¤¿¡¥¡¥¡¥");
2611 #else
2612                                         msg_print("Sigh... Another trifling thing I've cut....");
2613 #endif
2614                                 break;
2615                         }
2616
2617                         /* Anger the monster */
2618                         if (k > 0) anger_monster(m_ptr);
2619
2620                         touch_zap_player(m_ptr);
2621
2622                         /* Are we draining it?  A little note: If the monster is
2623                         dead, the drain does not work... */
2624
2625                         if (can_drain && (drain_result > 0))
2626                         {
2627                                 if (o_ptr->name1 == ART_MURAMASA)
2628                                 {
2629                                         if (is_human)
2630                                         {
2631                                                 int to_h = o_ptr->to_h;
2632                                                 int to_d = o_ptr->to_d;
2633                                                 int i, flag;
2634
2635                                                 flag = 1;
2636                                                 for (i = 0; i < to_h + 3; i++) if (one_in_(4)) flag = 0;
2637                                                 if (flag) to_h++;
2638
2639                                                 flag = 1;
2640                                                 for (i = 0; i < to_d + 3; i++) if (one_in_(4)) flag = 0;
2641                                                 if (flag) to_d++;
2642
2643                                                 if (o_ptr->to_h != to_h || o_ptr->to_d != to_d)
2644                                                 {
2645 #ifdef JP
2646                                                         msg_print("ÍÅÅá¤Ï·ì¤òµÛ¤Ã¤Æ¶¯¤¯¤Ê¤Ã¤¿¡ª");
2647 #else
2648                                                         msg_print("Muramasa sucked blood, and became more powerful!");
2649 #endif
2650                                                         o_ptr->to_h = to_h;
2651                                                         o_ptr->to_d = to_d;
2652                                                 }
2653                                         }
2654                                 }
2655                                 else
2656                                 {
2657                                         if (drain_result > 5) /* Did we really hurt it? */
2658                                         {
2659                                                 drain_heal = damroll(2, drain_result / 6);
2660
2661                                                 /* Hex */
2662                                                 if (hex_spelling(HEX_VAMP_BLADE)) drain_heal *= 2;
2663
2664                                                 if (cheat_xtra)
2665                                                 {
2666 #ifdef JP
2667                                                         msg_format("Draining left: %d", drain_left);
2668 #else
2669                                                         msg_format("Draining left: %d", drain_left);
2670 #endif
2671
2672                                                 }
2673
2674                                                 if (drain_left)
2675                                                 {
2676                                                         if (drain_heal < drain_left)
2677                                                         {
2678                                                                 drain_left -= drain_heal;
2679                                                         }
2680                                                         else
2681                                                         {
2682                                                                 drain_heal = drain_left;
2683                                                                 drain_left = 0;
2684                                                         }
2685
2686                                                         if (drain_msg)
2687                                                         {
2688 #ifdef JP
2689                                                                 msg_format("¿Ï¤¬%s¤«¤éÀ¸Ì¿ÎÏ¤òµÛ¤¤¼è¤Ã¤¿¡ª", m_name);
2690 #else
2691                                                                 msg_format("Your weapon drains life from %s!", m_name);
2692 #endif
2693
2694                                                                 drain_msg = FALSE;
2695                                                         }
2696
2697                                                         drain_heal = (drain_heal * mutant_regenerate_mod) / 100;
2698
2699                                                         hp_player(drain_heal);
2700                                                         /* We get to keep some of it! */
2701                                                 }
2702                                         }
2703                                 }
2704                                 m_ptr->maxhp -= (k+7)/8;
2705                                 if (m_ptr->hp > m_ptr->maxhp) m_ptr->hp = m_ptr->maxhp;
2706                                 if (m_ptr->maxhp < 1) m_ptr->maxhp = 1;
2707                                 weak = TRUE;
2708                         }
2709                         can_drain = FALSE;
2710                         drain_result = 0;
2711
2712                         /* Confusion attack */
2713                         if ((p_ptr->special_attack & ATTACK_CONFUSE) || (chaos_effect == 3) || (mode == HISSATSU_CONF) || hex_spelling(HEX_CONFUSION))
2714                         {
2715                                 /* Cancel glowing hands */
2716                                 if (p_ptr->special_attack & ATTACK_CONFUSE)
2717                                 {
2718                                         p_ptr->special_attack &= ~(ATTACK_CONFUSE);
2719 #ifdef JP
2720                                         msg_print("¼ê¤Îµ±¤¤¬¤Ê¤¯¤Ê¤Ã¤¿¡£");
2721 #else
2722                                         msg_print("Your hands stop glowing.");
2723 #endif
2724                                         p_ptr->redraw |= (PR_STATUS);
2725
2726                                 }
2727
2728                                 /* Confuse the monster */
2729                                 if (r_ptr->flags3 & RF3_NO_CONF)
2730                                 {
2731                                         if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags3 |= RF3_NO_CONF;
2732
2733 #ifdef JP
2734                                         msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", m_name);
2735 #else
2736                                         msg_format("%^s is unaffected.", m_name);
2737 #endif
2738
2739                                 }
2740                                 else if (randint0(100) < r_ptr->level)
2741                                 {
2742 #ifdef JP
2743                                         msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", m_name);
2744 #else
2745                                         msg_format("%^s is unaffected.", m_name);
2746 #endif
2747
2748                                 }
2749                                 else
2750                                 {
2751 #ifdef JP
2752                                         msg_format("%^s¤Ïº®Íð¤·¤¿¤è¤¦¤À¡£", m_name);
2753 #else
2754                                         msg_format("%^s appears confused.", m_name);
2755 #endif
2756
2757                                         (void)set_monster_confused(c_ptr->m_idx, MON_CONFUSED(m_ptr) + 10 + randint0(p_ptr->lev) / 5);
2758                                 }
2759                         }
2760
2761                         else if (chaos_effect == 4)
2762                         {
2763                                 bool resists_tele = FALSE;
2764
2765                                 if (r_ptr->flagsr & RFR_RES_TELE)
2766                                 {
2767                                         if (r_ptr->flags1 & RF1_UNIQUE)
2768                                         {
2769                                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flagsr |= RFR_RES_TELE;
2770 #ifdef JP
2771                                                 msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", m_name);
2772 #else
2773                                                 msg_format("%^s is unaffected!", m_name);
2774 #endif
2775
2776                                                 resists_tele = TRUE;
2777                                         }
2778                                         else if (r_ptr->level > randint1(100))
2779                                         {
2780                                                 if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flagsr |= RFR_RES_TELE;
2781 #ifdef JP
2782                                                 msg_format("%^s¤ÏÄñ¹³ÎÏ¤ò»ý¤Ã¤Æ¤¤¤ë¡ª", m_name);
2783 #else
2784                                                 msg_format("%^s resists!", m_name);
2785 #endif
2786
2787                                                 resists_tele = TRUE;
2788                                         }
2789                                 }
2790
2791                                 if (!resists_tele)
2792                                 {
2793 #ifdef JP
2794                                         msg_format("%^s¤Ï¾Ã¤¨¤¿¡ª", m_name);
2795 #else
2796                                         msg_format("%^s disappears!", m_name);
2797 #endif
2798
2799                                         teleport_away(c_ptr->m_idx, 50, TELEPORT_PASSIVE);
2800                                         num = num_blow + 1; /* Can't hit it anymore! */
2801                                         *mdeath = TRUE;
2802                                 }
2803                         }
2804
2805                         else if ((chaos_effect == 5) && (randint1(90) > r_ptr->level))
2806                         {
2807                                 if (!(r_ptr->flags1 & (RF1_UNIQUE | RF1_QUESTOR)) &&
2808                                     !(r_ptr->flagsr & RFR_EFF_RES_CHAO_MASK))
2809                                 {
2810                                         if (polymorph_monster(y, x))
2811                                         {
2812 #ifdef JP
2813                                                 msg_format("%^s¤ÏÊÑ²½¤·¤¿¡ª", m_name);
2814 #else
2815                                                 msg_format("%^s changes!", m_name);
2816 #endif
2817
2818                                                 *fear = FALSE;
2819                                                 weak = FALSE;
2820                                         }
2821                                         else
2822                                         {
2823 #ifdef JP
2824                                                 msg_format("%^s¤Ë¤Ï¸ú²Ì¤¬¤Ê¤«¤Ã¤¿¡£", m_name);
2825 #else
2826                                                 msg_format("%^s is unaffected.", m_name);
2827 #endif
2828                                         }
2829
2830                                         /* Hack -- Get new monster */
2831                                         m_ptr = &m_list[c_ptr->m_idx];
2832
2833                                         /* Oops, we need a different name... */
2834                                         monster_desc(m_name, m_ptr, 0);
2835
2836                                         /* Hack -- Get new race */
2837                                         r_ptr = &r_info[m_ptr->r_idx];
2838                                 }
2839                         }
2840                         else if (o_ptr->name1 == ART_G_HAMMER)
2841                         {
2842                                 monster_type *m_ptr = &m_list[c_ptr->m_idx];
2843
2844                                 if (m_ptr->hold_o_idx)
2845                                 {
2846                                         object_type *q_ptr = &o_list[m_ptr->hold_o_idx];
2847                                         char o_name[MAX_NLEN];
2848
2849                                         object_desc(o_name, q_ptr, OD_NAME_ONLY);
2850                                         q_ptr->held_m_idx = 0;
2851                                         q_ptr->marked = OM_TOUCHED;
2852                                         m_ptr->hold_o_idx = q_ptr->next_o_idx;
2853                                         q_ptr->next_o_idx = 0;
2854 #ifdef JP
2855                                         msg_format("%s¤òÃ¥¤Ã¤¿¡£", o_name);
2856 #else
2857                                         msg_format("You snatched %s.", o_name);
2858 #endif
2859                                         inven_carry(q_ptr);
2860                                 }
2861                         }
2862                 }
2863
2864                 /* Player misses */
2865                 else
2866                 {
2867                         backstab = FALSE; /* Clumsy! */
2868                         fuiuchi = FALSE; /* Clumsy! */
2869
2870                         if ((o_ptr->tval == TV_POLEARM) && (o_ptr->sval == SV_DEATH_SCYTHE) && one_in_(3))
2871                         {
2872                                 u32b flgs[TR_FLAG_SIZE];
2873
2874                                 /* Sound */
2875                                 sound(SOUND_HIT);
2876
2877                                 /* Message */
2878 #ifdef JP
2879                                 msg_format("¥ß¥¹¡ª %s¤Ë¤«¤ï¤µ¤ì¤¿¡£", m_name);
2880 #else
2881                                 msg_format("You miss %s.", m_name);
2882 #endif
2883                                 /* Message */
2884 #ifdef JP
2885                                 msg_print("¿¶¤ê²ó¤·¤¿Âç³ù¤¬¼«Ê¬¼«¿È¤ËÊÖ¤Ã¤Æ¤¤¿¡ª");
2886 #else
2887                                 msg_print("Your scythe returns to you!");
2888 #endif
2889
2890                                 /* Extract the flags */
2891                                 object_flags(o_ptr, flgs);
2892
2893                                 k = damroll(o_ptr->dd + p_ptr->to_dd[hand], o_ptr->ds + p_ptr->to_ds[hand]);
2894                                 {
2895                                         int mult;
2896                                         switch (p_ptr->mimic_form)
2897                                         {
2898                                         case MIMIC_NONE:
2899                                                 switch (p_ptr->prace)
2900                                                 {
2901                                                         case RACE_YEEK:
2902                                                         case RACE_KLACKON:
2903                                                         case RACE_HUMAN:
2904                                                         case RACE_AMBERITE:
2905                                                         case RACE_DUNADAN:
2906                                                         case RACE_BARBARIAN:
2907                                                         case RACE_BEASTMAN:
2908                                                                 mult = 25;break;
2909                                                         case RACE_HALF_ORC:
2910                                                         case RACE_HALF_TROLL:
2911                                                         case RACE_HALF_OGRE:
2912                                                         case RACE_HALF_GIANT:
2913                                                         case RACE_HALF_TITAN:
2914                                                         case RACE_CYCLOPS:
2915                                                         case RACE_IMP:
2916                                                         case RACE_SKELETON:
2917                                                         case RACE_ZOMBIE:
2918                                                         case RACE_VAMPIRE:
2919                                                         case RACE_SPECTRE:
2920                                                         case RACE_DEMON:
2921                                                         case RACE_DRACONIAN:
2922                                                                 mult = 30;break;
2923                                                         default:
2924                                                                 mult = 10;break;
2925                                                 }
2926                                                 break;
2927                                         case MIMIC_DEMON:
2928                                         case MIMIC_DEMON_LORD:
2929                                         case MIMIC_VAMPIRE:
2930                                                 mult = 30;break;
2931                                         default:
2932                                                 mult = 10;break;
2933                                         }
2934
2935                                         if (p_ptr->align < 0 && mult < 20)
2936                                                 mult = 20;
2937                                         if (!(p_ptr->resist_acid || IS_OPPOSE_ACID() || p_ptr->immune_acid) && (mult < 25))
2938                                                 mult = 25;
2939                                         if (!(p_ptr->resist_elec || IS_OPPOSE_ELEC() || p_ptr->immune_elec) && (mult < 25))
2940                                                 mult = 25;
2941                                         if (!(p_ptr->resist_fire || IS_OPPOSE_FIRE() || p_ptr->immune_fire) && (mult < 25))
2942                                                 mult = 25;
2943                                         if (!(p_ptr->resist_cold || IS_OPPOSE_COLD() || p_ptr->immune_cold) && (mult < 25))
2944                                                 mult = 25;
2945                                         if (!(p_ptr->resist_pois || IS_OPPOSE_POIS()) && (mult < 25))
2946                                                 mult = 25;
2947
2948                                         if ((p_ptr->pclass != CLASS_SAMURAI) && (have_flag(flgs, TR_FORCE_WEAPON)) && (p_ptr->csp > (p_ptr->msp / 30)))
2949                                         {
2950                                                 p_ptr->csp -= (1+(p_ptr->msp / 30));
2951                                                 p_ptr->redraw |= (PR_MANA);
2952                                                 mult = mult * 3 / 2 + 20;
2953                                         }
2954                                         k *= mult;
2955                                         k /= 10;
2956                                 }
2957
2958                                 k = critical_norm(o_ptr->weight, o_ptr->to_h, k, p_ptr->to_h[hand], mode);
2959                                 if (one_in_(6))
2960                                 {
2961                                         int mult = 2;
2962 #ifdef JP
2963                                         msg_format("¥°¥Ã¥µ¥êÀÚ¤êÎö¤«¤ì¤¿¡ª");
2964 #else
2965                                         msg_format("Your weapon cuts deep into yourself!");
2966 #endif
2967                                         /* Try to increase the damage */
2968                                         while (one_in_(4))
2969                                         {
2970                                                 mult++;
2971                                         }
2972
2973                                         k *= mult;
2974                                 }
2975                                 k += (p_ptr->to_d[hand] + o_ptr->to_d);
2976
2977                                 if (k < 0) k = 0;
2978
2979 #ifdef JP
2980                                 take_hit(DAMAGE_FORCE, k, "»à¤ÎÂç³ù", -1);
2981 #else
2982                                 take_hit(DAMAGE_FORCE, k, "Death scythe", -1);
2983 #endif
2984
2985                                 redraw_stuff();
2986                         }
2987                         else
2988                         {
2989                                 /* Sound */
2990                                 sound(SOUND_MISS);
2991
2992                                 /* Message */
2993 #ifdef JP
2994                                 msg_format("¥ß¥¹¡ª %s¤Ë¤«¤ï¤µ¤ì¤¿¡£", m_name);
2995 #else
2996                                 msg_format("You miss %s.", m_name);
2997 #endif
2998                         }
2999                 }
3000                 backstab = FALSE;
3001                 fuiuchi = FALSE;
3002         }
3003
3004
3005         if (weak && !(*mdeath))
3006         {
3007 #ifdef JP
3008                 msg_format("%s¤Ï¼å¤¯¤Ê¤Ã¤¿¤è¤¦¤À¡£", m_name);
3009 #else
3010                 msg_format("%^s seems weakened.", m_name);
3011 #endif
3012         }
3013         if (drain_left != MAX_VAMPIRIC_DRAIN)
3014         {
3015                 if (one_in_(4))
3016                 {
3017                         chg_virtue(V_UNLIFE, 1);
3018                 }
3019         }
3020         /* Mega-Hack -- apply earthquake brand */
3021         if (do_quake)
3022         {
3023                 earthquake(py, px, 10);
3024                 if (!cave[y][x].m_idx) *mdeath = TRUE;
3025         }
3026 }
3027
3028 bool py_attack(int y, int x, int mode)
3029 {
3030         bool            fear = FALSE;
3031         bool            mdeath = FALSE;
3032         bool            stormbringer = FALSE;
3033
3034         cave_type       *c_ptr = &cave[y][x];
3035         monster_type    *m_ptr = &m_list[c_ptr->m_idx];
3036         monster_race    *r_ptr = &r_info[m_ptr->r_idx];
3037         char            m_name[80];
3038
3039         /* Disturb the player */
3040         disturb(0, 1);
3041
3042         energy_use = 100;
3043
3044         if (!p_ptr->migite && !p_ptr->hidarite &&
3045             !(p_ptr->muta2 & (MUT2_HORNS | MUT2_BEAK | MUT2_SCOR_TAIL | MUT2_TRUNK | MUT2_TENTACLES)))
3046         {
3047 #ifdef JP
3048                 msg_format("%s¹¶·â¤Ç¤¤Ê¤¤¡£", (empty_hands(FALSE) == EMPTY_HAND_NONE) ? "Î¾¼ê¤¬¤Õ¤µ¤¬¤Ã¤Æ" : "");
3049 #else
3050                 msg_print("You cannot do attacking.");
3051 #endif
3052                 return FALSE;
3053         }
3054
3055         /* Extract monster name (or "it") */
3056         monster_desc(m_name, m_ptr, 0);
3057
3058         if (m_ptr->ml)
3059         {
3060                 /* Auto-Recall if possible and visible */
3061                 if (!p_ptr->image) monster_race_track(m_ptr->ap_r_idx);
3062
3063                 /* Track a new monster */
3064                 health_track(c_ptr->m_idx);
3065         }
3066
3067         if ((r_ptr->flags1 & RF1_FEMALE) &&
3068             !(p_ptr->stun || p_ptr->confused || p_ptr->image || !m_ptr->ml))
3069         {
3070                 if ((inventory[INVEN_RARM].name1 == ART_ZANTETSU) || (inventory[INVEN_LARM].name1 == ART_ZANTETSU))
3071                 {
3072 #ifdef JP
3073                         msg_print("ÀÛ¼Ô¡¢¤ª¤Ê¤´¤Ï»Â¤ì¤Ì¡ª");
3074 #else
3075                         msg_print("I can not attack women!");
3076 #endif
3077                         return FALSE;
3078                 }
3079         }
3080
3081         if (d_info[dungeon_type].flags1 & DF1_NO_MELEE)
3082         {
3083 #ifdef JP
3084                 msg_print("¤Ê¤¼¤«¹¶·â¤¹¤ë¤³¤È¤¬¤Ç¤¤Ê¤¤¡£");
3085 #else
3086                 msg_print("Something prevent you from attacking.");
3087 #endif
3088                 return FALSE;
3089         }
3090
3091         /* Stop if friendly */
3092         if (!is_hostile(m_ptr) &&
3093             !(p_ptr->stun || p_ptr->confused || p_ptr->image ||
3094             p_ptr->shero || !m_ptr->ml))
3095         {
3096                 if (inventory[INVEN_RARM].name1 == ART_STORMBRINGER) stormbringer = TRUE;
3097                 if (inventory[INVEN_LARM].name1 == ART_STORMBRINGER) stormbringer = TRUE;
3098                 if (stormbringer)
3099                 {
3100 #ifdef JP
3101                         msg_format("¹õ¤¤¿Ï¤Ï¶¯Íß¤Ë%s¤ò¹¶·â¤·¤¿¡ª", m_name);
3102 #else
3103                         msg_format("Your black blade greedily attacks %s!", m_name);
3104 #endif
3105                         chg_virtue(V_INDIVIDUALISM, 1);
3106                         chg_virtue(V_HONOUR, -1);
3107                         chg_virtue(V_JUSTICE, -1);
3108                         chg_virtue(V_COMPASSION, -1);
3109                 }
3110                 else if (p_ptr->pclass != CLASS_BERSERKER)
3111                 {
3112 #ifdef JP
3113                         if (get_check("ËÜÅö¤Ë¹¶·â¤·¤Þ¤¹¤«¡©"))
3114 #else
3115                         if (get_check("Really hit it? "))
3116 #endif
3117                         {
3118                                 chg_virtue(V_INDIVIDUALISM, 1);
3119                                 chg_virtue(V_HONOUR, -1);
3120                                 chg_virtue(V_JUSTICE, -1);
3121                                 chg_virtue(V_COMPASSION, -1);
3122                         }
3123                         else
3124                         {
3125 #ifdef JP
3126                                 msg_format("%s¤ò¹¶·â¤¹¤ë¤Î¤ò»ß¤á¤¿¡£", m_name);
3127 #else
3128                                 msg_format("You stop to avoid hitting %s.", m_name);
3129 #endif
3130                                 return FALSE;
3131                         }
3132                 }
3133         }
3134
3135
3136         /* Handle player fear */
3137         if (p_ptr->afraid)
3138         {
3139                 /* Message */
3140                 if (m_ptr->ml)
3141 #ifdef JP
3142                         msg_format("¶²¤¯¤Æ%s¤ò¹¶·â¤Ç¤¤Ê¤¤¡ª", m_name);
3143 #else
3144                         msg_format("You are too afraid to attack %s!", m_name);
3145 #endif
3146
3147                 else
3148 #ifdef JP
3149                         msg_format ("¤½¤Ã¤Á¤Ë¤Ï²¿¤«¶²¤¤¤â¤Î¤¬¤¤¤ë¡ª");
3150 #else
3151                         msg_format ("There is something scary in your way!");
3152 #endif
3153
3154                 /* Disturb the monster */
3155                 (void)set_monster_csleep(c_ptr->m_idx, 0);
3156
3157                 /* Done */
3158                 return FALSE;
3159         }
3160
3161         if (MON_CSLEEP(m_ptr)) /* It is not honorable etc to attack helpless victims */
3162         {
3163                 if (!(r_ptr->flags3 & RF3_EVIL) || one_in_(5)) chg_virtue(V_COMPASSION, -1);
3164                 if (!(r_ptr->flags3 & RF3_EVIL) || one_in_(5)) chg_virtue(V_HONOUR, -1);
3165         }
3166
3167         if (p_ptr->migite && p_ptr->hidarite)
3168         {
3169                 if ((p_ptr->skill_exp[GINOU_NITOURYU] < s_info[p_ptr->pclass].s_max[GINOU_NITOURYU]) && ((p_ptr->skill_exp[GINOU_NITOURYU] - 1000) / 200 < r_ptr->level))
3170                 {
3171                         if (p_ptr->skill_exp[GINOU_NITOURYU] < WEAPON_EXP_BEGINNER)
3172                                 p_ptr->skill_exp[GINOU_NITOURYU] += 80;
3173                         else if(p_ptr->skill_exp[GINOU_NITOURYU] < WEAPON_EXP_SKILLED)
3174                                 p_ptr->skill_exp[GINOU_NITOURYU] += 4;
3175                         else if(p_ptr->skill_exp[GINOU_NITOURYU] < WEAPON_EXP_EXPERT)
3176                                 p_ptr->skill_exp[GINOU_NITOURYU] += 1;
3177                         else if(p_ptr->skill_exp[GINOU_NITOURYU] < WEAPON_EXP_MASTER)
3178                                 if (one_in_(3)) p_ptr->skill_exp[GINOU_NITOURYU] += 1;
3179                         p_ptr->update |= (PU_BONUS);
3180                 }
3181         }
3182
3183         /* Gain riding experience */
3184         if (p_ptr->riding)
3185         {
3186                 int cur = p_ptr->skill_exp[GINOU_RIDING];
3187                 int max = s_info[p_ptr->pclass].s_max[GINOU_RIDING];
3188
3189                 if (cur < max)
3190                 {
3191                         int ridinglevel = r_info[m_list[p_ptr->riding].r_idx].level;
3192                         int targetlevel = r_ptr->level;
3193                         int inc = 0;
3194
3195                         if ((cur / 200 - 5) < targetlevel)
3196                                 inc += 1;
3197
3198                         /* Extra experience */
3199                         if ((cur / 100) < ridinglevel)
3200                         {
3201                                 if ((cur / 100 + 15) < ridinglevel)
3202                                         inc += 1 + (ridinglevel - (cur / 100 + 15));
3203                                 else
3204                                         inc += 1;
3205                         }
3206
3207                         p_ptr->skill_exp[GINOU_RIDING] = MIN(max, cur + inc);
3208
3209                         p_ptr->update |= (PU_BONUS);
3210                 }
3211         }
3212
3213         riding_t_m_idx = c_ptr->m_idx;
3214         if (p_ptr->migite) py_attack_aux(y, x, &fear, &mdeath, 0, mode);
3215         if (p_ptr->hidarite && !mdeath) py_attack_aux(y, x, &fear, &mdeath, 1, mode);
3216
3217         /* Mutations which yield extra 'natural' attacks */
3218         if (!mdeath)
3219         {
3220                 if ((p_ptr->muta2 & MUT2_HORNS) && !mdeath)
3221                         natural_attack(c_ptr->m_idx, MUT2_HORNS, &fear, &mdeath);
3222                 if ((p_ptr->muta2 & MUT2_BEAK) && !mdeath)
3223                         natural_attack(c_ptr->m_idx, MUT2_BEAK, &fear, &mdeath);
3224                 if ((p_ptr->muta2 & MUT2_SCOR_TAIL) && !mdeath)
3225                         natural_attack(c_ptr->m_idx, MUT2_SCOR_TAIL, &fear, &mdeath);
3226                 if ((p_ptr->muta2 & MUT2_TRUNK) && !mdeath)
3227                         natural_attack(c_ptr->m_idx, MUT2_TRUNK, &fear, &mdeath);
3228                 if ((p_ptr->muta2 & MUT2_TENTACLES) && !mdeath)
3229                         natural_attack(c_ptr->m_idx, MUT2_TENTACLES, &fear, &mdeath);
3230         }
3231
3232         /* Hack -- delay fear messages */
3233         if (fear && m_ptr->ml && !mdeath)
3234         {
3235                 /* Sound */
3236                 sound(SOUND_FLEE);
3237
3238                 /* Message */
3239 #ifdef JP
3240                 msg_format("%^s¤Ï¶²ÉÝ¤·¤ÆÆ¨¤²½Ð¤·¤¿¡ª", m_name);
3241 #else
3242                 msg_format("%^s flees in terror!", m_name);
3243 #endif
3244
3245         }
3246
3247         if ((p_ptr->special_defense & KATA_IAI) && ((mode != HISSATSU_IAI) || mdeath))
3248         {
3249                 set_action(ACTION_NONE);
3250         }
3251
3252         return mdeath;
3253 }
3254
3255
3256 bool pattern_seq(int c_y, int c_x, int n_y, int n_x)
3257 {
3258         feature_type *cur_f_ptr = &f_info[cave[c_y][c_x].feat];
3259         feature_type *new_f_ptr = &f_info[cave[n_y][n_x].feat];
3260         bool is_pattern_tile_cur = have_flag(cur_f_ptr->flags, FF_PATTERN);
3261         bool is_pattern_tile_new = have_flag(new_f_ptr->flags, FF_PATTERN);
3262         int pattern_type_cur, pattern_type_new;
3263
3264         if (!is_pattern_tile_cur && !is_pattern_tile_new) return TRUE;
3265
3266         pattern_type_cur = is_pattern_tile_cur ? cur_f_ptr->subtype : NOT_PATTERN_TILE;
3267         pattern_type_new = is_pattern_tile_new ? new_f_ptr->subtype : NOT_PATTERN_TILE;
3268
3269         if (pattern_type_new == PATTERN_TILE_START)
3270         {
3271                 if (!is_pattern_tile_cur && !p_ptr->confused && !p_ptr->stun && !p_ptr->image)
3272                 {
3273 #ifdef JP
3274                         if (get_check("¥Ñ¥¿¡¼¥ó¤Î¾å¤òÊâ¤»Ï¤á¤ë¤È¡¢Á´¤Æ¤òÊâ¤«¤Ê¤±¤ì¤Ð¤Ê¤ê¤Þ¤»¤ó¡£¤¤¤¤¤Ç¤¹¤«¡©"))
3275 #else
3276                         if (get_check("If you start walking the Pattern, you must walk the whole way. Ok? "))
3277 #endif
3278                                 return TRUE;
3279                         else
3280                                 return FALSE;
3281                 }
3282                 else
3283                         return TRUE;
3284         }
3285         else if ((pattern_type_new == PATTERN_TILE_OLD) ||
3286                  (pattern_type_new == PATTERN_TILE_END) ||
3287                  (pattern_type_new == PATTERN_TILE_WRECKED))
3288         {
3289                 if (is_pattern_tile_cur)
3290                 {
3291                         return TRUE;
3292                 }
3293                 else
3294                 {
3295 #ifdef JP
3296                         msg_print("¥Ñ¥¿¡¼¥ó¤Î¾å¤òÊâ¤¯¤Ë¤Ï¥¹¥¿¡¼¥ÈÃÏÅÀ¤«¤éÊâ¤»Ï¤á¤Ê¤¯¤Æ¤Ï¤Ê¤ê¤Þ¤»¤ó¡£");
3297 #else
3298                         msg_print("You must start walking the Pattern from the startpoint.");
3299 #endif
3300
3301                         return FALSE;
3302                 }
3303         }
3304         else if ((pattern_type_new == PATTERN_TILE_TELEPORT) ||
3305                  (pattern_type_cur == PATTERN_TILE_TELEPORT))
3306         {
3307                 return TRUE;
3308         }
3309         else if (pattern_type_cur == PATTERN_TILE_START)
3310         {
3311                 if (is_pattern_tile_new)
3312                         return TRUE;
3313                 else
3314                 {
3315 #ifdef JP
3316                         msg_print("¥Ñ¥¿¡¼¥ó¤Î¾å¤ÏÀµ¤·¤¤½ç½ø¤ÇÊâ¤«¤Í¤Ð¤Ê¤ê¤Þ¤»¤ó¡£");
3317 #else
3318                         msg_print("You must walk the Pattern in correct order.");
3319 #endif
3320
3321                         return FALSE;
3322                 }
3323         }
3324         else if ((pattern_type_cur == PATTERN_TILE_OLD) ||
3325                  (pattern_type_cur == PATTERN_TILE_END) ||
3326                  (pattern_type_cur == PATTERN_TILE_WRECKED))
3327         {
3328                 if (!is_pattern_tile_new)
3329                 {
3330 #ifdef JP
3331                         msg_print("¥Ñ¥¿¡¼¥ó¤òÆ§¤ß³°¤·¤Æ¤Ï¤¤¤±¤Þ¤»¤ó¡£");
3332 #else
3333                         msg_print("You may not step off from the Pattern.");
3334 #endif
3335
3336                         return FALSE;
3337                 }
3338                 else
3339                 {
3340                         return TRUE;
3341                 }
3342         }
3343         else
3344         {
3345                 if (!is_pattern_tile_cur)
3346                 {
3347 #ifdef JP
3348                         msg_print("¥Ñ¥¿¡¼¥ó¤Î¾å¤òÊâ¤¯¤Ë¤Ï¥¹¥¿¡¼¥ÈÃÏÅÀ¤«¤éÊâ¤»Ï¤á¤Ê¤¯¤Æ¤Ï¤Ê¤ê¤Þ¤»¤ó¡£");
3349 #else
3350                         msg_print("You must start walking the Pattern from the startpoint.");
3351 #endif
3352
3353                         return FALSE;
3354                 }
3355                 else
3356                 {
3357                         byte ok_move = PATTERN_TILE_START;
3358                         switch (pattern_type_cur)
3359                         {
3360                                 case PATTERN_TILE_1:
3361                                         ok_move = PATTERN_TILE_2;
3362                                         break;
3363                                 case PATTERN_TILE_2:
3364                                         ok_move = PATTERN_TILE_3;
3365                                         break;
3366                                 case PATTERN_TILE_3:
3367                                         ok_move = PATTERN_TILE_4;
3368                                         break;
3369                                 case PATTERN_TILE_4:
3370                                         ok_move = PATTERN_TILE_1;
3371                                         break;
3372                                 default:
3373                                         if (p_ptr->wizard)
3374 #ifdef JP
3375                                                 msg_format("¤ª¤«¤·¤Ê¥Ñ¥¿¡¼¥óÊâ¹Ô¡¢%d¡£", pattern_type_cur);
3376 #else
3377                                                 msg_format("Funny Pattern walking, %d.", pattern_type_cur);
3378 #endif
3379
3380                                         return TRUE; /* Goof-up */
3381                         }
3382
3383                         if ((pattern_type_new == ok_move) ||
3384                             (pattern_type_new == pattern_type_cur))
3385                                 return TRUE;
3386                         else
3387                         {
3388                                 if (!is_pattern_tile_new)
3389 #ifdef JP
3390                                         msg_print("¥Ñ¥¿¡¼¥ó¤òÆ§¤ß³°¤·¤Æ¤Ï¤¤¤±¤Þ¤»¤ó¡£");
3391 #else
3392                                         msg_print("You may not step off from the Pattern.");
3393 #endif
3394                                 else
3395 #ifdef JP
3396                                         msg_print("¥Ñ¥¿¡¼¥ó¤Î¾å¤ÏÀµ¤·¤¤½ç½ø¤ÇÊâ¤«¤Í¤Ð¤Ê¤ê¤Þ¤»¤ó¡£");
3397 #else
3398                                         msg_print("You must walk the Pattern in correct order.");
3399 #endif
3400
3401                                 return FALSE;
3402                         }
3403                 }
3404         }
3405 }
3406
3407
3408 bool player_can_enter(s16b feature, u16b mode)
3409 {
3410         feature_type *f_ptr = &f_info[feature];
3411
3412         if (p_ptr->riding) return monster_can_cross_terrain(feature, &r_info[m_list[p_ptr->riding].r_idx], mode | CEM_RIDING);
3413
3414         /* Pattern */
3415         if (have_flag(f_ptr->flags, FF_PATTERN))
3416         {
3417                 if (!(mode & CEM_P_CAN_ENTER_PATTERN)) return FALSE;
3418         }
3419
3420         /* "CAN" flags */
3421         if (have_flag(f_ptr->flags, FF_CAN_FLY) && p_ptr->levitation) return TRUE;
3422         if (have_flag(f_ptr->flags, FF_CAN_SWIM) && p_ptr->can_swim) return TRUE;
3423         if (have_flag(f_ptr->flags, FF_CAN_PASS) && p_ptr->pass_wall) return TRUE;
3424
3425         if (!have_flag(f_ptr->flags, FF_MOVE)) return FALSE;
3426
3427         return TRUE;
3428 }
3429
3430
3431 /*
3432  * Move the player
3433  */
3434 bool move_player_effect(int ny, int nx, u32b mpe_mode)
3435 {
3436         cave_type *c_ptr = &cave[ny][nx];
3437         feature_type *f_ptr = &f_info[c_ptr->feat];
3438
3439         if (!(mpe_mode & MPE_STAYING))
3440         {
3441                 int oy = py;
3442                 int ox = px;
3443                 cave_type *oc_ptr = &cave[oy][ox];
3444                 int om_idx = oc_ptr->m_idx;
3445                 int nm_idx = c_ptr->m_idx;
3446
3447                 /* Move the player */
3448                 py = ny;
3449                 px = nx;
3450
3451                 /* Hack -- For moving monster or riding player's moving */
3452                 if (!(mpe_mode & MPE_DONT_SWAP_MON))
3453                 {
3454                         /* Swap two monsters */
3455                         c_ptr->m_idx = om_idx;
3456                         oc_ptr->m_idx = nm_idx;
3457
3458                         if (om_idx > 0) /* Monster on old spot (or p_ptr->riding) */
3459                         {
3460                                 monster_type *om_ptr = &m_list[om_idx];
3461                                 om_ptr->fy = ny;
3462                                 om_ptr->fx = nx;
3463                                 update_mon(om_idx, TRUE);
3464                         }
3465
3466                         if (nm_idx > 0) /* Monster on new spot */
3467                         {
3468                                 monster_type *nm_ptr = &m_list[nm_idx];
3469                                 nm_ptr->fy = oy;
3470                                 nm_ptr->fx = ox;
3471                                 update_mon(nm_idx, TRUE);
3472                         }
3473                 }
3474
3475                 /* Redraw old spot */
3476                 lite_spot(oy, ox);
3477
3478                 /* Redraw new spot */
3479                 lite_spot(ny, nx);
3480
3481                 /* Check for new panel (redraw map) */
3482                 verify_panel();
3483
3484                 if (mpe_mode & MPE_FORGET_FLOW)
3485                 {
3486                         forget_flow();
3487
3488                         /* Mega-Hack -- Forget the view */
3489                         p_ptr->update |= (PU_UN_VIEW);
3490
3491                         /* Redraw map */
3492                         p_ptr->redraw |= (PR_MAP);
3493                 }
3494
3495                 /* Update stuff */
3496                 p_ptr->update |= (PU_VIEW | PU_LITE | PU_FLOW | PU_MON_LITE | PU_DISTANCE);
3497
3498                 /* Window stuff */
3499                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
3500
3501                 /* Remove "unsafe" flag */
3502                 if ((!p_ptr->blind && !no_lite()) || !is_trap(c_ptr->feat)) c_ptr->info &= ~(CAVE_UNSAFE);
3503
3504                 /* For get everything when requested hehe I'm *NASTY* */
3505                 if (dun_level && (d_info[dungeon_type].flags1 & DF1_FORGET)) wiz_dark();
3506
3507                 /* Handle stuff */
3508                 if (mpe_mode & MPE_HANDLE_STUFF) handle_stuff();
3509
3510                 if (p_ptr->pclass == CLASS_NINJA)
3511                 {
3512                         if (c_ptr->info & (CAVE_GLOW)) set_superstealth(FALSE);
3513                         else if (p_ptr->cur_lite <= 0) set_superstealth(TRUE);
3514                 }
3515
3516                 if ((p_ptr->action == ACTION_HAYAGAKE) &&
3517                     (!have_flag(f_ptr->flags, FF_PROJECT) ||
3518                      (!p_ptr->levitation && have_flag(f_ptr->flags, FF_DEEP))))
3519                 {
3520 #ifdef JP
3521                         msg_print("¤³¤³¤Ç¤ÏÁÇÁá¤¯Æ°¤±¤Ê¤¤¡£");
3522 #else
3523                         msg_print("You cannot run in here.");
3524 #endif
3525                         set_action(ACTION_NONE);
3526                 }
3527         }
3528
3529         if (mpe_mode & MPE_ENERGY_USE)
3530         {
3531                 if (music_singing(MUSIC_WALL))
3532                 {
3533                         (void)project(0, 0, py, px, (60 + p_ptr->lev), GF_DISINTEGRATE,
3534                                 PROJECT_KILL | PROJECT_ITEM, -1);
3535
3536                         if (!player_bold(ny, nx) || p_ptr->is_dead || p_ptr->leaving) return FALSE;
3537                 }
3538
3539                 /* Spontaneous Searching */
3540                 if ((p_ptr->skill_fos >= 50) || (0 == randint0(50 - p_ptr->skill_fos)))
3541                 {
3542                         search();
3543                 }
3544
3545                 /* Continuous Searching */
3546                 if (p_ptr->action == ACTION_SEARCH)
3547                 {
3548                         search();
3549                 }
3550         }
3551
3552         /* Handle "objects" */
3553         if (!(mpe_mode & MPE_DONT_PICKUP))
3554         {
3555                 carry((mpe_mode & MPE_DO_PICKUP) ? TRUE : FALSE);
3556         }
3557
3558         /* Handle "store doors" */
3559         if (have_flag(f_ptr->flags, FF_STORE))
3560         {
3561                 /* Disturb */
3562                 disturb(0, 1);
3563
3564                 energy_use = 0;
3565                 /* Hack -- Enter store */
3566                 command_new = SPECIAL_KEY_STORE;
3567         }
3568
3569         /* Handle "building doors" -KMW- */
3570         else if (have_flag(f_ptr->flags, FF_BLDG))
3571         {
3572                 /* Disturb */
3573                 disturb(0, 1);
3574
3575                 energy_use = 0;
3576                 /* Hack -- Enter building */
3577                 command_new = SPECIAL_KEY_BUILDING;
3578         }
3579
3580         /* Handle quest areas -KMW- */
3581         else if (have_flag(f_ptr->flags, FF_QUEST_ENTER))
3582         {
3583                 /* Disturb */
3584                 disturb(0, 1);
3585
3586                 energy_use = 0;
3587                 /* Hack -- Enter quest level */
3588                 command_new = SPECIAL_KEY_QUEST;
3589         }
3590
3591         else if (have_flag(f_ptr->flags, FF_QUEST_EXIT))
3592         {
3593                 if (quest[p_ptr->inside_quest].type == QUEST_TYPE_FIND_EXIT)
3594                 {
3595                         if (record_fix_quest) do_cmd_write_nikki(NIKKI_FIX_QUEST_C, p_ptr->inside_quest, NULL);
3596                         quest[p_ptr->inside_quest].status = QUEST_STATUS_COMPLETED;
3597                         quest[p_ptr->inside_quest].complev = (byte)p_ptr->lev;
3598 #ifdef JP
3599                         msg_print("¥¯¥¨¥¹¥È¤òÃ£À®¤·¤¿¡ª");
3600 #else
3601                         msg_print("You accomplished your quest!");
3602 #endif
3603
3604                         msg_print(NULL);
3605                 }
3606
3607                 leave_quest_check();
3608
3609                 p_ptr->inside_quest = c_ptr->special;
3610                 dun_level = 0;
3611                 p_ptr->oldpx = 0;
3612                 p_ptr->oldpy = 0;
3613
3614                 p_ptr->leaving = TRUE;
3615         }
3616
3617         /* Set off a trap */
3618         else if (have_flag(f_ptr->flags, FF_HIT_TRAP) && !(mpe_mode & MPE_STAYING))
3619         {
3620                 /* Disturb */
3621                 disturb(0, 1);
3622
3623                 /* Hidden trap */
3624                 if (c_ptr->mimic || have_flag(f_ptr->flags, FF_SECRET))
3625                 {
3626                         /* Message */
3627 #ifdef JP
3628                         msg_print("¥È¥é¥Ã¥×¤À¡ª");
3629 #else
3630                         msg_print("You found a trap!");
3631 #endif
3632
3633                         /* Pick a trap */
3634                         disclose_grid(py, px);
3635                 }
3636
3637                 /* Hit the trap */
3638                 hit_trap((mpe_mode & MPE_BREAK_TRAP) ? TRUE : FALSE);
3639
3640                 if (!player_bold(ny, nx) || p_ptr->is_dead || p_ptr->leaving) return FALSE;
3641         }
3642
3643         /* Warn when leaving trap detected region */
3644         if (!(mpe_mode & MPE_STAYING) && (disturb_trap_detect || alert_trap_detect)
3645             && p_ptr->dtrap && !(c_ptr->info & CAVE_IN_DETECT))
3646         {
3647                 /* No duplicate warning */
3648                 p_ptr->dtrap = FALSE;
3649
3650                 /* You are just on the edge */
3651                 if (!(c_ptr->info & CAVE_UNSAFE))
3652                 {
3653                         if (alert_trap_detect)
3654                         {
3655 #ifdef JP
3656                                 msg_print("* Ãí°Õ:¤³¤ÎÀè¤Ï¥È¥é¥Ã¥×¤Î´¶ÃÎÈÏ°Ï³°¤Ç¤¹¡ª *");
3657 #else
3658                                 msg_print("*Leaving trap detect region!*");
3659 #endif
3660                         }
3661
3662                         if (disturb_trap_detect) disturb(0, 1);
3663                 }
3664         }
3665
3666         return player_bold(ny, nx) && !p_ptr->is_dead && !p_ptr->leaving;
3667 }
3668
3669
3670 bool trap_can_be_ignored(int feat)
3671 {
3672         feature_type *f_ptr = &f_info[feat];
3673
3674         if (!have_flag(f_ptr->flags, FF_TRAP)) return TRUE;
3675
3676         switch (f_ptr->subtype)
3677         {
3678         case TRAP_TRAPDOOR:
3679         case TRAP_PIT:
3680         case TRAP_SPIKED_PIT:
3681         case TRAP_POISON_PIT:
3682                 if (p_ptr->levitation) return TRUE;
3683                 break;
3684         case TRAP_TELEPORT:
3685                 if (p_ptr->anti_tele) return TRUE;
3686                 break;
3687         case TRAP_FIRE:
3688                 if (p_ptr->immune_fire) return TRUE;
3689                 break;
3690         case TRAP_ACID:
3691                 if (p_ptr->immune_acid) return TRUE;
3692                 break;
3693         case TRAP_BLIND:
3694                 if (p_ptr->resist_blind) return TRUE;
3695                 break;
3696         case TRAP_CONFUSE:
3697                 if (p_ptr->resist_conf) return TRUE;
3698                 break;
3699         case TRAP_POISON:
3700                 if (p_ptr->resist_pois) return TRUE;
3701                 break;
3702         case TRAP_SLEEP:
3703                 if (p_ptr->free_act) return TRUE;
3704                 break;
3705         }
3706
3707         return FALSE;
3708 }
3709
3710
3711 /*
3712  * Determine if a "boundary" grid is "floor mimic"
3713  */
3714 #define boundary_floor(C, F, MF) \
3715         ((C)->mimic && permanent_wall(F) && \
3716          (have_flag((MF)->flags, FF_MOVE) || have_flag((MF)->flags, FF_CAN_FLY)) && \
3717          have_flag((MF)->flags, FF_PROJECT) && \
3718          !have_flag((MF)->flags, FF_OPEN))
3719
3720 /*
3721  * Move player in the given direction, with the given "pickup" flag.
3722  *
3723  * This routine should (probably) always induce energy expenditure.
3724  *
3725  * Note that moving will *always* take a turn, and will *always* hit
3726  * any monster which might be in the destination grid.  Previously,
3727  * moving into walls was "free" and did NOT hit invisible monsters.
3728  */
3729 void move_player(int dir, bool do_pickup, bool break_trap)
3730 {
3731         /* Find the result of moving */
3732         int y = py + ddy[dir];
3733         int x = px + ddx[dir];
3734
3735         /* Examine the destination */
3736         cave_type *c_ptr = &cave[y][x];
3737
3738         feature_type *f_ptr = &f_info[c_ptr->feat];
3739
3740         monster_type *m_ptr;
3741
3742         monster_type *riding_m_ptr = &m_list[p_ptr->riding];
3743         monster_race *riding_r_ptr = &r_info[p_ptr->riding ? riding_m_ptr->r_idx : 0]; /* Paranoia */
3744
3745         char m_name[80];
3746
3747         bool p_can_enter = player_can_enter(c_ptr->feat, CEM_P_CAN_ENTER_PATTERN);
3748         bool p_can_kill_walls = FALSE;
3749         bool stormbringer = FALSE;
3750
3751         bool oktomove = TRUE;
3752         bool do_past = FALSE;
3753
3754         /* Exit the area */
3755         if (!dun_level && !p_ptr->wild_mode &&
3756                 ((x == 0) || (x == MAX_WID - 1) ||
3757                  (y == 0) || (y == MAX_HGT - 1)))
3758         {
3759                 /* Can the player enter the grid? */
3760                 if (c_ptr->mimic && player_can_enter(c_ptr->mimic, 0))
3761                 {
3762                         /* Hack: move to new area */
3763                         if ((y == 0) && (x == 0))
3764                         {
3765                                 p_ptr->wilderness_y--;
3766                                 p_ptr->wilderness_x--;
3767                                 p_ptr->oldpy = cur_hgt - 2;
3768                                 p_ptr->oldpx = cur_wid - 2;
3769                                 ambush_flag = FALSE;
3770                         }
3771
3772                         else if ((y == 0) && (x == MAX_WID - 1))
3773                         {
3774                                 p_ptr->wilderness_y--;
3775                                 p_ptr->wilderness_x++;
3776                                 p_ptr->oldpy = cur_hgt - 2;
3777                                 p_ptr->oldpx = 1;
3778                                 ambush_flag = FALSE;
3779                         }
3780
3781                         else if ((y == MAX_HGT - 1) && (x == 0))
3782                         {
3783                                 p_ptr->wilderness_y++;
3784                                 p_ptr->wilderness_x--;
3785                                 p_ptr->oldpy = 1;
3786                                 p_ptr->oldpx = cur_wid - 2;
3787                                 ambush_flag = FALSE;
3788                         }
3789
3790                         else if ((y == MAX_HGT - 1) && (x == MAX_WID - 1))
3791                         {
3792                                 p_ptr->wilderness_y++;
3793                                 p_ptr->wilderness_x++;
3794                                 p_ptr->oldpy = 1;
3795                                 p_ptr->oldpx = 1;
3796                                 ambush_flag = FALSE;
3797                         }
3798
3799                         else if (y == 0)
3800                         {
3801                                 p_ptr->wilderness_y--;
3802                                 p_ptr->oldpy = cur_hgt - 2;
3803                                 p_ptr->oldpx = x;
3804                                 ambush_flag = FALSE;
3805                         }
3806
3807                         else if (y == MAX_HGT - 1)
3808                         {
3809                                 p_ptr->wilderness_y++;
3810                                 p_ptr->oldpy = 1;
3811                                 p_ptr->oldpx = x;
3812                                 ambush_flag = FALSE;
3813                         }
3814
3815                         else if (x == 0)
3816                         {
3817                                 p_ptr->wilderness_x--;
3818                                 p_ptr->oldpx = cur_wid - 2;
3819                                 p_ptr->oldpy = y;
3820                                 ambush_flag = FALSE;
3821                         }
3822
3823                         else if (x == MAX_WID - 1)
3824                         {
3825                                 p_ptr->wilderness_x++;
3826                                 p_ptr->oldpx = 1;
3827                                 p_ptr->oldpy = y;
3828                                 ambush_flag = FALSE;
3829                         }
3830
3831                         p_ptr->leaving = TRUE;
3832                         energy_use = 100;
3833
3834                         return;
3835                 }
3836
3837                 /* "Blocked" message appears later */
3838                 /* oktomove = FALSE; */
3839                 p_can_enter = FALSE;
3840         }
3841
3842         /* Get the monster */
3843         m_ptr = &m_list[c_ptr->m_idx];
3844
3845
3846         if (inventory[INVEN_RARM].name1 == ART_STORMBRINGER) stormbringer = TRUE;
3847         if (inventory[INVEN_LARM].name1 == ART_STORMBRINGER) stormbringer = TRUE;
3848
3849         /* Player can not walk through "walls"... */
3850         /* unless in Shadow Form */
3851         p_can_kill_walls = p_ptr->kill_wall && have_flag(f_ptr->flags, FF_HURT_DISI) &&
3852                 (!p_can_enter || !have_flag(f_ptr->flags, FF_LOS)) &&
3853                 !have_flag(f_ptr->flags, FF_PERMANENT);
3854
3855         /* Hack -- attack monsters */
3856         if (c_ptr->m_idx && (m_ptr->ml || p_can_enter || p_can_kill_walls))
3857         {
3858                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
3859
3860                 /* Attack -- only if we can see it OR it is not in a wall */
3861                 if (!is_hostile(m_ptr) &&
3862                     !(p_ptr->confused || p_ptr->image || !m_ptr->ml || p_ptr->stun ||
3863                     ((p_ptr->muta2 & MUT2_BERS_RAGE) && p_ptr->shero)) &&
3864                     pattern_seq(py, px, y, x) && (p_can_enter || p_can_kill_walls))
3865                 {
3866                         /* Disturb the monster */
3867                         (void)set_monster_csleep(c_ptr->m_idx, 0);
3868
3869                         /* Extract monster name (or "it") */
3870                         monster_desc(m_name, m_ptr, 0);
3871
3872                         if (m_ptr->ml)
3873                         {
3874                                 /* Auto-Recall if possible and visible */
3875                                 if (!p_ptr->image) monster_race_track(m_ptr->ap_r_idx);
3876
3877                                 /* Track a new monster */
3878                                 health_track(c_ptr->m_idx);
3879                         }
3880
3881                         /* displace? */
3882                         if ((stormbringer && (randint1(1000) > 666)) || (p_ptr->pclass == CLASS_BERSERKER))
3883                         {
3884                                 py_attack(y, x, 0);
3885                                 oktomove = FALSE;
3886                         }
3887                         else if (monster_can_cross_terrain(cave[py][px].feat, r_ptr, 0))
3888                         {
3889                                 do_past = TRUE;
3890                         }
3891                         else
3892                         {
3893 #ifdef JP
3894                                 msg_format("%^s¤¬¼ÙËâ¤À¡ª", m_name);
3895 #else
3896                                 msg_format("%^s is in your way!", m_name);
3897 #endif
3898
3899                                 energy_use = 0;
3900                                 oktomove = FALSE;
3901                         }
3902
3903                         /* now continue on to 'movement' */
3904                 }
3905                 else
3906                 {
3907                         py_attack(y, x, 0);
3908                         oktomove = FALSE;
3909                 }
3910         }
3911
3912         if (oktomove && p_ptr->riding)
3913         {
3914                 if (riding_r_ptr->flags1 & RF1_NEVER_MOVE)
3915                 {
3916 #ifdef JP
3917                         msg_print("Æ°¤±¤Ê¤¤¡ª");
3918 #else
3919                         msg_print("Can't move!");
3920 #endif
3921                         energy_use = 0;
3922                         oktomove = FALSE;
3923                         disturb(0, 1);
3924                 }
3925                 else if (MON_MONFEAR(riding_m_ptr))
3926                 {
3927                         char m_name[80];
3928
3929                         /* Acquire the monster name */
3930                         monster_desc(m_name, riding_m_ptr, 0);
3931
3932                         /* Dump a message */
3933 #ifdef JP
3934                         msg_format("%s¤¬¶²ÉÝ¤·¤Æ¤¤¤ÆÀ©¸æ¤Ç¤¤Ê¤¤¡£", m_name);
3935 #else
3936                         msg_format("%^s is too scared to control.", m_name);
3937 #endif
3938                         oktomove = FALSE;
3939                         disturb(0, 1);
3940                 }
3941                 else if (p_ptr->riding_ryoute)
3942                 {
3943                         oktomove = FALSE;
3944                         disturb(0, 1);
3945                 }
3946                 else if (have_flag(f_ptr->flags, FF_CAN_FLY) && (riding_r_ptr->flags7 & RF7_CAN_FLY))
3947                 {
3948                         /* Allow moving */
3949                 }
3950                 else if (have_flag(f_ptr->flags, FF_CAN_SWIM) && (riding_r_ptr->flags7 & RF7_CAN_SWIM))
3951                 {
3952                         /* Allow moving */
3953                 }
3954                 else if (have_flag(f_ptr->flags, FF_WATER) &&
3955                         !(riding_r_ptr->flags7 & RF7_AQUATIC) &&
3956                         (have_flag(f_ptr->flags, FF_DEEP) || (riding_r_ptr->flags2 & RF2_AURA_FIRE)))
3957                 {
3958 #ifdef JP
3959                         msg_format("%s¤Î¾å¤Ë¹Ô¤±¤Ê¤¤¡£", f_name + f_info[get_feat_mimic(c_ptr)].name);
3960 #else
3961                         msg_print("Can't swim.");
3962 #endif
3963                         energy_use = 0;
3964                         oktomove = FALSE;
3965                         disturb(0, 1);
3966                 }
3967                 else if (!have_flag(f_ptr->flags, FF_WATER) && (riding_r_ptr->flags7 & RF7_AQUATIC))
3968                 {
3969 #ifdef JP
3970                         msg_format("%s¤«¤é¾å¤¬¤ì¤Ê¤¤¡£", f_name + f_info[get_feat_mimic(&cave[py][px])].name);
3971 #else
3972                         msg_print("Can't land.");
3973 #endif
3974                         energy_use = 0;
3975                         oktomove = FALSE;
3976                         disturb(0, 1);
3977                 }
3978                 else if (have_flag(f_ptr->flags, FF_LAVA) && !(riding_r_ptr->flagsr & RFR_EFF_IM_FIRE_MASK))
3979                 {
3980 #ifdef JP
3981                         msg_format("%s¤Î¾å¤Ë¹Ô¤±¤Ê¤¤¡£", f_name + f_info[get_feat_mimic(c_ptr)].name);
3982 #else
3983                         msg_print("Too hot to go through.");
3984 #endif
3985                         energy_use = 0;
3986                         oktomove = FALSE;
3987                         disturb(0, 1);
3988                 }
3989
3990                 if (oktomove && MON_STUNNED(riding_m_ptr) && one_in_(2))
3991                 {
3992                         char m_name[80];
3993                         monster_desc(m_name, riding_m_ptr, 0);
3994 #ifdef JP
3995                         msg_format("%s¤¬Û¯Û°¤È¤·¤Æ¤¤¤Æ¤¦¤Þ¤¯Æ°¤±¤Ê¤¤¡ª",m_name);
3996 #else
3997                         msg_format("You cannot control stunned %s!",m_name);
3998 #endif
3999                         oktomove = FALSE;
4000                         disturb(0, 1);
4001                 }
4002         }
4003
4004         if (!oktomove)
4005         {
4006         }
4007
4008         else if (!have_flag(f_ptr->flags, FF_MOVE) && have_flag(f_ptr->flags, FF_CAN_FLY) && !p_ptr->levitation)
4009         {
4010 #ifdef JP
4011                 msg_format("¶õ¤òÈô¤Ð¤Ê¤¤¤È%s¤Î¾å¤Ë¤Ï¹Ô¤±¤Ê¤¤¡£", f_name + f_info[get_feat_mimic(c_ptr)].name);
4012 #else
4013                 msg_format("You need to fly to go through the %s.", f_name + f_info[get_feat_mimic(c_ptr)].name);
4014 #endif
4015
4016                 energy_use = 0;
4017                 running = 0;
4018                 oktomove = FALSE;
4019         }
4020
4021         /*
4022          * Player can move through trees and
4023          * has effective -10 speed
4024          * Rangers can move without penality
4025          */
4026         else if (have_flag(f_ptr->flags, FF_TREE) && !p_can_kill_walls)
4027         {
4028                 if ((p_ptr->pclass != CLASS_RANGER) && !p_ptr->levitation && (!p_ptr->riding || !(riding_r_ptr->flags8 & RF8_WILD_WOOD))) energy_use *= 2;
4029         }
4030
4031 #ifdef ALLOW_EASY_DISARM /* TNB */
4032
4033         /* Disarm a visible trap */
4034         else if ((do_pickup != easy_disarm) && have_flag(f_ptr->flags, FF_DISARM) && !c_ptr->mimic)
4035         {
4036                 if (!trap_can_be_ignored(c_ptr->feat))
4037                 {
4038                         (void)do_cmd_disarm_aux(y, x, dir);
4039                         return;
4040                 }
4041         }
4042
4043 #endif /* ALLOW_EASY_DISARM -- TNB */
4044
4045         /* Player can not walk through "walls" unless in wraith form...*/
4046         else if (!p_can_enter && !p_can_kill_walls)
4047         {
4048                 /* Feature code (applying "mimic" field) */
4049                 s16b feat = get_feat_mimic(c_ptr);
4050                 feature_type *mimic_f_ptr = &f_info[feat];
4051                 cptr name = f_name + mimic_f_ptr->name;
4052
4053                 oktomove = FALSE;
4054
4055                 /* Notice things in the dark */
4056                 if (!(c_ptr->info & CAVE_MARK) && !player_can_see_bold(y, x))
4057                 {
4058                         /* Boundary floor mimic */
4059                         if (boundary_floor(c_ptr, f_ptr, mimic_f_ptr))
4060                         {
4061 #ifdef JP
4062                                 msg_print("¤½¤ì°Ê¾åÀè¤Ë¤Ï¿Ê¤á¤Ê¤¤¤è¤¦¤À¡£");
4063 #else
4064                                 msg_print("You feel you cannot go any more.");
4065 #endif
4066                         }
4067
4068                         /* Wall (or secret door) */
4069                         else
4070                         {
4071 #ifdef JP
4072                                 msg_format("%s¤¬¹Ô¤¯¼ê¤ò¤Ï¤Ð¤ó¤Ç¤¤¤ë¤è¤¦¤À¡£", name);
4073 #else
4074                                 msg_format("You feel %s %s blocking your way.",
4075                                         is_a_vowel(name[0]) ? "an" : "a", name);
4076 #endif
4077
4078                                 c_ptr->info |= (CAVE_MARK);
4079                                 lite_spot(y, x);
4080                         }
4081                 }
4082
4083                 /* Notice things */
4084                 else
4085                 {
4086                         /* Boundary floor mimic */
4087                         if (boundary_floor(c_ptr, f_ptr, mimic_f_ptr))
4088                         {
4089 #ifdef JP
4090                                 msg_print("¤½¤ì°Ê¾åÀè¤Ë¤Ï¿Ê¤á¤Ê¤¤¡£");
4091 #else
4092                                 msg_print("You cannot go any more.");
4093 #endif
4094
4095                                 if (!(p_ptr->confused || p_ptr->stun || p_ptr->image))
4096                                         energy_use = 0;
4097                         }
4098
4099                         /* Wall (or secret door) */
4100                         else
4101                         {
4102 #ifdef ALLOW_EASY_OPEN
4103                                 /* Closed doors */
4104                                 if (easy_open && is_closed_door(feat) && easy_open_door(y, x)) return;
4105 #endif /* ALLOW_EASY_OPEN */
4106
4107 #ifdef JP
4108                                 msg_format("%s¤¬¹Ô¤¯¼ê¤ò¤Ï¤Ð¤ó¤Ç¤¤¤ë¡£", name);
4109 #else
4110                                 msg_format("There is %s %s blocking your way.",
4111                                         is_a_vowel(name[0]) ? "an" : "a", name);
4112 #endif
4113
4114                                 /*
4115                                  * Well, it makes sense that you lose time bumping into
4116                                  * a wall _if_ you are confused, stunned or blind; but
4117                                  * typing mistakes should not cost you a turn...
4118                                  */
4119                                 if (!(p_ptr->confused || p_ptr->stun || p_ptr->image))
4120                                         energy_use = 0;
4121                         }
4122                 }
4123
4124                 /* Disturb the player */
4125                 disturb(0, 1);
4126
4127                 /* Sound */
4128                 if (!boundary_floor(c_ptr, f_ptr, mimic_f_ptr)) sound(SOUND_HITWALL);
4129         }
4130
4131         /* Normal movement */
4132         if (oktomove && !pattern_seq(py, px, y, x))
4133         {
4134                 if (!(p_ptr->confused || p_ptr->stun || p_ptr->image))
4135                 {
4136                         energy_use = 0;
4137                 }
4138
4139                 /* To avoid a loop with running */
4140                 disturb(0, 1);
4141
4142                 oktomove = FALSE;
4143         }
4144
4145         /* Normal movement */
4146         if (oktomove)
4147         {
4148                 u32b mpe_mode = MPE_ENERGY_USE;
4149
4150                 if (p_ptr->warning)
4151                 {
4152                         if (!process_warning(x, y))
4153                         {
4154                                 energy_use = 25;
4155                                 return;
4156                         }
4157                 }
4158
4159                 if (do_past)
4160                 {
4161 #ifdef JP
4162                         msg_format("%s¤ò²¡¤·Âà¤±¤¿¡£", m_name);
4163 #else
4164                         msg_format("You push past %s.", m_name);
4165 #endif
4166                 }
4167
4168                 /* Change oldpx and oldpy to place the player well when going back to big mode */
4169                 if (p_ptr->wild_mode)
4170                 {
4171                         if (ddy[dir] > 0)  p_ptr->oldpy = 1;
4172                         if (ddy[dir] < 0)  p_ptr->oldpy = MAX_HGT - 2;
4173                         if (ddy[dir] == 0) p_ptr->oldpy = MAX_HGT / 2;
4174                         if (ddx[dir] > 0)  p_ptr->oldpx = 1;
4175                         if (ddx[dir] < 0)  p_ptr->oldpx = MAX_WID - 2;
4176                         if (ddx[dir] == 0) p_ptr->oldpx = MAX_WID / 2;
4177                 }
4178
4179                 if (p_can_kill_walls)
4180                 {
4181                         cave_alter_feat(y, x, FF_HURT_DISI);
4182
4183                         /* Update some things -- similar to GF_KILL_WALL */
4184                         p_ptr->update |= (PU_FLOW);
4185                 }
4186
4187                 /* Sound */
4188                 /* sound(SOUND_WALK); */
4189
4190 #ifdef ALLOW_EASY_DISARM /* TNB */
4191
4192                 if (do_pickup != always_pickup) mpe_mode |= MPE_DO_PICKUP;
4193
4194 #else /* ALLOW_EASY_DISARM -- TNB */
4195
4196                 if (do_pickup) mpe_mode |= MPE_DO_PICKUP;
4197
4198 #endif /* ALLOW_EASY_DISARM -- TNB */
4199
4200                 if (break_trap) mpe_mode |= MPE_BREAK_TRAP;
4201
4202                 /* Move the player */
4203                 (void)move_player_effect(y, x, mpe_mode);
4204         }
4205 }
4206
4207
4208 static bool ignore_avoid_run;
4209
4210 /*
4211  * Hack -- Check for a "known wall" (see below)
4212  */
4213 static int see_wall(int dir, int y, int x)
4214 {
4215         cave_type   *c_ptr;
4216
4217         /* Get the new location */
4218         y += ddy[dir];
4219         x += ddx[dir];
4220
4221         /* Illegal grids are not known walls */
4222         if (!in_bounds2(y, x)) return (FALSE);
4223
4224         /* Access grid */
4225         c_ptr = &cave[y][x];
4226
4227         /* Must be known to the player */
4228         if (c_ptr->info & (CAVE_MARK))
4229         {
4230                 /* Feature code (applying "mimic" field) */
4231                 s16b         feat = get_feat_mimic(c_ptr);
4232                 feature_type *f_ptr = &f_info[feat];
4233
4234                 /* Wall grids are known walls */
4235                 if (!player_can_enter(feat, 0)) return !have_flag(f_ptr->flags, FF_DOOR);
4236
4237                 /* Don't run on a tree unless explicitly requested */
4238                 if (have_flag(f_ptr->flags, FF_AVOID_RUN) && !ignore_avoid_run)
4239                         return TRUE;
4240
4241                 /* Don't run in a wall */
4242                 if (!have_flag(f_ptr->flags, FF_MOVE) && !have_flag(f_ptr->flags, FF_CAN_FLY))
4243                         return !have_flag(f_ptr->flags, FF_DOOR);
4244         }
4245
4246         return FALSE;
4247 }
4248
4249
4250 /*
4251  * Hack -- Check for an "unknown corner" (see below)
4252  */
4253 static int see_nothing(int dir, int y, int x)
4254 {
4255         /* Get the new location */
4256         y += ddy[dir];
4257         x += ddx[dir];
4258
4259         /* Illegal grids are unknown */
4260         if (!in_bounds2(y, x)) return (TRUE);
4261
4262         /* Memorized grids are always known */
4263         if (cave[y][x].info & (CAVE_MARK)) return (FALSE);
4264
4265         /* Viewable door/wall grids are known */
4266         if (player_can_see_bold(y, x)) return (FALSE);
4267
4268         /* Default */
4269         return (TRUE);
4270 }
4271
4272
4273
4274
4275
4276 /*
4277  * The running algorithm:                       -CJS-
4278  *
4279  * In the diagrams below, the player has just arrived in the
4280  * grid marked as '@', and he has just come from a grid marked
4281  * as 'o', and he is about to enter the grid marked as 'x'.
4282  *
4283  * Of course, if the "requested" move was impossible, then you
4284  * will of course be blocked, and will stop.
4285  *
4286  * Overview: You keep moving until something interesting happens.
4287  * If you are in an enclosed space, you follow corners. This is
4288  * the usual corridor scheme. If you are in an open space, you go
4289  * straight, but stop before entering enclosed space. This is
4290  * analogous to reaching doorways. If you have enclosed space on
4291  * one side only (that is, running along side a wall) stop if
4292  * your wall opens out, or your open space closes in. Either case
4293  * corresponds to a doorway.
4294  *
4295  * What happens depends on what you can really SEE. (i.e. if you
4296  * have no light, then running along a dark corridor is JUST like
4297  * running in a dark room.) The algorithm works equally well in
4298  * corridors, rooms, mine tailings, earthquake rubble, etc, etc.
4299  *
4300  * These conditions are kept in static memory:
4301  * find_openarea         You are in the open on at least one
4302  * side.
4303  * find_breakleft        You have a wall on the left, and will
4304  * stop if it opens
4305  * find_breakright       You have a wall on the right, and will
4306  * stop if it opens
4307  *
4308  * To initialize these conditions, we examine the grids adjacent
4309  * to the grid marked 'x', two on each side (marked 'L' and 'R').
4310  * If either one of the two grids on a given side is seen to be
4311  * closed, then that side is considered to be closed. If both
4312  * sides are closed, then it is an enclosed (corridor) run.
4313  *
4314  * LL           L
4315  * @x          LxR
4316  * RR          @R
4317  *
4318  * Looking at more than just the immediate squares is
4319  * significant. Consider the following case. A run along the
4320  * corridor will stop just before entering the center point,
4321  * because a choice is clearly established. Running in any of
4322  * three available directions will be defined as a corridor run.
4323  * Note that a minor hack is inserted to make the angled corridor
4324  * entry (with one side blocked near and the other side blocked
4325  * further away from the runner) work correctly. The runner moves
4326  * diagonally, but then saves the previous direction as being
4327  * straight into the gap. Otherwise, the tail end of the other
4328  * entry would be perceived as an alternative on the next move.
4329  *
4330  * #.#
4331  * ##.##
4332  * .@x..
4333  * ##.##
4334  * #.#
4335  *
4336  * Likewise, a run along a wall, and then into a doorway (two
4337  * runs) will work correctly. A single run rightwards from @ will
4338  * stop at 1. Another run right and down will enter the corridor
4339  * and make the corner, stopping at the 2.
4340  *
4341  * ##################
4342  * o@x       1
4343  * ########### ######
4344  * #2          #
4345  * #############
4346  *
4347  * After any move, the function area_affect is called to
4348  * determine the new surroundings, and the direction of
4349  * subsequent moves. It examines the current player location
4350  * (at which the runner has just arrived) and the previous
4351  * direction (from which the runner is considered to have come).
4352  *
4353  * Moving one square in some direction places you adjacent to
4354  * three or five new squares (for straight and diagonal moves
4355  * respectively) to which you were not previously adjacent,
4356  * marked as '!' in the diagrams below.
4357  *
4358  *   ...!              ...
4359  *   .o@!  (normal)    .o.!  (diagonal)
4360  *   ...!  (east)      ..@!  (south east)
4361  *                      !!!
4362  *
4363  * You STOP if any of the new squares are interesting in any way:
4364  * for example, if they contain visible monsters or treasure.
4365  *
4366  * You STOP if any of the newly adjacent squares seem to be open,
4367  * and you are also looking for a break on that side. (that is,
4368  * find_openarea AND find_break).
4369  *
4370  * You STOP if any of the newly adjacent squares do NOT seem to be
4371  * open and you are in an open area, and that side was previously
4372  * entirely open.
4373  *
4374  * Corners: If you are not in the open (i.e. you are in a corridor)
4375  * and there is only one way to go in the new squares, then turn in
4376  * that direction. If there are more than two new ways to go, STOP.
4377  * If there are two ways to go, and those ways are separated by a
4378  * square which does not seem to be open, then STOP.
4379  *
4380  * Otherwise, we have a potential corner. There are two new open
4381  * squares, which are also adjacent. One of the new squares is
4382  * diagonally located, the other is straight on (as in the diagram).
4383  * We consider two more squares further out (marked below as ?).
4384  *
4385  * We assign "option" to the straight-on grid, and "option2" to the
4386  * diagonal grid, and "check_dir" to the grid marked 's'.
4387  *
4388  * ##s
4389  * @x?
4390  * #.?
4391  *
4392  * If they are both seen to be closed, then it is seen that no benefit
4393  * is gained from moving straight. It is a known corner.  To cut the
4394  * corner, go diagonally, otherwise go straight, but pretend you
4395  * stepped diagonally into that next location for a full view next
4396  * time. Conversely, if one of the ? squares is not seen to be closed,
4397  * then there is a potential choice. We check to see whether it is a
4398  * potential corner or an intersection/room entrance.  If the square
4399  * two spaces straight ahead, and the space marked with 's' are both
4400  * unknown space, then it is a potential corner and enter if
4401  * find_examine is set, otherwise must stop because it is not a
4402  * corner. (find_examine option is removed and always is TRUE.)
4403  */
4404
4405
4406
4407
4408 /*
4409  * Hack -- allow quick "cycling" through the legal directions
4410  */
4411 static byte cycle[] =
4412 { 1, 2, 3, 6, 9, 8, 7, 4, 1, 2, 3, 6, 9, 8, 7, 4, 1 };
4413
4414 /*
4415  * Hack -- map each direction into the "middle" of the "cycle[]" array
4416  */
4417 static byte chome[] =
4418 { 0, 8, 9, 10, 7, 0, 11, 6, 5, 4 };
4419
4420 /*
4421  * The direction we are running
4422  */
4423 static byte find_current;
4424
4425 /*
4426  * The direction we came from
4427  */
4428 static byte find_prevdir;
4429
4430 /*
4431  * We are looking for open area
4432  */
4433 static bool find_openarea;
4434
4435 /*
4436  * We are looking for a break
4437  */
4438 static bool find_breakright;
4439 static bool find_breakleft;
4440
4441
4442
4443 /*
4444  * Initialize the running algorithm for a new direction.
4445  *
4446  * Diagonal Corridor -- allow diaginal entry into corridors.
4447  *
4448  * Blunt Corridor -- If there is a wall two spaces ahead and
4449  * we seem to be in a corridor, then force a turn into the side
4450  * corridor, must be moving straight into a corridor here. ???
4451  *
4452  * Diagonal Corridor    Blunt Corridor (?)
4453  *       # #                  #
4454  *       #x#                 @x#
4455  *       @p.                  p
4456  */
4457 static void run_init(int dir)
4458 {
4459         int             row, col, deepleft, deepright;
4460         int             i, shortleft, shortright;
4461
4462
4463         /* Save the direction */
4464         find_current = dir;
4465
4466         /* Assume running straight */
4467         find_prevdir = dir;
4468
4469         /* Assume looking for open area */
4470         find_openarea = TRUE;
4471
4472         /* Assume not looking for breaks */
4473         find_breakright = find_breakleft = FALSE;
4474
4475         /* Assume no nearby walls */
4476         deepleft = deepright = FALSE;
4477         shortright = shortleft = FALSE;
4478
4479         p_ptr->run_py = py;
4480         p_ptr->run_px = px;
4481
4482         /* Find the destination grid */
4483         row = py + ddy[dir];
4484         col = px + ddx[dir];
4485
4486         ignore_avoid_run = cave_have_flag_bold(row, col, FF_AVOID_RUN);
4487
4488         /* Extract cycle index */
4489         i = chome[dir];
4490
4491         /* Check for walls */
4492         if (see_wall(cycle[i+1], py, px))
4493         {
4494                 find_breakleft = TRUE;
4495                 shortleft = TRUE;
4496         }
4497         else if (see_wall(cycle[i+1], row, col))
4498         {
4499                 find_breakleft = TRUE;
4500                 deepleft = TRUE;
4501         }
4502
4503         /* Check for walls */
4504         if (see_wall(cycle[i-1], py, px))
4505         {
4506                 find_breakright = TRUE;
4507                 shortright = TRUE;
4508         }
4509         else if (see_wall(cycle[i-1], row, col))
4510         {
4511                 find_breakright = TRUE;
4512                 deepright = TRUE;
4513         }
4514
4515         /* Looking for a break */
4516         if (find_breakleft && find_breakright)
4517         {
4518                 /* Not looking for open area */
4519                 find_openarea = FALSE;
4520
4521                 /* Hack -- allow angled corridor entry */
4522                 if (dir & 0x01)
4523                 {
4524                         if (deepleft && !deepright)
4525                         {
4526                                 find_prevdir = cycle[i - 1];
4527                         }
4528                         else if (deepright && !deepleft)
4529                         {
4530                                 find_prevdir = cycle[i + 1];
4531                         }
4532                 }
4533
4534                 /* Hack -- allow blunt corridor entry */
4535                 else if (see_wall(cycle[i], row, col))
4536                 {
4537                         if (shortleft && !shortright)
4538                         {
4539                                 find_prevdir = cycle[i - 2];
4540                         }
4541                         else if (shortright && !shortleft)
4542                         {
4543                                 find_prevdir = cycle[i + 2];
4544                         }
4545                 }
4546         }
4547 }
4548
4549
4550 /*
4551  * Update the current "run" path
4552  *
4553  * Return TRUE if the running should be stopped
4554  */
4555 static bool run_test(void)
4556 {
4557         int         prev_dir, new_dir, check_dir = 0;
4558         int         row, col;
4559         int         i, max, inv;
4560         int         option = 0, option2 = 0;
4561         cave_type   *c_ptr;
4562         s16b        feat;
4563         feature_type *f_ptr;
4564
4565         /* Where we came from */
4566         prev_dir = find_prevdir;
4567
4568
4569         /* Range of newly adjacent grids */
4570         max = (prev_dir & 0x01) + 1;
4571
4572         /* break run when leaving trap detected region */
4573         if ((disturb_trap_detect || alert_trap_detect)
4574             && p_ptr->dtrap && !(cave[py][px].info & CAVE_IN_DETECT))
4575         {
4576                 /* No duplicate warning */
4577                 p_ptr->dtrap = FALSE;
4578
4579                 /* You are just on the edge */
4580                 if (!(cave[py][px].info & CAVE_UNSAFE))
4581                 {
4582                         if (alert_trap_detect)
4583                         {
4584 #ifdef JP
4585                                 msg_print("* Ãí°Õ:¤³¤ÎÀè¤Ï¥È¥é¥Ã¥×¤Î´¶ÃÎÈÏ°Ï³°¤Ç¤¹¡ª *");
4586 #else
4587                                 msg_print("*Leaving trap detect region!*");
4588 #endif
4589                         }
4590
4591                         if (disturb_trap_detect)
4592                         {
4593                                 /* Break Run */
4594                                 return(TRUE);
4595                         }
4596                 }
4597         }
4598
4599         /* Look at every newly adjacent square. */
4600         for (i = -max; i <= max; i++)
4601         {
4602                 s16b this_o_idx, next_o_idx = 0;
4603
4604                 /* New direction */
4605                 new_dir = cycle[chome[prev_dir] + i];
4606
4607                 /* New location */
4608                 row = py + ddy[new_dir];
4609                 col = px + ddx[new_dir];
4610
4611                 /* Access grid */
4612                 c_ptr = &cave[row][col];
4613
4614                 /* Feature code (applying "mimic" field) */
4615                 feat = get_feat_mimic(c_ptr);
4616                 f_ptr = &f_info[feat];
4617
4618                 /* Visible monsters abort running */
4619                 if (c_ptr->m_idx)
4620                 {
4621                         monster_type *m_ptr = &m_list[c_ptr->m_idx];
4622
4623                         /* Visible monster */
4624                         if (m_ptr->ml) return (TRUE);
4625                 }
4626
4627                 /* Visible objects abort running */
4628                 for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
4629                 {
4630                         object_type *o_ptr;
4631
4632                         /* Acquire object */
4633                         o_ptr = &o_list[this_o_idx];
4634
4635                         /* Acquire next object */
4636                         next_o_idx = o_ptr->next_o_idx;
4637
4638                         /* Visible object */
4639                         if (o_ptr->marked & OM_FOUND) return (TRUE);
4640                 }
4641
4642                 /* Assume unknown */
4643                 inv = TRUE;
4644
4645                 /* Check memorized grids */
4646                 if (c_ptr->info & (CAVE_MARK))
4647                 {
4648                         bool notice = have_flag(f_ptr->flags, FF_NOTICE);
4649
4650                         if (notice && have_flag(f_ptr->flags, FF_MOVE))
4651                         {
4652                                 /* Open doors */
4653                                 if (find_ignore_doors && have_flag(f_ptr->flags, FF_DOOR) && have_flag(f_ptr->flags, FF_CLOSE))
4654                                 {
4655                                         /* Option -- ignore */
4656                                         notice = FALSE;
4657                                 }
4658
4659                                 /* Stairs */
4660                                 else if (find_ignore_stairs && have_flag(f_ptr->flags, FF_STAIRS))
4661                                 {
4662                                         /* Option -- ignore */
4663                                         notice = FALSE;
4664                                 }
4665
4666                                 /* Lava */
4667                                 else if (have_flag(f_ptr->flags, FF_LAVA) && (p_ptr->immune_fire || IS_INVULN()))
4668                                 {
4669                                         /* Ignore */
4670                                         notice = FALSE;
4671                                 }
4672
4673                                 /* Deep water */
4674                                 else if (have_flag(f_ptr->flags, FF_WATER) && have_flag(f_ptr->flags, FF_DEEP) &&
4675                                          (p_ptr->levitation || p_ptr->can_swim || (p_ptr->total_weight <= weight_limit())))
4676                                 {
4677                                         /* Ignore */
4678                                         notice = FALSE;
4679                                 }
4680                         }
4681
4682                         /* Interesting feature */
4683                         if (notice) return (TRUE);
4684
4685                         /* The grid is "visible" */
4686                         inv = FALSE;
4687                 }
4688
4689                 /* Analyze unknown grids and floors considering mimic */
4690                 if (inv || !see_wall(0, row, col))
4691                 {
4692                         /* Looking for open area */
4693                         if (find_openarea)
4694                         {
4695                                 /* Nothing */
4696                         }
4697
4698                         /* The first new direction. */
4699                         else if (!option)
4700                         {
4701                                 option = new_dir;
4702                         }
4703
4704                         /* Three new directions. Stop running. */
4705                         else if (option2)
4706                         {
4707                                 return (TRUE);
4708                         }
4709
4710                         /* Two non-adjacent new directions.  Stop running. */
4711                         else if (option != cycle[chome[prev_dir] + i - 1])
4712                         {
4713                                 return (TRUE);
4714                         }
4715
4716                         /* Two new (adjacent) directions (case 1) */
4717                         else if (new_dir & 0x01)
4718                         {
4719                                 check_dir = cycle[chome[prev_dir] + i - 2];
4720                                 option2 = new_dir;
4721                         }
4722
4723                         /* Two new (adjacent) directions (case 2) */
4724                         else
4725                         {
4726                                 check_dir = cycle[chome[prev_dir] + i + 1];
4727                                 option2 = option;
4728                                 option = new_dir;
4729                         }
4730                 }
4731
4732                 /* Obstacle, while looking for open area */
4733                 else
4734                 {
4735                         if (find_openarea)
4736                         {
4737                                 if (i < 0)
4738                                 {
4739                                         /* Break to the right */
4740                                         find_breakright = TRUE;
4741                                 }
4742
4743                                 else if (i > 0)
4744                                 {
4745                                         /* Break to the left */
4746                                         find_breakleft = TRUE;
4747                                 }
4748                         }
4749                 }
4750         }
4751
4752         /* Looking for open area */
4753         if (find_openarea)
4754         {
4755                 /* Hack -- look again */
4756                 for (i = -max; i < 0; i++)
4757                 {
4758                         /* Unknown grid or non-wall */
4759                         if (!see_wall(cycle[chome[prev_dir] + i], py, px))
4760                         {
4761                                 /* Looking to break right */
4762                                 if (find_breakright)
4763                                 {
4764                                         return (TRUE);
4765                                 }
4766                         }
4767
4768                         /* Obstacle */
4769                         else
4770                         {
4771                                 /* Looking to break left */
4772                                 if (find_breakleft)
4773                                 {
4774                                         return (TRUE);
4775                                 }
4776                         }
4777                 }
4778
4779                 /* Hack -- look again */
4780                 for (i = max; i > 0; i--)
4781                 {
4782                         /* Unknown grid or non-wall */
4783                         if (!see_wall(cycle[chome[prev_dir] + i], py, px))
4784                         {
4785                                 /* Looking to break left */
4786                                 if (find_breakleft)
4787                                 {
4788                                         return (TRUE);
4789                                 }
4790                         }
4791
4792                         /* Obstacle */
4793                         else
4794                         {
4795                                 /* Looking to break right */
4796                                 if (find_breakright)
4797                                 {
4798                                         return (TRUE);
4799                                 }
4800                         }
4801                 }
4802         }
4803
4804         /* Not looking for open area */
4805         else
4806         {
4807                 /* No options */
4808                 if (!option)
4809                 {
4810                         return (TRUE);
4811                 }
4812
4813                 /* One option */
4814                 else if (!option2)
4815                 {
4816                         /* Primary option */
4817                         find_current = option;
4818
4819                         /* No other options */
4820                         find_prevdir = option;
4821                 }
4822
4823                 /* Two options, examining corners */
4824                 else if (!find_cut)
4825                 {
4826                         /* Primary option */
4827                         find_current = option;
4828
4829                         /* Hack -- allow curving */
4830                         find_prevdir = option2;
4831                 }
4832
4833                 /* Two options, pick one */
4834                 else
4835                 {
4836                         /* Get next location */
4837                         row = py + ddy[option];
4838                         col = px + ddx[option];
4839
4840                         /* Don't see that it is closed off. */
4841                         /* This could be a potential corner or an intersection. */
4842                         if (!see_wall(option, row, col) ||
4843                             !see_wall(check_dir, row, col))
4844                         {
4845                                 /* Can not see anything ahead and in the direction we */
4846                                 /* are turning, assume that it is a potential corner. */
4847                                 if (see_nothing(option, row, col) &&
4848                                     see_nothing(option2, row, col))
4849                                 {
4850                                         find_current = option;
4851                                         find_prevdir = option2;
4852                                 }
4853
4854                                 /* STOP: we are next to an intersection or a room */
4855                                 else
4856                                 {
4857                                         return (TRUE);
4858                                 }
4859                         }
4860
4861                         /* This corner is seen to be enclosed; we cut the corner. */
4862                         else if (find_cut)
4863                         {
4864                                 find_current = option2;
4865                                 find_prevdir = option2;
4866                         }
4867
4868                         /* This corner is seen to be enclosed, and we */
4869                         /* deliberately go the long way. */
4870                         else
4871                         {
4872                                 find_current = option;
4873                                 find_prevdir = option2;
4874                         }
4875                 }
4876         }
4877
4878         /* About to hit a known wall, stop */
4879         if (see_wall(find_current, py, px))
4880         {
4881                 return (TRUE);
4882         }
4883
4884         /* Failure */
4885         return (FALSE);
4886 }
4887
4888
4889
4890 /*
4891  * Take one step along the current "run" path
4892  */
4893 void run_step(int dir)
4894 {
4895         /* Start running */
4896         if (dir)
4897         {
4898                 /* Ignore AVOID_RUN on a first step */
4899                 ignore_avoid_run = TRUE;
4900
4901                 /* Hack -- do not start silly run */
4902                 if (see_wall(dir, py, px))
4903                 {
4904                         /* Message */
4905 #ifdef JP
4906                         msg_print("¤½¤ÎÊý¸þ¤Ë¤ÏÁö¤ì¤Þ¤»¤ó¡£");
4907 #else
4908                         msg_print("You cannot run in that direction.");
4909 #endif
4910
4911                         /* Disturb */
4912                         disturb(0, 0);
4913
4914                         /* Done */
4915                         return;
4916                 }
4917
4918                 /* Initialize */
4919                 run_init(dir);
4920         }
4921
4922         /* Keep running */
4923         else
4924         {
4925                 /* Update run */
4926                 if (run_test())
4927                 {
4928                         /* Disturb */
4929                         disturb(0, 0);
4930
4931                         /* Done */
4932                         return;
4933                 }
4934         }
4935
4936         /* Decrease the run counter */
4937         if (--running <= 0) return;
4938
4939         /* Take time */
4940         energy_use = 100;
4941
4942         /* Move the player, using the "pickup" flag */
4943 #ifdef ALLOW_EASY_DISARM /* TNB */
4944
4945         move_player(find_current, FALSE, FALSE);
4946
4947 #else /* ALLOW_EASY_DISARM -- TNB */
4948
4949         move_player(find_current, always_pickup, FALSE);
4950
4951 #endif /* ALLOW_EASY_DISARM -- TNB */
4952
4953         if (player_bold(p_ptr->run_py, p_ptr->run_px))
4954         {
4955                 p_ptr->run_py = 0;
4956                 p_ptr->run_px = 0;
4957                 disturb(0, 0);
4958         }
4959 }
4960
4961
4962 #ifdef TRAVEL
4963 /*
4964  * Test for traveling
4965  */
4966 static int travel_test(int prev_dir)
4967 {
4968         int new_dir = 0;
4969         int i, max;
4970         const cave_type *c_ptr;
4971         int cost;
4972
4973         /* Cannot travel when blind */
4974         if (p_ptr->blind || no_lite())
4975         {
4976                 msg_print(_("ÌÜ¤¬¸«¤¨¤Ê¤¤¡ª", "You cannot see!"));
4977                 return (0);
4978         }
4979
4980         /* break run when leaving trap detected region */
4981         if ((disturb_trap_detect || alert_trap_detect)
4982             && p_ptr->dtrap && !(cave[py][px].info & CAVE_IN_DETECT))
4983         {
4984                 /* No duplicate warning */
4985                 p_ptr->dtrap = FALSE;
4986
4987                 /* You are just on the edge */
4988                 if (!(cave[py][px].info & CAVE_UNSAFE))
4989                 {
4990                         if (alert_trap_detect)
4991                         {
4992 #ifdef JP
4993                                 msg_print("* Ãí°Õ:¤³¤ÎÀè¤Ï¥È¥é¥Ã¥×¤Î´¶ÃÎÈÏ°Ï³°¤Ç¤¹¡ª *");
4994 #else
4995                                 msg_print("*Leaving trap detect region!*");
4996 #endif
4997                         }
4998
4999                         if (disturb_trap_detect)
5000                         {
5001                                 /* Break Run */
5002                                 return (0);
5003                         }
5004                 }
5005         }
5006
5007         /* Range of newly adjacent grids */
5008         max = (prev_dir & 0x01) + 1;
5009
5010         /* Look at every newly adjacent square. */
5011         for (i = -max; i <= max; i++)
5012         {
5013                 /* New direction */
5014                 int dir = cycle[chome[prev_dir] + i];
5015
5016                 /* New location */
5017                 int row = py + ddy[dir];
5018                 int col = px + ddx[dir];
5019
5020                 /* Access grid */
5021                 c_ptr = &cave[row][col];
5022
5023                 /* Visible monsters abort running */
5024                 if (c_ptr->m_idx)
5025                 {
5026                         monster_type *m_ptr = &m_list[c_ptr->m_idx];
5027
5028                         /* Visible monster */
5029                         if (m_ptr->ml) return (0);
5030                 }
5031
5032         }
5033
5034         /* Travel cost of current grid */
5035         cost = travel.cost[py][px];
5036
5037         /* Determine travel direction */
5038         for (i = 0; i < 8; ++ i) {
5039                 int dir_cost = travel.cost[py+ddy_ddd[i]][px+ddx_ddd[i]];
5040
5041                 if (dir_cost < cost)
5042                 {
5043                         new_dir = ddd[i];
5044                         cost = dir_cost;
5045                 }
5046         }
5047
5048         if (!new_dir) return (0);
5049
5050         /* Access newly move grid */
5051         c_ptr = &cave[py+ddy[new_dir]][px+ddx[new_dir]];
5052
5053         /* Close door abort traveling */
5054         if (!easy_open && is_closed_door(c_ptr->feat)) return (0);
5055
5056         /* Visible and unignorable trap abort tarveling */
5057         if (!c_ptr->mimic && !trap_can_be_ignored(c_ptr->feat)) return (0);
5058
5059         /* Move new grid */
5060         return (new_dir);
5061 }
5062
5063
5064 /*
5065  * Travel command
5066  */
5067 void travel_step(void)
5068 {
5069         /* Get travel direction */
5070         travel.dir = travel_test(travel.dir);
5071
5072         /* disturb */
5073         if (!travel.dir)
5074         {
5075                 if (travel.run == 255)
5076                 {
5077 #ifdef JP
5078                         msg_print("Æ»¶Ú¤¬¸«¤Ä¤«¤ê¤Þ¤»¤ó¡ª");
5079 #else
5080                         msg_print("No route is found!");
5081 #endif
5082                 }
5083                 disturb(0, 1);
5084                 return;
5085         }
5086
5087         energy_use = 100;
5088
5089         move_player(travel.dir, always_pickup, FALSE);
5090
5091         if ((py == travel.y) && (px == travel.x))
5092                 travel.run = 0;
5093         else if (travel.run > 0)
5094                 travel.run--;
5095
5096         /* Travel Delay */
5097         Term_xtra(TERM_XTRA_DELAY, delay_factor);
5098 }
5099 #endif