

/* File: melee2.c */

/*
 * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
 *
 * This software may be copied and distributed for educational, research,
 * and not for profit purposes provided that this copyright and statement
 * are included in all such copies.  Other copyrights may also apply.
 */

#include "angband.h"



#ifdef DRS_SMART_OPTIONS


/*
 * And now for Intelligent monster attacks (including spells).
 *
 * Original idea and code by "DRS" (David Reeves Sward).
 *
 * Major modifications by "BEN" (Ben Harrison).
 *
 * Give monsters more intelligent attack/spell selection based on
 * observations of previous attacks on the player, and/or by allowing
 * the monster to "cheat" and know the player status.
 *
 * Maintain an idea of the player status, and use that information
 * to occasionally eliminate "ineffective" spell attacks.  We could
 * also eliminate ineffective normal attacks, but there is no reason
 * for the monster to do this, since he gains no benefit.
 * Note that MINDLESS monsters are not allowed to use this code.
 * And non-INTELLIGENT monsters only use it partially effectively.
 *
 * Actually learn what the player resists, and use that information
 * to remove attacks or spells before using them.  This will require
 * much less space, if I am not mistaken.  Thus, each monster gets a
 * set of 32 bit flags, "smart", build from the various "SM_*" flags.
 *
 * This has the added advantage that attacks and spells are related.
 * The "smart_learn" option means that the monster "learns" the flags
 * that should be set, and "smart_cheat" means that he "knows" them.
 * So "smart_cheat" means that the "smart" field is always up to date,
 * while "smart_learn" means that the "smart" field is slowly learned.
 * Both of them have the same effect on the "choose spell" routine.
 */




/*
 * Internal probablility routine
 */
static bool
int_outof(monster_race * r_ptr, int prob)
{
	/* Non-Smart monsters are half as "smart" */
	if (!(r_ptr->flags2 & (RF2_SMART)))
		prob = prob / 2;

	/* Roll the dice */
	return (rand_int(100) < prob);
}



/*
 * Remove the "bad" spells from a spell list
 */
static void
remove_bad_spells(int m_idx, u32b * f4p, u32b * f5p, u32b * f6p)
{
	monster_type *m_ptr = &m_list[m_idx];
	monster_race *r_ptr = &r_info[m_ptr->r_idx];

	u32b f4 = (*f4p);
	u32b f5 = (*f5p);
	u32b f6 = (*f6p);

	u32b smart = 0L;


	/* Too stupid to know anything */
	if (r_ptr->flags2 & (RF2_STUPID))
		return;


	/* Must be cheating or learning */
	if (!smart_cheat && !smart_learn)
		return;


	/* Update acquired knowledge */
	if (smart_learn)
	{
		/* Hack -- Occasionally forget player status */
		if (m_ptr->smart && (rand_int(100) < 1))
			m_ptr->smart = 0L;

		/* Use the memorized flags */
		smart = m_ptr->smart;
	}


	/* Cheat if requested */
	if (smart_cheat)
	{
		/* Know weirdness */
		if (p_ptr->free_act)
			smart |= (SM_IMM_FREE);
		if (!p_ptr->msp)
			smart |= (SM_IMM_MANA);

		/* Know immunities */
		if (p_ptr->immune_acid)
			smart |= (SM_IMM_ACID);
		if (p_ptr->immune_elec)
			smart |= (SM_IMM_ELEC);
		if (p_ptr->immune_fire)
			smart |= (SM_IMM_FIRE);
		if (p_ptr->immune_cold)
			smart |= (SM_IMM_COLD);

		/* Know oppositions */
		if (p_ptr->oppose_acid)
			smart |= (SM_OPP_ACID);
		if (p_ptr->oppose_elec)
			smart |= (SM_OPP_ELEC);
		if (p_ptr->oppose_fire)
			smart |= (SM_OPP_FIRE);
		if (p_ptr->oppose_cold)
			smart |= (SM_OPP_COLD);
		if (p_ptr->oppose_pois)
			smart |= (SM_OPP_POIS);

		/* Know resistances */
		if (p_ptr->resist_acid)
			smart |= (SM_RES_ACID);
		if (p_ptr->resist_elec)
			smart |= (SM_RES_ELEC);
		if (p_ptr->resist_fire)
			smart |= (SM_RES_FIRE);
		if (p_ptr->resist_cold)
			smart |= (SM_RES_COLD);
		if (p_ptr->resist_pois)
			smart |= (SM_RES_POIS);
		if (p_ptr->resist_fear)
			smart |= (SM_RES_FEAR);
		if (p_ptr->resist_lite)
			smart |= (SM_RES_LITE);
		if (p_ptr->resist_dark)
			smart |= (SM_RES_DARK);
		if (p_ptr->resist_blind)
			smart |= (SM_RES_BLIND);
		if (p_ptr->resist_confu)
			smart |= (SM_RES_CONFU);
		if (p_ptr->resist_sound)
			smart |= (SM_RES_SOUND);
		if (p_ptr->resist_shard)
			smart |= (SM_RES_SHARD);
		if (p_ptr->resist_nexus)
			smart |= (SM_RES_NEXUS);
		if (p_ptr->resist_nethr)
			smart |= (SM_RES_NETHR);
		if (p_ptr->resist_chaos)
			smart |= (SM_RES_CHAOS);
		if (p_ptr->resist_disen)
			smart |= (SM_RES_DISEN);
	}


	/* Nothing known */
	if (!smart)
		return;


	if (smart & (SM_IMM_ACID))
	{
		if (int_outof(r_ptr, 100))
			f4 &= ~(RF4_BR_ACID);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BA_ACID);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BO_ACID);
	}
	else if ((smart & (SM_OPP_ACID)) && (smart & (SM_RES_ACID)))
	{
		if (int_outof(r_ptr, 80))
			f4 &= ~(RF4_BR_ACID);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BA_ACID);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BO_ACID);
	}
	else if ((smart & (SM_OPP_ACID)) || (smart & (SM_RES_ACID)))
	{
		if (int_outof(r_ptr, 30))
			f4 &= ~(RF4_BR_ACID);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BA_ACID);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BO_ACID);
	}


	if (smart & (SM_IMM_ELEC))
	{
		if (int_outof(r_ptr, 100))
			f4 &= ~(RF4_BR_ELEC);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BA_ELEC);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BO_ELEC);
	}
	else if ((smart & (SM_OPP_ELEC)) && (smart & (SM_RES_ELEC)))
	{
		if (int_outof(r_ptr, 80))
			f4 &= ~(RF4_BR_ELEC);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BA_ELEC);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BO_ELEC);
	}
	else if ((smart & (SM_OPP_ELEC)) || (smart & (SM_RES_ELEC)))
	{
		if (int_outof(r_ptr, 30))
			f4 &= ~(RF4_BR_ELEC);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BA_ELEC);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BO_ELEC);
	}


	if (smart & (SM_IMM_FIRE))
	{
		if (int_outof(r_ptr, 100))
			f4 &= ~(RF4_BR_FIRE);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BA_FIRE);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BO_FIRE);
	}
	else if ((smart & (SM_OPP_FIRE)) && (smart & (SM_RES_FIRE)))
	{
		if (int_outof(r_ptr, 80))
			f4 &= ~(RF4_BR_FIRE);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BA_FIRE);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BO_FIRE);
	}
	else if ((smart & (SM_OPP_FIRE)) || (smart & (SM_RES_FIRE)))
	{
		if (int_outof(r_ptr, 30))
			f4 &= ~(RF4_BR_FIRE);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BA_FIRE);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BO_FIRE);
	}


	if (smart & (SM_IMM_COLD))
	{
		if (int_outof(r_ptr, 100))
			f4 &= ~(RF4_BR_COLD);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BA_COLD);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BO_COLD);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BO_ICEE);
	}
	else if ((smart & (SM_OPP_COLD)) && (smart & (SM_RES_COLD)))
	{
		if (int_outof(r_ptr, 80))
			f4 &= ~(RF4_BR_COLD);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BA_COLD);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BO_COLD);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BO_ICEE);
	}
	else if ((smart & (SM_OPP_COLD)) || (smart & (SM_RES_COLD)))
	{
		if (int_outof(r_ptr, 30))
			f4 &= ~(RF4_BR_COLD);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BA_COLD);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BO_COLD);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BO_ICEE);
	}


	if ((smart & (SM_OPP_POIS)) && (smart & (SM_RES_POIS)))
	{
		if (int_outof(r_ptr, 80))
			f4 &= ~(RF4_BR_POIS);
		if (int_outof(r_ptr, 80))
			f5 &= ~(RF5_BA_POIS);
	}
	else if ((smart & (SM_OPP_POIS)) || (smart & (SM_RES_POIS)))
	{
		if (int_outof(r_ptr, 30))
			f4 &= ~(RF4_BR_POIS);
		if (int_outof(r_ptr, 30))
			f5 &= ~(RF5_BA_POIS);
	}


	if (smart & (SM_RES_FEAR))
	{
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_SCARE);
	}

	if (smart & (SM_RES_LITE))
	{
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_LITE);
	}

	if (smart & (SM_RES_DARK))
	{
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_DARK);
		if (int_outof(r_ptr, 50))
			f5 &= ~(RF5_BA_DARK);
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_HELLFIRE);
	}

	if (smart & (SM_RES_BLIND))
	{
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_BLIND);
	}

	if (smart & (SM_RES_CONFU))
	{
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_CONF);
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_CONF);
	}

	if (smart & (SM_RES_SOUND))
	{
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_SOUN);
	}

	if (smart & (SM_RES_SHARD))
	{
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_SHAR);
	}

	if (smart & (SM_RES_NEXUS))
	{
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_NEXU);
		if (int_outof(r_ptr, 50))
			f6 &= ~(RF6_TELE_LEVEL);
	}

	if (smart & (SM_RES_NETHR))
	{
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_NETH);
		if (int_outof(r_ptr, 50))
			f5 &= ~(RF5_BA_NETH);
		if (int_outof(r_ptr, 50))
			f5 &= ~(RF5_BO_NETH);
	}

	if (smart & (SM_RES_CHAOS))
	{
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_CONF);
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_CONF);
		if (int_outof(r_ptr, 50))
			f4 &= ~(RF4_BR_CHAO);
	}

	if (smart & (SM_RES_DISEN))
	{
		if (int_outof(r_ptr, 100))
			f4 &= ~(RF4_BR_DISE);
	}


	if (smart & (SM_IMM_FREE))
	{
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_HOLD);
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_SLOW);
	}

	if (smart & (SM_IMM_MANA))
	{
		if (int_outof(r_ptr, 100))
			f5 &= ~(RF5_DRAIN_MANA);
	}


	/* XXX XXX XXX No spells left? */
	/* if (!f4 && !f5 && !f6) ... */


	(*f4p) = f4;
	(*f5p) = f5;
	(*f6p) = f6;
}


#endif

/*
 * Cast a bolt at the player
 * Stop if we hit a monster
 * Affect monsters and the player
 */
static void
bolt(int m_idx, int typ, int dam_hp)
{
	int py = p_ptr->py;
	int px = p_ptr->px;

	int flg = PROJECT_STOP | PROJECT_KILL;

	/* Target the player with a bolt attack */
	(void)project(m_idx, 0, py, px, dam_hp, typ, flg);
}


/*
 * Cast a breath (or ball) attack at the player
 * Pass over any monsters that may be in the way
 * Affect grids, objects, monsters, and the player
 */
static void
breath(int m_idx, int typ, int dam_hp)
{
	int py = p_ptr->py;
	int px = p_ptr->px;

	int rad;

	int flg = PROJECT_GRID | PROJECT_ITEM | PROJECT_KILL;

	monster_type *m_ptr = &m_list[m_idx];
	monster_race *r_ptr = &r_info[m_ptr->r_idx];

	/* Determine the radius of the blast */
	rad = (r_ptr->flags2 & (RF2_POWERFUL)) ? 3 : 2;

	/* Target the player with a ball attack */
	(void)project(m_idx, rad, py, px, dam_hp, typ, flg);
}



/*
 * Creatures can cast spells, shoot missiles, and breathe.
 *
 * Returns "TRUE" if a spell (or whatever) was (successfully) cast.
 *
 * XXX XXX XXX This function could use some work, but remember to
 * keep it as optimized as possible, while retaining generic code.
 *
 * Verify the various "blind-ness" checks in the code.
 *
 * XXX XXX XXX Note that several effects should really not be "seen"
 * if the player is blind.  See also "effects.c" for other "mistakes".
 *
 * Perhaps monsters should breathe at locations *near* the player,
 * since this would allow them to inflict "partial" damage.
 *
 * Perhaps smart monsters should decline to use "bolt" spells if
 * there is a monster in the way, unless they wish to kill it.
 *
 * It will not be possible to "correctly" handle the case in which a
 * monster attempts to attack a location which is thought to contain
 * the player, but which in fact is nowhere near the player, since this
 * might induce all sorts of messages about the attack itself, and about
 * the effects of the attack, which the player might or might not be in
 * a position to observe.  Thus, for simplicity, it is probably best to
 * only allow "faulty" attacks by a monster if one of the important grids
 * (probably the initial or final grid) is in fact in view of the player.
 * It may be necessary to actually prevent spell attacks except when the
 * monster actually has line of sight to the player.  Note that a monster
 * could be left in a bizarre situation after the player ducked behind a
 * pillar and then teleported away, for example.
 *
 * Note that certain spell attacks do not use the "project()" function
 * but "simulate" it via the "direct" variable, which is always at least
 * as restrictive as the "project()" function.  This is necessary to
 * prevent "blindness" attacks and such from bending around walls.
 *
 * Note that this function attempts to optimize the use of spells for the
 * cases in which the monster has no spells, or has spells but cannot use
 * them, or has spells but they will have no "useful" effect.  Note that
 * this function has been an efficiency bottleneck in the past.
 *
 * Note the special "MFLAG_NICE" flag, which prevents a monster from using
 * any spell attacks until the player has had a single chance to move.
 */
bool
make_attack_spell(int m_idx)
{
	int py = p_ptr->py;
	int px = p_ptr->px;

	int k, chance, thrown_spell, rlev;

	byte spell[96], num = 0;

	u32b f4, f5, f6;

	monster_type *m_ptr = &m_list[m_idx];
	monster_race *r_ptr = &r_info[m_ptr->r_idx];

	char m_name[80];
	char m_poss[80];

	char ddesc[80];


	/* Target player */
	int x = px;
	int y = py;

	/* Summon count */
	int count = 0;


	/* Extract the blind-ness */
	bool blind = (p_ptr->blind ? TRUE : FALSE);

	/* Extract the "see-able-ness" */
	bool seen = (!blind && m_ptr->ml);


	/* Assume "normal" target */
	bool normal = TRUE;

	/* Assume "projectable" */
	bool direct = TRUE;


	/* Cannot cast spells when confused */
	if (m_ptr->confused)
		return (FALSE);

	/* Cannot cast spells when nice */
	if (m_ptr->mflag & (MFLAG_NICE))
		return (FALSE);

	/* Hack -- Extract the spell probability */
	chance = (r_ptr->freq_inate + r_ptr->freq_spell) / 2;

	/* Not allowed to cast spells */
	if (!chance)
		return (FALSE);

	/* Only do spells occasionally */
	if (rand_int(100) >= chance)
		return (FALSE);


	/* Hack -- require projectable player */
	if (normal)
	{
		/* Check range */
		if (m_ptr->cdis > MAX_RANGE)
			return (FALSE);

		/* Check path */
		if (!projectable(m_ptr->fy, m_ptr->fx, py, px))
			return (FALSE);
	}


	/* Extract the monster level */
	rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);


	/* Extract the racial spell flags */
	f4 = r_ptr->flags4;
	f5 = r_ptr->flags5;
	f6 = r_ptr->flags6;

	/* Hack -- allow "desperate" spells */
	if ((r_ptr->flags2 & (RF2_SMART)) &&
		(m_ptr->hp < m_ptr->maxhp / 10) &&
		(rand_int(100) < 50))
	{
		/* Require intelligent spells */
		f4 &= (RF4_INT_MASK);
		f5 &= (RF5_INT_MASK);
		f6 &= (RF6_INT_MASK);

		/* No spells left */
		if (!f4 && !f5 && !f6)
			return (FALSE);
	}


#ifdef DRS_SMART_OPTIONS

	/* Remove the "ineffective" spells */
	remove_bad_spells(m_idx, &f4, &f5, &f6);

	/* No spells left */
	if (!f4 && !f5 && !f6)
		return (FALSE);

#endif


	/* Extract the "inate" spells */
	for (k = 0; k < 32; k++)
	{
		if (f4 & (1L << k))
			spell[num++] = k + 32 * 3;
	}

	/* Extract the "normal" spells */
	for (k = 0; k < 32; k++)
	{
		if (f5 & (1L << k))
			spell[num++] = k + 32 * 4;
	}

	/* Extract the "bizarre" spells */
	for (k = 0; k < 32; k++)
	{
		if (f6 & (1L << k))
			spell[num++] = k + 32 * 5;
	}

	/* No spells left */
	if (!num)
		return (FALSE);


	/* Handle "leaving" */
	if (p_ptr->leaving)
		return (FALSE);


	/* Get the monster name (or "it") */
	monster_desc(m_name, m_ptr, 0x00);

	/* Get the monster possessive ("his"/"her"/"its") */
	monster_desc(m_poss, m_ptr, 0x22);

	/* Hack -- Get the "died from" name */
	monster_desc(ddesc, m_ptr, 0x88);


	/* Choose a spell to cast */
	thrown_spell = spell[rand_int(num)];


	/* Cast the spell. */
	switch (thrown_spell)
	{
		/* RF4_SHRIEK */
	case 96 + 0:
		{
			if (!direct)
				break;
			disturb(1, 0);
			msg_format("%^s makes a high pitched shriek.", m_name);
			aggravate_monsters(m_idx);
			break;
		}

		/* RF4_XXX2X4 */
	case 96 + 1:
		{
			break;
		}

		/* RF4_XXX3X4 */
	case 96 + 2:
		{
			break;
		}

		/* RF4_XXX4X4 */
	case 96 + 3:
		{
			break;
		}

		/* RF4_ARROW_1 */
	case 96 + 4:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s makes a strange noise.", m_name);
			else
				msg_format("%^s fires an arrow.", m_name);
			bolt(m_idx, GF_ARROW, damroll(1, 6));
			break;
		}
		/* RF4_ARROW_2 */
	case 96 + 5:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s makes a strange noise.", m_name);
			else
				msg_format("%^s fires an arrow!", m_name);
			bolt(m_idx, GF_ARROW, damroll(3, 6));
			break;
		}

		/* RF4_ARROW_3 */
	case 96 + 6:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s makes a strange noise.", m_name);
			else
				msg_format("%^s fires a missile.", m_name);
			bolt(m_idx, GF_ARROW, damroll(5, 6));
			break;
		}

		/* RF4_ARROW_4 */
	case 96 + 7:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s makes a strange noise.", m_name);
			else
				msg_format("%^s fires a missile!", m_name);
			bolt(m_idx, GF_ARROW, damroll(7, 6));
			break;
		}

		/* RF4_BR_ACID */
	case 96 + 8:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes acid.", m_name);
			breath(m_idx, GF_ACID,
				   ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3)));
			update_smart_learn(m_idx, DRS_RES_ACID);
			break;
		}

		/* RF4_BR_ELEC */
	case 96 + 9:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes lightning.", m_name);
			breath(m_idx, GF_ELEC,
				   ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3)));
			update_smart_learn(m_idx, DRS_RES_ELEC);
			break;
		}

		/* RF4_BR_FIRE */
	case 96 + 10:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes fire.", m_name);
			breath(m_idx, GF_FIRE,
				   ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3)));
			update_smart_learn(m_idx, DRS_RES_FIRE);
			break;
		}

		/* RF4_BR_COLD */
	case 96 + 11:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes frost.", m_name);
			breath(m_idx, GF_COLD,
				   ((m_ptr->hp / 3) > 1600 ? 1600 : (m_ptr->hp / 3)));
			update_smart_learn(m_idx, DRS_RES_COLD);
			break;
		}

		/* RF4_BR_POIS */
	case 96 + 12:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes gas.", m_name);
			breath(m_idx, GF_POIS,
				   ((m_ptr->hp / 3) > 800 ? 800 : (m_ptr->hp / 3)));
			update_smart_learn(m_idx, DRS_RES_POIS);
			break;
		}

		/* RF4_BR_NETH */
	case 96 + 13:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes nether.", m_name);
			breath(m_idx, GF_NETHER,
				   ((m_ptr->hp / 6) > 550 ? 550 : (m_ptr->hp / 6)));
			update_smart_learn(m_idx, DRS_RES_NETHR);
			break;
		}

		/* RF4_BR_LITE */
	case 96 + 14:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes light.", m_name);
			breath(m_idx, GF_LITE,
				   ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6)));
			update_smart_learn(m_idx, DRS_RES_LITE);
			break;
		}

		/* RF4_BR_DARK */
	case 96 + 15:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes darkness.", m_name);
			breath(m_idx, GF_DARK,
				   ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6)));
			update_smart_learn(m_idx, DRS_RES_DARK);
			break;
		}

		/* RF4_BR_CONF */
	case 96 + 16:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes confusion.", m_name);
			breath(m_idx, GF_CONFUSION,
				   ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6)));
			update_smart_learn(m_idx, DRS_RES_CONFU);
			break;
		}

		/* RF4_BR_SOUN */
	case 96 + 17:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes sound.", m_name);
			breath(m_idx, GF_SOUND,
				   ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6)));
			update_smart_learn(m_idx, DRS_RES_SOUND);
			break;
		}

		/* RF4_BR_CHAO */
	case 96 + 18:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes chaos.", m_name);
			breath(m_idx, GF_CHAOS,
				   ((m_ptr->hp / 6) > 600 ? 600 : (m_ptr->hp / 6)));
			update_smart_learn(m_idx, DRS_RES_CHAOS);
			break;
		}

		/* RF4_BR_DISE */
	case 96 + 19:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes disenchantment.", m_name);
			breath(m_idx, GF_DISENCHANT,
				   ((m_ptr->hp / 6) > 500 ? 500 : (m_ptr->hp / 6)));
			update_smart_learn(m_idx, DRS_RES_DISEN);
			break;
		}

		/* RF4_BR_NEXU */
	case 96 + 20:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes nexus.", m_name);
			breath(m_idx, GF_NEXUS,
				   ((m_ptr->hp / 3) > 250 ? 250 : (m_ptr->hp / 3)));
			update_smart_learn(m_idx, DRS_RES_NEXUS);
			break;
		}

		/* RF4_BR_TIME */
	case 96 + 21:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes time.", m_name);
			breath(m_idx, GF_TIME,
				   ((m_ptr->hp / 3) > 150 ? 150 : (m_ptr->hp / 3)));
			break;
		}

		/* RF4_BR_INER */
	case 96 + 22:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes inertia.", m_name);
			breath(m_idx, GF_INERTIA,
				   ((m_ptr->hp / 6) > 200 ? 200 : (m_ptr->hp / 6)));
			break;
		}

		/* RF4_BR_GRAV */
	case 96 + 23:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes gravity.", m_name);
			breath(m_idx, GF_GRAVITY,
				   ((m_ptr->hp / 3) > 200 ? 200 : (m_ptr->hp / 3)));
			break;
		}

		/* RF4_BR_SHAR */
	case 96 + 24:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes shards.", m_name);
			breath(m_idx, GF_SHARD,
				   ((m_ptr->hp / 6) > 400 ? 400 : (m_ptr->hp / 6)));
			update_smart_learn(m_idx, DRS_RES_SHARD);
			break;
		}

		/* RF4_BR_PLAS */
	case 96 + 25:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes plasma.", m_name);
			breath(m_idx, GF_PLASMA,
				   ((m_ptr->hp / 6) > 150 ? 150 : (m_ptr->hp / 6)));
			break;
		}

		/* RF4_BR_WALL */
	case 96 + 26:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes force.", m_name);
			breath(m_idx, GF_FORCE,
				   ((m_ptr->hp / 6) > 200 ? 200 : (m_ptr->hp / 6)));
			break;
		}

		/* RF4_HELLFIRE */
	case 96 + 27:
		{
			int dam;

			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format(
						"%^s summons forth dark forces from hell!", m_name);
			unlite_area(10, 3);
			dam = r_ptr->level * 8;
			if (p_ptr->resist_dark)
				dam = dam / 3;
			if (rand_int(100) < p_ptr->skill_sav)
			{
				dam = dam / 3;
				msg_print("You resist the terrors of Hell!");
			}
			else
			{
				msg_print("You succumb to the visions of Hell!");
				(void)set_afraid(p_ptr->afraid + randint(30) + r_ptr->level * 2);
			}
			breath(m_idx, GF_MISSILE, dam);
			update_smart_learn(m_idx, DRS_RES_DARK);
			break;

		}

		/* RF4_BR_WIND */
	case 96 + 28:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes winds.", m_name);
			breath(m_idx, GF_WIND,
				   ((m_ptr->hp / 3) > 300 ? 300 : (m_ptr->hp / 3)));
			break;
		}

		/* RF4_BA_WIND */
	case 96 + 29:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s calls out.", m_name);
			else
				msg_format("%^s calls forth a whirlwind.", m_name);
			breath(m_idx, GF_WIND,
				   randint(rlev * 5 / 2) + 50);
			break;
		}

		/* RF4_BR_MANA */
	case 96 + 30:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s breathes.", m_name);
			else
				msg_format("%^s breathes raw mana.", m_name);
			breath(m_idx, GF_MANA,
				   ((m_ptr->hp / 3) > 250 ? 250 : (m_ptr->hp / 3)));
			break;
		}

		/* RF4_XXX8X4 */
	case 96 + 31:
		{
			break;
		}



		/* RF5_BA_ACID */
	case 128 + 0:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts an acid ball.", m_name);
			breath(m_idx, GF_ACID,
				   randint(rlev * 3) + 15);
			update_smart_learn(m_idx, DRS_RES_ACID);
			break;
		}

		/* RF5_BA_ELEC */
	case 128 + 1:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a lightning ball.", m_name);
			breath(m_idx, GF_ELEC,
				   randint(rlev * 3 / 2) + 8);
			update_smart_learn(m_idx, DRS_RES_ELEC);
			break;
		}
		/* RF5_BA_FIRE */
	case 128 + 2:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a fire ball.", m_name);
			breath(m_idx, GF_FIRE,
				   randint(rlev * 7 / 2) + 10);
			update_smart_learn(m_idx, DRS_RES_FIRE);
			break;
		}

		/* RF5_BA_COLD */
	case 128 + 3:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a frost ball.", m_name);
			breath(m_idx, GF_COLD,
				   randint(rlev * 3 / 2) + 10);
			update_smart_learn(m_idx, DRS_RES_COLD);
			break;
		}

		/* RF5_BA_POIS */
	case 128 + 4:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a stinking cloud.", m_name);
			breath(m_idx, GF_POIS,
				   damroll(12, 2));
			update_smart_learn(m_idx, DRS_RES_POIS);
			break;
		}

		/* RF5_BA_NETH */
	case 128 + 5:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a nether ball.", m_name);
			breath(m_idx, GF_NETHER,
				   (50 + damroll(10, 10) + rlev));
			update_smart_learn(m_idx, DRS_RES_NETHR);
			break;
		}

		/* RF5_BA_WATE */
	case 128 + 6:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s gestures fluidly.", m_name);
			msg_print("You are engulfed in a whirlpool.");
			breath(m_idx, GF_WATER,
				   randint(rlev * 5 / 2) + 50);
			break;
		}

		/* RF5_BA_MANA */
	case 128 + 7:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles powerfully.", m_name);
			else
				msg_format("%^s invokes a mana storm.", m_name);
			breath(m_idx, GF_MANA,
				   (rlev * 5) + damroll(10, 10));
			break;
		}

		/* RF5_BA_DARK */
	case 128 + 8:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles powerfully.", m_name);
			else
				msg_format("%^s invokes a darkness storm.", m_name);
			breath(m_idx, GF_DARK,
				   (rlev * 5) + damroll(10, 10));
			update_smart_learn(m_idx, DRS_RES_DARK);
			break;
		}

		/* RF5_DRAIN_MANA */
	case 128 + 9:
		{
			if (!direct)
				break;
			if (p_ptr->csp)
			{
				int r1;

				/* Disturb if legal */
				disturb(1, 0);

				/* Basic message */
				msg_format("%^s draws psychic energy from you!", m_name);

				/* Attack power */
				r1 = (randint(rlev) / 2) + 1;

				/* Full drain */
				if (r1 >= p_ptr->csp)
				{
					r1 = p_ptr->csp;
					p_ptr->csp = 0;
					p_ptr->csp_frac = 0;
				}
				/* Partial drain */
				else
				{
					p_ptr->csp -= r1;
				}

				/* Redraw mana */
				p_ptr->redraw |= (PR_MANA);

				/* Window stuff */
				p_ptr->window |= (PW_PLAYER_0 | PW_PLAYER_1);

				/* Heal the monster */
				if (m_ptr->hp < m_ptr->maxhp)
				{
					/* Heal */
					m_ptr->hp += (6 * r1);
					if (m_ptr->hp > m_ptr->maxhp)
						m_ptr->hp = m_ptr->maxhp;

					/* Redraw (later) if needed */
					if (p_ptr->health_who == m_idx)
						p_ptr->redraw |= (PR_HEALTH);

					/* Special message */
					if (seen)
					{
						msg_format("%^s appears healthier.", m_name);
					}
				}
			}
			update_smart_learn(m_idx, DRS_MANA);
			break;
		}

		/* RF5_MIND_BLAST */
	case 128 + 10:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (!seen)
			{
				msg_print("You feel something focusing on your mind.");
			}
			else
			{
				msg_format("%^s gazes deep into your eyes.", m_name);
			}

			if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				msg_print("Your mind is blasted by psionic energy.");
				if (!p_ptr->resist_confu)
				{
					(void)set_confused(p_ptr->confused + rand_int(4) + 4);
				}
				take_hit(damroll(8, 8), ddesc);
			}
			break;
		}

		/* RF5_BRAIN_SMASH */
	case 128 + 11:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (!seen)
			{
				msg_print("You feel something focusing on your mind.");
			}
			else
			{
				msg_format("%^s looks deep into your eyes.", m_name);
			}
			if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				msg_print("Your mind is blasted by psionic energy.");
				take_hit(damroll(12, 15), ddesc);
				if (!p_ptr->resist_blind)
				{
					(void)set_blind(p_ptr->blind + 8 + rand_int(8));
				}
				if (!p_ptr->resist_confu)
				{
					(void)set_confused(p_ptr->confused + rand_int(4) + 4);
				}
				if (!p_ptr->free_act)
				{
					(void)set_paralyzed(p_ptr->paralyzed + rand_int(4) + 4);
				}
				(void)set_slow(p_ptr->slow + rand_int(4) + 4);
			}
			break;
		}

		/* RF5_CAUSE_1 */
	case 128 + 12:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s points at you and curses.", m_name);
			if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				take_hit(damroll(3, 8), ddesc);
			}
			break;
		}

		/* RF5_CAUSE_2 */
	case 128 + 13:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s points at you and curses horribly.", m_name);
			if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				take_hit(damroll(8, 8), ddesc);
			}
			break;
		}

		/* RF5_CAUSE_3 */
	case 128 + 14:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles loudly.", m_name);
			else
				msg_format("%^s points at you, incanting terribly!", m_name);
			if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				take_hit(damroll(10, 15), ddesc);
			}
			break;
		}

		/* RF5_CAUSE_4 */
	case 128 + 15:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s screams the word 'DIE!'", m_name);
			else
				msg_format("%^s points at you, screaming the word DIE!", m_name);
			if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				take_hit(damroll(15, 15), ddesc);
				(void)set_cut(p_ptr->cut + damroll(10, 10));
			}
			break;
		}

		/* RF5_BO_ACID */
	case 128 + 16:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a acid bolt.", m_name);
			bolt(m_idx, GF_ACID,
				 damroll(7, 8) + (rlev / 3));
			update_smart_learn(m_idx, DRS_RES_ACID);
			break;
		}

		/* RF5_BO_ELEC */
	case 128 + 17:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a lightning bolt.", m_name);
			bolt(m_idx, GF_ELEC,
				 damroll(4, 8) + (rlev / 3));
			update_smart_learn(m_idx, DRS_RES_ELEC);
			break;
		}

		/* RF5_BO_FIRE */
	case 128 + 18:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a fire bolt.", m_name);
			bolt(m_idx, GF_FIRE,
				 damroll(9, 8) + (rlev / 3));
			update_smart_learn(m_idx, DRS_RES_FIRE);
			break;
		}

		/* RF5_BO_COLD */
	case 128 + 19:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a frost bolt.", m_name);
			bolt(m_idx, GF_COLD,
				 damroll(6, 8) + (rlev / 3));
			update_smart_learn(m_idx, DRS_RES_COLD);
			break;
		}

		/* RF5_BO_POIS */
	case 128 + 20:
		{
			/* XXX XXX XXX */
			break;
		}

		/* RF5_BO_NETH */
	case 128 + 21:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a nether bolt.", m_name);
			bolt(m_idx, GF_NETHER,
				 30 + damroll(5, 5) + (rlev * 3) / 2);
			update_smart_learn(m_idx, DRS_RES_NETHR);
			break;
		}

		/* RF5_BO_WATE */
	case 128 + 22:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a water bolt.", m_name);
			bolt(m_idx, GF_WATER,
				 damroll(10, 10) + (rlev));
			break;
		}

		/* RF5_BO_MANA */
	case 128 + 23:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a mana bolt.", m_name);
			bolt(m_idx, GF_MANA,
				 randint(rlev * 7 / 2) + 50);
			break;
		}
		/* RF5_BO_PLAS */
	case 128 + 24:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a plasma bolt.", m_name);
			bolt(m_idx, GF_PLASMA,
				 10 + damroll(8, 7) + (rlev));
			break;
		}

		/* RF5_BO_ICEE */
	case 128 + 25:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts an ice bolt.", m_name);
			bolt(m_idx, GF_ICE,
				 damroll(6, 6) + (rlev));
			update_smart_learn(m_idx, DRS_RES_COLD);
			break;
		}

		/* RF5_MISSILE */
	case 128 + 26:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a magic missile.", m_name);
			bolt(m_idx, GF_MISSILE,
				 damroll(2, 6) + (rlev / 3));
			break;
		}

		/* RF5_SCARE */
	case 128 + 27:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles, and you hear scary noises.", m_name);
			else
				msg_format("%^s casts a fearful illusion.", m_name);
			if (p_ptr->resist_fear)
			{
				msg_print("You refuse to be frightened.");
			}
			else if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You refuse to be frightened.");
			}
			else
			{
				(void)set_afraid(p_ptr->afraid + rand_int(4) + 4);
			}
			update_smart_learn(m_idx, DRS_RES_FEAR);
			break;
		}

		/* RF5_BLIND */
	case 128 + 28:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s casts a spell, burning your eyes!", m_name);
			if (p_ptr->resist_blind)
			{
				msg_print("You are unaffected!");
			}
			else if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				(void)set_blind(12 + rand_int(4));
			}
			update_smart_learn(m_idx, DRS_RES_BLIND);
			break;
		}

		/* RF5_CONF */
	case 128 + 29:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles, and you hear puzzling noises.", m_name);
			else
				msg_format("%^s creates a mesmerising illusion.", m_name);
			if (p_ptr->resist_confu)
			{
				msg_print("You disbelieve the feeble spell.");
			}
			else if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You disbelieve the feeble spell.");
			}
			else
			{
				(void)set_confused(p_ptr->confused + rand_int(4) + 4);
			}
			update_smart_learn(m_idx, DRS_RES_CONFU);
			break;
		}

		/* RF5_SLOW */
	case 128 + 30:
		{
			if (!direct)
				break;
			disturb(1, 0);
			msg_format("%^s drains power from your muscles!", m_name);
			if (p_ptr->free_act)
			{
				msg_print("You are unaffected!");
			}
			else if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				(void)set_slow(p_ptr->slow + rand_int(4) + 4);
			}
			update_smart_learn(m_idx, DRS_FREE);
			break;
		}

		/* RF5_HOLD */
	case 128 + 31:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s stares deep into your eyes!", m_name);
			if (p_ptr->free_act)
			{
				msg_print("You are unaffected!");
			}
			else if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_format("You resist the effects!");
			}
			else
			{
				(void)set_paralyzed(p_ptr->paralyzed + rand_int(4) + 4);
			}
			update_smart_learn(m_idx, DRS_FREE);
			break;
		}



		/* RF6_HASTE */
	case 160 + 0:
		{
			disturb(1, 0);
			if (blind)
			{
				msg_format("%^s mumbles.", m_name);
			}
			else
			{
				msg_format("%^s concentrates on %s body.", m_name, m_poss);
			}

			/* Allow quick speed increases to base+10 */
			if (m_ptr->mspeed < r_ptr->speed + 10)
			{
				msg_format("%^s starts moving faster.", m_name);
				m_ptr->mspeed += 10;
			}

			/* Allow small speed increases to base+20 */
			else if (m_ptr->mspeed < r_ptr->speed + 20)
			{
				msg_format("%^s starts moving faster.", m_name);
				m_ptr->mspeed += 2;
			}

			break;
		}

		/* RF6_XXX1X6 */
	case 160 + 1:
		{
			break;
		}

		/* RF6_HEAL */
	case 160 + 2:
		{
			disturb(1, 0);

			/* Message */
			if (blind)
			{
				msg_format("%^s mumbles.", m_name);
			}
			else
			{
				msg_format("%^s concentrates on %s wounds.", m_name, m_poss);
			}

			/* Heal some */
			m_ptr->hp += (rlev * 6);

			/* Fully healed */
			if (m_ptr->hp >= m_ptr->maxhp)
			{
				/* Fully healed */
				m_ptr->hp = m_ptr->maxhp;

				/* Message */
				if (seen)
				{
					msg_format("%^s looks REALLY healthy!", m_name);
				}
				else
				{
					msg_format("%^s sounds REALLY healthy!", m_name);
				}
			}

			/* Partially healed */
			else
			{
				/* Message */
				if (seen)
				{
					msg_format("%^s looks healthier.", m_name);
				}
				else
				{
					msg_format("%^s sounds healthier.", m_name);
				}
			}

			/* Redraw (later) if needed */
			if (p_ptr->health_who == m_idx)
				p_ptr->redraw |= (PR_HEALTH);

			/* Cancel fear */
			if (m_ptr->monfear)
			{
				/* Cancel fear */
				m_ptr->monfear = 0;

				/* Message */
				msg_format("%^s recovers %s courage.", m_name, m_poss);
			}

			break;
		}

		/* RF6_XXX2X6 */
	case 160 + 3:
		{
			break;
		}

		/* RF6_BLINK */
	case 160 + 4:
		{
			disturb(1, 0);
			msg_format("%^s blinks away.", m_name);
			teleport_away(m_idx, 10);
			break;
		}

		/* RF6_TPORT */
	case 160 + 5:
		{
			disturb(1, 0);
			msg_format("%^s teleports away.", m_name);
			teleport_away(m_idx, MAX_SIGHT * 2 + 5);
			break;
		}

		/* RF6_XXX3X6 */
	case 160 + 6:
		{
			break;
		}

		/* RF6_XXX4X6 */
	case 160 + 7:
		{
			break;
		}

		/* RF6_TELE_TO */
	case 160 + 8:
		{
			if (!direct)
				break;
			disturb(1, 0);
			msg_format("%^s commands you to return.", m_name);
			teleport_player_to(m_ptr->fy, m_ptr->fx);
			break;
		}

		/* RF6_TELE_AWAY */
	case 160 + 9:
		{
			if (!direct)
				break;
			disturb(1, 0);
			msg_format("%^s teleports you away.", m_name);
			teleport_player(100);
			break;
		}

		/* RF6_TELE_LEVEL */
	case 160 + 10:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles strangely.", m_name);
			else
				msg_format("%^s gestures at your feet.", m_name);
			if (p_ptr->resist_nexus)
			{
				msg_print("You are unaffected!");
			}
			else if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else
			{
				teleport_player_level();
			}
			update_smart_learn(m_idx, DRS_RES_NEXUS);
			break;
		}

		/* RF6_XXX5 */
	case 160 + 11:
		{
			break;
		}

		/* RF6_DARKNESS */
	case 160 + 12:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s gestures in shadow.", m_name);
			(void)unlite_area(0, 3);
			break;
		}

		/* RF6_TRAPS */
	case 160 + 13:
		{
			if (!direct)
				break;
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles, and then cackles evilly.", m_name);
			else
				msg_format("%^s casts a spell and cackles evilly.", m_name);
			(void)trap_creation();
			break;
		}

		/* RF6_FORGET */
	case 160 + 14:
		{
			if (!direct)
				break;
			disturb(1, 0);
			msg_format("%^s tries to blank your mind.", m_name);

			if (rand_int(100) < p_ptr->skill_sav)
			{
				msg_print("You resist the effects!");
			}
			else if (lose_all_info())
			{
				msg_print("Your memories fade away.");
			}
			break;
		}

		/* RF6_XXX6X6 */
	case 160 + 15:
		{
			break;
		}

		/* RF6_XXX7X6 */
	case 160 + 16:
		{
			break;
		}

		/* RF6_S_KIN */
	case 160 + 17:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons %s %s.", m_name, m_poss,
						   ((r_ptr->flags1) & RF1_UNIQUE ?
							"minions" : "kin"));
			summon_kin_type = r_ptr->d_char;	/* Big hack */
			for (k = 0; k < 6; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_KIN);
			}
			if (blind && count)
				msg_print("You hear many things appear nearby.");
			break;
		}

		/* RF6_S_MONSTER */
	case 160 + 18:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons help!", m_name);
			for (k = 0; k < 1; k++)
			{
				count += summon_specific(y, x, rlev, 0);
			}
			if (blind && count)
				msg_print("You hear something appear nearby.");
			break;
		}

		/* RF6_S_MONSTERS */
	case 160 + 19:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons monsters!", m_name);
			for (k = 0; k < 8; k++)
			{
				count += summon_specific(y, x, rlev, 0);
			}
			if (blind && count)
				msg_print("You hear many things appear nearby.");
			break;
		}

		/* RF6_S_ANT */
	case 160 + 20:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons ants.", m_name);
			for (k = 0; k < 6; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_ANT);
			}
			if (blind && count)
				msg_print("You hear many things appear nearby.");
			break;
		}

		/* RF6_S_SPIDER */
	case 160 + 21:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons spiders.", m_name);
			for (k = 0; k < 6; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_SPIDER);
			}
			if (blind && count)
				msg_print("You hear many things appear nearby.");
			break;
		}

		/* RF6_S_HOUND */
	case 160 + 22:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons hounds.", m_name);
			for (k = 0; k < 6; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_HOUND);
			}
			if (blind && count)
				msg_print("You hear many things appear nearby.");
			break;
		}

		/* RF6_S_HYDRA */
	case 160 + 23:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons hydras.", m_name);
			for (k = 0; k < 6; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_HYDRA);
			}
			if (blind && count)
				msg_print("You hear many things appear nearby.");
			break;
		}

		/* RF6_S_ANGEL */
	case 160 + 24:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons an angel!", m_name);
			for (k = 0; k < 1; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_ANGEL);
			}
			if (blind && count)
				msg_print("You hear something appear nearby.");
			break;
		}

		/* RF6_S_DEMON */
	case 160 + 25:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons a hellish adversary!", m_name);
			for (k = 0; k < 1; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_DEMON);
			}
			if (blind && count)
				msg_print("You hear something appear nearby.");
			break;
		}

		/* RF6_S_UNDEAD */
	case 160 + 26:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons an undead adversary!", m_name);
			for (k = 0; k < 1; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_UNDEAD);
			}
			if (blind && count)
				msg_print("You hear something appear nearby.");
			break;
		}

		/* RF6_S_DRAGON */
	case 160 + 27:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons a dragon!", m_name);
			for (k = 0; k < 1; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_DRAGON);
			}
			if (blind && count)
				msg_print("You hear something appear nearby.");
			break;
		}

		/* RF6_S_HI_UNDEAD */
	case 160 + 28:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons greater undead!", m_name);
			for (k = 0; k < 8; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_HI_UNDEAD);
			}
			if (blind && count)
			{
				msg_print("You hear many creepy things appear nearby.");
			}
			break;
		}

		/* RF6_S_HI_DRAGON */
	case 160 + 29:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons ancient dragons!", m_name);
			for (k = 0; k < 8; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_HI_DRAGON);
			}
			if (blind && count)
			{
				msg_print("You hear many powerful things appear nearby.");
			}
			break;
		}

		/* RF6_S_WRAITH */
	case 160 + 30:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons mighty undead opponents!", m_name);
			for (k = 0; k < 8; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_WRAITH);
			}
			for (k = 0; k < 8; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_HI_UNDEAD);
			}
			if (blind && count)
			{
				msg_print("You hear many creepy things appear nearby.");
			}
			break;
		}

		/* RF6_S_UNIQUE */
	case 160 + 31:
		{
			disturb(1, 0);
			if (blind)
				msg_format("%^s mumbles.", m_name);
			else
				msg_format("%^s magically summons special opponents!", m_name);
			for (k = 0; k < 8; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_UNIQUE);
			}
			for (k = 0; k < 8; k++)
			{
				count += summon_specific(y, x, rlev, SUMMON_HI_UNDEAD);
			}
			if (blind && count)
			{
				msg_print("You hear many powerful things appear nearby.");
			}
			break;
		}
	}


	/* Remember what the monster did to us */
	if (seen)
	{
		/* Inate spell */
		if (thrown_spell < 32 * 4)
		{
			r_ptr->r_flags4 |= (1L << (thrown_spell - 32 * 3));
			if (r_ptr->r_cast_inate < MAX_UCHAR)
				r_ptr->r_cast_inate++;
		}

		/* Bolt or Ball */
		else if (thrown_spell < 32 * 5)
		{
			r_ptr->r_flags5 |= (1L << (thrown_spell - 32 * 4));
			if (r_ptr->r_cast_spell < MAX_UCHAR)
				r_ptr->r_cast_spell++;
		}

		/* Special spell */
		else if (thrown_spell < 32 * 6)
		{
			r_ptr->r_flags6 |= (1L << (thrown_spell - 32 * 5));
			if (r_ptr->r_cast_spell < MAX_UCHAR)
				r_ptr->r_cast_spell++;
		}
	}


	/* Always take note of monsters that kill you */
	if (p_ptr->is_dead && (r_ptr->r_deaths < MAX_SHORT))
	{
		r_ptr->r_deaths++;
	}


	/* A spell was cast */
	return (TRUE);
}


/*
 * Returns whether a given monster will try to run from the player.
 *
 * Monsters will attempt to avoid very powerful players.  See below.
 *
 * Because this function is called so often, little details are important
 * for efficiency.  Like not using "mod" or "div" when possible.  And
 * attempting to check the conditions in an optimal order.  Note that
 * "(x << 2) == (x * 4)" if "x" has enough bits to hold the result.
 *
 * Note that this function is responsible for about one to five percent
 * of the processor use in normal conditions...
 */
static int
mon_will_run(int m_idx)
{
	monster_type *m_ptr = &m_list[m_idx];

#ifdef ALLOW_TERROR

	monster_race *r_ptr = &r_info[m_ptr->r_idx];

	u16b p_lev, m_lev;
	u16b p_chp, p_mhp;
	u16b m_chp, m_mhp;
	u32b p_val, m_val;

#endif

	/* Keep monsters from running too far away */
	if (m_ptr->cdis > MAX_SIGHT + 5)
		return (FALSE);

	/* All "afraid" monsters will run away */
	if (m_ptr->monfear)
		return (TRUE);

#ifdef ALLOW_TERROR

	/* Nearby monsters will not become terrified */
	if (m_ptr->cdis <= 5)
		return (FALSE);

	/* Examine player power */
	p_lev = get_raw_skill(p_ptr->wskill) / 5;
	if (get_skill(S_MAGIC) > p_lev)
		p_lev = get_skill(S_MAGIC);

	/* Examine monster power (level plus morale) */
	m_lev = r_ptr->level + (m_idx & 0x08) + 25;

	/* Optimize extreme cases below */
	if (m_lev > p_lev + 4)
		return (FALSE);
	if (m_lev + 4 <= p_lev)
		return (TRUE);

	/* Examine player health */
	p_chp = p_ptr->chp;
	p_mhp = p_ptr->mhp;

	/* Examine monster health */
	m_chp = m_ptr->hp;
	m_mhp = m_ptr->maxhp;

	/* Prepare to optimize the calculation */
	p_val = (p_lev * p_mhp) + (p_chp << 2);		/* div p_mhp */
	m_val = (m_lev * m_mhp) + (m_chp << 2);		/* div m_mhp */

	/* Strong players scare strong monsters */
	if (p_val * m_mhp > m_val * p_mhp)
		return (TRUE);

#endif

	/* Assume no terror */
	return (FALSE);
}




#ifdef MONSTER_FLOW

/*
 * Choose the "best" direction for "flowing"
 *
 * Note that ghosts and rock-eaters are never allowed to "flow",
 * since they should move directly towards the player.
 *
 * Prefer "non-diagonal" directions, but twiddle them a little
 * to angle slightly towards the player's actual location.
 *
 * Allow very perceptive monsters to track old "spoor" left by
 * previous locations occupied by the player.  This will tend
 * to have monsters end up either near the player or on a grid
 * recently occupied by the player (and left via "teleport").
 *
 * Note that if "smell" is turned on, all monsters get vicious.
 *
 * Also note that teleporting away from a location will cause
 * the monsters who were chasing you to converge on that location
 * as long as you are still near enough to "annoy" them without
 * being close enough to chase directly.  I have no idea what will
 * happen if you combine "smell" with low "aaf" values.
 */
static bool
get_moves_aux(int m_idx, int *yp, int *xp)
{
	int py = p_ptr->py;
	int px = p_ptr->px;

	int i, y, x, y1, x1;

	int when = 0;
	int cost = 999;

	monster_type *m_ptr = &m_list[m_idx];
	monster_race *r_ptr = &r_info[m_ptr->r_idx];

	/* Monster flowing disabled */
	if (!flow_by_sound)
		return (FALSE);

	/* Monster can go through rocks */
	if (r_ptr->flags2 & (RF2_PASS_WALL))
		return (FALSE);
	if (r_ptr->flags2 & (RF2_KILL_WALL))
		return (FALSE);

	/* Monster location */
	y1 = m_ptr->fy;
	x1 = m_ptr->fx;

	/* The player is not currently near the monster grid */
	if (cave_when[y1][x1] < cave_when[py][px])
	{
		/* The player has never been near the monster grid */
		if (cave_when[y1][x1] == 0)
			return (FALSE);

		/* The monster is not allowed to track the player */
		if (!flow_by_smell)
			return (FALSE);
	}

	/* Monster is too far away to notice the player */
	if (cave_cost[y1][x1] > MONSTER_FLOW_DEPTH)
		return (FALSE);
	if (cave_cost[y1][x1] > r_ptr->aaf)
		return (FALSE);

	/* Hack -- Player can see us, run towards him */
	if (player_has_los_bold(y1, x1))
		return (FALSE);

	/* Check nearby grids, diagonals first */
	for (i = 7; i >= 0; i--)
	{
		/* Get the location */
		y = y1 + ddy_ddd[i];
		x = x1 + ddx_ddd[i];

		/* Ignore illegal locations */
		if (cave_when[y][x] == 0)
			continue;

		/* Ignore ancient locations */
		if (cave_when[y][x] < when)
			continue;

		/* Ignore distant locations */
		if (cave_cost[y][x] > cost)
			continue;

		/* Save the cost and time */
		when = cave_when[y][x];
		cost = cave_cost[y][x];

		/* Hack -- Save the "twiddled" location */
		(*yp) = py + 16 * ddy_ddd[i];
		(*xp) = px + 16 * ddx_ddd[i];
	}

	/* No legal move (?) */
	if (!when)
		return (FALSE);

	/* Success */
	return (TRUE);
}

#endif


/*
 * Choose "logical" directions for monster movement
 *
 * We store the directions in a special "mm" array
 */
static void
get_moves(int m_idx, int mm[5])
{
	int py = p_ptr->py;
	int px = p_ptr->px;

	monster_type *m_ptr = &m_list[m_idx];

	int y, ay, x, ax;

	int move_val = 0;

	int y2 = py;
	int x2 = px;


#ifdef MONSTER_FLOW
	/* Flow towards the player */
	if (flow_by_sound)
	{
		/* Flow towards the player */
		(void)get_moves_aux(m_idx, &y2, &x2);
	}
#endif

	/* Extract the "pseudo-direction" */
	y = m_ptr->fy - y2;
	x = m_ptr->fx - x2;


	/* Apply fear */
	if (mon_will_run(m_idx))
	{
		/* This is not a very "smart" method XXX XXX */
		y = (-y);
		x = (-x);
	}


	/* Extract the "absolute distances" */
	ax = ABS(x);
	ay = ABS(y);

	/* Do something weird */
	if (y < 0)
		move_val += 8;
	if (x > 0)
		move_val += 4;

	/* Prevent the diamond maneuvre */
	if (ay > (ax << 1))
	{
		move_val++;
		move_val++;
	}
	else if (ax > (ay << 1))
	{
		move_val++;
	}

	/* Analyze */
	switch (move_val)
	{
	case 0:
		{
			mm[0] = 9;
			if (ay > ax)
			{
				mm[1] = 8;
				mm[2] = 6;
				mm[3] = 7;
				mm[4] = 3;
			}
			else
			{
				mm[1] = 6;
				mm[2] = 8;
				mm[3] = 3;
				mm[4] = 7;
			}
			break;
		}

	case 1:
	case 9:
		{
			mm[0] = 6;
			if (y < 0)
			{
				mm[1] = 3;
				mm[2] = 9;
				mm[3] = 2;
				mm[4] = 8;
			}
			else
			{
				mm[1] = 9;
				mm[2] = 3;
				mm[3] = 8;
				mm[4] = 2;
			}
			break;
		}

	case 2:
	case 6:
		{
			mm[0] = 8;
			if (x < 0)
			{
				mm[1] = 9;
				mm[2] = 7;
				mm[3] = 6;
				mm[4] = 4;
			}
			else
			{
				mm[1] = 7;
				mm[2] = 9;
				mm[3] = 4;
				mm[4] = 6;
			}
			break;
		}

	case 4:
		{
			mm[0] = 7;
			if (ay > ax)
			{
				mm[1] = 8;
				mm[2] = 4;
				mm[3] = 9;
				mm[4] = 1;
			}
			else
			{
				mm[1] = 4;
				mm[2] = 8;
				mm[3] = 1;
				mm[4] = 9;
			}
			break;
		}

	case 5:
	case 13:
		{
			mm[0] = 4;
			if (y < 0)
			{
				mm[1] = 1;
				mm[2] = 7;
				mm[3] = 2;
				mm[4] = 8;
			}
			else
			{
				mm[1] = 7;
				mm[2] = 1;
				mm[3] = 8;
				mm[4] = 2;
			}
			break;
		}

	case 8:
		{
			mm[0] = 3;
			if (ay > ax)
			{
				mm[1] = 2;
				mm[2] = 6;
				mm[3] = 1;
				mm[4] = 9;
			}
			else
			{
				mm[1] = 6;
				mm[2] = 2;
				mm[3] = 9;
				mm[4] = 1;
			}
			break;
		}

	case 10:
	case 14:
		{
			mm[0] = 2;
			if (x < 0)
			{
				mm[1] = 3;
				mm[2] = 1;
				mm[3] = 6;
				mm[4] = 4;
			}
			else
			{
				mm[1] = 1;
				mm[2] = 3;
				mm[3] = 4;
				mm[4] = 6;
			}
			break;
		}

	default:					/* case 12: */
		{
			mm[0] = 1;
			if (ay > ax)
			{
				mm[1] = 2;
				mm[2] = 4;
				mm[3] = 3;
				mm[4] = 7;
			}
			else
			{
				mm[1] = 4;
				mm[2] = 2;
				mm[3] = 7;
				mm[4] = 3;
			}
			break;
		}
	}
}



/*
 * Hack -- compare the "strength" of two monsters XXX XXX XXX
 */
static int
compare_monsters(monster_type * m_ptr, monster_type * n_ptr)
{
	monster_race *r_ptr;

	u32b mexp1, mexp2;

	/* Race 1 */
	r_ptr = &r_info[m_ptr->r_idx];

	/* Extract mexp */
	mexp1 = r_ptr->mexp;

	/* Race 2 */
	r_ptr = &r_info[n_ptr->r_idx];

	/* Extract mexp */
	mexp2 = r_ptr->mexp;

	/* Compare */
	if (mexp1 < mexp2)
		return (-1);
	if (mexp1 > mexp2)
		return (1);

	/* Assume equal */
	return (0);
}



/* Determine whether the player is invisible to a monster */
static bool
player_invis(monster_type * m_ptr)
{
	s16b inv, mlv;
	monster_race *r_ptr = &r_info[m_ptr->r_idx];

	inv = p_ptr->invisible;

	mlv = (s16b) r_ptr->level;

	if (r_ptr->flags3 & RF3_NO_SLEEP)
		mlv += 10;
	if (r_ptr->flags3 & RF3_DRAGON)
		mlv += 20;
	if (r_ptr->flags3 & RF3_UNDEAD)
		mlv += 15;
	if (r_ptr->flags3 & RF3_DEMON)
		mlv += 15;
	if (r_ptr->flags3 & RF3_ANIMAL)
		mlv += 15;
	if (r_ptr->flags3 & RF3_ORC)
		mlv -= 15;
	if (r_ptr->flags3 & RF3_TROLL)
		mlv -= 10;
	if (r_ptr->flags2 & RF2_STUPID)
		mlv /= 2;
	if (r_ptr->flags2 & RF2_SMART)
		mlv = (mlv * 5) / 4;
	if (r_ptr->flags1 & RF1_QUESTOR)
		inv = 0;
	if (r_ptr->flags2 & RF2_INVISIBLE)
		inv = 0;
	if (r_ptr->flags2 & RF2_NOMISS)
		inv = 0;
	if (m_ptr->cdis <= 1)		/* It's easier when you're nearby. */
		inv = (inv * 2) / 3;
	if (mlv < 1)
		mlv = 1;
	return (inv >= randint(mlv * 2));
}

/*
 * Process a monster
 *
 * In several cases, we directly update the monster lore
 *
 * Note that a monster is only allowed to "reproduce" if there
 * are a limited number of "reproducing" monsters on the current
 * level.  This should prevent the level from being "swamped" by
 * reproducing monsters.  It also allows a large mass of mice to
 * prevent a louse from multiplying, but this is a small price to
 * pay for a simple multiplication method.
 *
 * XXX Monster fear is slightly odd, in particular, monsters will
 * fixate on opening a door even if they cannot open it.  Actually,
 * the same thing happens to normal monsters when they hit a door
 *
 * In addition, monsters which *cannot* open or bash down a door
 * will still stand there trying to open it...  XXX XXX XXX
 *
 * Technically, need to check for monster in the way combined
 * with that monster being in a wall (or door?) XXX
 */
static void
process_monster(int m_idx)
{
	monster_type *m_ptr = &m_list[m_idx];
	monster_race *r_ptr = &r_info[m_ptr->r_idx];

	int i, d, oy, ox, ny, nx;

	int mm[5];

	bool stagger;

	bool do_turn;
	bool do_move;
	bool do_view;

	bool did_open_door;
	bool did_bash_door;
	bool did_take_item;
	bool did_kill_item;
	bool did_move_body;
	bool did_kill_body;
	bool did_pass_wall;
	bool did_kill_wall;

	bool inv;

	inv = player_invis(m_ptr);


	/* Handle "sleep" */
	if (m_ptr->csleep)
	{
		u32b notice;

		/* Aggravation */
		if (p_ptr->aggravate)
		{
			/* Reset sleep counter */
			m_ptr->csleep = 0;

			/* Notice the "waking up" */
			if (m_ptr->ml)
			{
				char m_name[80];

				/* Acquire the monster name */
				monster_desc(m_name, m_ptr, 0);

				/* Dump a message */
				msg_format("%^s wakes up.", m_name);
			}

			/* Efficiency XXX XXX */
			return;
		}

		/* Anti-stealth */
		notice = rand_int(1024);

		/* Hack -- See if monster "notices" player */
		if ((notice * notice * notice) <= p_ptr->noise)
		{
			int d = 1;

			/* Wake up faster near the player */
			if (m_ptr->cdis < 50)
				d = (100 / m_ptr->cdis);

			/* Still asleep */
			if (m_ptr->csleep > d)
			{
				/* Monster wakes up "a little bit" */
				m_ptr->csleep -= d;

				/* Notice the "not waking up" */
				if (m_ptr->ml)
				{
					/* Hack -- Count the ignores */
					if (r_ptr->r_ignore < MAX_UCHAR)
					{
						r_ptr->r_ignore++;
					}
				}
			}

			/* Just woke up */
			else
			{
				/* Reset sleep counter */
				m_ptr->csleep = 0;

				/* Notice the "waking up" */
				if (m_ptr->ml)
				{
					char m_name[80];

					/* Acquire the monster name */
					monster_desc(m_name, m_ptr, 0);

					/* Dump a message */
					msg_format("%^s wakes up.", m_name);

					/* Hack -- Count the wakings */
					if (r_ptr->r_wake < MAX_UCHAR)
					{
						r_ptr->r_wake++;
					}
				}
			}
		}

		/* Still sleeping */
		if (m_ptr->csleep)
			return;
	}


	/* Handle "stun" */
	if (m_ptr->stunned)
	{
		int d = 1;

		/* Make a "saving throw" against stun */
		if (rand_int(5000) <= r_ptr->level * r_ptr->level)
		{
			/* Recover fully */
			d = m_ptr->stunned;
		}

		/* Hack -- Recover from stun */
		if (m_ptr->stunned > d)
		{
			/* Recover somewhat */
			m_ptr->stunned -= d;
		}

		/* Fully recover */
		else
		{
			/* Recover fully */
			m_ptr->stunned = 0;

			/* Message if visible */
			if (m_ptr->ml)
			{
				char m_name[80];

				/* Acquire the monster name */
				monster_desc(m_name, m_ptr, 0);

				/* Dump a message */
				msg_format("%^s is no longer stunned.", m_name);
			}
		}

		/* Still stunned */
		if (m_ptr->stunned)
			return;
	}


	/* Handle confusion */
	if (m_ptr->confused)
	{
		int d = randint(r_ptr->level / 10 + 1);

		/* Still confused */
		if (m_ptr->confused > d)
		{
			/* Reduce the confusion */
			m_ptr->confused -= d;
		}

		/* Recovered */
		else
		{
			/* No longer confused */
			m_ptr->confused = 0;

			/* Message if visible */
			if (m_ptr->ml)
			{
				char m_name[80];

				/* Acquire the monster name */
				monster_desc(m_name, m_ptr, 0);

				/* Dump a message */
				msg_format("%^s is no longer confused.", m_name);
			}
		}
	}


	/* Handle "fear" */
	if (m_ptr->monfear)
	{
		/* Amount of "boldness" */
		int d = randint(r_ptr->level / 10 + 1);

		/* Still afraid */
		if (m_ptr->monfear > d)
		{
			/* Reduce the fear */
			m_ptr->monfear -= d;
		}

		/* Recover from fear, take note if seen */
		else
		{
			/* No longer afraid */
			m_ptr->monfear = 0;

			/* Visual note */
			if (m_ptr->ml)
			{
				char m_name[80];
				char m_poss[80];

				/* Acquire the monster name/poss */
				monster_desc(m_name, m_ptr, 0);
				monster_desc(m_poss, m_ptr, 0x22);

				/* Dump a message */
				msg_format("%^s recovers %s courage.", m_name, m_poss);
			}
		}
	}


	/* Get the origin */
	oy = m_ptr->fy;
	ox = m_ptr->fx;


	/* Attempt to "mutiply" if able and allowed */
	if ((r_ptr->flags2 & (RF2_MULTIPLY)) && (num_repro < MAX_REPRO))
	{
		int k, y, x;

		/* Count the adjacent monsters */
		for (k = 0, y = oy - 1; y <= oy + 1; y++)
		{
			for (x = ox - 1; x <= ox + 1; x++)
			{
				/* Count monsters */
				if (cave_m_idx[y][x] > 0)
					k++;
			}
		}

		/* Hack -- multiply slower in crowded areas */
		if ((k < 4) && (!k || !rand_int(k * MON_MULT_ADJ)))
		{
			/* Try to multiply */
			if (multiply_monster(m_idx))
			{
				/* Take note if visible */
				if (m_ptr->ml)
				{
					r_ptr->r_flags2 |= (RF2_MULTIPLY);
				}

				/* Multiplying takes energy */
				return;
			}
		}
	}


	/* Attempt to cast a spell */
	if (make_attack_spell(m_idx))
		return;


	/* Reset */
	stagger = FALSE;

	/* Confused or can't find player */
	if (m_ptr->confused || inv)
	{
		/* Stagger */
		stagger = TRUE;
	}

	/* Random movement */
	else if (r_ptr->flags1 & (RF1_RAND_50 | RF1_RAND_25))
	{
		/* Random movement (25%) */
		if (!(r_ptr->flags1 & (RF1_RAND_50)))
		{
			/* Random */
			if (rand_int(100) < 25)
			{
				/* Memorize flags */
				if (m_ptr->ml)
					r_ptr->r_flags1 |= (RF1_RAND_25);

				/* Stagger */
				stagger = TRUE;
			}
		}

		/* Random movement (50%) */
		else if (!(r_ptr->flags1 & (RF1_RAND_25)))
		{
			/* Random */
			if (rand_int(100) < 50)
			{
				/* Memorize flags */
				if (m_ptr->ml)
					r_ptr->r_flags1 |= (RF1_RAND_50);

				/* Stagger */
				stagger = TRUE;
			}
		}

		/* Random movement (75%) */
		else
		{
			/* Random */
			if (rand_int(100) < 75)
			{
				/* Memorize flags */
				if (m_ptr->ml)
					r_ptr->r_flags1 |= (RF1_RAND_50 | RF1_RAND_25);

				/* Stagger */
				stagger = TRUE;
			}
		}
	}

	/* Normal movement */
	if (!stagger)
	{
		/* Logical moves */
		get_moves(m_idx, mm);
	}


	/* Assume nothing */
	do_turn = FALSE;
	do_move = FALSE;
	do_view = FALSE;

	/* Assume nothing */
	did_open_door = FALSE;
	did_bash_door = FALSE;
	did_take_item = FALSE;
	did_kill_item = FALSE;
	did_move_body = FALSE;
	did_kill_body = FALSE;
	did_pass_wall = FALSE;
	did_kill_wall = FALSE;


	/* Process moves */
	for (i = 0; i < 5; i++)
	{
		/* Get the direction (or stagger) */
		d = (stagger ? ddd[rand_int(8)] : mm[i]);

		/* Get the destination */
		ny = oy + ddy[d];
		nx = ox + ddx[d];


		/* Floor is open? */
		if (cave_floor_bold(ny, nx))
		{
			/* Go ahead and move */
			do_move = TRUE;
		}

		/* Permanent wall */
		else if (cave_feat[ny][nx] >= FEAT_PERM_EXTRA)
		{
			/* Nothing */
		}

		/* Monster moves through walls (and doors) */
		else if (r_ptr->flags2 & (RF2_PASS_WALL))
		{
			/* Pass through walls/doors/rubble */
			do_move = TRUE;

			/* Monster went through a wall */
			did_pass_wall = TRUE;
		}

		/* Monster destroys walls (and doors) */
		else if (r_ptr->flags2 & (RF2_KILL_WALL))
		{
			/* Eat through walls/doors/rubble */
			do_move = TRUE;

			/* Monster destroyed a wall */
			did_kill_wall = TRUE;

			/* Forget the wall */
			cave_info[ny][nx] &= ~(CAVE_MARK);

			/* Notice */
			cave_set_feat(ny, nx, FEAT_FLOOR);

			/* Note changes to viewable region */
			if (player_has_los_bold(ny, nx))
				do_view = TRUE;
		}

		/* Handle doors and secret doors */
		else if (((cave_feat[ny][nx] >= FEAT_DOOR_HEAD) &&
				  (cave_feat[ny][nx] <= FEAT_DOOR_TAIL)) ||
				 (cave_feat[ny][nx] == FEAT_SECRET))
		{
			bool may_bash = TRUE;

			/* Take a turn */
			do_turn = TRUE;

			/* Creature can open doors. */
			if (r_ptr->flags2 & (RF2_OPEN_DOOR))
			{
				/* Closed doors and secret doors */
				if ((cave_feat[ny][nx] == FEAT_DOOR_HEAD) ||
					(cave_feat[ny][nx] == FEAT_SECRET))
				{
					/* The door is open */
					did_open_door = TRUE;

					/* Do not bash the door */
					may_bash = FALSE;
				}

				/* Locked doors (not jammed) */
				else if (cave_feat[ny][nx] < FEAT_DOOR_HEAD + 0x08)
				{
					int k;

					/* Door power */
					k = ((cave_feat[ny][nx] - FEAT_DOOR_HEAD) & 0x07);

#if 0
					/* XXX XXX XXX Old test (pval 10 to 20) */
					if (randint((m_ptr->hp + 1) * (50 + o_ptr->pval)) <
						40 * (m_ptr->hp - 10 - o_ptr->pval));
#endif

					/* Try to unlock it XXX XXX XXX */
					if (rand_int(m_ptr->hp / 10) > k)
					{
						/* Unlock the door */
						cave_set_feat(ny, nx, FEAT_DOOR_HEAD + 0x00);

						/* Do not bash the door */
						may_bash = FALSE;
					}
				}
			}

			/* Stuck doors -- attempt to bash them down if allowed */
			if (may_bash && (r_ptr->flags2 & (RF2_BASH_DOOR)))
			{
				int k;

				/* Door power */
				k = ((cave_feat[ny][nx] - FEAT_DOOR_HEAD) & 0x07);

#if 0
				/* XXX XXX XXX Old test (pval 10 to 20) */
				if (randint((m_ptr->hp + 1) * (50 + o_ptr->pval)) <
					40 * (m_ptr->hp - 10 - o_ptr->pval));
#endif

				/* Attempt to Bash XXX XXX XXX */
				if (rand_int(m_ptr->hp / 10) > k)
				{
					/* Message */
					msg_print("You hear a door burst open!");

					/* Disturb (sometimes) */
					if (disturb_minor)
						disturb(0, 0);

					/* The door was bashed open */
					did_bash_door = TRUE;

					/* Hack -- fall into doorway */
					do_move = TRUE;
				}
			}


			/* Deal with doors in the way */
			if (did_open_door || did_bash_door)
			{
				/* Break down the door */
				if (did_bash_door && (rand_int(100) < 50))
				{
					cave_set_feat(ny, nx, FEAT_BROKEN);
				}

				/* Open the door */
				else
				{
					cave_set_feat(ny, nx, FEAT_OPEN);
				}

				/* Handle viewable doors */
				if (player_has_los_bold(ny, nx))
					do_view = TRUE;
			}
		}


		/* Hack -- check for Glyph of Warding */
		if (do_move && (cave_feat[ny][nx] == FEAT_GLYPH))
		{
			/* Assume no move allowed */
			do_move = FALSE;

			/* Break the ward */
			if (randint(BREAK_GLYPH) < r_ptr->level)
			{
				/* Describe observable breakage */
				if (cave_info[ny][nx] & (CAVE_MARK))
				{
					msg_print("The rune of protection is broken!");
				}

				/* Forget the rune */
				cave_info[ny][nx] &= ~(CAVE_MARK);

				/* Break the rune */
				cave_set_feat(ny, nx, FEAT_FLOOR);

				/* Allow movement */
				do_move = TRUE;
			}
		}

		/* Some monsters never attack */
		if (do_move && (cave_m_idx[ny][nx] < 0) &&
			(r_ptr->flags1 & (RF1_NEVER_BLOW)))
		{
			/* Hack -- memorize lack of attacks */
			/* if (m_ptr->ml) r_ptr->r_flags1 |= (RF1_NEVER_BLOW); */

			/* Do not move */
			do_move = FALSE;
		}


		/* The player is in the way.  Attack him. */
		if (do_move && (cave_m_idx[ny][nx] < 0))
		{
			/* Do the attack */
			(void)make_attack_normal(m_idx);

			/* Do not move */
			do_move = FALSE;

			/* Took a turn */
			do_turn = TRUE;
		}


		/* Some monsters never move */
		if (do_move && (r_ptr->flags1 & (RF1_NEVER_MOVE)))
		{
			/* Hack -- memorize lack of attacks */
			/* if (m_ptr->ml) r_ptr->r_flags1 |= (RF1_NEVER_MOVE); */

			/* Do not move */
			do_move = FALSE;
		}


		/* A monster is in the way */
		if (do_move && (cave_m_idx[ny][nx] > 0))
		{
			monster_type *n_ptr = &m_list[cave_m_idx[ny][nx]];

			/* Assume no movement */
			do_move = FALSE;

			/* Kill weaker monsters */
			if ((r_ptr->flags2 & (RF2_KILL_BODY)) &&
				(compare_monsters(m_ptr, n_ptr) > 0))
			{
				/* Allow movement */
				do_move = TRUE;

				/* Monster ate another monster */
				did_kill_body = TRUE;

				/* Message XXX XXX XXX */

				/* Kill the monster */
				delete_monster(ny, nx);
			}
		}

		/* A monster is in the way */
		if (do_move && (cave_m_idx[ny][nx] > 0))
		{
			monster_type *n_ptr = &m_list[cave_m_idx[ny][nx]];

			/* Assume no movement */
			do_move = FALSE;

			/* Push past weaker monsters (unless leaving a wall) */
			if ((r_ptr->flags2 & (RF2_MOVE_BODY)) &&
				(compare_monsters(m_ptr, n_ptr) > 0) &&
				(cave_floor_bold(m_ptr->fy, m_ptr->fx)))
			{
				/* Allow movement */
				do_move = TRUE;

				/* Monster pushed past another monster */
				did_move_body = TRUE;

				/* XXX XXX XXX Message */
			}
		}


		/* Creature has been allowed move */
		if (do_move)
		{
			s16b this_o_idx, next_o_idx = 0;

			/* Take a turn */
			do_turn = TRUE;

			/* Move the monster */
			monster_swap(oy, ox, ny, nx);

			/* Possible disturb */
			if (m_ptr->ml &&
				(disturb_move ||
				 ((m_ptr->mflag & (MFLAG_VIEW)) &&
				  disturb_near)))
			{
				/* Disturb */
				disturb(0, 0);
			}


			/* Scan all objects in the grid */
			for (this_o_idx = cave_o_idx[ny][nx]; this_o_idx; this_o_idx = next_o_idx)
			{
				object_type *o_ptr;

				/* Acquire object */
				o_ptr = &o_list[this_o_idx];

				/* Acquire next object */
				next_o_idx = o_ptr->next_o_idx;

				/* Skip gold */
				if (o_ptr->tval == TV_GOLD)
					continue;

				/* Take or Kill objects on the floor */
				if ((r_ptr->flags2 & (RF2_TAKE_ITEM)) ||
					(r_ptr->flags2 & (RF2_KILL_ITEM)))
				{
					u32b f1, f2, f3;

					u32b flg3 = 0L;

					char m_name[80];
					char o_name[80];

					/* Extract some flags */
					object_flags(o_ptr, &f1, &f2, &f3);

					/* Acquire the object name */
					object_desc(o_name, o_ptr, TRUE, 3);

					/* Acquire the monster name */
					monster_desc(m_name, m_ptr, 0x04);

					/* React to objects that hurt the monster */
					if (f1 & (TR1_KILL_DRAGON))
						flg3 |= (RF3_DRAGON);
					if (f1 & (TR1_SLAY_DRAGON))
						flg3 |= (RF3_DRAGON);
					if (f1 & (TR1_SLAY_TROLL))
						flg3 |= (RF3_TROLL);
					if (f1 & (TR1_SLAY_GIANT))
						flg3 |= (RF3_GIANT);
					if (f1 & (TR1_SLAY_ORC))
						flg3 |= (RF3_ORC);
					if (f1 & (TR1_SLAY_DEMON))
						flg3 |= (RF3_DEMON);
					if (f1 & (TR1_SLAY_UNDEAD))
						flg3 |= (RF3_UNDEAD);
					if (f1 & (TR1_SLAY_ANIMAL))
						flg3 |= (RF3_ANIMAL);
					if (f1 & (TR1_SLAY_EVIL))
						flg3 |= (RF3_EVIL);

					/* The object cannot be picked up by the monster */
					if (artifact_p(o_ptr) || (r_ptr->flags3 & flg3))
					{
						/* Only give a message for "take_item" */
						if (r_ptr->flags2 & (RF2_TAKE_ITEM))
						{
							/* Take note */
							did_take_item = TRUE;

							/* Describe observable situations */
							if (m_ptr->ml && player_has_los_bold(ny, nx))
							{
								/* Dump a message */
								msg_format("%^s tries to pick up %s, but fails.",
										   m_name, o_name);
							}
						}
					}

					/* Pick up the item */
					else if (r_ptr->flags2 & (RF2_TAKE_ITEM))
					{
						object_type *i_ptr;
						object_type object_type_body;

						/* Take note */
						did_take_item = TRUE;

						/* Describe observable situations */
						if (player_has_los_bold(ny, nx))
						{
							/* Dump a message */
							msg_format("%^s picks up %s.", m_name, o_name);
						}

						/* Get local object */
						i_ptr = &object_type_body;

						/* Obtain local object */
						object_copy(i_ptr, o_ptr);

						/* Delete the object */
						delete_object_idx(this_o_idx);

						/* Carry the object */
						(void)monster_carry(m_idx, i_ptr);
					}

					/* Destroy the item */
					else
					{
						/* Take note */
						did_kill_item = TRUE;

						/* Describe observable situations */
						if (player_has_los_bold(ny, nx))
						{
							/* Dump a message */
							msg_format("%^s crushes %s.", m_name, o_name);
						}

						/* Delete the object */
						delete_object_idx(this_o_idx);
					}
				}
			}
		}

		/* Stop when done */
		if (do_turn)
			break;
	}


	/* Notice changes in view */
	if (do_view)
	{
		/* Update the visuals */
		p_ptr->update |= (PU_UPDATE_VIEW | PU_MONSTERS);

		/* Fully update the flow XXX XXX XXX */
		p_ptr->update |= (PU_FORGET_FLOW | PU_UPDATE_FLOW);
	}


	/* Learn things from observable monster */
	if (m_ptr->ml)
	{
		/* Monster opened a door */
		if (did_open_door)
			r_ptr->r_flags2 |= (RF2_OPEN_DOOR);

		/* Monster bashed a door */
		if (did_bash_door)
			r_ptr->r_flags2 |= (RF2_BASH_DOOR);

		/* Monster tried to pick something up */
		if (did_take_item)
			r_ptr->r_flags2 |= (RF2_TAKE_ITEM);

		/* Monster tried to crush something */
		if (did_kill_item)
			r_ptr->r_flags2 |= (RF2_KILL_ITEM);

		/* Monster pushed past another monster */
		if (did_move_body)
			r_ptr->r_flags2 |= (RF2_MOVE_BODY);

		/* Monster ate another monster */
		if (did_kill_body)
			r_ptr->r_flags2 |= (RF2_KILL_BODY);

		/* Monster passed through a wall */
		if (did_pass_wall)
			r_ptr->r_flags2 |= (RF2_PASS_WALL);

		/* Monster destroyed a wall */
		if (did_kill_wall)
			r_ptr->r_flags2 |= (RF2_KILL_WALL);
	}


	/* Hack -- get "bold" if out of options */
	if (!do_turn && !do_move && m_ptr->monfear)
	{
		/* No longer afraid */
		m_ptr->monfear = 0;

		/* Message if seen */
		if (m_ptr->ml)
		{
			char m_name[80];

			/* Acquire the monster name */
			monster_desc(m_name, m_ptr, 0);

			/* Dump a message */
			msg_format("%^s turns to fight!", m_name);
		}

		/* XXX XXX XXX Actually do something now (?) */
	}
}




/*
 * Process all the "live" monsters, once per game turn.
 *
 * During each game turn, we scan through the list of all the "live" monsters,
 * (backwards, so we can excise any "freshly dead" monsters), energizing each
 * monster, and allowing fully energized monsters to move, attack, pass, etc.
 *
 * Note that monsters can never move in the monster array (except when the
 * "compact_monsters()" function is called by "dungeon()" or "save_player()").
 *
 * This function is responsible for at least half of the processor time
 * on a normal system with a "normal" amount of monsters and a player doing
 * normal things.
 *
 * When the player is resting, virtually 90% of the processor time is spent
 * in this function, and its children, "process_monster()" and "make_move()".
 *
 * Most of the rest of the time is spent in "update_view()" and "lite_spot()",
 * especially when the player is running.
 *
 * Note the special "MFLAG_BORN" flag, which prevents monsters from doing
 * anything during the game turn in which they are created.  This flag is
 * optimized via the "repair_mflag_born" flag.
 *
 * Note the special "MFLAG_NICE" flag, which prevents "nasty" monsters from
 * using any of their spell attacks until the player gets a turn.  This flag
 * is optimized via the "repair_mflag_nice" flag.
 */
void
process_monsters(void)
{
	int i, e;
	int fy, fx;

	monster_type *m_ptr;
	monster_race *r_ptr;


	/* Repair "born" flags */
	if (repair_mflag_born)
	{
		/* Clear flag */
		repair_mflag_born = FALSE;

		/* Process the monsters */
		for (i = 1; i < m_max; i++)
		{
			/* Access the monster */
			m_ptr = &m_list[i];

			/* Ignore "dead" monsters */
			/* if (!m_ptr->r_idx) continue; */

			/* Clear "born" flag */
			m_ptr->mflag &= ~(MFLAG_BORN);
		}
	}


	/* Process the monsters (backwards) */
	for (i = m_max - 1; i >= 1; i--)
	{
		/* Handle "leaving" */
		if (p_ptr->leaving)
			break;


		/* Access the monster */
		m_ptr = &m_list[i];


		/* Ignore "dead" monsters */
		if (!m_ptr->r_idx)
			continue;


		/* Ignore "born" monsters XXX XXX */
		if (m_ptr->mflag & (MFLAG_BORN))
			continue;


		/* Access the race */
		r_ptr = &r_info[m_ptr->r_idx];


		/* Obtain the energy boost. SAMESPEED monsters move at a speed
		 * relative to the player. */
		e = extract_energy[(r_ptr->flags2 & RF2_SAMESPD) ?
						   (p_ptr->pspeed + (m_ptr->mspeed - 110)) :
						   m_ptr->mspeed];

		/* Give this monster some energy */
		m_ptr->energy += e;


		/* Not enough energy to move */
		if (m_ptr->energy < 100)
			continue;

		/* Use up "some" energy */
		m_ptr->energy -= 100;


		/* Heal monster? XXX XXX XXX */


		/* Monsters can "sense" the player */
		if (m_ptr->cdis <= r_ptr->aaf)
		{
			/* Process the monster */
			process_monster(i);

			/* Continue */
			continue;
		}


		/* Access the location */
		fx = m_ptr->fx;
		fy = m_ptr->fy;

		/* Monsters can "see" the player (backwards) XXX XXX */
		if (player_has_los_bold(fy, fx))
		{
			/* Process the monster */
			process_monster(i);

			/* Continue */
			continue;
		}

#ifdef MONSTER_FLOW

		/* Hack -- Monsters can "smell" the player from far away */
		if (flow_by_sound)
		{
			int py = p_ptr->py;
			int px = p_ptr->px;

			/* Check the flow (normal aaf is about 20) */
			if ((cave_when[fy][fx] == cave_when[py][px]) &&
				(cave_cost[fy][fx] < MONSTER_FLOW_DEPTH) &&
				(cave_cost[fy][fx] < r_ptr->aaf))
			{
				/* Process the monster */
				process_monster(i);

				/* Continue */
				continue;
			}
		}

#endif

	}
}
