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