[ViewVC] Diff of: cvs/deliantra/server/server/monster.C

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.27 by root, Mon Apr 30 04:25:30 2007 UTC vs.
Revision 1.65 by root, Fri Sep 25 18:44:58 2009 UTC

…		…
1	/*	1	/*
2	* CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	22	*/
24		23
25	#include <global.h>	24	#include <global.h>
26	#include <sproto.h>	25	#include <sproto.h>
27	#include <spells.h>	26	#include <spells.h>
36	* set to sane values.	35	* set to sane values.
37	*/	36	*/
38	object *	37	object *
39	check_enemy (object npc, rv_vector rv)	38	check_enemy (object npc, rv_vector rv)
40	{	39	{
41
42	/* if this is pet, let him attack the same enemy as his owner	40	/* if this is pet, let him attack the same enemy as his owner
43	* TODO: when there is no ower enemy, try to find a target,	41	* TODO: when there is no ower enemy, try to find a target,
44	* which CAN attack the owner. */	42	* which CAN attack the owner. */
45	if ((npc->attack_movement & HI4) == PETMOVE)	43	if ((npc->attack_movement & HI4) == PETMOVE)
46	{	44	{
…		…
92	&& npc->enemy->type != PLAYER	90	&& npc->enemy->type != PLAYER
93	&& npc->enemy->type != GOLEM)	91	&& npc->enemy->type != GOLEM)
94	npc->enemy = NULL;	92	npc->enemy = NULL;
95		93
96	}	94	}
		95
97	return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : NULL;	96	return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : NULL;
98	}	97	}
99		98
100	/* Returns the nearest living creature (monster or generator).	99	/* Returns the nearest living creature (monster or generator).
101	* Modified to deal with tiled maps properly.	100	* Modified to deal with tiled maps properly.
…		…
145	}	144	}
146		145
147	return 0;	146	return 0;
148	}	147	}
149		148
150
151	/* 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
152	* our caller will find the information useful.	150	* our caller will find the information useful.
153	* Currently, only move_monster calls this function.	151	* Currently, only move_monster calls this function.
154	* Fix function so that we always make calls to get_rangevector	152	* Fix function so that we always make calls to get_rangevector
155	* 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
156	* many cases.	154	* many cases.
157	*/	155	*/
158
159	object *	156	object *
160	find_enemy (object npc, rv_vector rv)	157	find_enemy (object npc, rv_vector rv)
161	{	158	{
162	object attacker, tmp = NULL;	159	object attacker, tmp = NULL;
163		160
…		…
169	{	166	{
170	tmp = find_nearest_living_creature (npc);	167	tmp = find_nearest_living_creature (npc);
171		168
172	if (tmp)	169	if (tmp)
173	get_rangevector (npc, tmp, rv, 0);	170	get_rangevector (npc, tmp, rv, 0);
		171
174	return tmp;	172	return tmp;
175	}	173	}
176		174
177	/* Here is the main enemy selection.	175	/* Here is the main enemy selection.
178	* 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
…		…
198	/* we check our old enemy. */	196	/* we check our old enemy. */
199	if (!(tmp = check_enemy (npc, rv)))	197	if (!(tmp = check_enemy (npc, rv)))
200	{	198	{
201	if (attacker) /* if we have an attacker, check him */	199	if (attacker) /* if we have an attacker, check him */
202	{	200	{
203	/* TODO: thats not finished */	201	/* TODO: that's not finished */
204	/* 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 */
205		203
206	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 */
207	(QUERY_FLAG (npc, FLAG_FRIENDLY) && QUERY_FLAG (attacker, FLAG_FRIENDLY)) \|\|	205	(QUERY_FLAG (npc, FLAG_FRIENDLY) && QUERY_FLAG (attacker, FLAG_FRIENDLY)) \|\|
208	(!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)))
209	CLEAR_FLAG (npc, FLAG_SLEEP); /* skip it, but lets wakeup */	207	CLEAR_FLAG (npc, FLAG_SLEEP); /* skip it, but lets wakeup */
210	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... */
211	{	209	{
212	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! */
213	npc->enemy = attacker;	211	npc->enemy = attacker;
214	return attacker; /* yes, we face our attacker! */	212	return attacker; /* yes, we face our attacker! */
215	}	213	}
…		…
231	/* Sees if this monster should wake up.	229	/* Sees if this monster should wake up.
232	* Currently, this is only called from move_monster, and	230	* Currently, this is only called from move_monster, and
233	* if enemy is set, then so should be rv.	231	* if enemy is set, then so should be rv.
234	* returns 1 if the monster should wake up, 0 otherwise.	232	* returns 1 if the monster should wake up, 0 otherwise.
235	*/	233	*/
236
237	int	234	int
238	check_wakeup (object op, object enemy, rv_vector * rv)	235	check_wakeup (object op, object enemy, rv_vector *rv)
239	{	236	{
240	int radius = op->stats.Wis > MIN_MON_RADIUS ? op->stats.Wis : MIN_MON_RADIUS;
241
242	/* Trim work - if no enemy, no need to do anything below */	237	/* Trim work - if no enemy, no need to do anything below */
243	if (!enemy)	238	if (!enemy)
244	return 0;	239	return 0;
245		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])
246	/* blinded monsters can only find nearby objects to attack */	247	/* blinded monsters can only find nearby objects to attack */
247	if (QUERY_FLAG (op, FLAG_BLIND))
248	radius = MIN_MON_RADIUS;	248	radius = MIN_MON_RADIUS;
249		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]))
250	/* This covers the situation where the monster is in the dark	253	/* This covers the situation where the monster is in the dark
251	* 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
252	* glowing!) then the monster has trouble finding the enemy.	255	* glowing!) then the monster has trouble finding the enemy.
253	* 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
254	* the dark. */	257	* the dark. */
		258	radius = min (radius, MIN_MON_RADIUS + MAX_DARKNESS - op->map->darklevel ());
255		259
256	else if (op->map && op->map->darkness > 0 && enemy && !enemy->invisible &&	260	if (enemy->flag [FLAG_STEALTH])
257	!stand_in_light (enemy) && (!QUERY_FLAG (op, FLAG_SEE_IN_DARK) \|\| !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))	261	radius = radius / 2 + 1;
258	{
259	int dark = radius / (op->map->darkness);
260
261	radius = (dark > MIN_MON_RADIUS) ? (dark + 1) : MIN_MON_RADIUS;
262	}
263	else if (!QUERY_FLAG (op, FLAG_SLEEP))
264	return 1;
265		262
266	/* 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
267	* for that.	264	* for that.
268	*/	265	*/
269	if (rv->distance < (unsigned int) (QUERY_FLAG (enemy, FLAG_STEALTH) ? (radius / 2) + 1 : radius))	266	if (rv->distance <= radius)
270	{	267	{
271	CLEAR_FLAG (op, FLAG_SLEEP);	268	CLEAR_FLAG (op, FLAG_SLEEP);
272	return 1;	269	return 1;
273	}	270	}
		271
274	return 0;	272	return 0;
275	}	273	}
276		274
277	int	275	int
278	move_randomly (object *op)	276	move_randomly (object *op)
279	{	277	{
280	int i;
281
282	/* Give up to 15 chances for a monster to move randomly */	278	/* Give up to 15 chances for a monster to move randomly */
283	for (i = 0; i < 15; i++)	279	for (int i = 0; i < 15; i++)
284	{
285	if (move_object (op, rndm (8) + 1))	280	if (move_object (op, rndm (8) + 1))
286	return 1;	281	return 1;
287	}	282
288	return 0;	283	return 0;
289	}	284	}
290		285
291	/*	286	/*
292	* 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.
293	*/	288	*/
294
295	int	289	int
296	move_monster (object *op)	290	move_monster (object *op)
297	{	291	{
298	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 */
299	object owner, enemy, part, oph = op;	293	object owner, enemy, part, oph = op;
…		…
316	enemy->attacked_by = op; /* our ptr */	310	enemy->attacked_by = op; /* our ptr */
317		311
318	/* generate hp, if applicable */	312	/* generate hp, if applicable */
319	if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)	313	if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)
320	{	314	{
321
322	/* last heal is in funny units. Dividing by speed puts	315	/* last heal is in funny units. Dividing by speed puts
323	* the regeneration rate on a basis of time instead of	316	* the regeneration rate on a basis of time instead of
324	* #moves the monster makes. The scaling by 8 is	317	* #moves the monster makes. The scaling by 8 is
325	* to capture 8th's of a hp fraction regens	318	* to capture 8th's of a hp fraction regens
326	*	319	*
…		…
331	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));
332	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 */
333	op->last_heal %= 32;	326	op->last_heal %= 32;
334		327
335	/* 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 */
336	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))
337	CLEAR_FLAG (op, FLAG_RUN_AWAY);	330	CLEAR_FLAG (op, FLAG_RUN_AWAY);
338		331
339	if (op->stats.hp > op->stats.maxhp)	332	if (op->stats.hp > op->stats.maxhp)
340	op->stats.hp = op->stats.maxhp;	333	op->stats.hp = op->stats.maxhp;
341	}	334	}
342		335
343	/* generate sp, if applicable */	336	/* generate sp, if applicable */
344	if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)	337	if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)
345	{	338	{
346
347	/* last_sp is in funny units. Dividing by speed puts	339	/* last_sp is in funny units. Dividing by speed puts
348	* the regeneration rate on a basis of time instead of	340	* the regeneration rate on a basis of time instead of
349	* #moves the monster makes. The scaling by 8 is	341	* #moves the monster makes. The scaling by 8 is
350	* to capture 8th's of a sp fraction regens	342	* to capture 8th's of a sp fraction regens
351	*	343	*
352	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)	344	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)
353	* overflow might produce monsters with negative sp.	345	* overflow might produce monsters with negative sp.
354	*/	346	*/
355		347
356	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));
357	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 */
358	op->last_sp %= 128;	350	op->last_sp %= 128;
359	}	351	}
360		352
361	/* this should probably get modified by many more values.	353	/* this should probably get modified by many more values.
362	* (eg, creatures resistance to fear, level, etc. )	354	* (eg, creatures resistance to fear, level, etc. )
363	*/	355	*/
364	if (QUERY_FLAG (op, FLAG_SCARED) && !(rndm (20)))	356	if (QUERY_FLAG (op, FLAG_SCARED) && !(rndm (20)))
365	{
366	CLEAR_FLAG (op, FLAG_SCARED); /* Time to regain some "guts"... */	357	CLEAR_FLAG (op, FLAG_SCARED); /* Time to regain some "guts"... */
367	}
368		358
369	if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))	359	if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))
370	return QUERY_FLAG (op, FLAG_FREED);	360	return QUERY_FLAG (op, FLAG_FREED);
371		361
372	if (QUERY_FLAG (op, FLAG_SLEEP) \|\| QUERY_FLAG (op, FLAG_BLIND) \|\|	362	if (QUERY_FLAG (op, FLAG_SLEEP) \|\| QUERY_FLAG (op, FLAG_BLIND) \|\|
373	((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)))
374	{
375	if (!check_wakeup (op, enemy, &rv))	364	if (!check_wakeup (op, enemy, &rv))
376	return 0;	365	return 0;
377	}
378		366
379	/* check if monster pops out of hidden spot */	367	/* check if monster pops out of hidden spot */
380	if (op->hide)	368	if (op->flag [FLAG_HIDDEN])
381	do_hidden_move (op);	369	do_hidden_move (op);
382		370
383	if (op->pick_up)	371	if (op->pick_up)
384	monster_check_pickup (op);	372	monster_check_pickup (op);
385		373
…		…
389	/* 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 */
390	if (!enemy)	378	if (!enemy)
391	{	379	{
392	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))	380	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
393	{	381	{
394	op->destroy ();	382	op->drop_and_destroy ();
395	return 1;	383	return 1;
396	}	384	}
397		385
398	/* Probably really a bug for a creature to have both	386	/* Probably really a bug for a creature to have both
399	* stand still and a movement type set.	387	* stand still and a movement type set.
…		…
402	{	390	{
403	if (op->attack_movement & HI4)	391	if (op->attack_movement & HI4)
404	{	392	{
405	switch (op->attack_movement & HI4)	393	switch (op->attack_movement & HI4)
406	{	394	{
407	case (PETMOVE):	395	case PETMOVE:
408	pet_move (op);	396	pet_move (op);
409	break;	397	break;
410		398
411	case (CIRCLE1):	399	case CIRCLE1:
412	circ1_move (op);	400	circ1_move (op);
413	break;	401	break;
414		402
415	case (CIRCLE2):	403	case CIRCLE2:
416	circ2_move (op);	404	circ2_move (op);
417	break;	405	break;
418		406
419	case (PACEV):	407	case PACEV:
420	pace_movev (op);	408	pace_movev (op);
421	break;	409	break;
422		410
423	case (PACEH):	411	case PACEH:
424	pace_moveh (op);	412	pace_moveh (op);
425	break;	413	break;
426		414
427	case (PACEV2):	415	case PACEV2:
428	pace2_movev (op);	416	pace2_movev (op);
429	break;	417	break;
430		418
431	case (PACEH2):	419	case PACEH2:
432	pace2_moveh (op);	420	pace2_moveh (op);
433	break;	421	break;
434		422
435	case (RANDO):	423	case RANDO:
436	rand_move (op);	424	rand_move (op);
437	break;	425	break;
438		426
439	case (RANDO2):	427	case RANDO2:
440	move_randomly (op);	428	move_randomly (op);
441	break;	429	break;
442	}	430	}
		431
443	return 0;	432	return 0;
444	}	433	}
445	else if (QUERY_FLAG (op, FLAG_RANDOM_MOVE))	434	else if (QUERY_FLAG (op, FLAG_RANDOM_MOVE))
446	(void) move_randomly (op);	435	move_randomly (op);
447
448	} /* stand still */	436	} /* stand still */
		437
449	return 0;	438	return 0;
450	} /* no enemy */	439	} /* no enemy */
451		440
452	/* We have an enemy. Block immediately below is for pets */	441	/* We have an enemy. Block immediately below is for pets */
453	if ((op->attack_movement & HI4) == PETMOVE	442	if ((op->attack_movement & HI4) == PETMOVE
…		…
455	&& !on_same_map (op, owner)	444	&& !on_same_map (op, owner)
456	&& !owner->flag [FLAG_REMOVED])	445	&& !owner->flag [FLAG_REMOVED])
457	return follow_owner (op, owner);	446	return follow_owner (op, owner);
458		447
459	/* doppleganger code to change monster facing to that of the nearest	448	/* doppleganger code to change monster facing to that of the nearest
460	* 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
461	* arch set uses it.	450	* arch set uses it.
462	*/	451	*/
463	if ((op->race != NULL) && strcmp (op->race, "doppleganger") == 0)	452	if (op->race == shstr_doppleganger)
464	{	453	{
465	op->face = enemy->face;	454	op->face = enemy->face;
466	op->name = enemy->name;	455	op->name = enemy->name;
467	}	456	}
468		457
…		…
480	if (!QUERY_FLAG (op, FLAG_SCARED))	469	if (!QUERY_FLAG (op, FLAG_SCARED))
481	{	470	{
482	rv_vector rv1;	471	rv_vector rv1;
483		472
484	/* 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 */
485	for (part = op; part != NULL; part = part->more)	474	for (part = op; part; part = part->more)
486	{	475	{
487	get_rangevector (part, enemy, &rv1, 0x1);	476	get_rangevector (part, enemy, &rv1, 0x1);
488	dir = rv1.direction;	477	dir = rv1.direction;
489		478
490	/* 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
491	* but that we test above... so can be old code here	480	* but that we test above... so can be old code here
492	*/	481	*/
493	if (QUERY_FLAG (op, FLAG_RUN_AWAY))	482	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
494	dir = absdir (dir + 4);	483	dir = absdir (dir + 4);
		484
495	if (QUERY_FLAG (op, FLAG_CONFUSED))	485	if (QUERY_FLAG (op, FLAG_CONFUSED))
496	dir = absdir (dir + rndm (3) + rndm (3) - 2);	486	dir = absdir (dir + rndm (3) + rndm (3) - 2);
497		487
498	if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(rndm (3)))	488	if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(rndm (3)))
499	{
500	if (monster_cast_spell (op, part, enemy, dir, &rv1))	489	if (monster_cast_spell (op, part, enemy, dir, &rv1))
501	return 0;	490	return 0;
502	}
503		491
504	if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(rndm (3)))	492	if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(rndm (3)))
505	{
506	if (monster_use_scroll (op, part, enemy, dir, &rv1))	493	if (monster_use_scroll (op, part, enemy, dir, &rv1))
507	return 0;	494	return 0;
508	}
509		495
510	if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(rndm (3)))	496	if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(rndm (3)))
511	{
512	if (monster_use_range (op, part, enemy, dir))	497	if (monster_use_range (op, part, enemy, dir))
513	return 0;	498	return 0;
514	}	499
515	if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(rndm (3)))	500	if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(rndm (3)))
516	{
517	if (monster_use_skill (op, rv.part, enemy, rv.direction))	501	if (monster_use_skill (op, rv.part, enemy, rv.direction))
518	return 0;	502	return 0;
519	}	503
520	if (QUERY_FLAG (op, FLAG_READY_BOW) && !(rndm (2)))	504	if (QUERY_FLAG (op, FLAG_READY_BOW) && !(rndm (2)))
521	{
522	if (monster_use_bow (op, part, enemy, dir))	505	if (monster_use_bow (op, part, enemy, dir))
523	return 0;	506	return 0;
524	}
525	} /* for processing of all parts */	507	} /* for processing of all parts */
526	} /* If not scared */	508	} /* If not scared */
527		509
528
529	part = rv.part;	510	part = rv.part;
530	dir = rv.direction;	511	dir = rv.direction;
531		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
532	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))
533	dir = absdir (dir + 4);	558	dir = absdir (dir + 4);
534		559
535	if (QUERY_FLAG (op, FLAG_CONFUSED))	560	if (QUERY_FLAG (op, FLAG_CONFUSED))
536	dir = absdir (dir + rndm (3) + rndm (3) - 2);	561	dir = absdir (dir + rndm (3) + rndm (3) - 2);
…		…
539		564
540	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))	565	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))
541	{	566	{
542	switch (op->attack_movement & LO4)	567	switch (op->attack_movement & LO4)
543	{	568	{
544	case DISTATT:	569	case DISTATT:
545	dir = dist_att (dir, op, enemy, part, &rv);	570	dir = dist_att (dir, op, enemy, part, &rv);
546	break;	571	break;
547		572
548	case RUNATT:	573	case RUNATT:
549	dir = run_att (dir, op, enemy, part, &rv);	574	dir = run_att (dir, op, enemy, part, &rv);
550	break;	575	break;
551		576
552	case HITRUN:	577	case HITRUN:
553	dir = hitrun_att (dir, op, enemy);	578	dir = hitrun_att (dir, op, enemy);
554	break;	579	break;
555		580
556	case WAITATT:	581	case WAITATT:
557	dir = wait_att (dir, op, enemy, part, &rv);	582	dir = wait_att (dir, op, enemy, part, &rv);
558	break;	583	break;
559		584
560	case RUSH: /* default - monster normally moves towards player */	585	case RUSH: /* default - monster normally moves towards player */
561	case ALLRUN:	586	case ALLRUN:
562	break;	587	break;
563		588
564	case DISTHIT:	589	case DISTHIT:
565	dir = disthit_att (dir, op, enemy, part, &rv);	590	dir = disthit_att (dir, op, enemy, part, &rv);
566	break;	591	break;
567		592
568	case WAIT2:	593	case WAIT2:
569	dir = wait_att2 (dir, op, enemy, part, &rv);	594	dir = wait_att2 (dir, op, enemy, part, &rv);
570	break;	595	break;
571		596
572	default:	597	default:
573	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);
574	}	599	}
575	}	600	}
576		601
577	if (!dir)	602	if (!dir)
578	return 0;	603	return 0;
…		…
588	return 0;	613	return 0;
589	}	614	}
590		615
591	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))
592	{	617	{
593
594	/* Try move around corners if !close */	618	/* Try move around corners if !close */
595	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;
596		620
597	for (diff = 1; diff <= maxdiff; diff++)	621	for (diff = 1; diff <= maxdiff; diff++)
598	{	622	{
599	/* try different detours */	623	/* try different detours */
600	int m = 1 - (RANDOM () & 2); /* Try left or right first? */	624	int m = 1 - rndm (2) * 2; /* Try left or right first? */
601		625
602	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)))
603	return 0;	627	return 0;
604	}	628	}
605	}	629	}
…		…
632	{	656	{
633	object *nearest_player = get_nearest_player (op);	657	object *nearest_player = get_nearest_player (op);
634		658
635	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))	659	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))
636	{	660	{
637	op->enemy = NULL;	661	op->enemy = 0;
638	enemy = nearest_player;	662	enemy = nearest_player;
639	}	663	}
640	}	664	}
641		665
642	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))	666	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))
…		…
648	* still be pretty nasty.	672	* still be pretty nasty.
649	*/	673	*/
650	if (QUERY_FLAG (op, FLAG_RUN_AWAY))	674	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
651	{	675	{
652	part->stats.wc += 10;	676	part->stats.wc += 10;
653	(void) skill_attack (enemy, part, 0, NULL, NULL);	677	skill_attack (enemy, part, 0, NULL, NULL);
654	part->stats.wc -= 10;	678	part->stats.wc -= 10;
655	}	679	}
656	else	680	else
657	(void) skill_attack (enemy, part, 0, NULL, NULL);	681	skill_attack (enemy, part, 0, NULL, NULL);
658	} /* if monster is in attack range */	682	} /* if monster is in attack range */
659		683
660	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 */
661	return 1;	685	return 1;
662		686
663	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))	687	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
664	{	688	{
665	op->remove ();
666	op->destroy ();	689	op->drop_and_destroy ();
667	return 1;	690	return 1;
668	}	691	}
		692
669	return 0;	693	return 0;
670	}	694	}
671		695
672	int	696	int
673	can_hit (object ob1, object ob2, rv_vector * rv)	697	can_hit (object ob1, object ob2, rv_vector * rv)
…		…
688	{	712	{
689	get_rangevector (ob1, more, &rv1, 0);	713	get_rangevector (ob1, more, &rv1, 0);
690	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)	714	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
691	return 1;	715	return 1;
692	}	716	}
		717
693	return 0;	718	return 0;
694
695	}	719	}
696		720
697	/* Returns 1 is monster should cast spell sp at an enemy	721	/* Returns 1 is monster should cast spell sp at an enemy
698	* Returns 0 if the monster should not cast this spell.	722	* Returns 0 if the monster should not cast this spell.
699	*	723	*
…		…
717	spell_ob->subtype == SP_EXPLOSION \|\| spell_ob->subtype == SP_CONE \|\|	741	spell_ob->subtype == SP_EXPLOSION \|\| spell_ob->subtype == SP_CONE \|\|
718	spell_ob->subtype == SP_BOMB \|\| spell_ob->subtype == SP_SMITE \|\|	742	spell_ob->subtype == SP_BOMB \|\| spell_ob->subtype == SP_SMITE \|\|
719	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 \|\|
720	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 \|\|
721	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)
722
723	return 1;	746	return 1;
724		747
725	return 0;	748	return 0;
726	}	749	}
727
728		750
729	#define MAX_KNOWN_SPELLS 20	751	#define MAX_KNOWN_SPELLS 20
730		752
731	/* Returns a randomly selected spell. This logic is still	753	/* Returns a randomly selected spell. This logic is still
732	* less than ideal. This code also only seems to deal with	754	* less than ideal. This code also only seems to deal with
…		…
735	*/	757	*/
736	object *	758	object *
737	monster_choose_random_spell (object *monster)	759	monster_choose_random_spell (object *monster)
738	{	760	{
739	object *altern[MAX_KNOWN_SPELLS];	761	object *altern[MAX_KNOWN_SPELLS];
740	object *tmp;
741	int i = 0;	762	int i = 0;
742		763
743	for (tmp = monster->inv; tmp != NULL; tmp = tmp->below)	764	for (object *tmp = monster->inv; tmp; tmp = tmp->below)
744	if (tmp->type == SPELLBOOK \|\| tmp->type == SPELL)	765	if (tmp->type == SPELLBOOK \|\| tmp->type == SPELL)
745	{	766	{
746	/* Check and see if it's actually a useful spell.	767	/* Check and see if it's actually a useful spell.
747	* If its a spellbook, the spell is actually the inventory item.	768	* If its a spellbook, the spell is actually the inventory item.
748	* 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.
749	*/	770	*/
750	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))
751	{	772	{
752	altern[i++] = tmp;	773	altern [i++] = tmp;
		774
753	if (i == MAX_KNOWN_SPELLS)	775	if (i == MAX_KNOWN_SPELLS)
754	break;	776	break;
755	}	777	}
756	}	778	}
757	if (!i)	779
758	return NULL;	780	return i ? altern [rndm (i)] : 0;
759	return altern[RANDOM () % i];
760	}	781	}
761		782
762	/* 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.
763	* 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.
764	* head is the head of the monster.	785	* head is the head of the monster.
765	* part is the part of the monster we are checking against.	786	* part is the part of the monster we are checking against.
766	* pl is the target.	787	* pl is the target.
767	* dir is the direction to case.	788	* dir is the direction to case.
768	* rv is the vector which describes where the enemy is.	789	* rv is the vector which describes where the enemy is.
769	*/	790	*/
770
771	int	791	int
772	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)
773	{	793	{
774	object *spell_item;	794	object *spell_item;
775	object *owner;	795	object *owner;
…		…
786		806
787	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)	807	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
788	{	808	{
789	get_rangevector (head, owner, &rv1, 0x1);	809	get_rangevector (head, owner, &rv1, 0x1);
790	if (dirdiff (dir, rv1.direction) < 2)	810	if (dirdiff (dir, rv1.direction) < 2)
791	{
792	return 0; /* Might hit owner with spell */	811	return 0; /* Might hit owner with spell */
793	}
794	}	812	}
795		813
796	if (QUERY_FLAG (head, FLAG_CONFUSED))	814	if (QUERY_FLAG (head, FLAG_CONFUSED))
797	dir = absdir (dir + rndm (3) + rndm (3) - 2);	815	dir = absdir (dir + rndm (3) + rndm (3) - 2);
798		816
…		…
806	{	824	{
807	LOG (llevMonster, "Turned off spells in %s\n", &head->name);	825	LOG (llevMonster, "Turned off spells in %s\n", &head->name);
808	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 */
809	return 0;	827	return 0;
810	}	828	}
		829
811	if (spell_item->type == SPELLBOOK)	830	if (spell_item->type == SPELLBOOK)
812	{	831	{
813	if (!spell_item->inv)	832	if (!spell_item->inv)
814	{	833	{
815	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);
816	return 0;	835	return 0;
817	}	836	}
		837
818	spell_item = spell_item->inv;	838	spell_item = spell_item->inv;
819	}	839	}
820	}	840	}
821	else	841	else
822	spell_item = head->spellitem;	842	spell_item = head->spellitem;
…		…
841	/* 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 */
842	head->spellitem = NULL;	862	head->spellitem = NULL;
843		863
844	return cast_spell (part, part, dir, spell_item, NULL);	864	return cast_spell (part, part, dir, spell_item, NULL);
845	}	865	}
846
847		866
848	int	867	int
849	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)
850	{	869	{
851	object *scroll;	870	object *scroll;
…		…
925	/* skill selection - monster will use the next unused skill.	944	/* skill selection - monster will use the next unused skill.
926	* well...the following scenario will allow the monster to	945	* well...the following scenario will allow the monster to
927	* 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
928	* more skills available to monsters.	947	* more skills available to monsters.
929	*/	948	*/
930
931	for (skill = head->inv; skill; skill = skill->below)	949	for (skill = head->inv; skill; skill = skill->below)
932	if (skill->type == SKILL && skill != head->chosen_skill)	950	if (skill->type == SKILL && skill != head->chosen_skill)
933	{	951	{
934	head->chosen_skill = skill;	952	head->chosen_skill = skill;
935	break;	953	break;
…		…
961	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);
962		980
963	if (dirdiff (dir, dir2) < 2)	981	if (dirdiff (dir, dir2) < 2)
964	return 0; /* Might hit owner with spell */	982	return 0; /* Might hit owner with spell */
965	}	983	}
		984
966	if (QUERY_FLAG (head, FLAG_CONFUSED))	985	if (QUERY_FLAG (head, FLAG_CONFUSED))
967	dir = absdir (dir + rndm (3) + rndm (3) - 2);	986	dir = absdir (dir + rndm (3) + rndm (3) - 2);
968		987
969	for (wand = head->inv; wand; wand = wand->below)	988	for (wand = head->inv; wand; wand = wand->below)
970	{	989	{
…		…
980	if (!(--wand->stats.food))	999	if (!(--wand->stats.food))
981	{	1000	{
982	if (wand->arch)	1001	if (wand->arch)
983	{	1002	{
984	CLEAR_FLAG (wand, FLAG_ANIMATE);	1003	CLEAR_FLAG (wand, FLAG_ANIMATE);
985	wand->face = wand->arch->clone.face;	1004	wand->face = wand->arch->face;
986	wand->set_speed (0);	1005	wand->set_speed (0);
987	}	1006	}
988	}	1007	}
989	/* Success */	1008	/* Success */
990	return 1;	1009	return 1;
…		…
1009	}	1028	}
1010		1029
1011	if (at_least_one)	1030	if (at_least_one)
1012	return 0;	1031	return 0;
1013		1032
1014	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);
1015	CLEAR_FLAG (head, FLAG_READY_RANGE);	1034	CLEAR_FLAG (head, FLAG_READY_RANGE);
1016	return 0;	1035	return 0;
1017	}	1036	}
1018		1037
1019	int	1038	int
…		…
1021	{	1040	{
1022	object *owner;	1041	object *owner;
1023		1042
1024	if (!(dir = path_to_player (part, pl, 0)))	1043	if (!(dir = path_to_player (part, pl, 0)))
1025	return 0;	1044	return 0;
		1045
1026	if (QUERY_FLAG (head, FLAG_CONFUSED))	1046	if (QUERY_FLAG (head, FLAG_CONFUSED))
1027	dir = absdir (dir + rndm (3) + rndm (3) - 2);	1047	dir = absdir (dir + rndm (3) + rndm (3) - 2);
1028		1048
1029	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)	1049	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
1030	{	1050	{
…		…
1038	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);
1039		1059
1040	}	1060	}
1041		1061
1042	/* Checks if putting on 'item' will make 'who' do more	1062	/* Checks if putting on 'item' will make 'who' do more
1043	* damage. This is a very simplistic check - also checking things	1063	* damage. This is a very simplistic check - also checking things
1044	* like speed and ac are also relevant.	1064	* like speed and ac are also relevant.
1045	*	1065	*
1046	* return true if item is a better object.	1066	* return true if item is a better object.
1047	*/	1067	*/
1048
1049	int	1068	int
1050	check_good_weapon (object who, object item)	1069	check_good_weapon (object who, object item)
1051	{	1070	{
1052	object *other_weap;	1071	object *other_weap;
1053	int val = 0, i;	1072	int val = 0, i;
1054		1073
1055	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)
1056	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))
1057	break;	1076	break;
1058		1077
1059	if (other_weap == NULL) /* No other weapons */	1078	if (!other_weap) /* No other weapons */
1060	return 1;	1079	return 1;
1061		1080
1062	/* 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
1063	* better, just do some simple checks	1082	* better, just do some simple checks
1064	* Put some multipliers for things that hvae several effects,	1083	* Put some multipliers for things that hvae several effects,
…		…
1069	val += (item->magic - other_weap->magic) * 3;	1088	val += (item->magic - other_weap->magic) * 3;
1070	/* Monsters don't really get benefits from things like regen rates	1089	/* Monsters don't really get benefits from things like regen rates
1071	* from items. But the bonus for their stats are very important.	1090	* from items. But the bonus for their stats are very important.
1072	*/	1091	*/
1073	for (i = 0; i < NUM_STATS; i++)	1092	for (i = 0; i < NUM_STATS; i++)
1074	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;
1075		1094
1076	if (val > 0)	1095	if (val > 0)
1077	return 1;	1096	return 1;
1078	else	1097	else
1079	return 0;	1098	return 0;
…		…
1083	check_good_armour (object who, object item)	1102	check_good_armour (object who, object item)
1084	{	1103	{
1085	object *other_armour;	1104	object *other_armour;
1086	int val = 0, i;	1105	int val = 0, i;
1087		1106
1088	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)
1089	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))
1090	break;	1109	break;
1091		1110
1092	if (other_armour == NULL) /* No other armour, use the new */	1111	if (other_armour == NULL) /* No other armour, use the new */
1093	return 1;	1112	return 1;
…		…
1215	case ROD:	1234	case ROD:
1216	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);	1235	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1217	break;	1236	break;
1218		1237
1219	case SPELLBOOK:	1238	case SPELLBOOK:
1220	flag = (monster->arch != NULL && QUERY_FLAG ((&monster->arch->clone), FLAG_CAST_SPELL));	1239	flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1221	break;	1240	break;
1222		1241
1223	case SCROLL:	1242	case SCROLL:
1224	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);	1243	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1225	break;	1244	break;
…		…
1234	* 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
1235	* use several locations.	1254	* use several locations.
1236	*/	1255	*/
1237	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1256	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1238	{	1257	{
1239	if (monster->body_info[i] && item->body_info[i])	1258	if (monster->slot[i].info && item->slot[i].info)
1240	{	1259	{
1241	flag = 1;	1260	flag = 1;
1242	break;	1261	break;
1243	}	1262	}
1244	}	1263	}
1245		1264
1246	if (((!(monster->pick_up & 32)) && flag) \|\| ((monster->pick_up & 32) && (!flag)))	1265	if (((!(monster->pick_up & 32)) && flag) \|\| ((monster->pick_up & 32) && (!flag)))
1247	return 1;	1266	return 1;
		1267
1248	return 0;	1268	return 0;
1249	}	1269	}
1250		1270
1251	/*	1271	/*
1252	* monster_apply_below():	1272	* monster_apply_below():
…		…
1294	void	1314	void
1295	monster_check_apply (object mon, object item)	1315	monster_check_apply (object mon, object item)
1296	{	1316	{
1297	int flag = 0;	1317	int flag = 0;
1298		1318
1299	if (item->type == SPELLBOOK && mon->arch && (QUERY_FLAG ((&mon->arch->clone), FLAG_CAST_SPELL)))	1319	if (item->type == SPELLBOOK && mon->arch && (QUERY_FLAG (mon->arch, FLAG_CAST_SPELL)))
1300	{	1320	{
1301	SET_FLAG (mon, FLAG_CAST_SPELL);	1321	SET_FLAG (mon, FLAG_CAST_SPELL);
1302	return;	1322	return;
1303	}	1323	}
1304		1324
…		…
1400	}	1420	}
1401		1421
1402	void	1422	void
1403	npc_call_help (object *op)	1423	npc_call_help (object *op)
1404	{	1424	{
1405	int x, y, mflags;	1425	unordered_mapwalk (op, -7, -7, 7, 7)
1406	object *npc;
1407	sint16 sx, sy;
1408	maptile *m;
1409
1410	for (x = -3; x < 4; x++)
1411	for (y = -3; y < 4; y++)
1412	{	1426	{
1413	m = op->map;	1427	mapspace &ms = m->at (nx, ny);
1414	sx = op->x + x;	1428
1415	sy = op->y + y;
1416	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1417	/* 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. */
1418	if ((mflags & P_OUT_OF_MAP) \|\| !(mflags & P_IS_ALIVE))	1430	if (!(ms.flags () & P_IS_ALIVE))
1419	continue;	1431	continue;
1420		1432
1421	for (npc = GET_MAP_OB (m, sx, sy); npc != NULL; npc = npc->above)	1433	for (object *npc = ms.bot; npc; npc = npc->above)
1422	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))	1434	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
1423	npc->enemy = op->enemy;	1435	npc->enemy = op->enemy;
1424	}	1436	}
1425	}	1437	}
1426		1438
1427	int	1439	int
1428	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)
1429	{	1441	{
1430	if (can_hit (part, enemy, rv))	1442	if (can_hit (part, enemy, rv))
1431	return dir;	1443	return dir;
		1444
1432	if (rv->distance < 10)	1445	if (rv->distance < 10)
1433	return absdir (dir + 4);	1446	return absdir (dir + 4);
1434	else if (rv->distance > 18)	1447	else if (rv->distance > 18)
1435	return dir;	1448	return dir;
1436		1449
1437	return 0;	1450	return 0;
1438	}	1451	}
1439		1452
1440	int	1453	int
1441	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)
1442	{	1455	{
1443	if ((can_hit (part, enemy, rv) && ob->move_status < 20) \|\| ob->move_status < 20)	1456	if (can_hit (part, enemy, rv))
1444	{
1445	ob->move_status++;
1446	return (dir);	1457	return dir;
1447	}	1458	else
1448	else if (ob->move_status > 20)
1449	ob->move_status = 0;
1450
1451	return absdir (dir + 4);	1459	return absdir (dir + 4);
1452	}	1460	}
1453		1461
1454	int	1462	int
1455	hitrun_att (int dir, object ob, object enemy)	1463	hitrun_att (int dir, object ob, object enemy)
1456	{	1464	{
…		…
1465	}	1473	}
1466		1474
1467	int	1475	int
1468	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)
1469	{	1477	{
1470
1471	int inrange = can_hit (part, enemy, rv);	1478	int inrange = can_hit (part, enemy, rv);
1472		1479
1473	if (ob->move_status \|\| inrange)	1480	if (ob->move_status \|\| inrange)
1474	ob->move_status++;	1481	ob->move_status++;
1475		1482
…		…
1485	}	1492	}
1486		1493
1487	int	1494	int
1488	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)
1489	{	1496	{
1490
1491	/* The logic below here looked plain wrong before. Basically, what should	1497	/* The logic below here looked plain wrong before. Basically, what should
1492	* 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,
1493	* the creature should run away (dir+4)	1499	* the creature should run away (dir+4)
1494	* 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
1495	* 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
…		…
1591	}	1597	}
1592		1598
1593	void	1599	void
1594	rand_move (object *ob)	1600	rand_move (object *ob)
1595	{	1601	{
1596	int i;
1597
1598	if (ob->move_status < 1 \|\| ob->move_status > 8 \|\| !(move_object (ob, ob->move_status \|\| !(rndm (9)))))	1602	if (ob->move_status < 1 \|\| ob->move_status > 8 \|\| !(move_object (ob, ob->move_status \|\| !(rndm (9)))))
1599	for (i = 0; i < 5; i++)	1603	for (int i = 0; i < 5; i++)
1600	if (move_object (ob, ob->move_status = rndm (8) + 1))	1604	if (move_object (ob, ob->move_status = rndm (8) + 1))
1601	return;	1605	return;
1602	}	1606	}
1603		1607
1604	void	1608	void
1605	check_earthwalls (object op, maptile m, int x, int y)	1609	check_earthwalls (object op, maptile m, int x, int y)
1606	{	1610	{
1607	object *tmp;
1608
1609	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)
1610	{
1611	if (tmp->type == EARTHWALL)	1612	if (tmp->type == EARTHWALL)
1612	{	1613	{
1613	hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);	1614	hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);
1614	return;	1615	return;
1615	}	1616	}
1616	}
1617	}	1617	}
1618		1618
1619	void	1619	void
1620	check_doors (object op, maptile m, int x, int y)	1620	check_doors (object op, maptile m, int x, int y)
1621	{	1621	{
1622	object *tmp;
1623
1624	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)
1625	{
1626	if (tmp->type == DOOR)	1623	if (tmp->type == DOOR)
1627	{	1624	{
1628	hit_player (tmp, 1000, op, AT_PHYSICAL, 1);	1625	hit_player (tmp, 1000, op, AT_PHYSICAL, 1);
1629	return;	1626	return;
1630	}	1627	}
1631	}
1632	}	1628	}
1633		1629
1634	/* find_mon_throw_ob() - modeled on find_throw_ob	1630	/* find_mon_throw_ob() - modeled on find_throw_ob
1635	* This is probably overly simplistic as it is now - We want	1631	* This is probably overly simplistic as it is now - We want
1636	* monsters to throw things like chairs and other pieces of	1632	* monsters to throw things like chairs and other pieces of
…		…
1676	* 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
1677	* 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
1678	* be within the valid range. MSW 2001-08-05	1674	* be within the valid range. MSW 2001-08-05
1679	* 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
1680	*/	1676	*/
1681
1682	int	1677	int
1683	can_detect_enemy (object op, object enemy, rv_vector * rv)	1678	can_detect_enemy (object op, object enemy, rv_vector * rv)
1684	{	1679	{
1685	int radius = MIN_MON_RADIUS, hide_discovery;
1686
1687	/* null detection for any of these condtions always */	1680	/* null detection for any of these condtions always */
1688	if (!op \|\| !enemy \|\| !op->map \|\| !enemy->map)	1681	if (!op \|\| !enemy \|\| !op->map \|\| !enemy->map)
1689	return 0;	1682	return 0;
1690		1683
1691	/* 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 */
…		…
1693	return 0;	1686	return 0;
1694		1687
1695	get_rangevector (op, enemy, rv, 0);	1688	get_rangevector (op, enemy, rv, 0);
1696		1689
1697	/* Monsters always ignore the DM */	1690	/* Monsters always ignore the DM */
1698	if ((op->type != PLAYER) && QUERY_FLAG (enemy, FLAG_WIZ))	1691	if (!op->is_player () && QUERY_FLAG (enemy, FLAG_WIZ))
1699	return 0;	1692	return 0;
1700		1693
1701	/* simple check. Should probably put some range checks in here. */	1694	/* simple check. Should probably put some range checks in here. */
1702	if (can_see_enemy (op, enemy))	1695	if (can_see_enemy (op, enemy))
1703	return 1;	1696	return 1;
1704		1697
1705	/* 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
1706	* finding enemies!	1699	* finding enemies!
1707	*/	1700	*/
1708	if (op->type == PLAYER)	1701	if (op->is_player ())
1709	return 0;	1702	return 0;
1710		1703
1711	/* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE	1704	/* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
1712	* 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
1713	*/	1706	*/
1714	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)))
1715	return 0;	1708	return 0;
1716		1709
		1710	int radius = MIN_MON_RADIUS;
		1711
1717	/* use this for invis also */	1712	/* use this for invis also */
1718	hide_discovery = op->stats.Int / 5;	1713	int hide_discovery = op->stats.Int / 5;
1719		1714
1720	/* Determine Detection radii */	1715	/* Determine Detection radii */
1721	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) */
1722	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);
1723	else	1718	else
1724	{ /* a level/INT/Dex adjustment for hiding */	1719	{ /* a level/INT/Dex adjustment for hiding */
1725	object *sk_hide;
1726	int bonus = (op->level / 2) + (op->stats.Int / 5);	1720	int bonus = op->level / 2 + op->stats.Int / 5;
1727		1721
1728	if (enemy->type == PLAYER)	1722	if (enemy->is_player ())
1729	{	1723	{
1730	if ((sk_hide = find_skill_by_number (enemy, SK_HIDING)))	1724	if (object *sk_hide = find_skill_by_number (enemy, SK_HIDING))
1731	bonus -= sk_hide->level;	1725	bonus -= sk_hide->level;
1732	else	1726	else
1733	{	1727	{
1734	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");
1735	make_visible (enemy);	1729	make_visible (enemy);
…		…
1744	} /* else creature has modifiers for hiding */	1738	} /* else creature has modifiers for hiding */
1745		1739
1746	/* Radii stealth adjustment. Only if you are stealthy	1740	/* Radii stealth adjustment. Only if you are stealthy
1747	* will you be able to sneak up closer to creatures */	1741	* will you be able to sneak up closer to creatures */
1748	if (QUERY_FLAG (enemy, FLAG_STEALTH))	1742	if (QUERY_FLAG (enemy, FLAG_STEALTH))
1749	radius = radius / 2, hide_discovery = hide_discovery / 3;	1743	{
		1744	radius /= 2;
		1745	hide_discovery /= 3;
		1746	}
1750		1747
1751	/* Radii adjustment for enemy standing in the dark */	1748	/* Radii adjustment for enemy standing in the dark */
1752	if (op->map->darkness > 0 && !stand_in_light (enemy))	1749	if (!stand_in_light (enemy))
1753	{	1750	{
1754	/* on dark maps body heat can help indicate location with infravision	1751	/* on dark maps body heat can help indicate location with infravision
1755	* undead don't have body heat, so no benefit detecting them.	1752	* undead don't have body heat, so no benefit detecting them.
1756	*/	1753	*/
1757	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))
1758	radius += op->map->darkness / 2;	1755	radius += op->map->darklevel () / 2;
1759	else	1756	else
1760	radius -= op->map->darkness / 2;	1757	radius -= op->map->darklevel () / 2;
1761		1758
1762	/* op next to a monster (and not in complete darkness)	1759	/* op next to a monster (and not in complete darkness)
1763	* the monster should have a chance to see you.	1760	* the monster should have a chance to see you.
1764	*/	1761	*/
1765	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)
1766	radius = MIN_MON_RADIUS;	1763	radius = MIN_MON_RADIUS;
1767	} /* if on dark map */	1764	} /* if on dark map */
1768		1765
1769	/* Lets not worry about monsters that have incredible detection	1766	/* Lets not worry about monsters that have incredible detection
1770	* 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
…		…
1772	* 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
1773	* do something. Note that the distance field in the	1770	* do something. Note that the distance field in the
1774	* 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
1775	* find that.	1772	* find that.
1776	*/	1773	*/
1777	if (radius > 13)	1774	// note that the above reasoning was utter bullshit even at the time it was written
1778	radius = 13;	1775	// we use 25, lets see if we have the cpu time for it
		1776	radius = min (25, radius);
1779		1777
1780	/* Enemy in range! Now test for detection */	1778	/* Enemy in range! Now test for detection */
1781	if ((int) rv->distance <= radius)	1779	if (rv->distance <= radius)
1782	{	1780	{
1783	/* ah, we are within range, detected? take cases */	1781	/* ah, we are within range, detected? take cases */
1784	if (!enemy->invisible) /* enemy in dark squares... are seen! */	1782	if (!enemy->invisible) /* enemy in dark squares... are seen! */
1785	return 1;	1783	return 1;
1786		1784
1787	/* hidden or low-quality invisible */	1785	/* hidden or low-quality invisible */
1788	if (enemy->hide && (rv->distance <= 1) && (rndm (100) <= hide_discovery))	1786	if (enemy->flag [FLAG_HIDDEN] && rv->distance <= 1 && rndm (100) <= hide_discovery)
1789	{	1787	{
1790	make_visible (enemy);	1788	make_visible (enemy);
		1789
1791	/* inform players of new status */	1790	/* inform players of new status */
1792	if (enemy->type == PLAYER && player_can_view (enemy, op))	1791	if (enemy->type == PLAYER && player_can_view (enemy, op))
1793	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
1794	return 1; /* detected enemy */	1794	return 1; /* detected enemy */
1795	}	1795	}
1796	else if (enemy->invisible)	1796	else if (enemy->invisible)
1797	{	1797	{
1798	/* Change this around - instead of negating the invisible, just	1798	/* Change this around - instead of negating the invisible, just
1799	* 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
1800	* do something to you. Decreasing the duration of invisible	1800	* do something to you. Decreasing the duration of invisible
1801	* 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
1802	* can then basically negate the spell. The spell isn't negated -	1802	* can then basically negate the spell. The spell isn't negated -
1803	* they just know where you are!	1803	* they just know where you are!
1804	*/	1804	*/
1805	if ((rndm (50)) <= hide_discovery)	1805	if (rndm (50) <= hide_discovery)
1806	{	1806	{
1807	if (enemy->type == PLAYER)	1807	if (enemy->type == PLAYER)
1808	{
1809	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));
1810	}	1809
1811	return 1;	1810	return 1;
1812	}	1811	}
1813	}	1812	}
1814	} /* within range */	1813	} /* within range */
1815		1814
1816	/* Wasn't detected above, so still hidden */	1815	/* Wasn't detected above, so still hidden */
1817	return 0;	1816	return 0;
1818	}	1817	}
1819		1818
1820	/* 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
1821	* intellegent algorithm. For one thing, we ignore los here, SO it	1820	* intelligent algorithm. For one thing, we ignore los here, SO it
1822	* 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
1823	* other side of a wall (!).	1822	* other side of a wall (!).
1824	*/	1823	*/
1825	int	1824	int
1826	stand_in_light (object *op)	1825	stand_in_light (object *op)
1827	{	1826	{
1828	sint16 nx, ny;
1829	maptile *m;
1830
1831	if (!op)	1827	if (op)
		1828	{
		1829	if (!op->is_on_map ())
1832	return 0;	1830	return 0;
1833		1831
		1832	if (op->map->darklevel () <= 0)
		1833	return 1;
		1834
1834	if (op->glow_radius > 0)	1835	if (op->glow_radius > 0)
1835	return 1;	1836	return 1;
1836		1837
1837	if (op->map)	1838	if (op->map)
1838	{	1839	unordered_mapwalk (op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)
1839	int x, y, x1, y1;	1840	{
1840
1841	/* 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
1842	* 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.
1843	*/
1844	for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++)
1845	{
1846	for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++)
1847	{	1843	*/
1848	m = op->map;	1844	int light = m->at (nx, ny).light;
1849	nx = x;
1850	ny = y;
1851		1845
1852	if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)	1846	if (expect_false (light > 0) && idistance (dx, dy) <= light)
1853	continue;
1854
1855	x1 = abs (x - op->x) * abs (x - op->x);
1856	y1 = abs (y - op->y) * abs (y - op->y);
1857	if (isqrt (x1 + y1) < GET_MAP_LIGHT (m, nx, ny))
1858	return 1;	1847	return 1;
1859	}	1848	}
1860	}
1861	}	1849	}
1862		1850
1863	return 0;	1851	return 0;
1864	}	1852	}
1865		1853
…		…
1889	{	1877	{
1890	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!	1878	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1891	* However,if you carry any source of light, then the hidden	1879	* However,if you carry any source of light, then the hidden
1892	* creature is seeable (and stupid) */	1880	* creature is seeable (and stupid) */
1893		1881
1894	if (has_carried_lights (enemy))	1882	if (enemy->has_carried_lights ())
1895	{	1883	{
1896	if (enemy->hide)	1884	if (enemy->flag [FLAG_HIDDEN])
1897	{	1885	{
1898	make_visible (enemy);	1886	make_visible (enemy);
1899	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!");
1900	}	1888	}
		1889
1901	return 1;	1890	return 1;
1902	}	1891	}
1903	else if (enemy->hide)	1892	else if (enemy->flag [FLAG_HIDDEN])
1904	return 0;	1893	return 0;
1905		1894
1906	/* Invisible enemy. Break apart the check for invis undead/invis looker	1895	/* Invisible enemy. Break apart the check for invis undead/invis looker
1907	* 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,
1908	* and making it a conditional makes the code pretty ugly.	1897	* and making it a conditional makes the code pretty ugly.
1909	*/	1898	*/
1910	if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))	1899	if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))
1911	{
1912	if (makes_invisible_to (enemy, looker))	1900	if (makes_invisible_to (enemy, looker))
1913	return 0;	1901	return 0;
1914	}
1915	}	1902	}
1916	else if (looker->type == PLAYER) /* for players, a (possible) shortcut */	1903	else if (looker->is_player ()) /* for players, a (possible) shortcut */
1917	if (player_can_view (looker, enemy))	1904	if (player_can_view (looker, enemy))
1918	return 1;	1905	return 1;
1919		1906
1920	/* ENEMY IN DARK MAP. Without infravision, the enemy is not seen	1907	/* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
1921	* unless they carry a light or stand in light. Darkness doesnt	1908	* unless they carry a light or stand in light. Darkness doesnt
…		…
1924	* we care about the enemy maps status, not the looker.	1911	* we care about the enemy maps status, not the looker.
1925	* only relevant for tiled maps, but it is possible that the	1912	* only relevant for tiled maps, but it is possible that the
1926	* 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
1927	* case, the looker can still see the enemy	1914	* case, the looker can still see the enemy
1928	*/	1915	*/
1929	if (enemy->map->darkness > 0 && !stand_in_light (enemy)	1916	if (!stand_in_light (enemy)
1930	&& (!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)))
1931	return 0;	1918	return 0;
1932		1919
1933	return 1;	1920	return 1;
1934	}	1921	}
		1922

Diff Legend

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

Comparing deliantra/server/server/monster.C (file contents): Revision 1.27 by root, Mon Apr 30 04:25:30 2007 UTC vs. Revision 1.65 by root, Fri Sep 25 18:44:58 2009 UTC

Diff Legend

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.27 by root, Mon Apr 30 04:25:30 2007 UTC vs.
Revision 1.65 by root, Fri Sep 25 18:44:58 2009 UTC