src/cmd1.c

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