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