ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/monster.C

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.9 by root, Thu Sep 14 17:10:25 2006 UTC vs.
Revision 1.70 by root, Mon Oct 12 21:27:55 2009 UTC

1
2	/*	1	/*
3	* static char *rcsid_monster_c =	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
4	* "$Id: monster.C,v 1.9 2006/09/14 17:10:25 root Exp $";	3	*
		4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
		5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
		6	* Copyright (©) 1992,2007 Frank Tore Johansen
		7	*
		8	* Deliantra is free software: you can redistribute it and/or modify it under
		9	* the terms of the Affero GNU General Public License as published by the
		10	* Free Software Foundation, either version 3 of the License, or (at your
		11	* option) any later version.
		12	*
		13	* This program is distributed in the hope that it will be useful,
		14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		16	* GNU General Public License for more details.
		17	*
		18	* You should have received a copy of the Affero GNU General Public License
		19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
		21	*
		22	* The authors can be reached via e-mail to <support@deliantra.net>
5	*/	23	*/
6		24
7	/*
8	CrossFire, A Multiplayer game for X-windows
9
10	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen
12
13	This program is free software; you can redistribute it and/or modify
14	it under the terms of the GNU General Public License as published by
15	the Free Software Foundation; either version 2 of the License, or
16	(at your option) any later version.
17
18	This program is distributed in the hope that it will be useful,
19	but WITHOUT ANY WARRANTY; without even the implied warranty of
20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	GNU General Public License for more details.
22
23	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27	The authors can be reached via e-mail at crossfire-devel@real-time.com
28	*/
29
30	#include <global.h>	25	#include <global.h>
31	#ifndef __CEXTRACT__
32	# include <sproto.h>	26	#include <sproto.h>
33	# include <spells.h>	27	#include <spells.h>
34	# include <skills.h>	28	#include <skills.h>
35	#endif
36
37		29
38	#define MIN_MON_RADIUS 3 /* minimum monster detection radius */	30	#define MIN_MON_RADIUS 3 /* minimum monster detection radius */
39
40		31
41	/* checks npc->enemy and returns that enemy if still valid,	32	/* checks npc->enemy and returns that enemy if still valid,
42	* NULL otherwise.	33	* NULL otherwise.
43	* this is map tile aware.	34	* this is map tile aware.
44	* If this returns an enemy, the range vector rv should also be	35	* If this returns an enemy, the range vector rv should also be
45	* set to sane values.	36	* set to sane values.
46	*/	37	*/
47	object *	38	object *
48	check_enemy (object *npc, rv_vector * rv)	39	check_enemy (object *npc, rv_vector * rv)
49	{	40	{
50
51	/* if this is pet, let him attack the same enemy as his owner	41	/* if this is pet, let him attack the same enemy as his owner
52	* TODO: when there is no ower enemy, try to find a target,	42	* TODO: when there is no ower enemy, try to find a target,
53	* which CAN attack the owner. */	43	* which CAN attack the owner. */
54	if ((npc->attack_movement & HI4) == PETMOVE)	44	if ((npc->attack_movement & HI4) == PETMOVE)
55	{	45	{
…		…
57	npc->enemy = NULL;	47	npc->enemy = NULL;
58	else if (npc->enemy == NULL)	48	else if (npc->enemy == NULL)
59	npc->enemy = npc->owner->enemy;	49	npc->enemy = npc->owner->enemy;
60	}	50	}
61		51
62	/* periodically, a monster mayu change its target. Also, if the object	52	/* periodically, a monster may change its target. Also, if the object
63	* has been destroyed, etc, clear the enemy.	53	* has been destroyed, etc, clear the enemy.
64	* TODO: this should be changed, because it invokes to attack forced or	54	* TODO: this should be changed, because it invokes to attack forced or
65	* attacked monsters to leave the attacker alone, before it is destroyed	55	* attacked monsters to leave the attacker alone, before it is destroyed
66	*/	56	*/
67	/* i had removed the random target leave, this invokes problems with friendly	57	/* I had removed the random target leave, this invokes problems with friendly
68	* objects, getting attacked and defending herself - they don't try to attack	58	* objects, getting attacked and defending herself - they don't try to attack
69	* again then but perhaps get attack on and on	59	* again then but perhaps get attack on and on
70	* If we include a aggravated flag in , we can handle evil vs evil and good vs good	60	* If we include a aggravated flag in , we can handle evil vs evil and good vs good
71	* too. */	61	* too. */
72		62
…		…
76	* the grouping checks are. Code is the same.	66	* the grouping checks are. Code is the same.
77	*/	67	*/
78	if (QUERY_FLAG (npc->enemy, FLAG_REMOVED) ||	68	if (QUERY_FLAG (npc->enemy, FLAG_REMOVED) ||
79	QUERY_FLAG (npc->enemy, FLAG_FREED) ||	69	QUERY_FLAG (npc->enemy, FLAG_FREED) ||
80	!on_same_map (npc, npc->enemy) || npc == npc->enemy || QUERY_FLAG (npc, FLAG_NEUTRAL) || QUERY_FLAG (npc->enemy, FLAG_NEUTRAL))	70	!on_same_map (npc, npc->enemy) || npc == npc->enemy || QUERY_FLAG (npc, FLAG_NEUTRAL) || QUERY_FLAG (npc->enemy, FLAG_NEUTRAL))
81	npc->enemy = NULL;	71	npc->enemy = 0;
82		72
83	else if (QUERY_FLAG (npc, FLAG_FRIENDLY) && ((QUERY_FLAG (npc->enemy, FLAG_FRIENDLY)	73	else if (QUERY_FLAG (npc, FLAG_FRIENDLY) && ((QUERY_FLAG (npc->enemy, FLAG_FRIENDLY)
84	&& !(should_arena_attack (npc, npc->owner, npc->enemy)))	74	&& !(should_arena_attack (npc, npc->owner, npc->enemy)))
85	|| ((npc->enemy->type == PLAYER) && !(should_arena_attack (npc, npc->owner, npc->enemy)))	75	|| ((npc->enemy->type == PLAYER) && !(should_arena_attack (npc, npc->owner, npc->enemy)))
86	|| npc->enemy == npc->owner))	76	|| npc->enemy == npc->owner))
87	npc->enemy = NULL;	77	npc->enemy = 0;
88		78
89		79
90	else if (!QUERY_FLAG (npc, FLAG_FRIENDLY) && (!QUERY_FLAG (npc->enemy, FLAG_FRIENDLY) && npc->enemy->type != PLAYER))	80	else if (!QUERY_FLAG (npc, FLAG_FRIENDLY) && (!QUERY_FLAG (npc->enemy, FLAG_FRIENDLY) && npc->enemy->type != PLAYER))
91	npc->enemy = NULL;	81	npc->enemy = 0;
92		82
93	/* I've noticed that pets could sometimes get an arrow as the	83	/* I've noticed that pets could sometimes get an arrow as the
94	* target enemy - this code below makes sure the enemy is something	84	* target enemy - this code below makes sure the enemy is something
95	* that should be attacked. My guess is that the arrow hits	85	* that should be attacked. My guess is that the arrow hits
96	* the creature/owner, and so the creature then takes that	86	* the creature/owner, and so the creature then takes that
97	* as the enemy to attack.	87	* as the enemy to attack.
98	*/	88	*/
99	else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER) &&	89	else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER)
100	!QUERY_FLAG (npc->enemy, FLAG_GENERATOR) && npc->enemy->type != PLAYER && npc->enemy->type != GOLEM)	90	&& !QUERY_FLAG (npc->enemy, FLAG_GENERATOR)
		91	&& npc->enemy->type != PLAYER
		92	&& npc->enemy->type != GOLEM)
101	npc->enemy = NULL;	93	npc->enemy = 0;
102
103	}	94	}
		95
104	return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : NULL;	96	return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : 0;
105	}	97	}
106		98
107	/* Returns the nearest living creature (monster or generator).	99	/* Returns the nearest living creature (monster or generator).
108	* Modified to deal with tiled maps properly.	100	* Modified to deal with tiled maps properly.
109	* Also fixed logic so that monsters in the lower directions were more	101	* Also fixed logic so that monsters in the lower directions were more
…		…
121	object *	113	object *
122	find_nearest_living_creature (object *npc)	114	find_nearest_living_creature (object *npc)
123	{	115	{
124	int i, mflags;	116	int i, mflags;
125	sint16 nx, ny;	117	sint16 nx, ny;
126	mapstruct *m;	118	maptile *m;
127	object *tmp;
128	int search_arr[SIZEOFFREE];	119	int search_arr[SIZEOFFREE];
129		120
130	get_search_arr (search_arr);	121	get_search_arr (search_arr);
		122
131	for (i = 0; i < SIZEOFFREE; i++)	123	for (i = 0; i < SIZEOFFREE; i++)
132	{	124	{
133	/* modified to implement smart searching using search_arr	125	/* modified to implement smart searching using search_arr
134	* guidance array to determine direction of search order	126	* guidance array to determine direction of search order
135	*/	127	*/
136	nx = npc->x + freearr_x[search_arr[i]];	128	nx = npc->x + freearr_x[search_arr[i]];
137	ny = npc->y + freearr_y[search_arr[i]];	129	ny = npc->y + freearr_y[search_arr[i]];
138	m = npc->map;	130	m = npc->map;
139		131
140	mflags = get_map_flags (m, &m, nx, ny, &nx, &ny);	132	mflags = get_map_flags (m, &m, nx, ny, &nx, &ny);
		133
141	if (mflags & P_OUT_OF_MAP)	134	if (mflags & P_OUT_OF_MAP)
142	continue;	135	continue;
143		136
144	if (mflags & P_IS_ALIVE)	137	if (mflags & P_IS_ALIVE)
145	{	138	{
146	tmp = get_map_ob (m, nx, ny);	139	for (object *tmp = m->at (nx, ny).top; tmp; tmp = tmp->below)
147	while (tmp != NULL && !QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_GENERATOR) && tmp->type != PLAYER)	140	if (tmp->flag [FLAG_MONSTER] || tmp->flag [FLAG_GENERATOR] || tmp->type == PLAYER)
148	tmp = tmp->above;
149
150	if (!tmp)
151	{
152	LOG (llevDebug, "find_nearest_living_creature: map %s (%d,%d) has is_alive set but did not find a monster?\n",
153	m->path, nx, ny);
154	}
155	else
156	{
157	if (can_see_monsterP (m, nx, ny, i))	141	if (can_see_monsterP (m, nx, ny, i))
158	return tmp;	142	return tmp;
159	}	143	}
160	} /* is something living on this space */
161	}	144	}
162	return NULL; /* nothing found */
163	}
164		145
		146	return 0;
		147	}
165		148
166	/* Tries to find an enmy for npc. We pass the range vector since	149	/* Tries to find an enemy for npc. We pass the range vector since
167	* our caller will find the information useful.	150	* our caller will find the information useful.
168	* Currently, only move_monster calls this function.	151	* Currently, only move_monster calls this function.
169	* Fix function so that we always make calls to get_rangevector	152	* Fix function so that we always make calls to get_rangevector
170	* if we have a valid target - function as not doing so in	153	* if we have a valid target - function as not doing so in
171	* many cases.	154	* many cases.
172	*/	155	*/
173
174	object *	156	object *
175	find_enemy (object *npc, rv_vector * rv)	157	find_enemy (object *npc, rv_vector * rv)
176	{	158	{
177	object *attacker, *tmp = NULL;	159	object *attacker, *tmp = NULL;
178		160
…		…
184	{	166	{
185	tmp = find_nearest_living_creature (npc);	167	tmp = find_nearest_living_creature (npc);
186		168
187	if (tmp)	169	if (tmp)
188	get_rangevector (npc, tmp, rv, 0);	170	get_rangevector (npc, tmp, rv, 0);
		171
189	return tmp;	172	return tmp;
190	}	173	}
191		174
192	/* Here is the main enemy selection.	175	/* Here is the main enemy selection.
193	* We want this: if there is an enemy, attack him until its not possible or	176	* We want this: if there is an enemy, attack him until its not possible or
…		…
213	/* we check our old enemy. */	196	/* we check our old enemy. */
214	if (!(tmp = check_enemy (npc, rv)))	197	if (!(tmp = check_enemy (npc, rv)))
215	{	198	{
216	if (attacker) /* if we have an attacker, check him */	199	if (attacker) /* if we have an attacker, check him */
217	{	200	{
218	/* TODO: thats not finished */	201	/* TODO: that's not finished */
219	/* we don't want a fight evil vs evil or good against non evil */	202	/* we don't want a fight evil vs evil or good against non evil */
220		203
221	if (QUERY_FLAG (npc, FLAG_NEUTRAL) || QUERY_FLAG (attacker, FLAG_NEUTRAL) || /* neutral */	204	if (QUERY_FLAG (npc, FLAG_NEUTRAL) || QUERY_FLAG (attacker, FLAG_NEUTRAL) || /* neutral */
222	(QUERY_FLAG (npc, FLAG_FRIENDLY) && QUERY_FLAG (attacker, FLAG_FRIENDLY)) ||	205	(QUERY_FLAG (npc, FLAG_FRIENDLY) && QUERY_FLAG (attacker, FLAG_FRIENDLY)) ||
223	(!QUERY_FLAG (npc, FLAG_FRIENDLY) && (!QUERY_FLAG (attacker, FLAG_FRIENDLY) && attacker->type != PLAYER)))	206	(!QUERY_FLAG (npc, FLAG_FRIENDLY) && (!QUERY_FLAG (attacker, FLAG_FRIENDLY) && attacker->type != PLAYER)))
224	CLEAR_FLAG (npc, FLAG_SLEEP); /* skip it, but lets wakeup */	207	CLEAR_FLAG (npc, FLAG_SLEEP); /* skip it, but lets wakeup */
225	else if (on_same_map (npc, attacker)) /* thats the only thing we must know... */	208	else if (on_same_map (npc, attacker)) /* that's the only thing we must know... */
226	{	209	{
227	CLEAR_FLAG (npc, FLAG_SLEEP); /* well, NOW we really should wake up! */	210	CLEAR_FLAG (npc, FLAG_SLEEP); /* well, NOW we really should wake up! */
228	npc->enemy = attacker;	211	npc->enemy = attacker;
229	return attacker; /* yes, we face our attacker! */	212	return attacker; /* yes, we face our attacker! */
230	}	213	}
…		…
246	/* Sees if this monster should wake up.	229	/* Sees if this monster should wake up.
247	* Currently, this is only called from move_monster, and	230	* Currently, this is only called from move_monster, and
248	* if enemy is set, then so should be rv.	231	* if enemy is set, then so should be rv.
249	* returns 1 if the monster should wake up, 0 otherwise.	232	* returns 1 if the monster should wake up, 0 otherwise.
250	*/	233	*/
251
252	int	234	int
253	check_wakeup (object *op, object *enemy, rv_vector * rv)	235	check_wakeup (object *op, object *enemy, rv_vector *rv)
254	{	236	{
255	int radius = op->stats.Wis > MIN_MON_RADIUS ? op->stats.Wis : MIN_MON_RADIUS;
256
257	/* Trim work - if no enemy, no need to do anything below */	237	/* Trim work - if no enemy, no need to do anything below */
258	if (!enemy)	238	if (!enemy)
259	return 0;	239	return 0;
260		240
		241	if (!op->flag [FLAG_SLEEP])
		242	return 1;
		243
		244	int radius = max (op->stats.Wis, MIN_MON_RADIUS);
		245
		246	if (op->flag [FLAG_BLIND])
261	/* blinded monsters can only find nearby objects to attack */	247	/* blinded monsters can only find nearby objects to attack */
262	if (QUERY_FLAG (op, FLAG_BLIND))
263	radius = MIN_MON_RADIUS;	248	radius = MIN_MON_RADIUS;
264		249	else if (op->map
		250	&& !enemy->invisible
		251	&& !stand_in_light (enemy)
		252	&& (!op->flag[FLAG_SEE_IN_DARK] || !op->flag [FLAG_SEE_INVISIBLE]))
265	/* This covers the situation where the monster is in the dark	253	/* This covers the situation where the monster is in the dark
266	* and has an enemy. If the enemy has no carried light (or isnt	254	* and has an enemy. If the enemy has no carried light (or isnt
267	* glowing!) then the monster has trouble finding the enemy.	255	* glowing!) then the monster has trouble finding the enemy.
268	* Remember we already checked to see if the monster can see in	256	* Remember we already checked to see if the monster can see in
269	* the dark. */	257	* the dark. */
		258	radius = min (radius, MIN_MON_RADIUS + MAX_DARKNESS - op->map->darklevel ());
270		259
271	else if (op->map && op->map->darkness > 0 && enemy && !enemy->invisible &&	260	if (enemy->flag [FLAG_STEALTH])
272	!stand_in_light (enemy) && (!QUERY_FLAG (op, FLAG_SEE_IN_DARK) || !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))	261	radius = radius / 2 + 1;
273	{
274	int dark = radius / (op->map->darkness);
275
276	radius = (dark > MIN_MON_RADIUS) ? (dark + 1) : MIN_MON_RADIUS;
277	}
278	else if (!QUERY_FLAG (op, FLAG_SLEEP))
279	return 1;
280		262
281	/* enemy should already be on this map, so don't really need to check	263	/* enemy should already be on this map, so don't really need to check
282	* for that.	264	* for that.
283	*/	265	*/
284	if (rv->distance < (unsigned int) (QUERY_FLAG (enemy, FLAG_STEALTH) ? (radius / 2) + 1 : radius))	266	if (rv->distance <= radius)
285	{	267	{
286	CLEAR_FLAG (op, FLAG_SLEEP);	268	CLEAR_FLAG (op, FLAG_SLEEP);
287	return 1;	269	return 1;
288	}	270	}
		271
289	return 0;	272	return 0;
290	}	273	}
291		274
292	int	275	int
293	move_randomly (object *op)	276	move_randomly (object *op)
294	{	277	{
295	int i;
296
297	/* Give up to 15 chances for a monster to move randomly */	278	/* Give up to 15 chances for a monster to move randomly */
298	for (i = 0; i < 15; i++)	279	for (int i = 0; i < 15; i++)
299	{
300	if (move_object (op, RANDOM () % 8 + 1))	280	if (move_object (op, rndm (8) + 1))
301	return 1;	281	return 1;
302	}	282
303	return 0;	283	return 0;
304	}	284	}
305		285
306	/*	286	/*
307	* Move-monster returns 1 if the object has been freed, otherwise 0.	287	* Move-monster returns 1 if the object has been freed, otherwise 0.
308	*/	288	*/
309
310	int	289	int
311	move_monster (object *op)	290	move_monster (object *op)
312	{	291	{
313	int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */	292	int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */
314	object *owner, *enemy, *part, *oph = op;	293	object *owner, *enemy, *part, *oph = op;
…		…
331	enemy->attacked_by = op; /* our ptr */	310	enemy->attacked_by = op; /* our ptr */
332		311
333	/* generate hp, if applicable */	312	/* generate hp, if applicable */
334	if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)	313	if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)
335	{	314	{
336
337	/* last heal is in funny units. Dividing by speed puts	315	/* last heal is in funny units. Dividing by speed puts
338	* the regeneration rate on a basis of time instead of	316	* the regeneration rate on a basis of time instead of
339	* #moves the monster makes. The scaling by 8 is	317	* #moves the monster makes. The scaling by 8 is
340	* to capture 8th's of a hp fraction regens	318	* to capture 8th's of a hp fraction regens
341	*	319	*
…		…
346	op->last_heal += (int) ((float) (8 * op->stats.Con) / FABS (op->speed));	324	op->last_heal += (int) ((float) (8 * op->stats.Con) / FABS (op->speed));
347	op->stats.hp = MIN ((sint32) op->stats.hp + op->last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */	325	op->stats.hp = MIN ((sint32) op->stats.hp + op->last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */
348	op->last_heal %= 32;	326	op->last_heal %= 32;
349		327
350	/* So if the monster has gained enough HP that they are no longer afraid */	328	/* So if the monster has gained enough HP that they are no longer afraid */
351	if (QUERY_FLAG (op, FLAG_RUN_AWAY) && op->stats.hp >= (signed short) (((float) op->run_away / (float) 100) * (float) op->stats.maxhp))	329	if (QUERY_FLAG (op, FLAG_RUN_AWAY) && op->stats.hp >= (signed short)(((float)op->run_away / 100.f) * (float)op->stats.maxhp))
352	CLEAR_FLAG (op, FLAG_RUN_AWAY);	330	CLEAR_FLAG (op, FLAG_RUN_AWAY);
353		331
354	if (op->stats.hp > op->stats.maxhp)	332	if (op->stats.hp > op->stats.maxhp)
355	op->stats.hp = op->stats.maxhp;	333	op->stats.hp = op->stats.maxhp;
356	}	334	}
357		335
358	/* generate sp, if applicable */	336	/* generate sp, if applicable */
359	if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)	337	if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)
360	{	338	{
361
362	/* last_sp is in funny units. Dividing by speed puts	339	/* last_sp is in funny units. Dividing by speed puts
363	* the regeneration rate on a basis of time instead of	340	* the regeneration rate on a basis of time instead of
364	* #moves the monster makes. The scaling by 8 is	341	* #moves the monster makes. The scaling by 8 is
365	* to capture 8th's of a sp fraction regens	342	* to capture 8th's of a sp fraction regens
366	*	343	*
367	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)	344	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)
368	* overflow might produce monsters with negative sp.	345	* overflow might produce monsters with negative sp.
369	*/	346	*/
370		347
371	op->last_sp += (int) ((float) (8 * op->stats.Pow) / FABS (op->speed));	348	op->last_sp += (int) ((float) (8 * op->stats.Pow) / fabsf (op->speed));
372	op->stats.sp = MIN (op->stats.sp + op->last_sp / 128, op->stats.maxsp); /* causes Pow/16 sp/tick */	349	op->stats.sp = min (op->stats.sp + op->last_sp / 128, op->stats.maxsp); /* causes Pow/16 sp/tick */
373	op->last_sp %= 128;	350	op->last_sp %= 128;
374	}	351	}
375		352
376	/* this should probably get modified by many more values.	353	/* this should probably get modified by many more values.
377	* (eg, creatures resistance to fear, level, etc. )	354	* (eg, creatures resistance to fear, level, etc. )
378	*/	355	*/
379	if (QUERY_FLAG (op, FLAG_SCARED) && !(RANDOM () % 20))	356	if (QUERY_FLAG (op, FLAG_SCARED) && !(rndm (20)))
380	{
381	CLEAR_FLAG (op, FLAG_SCARED); /* Time to regain some "guts"... */	357	CLEAR_FLAG (op, FLAG_SCARED); /* Time to regain some "guts"... */
382	}
383		358
384	if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))	359	if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))
385	return QUERY_FLAG (op, FLAG_FREED);	360	return QUERY_FLAG (op, FLAG_FREED);
386		361
387	if (QUERY_FLAG (op, FLAG_SLEEP) || QUERY_FLAG (op, FLAG_BLIND) ||	362	if (QUERY_FLAG (op, FLAG_SLEEP) || QUERY_FLAG (op, FLAG_BLIND) ||
388	((op->map->darkness > 0) && !QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))	363	((op->map->darklevel () > 0) && !QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))
389	{
390	if (!check_wakeup (op, enemy, &rv))	364	if (!check_wakeup (op, enemy, &rv))
391	return 0;	365	return 0;
392	}
393		366
394	/* check if monster pops out of hidden spot */	367	/* check if monster pops out of hidden spot */
395	if (op->hide)	368	if (op->flag [FLAG_HIDDEN])
396	do_hidden_move (op);	369	do_hidden_move (op);
397		370
398	if (op->pick_up)	371	if (op->pick_up)
399	monster_check_pickup (op);	372	monster_check_pickup (op);
400		373
…		…
404	/* If we don't have an enemy, do special movement or the like */	377	/* If we don't have an enemy, do special movement or the like */
405	if (!enemy)	378	if (!enemy)
406	{	379	{
407	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))	380	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
408	{	381	{
409	remove_ob (op);	382	op->drop_and_destroy ();
410	free_object (op);
411	return 1;	383	return 1;
412	}	384	}
413		385
414	/* Probably really a bug for a creature to have both	386	/* Probably really a bug for a creature to have both
415	* stand still and a movement type set.	387	* stand still and a movement type set.
…		…
418	{	390	{
419	if (op->attack_movement & HI4)	391	if (op->attack_movement & HI4)
420	{	392	{
421	switch (op->attack_movement & HI4)	393	switch (op->attack_movement & HI4)
422	{	394	{
423	case (PETMOVE):	395	case PETMOVE:
424	pet_move (op);	396	pet_move (op);
425	break;	397	break;
426		398
427	case (CIRCLE1):	399	case CIRCLE1:
428	circ1_move (op);	400	circ1_move (op);
429	break;	401	break;
430		402
431	case (CIRCLE2):	403	case CIRCLE2:
432	circ2_move (op);	404	circ2_move (op);
433	break;	405	break;
434		406
435	case (PACEV):	407	case PACEV:
436	pace_movev (op);	408	pace_movev (op);
437	break;	409	break;
438		410
439	case (PACEH):	411	case PACEH:
440	pace_moveh (op);	412	pace_moveh (op);
441	break;	413	break;
442		414
443	case (PACEV2):	415	case PACEV2:
444	pace2_movev (op);	416	pace2_movev (op);
445	break;	417	break;
446		418
447	case (PACEH2):	419	case PACEH2:
448	pace2_moveh (op);	420	pace2_moveh (op);
449	break;	421	break;
450		422
451	case (RANDO):	423	case RANDO:
452	rand_move (op);	424	rand_move (op);
453	break;	425	break;
454		426
455	case (RANDO2):	427	case RANDO2:
456	move_randomly (op);	428	move_randomly (op);
457	break;	429	break;
458	}	430	}
		431
459	return 0;	432	return 0;
460	}	433	}
461	else if (QUERY_FLAG (op, FLAG_RANDOM_MOVE))	434	else if (QUERY_FLAG (op, FLAG_RANDOM_MOVE))
462	(void) move_randomly (op);	435	move_randomly (op);
463
464	} /* stand still */	436	} /* stand still */
		437
465	return 0;	438	return 0;
466	} /* no enemy */	439	} /* no enemy */
467		440
468	/* We have an enemy. Block immediately below is for pets */	441	/* We have an enemy. Block immediately below is for pets */
469	if ((op->attack_movement & HI4) == PETMOVE && (owner = get_owner (op)) != NULL && !on_same_map (op, owner))	442	if ((op->attack_movement & HI4) == PETMOVE
		443	&& (owner = op->owner) != NULL
		444	&& !on_same_map (op, owner)
		445	&& !owner->flag [FLAG_REMOVED])
470	return follow_owner (op, owner);	446	return follow_owner (op, owner);
471		447
472	/* doppleganger code to change monster facing to that of the nearest	448	/* doppleganger code to change monster facing to that of the nearest
473	* player. Hmm. The code is here, but no monster in the current	449	* player. Hmm. The code is here, but no monster in the current
474	* arch set uses it.	450	* arch set uses it.
475	*/	451	*/
476	if ((op->race != NULL) && strcmp (op->race, "doppleganger") == 0)	452	if (op->race == shstr_doppleganger)
477	{	453	{
478	op->face = enemy->face;	454	op->face = enemy->face;
479	op->name = enemy->name;	455	op->name = enemy->name;
480	}	456	}
481		457
…		…
493	if (!QUERY_FLAG (op, FLAG_SCARED))	469	if (!QUERY_FLAG (op, FLAG_SCARED))
494	{	470	{
495	rv_vector rv1;	471	rv_vector rv1;
496		472
497	/* now we test every part of an object .... this is a real ugly piece of code */	473	/* now we test every part of an object .... this is a real ugly piece of code */
498	for (part = op; part != NULL; part = part->more)	474	for (part = op; part; part = part->more)
499	{	475	{
500	get_rangevector (part, enemy, &rv1, 0x1);	476	get_rangevector (part, enemy, &rv1, 0x1);
501	dir = rv1.direction;	477	dir = rv1.direction;
502		478
503	/* hm, not sure about this part - in original was a scared flag here too	479	/* hm, not sure about this part - in original was a scared flag here too
504	* but that we test above... so can be old code here	480	* but that we test above... so can be old code here
505	*/	481	*/
506	if (QUERY_FLAG (op, FLAG_RUN_AWAY))	482	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
507	dir = absdir (dir + 4);	483	dir = absdir (dir + 4);
		484
508	if (QUERY_FLAG (op, FLAG_CONFUSED))	485	if (QUERY_FLAG (op, FLAG_CONFUSED))
509	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	486	dir = absdir (dir + rndm (3) + rndm (3) - 2);
510		487
511	if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(RANDOM () % 3))	488	if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(rndm (3)))
512	{
513	if (monster_cast_spell (op, part, enemy, dir, &rv1))	489	if (monster_cast_spell (op, part, enemy, dir, &rv1))
514	return 0;	490	return 0;
515	}
516		491
517	if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(RANDOM () % 3))	492	if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(rndm (3)))
518	{
519	if (monster_use_scroll (op, part, enemy, dir, &rv1))	493	if (monster_use_scroll (op, part, enemy, dir, &rv1))
520	return 0;	494	return 0;
521	}
522		495
523	if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(RANDOM () % 3))	496	if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(rndm (3)))
524	{
525	if (monster_use_range (op, part, enemy, dir))	497	if (monster_use_range (op, part, enemy, dir))
526	return 0;	498	return 0;
527	}	499
528	if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(RANDOM () % 3))	500	if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(rndm (3)))
529	{
530	if (monster_use_skill (op, rv.part, enemy, rv.direction))	501	if (monster_use_skill (op, rv.part, enemy, rv.direction))
531	return 0;	502	return 0;
532	}	503
533	if (QUERY_FLAG (op, FLAG_READY_BOW) && !(RANDOM () % 2))	504	if (QUERY_FLAG (op, FLAG_READY_BOW) && !(rndm (2)))
534	{
535	if (monster_use_bow (op, part, enemy, dir))	505	if (monster_use_bow (op, part, enemy, dir))
536	return 0;	506	return 0;
537	}
538	} /* for processing of all parts */	507	} /* for processing of all parts */
539	} /* If not scared */	508	} /* If not scared */
540		509
541
542	part = rv.part;	510	part = rv.part;
543	dir = rv.direction;	511	dir = rv.direction;
544		512
		513	// if the enemy is a player, we have los. if los says we
		514	// can directly reach the player, we do not deviate.
		515	// for non-players, we never deviate
		516	if (op->stats.Wis >= 8
		517	&& enemy->contr && enemy->contr->darkness_at (op->map, op->x, op->y) == LOS_BLOCKED)
		518	{
		519	int sdir = 0;
		520	uint32_t &smell = op->ms ().smell;
		521
		522	for (int ndir = 1; ndir <= 8; ++ndir)
		523	{
		524	mapxy pos (op); pos.move (ndir);
		525
		526	if (pos.normalise ())
		527	{
		528	mapspace &ms = pos.ms ();
		529
		530	if (ms.smell > smell)
		531	{
		532	//printf ("%s: found smell, following it, apparently (%d, %d)\n",& op->name,op->ms().smell,ms.smell);//D
		533	if (op->stats.Wis >= 10)
		534	smell = ms.smell - 1; // smarter: tell others
		535
		536	sdir = ndir;
		537
		538	// perturbing the path might let the monster lose track,
		539	// but it will also widen the actual path, spreading information
		540	if (op->stats.Wis >= 15 && !rndm (20)) // even smarter, deviate and spread?
		541	sdir = absdir (sdir + 1 - rndm (2) * 2);
		542	}
		543	}
		544	}
		545
		546	if (sdir)
		547	dir = sdir;
		548	else if (smell)
		549	{
		550	// no better smell found, so assume the player jumped, and erase this smell
		551	//printf ("erasing smell %d\n", op->ms ().smell);//D
		552	unordered_mapwalk (op, -1, -1, 1, 1)
		553	m->at (nx, ny).smell = 0;
		554	}
		555	}
		556
545	if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY))	557	if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY))
546	dir = absdir (dir + 4);	558	dir = absdir (dir + 4);
547		559
548	if (QUERY_FLAG (op, FLAG_CONFUSED))	560	if (QUERY_FLAG (op, FLAG_CONFUSED))
549	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	561	dir = absdir (dir + rndm (3) + rndm (3) - 2);
550		562
551	pre_att_dir = dir; /* remember the original direction */	563	pre_att_dir = dir; /* remember the original direction */
552		564
553	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))	565	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))
554	{	566	{
555	switch (op->attack_movement & LO4)	567	switch (op->attack_movement & LO4)
556	{	568	{
557	case DISTATT:	569	case DISTATT:
558	dir = dist_att (dir, op, enemy, part, &rv);	570	dir = dist_att (dir, op, enemy, part, &rv);
559	break;	571	break;
560		572
561	case RUNATT:	573	case RUNATT:
562	dir = run_att (dir, op, enemy, part, &rv);	574	dir = run_att (dir, op, enemy, part, &rv);
563	break;	575	break;
564		576
565	case HITRUN:	577	case HITRUN:
566	dir = hitrun_att (dir, op, enemy);	578	dir = hitrun_att (dir, op, enemy);
567	break;	579	break;
568		580
569	case WAITATT:	581	case WAITATT:
570	dir = wait_att (dir, op, enemy, part, &rv);	582	dir = wait_att (dir, op, enemy, part, &rv);
571	break;	583	break;
572		584
573	case RUSH: /* default - monster normally moves towards player */	585	case RUSH: /* default - monster normally moves towards player */
574	case ALLRUN:	586	case ALLRUN:
575	break;	587	break;
576		588
577	case DISTHIT:	589	case DISTHIT:
578	dir = disthit_att (dir, op, enemy, part, &rv);	590	dir = disthit_att (dir, op, enemy, part, &rv);
579	break;	591	break;
580		592
581	case WAIT2:	593	case WAIT2:
582	dir = wait_att2 (dir, op, enemy, part, &rv);	594	dir = wait_att2 (dir, op, enemy, part, &rv);
583	break;	595	break;
584		596
585	default:	597	default:
586	LOG (llevDebug, "Illegal low mon-move: %d\n", op->attack_movement & LO4);	598	LOG (llevDebug, "Illegal low mon-move: %d\n", op->attack_movement & LO4);
587	}	599	}
588	}	600	}
589		601
590	if (!dir)	602	if (!dir)
591	return 0;	603	return 0;
…		…
601	return 0;	613	return 0;
602	}	614	}
603		615
604	if (QUERY_FLAG (op, FLAG_SCARED) || !can_hit (part, enemy, &rv) || QUERY_FLAG (op, FLAG_RUN_AWAY))	616	if (QUERY_FLAG (op, FLAG_SCARED) || !can_hit (part, enemy, &rv) || QUERY_FLAG (op, FLAG_RUN_AWAY))
605	{	617	{
606
607	/* Try move around corners if !close */	618	/* Try move around corners if !close */
608	int maxdiff = (QUERY_FLAG (op, FLAG_ONLY_ATTACK) || RANDOM () & 1) ? 1 : 2;	619	int maxdiff = (QUERY_FLAG (op, FLAG_ONLY_ATTACK) || rndm (2)) ? 1 : 2;
609		620
610	for (diff = 1; diff <= maxdiff; diff++)	621	for (diff = 1; diff <= maxdiff; diff++)
611	{	622	{
612	/* try different detours */	623	/* try different detours */
613	int m = 1 - (RANDOM () & 2); /* Try left or right first? */	624	int m = 1 - rndm (2) * 2; /* Try left or right first? */
614		625
615	if (move_object (op, absdir (dir + diff * m)) || move_object (op, absdir (dir - diff * m)))	626	if (move_object (op, absdir (dir + diff * m)) || move_object (op, absdir (dir - diff * m)))
616	return 0;	627	return 0;
617	}	628	}
618	}	629	}
…		…
645	{	656	{
646	object *nearest_player = get_nearest_player (op);	657	object *nearest_player = get_nearest_player (op);
647		658
648	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))	659	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))
649	{	660	{
650	op->enemy = NULL;	661	op->enemy = 0;
651	enemy = nearest_player;	662	enemy = nearest_player;
652	}	663	}
653	}	664	}
654		665
655	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))	666	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))
…		…
661	* still be pretty nasty.	672	* still be pretty nasty.
662	*/	673	*/
663	if (QUERY_FLAG (op, FLAG_RUN_AWAY))	674	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
664	{	675	{
665	part->stats.wc += 10;	676	part->stats.wc += 10;
666	(void) skill_attack (enemy, part, 0, NULL, NULL);	677	skill_attack (enemy, part, 0, NULL, NULL);
667	part->stats.wc -= 10;	678	part->stats.wc -= 10;
668	}	679	}
669	else	680	else
670	(void) skill_attack (enemy, part, 0, NULL, NULL);	681	skill_attack (enemy, part, 0, NULL, NULL);
671	} /* if monster is in attack range */	682	} /* if monster is in attack range */
672		683
673	if (QUERY_FLAG (part, FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */	684	if (QUERY_FLAG (part, FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */
674	return 1;	685	return 1;
675		686
676	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))	687	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
677	{	688	{
678	remove_ob (op);	689	op->drop_and_destroy ();
679	free_object (op);
680	return 1;	690	return 1;
681	}	691	}
		692
682	return 0;	693	return 0;
683	}	694	}
684		695
685	int	696	int
686	can_hit (object *ob1, object *ob2, rv_vector * rv)	697	can_hit (object *ob1, object *ob2, rv_vector * rv)
687	{	698	{
688	object *more;	699	object *more;
689	rv_vector rv1;	700	rv_vector rv1;
690		701
691	if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(RANDOM () % 3))	702	if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(rndm (3)))
692	return 0;	703	return 0;
693		704
694	if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)	705	if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)
695	return 1;	706	return 1;
696		707
697	/* check all the parts of ob2 - just because we can't get to	708	/* check all the parts of ob2 - just because we can't get to
698	* its head doesn't mean we don't want to pound its feet	709	* its head doesn't mean we don't want to pound its feet
699	*/	710	*/
700	for (more = ob2->more; more != NULL; more = more->more)	711	for (more = ob2->more; more; more = more->more)
701	{	712	{
702	get_rangevector (ob1, more, &rv1, 0);	713	get_rangevector (ob1, more, &rv1, 0);
703	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)	714	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
704	return 1;	715	return 1;
705	}	716	}
		717
706	return 0;	718	return 0;
707
708	}	719	}
709		720
710	/* Returns 1 is monster should cast spell sp at an enemy	721	/* Returns 1 is monster should cast spell sp at an enemy
711	* Returns 0 if the monster should not cast this spell.	722	* Returns 0 if the monster should not cast this spell.
712	*	723	*
…		…
730	spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||	741	spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||
731	spell_ob->subtype == SP_BOMB || spell_ob->subtype == SP_SMITE ||	742	spell_ob->subtype == SP_BOMB || spell_ob->subtype == SP_SMITE ||
732	spell_ob->subtype == SP_MAGIC_MISSILE || spell_ob->subtype == SP_SUMMON_GOLEM ||	743	spell_ob->subtype == SP_MAGIC_MISSILE || spell_ob->subtype == SP_SUMMON_GOLEM ||
733	spell_ob->subtype == SP_MAGIC_WALL || spell_ob->subtype == SP_SUMMON_MONSTER ||	744	spell_ob->subtype == SP_MAGIC_WALL || spell_ob->subtype == SP_SUMMON_MONSTER ||
734	spell_ob->subtype == SP_MOVING_BALL || spell_ob->subtype == SP_SWARM || spell_ob->subtype == SP_INVISIBLE)	745	spell_ob->subtype == SP_MOVING_BALL || spell_ob->subtype == SP_SWARM || spell_ob->subtype == SP_INVISIBLE)
735
736	return 1;	746	return 1;
737		747
738	return 0;	748	return 0;
739	}	749	}
740
741		750
742	#define MAX_KNOWN_SPELLS 20	751	#define MAX_KNOWN_SPELLS 20
743		752
744	/* Returns a randomly selected spell. This logic is still	753	/* Returns a randomly selected spell. This logic is still
745	* less than ideal. This code also only seems to deal with	754	* less than ideal. This code also only seems to deal with
…		…
748	*/	757	*/
749	object *	758	object *
750	monster_choose_random_spell (object *monster)	759	monster_choose_random_spell (object *monster)
751	{	760	{
752	object *altern[MAX_KNOWN_SPELLS];	761	object *altern[MAX_KNOWN_SPELLS];
753	object *tmp;
754	int i = 0;	762	int i = 0;
755		763
756	for (tmp = monster->inv; tmp != NULL; tmp = tmp->below)	764	for (object *tmp = monster->inv; tmp; tmp = tmp->below)
757	if (tmp->type == SPELLBOOK || tmp->type == SPELL)	765	if (tmp->type == SPELLBOOK || tmp->type == SPELL)
758	{	766	{
759	/* Check and see if it's actually a useful spell.	767	/* Check and see if it's actually a useful spell.
760	* If its a spellbook, the spell is actually the inventory item.	768	* If its a spellbook, the spell is actually the inventory item.
761	* if it is a spell, then it is just the object itself.	769	* if it is a spell, then it is just the object itself.
762	*/	770	*/
763	if (monster_should_cast_spell (monster, (tmp->type == SPELLBOOK) ? tmp->inv : tmp))	771	if (monster_should_cast_spell (monster, (tmp->type == SPELLBOOK) ? tmp->inv : tmp))
764	{	772	{
765	altern[i++] = tmp;	773	altern [i++] = tmp;
		774
766	if (i == MAX_KNOWN_SPELLS)	775	if (i == MAX_KNOWN_SPELLS)
767	break;	776	break;
768	}	777	}
769	}	778	}
770	if (!i)	779
771	return NULL;	780	return i ? altern [rndm (i)] : 0;
772	return altern[RANDOM () % i];
773	}	781	}
774		782
775	/* This checks to see if the monster should cast a spell/ability.	783	/* This checks to see if the monster should cast a spell/ability.
776	* it returns true if the monster casts a spell, 0 if he doesn't.	784	* it returns true if the monster casts a spell, 0 if he doesn't.
777	* head is the head of the monster.	785	* head is the head of the monster.
778	* part is the part of the monster we are checking against.	786	* part is the part of the monster we are checking against.
779	* pl is the target.	787	* pl is the target.
780	* dir is the direction to case.	788	* dir is the direction to case.
781	* rv is the vector which describes where the enemy is.	789	* rv is the vector which describes where the enemy is.
782	*/	790	*/
783
784	int	791	int
785	monster_cast_spell (object *head, object *part, object *pl, int dir, rv_vector * rv)	792	monster_cast_spell (object *head, object *part, object *pl, int dir, rv_vector * rv)
786	{	793	{
787	object *spell_item;	794	object *spell_item;
788	object *owner;	795	object *owner;
…		…
795	* other monsters)	802	* other monsters)
796	*/	803	*/
797	if (!(dir = path_to_player (part, pl, 0)))	804	if (!(dir = path_to_player (part, pl, 0)))
798	return 0;	805	return 0;
799		806
800	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = get_owner (head)) != NULL)	807	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
801	{	808	{
802	get_rangevector (head, owner, &rv1, 0x1);	809	get_rangevector (head, owner, &rv1, 0x1);
803	if (dirdiff (dir, rv1.direction) < 2)	810	if (dirdiff (dir, rv1.direction) < 2)
804	{
805	return 0; /* Might hit owner with spell */	811	return 0; /* Might hit owner with spell */
806	}
807	}	812	}
808		813
809	if (QUERY_FLAG (head, FLAG_CONFUSED))	814	if (QUERY_FLAG (head, FLAG_CONFUSED))
810	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	815	dir = absdir (dir + rndm (3) + rndm (3) - 2);
811		816
812	/* If the monster hasn't already chosen a spell, choose one	817	/* If the monster hasn't already chosen a spell, choose one
813	* I'm not sure if it really make sense to pre-select spells (events	818	* I'm not sure if it really make sense to pre-select spells (events
814	* could be different by the time the monster goes again).	819	* could be different by the time the monster goes again).
815	*/	820	*/
…		…
819	{	824	{
820	LOG (llevMonster, "Turned off spells in %s\n", &head->name);	825	LOG (llevMonster, "Turned off spells in %s\n", &head->name);
821	CLEAR_FLAG (head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */	826	CLEAR_FLAG (head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
822	return 0;	827	return 0;
823	}	828	}
		829
824	if (spell_item->type == SPELLBOOK)	830	if (spell_item->type == SPELLBOOK)
825	{	831	{
826	if (!spell_item->inv)	832	if (!spell_item->inv)
827	{	833	{
828	LOG (llevError, "spellbook %s does not contain a spell?\n", &spell_item->name);	834	LOG (llevError, "spellbook %s does not contain a spell?\n", &spell_item->name);
829	return 0;	835	return 0;
830	}	836	}
		837
831	spell_item = spell_item->inv;	838	spell_item = spell_item->inv;
832	}	839	}
833	}	840	}
834	else	841	else
835	spell_item = head->spellitem;	842	spell_item = head->spellitem;
…		…
854	/* set this to null, so next time monster will choose something different */	861	/* set this to null, so next time monster will choose something different */
855	head->spellitem = NULL;	862	head->spellitem = NULL;
856		863
857	return cast_spell (part, part, dir, spell_item, NULL);	864	return cast_spell (part, part, dir, spell_item, NULL);
858	}	865	}
859
860		866
861	int	867	int
862	monster_use_scroll (object *head, object *part, object *pl, int dir, rv_vector * rv)	868	monster_use_scroll (object *head, object *part, object *pl, int dir, rv_vector * rv)
863	{	869	{
864	object *scroll;	870	object *scroll;
…		…
872	* other monsters)	878	* other monsters)
873	*/	879	*/
874	if (!(dir = path_to_player (part, pl, 0)))	880	if (!(dir = path_to_player (part, pl, 0)))
875	return 0;	881	return 0;
876		882
877	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = get_owner (head)) != NULL)	883	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
878	{	884	{
879	get_rangevector (head, owner, &rv1, 0x1);	885	get_rangevector (head, owner, &rv1, 0x1);
880	if (dirdiff (dir, rv1.direction) < 2)	886	if (dirdiff (dir, rv1.direction) < 2)
881	{	887	{
882	return 0; /* Might hit owner with spell */	888	return 0; /* Might hit owner with spell */
883	}	889	}
884	}	890	}
885		891
886	if (QUERY_FLAG (head, FLAG_CONFUSED))	892	if (QUERY_FLAG (head, FLAG_CONFUSED))
887	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	893	dir = absdir (dir + rndm (3) + rndm (3) - 2);
888		894
889	for (scroll = head->inv; scroll; scroll = scroll->below)	895	for (scroll = head->inv; scroll; scroll = scroll->below)
890	if (scroll->type == SCROLL && monster_should_cast_spell (head, scroll->inv))	896	if (scroll->type == SCROLL && monster_should_cast_spell (head, scroll->inv))
891	break;	897	break;
892		898
…		…
914	* The skills we are treating here are all but those. -b.t.	920	* The skills we are treating here are all but those. -b.t.
915	*	921	*
916	* At the moment this is only useful for throwing, perhaps for	922	* At the moment this is only useful for throwing, perhaps for
917	* stealing. TODO: This should be more integrated in the game. -MT, 25.11.01	923	* stealing. TODO: This should be more integrated in the game. -MT, 25.11.01
918	*/	924	*/
919
920	int	925	int
921	monster_use_skill (object *head, object *part, object *pl, int dir)	926	monster_use_skill (object *head, object *part, object *pl, int dir)
922	{	927	{
923	object *skill, *owner;	928	object *skill, *owner;
924		929
925	if (!(dir = path_to_player (part, pl, 0)))	930	if (!(dir = path_to_player (part, pl, 0)))
926	return 0;	931	return 0;
927		932
928	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = get_owner (head)) != NULL)	933	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
929	{	934	{
930	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);	935	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
931		936
932	if (dirdiff (dir, dir2) < 1)	937	if (dirdiff (dir, dir2) < 1)
933	return 0; /* Might hit owner with skill -thrown rocks for example ? */	938	return 0; /* Might hit owner with skill -thrown rocks for example ? */
934	}	939	}
		940
935	if (QUERY_FLAG (head, FLAG_CONFUSED))	941	if (QUERY_FLAG (head, FLAG_CONFUSED))
936	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	942	dir = absdir (dir + rndm (3) + rndm (3) - 2);
937		943
938	/* skill selection - monster will use the next unused skill.	944	/* skill selection - monster will use the next unused skill.
939	* well...the following scenario will allow the monster to	945	* well...the following scenario will allow the monster to
940	* toggle between 2 skills. One day it would be nice to make	946	* toggle between 2 skills. One day it would be nice to make
941	* more skills available to monsters.	947	* more skills available to monsters.
942	*/	948	*/
943
944	for (skill = head->inv; skill != NULL; skill = skill->below)	949	for (skill = head->inv; skill; skill = skill->below)
945	if (skill->type == SKILL && skill != head->chosen_skill)	950	if (skill->type == SKILL && skill != head->chosen_skill)
946	{	951	{
947	head->chosen_skill = skill;	952	head->chosen_skill = skill;
948	break;	953	break;
949	}	954	}
…		…
952	{	957	{
953	LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);	958	LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);
954	CLEAR_FLAG (head, FLAG_READY_SKILL);	959	CLEAR_FLAG (head, FLAG_READY_SKILL);
955	return 0;	960	return 0;
956	}	961	}
		962
957	/* use skill */	963	/* use skill */
958	return do_skill (head, part, head->chosen_skill, dir, NULL);	964	return do_skill (head, part, head->chosen_skill, dir, NULL);
959	}	965	}
960		966
961	/* Monster will use a ranged spell attack. */	967	/* Monster will use a ranged spell attack. */
962
963	int	968	int
964	monster_use_range (object *head, object *part, object *pl, int dir)	969	monster_use_range (object *head, object *part, object *pl, int dir)
965	{	970	{
966	object *wand, *owner;	971	object *wand, *owner;
967	int at_least_one = 0;	972	int at_least_one = 0;
968		973
969	if (!(dir = path_to_player (part, pl, 0)))	974	if (!(dir = path_to_player (part, pl, 0)))
970	return 0;	975	return 0;
971		976
972	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = get_owner (head)) != NULL)	977	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
973	{	978	{
974	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);	979	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
975		980
976	if (dirdiff (dir, dir2) < 2)	981	if (dirdiff (dir, dir2) < 2)
977	return 0; /* Might hit owner with spell */	982	return 0; /* Might hit owner with spell */
978	}	983	}
		984
979	if (QUERY_FLAG (head, FLAG_CONFUSED))	985	if (QUERY_FLAG (head, FLAG_CONFUSED))
980	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	986	dir = absdir (dir + rndm (3) + rndm (3) - 2);
981		987
982	for (wand = head->inv; wand != NULL; wand = wand->below)	988	for (wand = head->inv; wand; wand = wand->below)
983	{	989	{
984	if (wand->type == WAND)	990	if (wand->type == WAND)
985	{	991	{
986	/* Found a wand, let's see if it has charges left */	992	/* Found a wand, let's see if it has charges left */
987	at_least_one = 1;	993	at_least_one = 1;
…		…
993	if (!(--wand->stats.food))	999	if (!(--wand->stats.food))
994	{	1000	{
995	if (wand->arch)	1001	if (wand->arch)
996	{	1002	{
997	CLEAR_FLAG (wand, FLAG_ANIMATE);	1003	CLEAR_FLAG (wand, FLAG_ANIMATE);
998	wand->face = wand->arch->clone.face;	1004	wand->face = wand->arch->face;
999	wand->speed = 0;	1005	wand->set_speed (0);
1000	update_ob_speed (wand);
1001	}	1006	}
1002	}	1007	}
1003	/* Success */	1008	/* Success */
1004	return 1;	1009	return 1;
1005	}	1010	}
…		…
1023	}	1028	}
1024		1029
1025	if (at_least_one)	1030	if (at_least_one)
1026	return 0;	1031	return 0;
1027		1032
1028	LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n", &head->name, head->count);	1033	LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANGE() without wand/horn/rod.\n", &head->name, head->count);
1029	CLEAR_FLAG (head, FLAG_READY_RANGE);	1034	CLEAR_FLAG (head, FLAG_READY_RANGE);
1030	return 0;	1035	return 0;
1031	}	1036	}
1032		1037
1033	int	1038	int
…		…
1035	{	1040	{
1036	object *owner;	1041	object *owner;
1037		1042
1038	if (!(dir = path_to_player (part, pl, 0)))	1043	if (!(dir = path_to_player (part, pl, 0)))
1039	return 0;	1044	return 0;
		1045
1040	if (QUERY_FLAG (head, FLAG_CONFUSED))	1046	if (QUERY_FLAG (head, FLAG_CONFUSED))
1041	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	1047	dir = absdir (dir + rndm (3) + rndm (3) - 2);
1042		1048
1043	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = get_owner (head)) != NULL)	1049	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
1044	{	1050	{
1045	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);	1051	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
1046		1052
1047	if (dirdiff (dir, dir2) < 1)	1053	if (dirdiff (dir, dir2) < 1)
1048	return 0; /* Might hit owner with arrow */	1054	return 0; /* Might hit owner with arrow */
…		…
1052	return fire_bow (head, part, NULL, dir, 0, part->x, part->y);	1058	return fire_bow (head, part, NULL, dir, 0, part->x, part->y);
1053		1059
1054	}	1060	}
1055		1061
1056	/* Checks if putting on 'item' will make 'who' do more	1062	/* Checks if putting on 'item' will make 'who' do more
1057	* damage. This is a very simplistic check - also checking things	1063	* damage. This is a very simplistic check - also checking things
1058	* like speed and ac are also relevant.	1064	* like speed and ac are also relevant.
1059	*	1065	*
1060	* return true if item is a better object.	1066	* return true if item is a better object.
1061	*/	1067	*/
1062
1063	int	1068	int
1064	check_good_weapon (object *who, object *item)	1069	check_good_weapon (object *who, object *item)
1065	{	1070	{
1066	object *other_weap;	1071	object *other_weap;
1067	int val = 0, i;	1072	int val = 0, i;
1068		1073
1069	for (other_weap = who->inv; other_weap != NULL; other_weap = other_weap->below)	1074	for (other_weap = who->inv; other_weap; other_weap = other_weap->below)
1070	if (other_weap->type == item->type && QUERY_FLAG (other_weap, FLAG_APPLIED))	1075	if (other_weap->type == item->type && QUERY_FLAG (other_weap, FLAG_APPLIED))
1071	break;	1076	break;
1072		1077
1073	if (other_weap == NULL) /* No other weapons */	1078	if (!other_weap) /* No other weapons */
1074	return 1;	1079	return 1;
1075		1080
1076	/* Rather than go through and apply the new one, and see if it is	1081	/* Rather than go through and apply the new one, and see if it is
1077	* better, just do some simple checks	1082	* better, just do some simple checks
1078	* Put some multipliers for things that hvae several effects,	1083	* Put some multipliers for things that hvae several effects,
…		…
1083	val += (item->magic - other_weap->magic) * 3;	1088	val += (item->magic - other_weap->magic) * 3;
1084	/* Monsters don't really get benefits from things like regen rates	1089	/* Monsters don't really get benefits from things like regen rates
1085	* from items. But the bonus for their stats are very important.	1090	* from items. But the bonus for their stats are very important.
1086	*/	1091	*/
1087	for (i = 0; i < NUM_STATS; i++)	1092	for (i = 0; i < NUM_STATS; i++)
1088	val += (get_attr_value (&item->stats, i) - get_attr_value (&other_weap->stats, i)) * 2;	1093	val += item->stats.stat (i) - other_weap->stats.stat (i) * 2;
1089		1094
1090	if (val > 0)	1095	if (val > 0)
1091	return 1;	1096	return 1;
1092	else	1097	else
1093	return 0;	1098	return 0;
1094
1095	}	1099	}
1096		1100
1097	int	1101	int
1098	check_good_armour (object *who, object *item)	1102	check_good_armour (object *who, object *item)
1099	{	1103	{
1100	object *other_armour;	1104	object *other_armour;
1101	int val = 0, i;	1105	int val = 0, i;
1102		1106
1103	for (other_armour = who->inv; other_armour != NULL; other_armour = other_armour->below)	1107	for (other_armour = who->inv; other_armour; other_armour = other_armour->below)
1104	if (other_armour->type == item->type && QUERY_FLAG (other_armour, FLAG_APPLIED))	1108	if (other_armour->type == item->type && QUERY_FLAG (other_armour, FLAG_APPLIED))
1105	break;	1109	break;
1106		1110
1107	if (other_armour == NULL) /* No other armour, use the new */	1111	if (other_armour == NULL) /* No other armour, use the new */
1108	return 1;	1112	return 1;
…		…
1130		1134
1131	if (val > 0)	1135	if (val > 0)
1132	return 1;	1136	return 1;
1133	else	1137	else
1134	return 0;	1138	return 0;
1135
1136	}	1139	}
1137		1140
1138	/*	1141	/*
1139	* monster_check_pickup(): checks for items that monster can pick up.	1142	* monster_check_pickup(): checks for items that monster can pick up.
1140	*	1143	*
…		…
1148	* This function was seen be continueing looping at one point (tmp->below	1151	* This function was seen be continueing looping at one point (tmp->below
1149	* became a recursive loop. It may be better to call monster_check_apply	1152	* became a recursive loop. It may be better to call monster_check_apply
1150	* after we pick everything up, since that function may call others which	1153	* after we pick everything up, since that function may call others which
1151	* affect stacking on this space.	1154	* affect stacking on this space.
1152	*/	1155	*/
1153
1154	void	1156	void
1155	monster_check_pickup (object *monster)	1157	monster_check_pickup (object *monster)
1156	{	1158	{
1157	object *tmp, *next;	1159	object *tmp, *next;
1158	int next_tag;
1159		1160
1160	for (tmp = monster->below; tmp != NULL; tmp = next)	1161	for (tmp = monster->below; tmp != NULL; tmp = next)
1161	{	1162	{
1162	next = tmp->below;	1163	next = tmp->below;
1163	next_tag = next ? next->count : 0;
1164	if (monster_can_pick (monster, tmp))	1164	if (monster_can_pick (monster, tmp))
1165	{	1165	{
1166	remove_ob (tmp);	1166	tmp->remove ();
1167	tmp = insert_ob_in_ob (tmp, monster);	1167	tmp = insert_ob_in_ob (tmp, monster);
1168	(void) monster_check_apply (monster, tmp);	1168	(void) monster_check_apply (monster, tmp);
1169	}	1169	}
1170	/* We could try to re-establish the cycling, of the space, but probably	1170	/* We could try to re-establish the cycling, of the space, but probably
1171	* not a big deal to just bail out.	1171	* not a big deal to just bail out.
1172	*/	1172	*/
1173	if (next && was_destroyed (next, next_tag))	1173	if (next && next->destroyed ())
1174	return;	1174	return;
1175	}	1175	}
1176	}	1176	}
1177		1177
1178	/*	1178	/*
1179	* monster_can_pick(): If the monster is interested in picking up	1179	* monster_can_pick(): If the monster is interested in picking up
1180	* the item, then return 0. Otherwise 0.	1180	* the item, then return 0. Otherwise 0.
1181	* Instead of pick_up, flags for "greed", etc, should be used.	1181	* Instead of pick_up, flags for "greed", etc, should be used.
1182	* I've already utilized flags for bows, wands, rings, etc, etc. -Frank.	1182	* I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
1183	*/	1183	*/
1184
1185	int	1184	int
1186	monster_can_pick (object *monster, object *item)	1185	monster_can_pick (object *monster, object *item)
1187	{	1186	{
1188	int flag = 0;	1187	int flag = 0;
1189	int i;	1188	int i;
…		…
1198	flag = 1;	1197	flag = 1;
1199		1198
1200	else	1199	else
1201	switch (item->type)	1200	switch (item->type)
1202	{	1201	{
1203	case MONEY:	1202	case MONEY:
1204	case GEM:	1203	case GEM:
1205	flag = monster->pick_up & 2;	1204	flag = monster->pick_up & 2;
1206	break;	1205	break;
1207		1206
1208	case FOOD:	1207	case FOOD:
1209	flag = monster->pick_up & 4;	1208	flag = monster->pick_up & 4;
1210	break;	1209	break;
1211		1210
1212	case WEAPON:	1211	case WEAPON:
1213	flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON);	1212	flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON);
1214	break;	1213	break;
1215		1214
1216	case ARMOUR:	1215	case ARMOUR:
1217	case SHIELD:	1216	case SHIELD:
1218	case HELMET:	1217	case HELMET:
1219	case BOOTS:	1218	case BOOTS:
1220	case GLOVES:	1219	case GLOVES:
1221	case GIRDLE:	1220	case GIRDLE:
1222	flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR);	1221	flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR);
1223	break;	1222	break;
1224		1223
1225	case SKILL:	1224	case SKILL:
1226	flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);	1225	flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);
1227	break;	1226	break;
1228		1227
1229	case RING:	1228	case RING:
1230	flag = QUERY_FLAG (monster, FLAG_USE_RING);	1229	flag = QUERY_FLAG (monster, FLAG_USE_RING);
1231	break;	1230	break;
1232		1231
1233	case WAND:	1232	case WAND:
1234	case HORN:	1233	case HORN:
1235	case ROD:	1234	case ROD:
1236	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);	1235	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1237	break;	1236	break;
1238		1237
1239	case SPELLBOOK:	1238	case SPELLBOOK:
1240	flag = (monster->arch != NULL && QUERY_FLAG ((&monster->arch->clone), FLAG_CAST_SPELL));	1239	flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1241	break;	1240	break;
1242		1241
1243	case SCROLL:	1242	case SCROLL:
1244	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);	1243	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1245	break;	1244	break;
1246		1245
1247	case BOW:	1246	case BOW:
1248	case ARROW:	1247	case ARROW:
1249	flag = QUERY_FLAG (monster, FLAG_USE_BOW);	1248	flag = QUERY_FLAG (monster, FLAG_USE_BOW);
1250	break;	1249	break;
1251	}	1250	}
		1251
1252	/* Simplistic check - if the monster has a location to equip it, he will	1252	/* Simplistic check - if the monster has a location to equip it, he will
1253	* pick it up. Note that this doesn't handle cases where an item may	1253	* pick it up. Note that this doesn't handle cases where an item may
1254	* use several locations.	1254	* use several locations.
1255	*/	1255	*/
1256	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1256	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1257	{	1257	{
1258	if (monster->body_info[i] && item->body_info[i])	1258	if (monster->slot[i].info && item->slot[i].info)
1259	{	1259	{
1260	flag = 1;	1260	flag = 1;
1261	break;	1261	break;
1262	}	1262	}
1263	}	1263	}
1264		1264
1265	if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && (!flag)))	1265	if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && (!flag)))
1266	return 1;	1266	return 1;
		1267
1267	return 0;	1268	return 0;
1268	}	1269	}
1269		1270
1270	/*	1271	/*
1271	* monster_apply_below():	1272	* monster_apply_below():
1272	* Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's	1273	* Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
1273	* eager to apply things, encounters something apply-able,	1274	* eager to apply things, encounters something apply-able,
1274	* then make him apply it	1275	* then make him apply it
1275	*/	1276	*/
1276
1277	void	1277	void
1278	monster_apply_below (object *monster)	1278	monster_apply_below (object *monster)
1279	{	1279	{
1280	object *tmp, *next;	1280	object *tmp, *next;
1281		1281
1282	for (tmp = monster->below; tmp != NULL; tmp = next)	1282	for (tmp = monster->below; tmp != NULL; tmp = next)
1283	{	1283	{
1284	next = tmp->below;	1284	next = tmp->below;
1285	switch (tmp->type)	1285	switch (tmp->type)
1286	{	1286	{
1287	case CF_HANDLE:	1287	case T_HANDLE:
1288	case TRIGGER:	1288	case TRIGGER:
1289	if (monster->will_apply & 1)	1289	if (monster->will_apply & 1)
1290	manual_apply (monster, tmp, 0);	1290	manual_apply (monster, tmp, 0);
1291	break;	1291	break;
1292		1292
…		…
1308	* a pointer to that object is returned, so it can be dropped.	1308	* a pointer to that object is returned, so it can be dropped.
1309	* (so that other monsters can pick it up and use it)	1309	* (so that other monsters can pick it up and use it)
1310	* Note that as things are now, monsters never drop something -	1310	* Note that as things are now, monsters never drop something -
1311	* they can pick up all that they can use.	1311	* they can pick up all that they can use.
1312	*/	1312	*/
1313
1314	/* Sept 96, fixed this so skills will be readied -b.t.*/	1313	/* Sept 96, fixed this so skills will be readied -b.t.*/
1315
1316	void	1314	void
1317	monster_check_apply (object *mon, object *item)	1315	monster_check_apply (object *mon, object *item)
1318	{	1316	{
1319
1320	int flag = 0;	1317	int flag = 0;
1321		1318
1322	if (item->type == SPELLBOOK && mon->arch != NULL && (QUERY_FLAG ((&mon->arch->clone), FLAG_CAST_SPELL)))	1319	if (item->type == SPELLBOOK && mon->arch && (QUERY_FLAG (mon->arch, FLAG_CAST_SPELL)))
1323	{	1320	{
1324	SET_FLAG (mon, FLAG_CAST_SPELL);	1321	SET_FLAG (mon, FLAG_CAST_SPELL);
1325	return;	1322	return;
1326	}	1323	}
1327		1324
…		…
1336	if (QUERY_FLAG (mon, FLAG_USE_BOW) && item->type == ARROW)	1333	if (QUERY_FLAG (mon, FLAG_USE_BOW) && item->type == ARROW)
1337	{	1334	{
1338	/* Check for the right kind of bow */	1335	/* Check for the right kind of bow */
1339	object *bow;	1336	object *bow;
1340		1337
1341	for (bow = mon->inv; bow != NULL; bow = bow->below)	1338	for (bow = mon->inv; bow; bow = bow->below)
1342	if (bow->type == BOW && bow->race == item->race)	1339	if (bow->type == BOW && bow->race == item->race)
1343	{	1340	{
1344	SET_FLAG (mon, FLAG_READY_BOW);	1341	SET_FLAG (mon, FLAG_READY_BOW);
1345	LOG (llevMonster, "Found correct bow for arrows.\n");	1342	LOG (llevMonster, "Found correct bow for arrows.\n");
1346	return; /* nothing more to do for arrows */	1343	return; /* nothing more to do for arrows */
…		…
1361	/* Don't use it right now */	1358	/* Don't use it right now */
1362	return;	1359	return;
1363	}	1360	}
1364	else if (item->type == WEAPON)	1361	else if (item->type == WEAPON)
1365	flag = check_good_weapon (mon, item);	1362	flag = check_good_weapon (mon, item);
1366	else if (IS_ARMOR (item))	1363	else if (item->is_armor ())
1367	flag = check_good_armour (mon, item);	1364	flag = check_good_armour (mon, item);
1368	/* Should do something more, like make sure this is a better item */	1365	/* Should do something more, like make sure this is a better item */
1369	else if (item->type == RING)	1366	else if (item->type == RING)
1370	flag = 1;	1367	flag = 1;
1371	else if (item->type == WAND || item->type == ROD || item->type == HORN)	1368	else if (item->type == WAND || item->type == ROD || item->type == HORN)
…		…
1398	*/	1395	*/
1399	SET_FLAG (mon, FLAG_READY_SKILL);	1396	SET_FLAG (mon, FLAG_READY_SKILL);
1400	return;	1397	return;
1401	}	1398	}
1402		1399
1403
1404	/* if we don't match one of the above types, return now.	1400	/* if we don't match one of the above types, return now.
1405	* can_apply_object will say that we can apply things like flesh,	1401	* can_apply_object will say that we can apply things like flesh,
1406	* bolts, and whatever else, because it only checks against the	1402	* bolts, and whatever else, because it only checks against the
1407	* body_info locations.	1403	* body_info locations.
1408	*/	1404	*/
…		…
1419	/* should only be applying this item, not unapplying it.	1415	/* should only be applying this item, not unapplying it.
1420	* also, ignore status of curse so they can take off old armour.	1416	* also, ignore status of curse so they can take off old armour.
1421	* monsters have some advantages after all.	1417	* monsters have some advantages after all.
1422	*/	1418	*/
1423	manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);	1419	manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);
1424
1425	return;
1426	}	1420	}
1427		1421
1428	void	1422	void
1429	npc_call_help (object *op)	1423	npc_call_help (object *op)
1430	{	1424	{
1431	int x, y, mflags;	1425	unordered_mapwalk (op, -7, -7, 7, 7)
1432	object *npc;
1433	sint16 sx, sy;
1434	mapstruct *m;
1435
1436	for (x = -3; x < 4; x++)
1437	for (y = -3; y < 4; y++)
1438	{	1426	{
1439	m = op->map;	1427	mapspace &ms = m->at (nx, ny);
1440	sx = op->x + x;	1428
1441	sy = op->y + y;
1442	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1443	/* If nothing alive on this space, no need to search the space. */	1429	/* If nothing alive on this space, no need to search the space. */
1444	if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE))	1430	if (!(ms.flags () & P_IS_ALIVE))
1445	continue;	1431	continue;
1446		1432
1447	for (npc = get_map_ob (m, sx, sy); npc != NULL; npc = npc->above)	1433	for (object *npc = ms.bot; npc; npc = npc->above)
1448	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))	1434	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
1449	npc->enemy = op->enemy;	1435	npc->enemy = op->enemy;
1450	}	1436	}
1451	}	1437	}
1452		1438
1453
1454	int	1439	int
1455	dist_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	1440	dist_att (int dir, object *ob, object *enemy, object *part, rv_vector *rv)
1456	{	1441	{
1457
1458	if (can_hit (part, enemy, rv))	1442	if (can_hit (part, enemy, rv))
1459	return dir;	1443	return dir;
		1444
1460	if (rv->distance < 10)	1445	if (rv->distance < 10)
1461	return absdir (dir + 4);	1446	return absdir (dir + 4);
1462	else if (rv->distance > 18)	1447	else if (rv->distance > 18)
1463	return dir;	1448	return dir;
		1449
1464	return 0;	1450	return 0;
1465	}	1451	}
1466		1452
1467	int	1453	int
1468	run_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	1454	run_att (int dir, object *ob, object *enemy, object *part, rv_vector *rv)
1469	{	1455	{
1470		1456	if (can_hit (part, enemy, rv))
1471	if ((can_hit (part, enemy, rv) && ob->move_status < 20) || ob->move_status < 20)
1472	{
1473	ob->move_status++;
1474	return (dir);	1457	return dir;
1475	}	1458	else
1476	else if (ob->move_status > 20)
1477	ob->move_status = 0;
1478	return absdir (dir + 4);	1459	return absdir (dir + 4);
1479	}	1460	}
1480		1461
1481	int	1462	int
1482	hitrun_att (int dir, object *ob, object *enemy)	1463	hitrun_att (int dir, object *ob, object *enemy)
1483	{	1464	{
…		…
1485	return dir;	1466	return dir;
1486	else if (ob->move_status < 50)	1467	else if (ob->move_status < 50)
1487	return absdir (dir + 4);	1468	return absdir (dir + 4);
1488	else	1469	else
1489	ob->move_status = 0;	1470	ob->move_status = 0;
		1471
1490	return absdir (dir + 4);	1472	return absdir (dir + 4);
1491	}	1473	}
1492		1474
1493	int	1475	int
1494	wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	1476	wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1495	{	1477	{
1496
1497	int inrange = can_hit (part, enemy, rv);	1478	int inrange = can_hit (part, enemy, rv);
1498		1479
1499	if (ob->move_status || inrange)	1480	if (ob->move_status || inrange)
1500	ob->move_status++;	1481	ob->move_status++;
1501		1482
…		…
1503	return 0;	1484	return 0;
1504	else if (ob->move_status < 10)	1485	else if (ob->move_status < 10)
1505	return dir;	1486	return dir;
1506	else if (ob->move_status < 15)	1487	else if (ob->move_status < 15)
1507	return absdir (dir + 4);	1488	return absdir (dir + 4);
		1489
1508	ob->move_status = 0;	1490	ob->move_status = 0;
1509	return 0;	1491	return 0;
1510	}	1492	}
1511		1493
1512	int	1494	int
1513	disthit_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	1495	disthit_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1514	{	1496	{
1515
1516	/* The logic below here looked plain wrong before. Basically, what should	1497	/* The logic below here looked plain wrong before. Basically, what should
1517	* happen is that if the creatures hp percentage falls below run_away,	1498	* happen is that if the creatures hp percentage falls below run_away,
1518	* the creature should run away (dir+4)	1499	* the creature should run away (dir+4)
1519	* I think its wrong for a creature to have a zero maxhp value, but	1500	* I think its wrong for a creature to have a zero maxhp value, but
1520	* at least one map has this set, and whatever the map contains, the	1501	* at least one map has this set, and whatever the map contains, the
1521	* server should try to be resilant enough to avoid the problem	1502	* server should try to be resilant enough to avoid the problem
1522	*/	1503	*/
1523	if (ob->stats.maxhp && (ob->stats.hp * 100) / ob->stats.maxhp < ob->run_away)	1504	if (ob->stats.hp * 100 < ob->stats.maxhp * ob->run_away)
1524	return absdir (dir + 4);	1505	return absdir (dir + 4);
		1506
1525	return dist_att (dir, ob, enemy, part, rv);	1507	return dist_att (dir, ob, enemy, part, rv);
1526	}	1508	}
1527		1509
1528	int	1510	int
1529	wait_att2 (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	1511	wait_att2 (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1530	{	1512	{
1531	if (rv->distance < 9)	1513	if (rv->distance < 9)
1532	return absdir (dir + 4);	1514	return absdir (dir + 4);
		1515
1533	return 0;	1516	return 0;
1534	}	1517	}
1535		1518
1536	void	1519	void
1537	circ1_move (object *ob)	1520	circ1_move (object *ob)
1538	{	1521	{
1539	static int circle[12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 };	1522	static int circle[12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 };
		1523
1540	if (++ob->move_status > 11)	1524	if (++ob->move_status > 11)
1541	ob->move_status = 0;	1525	ob->move_status = 0;
		1526
1542	if (!(move_object (ob, circle[ob->move_status])))	1527	if (!(move_object (ob, circle[ob->move_status])))
1543	(void) move_object (ob, RANDOM () % 8 + 1);	1528	move_object (ob, rndm (8) + 1);
1544	}	1529	}
1545		1530
1546	void	1531	void
1547	circ2_move (object *ob)	1532	circ2_move (object *ob)
1548	{	1533	{
1549	static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };	1534	static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };
		1535
1550	if (++ob->move_status > 19)	1536	if (++ob->move_status > 19)
1551	ob->move_status = 0;	1537	ob->move_status = 0;
		1538
1552	if (!(move_object (ob, circle[ob->move_status])))	1539	if (!(move_object (ob, circle[ob->move_status])))
1553	(void) move_object (ob, RANDOM () % 8 + 1);	1540	move_object (ob, rndm (8) + 1);
1554	}	1541	}
1555		1542
1556	void	1543	void
1557	pace_movev (object *ob)	1544	pace_movev (object *ob)
1558	{	1545	{
1559	if (ob->move_status++ > 6)	1546	if (ob->move_status++ > 6)
1560	ob->move_status = 0;	1547	ob->move_status = 0;
		1548
1561	if (ob->move_status < 4)	1549	if (ob->move_status < 4)
1562	(void) move_object (ob, 5);	1550	move_object (ob, 5);
1563	else	1551	else
1564	(void) move_object (ob, 1);	1552	move_object (ob, 1);
1565	}	1553	}
1566		1554
1567	void	1555	void
1568	pace_moveh (object *ob)	1556	pace_moveh (object *ob)
1569	{	1557	{
1570	if (ob->move_status++ > 6)	1558	if (ob->move_status++ > 6)
1571	ob->move_status = 0;	1559	ob->move_status = 0;
		1560
1572	if (ob->move_status < 4)	1561	if (ob->move_status < 4)
1573	(void) move_object (ob, 3);	1562	move_object (ob, 3);
1574	else	1563	else
1575	(void) move_object (ob, 7);	1564	move_object (ob, 7);
1576	}	1565	}
1577		1566
1578	void	1567	void
1579	pace2_movev (object *ob)	1568	pace2_movev (object *ob)
1580	{	1569	{
1581	if (ob->move_status++ > 16)	1570	if (ob->move_status++ > 16)
1582	ob->move_status = 0;	1571	ob->move_status = 0;
		1572
1583	if (ob->move_status < 6)	1573	if (ob->move_status < 6)
1584	(void) move_object (ob, 5);	1574	move_object (ob, 5);
1585	else if (ob->move_status < 8)	1575	else if (ob->move_status < 8)
1586	return;	1576	return;
1587	else if (ob->move_status < 13)	1577	else if (ob->move_status < 13)
1588	(void) move_object (ob, 1);	1578	move_object (ob, 1);
1589	else	1579	else
1590	return;	1580	return;
1591	}	1581	}
1592		1582
1593	void	1583	void
1594	pace2_moveh (object *ob)	1584	pace2_moveh (object *ob)
1595	{	1585	{
1596	if (ob->move_status++ > 16)	1586	if (ob->move_status++ > 16)
1597	ob->move_status = 0;	1587	ob->move_status = 0;
		1588
1598	if (ob->move_status < 6)	1589	if (ob->move_status < 6)
1599	(void) move_object (ob, 3);	1590	move_object (ob, 3);
1600	else if (ob->move_status < 8)	1591	else if (ob->move_status < 8)
1601	return;	1592	return;
1602	else if (ob->move_status < 13)	1593	else if (ob->move_status < 13)
1603	(void) move_object (ob, 7);	1594	move_object (ob, 7);
1604	else	1595	else
1605	return;	1596	return;
1606	}	1597	}
1607		1598
1608	void	1599	void
1609	rand_move (object *ob)	1600	rand_move (object *ob)
1610	{	1601	{
1611	int i;
1612
1613	if (ob->move_status < 1 || ob->move_status > 8 || !(move_object (ob, ob->move_status || !(RANDOM () % 9))))	1602	if (ob->move_status < 1 || ob->move_status > 8 || !(move_object (ob, ob->move_status || !(rndm (9)))))
1614	for (i = 0; i < 5; i++)	1603	for (int i = 0; i < 5; i++)
1615	if (move_object (ob, ob->move_status = RANDOM () % 8 + 1))	1604	if (move_object (ob, ob->move_status = rndm (8) + 1))
1616	return;	1605	return;
1617	}	1606	}
1618		1607
1619	void	1608	void
1620	check_earthwalls (object *op, mapstruct *m, int x, int y)	1609	check_earthwalls (object *op, maptile *m, int x, int y)
1621	{	1610	{
1622	object *tmp;
1623
1624	for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above)	1611	for (object *tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
1625	{
1626	if (tmp->type == EARTHWALL)	1612	if (tmp->type == EARTHWALL)
1627	{	1613	{
1628	hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);	1614	hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);
1629	return;	1615	return;
1630	}	1616	}
1631	}
1632	}	1617	}
1633		1618
1634	void	1619	void
1635	check_doors (object *op, mapstruct *m, int x, int y)	1620	check_doors (object *op, maptile *m, int x, int y)
1636	{	1621	{
1637	object *tmp;
1638
1639	for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above)	1622	for (object *tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
1640	{
1641	if (tmp->type == DOOR)	1623	if (tmp->type == DOOR)
1642	{	1624	{
1643	hit_player (tmp, 1000, op, AT_PHYSICAL, 1);	1625	hit_player (tmp, 1000, op, AT_PHYSICAL, 1);
1644	return;	1626	return;
1645	}	1627	}
1646	}
1647	}	1628	}
1648		1629
1649	/* find_mon_throw_ob() - modeled on find_throw_ob	1630	/* find_mon_throw_ob() - modeled on find_throw_ob
1650	* This is probably overly simplistic as it is now - We want	1631	* This is probably overly simplistic as it is now - We want
1651	* monsters to throw things like chairs and other pieces of	1632	* monsters to throw things like chairs and other pieces of
1652	* furniture, even if they are not good throwable objects.	1633	* furniture, even if they are not good throwable objects.
1653	* Probably better to have the monster throw a throwable object	1634	* Probably better to have the monster throw a throwable object
1654	* first, then throw any non equipped weapon.	1635	* first, then throw any non equipped weapon.
1655	*/	1636	*/
1656
1657	object *	1637	object *
1658	find_mon_throw_ob (object *op)	1638	find_mon_throw_ob (object *op)
1659	{	1639	{
1660	object *tmp = NULL;	1640	object *tmp = NULL;
1661		1641
…		…
1665	tmp = op;	1645	tmp = op;
1666		1646
1667	/* New throw code: look through the inventory. Grap the first legal is_thrown	1647	/* New throw code: look through the inventory. Grap the first legal is_thrown
1668	* marked item and throw it to the enemy.	1648	* marked item and throw it to the enemy.
1669	*/	1649	*/
1670
1671	for (tmp = op->inv; tmp; tmp = tmp->below)	1650	for (tmp = op->inv; tmp; tmp = tmp->below)
1672	{	1651	{
1673
1674	/* Can't throw invisible objects or items that are applied */	1652	/* Can't throw invisible objects or items that are applied */
1675	if (tmp->invisible || QUERY_FLAG (tmp, FLAG_APPLIED))	1653	if (tmp->invisible || QUERY_FLAG (tmp, FLAG_APPLIED))
1676	continue;	1654	continue;
1677		1655
1678	if (QUERY_FLAG (tmp, FLAG_IS_THROWN))	1656	if (QUERY_FLAG (tmp, FLAG_IS_THROWN))
…		…
1694	* properly. I also so odd code in place that checked for x distance	1672	* properly. I also so odd code in place that checked for x distance
1695	* OR y distance being within some range - that seemed wrong - both should	1673	* OR y distance being within some range - that seemed wrong - both should
1696	* be within the valid range. MSW 2001-08-05	1674	* be within the valid range. MSW 2001-08-05
1697	* Returns 0 if enemy can not be detected, 1 if it is detected	1675	* Returns 0 if enemy can not be detected, 1 if it is detected
1698	*/	1676	*/
1699
1700	int	1677	int
1701	can_detect_enemy (object *op, object *enemy, rv_vector * rv)	1678	can_detect_enemy (object *op, object *enemy, rv_vector * rv)
1702	{	1679	{
1703	int radius = MIN_MON_RADIUS, hide_discovery;
1704
1705	/* null detection for any of these condtions always */	1680	/* null detection for any of these condtions always */
1706	if (!op || !enemy || !op->map || !enemy->map)	1681	if (!op || !enemy || !op->map || !enemy->map)
1707	return 0;	1682	return 0;
1708		1683
1709	/* If the monster (op) has no way to get to the enemy, do nothing */	1684	/* If the monster (op) has no way to get to the enemy, do nothing */
…		…
1711	return 0;	1686	return 0;
1712		1687
1713	get_rangevector (op, enemy, rv, 0);	1688	get_rangevector (op, enemy, rv, 0);
1714		1689
1715	/* Monsters always ignore the DM */	1690	/* Monsters always ignore the DM */
1716	if ((op->type != PLAYER) && QUERY_FLAG (enemy, FLAG_WIZ))	1691	if (!op->is_player () && QUERY_FLAG (enemy, FLAG_WIZ))
1717	return 0;	1692	return 0;
1718		1693
1719	/* simple check. Should probably put some range checks in here. */	1694	/* simple check. Should probably put some range checks in here. */
1720	if (can_see_enemy (op, enemy))	1695	if (can_see_enemy (op, enemy))
1721	return 1;	1696	return 1;
1722		1697
1723	/* The rest of this is for monsters. Players are on their own for	1698	/* The rest of this is for monsters. Players are on their own for
1724	* finding enemies!	1699	* finding enemies!
1725	*/	1700	*/
1726	if (op->type == PLAYER)	1701	if (op->is_player ())
1727	return 0;	1702	return 0;
1728		1703
1729	/* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE	1704	/* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
1730	* flag (which was already checked) in can_see_enmy (). Lets get out of here	1705	* flag (which was already checked) in can_see_enemy (). Lets get out of here
1731	*/	1706	*/
1732	if (enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden)))	1707	if (enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden)))
1733	return 0;	1708	return 0;
1734		1709
		1710	int radius = MIN_MON_RADIUS;
		1711
1735	/* use this for invis also */	1712	/* use this for invis also */
1736	hide_discovery = op->stats.Int / 5;	1713	int hide_discovery = op->stats.Int / 5;
1737		1714
1738	/* Determine Detection radii */	1715	/* Determine Detection radii */
1739	if (!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */	1716	if (!enemy->flag [FLAG_HIDDEN]) /* to detect non-hidden (eg dark/invis enemy) */
1740	radius = (op->stats.Wis / 5) + 1 > MIN_MON_RADIUS ? (op->stats.Wis / 5) + 1 : MIN_MON_RADIUS;	1717	radius = max (MIN_MON_RADIUS, op->stats.Wis / 3 + 1);
1741	else	1718	else
1742	{ /* a level/INT/Dex adjustment for hiding */	1719	{ /* a level/INT/Dex adjustment for hiding */
1743	object *sk_hide;
1744	int bonus = (op->level / 2) + (op->stats.Int / 5);	1720	int bonus = op->level / 2 + op->stats.Int / 5;
1745		1721
1746	if (enemy->type == PLAYER)	1722	if (enemy->is_player ())
1747	{	1723	{
1748	if ((sk_hide = find_skill_by_number (enemy, SK_HIDING)))	1724	if (object *sk_hide = find_skill_by_number (enemy, SK_HIDING))
1749	bonus -= sk_hide->level;	1725	bonus -= sk_hide->level;
1750	else	1726	else
1751	{	1727	{
1752	LOG (llevError, "can_detect_enemy() got hidden player w/o hiding skill!\n");	1728	LOG (llevError, "can_detect_enemy() got hidden player w/o hiding skill!\n");
1753	make_visible (enemy);	1729	make_visible (enemy);
…		…
1762	} /* else creature has modifiers for hiding */	1738	} /* else creature has modifiers for hiding */
1763		1739
1764	/* Radii stealth adjustment. Only if you are stealthy	1740	/* Radii stealth adjustment. Only if you are stealthy
1765	* will you be able to sneak up closer to creatures */	1741	* will you be able to sneak up closer to creatures */
1766	if (QUERY_FLAG (enemy, FLAG_STEALTH))	1742	if (QUERY_FLAG (enemy, FLAG_STEALTH))
1767	radius = radius / 2, hide_discovery = hide_discovery / 3;	1743	{
		1744	radius /= 2;
		1745	hide_discovery /= 3;
		1746	}
1768		1747
1769	/* Radii adjustment for enemy standing in the dark */	1748	/* Radii adjustment for enemy standing in the dark */
1770	if (op->map->darkness > 0 && !stand_in_light (enemy))	1749	if (!stand_in_light (enemy))
1771	{	1750	{
1772	/* on dark maps body heat can help indicate location with infravision	1751	/* on dark maps body heat can help indicate location with infravision
1773	* undead don't have body heat, so no benefit detecting them.	1752	* undead don't have body heat, so no benefit detecting them.
1774	*/	1753	*/
1775	if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !is_true_undead (enemy))	1754	if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !is_true_undead (enemy))
1776	radius += op->map->darkness / 2;	1755	radius += op->map->darklevel () / 2;
1777	else	1756	else
1778	radius -= op->map->darkness / 2;	1757	radius -= op->map->darklevel () / 2;
1779		1758
1780	/* op next to a monster (and not in complete darkness)	1759	/* op next to a monster (and not in complete darkness)
1781	* the monster should have a chance to see you.	1760	* the monster should have a chance to see you.
1782	*/	1761	*/
1783	if (radius < MIN_MON_RADIUS && op->map->darkness < 5 && rv->distance <= 1)	1762	if (radius < MIN_MON_RADIUS && op->map->darklevel () < MAX_DARKNESS && rv->distance <= 1)
1784	radius = MIN_MON_RADIUS;	1763	radius = MIN_MON_RADIUS;
1785	} /* if on dark map */	1764	} /* if on dark map */
1786		1765
1787	/* Lets not worry about monsters that have incredible detection	1766	/* Lets not worry about monsters that have incredible detection
1788	* radii, we only need to worry here about things the player can	1767	* radii, we only need to worry here about things the player can
…		…
1790	* may have for their map - in that way, creatures at the edge will	1769	* may have for their map - in that way, creatures at the edge will
1791	* do something. Note that the distance field in the	1770	* do something. Note that the distance field in the
1792	* vector is real distance, so in theory this should be 18 to	1771	* vector is real distance, so in theory this should be 18 to
1793	* find that.	1772	* find that.
1794	*/	1773	*/
1795	if (radius > 13)	1774	// note that the above reasoning was utter bullshit even at the time it was written
1796	radius = 13;	1775	// we use 25, lets see if we have the cpu time for it
		1776	radius = min (25, radius);
1797		1777
1798	/* Enemy in range! Now test for detection */	1778	/* Enemy in range! Now test for detection */
1799	if ((int) rv->distance <= radius)	1779	if (rv->distance <= radius)
1800	{	1780	{
1801	/* ah, we are within range, detected? take cases */	1781	/* ah, we are within range, detected? take cases */
1802	if (!enemy->invisible) /* enemy in dark squares... are seen! */	1782	if (!enemy->invisible) /* enemy in dark squares... are seen! */
1803	return 1;	1783	return 1;
1804		1784
1805	/* hidden or low-quality invisible */	1785	/* hidden or low-quality invisible */
1806	if (enemy->hide && (rv->distance <= 1) && (RANDOM () % 100 <= hide_discovery))	1786	if (enemy->flag [FLAG_HIDDEN] && rv->distance <= 1 && rndm (100) <= hide_discovery)
1807	{	1787	{
1808	make_visible (enemy);	1788	make_visible (enemy);
		1789
1809	/* inform players of new status */	1790	/* inform players of new status */
1810	if (enemy->type == PLAYER && player_can_view (enemy, op))	1791	if (enemy->type == PLAYER && player_can_view (enemy, op))
1811	new_draw_info_format (NDI_UNIQUE, 0, enemy, "You are discovered by %s!", &op->name);	1792	new_draw_info_format (NDI_UNIQUE, 0, enemy, "You are discovered by %s!", &op->name);
		1793
1812	return 1; /* detected enemy */	1794	return 1; /* detected enemy */
1813	}	1795	}
1814	else if (enemy->invisible)	1796	else if (enemy->invisible)
1815	{	1797	{
1816	/* Change this around - instead of negating the invisible, just	1798	/* Change this around - instead of negating the invisible, just
1817	* return true so that the mosnter that managed to detect you can	1799	* return true so that the monster that managed to detect you can
1818	* do something to you. Decreasing the duration of invisible	1800	* do something to you. Decreasing the duration of invisible
1819	* doesn't make a lot of sense IMO, as a bunch of stupid creatures	1801	* doesn't make a lot of sense IMO, as a bunch of stupid creatures
1820	* can then basically negate the spell. The spell isn't negated -	1802	* can then basically negate the spell. The spell isn't negated -
1821	* they just know where you are!	1803	* they just know where you are!
1822	*/	1804	*/
1823	if ((RANDOM () % 50) <= hide_discovery)	1805	if (rndm (50) <= hide_discovery)
1824	{	1806	{
1825	if (enemy->type == PLAYER)	1807	if (enemy->type == PLAYER)
1826	{
1827	new_draw_info_format (NDI_UNIQUE, 0, enemy, "You see %s noticing your position.", query_name (op));	1808	new_draw_info_format (NDI_UNIQUE, 0, enemy, "You see %s noticing your position.", query_name (op));
1828	}	1809
1829	return 1;	1810	return 1;
1830	}	1811	}
1831	}	1812	}
1832	} /* within range */	1813	} /* within range */
1833		1814
1834	/* Wasn't detected above, so still hidden */	1815	/* Wasn't detected above, so still hidden */
1835	return 0;	1816	return 0;
1836	}	1817	}
1837		1818
1838	/* determine if op stands in a lighted square. This is not a very	1819	/* determine if op stands in a lighted square. This is not a very
1839	* intellegent algorithm. For one thing, we ignore los here, SO it	1820	* intelligent algorithm. For one thing, we ignore los here, SO it
1840	* is possible for a bright light to illuminate a player on the	1821	* is possible for a bright light to illuminate a player on the
1841	* other side of a wall (!).	1822	* other side of a wall (!).
1842	*/	1823	*/
1843
1844	int	1824	int
1845	stand_in_light (object *op)	1825	stand_in_light (object *op)
1846	{	1826	{
1847	sint16 nx, ny;
1848	mapstruct *m;
1849
1850
1851	if (!op)	1827	if (op)
		1828	{
		1829	if (!op->is_on_map ())
1852	return 0;	1830	return 0;
		1831
		1832	if (op->map->darklevel () <= 0)
		1833	return 1;
		1834
1853	if (op->glow_radius > 0)	1835	if (op->glow_radius > 0)
1854	return 1;	1836	return 1;
1855		1837
1856	if (op->map)	1838	if (op->map)
1857	{	1839	unordered_mapwalk (op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)
1858	int x, y, x1, y1;	1840	{
1859
1860
1861
1862	/* Check the spaces with the max light radius to see if any of them	1841	/* Check the spaces with the max light radius to see if any of them
1863	* have lights, and if any of them light the player enough, then return 1.	1842	* have lights, and if any of them light the player enough, then return 1.
1864	*/
1865	for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++)
1866	{
1867	for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++)
1868	{	1843	*/
1869	m = op->map;	1844	int light = m->at (nx, ny).light;
1870	nx = x;
1871	ny = y;
1872		1845
1873	if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)	1846	if (expect_false (light > 0) && idistance (dx, dy) <= light)
1874	continue;
1875
1876	x1 = abs (x - op->x) * abs (x - op->x);
1877	y1 = abs (y - op->y) * abs (y - op->y);
1878	if (isqrt (x1 + y1) < GET_MAP_LIGHT (m, nx, ny))
1879	return 1;	1847	return 1;
1880	}	1848	}
1881	}
1882	}	1849	}
		1850
1883	return 0;	1851	return 0;
1884	}	1852	}
1885
1886		1853
1887	/* assuming no walls/barriers, lets check to see if its *possible*	1854	/* assuming no walls/barriers, lets check to see if its *possible*
1888	* to see an enemy. Note, "detection" is different from "seeing".	1855	* to see an enemy. Note, "detection" is different from "seeing".
1889	* See can_detect_enemy() for more details. -b.t.	1856	* See can_detect_enemy() for more details. -b.t.
1890	* return 0 if can't be seen, 1 if can be	1857	* return 0 if can't be seen, 1 if can be
1891	*/	1858	*/
1892
1893	int	1859	int
1894	can_see_enemy (object *op, object *enemy)	1860	can_see_enemy (object *op, object *enemy)
1895	{	1861	{
1896	object *looker = op->head ? op->head : op;	1862	object *looker = op->head ? op->head : op;
1897		1863
…		…
1911	{	1877	{
1912	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!	1878	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1913	* However,if you carry any source of light, then the hidden	1879	* However,if you carry any source of light, then the hidden
1914	* creature is seeable (and stupid) */	1880	* creature is seeable (and stupid) */
1915		1881
1916	if (has_carried_lights (enemy))	1882	if (enemy->has_carried_lights ())
1917	{	1883	{
1918	if (enemy->hide)	1884	if (enemy->flag [FLAG_HIDDEN])
1919	{	1885	{
1920	make_visible (enemy);	1886	make_visible (enemy);
1921	new_draw_info (NDI_UNIQUE, 0, enemy, "Your light reveals your hiding spot!");	1887	new_draw_info (NDI_UNIQUE, 0, enemy, "Your light reveals your hiding spot!");
1922	}	1888	}
		1889
1923	return 1;	1890	return 1;
1924	}	1891	}
1925	else if (enemy->hide)	1892	else if (enemy->flag [FLAG_HIDDEN])
1926	return 0;	1893	return 0;
1927		1894
1928	/* Invisible enemy. Break apart the check for invis undead/invis looker	1895	/* Invisible enemy. Break apart the check for invis undead/invis looker
1929	* into more simple checks - the QUERY_FLAG doesn't return 1/0 values,	1896	* into more simple checks - the QUERY_FLAG doesn't return 1/0 values,
1930	* and making it a conditional makes the code pretty ugly.	1897	* and making it a conditional makes the code pretty ugly.
1931	*/	1898	*/
1932	if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))	1899	if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))
1933	{
1934	if (makes_invisible_to (enemy, looker))	1900	if (makes_invisible_to (enemy, looker))
1935	return 0;	1901	return 0;
1936	}
1937	}	1902	}
1938	else if (looker->type == PLAYER) /* for players, a (possible) shortcut */	1903	else if (looker->is_player ()) /* for players, a (possible) shortcut */
1939	if (player_can_view (looker, enemy))	1904	if (player_can_view (looker, enemy))
1940	return 1;	1905	return 1;
1941		1906
1942	/* ENEMY IN DARK MAP. Without infravision, the enemy is not seen	1907	/* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
1943	* unless they carry a light or stand in light. Darkness doesnt	1908	* unless they carry a light or stand in light. Darkness doesnt
…		…
1946	* we care about the enemy maps status, not the looker.	1911	* we care about the enemy maps status, not the looker.
1947	* only relevant for tiled maps, but it is possible that the	1912	* only relevant for tiled maps, but it is possible that the
1948	* enemy is on a bright map and the looker on a dark - in that	1913	* enemy is on a bright map and the looker on a dark - in that
1949	* case, the looker can still see the enemy	1914	* case, the looker can still see the enemy
1950	*/	1915	*/
1951	if (enemy->map->darkness > 0 && !stand_in_light (enemy)	1916	if (!stand_in_light (enemy)
1952	&& (!QUERY_FLAG (looker, FLAG_SEE_IN_DARK) || !is_true_undead (looker) || !QUERY_FLAG (looker, FLAG_XRAYS)))	1917	&& (!QUERY_FLAG (looker, FLAG_SEE_IN_DARK) || !is_true_undead (looker) || !QUERY_FLAG (looker, FLAG_XRAYS)))
1953	return 0;	1918	return 0;
1954		1919
1955	return 1;	1920	return 1;
1956	}	1921	}
		1922

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines