src/cmd1.c

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