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

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.30 by root, Mon May 7 03:05:58 2007 UTC vs.
Revision 1.70 by root, Mon Oct 12 21:27:55 2009 UTC

…		…
1	/*	1	/*
2	* CrossFire, A Multiplayer game	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 it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* 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 Affero GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* and the GNU General Public License along with this program. If not, see
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
21	*	21	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	23	*/
24		24
25	#include <global.h>	25	#include <global.h>
26	#include <sproto.h>	26	#include <sproto.h>
27	#include <spells.h>	27	#include <spells.h>
36	* set to sane values.	36	* set to sane values.
37	*/	37	*/
38	object *	38	object *
39	check_enemy (object npc, rv_vector rv)	39	check_enemy (object npc, rv_vector rv)
40	{	40	{
41
42	/* 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
43	* 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,
44	* which CAN attack the owner. */	43	* which CAN attack the owner. */
45	if ((npc->attack_movement & HI4) == PETMOVE)	44	if ((npc->attack_movement & HI4) == PETMOVE)
46	{	45	{
…		…
48	npc->enemy = NULL;	47	npc->enemy = NULL;
49	else if (npc->enemy == NULL)	48	else if (npc->enemy == NULL)
50	npc->enemy = npc->owner->enemy;	49	npc->enemy = npc->owner->enemy;
51	}	50	}
52		51
53	/* periodically, a monster mayu change its target. Also, if the object	52	/* periodically, a monster may change its target. Also, if the object
54	* has been destroyed, etc, clear the enemy.	53	* has been destroyed, etc, clear the enemy.
55	* 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
56	* attacked monsters to leave the attacker alone, before it is destroyed	55	* attacked monsters to leave the attacker alone, before it is destroyed
57	*/	56	*/
58	/* 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
59	* 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
60	* again then but perhaps get attack on and on	59	* again then but perhaps get attack on and on
61	* 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
62	* too. */	61	* too. */
63		62
…		…
67	* the grouping checks are. Code is the same.	66	* the grouping checks are. Code is the same.
68	*/	67	*/
69	if (QUERY_FLAG (npc->enemy, FLAG_REMOVED) \|\|	68	if (QUERY_FLAG (npc->enemy, FLAG_REMOVED) \|\|
70	QUERY_FLAG (npc->enemy, FLAG_FREED) \|\|	69	QUERY_FLAG (npc->enemy, FLAG_FREED) \|\|
71	!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))
72	npc->enemy = NULL;	71	npc->enemy = 0;
73		72
74	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)
75	&& !(should_arena_attack (npc, npc->owner, npc->enemy)))	74	&& !(should_arena_attack (npc, npc->owner, npc->enemy)))
76	\|\| ((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)))
77	\|\| npc->enemy == npc->owner))	76	\|\| npc->enemy == npc->owner))
78	npc->enemy = NULL;	77	npc->enemy = 0;
79		78
80		79
81	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))
82	npc->enemy = NULL;	81	npc->enemy = 0;
83		82
84	/* 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
85	* target enemy - this code below makes sure the enemy is something	84	* target enemy - this code below makes sure the enemy is something
86	* that should be attacked. My guess is that the arrow hits	85	* that should be attacked. My guess is that the arrow hits
87	* the creature/owner, and so the creature then takes that	86	* the creature/owner, and so the creature then takes that
…		…
89	*/	88	*/
90	else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER)	89	else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER)
91	&& !QUERY_FLAG (npc->enemy, FLAG_GENERATOR)	90	&& !QUERY_FLAG (npc->enemy, FLAG_GENERATOR)
92	&& npc->enemy->type != PLAYER	91	&& npc->enemy->type != PLAYER
93	&& npc->enemy->type != GOLEM)	92	&& npc->enemy->type != GOLEM)
94	npc->enemy = NULL;	93	npc->enemy = 0;
95
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 : 0;
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.
102	* 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
…		…
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
…		…
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)
…		…
682	return 1;	706	return 1;
683		707
684	/* 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
685	* 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
686	*/	710	*/
687	for (more = ob2->more; more != NULL; more = more->more)	711	for (more = ob2->more; more; more = more->more)
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;
…		…
960	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);
961		980
962	if (dirdiff (dir, dir2) < 2)	981	if (dirdiff (dir, dir2) < 2)
963	return 0; /* Might hit owner with spell */	982	return 0; /* Might hit owner with spell */
964	}	983	}
		984
965	if (QUERY_FLAG (head, FLAG_CONFUSED))	985	if (QUERY_FLAG (head, FLAG_CONFUSED))
966	dir = absdir (dir + rndm (3) + rndm (3) - 2);	986	dir = absdir (dir + rndm (3) + rndm (3) - 2);
967		987
968	for (wand = head->inv; wand; wand = wand->below)	988	for (wand = head->inv; wand; wand = wand->below)
969	{	989	{
…		…
979	if (!(--wand->stats.food))	999	if (!(--wand->stats.food))
980	{	1000	{
981	if (wand->arch)	1001	if (wand->arch)
982	{	1002	{
983	CLEAR_FLAG (wand, FLAG_ANIMATE);	1003	CLEAR_FLAG (wand, FLAG_ANIMATE);
984	wand->face = wand->arch->clone.face;	1004	wand->face = wand->arch->face;
985	wand->set_speed (0);	1005	wand->set_speed (0);
986	}	1006	}
987	}	1007	}
988	/* Success */	1008	/* Success */
989	return 1;	1009	return 1;
…		…
1008	}	1028	}
1009		1029
1010	if (at_least_one)	1030	if (at_least_one)
1011	return 0;	1031	return 0;
1012		1032
1013	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);
1014	CLEAR_FLAG (head, FLAG_READY_RANGE);	1034	CLEAR_FLAG (head, FLAG_READY_RANGE);
1015	return 0;	1035	return 0;
1016	}	1036	}
1017		1037
1018	int	1038	int
…		…
1020	{	1040	{
1021	object *owner;	1041	object *owner;
1022		1042
1023	if (!(dir = path_to_player (part, pl, 0)))	1043	if (!(dir = path_to_player (part, pl, 0)))
1024	return 0;	1044	return 0;
		1045
1025	if (QUERY_FLAG (head, FLAG_CONFUSED))	1046	if (QUERY_FLAG (head, FLAG_CONFUSED))
1026	dir = absdir (dir + rndm (3) + rndm (3) - 2);	1047	dir = absdir (dir + rndm (3) + rndm (3) - 2);
1027		1048
1028	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)	1049	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
1029	{	1050	{
…		…
1037	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);
1038		1059
1039	}	1060	}
1040		1061
1041	/* Checks if putting on 'item' will make 'who' do more	1062	/* Checks if putting on 'item' will make 'who' do more
1042	* damage. This is a very simplistic check - also checking things	1063	* damage. This is a very simplistic check - also checking things
1043	* like speed and ac are also relevant.	1064	* like speed and ac are also relevant.
1044	*	1065	*
1045	* return true if item is a better object.	1066	* return true if item is a better object.
1046	*/	1067	*/
1047
1048	int	1068	int
1049	check_good_weapon (object who, object item)	1069	check_good_weapon (object who, object item)
1050	{	1070	{
1051	object *other_weap;	1071	object *other_weap;
1052	int val = 0, i;	1072	int val = 0, i;
1053		1073
1054	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)
1055	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))
1056	break;	1076	break;
1057		1077
1058	if (other_weap == NULL) /* No other weapons */	1078	if (!other_weap) /* No other weapons */
1059	return 1;	1079	return 1;
1060		1080
1061	/* 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
1062	* better, just do some simple checks	1082	* better, just do some simple checks
1063	* Put some multipliers for things that hvae several effects,	1083	* Put some multipliers for things that hvae several effects,
…		…
1068	val += (item->magic - other_weap->magic) * 3;	1088	val += (item->magic - other_weap->magic) * 3;
1069	/* Monsters don't really get benefits from things like regen rates	1089	/* Monsters don't really get benefits from things like regen rates
1070	* from items. But the bonus for their stats are very important.	1090	* from items. But the bonus for their stats are very important.
1071	*/	1091	*/
1072	for (i = 0; i < NUM_STATS; i++)	1092	for (i = 0; i < NUM_STATS; i++)
1073	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;
1074		1094
1075	if (val > 0)	1095	if (val > 0)
1076	return 1;	1096	return 1;
1077	else	1097	else
1078	return 0;	1098	return 0;
…		…
1082	check_good_armour (object who, object item)	1102	check_good_armour (object who, object item)
1083	{	1103	{
1084	object *other_armour;	1104	object *other_armour;
1085	int val = 0, i;	1105	int val = 0, i;
1086		1106
1087	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)
1088	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))
1089	break;	1109	break;
1090		1110
1091	if (other_armour == NULL) /* No other armour, use the new */	1111	if (other_armour == NULL) /* No other armour, use the new */
1092	return 1;	1112	return 1;
…		…
1177	flag = 1;	1197	flag = 1;
1178		1198
1179	else	1199	else
1180	switch (item->type)	1200	switch (item->type)
1181	{	1201	{
1182	case MONEY:	1202	case MONEY:
1183	case GEM:	1203	case GEM:
1184	flag = monster->pick_up & 2;	1204	flag = monster->pick_up & 2;
1185	break;	1205	break;
1186		1206
1187	case FOOD:	1207	case FOOD:
1188	flag = monster->pick_up & 4;	1208	flag = monster->pick_up & 4;
1189	break;	1209	break;
1190		1210
1191	case WEAPON:	1211	case WEAPON:
1192	flag = (monster->pick_up & 8) \|\| QUERY_FLAG (monster, FLAG_USE_WEAPON);	1212	flag = (monster->pick_up & 8) \|\| QUERY_FLAG (monster, FLAG_USE_WEAPON);
1193	break;	1213	break;
1194		1214
1195	case ARMOUR:	1215	case ARMOUR:
1196	case SHIELD:	1216	case SHIELD:
1197	case HELMET:	1217	case HELMET:
1198	case BOOTS:	1218	case BOOTS:
1199	case GLOVES:	1219	case GLOVES:
1200	case GIRDLE:	1220	case GIRDLE:
1201	flag = (monster->pick_up & 16) \|\| QUERY_FLAG (monster, FLAG_USE_ARMOUR);	1221	flag = (monster->pick_up & 16) \|\| QUERY_FLAG (monster, FLAG_USE_ARMOUR);
1202	break;	1222	break;
1203		1223
1204	case SKILL:	1224	case SKILL:
1205	flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);	1225	flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);
1206	break;	1226	break;
1207		1227
1208	case RING:	1228	case RING:
1209	flag = QUERY_FLAG (monster, FLAG_USE_RING);	1229	flag = QUERY_FLAG (monster, FLAG_USE_RING);
1210	break;	1230	break;
1211		1231
1212	case WAND:	1232	case WAND:
1213	case HORN:	1233	case HORN:
1214	case ROD:	1234	case ROD:
1215	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);	1235	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1216	break;	1236	break;
1217		1237
1218	case SPELLBOOK:	1238	case SPELLBOOK:
1219	flag = (monster->arch != NULL && QUERY_FLAG ((&monster->arch->clone), FLAG_CAST_SPELL));	1239	flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1220	break;	1240	break;
1221		1241
1222	case SCROLL:	1242	case SCROLL:
1223	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);	1243	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1224	break;	1244	break;
1225		1245
1226	case BOW:	1246	case BOW:
1227	case ARROW:	1247	case ARROW:
1228	flag = QUERY_FLAG (monster, FLAG_USE_BOW);	1248	flag = QUERY_FLAG (monster, FLAG_USE_BOW);
1229	break;	1249	break;
1230	}	1250	}
1231		1251
1232	/* 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
1233	* 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
1234	* use several locations.	1254	* use several locations.
…		…
1242	}	1262	}
1243	}	1263	}
1244		1264
1245	if (((!(monster->pick_up & 32)) && flag) \|\| ((monster->pick_up & 32) && (!flag)))	1265	if (((!(monster->pick_up & 32)) && flag) \|\| ((monster->pick_up & 32) && (!flag)))
1246	return 1;	1266	return 1;
		1267
1247	return 0;	1268	return 0;
1248	}	1269	}
1249		1270
1250	/*	1271	/*
1251	* monster_apply_below():	1272	* monster_apply_below():
…		…
1261	for (tmp = monster->below; tmp != NULL; tmp = next)	1282	for (tmp = monster->below; tmp != NULL; tmp = next)
1262	{	1283	{
1263	next = tmp->below;	1284	next = tmp->below;
1264	switch (tmp->type)	1285	switch (tmp->type)
1265	{	1286	{
1266	case CF_HANDLE:	1287	case T_HANDLE:
1267	case TRIGGER:	1288	case TRIGGER:
1268	if (monster->will_apply & 1)	1289	if (monster->will_apply & 1)
1269	manual_apply (monster, tmp, 0);	1290	manual_apply (monster, tmp, 0);
1270	break;	1291	break;
1271		1292
…		…
1293	void	1314	void
1294	monster_check_apply (object mon, object item)	1315	monster_check_apply (object mon, object item)
1295	{	1316	{
1296	int flag = 0;	1317	int flag = 0;
1297		1318
1298	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)))
1299	{	1320	{
1300	SET_FLAG (mon, FLAG_CAST_SPELL);	1321	SET_FLAG (mon, FLAG_CAST_SPELL);
1301	return;	1322	return;
1302	}	1323	}
1303		1324
…		…
1399	}	1420	}
1400		1421
1401	void	1422	void
1402	npc_call_help (object *op)	1423	npc_call_help (object *op)
1403	{	1424	{
1404	int x, y, mflags;	1425	unordered_mapwalk (op, -7, -7, 7, 7)
1405	object *npc;
1406	sint16 sx, sy;
1407	maptile *m;
1408
1409	for (x = -3; x < 4; x++)
1410	for (y = -3; y < 4; y++)
1411	{	1426	{
1412	m = op->map;	1427	mapspace &ms = m->at (nx, ny);
1413	sx = op->x + x;	1428
1414	sy = op->y + y;
1415	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1416	/* 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. */
1417	if ((mflags & P_OUT_OF_MAP) \|\| !(mflags & P_IS_ALIVE))	1430	if (!(ms.flags () & P_IS_ALIVE))
1418	continue;	1431	continue;
1419		1432
1420	for (npc = GET_MAP_OB (m, sx, sy); npc != NULL; npc = npc->above)	1433	for (object *npc = ms.bot; npc; npc = npc->above)
1421	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))	1434	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
1422	npc->enemy = op->enemy;	1435	npc->enemy = op->enemy;
1423	}	1436	}
1424	}	1437	}
1425		1438
1426	int	1439	int
1427	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)
1428	{	1441	{
1429	if (can_hit (part, enemy, rv))	1442	if (can_hit (part, enemy, rv))
1430	return dir;	1443	return dir;
		1444
1431	if (rv->distance < 10)	1445	if (rv->distance < 10)
1432	return absdir (dir + 4);	1446	return absdir (dir + 4);
1433	else if (rv->distance > 18)	1447	else if (rv->distance > 18)
1434	return dir;	1448	return dir;
1435		1449
1436	return 0;	1450	return 0;
1437	}	1451	}
1438		1452
1439	int	1453	int
1440	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)
1441	{	1455	{
1442	if ((can_hit (part, enemy, rv) && ob->move_status < 20) \|\| ob->move_status < 20)	1456	if (can_hit (part, enemy, rv))
1443	{
1444	ob->move_status++;
1445	return (dir);	1457	return dir;
1446	}	1458	else
1447	else if (ob->move_status > 20)
1448	ob->move_status = 0;
1449
1450	return absdir (dir + 4);	1459	return absdir (dir + 4);
1451	}	1460	}
1452		1461
1453	int	1462	int
1454	hitrun_att (int dir, object ob, object enemy)	1463	hitrun_att (int dir, object ob, object enemy)
1455	{	1464	{
…		…
1464	}	1473	}
1465		1474
1466	int	1475	int
1467	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)
1468	{	1477	{
1469
1470	int inrange = can_hit (part, enemy, rv);	1478	int inrange = can_hit (part, enemy, rv);
1471		1479
1472	if (ob->move_status \|\| inrange)	1480	if (ob->move_status \|\| inrange)
1473	ob->move_status++;	1481	ob->move_status++;
1474		1482
…		…
1484	}	1492	}
1485		1493
1486	int	1494	int
1487	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)
1488	{	1496	{
1489
1490	/* The logic below here looked plain wrong before. Basically, what should	1497	/* The logic below here looked plain wrong before. Basically, what should
1491	* 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,
1492	* the creature should run away (dir+4)	1499	* the creature should run away (dir+4)
1493	* 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
1494	* 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
1495	* server should try to be resilant enough to avoid the problem	1502	* server should try to be resilant enough to avoid the problem
1496	*/	1503	*/
1497	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)
1498	return absdir (dir + 4);	1505	return absdir (dir + 4);
1499		1506
1500	return dist_att (dir, ob, enemy, part, rv);	1507	return dist_att (dir, ob, enemy, part, rv);
1501	}	1508	}
1502		1509
…		…
1590	}	1597	}
1591		1598
1592	void	1599	void
1593	rand_move (object *ob)	1600	rand_move (object *ob)
1594	{	1601	{
1595	int i;
1596
1597	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)))))
1598	for (i = 0; i < 5; i++)	1603	for (int i = 0; i < 5; i++)
1599	if (move_object (ob, ob->move_status = rndm (8) + 1))	1604	if (move_object (ob, ob->move_status = rndm (8) + 1))
1600	return;	1605	return;
1601	}	1606	}
1602		1607
1603	void	1608	void
1604	check_earthwalls (object op, maptile m, int x, int y)	1609	check_earthwalls (object op, maptile m, int x, int y)
1605	{	1610	{
1606	object *tmp;
1607
1608	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)
1609	{
1610	if (tmp->type == EARTHWALL)	1612	if (tmp->type == EARTHWALL)
1611	{	1613	{
1612	hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);	1614	hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);
1613	return;	1615	return;
1614	}	1616	}
1615	}
1616	}	1617	}
1617		1618
1618	void	1619	void
1619	check_doors (object op, maptile m, int x, int y)	1620	check_doors (object op, maptile m, int x, int y)
1620	{	1621	{
1621	object *tmp;
1622
1623	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)
1624	{
1625	if (tmp->type == DOOR)	1623	if (tmp->type == DOOR)
1626	{	1624	{
1627	hit_player (tmp, 1000, op, AT_PHYSICAL, 1);	1625	hit_player (tmp, 1000, op, AT_PHYSICAL, 1);
1628	return;	1626	return;
1629	}	1627	}
1630	}
1631	}	1628	}
1632		1629
1633	/* find_mon_throw_ob() - modeled on find_throw_ob	1630	/* find_mon_throw_ob() - modeled on find_throw_ob
1634	* This is probably overly simplistic as it is now - We want	1631	* This is probably overly simplistic as it is now - We want
1635	* monsters to throw things like chairs and other pieces of	1632	* monsters to throw things like chairs and other pieces of
…		…
1675	* 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
1676	* 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
1677	* be within the valid range. MSW 2001-08-05	1674	* be within the valid range. MSW 2001-08-05
1678	* 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
1679	*/	1676	*/
1680
1681	int	1677	int
1682	can_detect_enemy (object op, object enemy, rv_vector * rv)	1678	can_detect_enemy (object op, object enemy, rv_vector * rv)
1683	{	1679	{
1684	int radius = MIN_MON_RADIUS, hide_discovery;
1685
1686	/* null detection for any of these condtions always */	1680	/* null detection for any of these condtions always */
1687	if (!op \|\| !enemy \|\| !op->map \|\| !enemy->map)	1681	if (!op \|\| !enemy \|\| !op->map \|\| !enemy->map)
1688	return 0;	1682	return 0;
1689		1683
1690	/* 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 */
…		…
1692	return 0;	1686	return 0;
1693		1687
1694	get_rangevector (op, enemy, rv, 0);	1688	get_rangevector (op, enemy, rv, 0);
1695		1689
1696	/* Monsters always ignore the DM */	1690	/* Monsters always ignore the DM */
1697	if ((op->type != PLAYER) && QUERY_FLAG (enemy, FLAG_WIZ))	1691	if (!op->is_player () && QUERY_FLAG (enemy, FLAG_WIZ))
1698	return 0;	1692	return 0;
1699		1693
1700	/* simple check. Should probably put some range checks in here. */	1694	/* simple check. Should probably put some range checks in here. */
1701	if (can_see_enemy (op, enemy))	1695	if (can_see_enemy (op, enemy))
1702	return 1;	1696	return 1;
1703		1697
1704	/* 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
1705	* finding enemies!	1699	* finding enemies!
1706	*/	1700	*/
1707	if (op->type == PLAYER)	1701	if (op->is_player ())
1708	return 0;	1702	return 0;
1709		1703
1710	/* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE	1704	/* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
1711	* 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
1712	*/	1706	*/
1713	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)))
1714	return 0;	1708	return 0;
1715		1709
		1710	int radius = MIN_MON_RADIUS;
		1711
1716	/* use this for invis also */	1712	/* use this for invis also */
1717	hide_discovery = op->stats.Int / 5;	1713	int hide_discovery = op->stats.Int / 5;
1718		1714
1719	/* Determine Detection radii */	1715	/* Determine Detection radii */
1720	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) */
1721	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);
1722	else	1718	else
1723	{ /* a level/INT/Dex adjustment for hiding */	1719	{ /* a level/INT/Dex adjustment for hiding */
1724	object *sk_hide;
1725	int bonus = (op->level / 2) + (op->stats.Int / 5);	1720	int bonus = op->level / 2 + op->stats.Int / 5;
1726		1721
1727	if (enemy->type == PLAYER)	1722	if (enemy->is_player ())
1728	{	1723	{
1729	if ((sk_hide = find_skill_by_number (enemy, SK_HIDING)))	1724	if (object *sk_hide = find_skill_by_number (enemy, SK_HIDING))
1730	bonus -= sk_hide->level;	1725	bonus -= sk_hide->level;
1731	else	1726	else
1732	{	1727	{
1733	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");
1734	make_visible (enemy);	1729	make_visible (enemy);
…		…
1743	} /* else creature has modifiers for hiding */	1738	} /* else creature has modifiers for hiding */
1744		1739
1745	/* Radii stealth adjustment. Only if you are stealthy	1740	/* Radii stealth adjustment. Only if you are stealthy
1746	* will you be able to sneak up closer to creatures */	1741	* will you be able to sneak up closer to creatures */
1747	if (QUERY_FLAG (enemy, FLAG_STEALTH))	1742	if (QUERY_FLAG (enemy, FLAG_STEALTH))
1748	radius = radius / 2, hide_discovery = hide_discovery / 3;	1743	{
		1744	radius /= 2;
		1745	hide_discovery /= 3;
		1746	}
1749		1747
1750	/* Radii adjustment for enemy standing in the dark */	1748	/* Radii adjustment for enemy standing in the dark */
1751	if (op->map->darkness > 0 && !stand_in_light (enemy))	1749	if (!stand_in_light (enemy))
1752	{	1750	{
1753	/* on dark maps body heat can help indicate location with infravision	1751	/* on dark maps body heat can help indicate location with infravision
1754	* undead don't have body heat, so no benefit detecting them.	1752	* undead don't have body heat, so no benefit detecting them.
1755	*/	1753	*/
1756	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))
1757	radius += op->map->darkness / 2;	1755	radius += op->map->darklevel () / 2;
1758	else	1756	else
1759	radius -= op->map->darkness / 2;	1757	radius -= op->map->darklevel () / 2;
1760		1758
1761	/* op next to a monster (and not in complete darkness)	1759	/* op next to a monster (and not in complete darkness)
1762	* the monster should have a chance to see you.	1760	* the monster should have a chance to see you.
1763	*/	1761	*/
1764	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)
1765	radius = MIN_MON_RADIUS;	1763	radius = MIN_MON_RADIUS;
1766	} /* if on dark map */	1764	} /* if on dark map */
1767		1765
1768	/* Lets not worry about monsters that have incredible detection	1766	/* Lets not worry about monsters that have incredible detection
1769	* 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
…		…
1771	* 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
1772	* do something. Note that the distance field in the	1770	* do something. Note that the distance field in the
1773	* 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
1774	* find that.	1772	* find that.
1775	*/	1773	*/
1776	if (radius > 13)	1774	// note that the above reasoning was utter bullshit even at the time it was written
1777	radius = 13;	1775	// we use 25, lets see if we have the cpu time for it
		1776	radius = min (25, radius);
1778		1777
1779	/* Enemy in range! Now test for detection */	1778	/* Enemy in range! Now test for detection */
1780	if ((int) rv->distance <= radius)	1779	if (rv->distance <= radius)
1781	{	1780	{
1782	/* ah, we are within range, detected? take cases */	1781	/* ah, we are within range, detected? take cases */
1783	if (!enemy->invisible) /* enemy in dark squares... are seen! */	1782	if (!enemy->invisible) /* enemy in dark squares... are seen! */
1784	return 1;	1783	return 1;
1785		1784
1786	/* hidden or low-quality invisible */	1785	/* hidden or low-quality invisible */
1787	if (enemy->hide && (rv->distance <= 1) && (rndm (100) <= hide_discovery))	1786	if (enemy->flag [FLAG_HIDDEN] && rv->distance <= 1 && rndm (100) <= hide_discovery)
1788	{	1787	{
1789	make_visible (enemy);	1788	make_visible (enemy);
		1789
1790	/* inform players of new status */	1790	/* inform players of new status */
1791	if (enemy->type == PLAYER && player_can_view (enemy, op))	1791	if (enemy->type == PLAYER && player_can_view (enemy, op))
1792	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
1793	return 1; /* detected enemy */	1794	return 1; /* detected enemy */
1794	}	1795	}
1795	else if (enemy->invisible)	1796	else if (enemy->invisible)
1796	{	1797	{
1797	/* Change this around - instead of negating the invisible, just	1798	/* Change this around - instead of negating the invisible, just
1798	* 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
1799	* do something to you. Decreasing the duration of invisible	1800	* do something to you. Decreasing the duration of invisible
1800	* 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
1801	* can then basically negate the spell. The spell isn't negated -	1802	* can then basically negate the spell. The spell isn't negated -
1802	* they just know where you are!	1803	* they just know where you are!
1803	*/	1804	*/
1804	if ((rndm (50)) <= hide_discovery)	1805	if (rndm (50) <= hide_discovery)
1805	{	1806	{
1806	if (enemy->type == PLAYER)	1807	if (enemy->type == PLAYER)
1807	{
1808	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));
1809	}	1809
1810	return 1;	1810	return 1;
1811	}	1811	}
1812	}	1812	}
1813	} /* within range */	1813	} /* within range */
1814		1814
1815	/* Wasn't detected above, so still hidden */	1815	/* Wasn't detected above, so still hidden */
1816	return 0;	1816	return 0;
1817	}	1817	}
1818		1818
1819	/* 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
1820	* intellegent algorithm. For one thing, we ignore los here, SO it	1820	* intelligent algorithm. For one thing, we ignore los here, SO it
1821	* 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
1822	* other side of a wall (!).	1822	* other side of a wall (!).
1823	*/	1823	*/
1824	int	1824	int
1825	stand_in_light (object *op)	1825	stand_in_light (object *op)
1826	{	1826	{
1827	sint16 nx, ny;
1828	maptile *m;
1829
1830	if (!op)	1827	if (op)
		1828	{
		1829	if (!op->is_on_map ())
1831	return 0;	1830	return 0;
1832		1831
		1832	if (op->map->darklevel () <= 0)
		1833	return 1;
		1834
1833	if (op->glow_radius > 0)	1835	if (op->glow_radius > 0)
1834	return 1;	1836	return 1;
1835		1837
1836	if (op->map)	1838	if (op->map)
1837	{	1839	unordered_mapwalk (op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)
1838	int x, y, x1, y1;	1840	{
1839
1840	/* 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
1841	* 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.
1842	*/
1843	for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++)
1844	{
1845	for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++)
1846	{	1843	*/
1847	m = op->map;	1844	int light = m->at (nx, ny).light;
1848	nx = x;
1849	ny = y;
1850		1845
1851	if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)	1846	if (expect_false (light > 0) && idistance (dx, dy) <= light)
1852	continue;
1853
1854	x1 = abs (x - op->x) * abs (x - op->x);
1855	y1 = abs (y - op->y) * abs (y - op->y);
1856	if (isqrt (x1 + y1) < GET_MAP_LIGHT (m, nx, ny))
1857	return 1;	1847	return 1;
1858	}	1848	}
1859	}
1860	}	1849	}
1861		1850
1862	return 0;	1851	return 0;
1863	}	1852	}
1864		1853
…		…
1888	{	1877	{
1889	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!	1878	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1890	* However,if you carry any source of light, then the hidden	1879	* However,if you carry any source of light, then the hidden
1891	* creature is seeable (and stupid) */	1880	* creature is seeable (and stupid) */
1892		1881
1893	if (has_carried_lights (enemy))	1882	if (enemy->has_carried_lights ())
1894	{	1883	{
1895	if (enemy->hide)	1884	if (enemy->flag [FLAG_HIDDEN])
1896	{	1885	{
1897	make_visible (enemy);	1886	make_visible (enemy);
1898	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!");
1899	}	1888	}
		1889
1900	return 1;	1890	return 1;
1901	}	1891	}
1902	else if (enemy->hide)	1892	else if (enemy->flag [FLAG_HIDDEN])
1903	return 0;	1893	return 0;
1904		1894
1905	/* Invisible enemy. Break apart the check for invis undead/invis looker	1895	/* Invisible enemy. Break apart the check for invis undead/invis looker
1906	* 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,
1907	* and making it a conditional makes the code pretty ugly.	1897	* and making it a conditional makes the code pretty ugly.
1908	*/	1898	*/
1909	if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))	1899	if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))
1910	{
1911	if (makes_invisible_to (enemy, looker))	1900	if (makes_invisible_to (enemy, looker))
1912	return 0;	1901	return 0;
1913	}
1914	}	1902	}
1915	else if (looker->type == PLAYER) /* for players, a (possible) shortcut */	1903	else if (looker->is_player ()) /* for players, a (possible) shortcut */
1916	if (player_can_view (looker, enemy))	1904	if (player_can_view (looker, enemy))
1917	return 1;	1905	return 1;
1918		1906
1919	/* ENEMY IN DARK MAP. Without infravision, the enemy is not seen	1907	/* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
1920	* unless they carry a light or stand in light. Darkness doesnt	1908	* unless they carry a light or stand in light. Darkness doesnt
…		…
1923	* we care about the enemy maps status, not the looker.	1911	* we care about the enemy maps status, not the looker.
1924	* only relevant for tiled maps, but it is possible that the	1912	* only relevant for tiled maps, but it is possible that the
1925	* 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
1926	* case, the looker can still see the enemy	1914	* case, the looker can still see the enemy
1927	*/	1915	*/
1928	if (enemy->map->darkness > 0 && !stand_in_light (enemy)	1916	if (!stand_in_light (enemy)
1929	&& (!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)))
1930	return 0;	1918	return 0;
1931		1919
1932	return 1;	1920	return 1;
1933	}	1921	}
		1922

Diff Legend

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

Comparing deliantra/server/server/monster.C (file contents): Revision 1.30 by root, Mon May 7 03:05:58 2007 UTC vs. Revision 1.70 by root, Mon Oct 12 21:27:55 2009 UTC

Diff Legend

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.30 by root, Mon May 7 03:05:58 2007 UTC vs.
Revision 1.70 by root, Mon Oct 12 21:27:55 2009 UTC