src/cmd1.c

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