}
+#define BLOW_EFFECT_TYPE_NONE 0
+#define BLOW_EFFECT_TYPE_FEAR 1
+#define BLOW_EFFECT_TYPE_SLEEP 2
+#define BLOW_EFFECT_TYPE_HEAL 3
+
+
/* Monster attacks monster */
static bool monst_attack_monst(int m_idx, int t_idx)
{
int ac, rlev, pt;
char m_name[80], t_name[80];
char temp[80];
- bool blinked, heal_effect;
+ bool blinked;
bool explode = FALSE, touched = FALSE, fear = FALSE;
int y_saver = t_ptr->fy;
int x_saver = t_ptr->fx;
+ int effect_type;
bool see_m = is_seen(m_ptr);
bool see_t = is_seen(t_ptr);
/* Roll out the damage */
damage = damroll(d_dice, d_side);
- /* Assume no healing effect */
- heal_effect = FALSE;
+ /* Assume no effect */
+ effect_type = BLOW_EFFECT_TYPE_NONE;
pt = GF_MISSILE;
switch (effect)
{
case 0:
- {
- damage = 0;
- pt = 0;
- break;
- }
+ case RBE_DR_MANA:
+ damage = pt = 0;
+ break;
case RBE_SUPERHURT:
+ if ((randint1(rlev*2+250) > (ac+200)) || one_in_(13))
{
- if ((randint1(rlev*2+250) > (ac+200)) || one_in_(13)) {
- int tmp_damage = damage-(damage*((ac < 150) ? ac : 150)/250);
- damage = MAX(damage, tmp_damage*2);
- break;
- }
- }
- case RBE_HURT:
- {
- damage -= (damage * ((ac < 150) ? ac : 150) / 250);
+ int tmp_damage = damage - (damage * ((ac < 150) ? ac : 150) / 250);
+ damage = MAX(damage, tmp_damage * 2);
break;
}
+ /* Fall through */
+
+ case RBE_HURT:
+ damage -= (damage * ((ac < 150) ? ac : 150) / 250);
+ break;
+
case RBE_POISON:
case RBE_DISEASE:
- {
- pt = GF_POIS;
- break;
- }
+ pt = GF_POIS;
+ break;
case RBE_UN_BONUS:
case RBE_UN_POWER:
- {
- pt = GF_DISENCHANT;
- break;
- }
-
- case RBE_EAT_FOOD:
- case RBE_EAT_LITE:
- case RBE_DR_MANA:
- {
- pt = damage = 0;
- break;
- }
+ pt = GF_DISENCHANT;
+ break;
case RBE_EAT_ITEM:
case RBE_EAT_GOLD:
- {
- pt = damage = 0;
- if ((p_ptr->riding != m_idx) && one_in_(2)) blinked = TRUE;
- break;
- }
+ if ((p_ptr->riding != m_idx) && one_in_(2)) blinked = TRUE;
+ break;
+
+ case RBE_EAT_FOOD:
+ case RBE_EAT_LITE:
+ case RBE_BLIND:
+ case RBE_LOSE_STR:
+ case RBE_LOSE_INT:
+ case RBE_LOSE_WIS:
+ case RBE_LOSE_DEX:
+ case RBE_LOSE_CON:
+ case RBE_LOSE_CHR:
+ case RBE_LOSE_ALL:
+ break;
case RBE_ACID:
- {
- pt = GF_ACID;
- break;
- }
+ pt = GF_ACID;
+ break;
case RBE_ELEC:
- {
- pt = GF_ELEC;
- break;
- }
+ pt = GF_ELEC;
+ break;
case RBE_FIRE:
- {
- pt = GF_FIRE;
- break;
- }
+ pt = GF_FIRE;
+ break;
case RBE_COLD:
- {
- pt = GF_COLD;
- break;
- }
-
- case RBE_BLIND:
- {
- break;
- }
+ pt = GF_COLD;
+ break;
case RBE_CONFUSE:
- {
- pt = GF_CONFUSION;
- break;
- }
+ pt = GF_CONFUSION;
+ break;
case RBE_TERRIFY:
- {
- pt = GF_TURN_ALL;
- break;
- }
+ effect_type = BLOW_EFFECT_TYPE_FEAR;
+ break;
case RBE_PARALYZE:
- {
- pt = GF_OLD_SLEEP; /* sort of close... */
- break;
- }
+ effect_type = BLOW_EFFECT_TYPE_SLEEP;
+ break;
- case RBE_LOSE_STR:
- case RBE_LOSE_INT:
- case RBE_LOSE_WIS:
- case RBE_LOSE_DEX:
- case RBE_LOSE_CON:
- case RBE_LOSE_CHR:
- case RBE_LOSE_ALL:
- {
- break;
- }
case RBE_SHATTER:
- {
- damage -= (damage * ((ac < 150) ? ac : 150) / 250);
- if (damage > 23)
- {
- earthquake(m_ptr->fy, m_ptr->fx, 8);
- }
- break;
- }
+ damage -= (damage * ((ac < 150) ? ac : 150) / 250);
+ if (damage > 23) earthquake_aux(m_ptr->fy, m_ptr->fx, 8, m_idx);
+ break;
+
case RBE_EXP_10:
case RBE_EXP_20:
case RBE_EXP_40:
case RBE_EXP_80:
- {
- pt = GF_NETHER;
- break;
- }
+ pt = GF_NETHER;
+ break;
+
case RBE_TIME:
- {
- pt = GF_TIME;
- break;
- }
+ pt = GF_TIME;
+ break;
+
case RBE_EXP_VAMP:
- {
- pt = GF_OLD_DRAIN;
- heal_effect = TRUE;
- break;
- }
+ pt = GF_OLD_DRAIN;
+ effect_type = BLOW_EFFECT_TYPE_HEAL;
+ break;
default:
- {
- pt = 0;
- break;
- }
+ pt = 0;
+ break;
}
if (pt)
if (!explode)
{
project(m_idx, 0, t_ptr->fy, t_ptr->fx,
- (pt == GF_OLD_SLEEP ? r_ptr->level : damage), pt, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
+ damage, pt, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
}
- if (heal_effect)
+ switch (effect_type)
{
+ case BLOW_EFFECT_TYPE_FEAR:
+ project(m_idx, 0, t_ptr->fy, t_ptr->fx,
+ damage, GF_TURN_ALL, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
+ break;
+
+ case BLOW_EFFECT_TYPE_SLEEP:
+ project(m_idx, 0, t_ptr->fy, t_ptr->fx,
+ r_ptr->level, GF_OLD_SLEEP, PROJECT_KILL | PROJECT_STOP | PROJECT_AIMED, -1);
+ break;
+
+ case BLOW_EFFECT_TYPE_HEAL:
if ((monster_living(tr_ptr)) && (damage > 2))
{
bool did_heal = FALSE;
if (see_m && did_heal)
{
#ifdef JP
-msg_format("%s¤ÏÂÎÎϤò²óÉü¤·¤¿¤è¤¦¤À¡£", m_name);
+ msg_format("%s¤ÏÂÎÎϤò²óÉü¤·¤¿¤è¤¦¤À¡£", m_name);
#else
msg_format("%^s appears healthier.", m_name);
#endif
-
}
}
+ break;
}
if (touched)
mon_fight = TRUE;
}
- teleport_away(m_idx, MAX_SIGHT * 2 + 5, FALSE, FALSE);
+ teleport_away(m_idx, MAX_SIGHT * 2 + 5, 0L);
}
return TRUE;
bool do_turn;
bool do_move;
bool do_view;
+ bool must_alter_to_move;
bool did_open_door;
bool did_bash_door;
do_turn = FALSE;
do_move = FALSE;
do_view = FALSE;
+ must_alter_to_move = FALSE;
/* Assume nothing */
did_open_door = FALSE;
do_move = TRUE;
}
+ /* Possibly a monster to attack */
else if (c_ptr->m_idx)
{
- /* Possibly a monster to attack */
do_move = TRUE;
}
+ /* Monster destroys walls (and doors) */
+ else if ((r_ptr->flags2 & RF2_KILL_WALL) &&
+ (can_cross ? !have_flag(f_ptr->flags, FF_LOS) : !is_riding_mon) &&
+ have_flag(f_ptr->flags, FF_HURT_DISI) && !have_flag(f_ptr->flags, FF_PERMANENT) &&
+ (!have_flag(f_ptr->flags, FF_GLASS) || (r_ptr->flags2 & RF2_STUPID) || (m_ptr->hp >= MAX(m_ptr->maxhp / 3, 200))))
+ {
+ /* Eat through walls/doors/rubble */
+ do_move = TRUE;
+ if (!can_cross) must_alter_to_move = TRUE;
+
+ /* Monster destroyed a wall (later) */
+ did_kill_wall = TRUE;
+ }
+
/* Floor is open? */
else if (can_cross)
{
/* Monster went through a wall */
did_pass_wall = TRUE;
}
-
- if ((r_ptr->flags2 & RF2_KILL_WALL) && have_flag(f_ptr->flags, FF_TUNNEL) &&
- !have_flag(f_ptr->flags, FF_LOS) && !have_flag(f_ptr->flags, FF_PERMANENT))
- {
- /* Monster destroyed a wall (later) */
- did_kill_wall = TRUE;
- }
- }
-
- /* Monster destroys walls (and doors) */
- else if ((r_ptr->flags2 & RF2_KILL_WALL) && !is_riding_mon &&
- have_flag(f_ptr->flags, FF_TUNNEL) && !have_flag(f_ptr->flags, FF_PERMANENT))
- {
- /* Eat through walls/doors/rubble */
- do_move = TRUE;
-
- /* Monster destroyed a wall (later) */
- did_kill_wall = TRUE;
}
/* Handle doors and secret doors */
else if (is_closed_door(c_ptr->feat))
{
bool may_bash = TRUE;
- feature_type *f_ptr = &f_info[c_ptr->feat];
/* Assume no move allowed */
do_move = FALSE;
if (randint0(m_ptr->hp / 10) > f_ptr->power)
{
/* Message */
+ if (have_flag(f_ptr->flags, FF_GLASS))
+#ifdef JP
+ msg_print("¥¬¥é¥¹¤¬ºÕ¤±¤ë²»¤¬¤·¤¿¡ª");
+#else
+ msg_print("You hear a glass was crashed!");
+#endif
+ else
#ifdef JP
- msg_print("¥É¥¢¤òᤳ«¤±¤ë²»¤¬¤·¤¿¡ª");
+ msg_print("¥É¥¢¤òᤳ«¤±¤ë²»¤¬¤·¤¿¡ª");
#else
- msg_print("You hear a door burst open!");
+ msg_print("You hear a door burst open!");
#endif
/* Disturb (sometimes) */
/* Hack -- fall into doorway */
do_move = TRUE;
+ must_alter_to_move = TRUE;
}
}
if (did_open_door || did_bash_door)
{
/* Break down the door */
- if (did_bash_door && ((randint0(100) < 50) || (feat_state(c_ptr->feat, FF_OPEN) == c_ptr->feat)))
+ if (did_bash_door && ((randint0(100) < 50) || (feat_state(c_ptr->feat, FF_OPEN) == c_ptr->feat) || have_flag(f_ptr->flags, FF_GLASS)))
{
cave_alter_feat(ny, nx, FF_BASH);
+
+ if (!m_ptr->r_idx) /* Killed by shards of glass, etc. */
+ {
+ /* Update some things */
+ p_ptr->update |= (PU_FLOW);
+ p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
+ if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= (RF2_BASH_DOOR);
+
+ return;
+ }
}
/* Open the door */
cave_alter_feat(ny, nx, FF_OPEN);
}
+ f_ptr = &f_info[c_ptr->feat];
+
/* Handle viewable doors */
do_view = TRUE;
}
}
}
+ if (is_riding_mon)
+ {
+ if (!p_ptr->riding_ryoute && !MON_MONFEAR(&m_list[p_ptr->riding])) do_move = FALSE;
+ }
+
+ if (did_kill_wall && do_move)
+ {
+ if (one_in_(GRINDNOISE))
+ {
+ if (have_flag(f_ptr->flags, FF_GLASS))
+#ifdef JP
+ msg_print("²¿¤«¤ÎºÕ¤±¤ë²»¤¬Ê¹¤³¤¨¤ë¡£");
+#else
+ msg_print("There is a crashing sound.");
+#endif
+ else
+#ifdef JP
+ msg_print("¥®¥·¥®¥·¤¤¤¦²»¤¬Ê¹¤³¤¨¤ë¡£");
+#else
+ msg_print("There is a grinding sound.");
+#endif
+ }
+
+ cave_alter_feat(ny, nx, FF_HURT_DISI);
+
+ if (!m_ptr->r_idx) /* Killed by shards of glass, etc. */
+ {
+ /* Update some things */
+ p_ptr->update |= (PU_FLOW);
+ p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
+ if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags2 |= (RF2_KILL_WALL);
+
+ return;
+ }
+
+ f_ptr = &f_info[c_ptr->feat];
+
+ /* Note changes to viewable region */
+ do_view = TRUE;
+
+ /* Take a turn */
+ do_turn = TRUE;
+ }
+
+ if (must_alter_to_move && (r_ptr->flags7 & RF7_AQUATIC))
+ {
+ if (!monster_can_cross_terrain(c_ptr->feat, r_ptr, is_riding_mon ? CEM_RIDING : 0))
+ {
+ /* Assume no move allowed */
+ do_move = FALSE;
+ }
+ }
+
/*
* Check if monster can cross terrain
* This is checked after the normal attacks
/* Some monsters never move */
if (do_move && (r_ptr->flags1 & RF1_NEVER_MOVE))
{
- /* Hack -- memorize lack of attacks */
+ /* Hack -- memorize lack of moves */
if (is_original_ap_and_seen(m_ptr)) r_ptr->r_flags1 |= (RF1_NEVER_MOVE);
/* Do not move */
do_move = FALSE;
}
- if (is_riding_mon)
- {
- if (!p_ptr->riding_ryoute && !MON_MONFEAR(&m_list[p_ptr->riding])) do_move = FALSE;
- }
-
/* Creature has been allowed move */
if (do_move)
{
/* Take a turn */
do_turn = TRUE;
- if (did_kill_wall)
- {
- if (one_in_(GRINDNOISE))
- {
-#ifdef JP
- msg_print("¥®¥·¥®¥·¤¤¤¦²»¤¬Ê¹¤³¤¨¤ë¡£");
-#else
- msg_print("There is a grinding sound.");
-#endif
- }
-
- cave_alter_feat(ny, nx, FF_HURT_DISI);
-
- /* Note changes to viewable region */
- do_view = TRUE;
- }
- else if (have_flag(f_ptr->flags, FF_TREE))
+ if (have_flag(f_ptr->flags, FF_TREE))
{
- if (!(r_ptr->flags7 & RF7_CAN_FLY) && (!is_riding_mon || !p_ptr->levitation) && !(r_ptr->flags8 & RF8_WILD_WOOD))
+ if (!(r_ptr->flags7 & RF7_CAN_FLY) && !(r_ptr->flags8 & RF8_WILD_WOOD))
{
m_ptr->energy_need += ENERGY_NEED();
}
}
-static void mproc_add(int m_idx, int mproc_type)
+int get_mproc_idx(int m_idx, int mproc_type)
{
- if (mproc_max[mproc_type] < max_m_idx)
+ s16b *cur_mproc_list = mproc_list[mproc_type];
+ int i;
+
+ for (i = mproc_max[mproc_type] - 1; i >= 0; i--)
{
- m_list[m_idx].mproc_idx[mproc_type] = mproc_max[mproc_type];
- mproc_list[mproc_type][mproc_max[mproc_type]++] = m_idx;
+ if (cur_mproc_list[i] == m_idx) return i;
}
+
+ return -1;
}
-void mproc_remove(int m_idx, int mproc_type)
+static void mproc_add(int m_idx, int mproc_type)
{
- s16b *mproc_idx = &(m_list[m_idx].mproc_idx[mproc_type]);
+ if (mproc_max[mproc_type] < max_m_idx) mproc_list[mproc_type][mproc_max[mproc_type]++] = m_idx;
+}
- if (mproc_max[mproc_type] > 1)
- {
- mproc_list[mproc_type][*mproc_idx] = mproc_list[mproc_type][--mproc_max[mproc_type]];
- m_list[mproc_list[mproc_type][*mproc_idx]].mproc_idx[mproc_type] = *mproc_idx;
- }
- *mproc_idx = 0;
+static void mproc_remove(int m_idx, int mproc_type)
+{
+ int mproc_idx = get_mproc_idx(m_idx, mproc_type);
+ if (mproc_idx >= 0) mproc_list[mproc_type][mproc_idx] = mproc_list[mproc_type][--mproc_max[mproc_type]];
}
int i, cmi;
/* Reset "mproc_max[]" */
- for (cmi = 0; cmi < MAX_MTIMED; cmi++) mproc_max[cmi] = 1;
+ for (cmi = 0; cmi < MAX_MTIMED; cmi++) mproc_max[cmi] = 0;
/* Process the monsters (backwards) */
for (i = m_max - 1; i >= 1; i--)
for (cmi = 0; cmi < MAX_MTIMED; cmi++)
{
if (m_ptr->mtimed[cmi]) mproc_add(i, cmi);
- else m_ptr->mproc_idx[cmi] = 0;
}
}
}
if (!notice) return FALSE;
- if (p_ptr->riding == m_idx) p_ptr->update |= (PU_BONUS);
+ if ((p_ptr->riding == m_idx) && !p_ptr->leaving) p_ptr->update |= (PU_BONUS);
return TRUE;
}
if (!notice) return FALSE;
- if (p_ptr->riding == m_idx) p_ptr->update |= (PU_BONUS);
+ if ((p_ptr->riding == m_idx) && !p_ptr->leaving) p_ptr->update |= (PU_BONUS);
return TRUE;
}
}
-/*
- * Process the counters of monsters (once per 10 game turns)
- *
- * These functions are to process monsters' counters same as player's.
- */
-
+static u32b csleep_noise;
-/* Handle "sleep" */
-void process_monsters_csleep(void)
+static void process_monsters_mtimed_aux(int m_idx, int mtimed_idx)
{
- int m_idx, i;
- monster_type *m_ptr;
- monster_race *r_ptr;
- bool test;
- s16b *cur_mproc_list = mproc_list[MTIMED_CSLEEP];
-
- u32b noise; /* Hack -- local "player stealth" value */
-
- /* Hack -- calculate the "player noise" */
- noise = (1L << (30 - p_ptr->skill_stl));
+ monster_type *m_ptr = &m_list[m_idx];
- /* Process the monsters (backwards) */
- for (i = mproc_max[MTIMED_CSLEEP] - 1; i >= 1; i--)
+ switch (mtimed_idx)
{
- /* Access the monster */
- m_idx = cur_mproc_list[i];
- m_ptr = &m_list[m_idx];
- r_ptr = &r_info[m_ptr->r_idx];
+ case MTIMED_CSLEEP:
+ {
+ monster_race *r_ptr = &r_info[m_ptr->r_idx];
/* Assume does not wake up */
- test = FALSE;
+ bool test = FALSE;
/* Hack -- Require proximity */
if (m_ptr->cdis < AAF_LIMIT)
if (ironman_nightmare) notice /= 2;
/* Hack -- See if monster "notices" player */
- if ((notice * notice * notice) <= noise)
+ if ((notice * notice * notice) <= csleep_noise)
{
/* Hack -- amount of "waking" */
/* Wake up faster near the player */
}
}
}
+ break;
}
-}
-
-
-/* Handle fast */
-void process_monsters_fast(void)
-{
- int m_idx, i;
- monster_type *m_ptr;
- s16b *cur_mproc_list = mproc_list[MTIMED_FAST];
-
- /* Process the monsters (backwards) */
- for (i = mproc_max[MTIMED_FAST] - 1; i >= 1; i--)
- {
- /* Access the monster */
- m_idx = cur_mproc_list[i];
- m_ptr = &m_list[m_idx];
+ case MTIMED_FAST:
/* Reduce by one, note if expires */
if (set_monster_fast(m_idx, MON_FAST(m_ptr) - 1))
{
#endif
}
}
- }
-}
-
-
-/* Handle slow */
-void process_monsters_slow(void)
-{
- int m_idx, i;
- monster_type *m_ptr;
- s16b *cur_mproc_list = mproc_list[MTIMED_SLOW];
-
- /* Process the monsters (backwards) */
- for (i = mproc_max[MTIMED_SLOW] - 1; i >= 1; i--)
- {
- /* Access the monster */
- m_idx = cur_mproc_list[i];
- m_ptr = &m_list[m_idx];
+ break;
+ case MTIMED_SLOW:
/* Reduce by one, note if expires */
if (set_monster_slow(m_idx, MON_SLOW(m_ptr) - 1))
{
#endif
}
}
- }
-}
-
-
-/* Handle "stun" */
-void process_monsters_stunned(void)
-{
- int m_idx, i, rlev;
- monster_type *m_ptr;
- s16b *cur_mproc_list = mproc_list[MTIMED_STUNNED];
+ break;
- /* Process the monsters (backwards) */
- for (i = mproc_max[MTIMED_STUNNED] - 1; i >= 1; i--)
+ case MTIMED_STUNNED:
{
- /* Access the monster */
- m_idx = cur_mproc_list[i];
- m_ptr = &m_list[m_idx];
- rlev = r_info[m_ptr->r_idx].level;
-
- /* Hack -- Recover from stun */
+ int rlev = r_info[m_ptr->r_idx].level;
- /* Fully recover */
+ /* Recover from stun */
if (set_monster_stunned(m_idx, (randint0(10000) <= rlev * rlev) ? 0 : (MON_STUNNED(m_ptr) - 1)))
{
/* Message if visible */
#endif
}
}
+ break;
}
-}
-
-
-/* Handle confusion */
-void process_monsters_confused(void)
-{
- int m_idx, i;
- monster_type *m_ptr;
- s16b *cur_mproc_list = mproc_list[MTIMED_CONFUSED];
-
- /* Process the monsters (backwards) */
- for (i = mproc_max[MTIMED_CONFUSED] - 1; i >= 1; i--)
- {
- /* Access the monster */
- m_idx = cur_mproc_list[i];
- m_ptr = &m_list[m_idx];
+ case MTIMED_CONFUSED:
/* Reduce the confusion */
-
- /* Recovered */
if (set_monster_confused(m_idx, MON_CONFUSED(m_ptr) - randint1(r_info[m_ptr->r_idx].level / 20 + 1)))
{
/* Message if visible */
#endif
}
}
- }
-}
-
-
-/* Handle "fear" */
-void process_monsters_monfear(void)
-{
- int m_idx, i;
- monster_type *m_ptr;
- s16b *cur_mproc_list = mproc_list[MTIMED_MONFEAR];
-
- /* Process the monsters (backwards) */
- for (i = mproc_max[MTIMED_MONFEAR] - 1; i >= 1; i--)
- {
- /* Access the monster */
- m_idx = cur_mproc_list[i];
- m_ptr = &m_list[m_idx];
+ break;
+ case MTIMED_MONFEAR:
/* Reduce the fear */
-
- /* Recover from fear, take note if seen */
if (set_monster_monfear(m_idx, MON_MONFEAR(m_ptr) - randint1(r_info[m_ptr->r_idx].level / 20 + 1)))
{
/* Visual note */
#endif
}
}
- }
-}
-
-
-/* Handle Invulnerability */
-void process_monsters_invulner(void)
-{
- int m_idx, i;
- monster_type *m_ptr;
- s16b *cur_mproc_list = mproc_list[MTIMED_INVULNER];
-
- /* Process the monsters (backwards) */
- for (i = mproc_max[MTIMED_INVULNER] - 1; i >= 1; i--)
- {
- /* Access the monster */
- m_idx = cur_mproc_list[i];
- m_ptr = &m_list[m_idx];
+ break;
+ case MTIMED_INVULNER:
/* Reduce by one, note if expires */
if (set_monster_invulner(m_idx, MON_INVULNER(m_ptr) - 1, TRUE))
{
#endif
}
}
+ break;
+ }
+}
+
+
+/*
+ * Process the counters of monsters (once per 10 game turns)
+ *
+ * These functions are to process monsters' counters same as player's.
+ */
+void process_monsters_mtimed(int mtimed_idx)
+{
+ int i;
+ s16b *cur_mproc_list = mproc_list[mtimed_idx];
+
+ /* Hack -- calculate the "player noise" */
+ if (mtimed_idx == MTIMED_CSLEEP) csleep_noise = (1L << (30 - p_ptr->skill_stl));
+
+ /* Process the monsters (backwards) */
+ for (i = mproc_max[mtimed_idx] - 1; i >= 0; i--)
+ {
+ /* Access the monster */
+ process_monsters_mtimed_aux(cur_mproc_list[i], mtimed_idx);
}
}
OSDN Git Service
