ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.58 by root, Sun Dec 28 08:56:44 2008 UTC vs.
Revision 1.78 by root, Sun Feb 7 04:22:33 2010 UTC

…		…
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* Deliantra 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 3 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, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
		24
		25	//+GPL
23		26
24	#include <global.h>	27	#include <global.h>
25	#include <sproto.h>	28	#include <sproto.h>
26	#include <spells.h>	29	#include <spells.h>
27	#include <skills.h>	30	#include <skills.h>
…		…
46	npc->enemy = NULL;	49	npc->enemy = NULL;
47	else if (npc->enemy == NULL)	50	else if (npc->enemy == NULL)
48	npc->enemy = npc->owner->enemy;	51	npc->enemy = npc->owner->enemy;
49	}	52	}
50		53
51	/* periodically, a monster mayu change its target. Also, if the object	54	/* periodically, a monster may change its target. Also, if the object
52	* has been destroyed, etc, clear the enemy.	55	* has been destroyed, etc, clear the enemy.
53	* TODO: this should be changed, because it invokes to attack forced or	56	* TODO: this should be changed, because it invokes to attack forced or
54	* attacked monsters to leave the attacker alone, before it is destroyed	57	* attacked monsters to leave the attacker alone, before it is destroyed
55	*/	58	*/
56	/* i had removed the random target leave, this invokes problems with friendly	59	/* I had removed the random target leave, this invokes problems with friendly
57	* objects, getting attacked and defending herself - they don't try to attack	60	* objects, getting attacked and defending herself - they don't try to attack
58	* again then but perhaps get attack on and on	61	* again then but perhaps get attack on and on
59	* If we include a aggravated flag in , we can handle evil vs evil and good vs good	62	* If we include a aggravated flag in , we can handle evil vs evil and good vs good
60	* too. */	63	* too. */
61		64
…		…
65	* the grouping checks are. Code is the same.	68	* the grouping checks are. Code is the same.
66	*/	69	*/
67	if (QUERY_FLAG (npc->enemy, FLAG_REMOVED) ||	70	if (QUERY_FLAG (npc->enemy, FLAG_REMOVED) ||
68	QUERY_FLAG (npc->enemy, FLAG_FREED) ||	71	QUERY_FLAG (npc->enemy, FLAG_FREED) ||
69	!on_same_map (npc, npc->enemy) || npc == npc->enemy || QUERY_FLAG (npc, FLAG_NEUTRAL) || QUERY_FLAG (npc->enemy, FLAG_NEUTRAL))	72	!on_same_map (npc, npc->enemy) || npc == npc->enemy || QUERY_FLAG (npc, FLAG_NEUTRAL) || QUERY_FLAG (npc->enemy, FLAG_NEUTRAL))
70	npc->enemy = NULL;	73	npc->enemy = 0;
71		74
72	else if (QUERY_FLAG (npc, FLAG_FRIENDLY) && ((QUERY_FLAG (npc->enemy, FLAG_FRIENDLY)	75	else if (QUERY_FLAG (npc, FLAG_FRIENDLY) && ((QUERY_FLAG (npc->enemy, FLAG_FRIENDLY)
73	&& !(should_arena_attack (npc, npc->owner, npc->enemy)))	76	&& !(should_arena_attack (npc, npc->owner, npc->enemy)))
74	|| ((npc->enemy->type == PLAYER) && !(should_arena_attack (npc, npc->owner, npc->enemy)))	77	|| ((npc->enemy->type == PLAYER) && !(should_arena_attack (npc, npc->owner, npc->enemy)))
75	|| npc->enemy == npc->owner))	78	|| npc->enemy == npc->owner))
76	npc->enemy = NULL;	79	npc->enemy = 0;
77		80
78		81
79	else if (!QUERY_FLAG (npc, FLAG_FRIENDLY) && (!QUERY_FLAG (npc->enemy, FLAG_FRIENDLY) && npc->enemy->type != PLAYER))	82	else if (!QUERY_FLAG (npc, FLAG_FRIENDLY) && (!QUERY_FLAG (npc->enemy, FLAG_FRIENDLY) && npc->enemy->type != PLAYER))
80	npc->enemy = NULL;	83	npc->enemy = 0;
81		84
82	/* I've noticed that pets could sometimes get an arrow as the	85	/* I've noticed that pets could sometimes get an arrow as the
83	* target enemy - this code below makes sure the enemy is something	86	* target enemy - this code below makes sure the enemy is something
84	* that should be attacked. My guess is that the arrow hits	87	* that should be attacked. My guess is that the arrow hits
85	* the creature/owner, and so the creature then takes that	88	* the creature/owner, and so the creature then takes that
…		…
87	*/	90	*/
88	else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER)	91	else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER)
89	&& !QUERY_FLAG (npc->enemy, FLAG_GENERATOR)	92	&& !QUERY_FLAG (npc->enemy, FLAG_GENERATOR)
90	&& npc->enemy->type != PLAYER	93	&& npc->enemy->type != PLAYER
91	&& npc->enemy->type != GOLEM)	94	&& npc->enemy->type != GOLEM)
92	npc->enemy = NULL;	95	npc->enemy = 0;
93
94	}	96	}
95		97
96	return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : NULL;	98	return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : 0;
97	}	99	}
98		100
99	/* Returns the nearest living creature (monster or generator).	101	/* Returns the nearest living creature (monster or generator).
100	* Modified to deal with tiled maps properly.	102	* Modified to deal with tiled maps properly.
101	* Also fixed logic so that monsters in the lower directions were more	103	* Also fixed logic so that monsters in the lower directions were more
…		…
151	* Currently, only move_monster calls this function.	153	* Currently, only move_monster calls this function.
152	* Fix function so that we always make calls to get_rangevector	154	* Fix function so that we always make calls to get_rangevector
153	* if we have a valid target - function as not doing so in	155	* if we have a valid target - function as not doing so in
154	* many cases.	156	* many cases.
155	*/	157	*/
156	object *	158	static object *
157	find_enemy (object *npc, rv_vector * rv)	159	find_enemy (object *npc, rv_vector * rv)
158	{	160	{
159	object *attacker, *tmp = NULL;	161	object *attacker, *tmp = NULL;
160		162
161	attacker = npc->attacked_by; /* save this for later use. This can be a attacker. */	163	attacker = npc->attacked_by; /* save this for later use. This can be a attacker. */
…		…
229	/* Sees if this monster should wake up.	231	/* Sees if this monster should wake up.
230	* Currently, this is only called from move_monster, and	232	* Currently, this is only called from move_monster, and
231	* if enemy is set, then so should be rv.	233	* if enemy is set, then so should be rv.
232	* returns 1 if the monster should wake up, 0 otherwise.	234	* returns 1 if the monster should wake up, 0 otherwise.
233	*/	235	*/
234	int	236	static int
235	check_wakeup (object *op, object *enemy, rv_vector *rv)	237	check_wakeup (object *op, object *enemy, rv_vector *rv)
236	{	238	{
237	/* Trim work - if no enemy, no need to do anything below */	239	/* Trim work - if no enemy, no need to do anything below */
238	if (!enemy)	240	if (!enemy)
239	return 0;	241	return 0;
…		…
270	}	272	}
271		273
272	return 0;	274	return 0;
273	}	275	}
274		276
275	int	277	static int
276	move_randomly (object *op)	278	move_randomly (object *op)
277	{	279	{
278	/* Give up to 15 chances for a monster to move randomly */	280	/* Give up to 15 chances for a monster to move randomly */
279	for (int i = 0; i < 15; i++)	281	for (int i = 0; i < 15; i++)
280	if (move_object (op, rndm (8) + 1))	282	if (move_object (op, rndm (8) + 1))
…		…
282		284
283	return 0;	285	return 0;
284	}	286	}
285		287
286	/*	288	/*
287	* Move-monster returns 1 if the object has been freed, otherwise 0.	289	* monster_can_pick(): If the monster is interested in picking up
		290	* the item, then return 0. Otherwise 0.
		291	* Instead of pick_up, flags for "greed", etc, should be used.
		292	* I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
288	*/	293	*/
289	int	294	static int
290	move_monster (object *op)	295	monster_can_pick (object *monster, object *item)
291	{	296	{
292	int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */	297	int flag = 0;
293	object *owner, *enemy, *part, *oph = op;	298	int i;
294	rv_vector rv;
295		299
296	/* Monsters not on maps don't do anything. These monsters are things	300	if (!can_pick (monster, item))
297	* Like royal guards in city dwellers inventories.	301	return 0;
		302
		303	if (QUERY_FLAG (item, FLAG_UNPAID))
		304	return 0;
		305
		306	if (monster->pick_up & 64) /* All */
		307	flag = 1;
		308
		309	else
		310	switch (item->type)
		311	{
		312	case MONEY:
		313	case GEM:
		314	flag = monster->pick_up & 2;
		315	break;
		316
		317	case FOOD:
		318	flag = monster->pick_up & 4;
		319	break;
		320
		321	case WEAPON:
		322	flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON);
		323	break;
		324
		325	case ARMOUR:
		326	case SHIELD:
		327	case HELMET:
		328	case BOOTS:
		329	case GLOVES:
		330	case GIRDLE:
		331	flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR);
		332	break;
		333
		334	case SKILL:
		335	flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);
		336	break;
		337
		338	case RING:
		339	flag = QUERY_FLAG (monster, FLAG_USE_RING);
		340	break;
		341
		342	case WAND:
		343	case HORN:
		344	case ROD:
		345	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
		346	break;
		347
		348	case SPELLBOOK:
		349	flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
		350	break;
		351
		352	case SCROLL:
		353	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
		354	break;
		355
		356	case BOW:
		357	case ARROW:
		358	flag = QUERY_FLAG (monster, FLAG_USE_BOW);
		359	break;
		360	}
		361
		362	/* Simplistic check - if the monster has a location to equip it, he will
		363	* pick it up. Note that this doesn't handle cases where an item may
		364	* use several locations.
298	*/	365	*/
299	if (!op->map)	366	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
		367	{
		368	if (monster->slot[i].info && item->slot[i].info)
		369	{
		370	flag = 1;
		371	break;
		372	}
		373	}
		374
		375	if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && (!flag)))
300	return 0;	376	return 1;
301		377
302	/* for target facing, we copy this value here for fast access */	378	return 0;
303	if (oph->head) /* force update the head - one arch one pic */	379	}
304	oph = oph->head;
305		380
306	if (QUERY_FLAG (op, FLAG_NO_ATTACK)) /* we never ever attack */	381	/*
307	enemy = op->enemy = NULL;	382	* monster_check_pickup(): checks for items that monster can pick up.
308	else if ((enemy = find_enemy (op, &rv)))	383	*
309	/* we have an enemy, just tell him we want him dead */	384	* Vick's (vick@bern.docs.uu.se) fix 921030 for the sweeper blob.
310	enemy->attacked_by = op; /* our ptr */	385	* Each time the blob passes over some treasure, it will
		386	* grab it a.s.a.p.
		387	*
		388	* Eneq(@csd.uu.se): This can now be defined in the archetypes, added code
		389	* to handle this.
		390	*
		391	* This function was seen be continueing looping at one point (tmp->below
		392	* became a recursive loop. It may be better to call monster_check_apply
		393	* after we pick everything up, since that function may call others which
		394	* affect stacking on this space.
		395	*/
		396	static void
		397	monster_check_pickup (object *monster)
		398	{
		399	object *tmp, *next;
311		400
312	/* generate hp, if applicable */	401	for (tmp = monster->below; tmp != NULL; tmp = next)
313	if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)
314	{	402	{
315	/* last heal is in funny units. Dividing by speed puts	403	next = tmp->below;
316	* the regeneration rate on a basis of time instead of	404	if (monster_can_pick (monster, tmp))
317	* #moves the monster makes. The scaling by 8 is
318	* to capture 8th's of a hp fraction regens
319	*	405	{
320	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)	406	tmp->remove ();
321	* overflow might produce monsters with negative hp.	407	tmp = insert_ob_in_ob (tmp, monster);
		408	monster_check_apply (monster, tmp);
		409	}
		410
		411	/* We could try to re-establish the cycling, of the space, but probably
		412	* not a big deal to just bail out.
322	*/	413	*/
323		414	if (next && next->destroyed ())
324	op->last_heal += (int) ((float) (8 * op->stats.Con) / FABS (op->speed));
325	op->stats.hp = MIN ((sint32) op->stats.hp + op->last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */
326	op->last_heal %= 32;
327
328	/* So if the monster has gained enough HP that they are no longer afraid */
329	if (QUERY_FLAG (op, FLAG_RUN_AWAY) && op->stats.hp >= (signed short)(((float)op->run_away / 100.f) * (float)op->stats.maxhp))
330	CLEAR_FLAG (op, FLAG_RUN_AWAY);
331
332	if (op->stats.hp > op->stats.maxhp)
333	op->stats.hp = op->stats.maxhp;
334	}
335
336	/* generate sp, if applicable */
337	if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)
338	{
339	/* last_sp is in funny units. Dividing by speed puts
340	* the regeneration rate on a basis of time instead of
341	* #moves the monster makes. The scaling by 8 is
342	* to capture 8th's of a sp fraction regens
343	*
344	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)
345	* overflow might produce monsters with negative sp.
346	*/
347
348	op->last_sp += (int) ((float) (8 * op->stats.Pow) / fabsf (op->speed));
349	op->stats.sp = min (op->stats.sp + op->last_sp / 128, op->stats.maxsp); /* causes Pow/16 sp/tick */
350	op->last_sp %= 128;
351	}
352
353	/* this should probably get modified by many more values.
354	* (eg, creatures resistance to fear, level, etc. )
355	*/
356	if (QUERY_FLAG (op, FLAG_SCARED) && !(rndm (20)))
357	CLEAR_FLAG (op, FLAG_SCARED); /* Time to regain some "guts"... */
358
359	if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))
360	return QUERY_FLAG (op, FLAG_FREED);
361
362	if (QUERY_FLAG (op, FLAG_SLEEP) || QUERY_FLAG (op, FLAG_BLIND) ||
363	((op->map->darklevel () > 0) && !QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))
364	if (!check_wakeup (op, enemy, &rv))
365	return 0;
366
367	/* check if monster pops out of hidden spot */
368	if (op->flag [FLAG_HIDDEN])
369	do_hidden_move (op);
370
371	if (op->pick_up)
372	monster_check_pickup (op);
373
374	if (op->will_apply)
375	monster_apply_below (op); /* Check for items to apply below */
376
377	/* If we don't have an enemy, do special movement or the like */
378	if (!enemy)
379	{
380	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
381	{
382	op->drop_and_destroy ();
383	return 1;	415	return;
		416	}
		417	}
		418
		419	/*
		420	* monster_apply_below():
		421	* Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
		422	* eager to apply things, encounters something apply-able,
		423	* then make him apply it
		424	*/
		425	static void
		426	monster_apply_below (object *monster)
		427	{
		428	object *tmp, *next;
		429
		430	for (tmp = monster->below; tmp != NULL; tmp = next)
		431	{
		432	next = tmp->below;
		433	switch (tmp->type)
384	}	434	{
385		435	case T_HANDLE:
386	/* Probably really a bug for a creature to have both	436	case TRIGGER:
387	* stand still and a movement type set.	437	if (monster->will_apply & 1)
388	*/	438	manual_apply (monster, tmp, 0);
389	if (!QUERY_FLAG (op, FLAG_STAND_STILL))
390	{
391	if (op->attack_movement & HI4)
392	{
393	switch (op->attack_movement & HI4)
394	{
395	case (PETMOVE):
396	pet_move (op);
397	break;
398
399	case (CIRCLE1):
400	circ1_move (op);
401	break;
402
403	case (CIRCLE2):
404	circ2_move (op);
405	break;
406
407	case (PACEV):
408	pace_movev (op);
409	break;
410
411	case (PACEH):
412	pace_moveh (op);
413	break;
414
415	case (PACEV2):
416	pace2_movev (op);
417	break;
418
419	case (PACEH2):
420	pace2_moveh (op);
421	break;
422
423	case (RANDO):
424	rand_move (op);
425	break;
426
427	case (RANDO2):
428	move_randomly (op);
429	break;
430	}
431
432	return 0;
433	}
434	else if (QUERY_FLAG (op, FLAG_RANDOM_MOVE))
435	move_randomly (op);
436	} /* stand still */
437
438	return 0;
439	} /* no enemy */
440
441	/* We have an enemy. Block immediately below is for pets */
442	if ((op->attack_movement & HI4) == PETMOVE
443	&& (owner = op->owner) != NULL
444	&& !on_same_map (op, owner)
445	&& !owner->flag [FLAG_REMOVED])
446	return follow_owner (op, owner);
447
448	/* doppleganger code to change monster facing to that of the nearest
449	* player. Hmm. The code is here, but no monster in the current
450	* arch set uses it.
451	*/
452	if (op->race && strcmp (op->race, "doppleganger") == 0)
453	{
454	op->face = enemy->face;
455	op->name = enemy->name;
456	}
457
458	/* Calculate range information for closest body part - this
459	* is used for the 'skill' code, which isn't that smart when
460	* it comes to figuring it out - otherwise, giants throw boulders
461	* into themselves.
462	*/
463	get_rangevector (op, enemy, &rv, 0);
464
465	/* Move the check for scared up here - if the monster was scared,
466	* we were not doing any of the logic below, so might as well save
467	* a few cpu cycles.
468	*/
469	if (!QUERY_FLAG (op, FLAG_SCARED))
470	{
471	rv_vector rv1;
472
473	/* now we test every part of an object .... this is a real ugly piece of code */
474	for (part = op; part; part = part->more)
475	{
476	get_rangevector (part, enemy, &rv1, 0x1);
477	dir = rv1.direction;
478
479	/* hm, not sure about this part - in original was a scared flag here too
480	* but that we test above... so can be old code here
481	*/
482	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
483	dir = absdir (dir + 4);
484
485	if (QUERY_FLAG (op, FLAG_CONFUSED))
486	dir = absdir (dir + rndm (3) + rndm (3) - 2);
487
488	if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(rndm (3)))
489	if (monster_cast_spell (op, part, enemy, dir, &rv1))
490	return 0;
491
492	if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(rndm (3)))
493	if (monster_use_scroll (op, part, enemy, dir, &rv1))
494	return 0;
495
496	if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(rndm (3)))
497	if (monster_use_range (op, part, enemy, dir))
498	return 0;
499
500	if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(rndm (3)))
501	if (monster_use_skill (op, rv.part, enemy, rv.direction))
502	return 0;
503
504	if (QUERY_FLAG (op, FLAG_READY_BOW) && !(rndm (2)))
505	if (monster_use_bow (op, part, enemy, dir))
506	return 0;
507	} /* for processing of all parts */
508	} /* If not scared */
509
510	part = rv.part;
511	dir = rv.direction;
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 (enemy->contr && enemy->contr->darkness_at (op->map, op->x, op->y) == LOS_BLOCKED)
517	{
518	int sdir = 0;
519
520	for (int ndir = 1; ndir <= 8; ++ndir)
521	{
522	mapxy pos (op); pos.move (ndir);
523
524	if (pos.normalise ())
525	{
526	mapspace &ms = pos.ms ();
527
528	if (ms.smell > op->ms ().smell)
529	{
530	//printf ("%s: found smell, following it, apparently (%d, %d)\n",& op->name,op->ms().smell,ms.smell);//D
531	op->ms ().smell = ms.smell - 1; // smarter: tell others
532	sdir = ndir;
533
534	// perturbing the path might let the monster lose track,
535	// but it will also widen the actual path, spreading information
536	if (!rndm (20)) // even smarter, deviate and spread?
537	sdir += absdir (1 - rndm (2) * 2);
538	}
539	}
540	}
541
542	if (sdir)
543	dir = sdir;
544	else if (op->ms ().smell)
545	{
546	// no better smell found, so assume the player jumped, and erase this smell
547	//printf ("erasing smell %d\n", op->ms ().smell);//D
548	ordered_mapwalk_begin (op, -1, -1, 1, 1)
549	if (m)
550	m->at (nx, ny).smell = 0;
551	ordered_mapwalk_end
552	}
553	}
554
555	if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY))
556	dir = absdir (dir + 4);
557
558	if (QUERY_FLAG (op, FLAG_CONFUSED))
559	dir = absdir (dir + rndm (3) + rndm (3) - 2);
560
561	pre_att_dir = dir; /* remember the original direction */
562
563	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))
564	{
565	switch (op->attack_movement & LO4)
566	{
567	case DISTATT:
568	dir = dist_att (dir, op, enemy, part, &rv);
569	break;	439	break;
570		440
571	case RUNATT:	441	case TREASURE:
572	dir = run_att (dir, op, enemy, part, &rv);	442	if (monster->will_apply & 2)
		443	manual_apply (monster, tmp, 0);
573	break;	444	break;
574		445
575	case HITRUN:
576	dir = hitrun_att (dir, op, enemy);
577	break;
578
579	case WAITATT:
580	dir = wait_att (dir, op, enemy, part, &rv);
581	break;
582
583	case RUSH: /* default - monster normally moves towards player */
584	case ALLRUN:
585	break;
586
587	case DISTHIT:
588	dir = disthit_att (dir, op, enemy, part, &rv);
589	break;
590
591	case WAIT2:
592	dir = wait_att2 (dir, op, enemy, part, &rv);
593	break;
594
595	default:
596	LOG (llevDebug, "Illegal low mon-move: %d\n", op->attack_movement & LO4);
597	}
598	}
599
600	if (!dir)
601	return 0;
602
603	if (!QUERY_FLAG (op, FLAG_STAND_STILL))
604	{
605	if (move_object (op, dir)) /* Can the monster move directly toward player? */
606	{	446	}
607	/* elmex: Turn our monster after it moved if it has DISTATT attack */	447	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
608	if ((op->attack_movement & LO4) == DISTATT)	448	break;
609	op->direction = pre_att_dir;
610
611	return 0;
612	}
613
614	if (QUERY_FLAG (op, FLAG_SCARED) || !can_hit (part, enemy, &rv) || QUERY_FLAG (op, FLAG_RUN_AWAY))
615	{
616	/* Try move around corners if !close */
617	int maxdiff = (QUERY_FLAG (op, FLAG_ONLY_ATTACK) || rndm (2)) ? 1 : 2;
618
619	for (diff = 1; diff <= maxdiff; diff++)
620	{
621	/* try different detours */
622	int m = 1 - rndm (2) * 2; /* Try left or right first? */
623
624	if (move_object (op, absdir (dir + diff * m)) || move_object (op, absdir (dir - diff * m)))
625	return 0;
626	}
627	}
628	} /* if monster is not standing still */
629
630	/* elmex: Turn our monster after it moved if it has DISTATT attack */
631	if ((op->attack_movement & LO4) == DISTATT)
632	op->direction = pre_att_dir;
633
634	/*
635	* Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random
636	* direction if they can't move away.
637	*/
638	if (!QUERY_FLAG (op, FLAG_ONLY_ATTACK) && (QUERY_FLAG (op, FLAG_RUN_AWAY) || QUERY_FLAG (op, FLAG_SCARED)))
639	if (move_randomly (op))
640	return 0;
641
642	/*
643	* Try giving the monster a new enemy - the player that is closest
644	* to it. In this way, it won't just keep trying to get to a target
645	* that is inaccessible.
646	* This could be more clever - it should go through a list of several
647	* enemies, as it is now, you could perhaps get situations where there
648	* are two players flanking the monster at close distance, but which
649	* the monster can't get to, and a third one at a far distance that
650	* the monster could get to - as it is, the monster won't look at that
651	* third one.
652	*/
653	if (!QUERY_FLAG (op, FLAG_FRIENDLY) && enemy == op->enemy)
654	{	449	}
655	object *nearest_player = get_nearest_player (op);
656
657	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))
658	{
659	op->enemy = 0;
660	enemy = nearest_player;
661	}
662	}
663
664	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))
665	{
666	/* The adjustement to wc that was here before looked totally bogus -
667	* since wc can in fact get negative, that would mean by adding
668	* the current wc, the creature gets better? Instead, just
669	* add a fixed amount - nasty creatures that are runny away should
670	* still be pretty nasty.
671	*/
672	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
673	{
674	part->stats.wc += 10;
675	skill_attack (enemy, part, 0, NULL, NULL);
676	part->stats.wc -= 10;
677	}
678	else
679	skill_attack (enemy, part, 0, NULL, NULL);
680	} /* if monster is in attack range */
681
682	if (QUERY_FLAG (part, FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */
683	return 1;
684
685	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
686	{
687	op->drop_and_destroy ();
688	return 1;
689	}
690
691	return 0;
692	}
693
694	int
695	can_hit (object *ob1, object *ob2, rv_vector * rv)
696	{
697	object *more;
698	rv_vector rv1;
699
700	if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(rndm (3)))
701	return 0;
702
703	if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)
704	return 1;
705
706	/* check all the parts of ob2 - just because we can't get to
707	* its head doesn't mean we don't want to pound its feet
708	*/
709	for (more = ob2->more; more != NULL; more = more->more)
710	{
711	get_rangevector (ob1, more, &rv1, 0);
712	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
713	return 1;
714	}
715
716	return 0;
717	}	450	}
718		451
719	/* Returns 1 is monster should cast spell sp at an enemy	452	/* Returns 1 is monster should cast spell sp at an enemy
720	* Returns 0 if the monster should not cast this spell.	453	* Returns 0 if the monster should not cast this spell.
721	*	454	*
…		…
729	*	462	*
730	* This could be a lot smarter - if there are few monsters around,	463	* This could be a lot smarter - if there are few monsters around,
731	* then disease might not be as bad. Likewise, if the monster is damaged,	464	* then disease might not be as bad. Likewise, if the monster is damaged,
732	* the right type of healing spell could be useful.	465	* the right type of healing spell could be useful.
733	*/	466	*/
734
735	static int	467	static int
736	monster_should_cast_spell (object *monster, object *spell_ob)	468	monster_should_cast_spell (object *monster, object *spell_ob)
737	{	469	{
738	if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||	470	if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||
739	spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||	471	spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||
…		…
744	return 1;	476	return 1;
745		477
746	return 0;	478	return 0;
747	}	479	}
748		480
749	#define MAX_KNOWN_SPELLS 20
750
751	/* Returns a randomly selected spell. This logic is still
752	* less than ideal. This code also only seems to deal with
753	* wizard spells, as the check is against sp, and not grace.
754	* can mosnters know cleric spells?
755	*/
756	object *
757	monster_choose_random_spell (object *monster)
758	{
759	object *altern[MAX_KNOWN_SPELLS];
760	int i = 0;
761
762	for (object *tmp = monster->inv; tmp; tmp = tmp->below)
763	if (tmp->type == SPELLBOOK || tmp->type == SPELL)
764	{
765	/* Check and see if it's actually a useful spell.
766	* If its a spellbook, the spell is actually the inventory item.
767	* if it is a spell, then it is just the object itself.
768	*/
769	if (monster_should_cast_spell (monster, (tmp->type == SPELLBOOK) ? tmp->inv : tmp))
770	{
771	altern [i++] = tmp;
772
773	if (i == MAX_KNOWN_SPELLS)
774	break;
775	}
776	}
777
778	return i ? altern [rndm (i)] : 0;
779	}
780
781	/* This checks to see if the monster should cast a spell/ability.
782	* it returns true if the monster casts a spell, 0 if he doesn't.
783	* head is the head of the monster.
784	* part is the part of the monster we are checking against.
785	* pl is the target.
786	* dir is the direction to case.
787	* rv is the vector which describes where the enemy is.
788	*/
789	int
790	monster_cast_spell (object *head, object *part, object *pl, int dir, rv_vector * rv)
791	{
792	object *spell_item;
793	object *owner;
794	rv_vector rv1;
795
796	/* If you want monsters to cast spells over friends, this spell should
797	* be removed. It probably should be in most cases, since monsters still
798	* don't care about residual effects (ie, casting a cone which may have a
799	* clear path to the player, the side aspects of the code will still hit
800	* other monsters)
801	*/
802	if (!(dir = path_to_player (part, pl, 0)))
803	return 0;
804
805	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
806	{
807	get_rangevector (head, owner, &rv1, 0x1);
808	if (dirdiff (dir, rv1.direction) < 2)
809	return 0; /* Might hit owner with spell */
810	}
811
812	if (QUERY_FLAG (head, FLAG_CONFUSED))
813	dir = absdir (dir + rndm (3) + rndm (3) - 2);
814
815	/* If the monster hasn't already chosen a spell, choose one
816	* I'm not sure if it really make sense to pre-select spells (events
817	* could be different by the time the monster goes again).
818	*/
819	if (head->spellitem == NULL)
820	{
821	if ((spell_item = monster_choose_random_spell (head)) == NULL)
822	{
823	LOG (llevMonster, "Turned off spells in %s\n", &head->name);
824	CLEAR_FLAG (head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
825	return 0;
826	}
827
828	if (spell_item->type == SPELLBOOK)
829	{
830	if (!spell_item->inv)
831	{
832	LOG (llevError, "spellbook %s does not contain a spell?\n", &spell_item->name);
833	return 0;
834	}
835
836	spell_item = spell_item->inv;
837	}
838	}
839	else
840	spell_item = head->spellitem;
841
842	if (!spell_item)
843	return 0;
844
845	/* Best guess this is a defensive/healing spell */
846	if (spell_item->range <= 1 || spell_item->stats.dam < 0)
847	dir = 0;
848
849	/* Monster doesn't have enough spell-points */
850	if (head->stats.sp < SP_level_spellpoint_cost (head, spell_item, SPELL_MANA))
851	return 0;
852
853	if (head->stats.grace < SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE))
854	return 0;
855
856	head->stats.sp -= SP_level_spellpoint_cost (head, spell_item, SPELL_MANA);
857	head->stats.grace -= SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE);
858
859	/* set this to null, so next time monster will choose something different */
860	head->spellitem = NULL;
861
862	return cast_spell (part, part, dir, spell_item, NULL);
863	}
864
865	int
866	monster_use_scroll (object *head, object *part, object *pl, int dir, rv_vector * rv)
867	{
868	object *scroll;
869	object *owner;
870	rv_vector rv1;
871
872	/* If you want monsters to cast spells over friends, this spell should
873	* be removed. It probably should be in most cases, since monsters still
874	* don't care about residual effects (ie, casting a cone which may have a
875	* clear path to the player, the side aspects of the code will still hit
876	* other monsters)
877	*/
878	if (!(dir = path_to_player (part, pl, 0)))
879	return 0;
880
881	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
882	{
883	get_rangevector (head, owner, &rv1, 0x1);
884	if (dirdiff (dir, rv1.direction) < 2)
885	{
886	return 0; /* Might hit owner with spell */
887	}
888	}
889
890	if (QUERY_FLAG (head, FLAG_CONFUSED))
891	dir = absdir (dir + rndm (3) + rndm (3) - 2);
892
893	for (scroll = head->inv; scroll; scroll = scroll->below)
894	if (scroll->type == SCROLL && monster_should_cast_spell (head, scroll->inv))
895	break;
896
897	/* Used up all his scrolls, so nothing do to */
898	if (!scroll)
899	{
900	CLEAR_FLAG (head, FLAG_READY_SCROLL);
901	return 0;
902	}
903
904	/* Spell should be cast on caster (ie, heal, strength) */
905	if (scroll->inv->range == 0)
906	dir = 0;
907
908	apply_scroll (part, scroll, dir);
909	return 1;
910	}
911
912	/* monster_use_skill()-implemented 95-04-28 to allow monster skill use.
913	* Note that monsters do not need the skills SK_MELEE_WEAPON and
914	* SK_MISSILE_WEAPON to make those respective attacks, if we
915	* required that we would drastically increase the memory
916	* requirements of CF!!
917	*
918	* The skills we are treating here are all but those. -b.t.
919	*
920	* At the moment this is only useful for throwing, perhaps for
921	* stealing. TODO: This should be more integrated in the game. -MT, 25.11.01
922	*/
923	int
924	monster_use_skill (object *head, object *part, object *pl, int dir)
925	{
926	object *skill, *owner;
927
928	if (!(dir = path_to_player (part, pl, 0)))
929	return 0;
930
931	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
932	{
933	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
934
935	if (dirdiff (dir, dir2) < 1)
936	return 0; /* Might hit owner with skill -thrown rocks for example ? */
937	}
938
939	if (QUERY_FLAG (head, FLAG_CONFUSED))
940	dir = absdir (dir + rndm (3) + rndm (3) - 2);
941
942	/* skill selection - monster will use the next unused skill.
943	* well...the following scenario will allow the monster to
944	* toggle between 2 skills. One day it would be nice to make
945	* more skills available to monsters.
946	*/
947	for (skill = head->inv; skill; skill = skill->below)
948	if (skill->type == SKILL && skill != head->chosen_skill)
949	{
950	head->chosen_skill = skill;
951	break;
952	}
953
954	if (!skill && !head->chosen_skill)
955	{
956	LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);
957	CLEAR_FLAG (head, FLAG_READY_SKILL);
958	return 0;
959	}
960
961	/* use skill */
962	return do_skill (head, part, head->chosen_skill, dir, NULL);
963	}
964
965	/* Monster will use a ranged spell attack. */
966	int
967	monster_use_range (object *head, object *part, object *pl, int dir)
968	{
969	object *wand, *owner;
970	int at_least_one = 0;
971
972	if (!(dir = path_to_player (part, pl, 0)))
973	return 0;
974
975	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
976	{
977	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
978
979	if (dirdiff (dir, dir2) < 2)
980	return 0; /* Might hit owner with spell */
981	}
982
983	if (QUERY_FLAG (head, FLAG_CONFUSED))
984	dir = absdir (dir + rndm (3) + rndm (3) - 2);
985
986	for (wand = head->inv; wand; wand = wand->below)
987	{
988	if (wand->type == WAND)
989	{
990	/* Found a wand, let's see if it has charges left */
991	at_least_one = 1;
992	if (wand->stats.food <= 0)
993	continue;
994
995	cast_spell (head, wand, dir, wand->inv, NULL);
996
997	if (!(--wand->stats.food))
998	{
999	if (wand->arch)
1000	{
1001	CLEAR_FLAG (wand, FLAG_ANIMATE);
1002	wand->face = wand->arch->face;
1003	wand->set_speed (0);
1004	}
1005	}
1006	/* Success */
1007	return 1;
1008	}
1009	else if (wand->type == ROD || wand->type == HORN)
1010	{
1011	/* Found rod/horn, let's use it if possible */
1012	at_least_one = 1;
1013	if (wand->stats.hp < MAX (wand->inv->stats.sp, wand->inv->stats.grace))
1014	continue;
1015
1016	/* drain charge before casting spell - can be a case where the
1017	* spell destroys the monster, and rod, so if done after, results
1018	* in crash.
1019	*/
1020	drain_rod_charge (wand);
1021	cast_spell (head, wand, dir, wand->inv, NULL);
1022
1023	/* Success */
1024	return 1;
1025	}
1026	}
1027
1028	if (at_least_one)
1029	return 0;
1030
1031	LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANGE() without wand/horn/rod.\n", &head->name, head->count);
1032	CLEAR_FLAG (head, FLAG_READY_RANGE);
1033	return 0;
1034	}
1035
1036	int
1037	monster_use_bow (object *head, object *part, object *pl, int dir)
1038	{
1039	object *owner;
1040
1041	if (!(dir = path_to_player (part, pl, 0)))
1042	return 0;
1043
1044	if (QUERY_FLAG (head, FLAG_CONFUSED))
1045	dir = absdir (dir + rndm (3) + rndm (3) - 2);
1046
1047	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
1048	{
1049	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
1050
1051	if (dirdiff (dir, dir2) < 1)
1052	return 0; /* Might hit owner with arrow */
1053	}
1054
1055	/* in server/player.c */
1056	return fire_bow (head, part, NULL, dir, 0, part->x, part->y);
1057
1058	}
1059
1060	/* Checks if putting on 'item' will make 'who' do more	481	/* Checks if putting on 'item' will make 'who' do more
1061	* damage. This is a very simplistic check - also checking things	482	* damage. This is a very simplistic check - also checking things
1062	* like speed and ac are also relevant.	483	* like speed and ac are also relevant.
1063	*	484	*
1064	* return true if item is a better object.	485	* return true if item is a better object.
1065	*/	486	*/
1066	int	487	static int
1067	check_good_weapon (object *who, object *item)	488	check_good_weapon (object *who, object *item)
1068	{	489	{
1069	object *other_weap;	490	object *other_weap;
1070	int val = 0, i;	491	int val = 0, i;
1071		492
…		…
1094	return 1;	515	return 1;
1095	else	516	else
1096	return 0;	517	return 0;
1097	}	518	}
1098		519
1099	int	520	static int
1100	check_good_armour (object *who, object *item)	521	check_good_armour (object *who, object *item)
1101	{	522	{
1102	object *other_armour;	523	object *other_armour;
1103	int val = 0, i;	524	int val = 0, i;
1104		525
…		…
1132		553
1133	if (val > 0)	554	if (val > 0)
1134	return 1;	555	return 1;
1135	else	556	else
1136	return 0;	557	return 0;
1137	}
1138
1139	/*
1140	* monster_check_pickup(): checks for items that monster can pick up.
1141	*
1142	* Vick's (vick@bern.docs.uu.se) fix 921030 for the sweeper blob.
1143	* Each time the blob passes over some treasure, it will
1144	* grab it a.s.a.p.
1145	*
1146	* Eneq(@csd.uu.se): This can now be defined in the archetypes, added code
1147	* to handle this.
1148	*
1149	* This function was seen be continueing looping at one point (tmp->below
1150	* became a recursive loop. It may be better to call monster_check_apply
1151	* after we pick everything up, since that function may call others which
1152	* affect stacking on this space.
1153	*/
1154	void
1155	monster_check_pickup (object *monster)
1156	{
1157	object *tmp, *next;
1158
1159	for (tmp = monster->below; tmp != NULL; tmp = next)
1160	{
1161	next = tmp->below;
1162	if (monster_can_pick (monster, tmp))
1163	{
1164	tmp->remove ();
1165	tmp = insert_ob_in_ob (tmp, monster);
1166	(void) monster_check_apply (monster, tmp);
1167	}
1168	/* We could try to re-establish the cycling, of the space, but probably
1169	* not a big deal to just bail out.
1170	*/
1171	if (next && next->destroyed ())
1172	return;
1173	}
1174	}
1175
1176	/*
1177	* monster_can_pick(): If the monster is interested in picking up
1178	* the item, then return 0. Otherwise 0.
1179	* Instead of pick_up, flags for "greed", etc, should be used.
1180	* I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
1181	*/
1182	int
1183	monster_can_pick (object *monster, object *item)
1184	{
1185	int flag = 0;
1186	int i;
1187
1188	if (!can_pick (monster, item))
1189	return 0;
1190
1191	if (QUERY_FLAG (item, FLAG_UNPAID))
1192	return 0;
1193
1194	if (monster->pick_up & 64) /* All */
1195	flag = 1;
1196
1197	else
1198	switch (item->type)
1199	{
1200	case MONEY:
1201	case GEM:
1202	flag = monster->pick_up & 2;
1203	break;
1204
1205	case FOOD:
1206	flag = monster->pick_up & 4;
1207	break;
1208
1209	case WEAPON:
1210	flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON);
1211	break;
1212
1213	case ARMOUR:
1214	case SHIELD:
1215	case HELMET:
1216	case BOOTS:
1217	case GLOVES:
1218	case GIRDLE:
1219	flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR);
1220	break;
1221
1222	case SKILL:
1223	flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);
1224	break;
1225
1226	case RING:
1227	flag = QUERY_FLAG (monster, FLAG_USE_RING);
1228	break;
1229
1230	case WAND:
1231	case HORN:
1232	case ROD:
1233	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1234	break;
1235
1236	case SPELLBOOK:
1237	flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1238	break;
1239
1240	case SCROLL:
1241	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1242	break;
1243
1244	case BOW:
1245	case ARROW:
1246	flag = QUERY_FLAG (monster, FLAG_USE_BOW);
1247	break;
1248	}
1249
1250	/* Simplistic check - if the monster has a location to equip it, he will
1251	* pick it up. Note that this doesn't handle cases where an item may
1252	* use several locations.
1253	*/
1254	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1255	{
1256	if (monster->slot[i].info && item->slot[i].info)
1257	{
1258	flag = 1;
1259	break;
1260	}
1261	}
1262
1263	if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && (!flag)))
1264	return 1;
1265
1266	return 0;
1267	}
1268
1269	/*
1270	* monster_apply_below():
1271	* Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
1272	* eager to apply things, encounters something apply-able,
1273	* then make him apply it
1274	*/
1275	void
1276	monster_apply_below (object *monster)
1277	{
1278	object *tmp, *next;
1279
1280	for (tmp = monster->below; tmp != NULL; tmp = next)
1281	{
1282	next = tmp->below;
1283	switch (tmp->type)
1284	{
1285	case CF_HANDLE:
1286	case TRIGGER:
1287	if (monster->will_apply & 1)
1288	manual_apply (monster, tmp, 0);
1289	break;
1290
1291	case TREASURE:
1292	if (monster->will_apply & 2)
1293	manual_apply (monster, tmp, 0);
1294	break;
1295
1296	}
1297	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1298	break;
1299	}
1300	}	558	}
1301		559
1302	/*	560	/*
1303	* monster_check_apply() is meant to be called after an item is	561	* monster_check_apply() is meant to be called after an item is
1304	* inserted in a monster.	562	* inserted in a monster.
…		…
1415	* monsters have some advantages after all.	673	* monsters have some advantages after all.
1416	*/	674	*/
1417	manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);	675	manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);
1418	}	676	}
1419		677
1420	void	678	static int
1421	npc_call_help (object *op)	679	can_hit (object *ob1, object *ob2, rv_vector * rv)
1422	{	680	{
1423	int x, y, mflags;
1424	object *npc;	681	object *more;
1425	sint16 sx, sy;	682	rv_vector rv1;
1426	maptile *m;
1427		683
1428	for (x = -3; x < 4; x++)	684	if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(rndm (3)))
1429	for (y = -3; y < 4; y++)	685	return 0;
		686
		687	if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)
		688	return 1;
		689
		690	/* check all the parts of ob2 - just because we can't get to
		691	* its head doesn't mean we don't want to pound its feet
		692	*/
		693	for (more = ob2->more; more; more = more->more)
1430	{	694	{
1431	m = op->map;	695	get_rangevector (ob1, more, &rv1, 0);
1432	sx = op->x + x;	696	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
1433	sy = op->y + y;	697	return 1;
1434	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1435	/* If nothing alive on this space, no need to search the space. */
1436	if ((mflags & P_OUT_OF_MAP) || !(mflags & P_IS_ALIVE))
1437	continue;
1438
1439	for (npc = GET_MAP_OB (m, sx, sy); npc != NULL; npc = npc->above)
1440	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
1441	npc->enemy = op->enemy;
1442	}	698	}
1443	}
1444		699
1445	int	700	return 0;
		701	}
		702
		703	static int
1446	dist_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	704	dist_att (int dir, object *ob, object *enemy, object *part, rv_vector *rv)
1447	{	705	{
1448	if (can_hit (part, enemy, rv))	706	if (can_hit (part, enemy, rv))
1449	return dir;	707	return dir;
1450		708
1451	if (rv->distance < 10)	709	if (rv->distance < 10)
…		…
1454	return dir;	712	return dir;
1455		713
1456	return 0;	714	return 0;
1457	}	715	}
1458		716
1459	int	717	static int
1460	run_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	718	run_att (int dir, object *ob, object *enemy, object *part, rv_vector *rv)
1461	{	719	{
1462	if ((can_hit (part, enemy, rv) && ob->move_status < 20) || ob->move_status < 20)	720	if (can_hit (part, enemy, rv))
1463	{
1464	ob->move_status++;
1465	return (dir);	721	return dir;
1466	}	722	else
1467	else if (ob->move_status > 20)
1468	ob->move_status = 0;
1469
1470	return absdir (dir + 4);	723	return absdir (dir + 4);
1471	}	724	}
1472		725
1473	int	726	static int
1474	hitrun_att (int dir, object *ob, object *enemy)	727	hitrun_att (int dir, object *ob, object *enemy)
1475	{	728	{
1476	if (ob->move_status++ < 25)	729	if (ob->move_status++ < 25)
1477	return dir;	730	return dir;
1478	else if (ob->move_status < 50)	731	else if (ob->move_status < 50)
…		…
1481	ob->move_status = 0;	734	ob->move_status = 0;
1482		735
1483	return absdir (dir + 4);	736	return absdir (dir + 4);
1484	}	737	}
1485		738
1486	int	739	static int
1487	wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	740	wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1488	{	741	{
1489
1490	int inrange = can_hit (part, enemy, rv);	742	int inrange = can_hit (part, enemy, rv);
1491		743
1492	if (ob->move_status || inrange)	744	if (ob->move_status || inrange)
1493	ob->move_status++;	745	ob->move_status++;
1494		746
…		…
1501		753
1502	ob->move_status = 0;	754	ob->move_status = 0;
1503	return 0;	755	return 0;
1504	}	756	}
1505		757
1506	int	758	static int
1507	disthit_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	759	disthit_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1508	{	760	{
1509
1510	/* The logic below here looked plain wrong before. Basically, what should	761	/* The logic below here looked plain wrong before. Basically, what should
1511	* happen is that if the creatures hp percentage falls below run_away,	762	* happen is that if the creatures hp percentage falls below run_away,
1512	* the creature should run away (dir+4)	763	* the creature should run away (dir+4)
1513	* I think its wrong for a creature to have a zero maxhp value, but	764	* I think its wrong for a creature to have a zero maxhp value, but
1514	* at least one map has this set, and whatever the map contains, the	765	* at least one map has this set, and whatever the map contains, the
1515	* server should try to be resilant enough to avoid the problem	766	* server should try to be resilant enough to avoid the problem
1516	*/	767	*/
1517	if (ob->stats.maxhp && (ob->stats.hp * 100) / ob->stats.maxhp < ob->run_away)	768	if (ob->stats.hp * 100 < ob->stats.maxhp * ob->run_away)
1518	return absdir (dir + 4);	769	return absdir (dir + 4);
1519		770
1520	return dist_att (dir, ob, enemy, part, rv);	771	return dist_att (dir, ob, enemy, part, rv);
1521	}	772	}
1522		773
1523	int	774	static int
1524	wait_att2 (int dir, object *ob, object *enemy, object *part, rv_vector * rv)	775	wait_att2 (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1525	{	776	{
1526	if (rv->distance < 9)	777	if (rv->distance < 9)
1527	return absdir (dir + 4);	778	return absdir (dir + 4);
1528		779
1529	return 0;	780	return 0;
1530	}	781	}
1531		782
1532	void	783	static void
1533	circ1_move (object *ob)	784	circ1_move (object *ob)
1534	{	785	{
1535	static int circle[12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 };	786	static int circle[12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 };
1536		787
1537	if (++ob->move_status > 11)	788	if (++ob->move_status > 11)
…		…
1539		790
1540	if (!(move_object (ob, circle[ob->move_status])))	791	if (!(move_object (ob, circle[ob->move_status])))
1541	move_object (ob, rndm (8) + 1);	792	move_object (ob, rndm (8) + 1);
1542	}	793	}
1543		794
1544	void	795	static void
1545	circ2_move (object *ob)	796	circ2_move (object *ob)
1546	{	797	{
1547	static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };	798	static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };
1548		799
1549	if (++ob->move_status > 19)	800	if (++ob->move_status > 19)
…		…
1551		802
1552	if (!(move_object (ob, circle[ob->move_status])))	803	if (!(move_object (ob, circle[ob->move_status])))
1553	move_object (ob, rndm (8) + 1);	804	move_object (ob, rndm (8) + 1);
1554	}	805	}
1555		806
1556	void	807	static void
1557	pace_movev (object *ob)	808	pace_movev (object *ob)
1558	{	809	{
1559	if (ob->move_status++ > 6)	810	if (ob->move_status++ > 6)
1560	ob->move_status = 0;	811	ob->move_status = 0;
1561		812
…		…
1563	move_object (ob, 5);	814	move_object (ob, 5);
1564	else	815	else
1565	move_object (ob, 1);	816	move_object (ob, 1);
1566	}	817	}
1567		818
1568	void	819	static void
1569	pace_moveh (object *ob)	820	pace_moveh (object *ob)
1570	{	821	{
1571	if (ob->move_status++ > 6)	822	if (ob->move_status++ > 6)
1572	ob->move_status = 0;	823	ob->move_status = 0;
1573		824
…		…
1575	move_object (ob, 3);	826	move_object (ob, 3);
1576	else	827	else
1577	move_object (ob, 7);	828	move_object (ob, 7);
1578	}	829	}
1579		830
1580	void	831	static void
1581	pace2_movev (object *ob)	832	pace2_movev (object *ob)
1582	{	833	{
1583	if (ob->move_status++ > 16)	834	if (ob->move_status++ > 16)
1584	ob->move_status = 0;	835	ob->move_status = 0;
1585		836
…		…
1591	move_object (ob, 1);	842	move_object (ob, 1);
1592	else	843	else
1593	return;	844	return;
1594	}	845	}
1595		846
1596	void	847	static void
1597	pace2_moveh (object *ob)	848	pace2_moveh (object *ob)
1598	{	849	{
1599	if (ob->move_status++ > 16)	850	if (ob->move_status++ > 16)
1600	ob->move_status = 0;	851	ob->move_status = 0;
1601		852
…		…
1607	move_object (ob, 7);	858	move_object (ob, 7);
1608	else	859	else
1609	return;	860	return;
1610	}	861	}
1611		862
1612	void	863	static void
1613	rand_move (object *ob)	864	rand_move (object *ob)
1614	{	865	{
1615	if (ob->move_status < 1 || ob->move_status > 8 || !(move_object (ob, ob->move_status || !(rndm (9)))))	866	if (ob->move_status < 1 || ob->move_status > 8 || !(move_object (ob, ob->move_status || !(rndm (9)))))
1616	for (int i = 0; i < 5; i++)	867	for (int i = 0; i < 5; i++)
1617	if (move_object (ob, ob->move_status = rndm (8) + 1))	868	if (move_object (ob, ob->move_status = rndm (8) + 1))
1618	return;	869	return;
		870	}
		871
		872	#define MAX_KNOWN_SPELLS 20
		873
		874	/* Returns a randomly selected spell. This logic is still
		875	* less than ideal. This code also only seems to deal with
		876	* wizard spells, as the check is against sp, and not grace.
		877	* can mosnters know cleric spells?
		878	*/
		879	static object *
		880	monster_choose_random_spell (object *monster)
		881	{
		882	object *altern[MAX_KNOWN_SPELLS];
		883	int i = 0;
		884
		885	for (object *tmp = monster->inv; tmp; tmp = tmp->below)
		886	if (tmp->type == SPELLBOOK || tmp->type == SPELL)
		887	{
		888	/* Check and see if it's actually a useful spell.
		889	* If its a spellbook, the spell is actually the inventory item.
		890	* if it is a spell, then it is just the object itself.
		891	*/
		892	if (monster_should_cast_spell (monster, (tmp->type == SPELLBOOK) ? tmp->inv : tmp))
		893	{
		894	altern [i++] = tmp;
		895
		896	if (i == MAX_KNOWN_SPELLS)
		897	break;
		898	}
		899	}
		900
		901	return i ? altern [rndm (i)] : 0;
		902	}
		903
		904	/* This checks to see if the monster should cast a spell/ability.
		905	* it returns true if the monster casts a spell, 0 if he doesn't.
		906	* head is the head of the monster.
		907	* part is the part of the monster we are checking against.
		908	* pl is the target.
		909	* dir is the direction to case.
		910	* rv is the vector which describes where the enemy is.
		911	*/
		912	static int
		913	monster_cast_spell (object *head, object *part, object *pl, int dir, rv_vector * rv)
		914	{
		915	object *spell_item;
		916	object *owner;
		917	rv_vector rv1;
		918
		919	/* If you want monsters to cast spells over friends, this spell should
		920	* be removed. It probably should be in most cases, since monsters still
		921	* don't care about residual effects (ie, casting a cone which may have a
		922	* clear path to the player, the side aspects of the code will still hit
		923	* other monsters)
		924	*/
		925	if (!(dir = path_to_player (part, pl, 0)))
		926	return 0;
		927
		928	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
		929	{
		930	get_rangevector (head, owner, &rv1, 0x1);
		931	if (dirdiff (dir, rv1.direction) < 2)
		932	return 0; /* Might hit owner with spell */
		933	}
		934
		935	if (QUERY_FLAG (head, FLAG_CONFUSED))
		936	dir = absdir (dir + rndm (3) + rndm (3) - 2);
		937
		938	/* If the monster hasn't already chosen a spell, choose one
		939	* I'm not sure if it really make sense to pre-select spells (events
		940	* could be different by the time the monster goes again).
		941	*/
		942	if (head->spellitem == NULL)
		943	{
		944	if ((spell_item = monster_choose_random_spell (head)) == NULL)
		945	{
		946	LOG (llevMonster, "Turned off spells in %s\n", &head->name);
		947	CLEAR_FLAG (head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
		948	return 0;
		949	}
		950
		951	if (spell_item->type == SPELLBOOK)
		952	{
		953	if (!spell_item->inv)
		954	{
		955	LOG (llevError, "spellbook %s does not contain a spell?\n", &spell_item->name);
		956	return 0;
		957	}
		958
		959	spell_item = spell_item->inv;
		960	}
		961	}
		962	else
		963	spell_item = head->spellitem;
		964
		965	if (!spell_item)
		966	return 0;
		967
		968	/* Best guess this is a defensive/healing spell */
		969	if (spell_item->range <= 1 || spell_item->stats.dam < 0)
		970	dir = 0;
		971
		972	/* Monster doesn't have enough spell-points */
		973	if (head->stats.sp < SP_level_spellpoint_cost (head, spell_item, SPELL_MANA))
		974	return 0;
		975
		976	if (head->stats.grace < SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE))
		977	return 0;
		978
		979	head->stats.sp -= SP_level_spellpoint_cost (head, spell_item, SPELL_MANA);
		980	head->stats.grace -= SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE);
		981
		982	/* set this to null, so next time monster will choose something different */
		983	head->spellitem = NULL;
		984
		985	return cast_spell (part, part, dir, spell_item, NULL);
		986	}
		987
		988	static int
		989	monster_use_scroll (object *head, object *part, object *pl, int dir, rv_vector * rv)
		990	{
		991	object *scroll;
		992	object *owner;
		993	rv_vector rv1;
		994
		995	/* If you want monsters to cast spells over friends, this spell should
		996	* be removed. It probably should be in most cases, since monsters still
		997	* don't care about residual effects (ie, casting a cone which may have a
		998	* clear path to the player, the side aspects of the code will still hit
		999	* other monsters)
		1000	*/
		1001	if (!(dir = path_to_player (part, pl, 0)))
		1002	return 0;
		1003
		1004	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
		1005	{
		1006	get_rangevector (head, owner, &rv1, 0x1);
		1007	if (dirdiff (dir, rv1.direction) < 2)
		1008	{
		1009	return 0; /* Might hit owner with spell */
		1010	}
		1011	}
		1012
		1013	if (QUERY_FLAG (head, FLAG_CONFUSED))
		1014	dir = absdir (dir + rndm (3) + rndm (3) - 2);
		1015
		1016	for (scroll = head->inv; scroll; scroll = scroll->below)
		1017	if (scroll->type == SCROLL && monster_should_cast_spell (head, scroll->inv))
		1018	break;
		1019
		1020	/* Used up all his scrolls, so nothing do to */
		1021	if (!scroll)
		1022	{
		1023	CLEAR_FLAG (head, FLAG_READY_SCROLL);
		1024	return 0;
		1025	}
		1026
		1027	/* Spell should be cast on caster (ie, heal, strength) */
		1028	if (scroll->inv->range == 0)
		1029	dir = 0;
		1030
		1031	apply_scroll (part, scroll, dir);
		1032	return 1;
		1033	}
		1034
		1035	/* monster_use_skill()-implemented 95-04-28 to allow monster skill use.
		1036	* Note that monsters do not need the skills SK_MELEE_WEAPON and
		1037	* SK_MISSILE_WEAPON to make those respective attacks, if we
		1038	* required that we would drastically increase the memory
		1039	* requirements of CF!!
		1040	*
		1041	* The skills we are treating here are all but those. -b.t.
		1042	*
		1043	* At the moment this is only useful for throwing, perhaps for
		1044	* stealing. TODO: This should be more integrated in the game. -MT, 25.11.01
		1045	*/
		1046	static int
		1047	monster_use_skill (object *head, object *part, object *pl, int dir)
		1048	{
		1049	object *skill, *owner;
		1050
		1051	if (!(dir = path_to_player (part, pl, 0)))
		1052	return 0;
		1053
		1054	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
		1055	{
		1056	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
		1057
		1058	if (dirdiff (dir, dir2) < 1)
		1059	return 0; /* Might hit owner with skill -thrown rocks for example ? */
		1060	}
		1061
		1062	if (QUERY_FLAG (head, FLAG_CONFUSED))
		1063	dir = absdir (dir + rndm (3) + rndm (3) - 2);
		1064
		1065	/* skill selection - monster will use the next unused skill.
		1066	* well...the following scenario will allow the monster to
		1067	* toggle between 2 skills. One day it would be nice to make
		1068	* more skills available to monsters.
		1069	*/
		1070	for (skill = head->inv; skill; skill = skill->below)
		1071	if (skill->type == SKILL && skill != head->chosen_skill)
		1072	{
		1073	head->chosen_skill = skill;
		1074	break;
		1075	}
		1076
		1077	if (!skill && !head->chosen_skill)
		1078	{
		1079	LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);
		1080	CLEAR_FLAG (head, FLAG_READY_SKILL);
		1081	return 0;
		1082	}
		1083
		1084	/* use skill */
		1085	return do_skill (head, part, head->chosen_skill, dir, NULL);
		1086	}
		1087
		1088	/* Monster will use a ranged spell attack. */
		1089	static int
		1090	monster_use_range (object *head, object *part, object *pl, int dir)
		1091	{
		1092	object *wand, *owner;
		1093	int at_least_one = 0;
		1094
		1095	if (!(dir = path_to_player (part, pl, 0)))
		1096	return 0;
		1097
		1098	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
		1099	{
		1100	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
		1101
		1102	if (dirdiff (dir, dir2) < 2)
		1103	return 0; /* Might hit owner with spell */
		1104	}
		1105
		1106	if (QUERY_FLAG (head, FLAG_CONFUSED))
		1107	dir = absdir (dir + rndm (3) + rndm (3) - 2);
		1108
		1109	for (wand = head->inv; wand; wand = wand->below)
		1110	{
		1111	if (wand->type == WAND)
		1112	{
		1113	/* Found a wand, let's see if it has charges left */
		1114	at_least_one = 1;
		1115	if (wand->stats.food <= 0)
		1116	continue;
		1117
		1118	cast_spell (head, wand, dir, wand->inv, NULL);
		1119
		1120	if (!(--wand->stats.food))
		1121	{
		1122	if (wand->arch)
		1123	{
		1124	CLEAR_FLAG (wand, FLAG_ANIMATE);
		1125	wand->face = wand->arch->face;
		1126	wand->set_speed (0);
		1127	}
		1128	}
		1129	/* Success */
		1130	return 1;
		1131	}
		1132	else if (wand->type == ROD || wand->type == HORN)
		1133	{
		1134	/* Found rod/horn, let's use it if possible */
		1135	at_least_one = 1;
		1136	if (wand->stats.hp < max (wand->inv->stats.sp, wand->inv->stats.grace))
		1137	continue;
		1138
		1139	/* drain charge before casting spell - can be a case where the
		1140	* spell destroys the monster, and rod, so if done after, results
		1141	* in crash.
		1142	*/
		1143	drain_rod_charge (wand);
		1144	cast_spell (head, wand, dir, wand->inv, NULL);
		1145
		1146	/* Success */
		1147	return 1;
		1148	}
		1149	}
		1150
		1151	if (at_least_one)
		1152	return 0;
		1153
		1154	LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANGE() without wand/horn/rod.\n", &head->name, head->count);
		1155	CLEAR_FLAG (head, FLAG_READY_RANGE);
		1156	return 0;
		1157	}
		1158
		1159	static int
		1160	monster_use_bow (object *head, object *part, object *pl, int dir)
		1161	{
		1162	object *owner;
		1163
		1164	if (!(dir = path_to_player (part, pl, 0)))
		1165	return 0;
		1166
		1167	if (QUERY_FLAG (head, FLAG_CONFUSED))
		1168	dir = absdir (dir + rndm (3) + rndm (3) - 2);
		1169
		1170	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
		1171	{
		1172	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
		1173
		1174	if (dirdiff (dir, dir2) < 1)
		1175	return 0; /* Might hit owner with arrow */
		1176	}
		1177
		1178	/* in server/player.c */
		1179	return fire_bow (head, part, NULL, dir, 0, part->x, part->y);
		1180
		1181	}
		1182
		1183	void
		1184	npc_call_help (object *op)
		1185	{
		1186	unordered_mapwalk (mapwalk_buf, op, -7, -7, 7, 7)
		1187	{
		1188	mapspace &ms = m->at (nx, ny);
		1189
		1190	/* If nothing alive on this space, no need to search the space. */
		1191	if (!(ms.flags () & P_IS_ALIVE))
		1192	continue;
		1193
		1194	for (object *npc = ms.bot; npc; npc = npc->above)
		1195	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
		1196	npc->enemy = op->enemy;
		1197	}
1619	}	1198	}
1620		1199
1621	void	1200	void
1622	check_earthwalls (object *op, maptile *m, int x, int y)	1201	check_earthwalls (object *op, maptile *m, int x, int y)
1623	{	1202	{
…		…
1674	#ifdef DEBUG_THROW	1253	#ifdef DEBUG_THROW
1675	LOG (llevDebug, "%s chooses to throw: %s (%d)\n", op->name, !(tmp) ? "(nothing)" : query_name (tmp), tmp ? tmp->count : -1);	1254	LOG (llevDebug, "%s chooses to throw: %s (%d)\n", op->name, !(tmp) ? "(nothing)" : query_name (tmp), tmp ? tmp->count : -1);
1676	#endif	1255	#endif
1677		1256
1678	return tmp;	1257	return tmp;
		1258	}
		1259
		1260	/*
		1261	* Move-monster returns 1 if the object has been freed, otherwise 0.
		1262	*/
		1263	int
		1264	move_monster (object *op)
		1265	{
		1266	int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */
		1267	object *owner, *enemy, *part, *oph = op;
		1268	rv_vector rv;
		1269
		1270	/* Monsters not on maps don't do anything. These monsters are things
		1271	* Like royal guards in city dwellers inventories.
		1272	*/
		1273	if (!op->map)
		1274	return 0;
		1275
		1276	/* for target facing, we copy this value here for fast access */
		1277	if (oph->head) /* force update the head - one arch one pic */
		1278	oph = oph->head;
		1279
		1280	if (QUERY_FLAG (op, FLAG_NO_ATTACK)) /* we never ever attack */
		1281	enemy = op->enemy = NULL;
		1282	else if ((enemy = find_enemy (op, &rv)))
		1283	/* we have an enemy, just tell him we want him dead */
		1284	enemy->attacked_by = op; /* our ptr */
		1285
		1286	/* generate hp, if applicable */
		1287	if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)
		1288	{
		1289	/* last heal is in funny units. Dividing by speed puts
		1290	* the regeneration rate on a basis of time instead of
		1291	* #moves the monster makes. The scaling by 8 is
		1292	* to capture 8th's of a hp fraction regens
		1293	*
		1294	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)
		1295	* overflow might produce monsters with negative hp.
		1296	*/
		1297
		1298	op->last_heal += (int) ((float) (8 * op->stats.Con) / op->speed);
		1299	op->stats.hp = min ((sint32) op->stats.hp + op->last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */
		1300	op->last_heal %= 32;
		1301
		1302	/* So if the monster has gained enough HP that they are no longer afraid */
		1303	if (QUERY_FLAG (op, FLAG_RUN_AWAY) && op->stats.hp >= (signed short)(((float)op->run_away / 100.f) * (float)op->stats.maxhp))
		1304	CLEAR_FLAG (op, FLAG_RUN_AWAY);
		1305
		1306	if (op->stats.hp > op->stats.maxhp)
		1307	op->stats.hp = op->stats.maxhp;
		1308	}
		1309
		1310	/* generate sp, if applicable */
		1311	if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)
		1312	{
		1313	/* last_sp is in funny units. Dividing by speed puts
		1314	* the regeneration rate on a basis of time instead of
		1315	* #moves the monster makes. The scaling by 8 is
		1316	* to capture 8th's of a sp fraction regens
		1317	*
		1318	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)
		1319	* overflow might produce monsters with negative sp.
		1320	*/
		1321
		1322	op->last_sp += (int) ((float) (8 * op->stats.Pow) / op->speed);
		1323	op->stats.sp = min (op->stats.sp + op->last_sp / 128, op->stats.maxsp); /* causes Pow/16 sp/tick */
		1324	op->last_sp %= 128;
		1325	}
		1326
		1327	/* this should probably get modified by many more values.
		1328	* (eg, creatures resistance to fear, level, etc. )
		1329	*/
		1330	if (QUERY_FLAG (op, FLAG_SCARED) && !(rndm (20)))
		1331	CLEAR_FLAG (op, FLAG_SCARED); /* Time to regain some "guts"... */
		1332
		1333	if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))
		1334	return QUERY_FLAG (op, FLAG_FREED);
		1335
		1336	if (QUERY_FLAG (op, FLAG_SLEEP) || QUERY_FLAG (op, FLAG_BLIND) ||
		1337	((op->map->darklevel () > 0) && !QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))
		1338	if (!check_wakeup (op, enemy, &rv))
		1339	return 0;
		1340
		1341	/* check if monster pops out of hidden spot */
		1342	if (op->flag [FLAG_HIDDEN])
		1343	do_hidden_move (op);
		1344
		1345	if (op->pick_up)
		1346	monster_check_pickup (op);
		1347
		1348	if (op->will_apply)
		1349	monster_apply_below (op); /* Check for items to apply below */
		1350
		1351	/* If we don't have an enemy, do special movement or the like */
		1352	if (!enemy)
		1353	{
		1354	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
		1355	{
		1356	op->drop_and_destroy ();
		1357	return 1;
		1358	}
		1359
		1360	/* Probably really a bug for a creature to have both
		1361	* stand still and a movement type set.
		1362	*/
		1363	if (!QUERY_FLAG (op, FLAG_STAND_STILL))
		1364	{
		1365	if (op->attack_movement & HI4)
		1366	{
		1367	switch (op->attack_movement & HI4)
		1368	{
		1369	case PETMOVE:
		1370	pet_move (op);
		1371	break;
		1372
		1373	case CIRCLE1:
		1374	circ1_move (op);
		1375	break;
		1376
		1377	case CIRCLE2:
		1378	circ2_move (op);
		1379	break;
		1380
		1381	case PACEV:
		1382	pace_movev (op);
		1383	break;
		1384
		1385	case PACEH:
		1386	pace_moveh (op);
		1387	break;
		1388
		1389	case PACEV2:
		1390	pace2_movev (op);
		1391	break;
		1392
		1393	case PACEH2:
		1394	pace2_moveh (op);
		1395	break;
		1396
		1397	case RANDO:
		1398	rand_move (op);
		1399	break;
		1400
		1401	case RANDO2:
		1402	move_randomly (op);
		1403	break;
		1404	}
		1405
		1406	return 0;
		1407	}
		1408	else if (QUERY_FLAG (op, FLAG_RANDOM_MOVE))
		1409	move_randomly (op);
		1410	} /* stand still */
		1411
		1412	return 0;
		1413	} /* no enemy */
		1414
		1415	/* We have an enemy. Block immediately below is for pets */
		1416	if ((op->attack_movement & HI4) == PETMOVE
		1417	&& (owner = op->owner) != NULL
		1418	&& !on_same_map (op, owner)
		1419	&& !owner->flag [FLAG_REMOVED])
		1420	return follow_owner (op, owner);
		1421
		1422	/* doppleganger code to change monster facing to that of the nearest
		1423	* player. Hmm. The code is here, but no monster in the current
		1424	* arch set uses it.
		1425	*/
		1426	if (op->race == shstr_doppleganger)
		1427	{
		1428	op->face = enemy->face;
		1429	op->name = enemy->name;
		1430	}
		1431
		1432	/* Calculate range information for closest body part - this
		1433	* is used for the 'skill' code, which isn't that smart when
		1434	* it comes to figuring it out - otherwise, giants throw boulders
		1435	* into themselves.
		1436	*/
		1437	get_rangevector (op, enemy, &rv, 0);
		1438
		1439	/* Move the check for scared up here - if the monster was scared,
		1440	* we were not doing any of the logic below, so might as well save
		1441	* a few cpu cycles.
		1442	*/
		1443	if (!QUERY_FLAG (op, FLAG_SCARED))
		1444	{
		1445	rv_vector rv1;
		1446
		1447	/* now we test every part of an object .... this is a real ugly piece of code */
		1448	for (part = op; part; part = part->more)
		1449	{
		1450	get_rangevector (part, enemy, &rv1, 0x1);
		1451	dir = rv1.direction;
		1452
		1453	/* hm, not sure about this part - in original was a scared flag here too
		1454	* but that we test above... so can be old code here
		1455	*/
		1456	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
		1457	dir = absdir (dir + 4);
		1458
		1459	if (QUERY_FLAG (op, FLAG_CONFUSED))
		1460	dir = absdir (dir + rndm (3) + rndm (3) - 2);
		1461
		1462	if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(rndm (3)))
		1463	if (monster_cast_spell (op, part, enemy, dir, &rv1))
		1464	return 0;
		1465
		1466	if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(rndm (3)))
		1467	if (monster_use_scroll (op, part, enemy, dir, &rv1))
		1468	return 0;
		1469
		1470	if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(rndm (3)))
		1471	if (monster_use_range (op, part, enemy, dir))
		1472	return 0;
		1473
		1474	if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(rndm (3)))
		1475	if (monster_use_skill (op, rv.part, enemy, rv.direction))
		1476	return 0;
		1477
		1478	if (QUERY_FLAG (op, FLAG_READY_BOW) && !(rndm (2)))
		1479	if (monster_use_bow (op, part, enemy, dir))
		1480	return 0;
		1481	} /* for processing of all parts */
		1482	} /* If not scared */
		1483
		1484	part = rv.part;
		1485	dir = rv.direction;
		1486
		1487	//-GPL
		1488
		1489	// if the enemy is a player, we have los. if los says we
		1490	// can directly reach the player, we do not deviate.
		1491	// for non-players, we never deviate
		1492	if (op->stats.Wis >= 8
		1493	&& enemy->contr && enemy->contr->darkness_at (op->map, op->x, op->y) == LOS_BLOCKED)
		1494	{
		1495	int sdir = 0;
		1496	uint32_t &smell = op->ms ().smell;
		1497
		1498	for (int ndir = 1; ndir <= 8; ++ndir)
		1499	{
		1500	mapxy pos (op); pos.move (ndir);
		1501
		1502	if (pos.normalise ())
		1503	{
		1504	mapspace &ms = pos.ms ();
		1505
		1506	if (ms.smell > smell)
		1507	{
		1508	//printf ("%s: found smell, following it, apparently (%d, %d)\n",& op->name,op->ms().smell,ms.smell);//D
		1509	if (op->stats.Wis >= 10)
		1510	smell = ms.smell - 1; // smarter: tell others
		1511
		1512	sdir = ndir;
		1513
		1514	// perturbing the path might let the monster lose track,
		1515	// but it will also widen the actual path, spreading information
		1516	if (op->stats.Wis >= 15 && !rndm (20)) // even smarter, deviate and spread?
		1517	sdir = absdir (sdir + 1 - rndm (2) * 2);
		1518	}
		1519	}
		1520	}
		1521
		1522	if (sdir)
		1523	dir = sdir;
		1524	else if (smell)
		1525	{
		1526	// no better smell found, so assume the player jumped, and erase this smell
		1527	//printf ("erasing smell %d\n", op->ms ().smell);//D
		1528	unordered_mapwalk (mapwalk_buf, op, -1, -1, 1, 1)
		1529	m->at (nx, ny).smell = 0;
		1530	}
		1531	}
		1532
		1533	//+GPL
		1534
		1535	if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY))
		1536	dir = absdir (dir + 4);
		1537
		1538	if (QUERY_FLAG (op, FLAG_CONFUSED))
		1539	dir = absdir (dir + rndm (3) + rndm (3) - 2);
		1540
		1541	pre_att_dir = dir; /* remember the original direction */
		1542
		1543	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))
		1544	{
		1545	switch (op->attack_movement & LO4)
		1546	{
		1547	case DISTATT:
		1548	dir = dist_att (dir, op, enemy, part, &rv);
		1549	break;
		1550
		1551	case RUNATT:
		1552	dir = run_att (dir, op, enemy, part, &rv);
		1553	break;
		1554
		1555	case HITRUN:
		1556	dir = hitrun_att (dir, op, enemy);
		1557	break;
		1558
		1559	case WAITATT:
		1560	dir = wait_att (dir, op, enemy, part, &rv);
		1561	break;
		1562
		1563	case RUSH: /* default - monster normally moves towards player */
		1564	case ALLRUN:
		1565	break;
		1566
		1567	case DISTHIT:
		1568	dir = disthit_att (dir, op, enemy, part, &rv);
		1569	break;
		1570
		1571	case WAIT2:
		1572	dir = wait_att2 (dir, op, enemy, part, &rv);
		1573	break;
		1574
		1575	default:
		1576	LOG (llevDebug, "Illegal low mon-move: %d\n", op->attack_movement & LO4);
		1577	}
		1578	}
		1579
		1580	if (!dir)
		1581	return 0;
		1582
		1583	if (!QUERY_FLAG (op, FLAG_STAND_STILL))
		1584	{
		1585	if (move_object (op, dir)) /* Can the monster move directly toward player? */
		1586	{
		1587	/* elmex: Turn our monster after it moved if it has DISTATT attack */
		1588	if ((op->attack_movement & LO4) == DISTATT)
		1589	op->direction = pre_att_dir;
		1590
		1591	return 0;
		1592	}
		1593
		1594	if (QUERY_FLAG (op, FLAG_SCARED) || !can_hit (part, enemy, &rv) || QUERY_FLAG (op, FLAG_RUN_AWAY))
		1595	{
		1596	/* Try move around corners if !close */
		1597	int maxdiff = (QUERY_FLAG (op, FLAG_ONLY_ATTACK) || rndm (2)) ? 1 : 2;
		1598
		1599	for (diff = 1; diff <= maxdiff; diff++)
		1600	{
		1601	/* try different detours */
		1602	int m = 1 - rndm (2) * 2; /* Try left or right first? */
		1603
		1604	if (move_object (op, absdir (dir + diff * m)) || move_object (op, absdir (dir - diff * m)))
		1605	return 0;
		1606	}
		1607	}
		1608	} /* if monster is not standing still */
		1609
		1610	/* elmex: Turn our monster after it moved if it has DISTATT attack */
		1611	if ((op->attack_movement & LO4) == DISTATT)
		1612	op->direction = pre_att_dir;
		1613
		1614	/*
		1615	* Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random
		1616	* direction if they can't move away.
		1617	*/
		1618	if (!QUERY_FLAG (op, FLAG_ONLY_ATTACK) && (QUERY_FLAG (op, FLAG_RUN_AWAY) || QUERY_FLAG (op, FLAG_SCARED)))
		1619	if (move_randomly (op))
		1620	return 0;
		1621
		1622	/*
		1623	* Try giving the monster a new enemy - the player that is closest
		1624	* to it. In this way, it won't just keep trying to get to a target
		1625	* that is inaccessible.
		1626	* This could be more clever - it should go through a list of several
		1627	* enemies, as it is now, you could perhaps get situations where there
		1628	* are two players flanking the monster at close distance, but which
		1629	* the monster can't get to, and a third one at a far distance that
		1630	* the monster could get to - as it is, the monster won't look at that
		1631	* third one.
		1632	*/
		1633	if (!QUERY_FLAG (op, FLAG_FRIENDLY) && enemy == op->enemy)
		1634	{
		1635	object *nearest_player = get_nearest_player (op);
		1636
		1637	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))
		1638	{
		1639	op->enemy = 0;
		1640	enemy = nearest_player;
		1641	}
		1642	}
		1643
		1644	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))
		1645	{
		1646	/* The adjustement to wc that was here before looked totally bogus -
		1647	* since wc can in fact get negative, that would mean by adding
		1648	* the current wc, the creature gets better? Instead, just
		1649	* add a fixed amount - nasty creatures that are runny away should
		1650	* still be pretty nasty.
		1651	*/
		1652	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
		1653	{
		1654	part->stats.wc += 10;
		1655	skill_attack (enemy, part, 0, NULL, NULL);
		1656	part->stats.wc -= 10;
		1657	}
		1658	else
		1659	skill_attack (enemy, part, 0, NULL, NULL);
		1660	} /* if monster is in attack range */
		1661
		1662	if (QUERY_FLAG (part, FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */
		1663	return 1;
		1664
		1665	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
		1666	{
		1667	op->drop_and_destroy ();
		1668	return 1;
		1669	}
		1670
		1671	return 0;
1679	}	1672	}
1680		1673
1681	/* determine if we can 'detect' the enemy. Check for walls blocking the	1674	/* determine if we can 'detect' the enemy. Check for walls blocking the
1682	* los. Also, just because its hidden/invisible, we may be sensitive/smart	1675	* los. Also, just because its hidden/invisible, we may be sensitive/smart
1683	* enough (based on Wis & Int) to figure out where the enemy is. -b.t.	1676	* enough (based on Wis & Int) to figure out where the enemy is. -b.t.
…		…
1828	/* Wasn't detected above, so still hidden */	1821	/* Wasn't detected above, so still hidden */
1829	return 0;	1822	return 0;
1830	}	1823	}
1831		1824
1832	/* determine if op stands in a lighted square. This is not a very	1825	/* determine if op stands in a lighted square. This is not a very
1833	* intellegent algorithm. For one thing, we ignore los here, SO it	1826	* intelligent algorithm. For one thing, we ignore los here, SO it
1834	* is possible for a bright light to illuminate a player on the	1827	* is possible for a bright light to illuminate a player on the
1835	* other side of a wall (!).	1828	* other side of a wall (!).
1836	*/	1829	*/
1837	int	1830	int
1838	stand_in_light (object *op)	1831	stand_in_light (object *op)
…		…
1847		1840
1848	if (op->glow_radius > 0)	1841	if (op->glow_radius > 0)
1849	return 1;	1842	return 1;
1850		1843
1851	if (op->map)	1844	if (op->map)
1852	unordered_mapwalk (op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)	1845	unordered_mapwalk (mapwalk_buf, op, -MAX_LIGHT_RADIUS, -MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS, MAX_LIGHT_RADIUS)
1853	{	1846	{
1854	/* Check the spaces with the max light radius to see if any of them	1847	/* Check the spaces with the max light radius to see if any of them
1855	* have lights, and if any of them light the player enough, then return 1.	1848	* have lights, and if any of them light the player enough, then return 1.
1856	*/	1849	*/
1857	int light = m->at (nx, ny).light;	1850	int light = m->at (nx, ny).light;
…		…
1890	{	1883	{
1891	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!	1884	/* HIDDEN ENEMY. by definition, you can't see hidden stuff!
1892	* However,if you carry any source of light, then the hidden	1885	* However,if you carry any source of light, then the hidden
1893	* creature is seeable (and stupid) */	1886	* creature is seeable (and stupid) */
1894		1887
1895	if (has_carried_lights (enemy))	1888	if (enemy->has_carried_lights ())
1896	{	1889	{
1897	if (enemy->flag [FLAG_HIDDEN])	1890	if (enemy->flag [FLAG_HIDDEN])
1898	{	1891	{
1899	make_visible (enemy);	1892	make_visible (enemy);
1900	new_draw_info (NDI_UNIQUE, 0, enemy, "Your light reveals your hiding spot!");	1893	new_draw_info (NDI_UNIQUE, 0, enemy, "Your light reveals your hiding spot!");
…		…
1931	return 0;	1924	return 0;
1932		1925
1933	return 1;	1926	return 1;
1934	}	1927	}
1935		1928
		1929	//-GPL

Diff Legend

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