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

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.32 by root, Sat May 12 18:14:48 2007 UTC vs.
Revision 1.65 by root, Fri Sep 25 18:44:58 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
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
…		…
516	if (monster_use_bow (op, part, enemy, dir))	505	if (monster_use_bow (op, part, enemy, dir))
517	return 0;	506	return 0;
518	} /* for processing of all parts */	507	} /* for processing of all parts */
519	} /* If not scared */	508	} /* If not scared */
520		509
521
522	part = rv.part;	510	part = rv.part;
523	dir = rv.direction;	511	dir = rv.direction;
524		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
525	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))
526	dir = absdir (dir + 4);	558	dir = absdir (dir + 4);
527		559
528	if (QUERY_FLAG (op, FLAG_CONFUSED))	560	if (QUERY_FLAG (op, FLAG_CONFUSED))
529	dir = absdir (dir + rndm (3) + rndm (3) - 2);	561	dir = absdir (dir + rndm (3) + rndm (3) - 2);
…		…
532		564
533	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))	565	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))
534	{	566	{
535	switch (op->attack_movement & LO4)	567	switch (op->attack_movement & LO4)
536	{	568	{
537	case DISTATT:	569	case DISTATT:
538	dir = dist_att (dir, op, enemy, part, &rv);	570	dir = dist_att (dir, op, enemy, part, &rv);
539	break;	571	break;
540		572
541	case RUNATT:	573	case RUNATT:
542	dir = run_att (dir, op, enemy, part, &rv);	574	dir = run_att (dir, op, enemy, part, &rv);
543	break;	575	break;
544		576
545	case HITRUN:	577	case HITRUN:
546	dir = hitrun_att (dir, op, enemy);	578	dir = hitrun_att (dir, op, enemy);
547	break;	579	break;
548		580
549	case WAITATT:	581	case WAITATT:
550	dir = wait_att (dir, op, enemy, part, &rv);	582	dir = wait_att (dir, op, enemy, part, &rv);
551	break;	583	break;
552		584
553	case RUSH: /* default - monster normally moves towards player */	585	case RUSH: /* default - monster normally moves towards player */
554	case ALLRUN:	586	case ALLRUN:
555	break;	587	break;
556		588
557	case DISTHIT:	589	case DISTHIT:
558	dir = disthit_att (dir, op, enemy, part, &rv);	590	dir = disthit_att (dir, op, enemy, part, &rv);
559	break;	591	break;
560		592
561	case WAIT2:	593	case WAIT2:
562	dir = wait_att2 (dir, op, enemy, part, &rv);	594	dir = wait_att2 (dir, op, enemy, part, &rv);
563	break;	595	break;
564		596
565	default:	597	default:
566	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);
567	}	599	}
568	}	600	}
569		601
570	if (!dir)	602	if (!dir)
571	return 0;	603	return 0;
…		…
581	return 0;	613	return 0;
582	}	614	}
583		615
584	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))
585	{	617	{
586
587	/* Try move around corners if !close */	618	/* Try move around corners if !close */
588	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;
589		620
590	for (diff = 1; diff <= maxdiff; diff++)	621	for (diff = 1; diff <= maxdiff; diff++)
591	{	622	{
592	/* try different detours */	623	/* try different detours */
593	int m = 1 - (RANDOM () & 2); /* Try left or right first? */	624	int m = 1 - rndm (2) * 2; /* Try left or right first? */
594		625
595	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)))
596	return 0;	627	return 0;
597	}	628	}
598	}	629	}
…		…
625	{	656	{
626	object *nearest_player = get_nearest_player (op);	657	object *nearest_player = get_nearest_player (op);
627		658
628	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))	659	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))
629	{	660	{
630	op->enemy = NULL;	661	op->enemy = 0;
631	enemy = nearest_player;	662	enemy = nearest_player;
632	}	663	}
633	}	664	}
634		665
635	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))	666	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))
…		…
641	* still be pretty nasty.	672	* still be pretty nasty.
642	*/	673	*/
643	if (QUERY_FLAG (op, FLAG_RUN_AWAY))	674	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
644	{	675	{
645	part->stats.wc += 10;	676	part->stats.wc += 10;
646	(void) skill_attack (enemy, part, 0, NULL, NULL);	677	skill_attack (enemy, part, 0, NULL, NULL);
647	part->stats.wc -= 10;	678	part->stats.wc -= 10;
648	}	679	}
649	else	680	else
650	(void) skill_attack (enemy, part, 0, NULL, NULL);	681	skill_attack (enemy, part, 0, NULL, NULL);
651	} /* if monster is in attack range */	682	} /* if monster is in attack range */
652		683
653	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 */
654	return 1;	685	return 1;
655		686
656	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))	687	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
657	{	688	{
658	op->remove ();
659	op->destroy ();	689	op->drop_and_destroy ();
660	return 1;	690	return 1;
661	}	691	}
		692
662	return 0;	693	return 0;
663	}	694	}
664		695
665	int	696	int
666	can_hit (object ob1, object ob2, rv_vector * rv)	697	can_hit (object ob1, object ob2, rv_vector * rv)
…		…
681	{	712	{
682	get_rangevector (ob1, more, &rv1, 0);	713	get_rangevector (ob1, more, &rv1, 0);
683	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)	714	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
684	return 1;	715	return 1;
685	}	716	}
		717
686	return 0;	718	return 0;
687
688	}	719	}
689		720
690	/* Returns 1 is monster should cast spell sp at an enemy	721	/* Returns 1 is monster should cast spell sp at an enemy
691	* Returns 0 if the monster should not cast this spell.	722	* Returns 0 if the monster should not cast this spell.
692	*	723	*
…		…
710	spell_ob->subtype == SP_EXPLOSION \|\| spell_ob->subtype == SP_CONE \|\|	741	spell_ob->subtype == SP_EXPLOSION \|\| spell_ob->subtype == SP_CONE \|\|
711	spell_ob->subtype == SP_BOMB \|\| spell_ob->subtype == SP_SMITE \|\|	742	spell_ob->subtype == SP_BOMB \|\| spell_ob->subtype == SP_SMITE \|\|
712	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 \|\|
713	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 \|\|
714	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)
715
716	return 1;	746	return 1;
717		747
718	return 0;	748	return 0;
719	}	749	}
720
721		750
722	#define MAX_KNOWN_SPELLS 20	751	#define MAX_KNOWN_SPELLS 20
723		752
724	/* Returns a randomly selected spell. This logic is still	753	/* Returns a randomly selected spell. This logic is still
725	* less than ideal. This code also only seems to deal with	754	* less than ideal. This code also only seems to deal with
…		…
728	*/	757	*/
729	object *	758	object *
730	monster_choose_random_spell (object *monster)	759	monster_choose_random_spell (object *monster)
731	{	760	{
732	object *altern[MAX_KNOWN_SPELLS];	761	object *altern[MAX_KNOWN_SPELLS];
733	object *tmp;
734	int i = 0;	762	int i = 0;
735		763
736	for (tmp = monster->inv; tmp != NULL; tmp = tmp->below)	764	for (object *tmp = monster->inv; tmp; tmp = tmp->below)
737	if (tmp->type == SPELLBOOK \|\| tmp->type == SPELL)	765	if (tmp->type == SPELLBOOK \|\| tmp->type == SPELL)
738	{	766	{
739	/* Check and see if it's actually a useful spell.	767	/* Check and see if it's actually a useful spell.
740	* If its a spellbook, the spell is actually the inventory item.	768	* If its a spellbook, the spell is actually the inventory item.
741	* 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.
742	*/	770	*/
743	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))
744	{	772	{
745	altern[i++] = tmp;	773	altern [i++] = tmp;
		774
746	if (i == MAX_KNOWN_SPELLS)	775	if (i == MAX_KNOWN_SPELLS)
747	break;	776	break;
748	}	777	}
749	}	778	}
750	if (!i)	779
751	return NULL;	780	return i ? altern [rndm (i)] : 0;
752	return altern[RANDOM () % i];
753	}	781	}
754		782
755	/* 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.
756	* 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.
757	* head is the head of the monster.	785	* head is the head of the monster.
758	* part is the part of the monster we are checking against.	786	* part is the part of the monster we are checking against.
759	* pl is the target.	787	* pl is the target.
760	* dir is the direction to case.	788	* dir is the direction to case.
761	* rv is the vector which describes where the enemy is.	789	* rv is the vector which describes where the enemy is.
762	*/	790	*/
763
764	int	791	int
765	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)
766	{	793	{
767	object *spell_item;	794	object *spell_item;
768	object *owner;	795	object *owner;
…		…
779		806
780	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)	807	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
781	{	808	{
782	get_rangevector (head, owner, &rv1, 0x1);	809	get_rangevector (head, owner, &rv1, 0x1);
783	if (dirdiff (dir, rv1.direction) < 2)	810	if (dirdiff (dir, rv1.direction) < 2)
784	{
785	return 0; /* Might hit owner with spell */	811	return 0; /* Might hit owner with spell */
786	}
787	}	812	}
788		813
789	if (QUERY_FLAG (head, FLAG_CONFUSED))	814	if (QUERY_FLAG (head, FLAG_CONFUSED))
790	dir = absdir (dir + rndm (3) + rndm (3) - 2);	815	dir = absdir (dir + rndm (3) + rndm (3) - 2);
791		816
…		…
799	{	824	{
800	LOG (llevMonster, "Turned off spells in %s\n", &head->name);	825	LOG (llevMonster, "Turned off spells in %s\n", &head->name);
801	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 */
802	return 0;	827	return 0;
803	}	828	}
		829
804	if (spell_item->type == SPELLBOOK)	830	if (spell_item->type == SPELLBOOK)
805	{	831	{
806	if (!spell_item->inv)	832	if (!spell_item->inv)
807	{	833	{
808	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);
809	return 0;	835	return 0;
810	}	836	}
		837
811	spell_item = spell_item->inv;	838	spell_item = spell_item->inv;
812	}	839	}
813	}	840	}
814	else	841	else
815	spell_item = head->spellitem;	842	spell_item = head->spellitem;
…		…
834	/* 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 */
835	head->spellitem = NULL;	862	head->spellitem = NULL;
836		863
837	return cast_spell (part, part, dir, spell_item, NULL);	864	return cast_spell (part, part, dir, spell_item, NULL);
838	}	865	}
839
840		866
841	int	867	int
842	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)
843	{	869	{
844	object *scroll;	870	object *scroll;
…		…
973	if (!(--wand->stats.food))	999	if (!(--wand->stats.food))
974	{	1000	{
975	if (wand->arch)	1001	if (wand->arch)
976	{	1002	{
977	CLEAR_FLAG (wand, FLAG_ANIMATE);	1003	CLEAR_FLAG (wand, FLAG_ANIMATE);
978	wand->face = wand->arch->clone.face;	1004	wand->face = wand->arch->face;
979	wand->set_speed (0);	1005	wand->set_speed (0);
980	}	1006	}
981	}	1007	}
982	/* Success */	1008	/* Success */
983	return 1;	1009	return 1;
…		…
1208	case ROD:	1234	case ROD:
1209	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);	1235	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1210	break;	1236	break;
1211		1237
1212	case SPELLBOOK:	1238	case SPELLBOOK:
1213	flag = (monster->arch != NULL && QUERY_FLAG ((&monster->arch->clone), FLAG_CAST_SPELL));	1239	flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1214	break;	1240	break;
1215		1241
1216	case SCROLL:	1242	case SCROLL:
1217	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);	1243	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1218	break;	1244	break;
…		…
1236	}	1262	}
1237	}	1263	}
1238		1264
1239	if (((!(monster->pick_up & 32)) && flag) \|\| ((monster->pick_up & 32) && (!flag)))	1265	if (((!(monster->pick_up & 32)) && flag) \|\| ((monster->pick_up & 32) && (!flag)))
1240	return 1;	1266	return 1;
		1267
1241	return 0;	1268	return 0;
1242	}	1269	}
1243		1270
1244	/*	1271	/*
1245	* monster_apply_below():	1272	* monster_apply_below():
…		…
1287	void	1314	void
1288	monster_check_apply (object mon, object item)	1315	monster_check_apply (object mon, object item)
1289	{	1316	{
1290	int flag = 0;	1317	int flag = 0;
1291		1318
1292	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)))
1293	{	1320	{
1294	SET_FLAG (mon, FLAG_CAST_SPELL);	1321	SET_FLAG (mon, FLAG_CAST_SPELL);
1295	return;	1322	return;
1296	}	1323	}
1297		1324
…		…
1393	}	1420	}
1394		1421
1395	void	1422	void
1396	npc_call_help (object *op)	1423	npc_call_help (object *op)
1397	{	1424	{
1398	int x, y, mflags;	1425	unordered_mapwalk (op, -7, -7, 7, 7)
1399	object *npc;
1400	sint16 sx, sy;
1401	maptile *m;
1402
1403	for (x = -3; x < 4; x++)
1404	for (y = -3; y < 4; y++)
1405	{	1426	{
1406	m = op->map;	1427	mapspace &ms = m->at (nx, ny);
1407	sx = op->x + x;	1428
1408	sy = op->y + y;
1409	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1410	/* 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. */
1411	if ((mflags & P_OUT_OF_MAP) \|\| !(mflags & P_IS_ALIVE))	1430	if (!(ms.flags () & P_IS_ALIVE))
1412	continue;	1431	continue;
1413		1432
1414	for (npc = GET_MAP_OB (m, sx, sy); npc != NULL; npc = npc->above)	1433	for (object *npc = ms.bot; npc; npc = npc->above)
1415	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))	1434	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
1416	npc->enemy = op->enemy;	1435	npc->enemy = op->enemy;
1417	}	1436	}
1418	}	1437	}
1419		1438
1420	int	1439	int
1421	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)
1422	{	1441	{
1423	if (can_hit (part, enemy, rv))	1442	if (can_hit (part, enemy, rv))
1424	return dir;	1443	return dir;
		1444
1425	if (rv->distance < 10)	1445	if (rv->distance < 10)
1426	return absdir (dir + 4);	1446	return absdir (dir + 4);
1427	else if (rv->distance > 18)	1447	else if (rv->distance > 18)
1428	return dir;	1448	return dir;
1429		1449
1430	return 0;	1450	return 0;
1431	}	1451	}
1432		1452
1433	int	1453	int
1434	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)
1435	{	1455	{
1436	if ((can_hit (part, enemy, rv) && ob->move_status < 20) \|\| ob->move_status < 20)	1456	if (can_hit (part, enemy, rv))
1437	{
1438	ob->move_status++;
1439	return (dir);	1457	return dir;
1440	}	1458	else
1441	else if (ob->move_status > 20)
1442	ob->move_status = 0;
1443
1444	return absdir (dir + 4);	1459	return absdir (dir + 4);
1445	}	1460	}
1446		1461
1447	int	1462	int
1448	hitrun_att (int dir, object ob, object enemy)	1463	hitrun_att (int dir, object ob, object enemy)
1449	{	1464	{
…		…
1458	}	1473	}
1459		1474
1460	int	1475	int
1461	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)
1462	{	1477	{
1463
1464	int inrange = can_hit (part, enemy, rv);	1478	int inrange = can_hit (part, enemy, rv);
1465		1479
1466	if (ob->move_status \|\| inrange)	1480	if (ob->move_status \|\| inrange)
1467	ob->move_status++;	1481	ob->move_status++;
1468		1482
…		…
1478	}	1492	}
1479		1493
1480	int	1494	int
1481	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)
1482	{	1496	{
1483
1484	/* The logic below here looked plain wrong before. Basically, what should	1497	/* The logic below here looked plain wrong before. Basically, what should
1485	* 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,
1486	* the creature should run away (dir+4)	1499	* the creature should run away (dir+4)
1487	* 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
1488	* 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
…		…
1584	}	1597	}
1585		1598
1586	void	1599	void
1587	rand_move (object *ob)	1600	rand_move (object *ob)
1588	{	1601	{
1589	int i;
1590
1591	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)))))
1592	for (i = 0; i < 5; i++)	1603	for (int i = 0; i < 5; i++)
1593	if (move_object (ob, ob->move_status = rndm (8) + 1))	1604	if (move_object (ob, ob->move_status = rndm (8) + 1))
1594	return;	1605	return;
1595	}	1606	}
1596		1607
1597	void	1608	void
1598	check_earthwalls (object op, maptile m, int x, int y)	1609	check_earthwalls (object op, maptile m, int x, int y)
1599	{	1610	{
1600	object *tmp;
1601
1602	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)
1603	{
1604	if (tmp->type == EARTHWALL)	1612	if (tmp->type == EARTHWALL)
1605	{	1613	{
1606	hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);	1614	hit_player (tmp, op->stats.dam, op, AT_PHYSICAL, 1);
1607	return;	1615	return;
1608	}	1616	}
1609	}
1610	}	1617	}
1611		1618
1612	void	1619	void
1613	check_doors (object op, maptile m, int x, int y)	1620	check_doors (object op, maptile m, int x, int y)
1614	{	1621	{
1615	object *tmp;
1616
1617	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)
1618	{
1619	if (tmp->type == DOOR)	1623	if (tmp->type == DOOR)
1620	{	1624	{
1621	hit_player (tmp, 1000, op, AT_PHYSICAL, 1);	1625	hit_player (tmp, 1000, op, AT_PHYSICAL, 1);
1622	return;	1626	return;
1623	}	1627	}
1624	}
1625	}	1628	}
1626		1629
1627	/* find_mon_throw_ob() - modeled on find_throw_ob	1630	/* find_mon_throw_ob() - modeled on find_throw_ob
1628	* This is probably overly simplistic as it is now - We want	1631	* This is probably overly simplistic as it is now - We want
1629	* monsters to throw things like chairs and other pieces of	1632	* monsters to throw things like chairs and other pieces of
…		…
1669	* 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
1670	* 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
1671	* be within the valid range. MSW 2001-08-05	1674	* be within the valid range. MSW 2001-08-05
1672	* 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
1673	*/	1676	*/
1674
1675	int	1677	int
1676	can_detect_enemy (object op, object enemy, rv_vector * rv)	1678	can_detect_enemy (object op, object enemy, rv_vector * rv)
1677	{	1679	{
1678	int radius = MIN_MON_RADIUS, hide_discovery;
1679
1680	/* null detection for any of these condtions always */	1680	/* null detection for any of these condtions always */
1681	if (!op \|\| !enemy \|\| !op->map \|\| !enemy->map)	1681	if (!op \|\| !enemy \|\| !op->map \|\| !enemy->map)
1682	return 0;	1682	return 0;
1683		1683
1684	/* 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 */
…		…
1686	return 0;	1686	return 0;
1687		1687
1688	get_rangevector (op, enemy, rv, 0);	1688	get_rangevector (op, enemy, rv, 0);
1689		1689
1690	/* Monsters always ignore the DM */	1690	/* Monsters always ignore the DM */
1691	if ((op->type != PLAYER) && QUERY_FLAG (enemy, FLAG_WIZ))	1691	if (!op->is_player () && QUERY_FLAG (enemy, FLAG_WIZ))
1692	return 0;	1692	return 0;
1693		1693
1694	/* simple check. Should probably put some range checks in here. */	1694	/* simple check. Should probably put some range checks in here. */
1695	if (can_see_enemy (op, enemy))	1695	if (can_see_enemy (op, enemy))
1696	return 1;	1696	return 1;
1697		1697
1698	/* 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
1699	* finding enemies!	1699	* finding enemies!
1700	*/	1700	*/
1701	if (op->type == PLAYER)	1701	if (op->is_player ())
1702	return 0;	1702	return 0;
1703		1703
1704	/* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE	1704	/* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
1705	* 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
1706	*/	1706	*/
1707	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)))
1708	return 0;	1708	return 0;
1709		1709
		1710	int radius = MIN_MON_RADIUS;
		1711
1710	/* use this for invis also */	1712	/* use this for invis also */
1711	hide_discovery = op->stats.Int / 5;	1713	int hide_discovery = op->stats.Int / 5;
1712		1714
1713	/* Determine Detection radii */	1715	/* Determine Detection radii */
1714	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) */
1715	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);
1716	else	1718	else
1717	{ /* a level/INT/Dex adjustment for hiding */	1719	{ /* a level/INT/Dex adjustment for hiding */
1718	object *sk_hide;
1719	int bonus = (op->level / 2) + (op->stats.Int / 5);	1720	int bonus = op->level / 2 + op->stats.Int / 5;
1720		1721
1721	if (enemy->type == PLAYER)	1722	if (enemy->is_player ())
1722	{	1723	{
1723	if ((sk_hide = find_skill_by_number (enemy, SK_HIDING)))	1724	if (object *sk_hide = find_skill_by_number (enemy, SK_HIDING))
1724	bonus -= sk_hide->level;	1725	bonus -= sk_hide->level;
1725	else	1726	else
1726	{	1727	{
1727	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");
1728	make_visible (enemy);	1729	make_visible (enemy);
…		…
1737	} /* else creature has modifiers for hiding */	1738	} /* else creature has modifiers for hiding */
1738		1739
1739	/* Radii stealth adjustment. Only if you are stealthy	1740	/* Radii stealth adjustment. Only if you are stealthy
1740	* will you be able to sneak up closer to creatures */	1741	* will you be able to sneak up closer to creatures */
1741	if (QUERY_FLAG (enemy, FLAG_STEALTH))	1742	if (QUERY_FLAG (enemy, FLAG_STEALTH))
1742	radius = radius / 2, hide_discovery = hide_discovery / 3;	1743	{
		1744	radius /= 2;
		1745	hide_discovery /= 3;
		1746	}
1743		1747
1744	/* Radii adjustment for enemy standing in the dark */	1748	/* Radii adjustment for enemy standing in the dark */
1745	if (op->map->darkness > 0 && !stand_in_light (enemy))	1749	if (!stand_in_light (enemy))
1746	{	1750	{
1747	/* on dark maps body heat can help indicate location with infravision	1751	/* on dark maps body heat can help indicate location with infravision
1748	* undead don't have body heat, so no benefit detecting them.	1752	* undead don't have body heat, so no benefit detecting them.
1749	*/	1753	*/
1750	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))
1751	radius += op->map->darkness / 2;	1755	radius += op->map->darklevel () / 2;
1752	else	1756	else
1753	radius -= op->map->darkness / 2;	1757	radius -= op->map->darklevel () / 2;
1754		1758
1755	/* op next to a monster (and not in complete darkness)	1759	/* op next to a monster (and not in complete darkness)
1756	* the monster should have a chance to see you.	1760	* the monster should have a chance to see you.
1757	*/	1761	*/
1758	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)
1759	radius = MIN_MON_RADIUS;	1763	radius = MIN_MON_RADIUS;
1760	} /* if on dark map */	1764	} /* if on dark map */
1761		1765
1762	/* Lets not worry about monsters that have incredible detection	1766	/* Lets not worry about monsters that have incredible detection
1763	* 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
…		…
1765	* 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
1766	* do something. Note that the distance field in the	1770	* do something. Note that the distance field in the
1767	* 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
1768	* find that.	1772	* find that.
1769	*/	1773	*/
1770	if (radius > 13)	1774	// note that the above reasoning was utter bullshit even at the time it was written
1771	radius = 13;	1775	// we use 25, lets see if we have the cpu time for it
		1776	radius = min (25, radius);
1772		1777
1773	/* Enemy in range! Now test for detection */	1778	/* Enemy in range! Now test for detection */
1774	if ((int) rv->distance <= radius)	1779	if (rv->distance <= radius)
1775	{	1780	{
1776	/* ah, we are within range, detected? take cases */	1781	/* ah, we are within range, detected? take cases */
1777	if (!enemy->invisible) /* enemy in dark squares... are seen! */	1782	if (!enemy->invisible) /* enemy in dark squares... are seen! */
1778	return 1;	1783	return 1;
1779		1784
1780	/* hidden or low-quality invisible */	1785	/* hidden or low-quality invisible */
1781	if (enemy->hide && (rv->distance <= 1) && (rndm (100) <= hide_discovery))	1786	if (enemy->flag [FLAG_HIDDEN] && rv->distance <= 1 && rndm (100) <= hide_discovery)
1782	{	1787	{
1783	make_visible (enemy);	1788	make_visible (enemy);
		1789
1784	/* inform players of new status */	1790	/* inform players of new status */
1785	if (enemy->type == PLAYER && player_can_view (enemy, op))	1791	if (enemy->type == PLAYER && player_can_view (enemy, op))
1786	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
1787	return 1; /* detected enemy */	1794	return 1; /* detected enemy */
1788	}	1795	}
1789	else if (enemy->invisible)	1796	else if (enemy->invisible)
1790	{	1797	{
1791	/* Change this around - instead of negating the invisible, just	1798	/* Change this around - instead of negating the invisible, just
1792	* 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
1793	* do something to you. Decreasing the duration of invisible	1800	* do something to you. Decreasing the duration of invisible
1794	* 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
1795	* can then basically negate the spell. The spell isn't negated -	1802	* can then basically negate the spell. The spell isn't negated -
1796	* they just know where you are!	1803	* they just know where you are!
1797	*/	1804	*/
1798	if ((rndm (50)) <= hide_discovery)	1805	if (rndm (50) <= hide_discovery)
1799	{	1806	{
1800	if (enemy->type == PLAYER)	1807	if (enemy->type == PLAYER)
1801	{
1802	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));
1803	}	1809
1804	return 1;	1810	return 1;
1805	}	1811	}
1806	}	1812	}
1807	} /* within range */	1813	} /* within range */
1808		1814
1809	/* Wasn't detected above, so still hidden */	1815	/* Wasn't detected above, so still hidden */
1810	return 0;	1816	return 0;
1811	}	1817	}
1812		1818
1813	/* 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
1814	* intellegent algorithm. For one thing, we ignore los here, SO it	1820	* intelligent algorithm. For one thing, we ignore los here, SO it
1815	* 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
1816	* other side of a wall (!).	1822	* other side of a wall (!).
1817	*/	1823	*/
1818	int	1824	int
1819	stand_in_light (object *op)	1825	stand_in_light (object *op)
1820	{	1826	{
1821	sint16 nx, ny;
1822	maptile *m;
1823
1824	if (!op)	1827	if (op)
		1828	{
		1829	if (!op->is_on_map ())
1825	return 0;	1830	return 0;
1826		1831
		1832	if (op->map->darklevel () <= 0)
		1833	return 1;
		1834
1827	if (op->glow_radius > 0)	1835	if (op->glow_radius > 0)
1828	return 1;	1836	return 1;
1829		1837
1830	if (op->map)	1838	if (op->map)
1831	{	1839	unordered_mapwalk (op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)
1832	int x, y, x1, y1;	1840	{
1833
1834	/* 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
1835	* 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.
1836	*/
1837	for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++)
1838	{
1839	for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++)
1840	{	1843	*/
1841	m = op->map;	1844	int light = m->at (nx, ny).light;
1842	nx = x;
1843	ny = y;
1844		1845
1845	if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)	1846	if (expect_false (light > 0) && idistance (dx, dy) <= light)
1846	continue;
1847
1848	x1 = abs (x - op->x) * abs (x - op->x);
1849	y1 = abs (y - op->y) * abs (y - op->y);
1850	if (isqrt (x1 + y1) < GET_MAP_LIGHT (m, nx, ny))
1851	return 1;	1847	return 1;
1852	}	1848	}
1853	}
1854	}	1849	}
1855		1850
1856	return 0;	1851	return 0;
1857	}	1852	}
1858		1853
…		…
1882	{	1877	{
1883	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!	1878	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1884	* However,if you carry any source of light, then the hidden	1879	* However,if you carry any source of light, then the hidden
1885	* creature is seeable (and stupid) */	1880	* creature is seeable (and stupid) */
1886		1881
1887	if (has_carried_lights (enemy))	1882	if (enemy->has_carried_lights ())
1888	{	1883	{
1889	if (enemy->hide)	1884	if (enemy->flag [FLAG_HIDDEN])
1890	{	1885	{
1891	make_visible (enemy);	1886	make_visible (enemy);
1892	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!");
1893	}	1888	}
		1889
1894	return 1;	1890	return 1;
1895	}	1891	}
1896	else if (enemy->hide)	1892	else if (enemy->flag [FLAG_HIDDEN])
1897	return 0;	1893	return 0;
1898		1894
1899	/* Invisible enemy. Break apart the check for invis undead/invis looker	1895	/* Invisible enemy. Break apart the check for invis undead/invis looker
1900	* 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,
1901	* and making it a conditional makes the code pretty ugly.	1897	* and making it a conditional makes the code pretty ugly.
1902	*/	1898	*/
1903	if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))	1899	if (!QUERY_FLAG (looker, FLAG_SEE_INVISIBLE))
1904	{
1905	if (makes_invisible_to (enemy, looker))	1900	if (makes_invisible_to (enemy, looker))
1906	return 0;	1901	return 0;
1907	}
1908	}	1902	}
1909	else if (looker->type == PLAYER) /* for players, a (possible) shortcut */	1903	else if (looker->is_player ()) /* for players, a (possible) shortcut */
1910	if (player_can_view (looker, enemy))	1904	if (player_can_view (looker, enemy))
1911	return 1;	1905	return 1;
1912		1906
1913	/* ENEMY IN DARK MAP. Without infravision, the enemy is not seen	1907	/* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
1914	* unless they carry a light or stand in light. Darkness doesnt	1908	* unless they carry a light or stand in light. Darkness doesnt
…		…
1917	* we care about the enemy maps status, not the looker.	1911	* we care about the enemy maps status, not the looker.
1918	* only relevant for tiled maps, but it is possible that the	1912	* only relevant for tiled maps, but it is possible that the
1919	* 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
1920	* case, the looker can still see the enemy	1914	* case, the looker can still see the enemy
1921	*/	1915	*/
1922	if (enemy->map->darkness > 0 && !stand_in_light (enemy)	1916	if (!stand_in_light (enemy)
1923	&& (!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)))
1924	return 0;	1918	return 0;
1925		1919
1926	return 1;	1920	return 1;
1927	}	1921	}
		1922

Diff Legend

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

Comparing deliantra/server/server/monster.C (file contents): Revision 1.32 by root, Sat May 12 18:14:48 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.32 by root, Sat May 12 18:14:48 2007 UTC vs.
Revision 1.65 by root, Fri Sep 25 18:44:58 2009 UTC