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