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