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.65 by root, Fri Sep 25 18:44:58 2009 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
386	/* Probably really a bug for a creature to have both
387	* stand still and a movement type set.
388	*/
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:	435	case T_HANDLE:
424	rand_move (op);	436	case TRIGGER:
425	break;	437	if (monster->will_apply & 1)
426		438	manual_apply (monster, tmp, 0);
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 == shstr_doppleganger)
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 (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
557	if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY))
558	dir = absdir (dir + 4);
559
560	if (QUERY_FLAG (op, FLAG_CONFUSED))
561	dir = absdir (dir + rndm (3) + rndm (3) - 2);
562
563	pre_att_dir = dir; /* remember the original direction */
564
565	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))
566	{
567	switch (op->attack_movement & LO4)
568	{
569	case DISTATT:
570	dir = dist_att (dir, op, enemy, part, &rv);
571	break;	439	break;
572		440
573	case RUNATT:	441	case TREASURE:
574	dir = run_att (dir, op, enemy, part, &rv);	442	if (monster->will_apply & 2)
		443	manual_apply (monster, tmp, 0);
575	break;	444	break;
576		445
577	case HITRUN:
578	dir = hitrun_att (dir, op, enemy);
579	break;
580
581	case WAITATT:
582	dir = wait_att (dir, op, enemy, part, &rv);
583	break;
584
585	case RUSH: /* default - monster normally moves towards player */
586	case ALLRUN:
587	break;
588
589	case DISTHIT:
590	dir = disthit_att (dir, op, enemy, part, &rv);
591	break;
592
593	case WAIT2:
594	dir = wait_att2 (dir, op, enemy, part, &rv);
595	break;
596
597	default:
598	LOG (llevDebug, "Illegal low mon-move: %d\n", op->attack_movement & LO4);
599	}
600	}
601
602	if (!dir)
603	return 0;
604
605	if (!QUERY_FLAG (op, FLAG_STAND_STILL))
606	{
607	if (move_object (op, dir)) /* Can the monster move directly toward player? */
608	{	446	}
609	/* elmex: Turn our monster after it moved if it has DISTATT attack */	447	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
610	if ((op->attack_movement & LO4) == DISTATT)	448	break;
611	op->direction = pre_att_dir;
612
613	return 0;
614	}
615
616	if (QUERY_FLAG (op, FLAG_SCARED) || !can_hit (part, enemy, &rv) || QUERY_FLAG (op, FLAG_RUN_AWAY))
617	{
618	/* Try move around corners if !close */
619	int maxdiff = (QUERY_FLAG (op, FLAG_ONLY_ATTACK) || rndm (2)) ? 1 : 2;
620
621	for (diff = 1; diff <= maxdiff; diff++)
622	{
623	/* try different detours */
624	int m = 1 - rndm (2) * 2; /* Try left or right first? */
625
626	if (move_object (op, absdir (dir + diff * m)) || move_object (op, absdir (dir - diff * m)))
627	return 0;
628	}
629	}
630	} /* if monster is not standing still */
631
632	/* elmex: Turn our monster after it moved if it has DISTATT attack */
633	if ((op->attack_movement & LO4) == DISTATT)
634	op->direction = pre_att_dir;
635
636	/*
637	* Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random
638	* direction if they can't move away.
639	*/
640	if (!QUERY_FLAG (op, FLAG_ONLY_ATTACK) && (QUERY_FLAG (op, FLAG_RUN_AWAY) || QUERY_FLAG (op, FLAG_SCARED)))
641	if (move_randomly (op))
642	return 0;
643
644	/*
645	* Try giving the monster a new enemy - the player that is closest
646	* to it. In this way, it won't just keep trying to get to a target
647	* that is inaccessible.
648	* This could be more clever - it should go through a list of several
649	* enemies, as it is now, you could perhaps get situations where there
650	* are two players flanking the monster at close distance, but which
651	* the monster can't get to, and a third one at a far distance that
652	* the monster could get to - as it is, the monster won't look at that
653	* third one.
654	*/
655	if (!QUERY_FLAG (op, FLAG_FRIENDLY) && enemy == op->enemy)
656	{	449	}
657	object *nearest_player = get_nearest_player (op);
658
659	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))
660	{
661	op->enemy = 0;
662	enemy = nearest_player;
663	}
664	}
665
666	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))
667	{
668	/* The adjustement to wc that was here before looked totally bogus -
669	* since wc can in fact get negative, that would mean by adding
670	* the current wc, the creature gets better? Instead, just
671	* add a fixed amount - nasty creatures that are runny away should
672	* still be pretty nasty.
673	*/
674	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
675	{
676	part->stats.wc += 10;
677	skill_attack (enemy, part, 0, NULL, NULL);
678	part->stats.wc -= 10;
679	}
680	else
681	skill_attack (enemy, part, 0, NULL, NULL);
682	} /* if monster is in attack range */
683
684	if (QUERY_FLAG (part, FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */
685	return 1;
686
687	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
688	{
689	op->drop_and_destroy ();
690	return 1;
691	}
692
693	return 0;
694	}
695
696	int
697	can_hit (object *ob1, object *ob2, rv_vector * rv)
698	{
699	object *more;
700	rv_vector rv1;
701
702	if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(rndm (3)))
703	return 0;
704
705	if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)
706	return 1;
707
708	/* check all the parts of ob2 - just because we can't get to
709	* its head doesn't mean we don't want to pound its feet
710	*/
711	for (more = ob2->more; more != NULL; more = more->more)
712	{
713	get_rangevector (ob1, more, &rv1, 0);
714	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
715	return 1;
716	}
717
718	return 0;
719	}	450	}
720		451
721	/* Returns 1 is monster should cast spell sp at an enemy	452	/* Returns 1 is monster should cast spell sp at an enemy
722	* Returns 0 if the monster should not cast this spell.	453	* Returns 0 if the monster should not cast this spell.
723	*	454	*
…		…
731	*	462	*
732	* 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,
733	* 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,
734	* the right type of healing spell could be useful.	465	* the right type of healing spell could be useful.
735	*/	466	*/
736
737	static int	467	static int
738	monster_should_cast_spell (object *monster, object *spell_ob)	468	monster_should_cast_spell (object *monster, object *spell_ob)
739	{	469	{
740	if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||	470	if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||
741	spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||	471	spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||
…		…
746	return 1;	476	return 1;
747		477
748	return 0;	478	return 0;
749	}	479	}
750		480
751	#define MAX_KNOWN_SPELLS 20
752
753	/* Returns a randomly selected spell. This logic is still
754	* less than ideal. This code also only seems to deal with
755	* wizard spells, as the check is against sp, and not grace.
756	* can mosnters know cleric spells?
757	*/
758	object *
759	monster_choose_random_spell (object *monster)
760	{
761	object *altern[MAX_KNOWN_SPELLS];
762	int i = 0;
763
764	for (object *tmp = monster->inv; tmp; tmp = tmp->below)
765	if (tmp->type == SPELLBOOK || tmp->type == SPELL)
766	{
767	/* Check and see if it's actually a useful spell.
768	* If its a spellbook, the spell is actually the inventory item.
769	* if it is a spell, then it is just the object itself.
770	*/
771	if (monster_should_cast_spell (monster, (tmp->type == SPELLBOOK) ? tmp->inv : tmp))
772	{
773	altern [i++] = tmp;
774
775	if (i == MAX_KNOWN_SPELLS)
776	break;
777	}
778	}
779
780	return i ? altern [rndm (i)] : 0;
781	}
782
783	/* This checks to see if the monster should cast a spell/ability.
784	* it returns true if the monster casts a spell, 0 if he doesn't.
785	* head is the head of the monster.
786	* part is the part of the monster we are checking against.
787	* pl is the target.
788	* dir is the direction to case.
789	* rv is the vector which describes where the enemy is.
790	*/
791	int
792	monster_cast_spell (object *head, object *part, object *pl, int dir, rv_vector * rv)
793	{
794	object *spell_item;
795	object *owner;
796	rv_vector rv1;
797
798	/* If you want monsters to cast spells over friends, this spell should
799	* be removed. It probably should be in most cases, since monsters still
800	* don't care about residual effects (ie, casting a cone which may have a
801	* clear path to the player, the side aspects of the code will still hit
802	* other monsters)
803	*/
804	if (!(dir = path_to_player (part, pl, 0)))
805	return 0;
806
807	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
808	{
809	get_rangevector (head, owner, &rv1, 0x1);
810	if (dirdiff (dir, rv1.direction) < 2)
811	return 0; /* Might hit owner with spell */
812	}
813
814	if (QUERY_FLAG (head, FLAG_CONFUSED))
815	dir = absdir (dir + rndm (3) + rndm (3) - 2);
816
817	/* If the monster hasn't already chosen a spell, choose one
818	* I'm not sure if it really make sense to pre-select spells (events
819	* could be different by the time the monster goes again).
820	*/
821	if (head->spellitem == NULL)
822	{
823	if ((spell_item = monster_choose_random_spell (head)) == NULL)
824	{
825	LOG (llevMonster, "Turned off spells in %s\n", &head->name);
826	CLEAR_FLAG (head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
827	return 0;
828	}
829
830	if (spell_item->type == SPELLBOOK)
831	{
832	if (!spell_item->inv)
833	{
834	LOG (llevError, "spellbook %s does not contain a spell?\n", &spell_item->name);
835	return 0;
836	}
837
838	spell_item = spell_item->inv;
839	}
840	}
841	else
842	spell_item = head->spellitem;
843
844	if (!spell_item)
845	return 0;
846
847	/* Best guess this is a defensive/healing spell */
848	if (spell_item->range <= 1 || spell_item->stats.dam < 0)
849	dir = 0;
850
851	/* Monster doesn't have enough spell-points */
852	if (head->stats.sp < SP_level_spellpoint_cost (head, spell_item, SPELL_MANA))
853	return 0;
854
855	if (head->stats.grace < SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE))
856	return 0;
857
858	head->stats.sp -= SP_level_spellpoint_cost (head, spell_item, SPELL_MANA);
859	head->stats.grace -= SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE);
860
861	/* set this to null, so next time monster will choose something different */
862	head->spellitem = NULL;
863
864	return cast_spell (part, part, dir, spell_item, NULL);
865	}
866
867	int
868	monster_use_scroll (object *head, object *part, object *pl, int dir, rv_vector * rv)
869	{
870	object *scroll;
871	object *owner;
872	rv_vector rv1;
873
874	/* If you want monsters to cast spells over friends, this spell should
875	* be removed. It probably should be in most cases, since monsters still
876	* don't care about residual effects (ie, casting a cone which may have a
877	* clear path to the player, the side aspects of the code will still hit
878	* other monsters)
879	*/
880	if (!(dir = path_to_player (part, pl, 0)))
881	return 0;
882
883	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
884	{
885	get_rangevector (head, owner, &rv1, 0x1);
886	if (dirdiff (dir, rv1.direction) < 2)
887	{
888	return 0; /* Might hit owner with spell */
889	}
890	}
891
892	if (QUERY_FLAG (head, FLAG_CONFUSED))
893	dir = absdir (dir + rndm (3) + rndm (3) - 2);
894
895	for (scroll = head->inv; scroll; scroll = scroll->below)
896	if (scroll->type == SCROLL && monster_should_cast_spell (head, scroll->inv))
897	break;
898
899	/* Used up all his scrolls, so nothing do to */
900	if (!scroll)
901	{
902	CLEAR_FLAG (head, FLAG_READY_SCROLL);
903	return 0;
904	}
905
906	/* Spell should be cast on caster (ie, heal, strength) */
907	if (scroll->inv->range == 0)
908	dir = 0;
909
910	apply_scroll (part, scroll, dir);
911	return 1;
912	}
913
914	/* monster_use_skill()-implemented 95-04-28 to allow monster skill use.
915	* Note that monsters do not need the skills SK_MELEE_WEAPON and
916	* SK_MISSILE_WEAPON to make those respective attacks, if we
917	* required that we would drastically increase the memory
918	* requirements of CF!!
919	*
920	* The skills we are treating here are all but those. -b.t.
921	*
922	* At the moment this is only useful for throwing, perhaps for
923	* stealing. TODO: This should be more integrated in the game. -MT, 25.11.01
924	*/
925	int
926	monster_use_skill (object *head, object *part, object *pl, int dir)
927	{
928	object *skill, *owner;
929
930	if (!(dir = path_to_player (part, pl, 0)))
931	return 0;
932
933	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
934	{
935	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
936
937	if (dirdiff (dir, dir2) < 1)
938	return 0; /* Might hit owner with skill -thrown rocks for example ? */
939	}
940
941	if (QUERY_FLAG (head, FLAG_CONFUSED))
942	dir = absdir (dir + rndm (3) + rndm (3) - 2);
943
944	/* skill selection - monster will use the next unused skill.
945	* well...the following scenario will allow the monster to
946	* toggle between 2 skills. One day it would be nice to make
947	* more skills available to monsters.
948	*/
949	for (skill = head->inv; skill; skill = skill->below)
950	if (skill->type == SKILL && skill != head->chosen_skill)
951	{
952	head->chosen_skill = skill;
953	break;
954	}
955
956	if (!skill && !head->chosen_skill)
957	{
958	LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);
959	CLEAR_FLAG (head, FLAG_READY_SKILL);
960	return 0;
961	}
962
963	/* use skill */
964	return do_skill (head, part, head->chosen_skill, dir, NULL);
965	}
966
967	/* Monster will use a ranged spell attack. */
968	int
969	monster_use_range (object *head, object *part, object *pl, int dir)
970	{
971	object *wand, *owner;
972	int at_least_one = 0;
973
974	if (!(dir = path_to_player (part, pl, 0)))
975	return 0;
976
977	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
978	{
979	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
980
981	if (dirdiff (dir, dir2) < 2)
982	return 0; /* Might hit owner with spell */
983	}
984
985	if (QUERY_FLAG (head, FLAG_CONFUSED))
986	dir = absdir (dir + rndm (3) + rndm (3) - 2);
987
988	for (wand = head->inv; wand; wand = wand->below)
989	{
990	if (wand->type == WAND)
991	{
992	/* Found a wand, let's see if it has charges left */
993	at_least_one = 1;
994	if (wand->stats.food <= 0)
995	continue;
996
997	cast_spell (head, wand, dir, wand->inv, NULL);
998
999	if (!(--wand->stats.food))
1000	{
1001	if (wand->arch)
1002	{
1003	CLEAR_FLAG (wand, FLAG_ANIMATE);
1004	wand->face = wand->arch->face;
1005	wand->set_speed (0);
1006	}
1007	}
1008	/* Success */
1009	return 1;
1010	}
1011	else if (wand->type == ROD || wand->type == HORN)
1012	{
1013	/* Found rod/horn, let's use it if possible */
1014	at_least_one = 1;
1015	if (wand->stats.hp < MAX (wand->inv->stats.sp, wand->inv->stats.grace))
1016	continue;
1017
1018	/* drain charge before casting spell - can be a case where the
1019	* spell destroys the monster, and rod, so if done after, results
1020	* in crash.
1021	*/
1022	drain_rod_charge (wand);
1023	cast_spell (head, wand, dir, wand->inv, NULL);
1024
1025	/* Success */
1026	return 1;
1027	}
1028	}
1029
1030	if (at_least_one)
1031	return 0;
1032
1033	LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANGE() without wand/horn/rod.\n", &head->name, head->count);
1034	CLEAR_FLAG (head, FLAG_READY_RANGE);
1035	return 0;
1036	}
1037
1038	int
1039	monster_use_bow (object *head, object *part, object *pl, int dir)
1040	{
1041	object *owner;
1042
1043	if (!(dir = path_to_player (part, pl, 0)))
1044	return 0;
1045
1046	if (QUERY_FLAG (head, FLAG_CONFUSED))
1047	dir = absdir (dir + rndm (3) + rndm (3) - 2);
1048
1049	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
1050	{
1051	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
1052
1053	if (dirdiff (dir, dir2) < 1)
1054	return 0; /* Might hit owner with arrow */
1055	}
1056
1057	/* in server/player.c */
1058	return fire_bow (head, part, NULL, dir, 0, part->x, part->y);
1059
1060	}
1061
1062	/* Checks if putting on 'item' will make 'who' do more	481	/* Checks if putting on 'item' will make 'who' do more
1063	* damage. This is a very simplistic check - also checking things	482	* damage. This is a very simplistic check - also checking things
1064	* like speed and ac are also relevant.	483	* like speed and ac are also relevant.
1065	*	484	*
1066	* return true if item is a better object.	485	* return true if item is a better object.
1067	*/	486	*/
1068	int	487	static int
1069	check_good_weapon (object *who, object *item)	488	check_good_weapon (object *who, object *item)
1070	{	489	{
1071	object *other_weap;	490	object *other_weap;
1072	int val = 0, i;	491	int val = 0, i;
1073		492
…		…
1096	return 1;	515	return 1;
1097	else	516	else
1098	return 0;	517	return 0;
1099	}	518	}
1100		519
1101	int	520	static int
1102	check_good_armour (object *who, object *item)	521	check_good_armour (object *who, object *item)
1103	{	522	{
1104	object *other_armour;	523	object *other_armour;
1105	int val = 0, i;	524	int val = 0, i;
1106		525
…		…
1134		553
1135	if (val > 0)	554	if (val > 0)
1136	return 1;	555	return 1;
1137	else	556	else
1138	return 0;	557	return 0;
1139	}
1140
1141	/*
1142	* monster_check_pickup(): checks for items that monster can pick up.
1143	*
1144	* Vick's (vick@bern.docs.uu.se) fix 921030 for the sweeper blob.
1145	* Each time the blob passes over some treasure, it will
1146	* grab it a.s.a.p.
1147	*
1148	* Eneq(@csd.uu.se): This can now be defined in the archetypes, added code
1149	* to handle this.
1150	*
1151	* This function was seen be continueing looping at one point (tmp->below
1152	* became a recursive loop. It may be better to call monster_check_apply
1153	* after we pick everything up, since that function may call others which
1154	* affect stacking on this space.
1155	*/
1156	void
1157	monster_check_pickup (object *monster)
1158	{
1159	object *tmp, *next;
1160
1161	for (tmp = monster->below; tmp != NULL; tmp = next)
1162	{
1163	next = tmp->below;
1164	if (monster_can_pick (monster, tmp))
1165	{
1166	tmp->remove ();
1167	tmp = insert_ob_in_ob (tmp, monster);
1168	(void) monster_check_apply (monster, tmp);
1169	}
1170	/* We could try to re-establish the cycling, of the space, but probably
1171	* not a big deal to just bail out.
1172	*/
1173	if (next && next->destroyed ())
1174	return;
1175	}
1176	}
1177
1178	/*
1179	* monster_can_pick(): If the monster is interested in picking up
1180	* the item, then return 0. Otherwise 0.
1181	* Instead of pick_up, flags for "greed", etc, should be used.
1182	* I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
1183	*/
1184	int
1185	monster_can_pick (object *monster, object *item)
1186	{
1187	int flag = 0;
1188	int i;
1189
1190	if (!can_pick (monster, item))
1191	return 0;
1192
1193	if (QUERY_FLAG (item, FLAG_UNPAID))
1194	return 0;
1195
1196	if (monster->pick_up & 64) /* All */
1197	flag = 1;
1198
1199	else
1200	switch (item->type)
1201	{
1202	case MONEY:
1203	case GEM:
1204	flag = monster->pick_up & 2;
1205	break;
1206
1207	case FOOD:
1208	flag = monster->pick_up & 4;
1209	break;
1210
1211	case WEAPON:
1212	flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON);
1213	break;
1214
1215	case ARMOUR:
1216	case SHIELD:
1217	case HELMET:
1218	case BOOTS:
1219	case GLOVES:
1220	case GIRDLE:
1221	flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR);
1222	break;
1223
1224	case SKILL:
1225	flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);
1226	break;
1227
1228	case RING:
1229	flag = QUERY_FLAG (monster, FLAG_USE_RING);
1230	break;
1231
1232	case WAND:
1233	case HORN:
1234	case ROD:
1235	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1236	break;
1237
1238	case SPELLBOOK:
1239	flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1240	break;
1241
1242	case SCROLL:
1243	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1244	break;
1245
1246	case BOW:
1247	case ARROW:
1248	flag = QUERY_FLAG (monster, FLAG_USE_BOW);
1249	break;
1250	}
1251
1252	/* Simplistic check - if the monster has a location to equip it, he will
1253	* pick it up. Note that this doesn't handle cases where an item may
1254	* use several locations.
1255	*/
1256	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1257	{
1258	if (monster->slot[i].info && item->slot[i].info)
1259	{
1260	flag = 1;
1261	break;
1262	}
1263	}
1264
1265	if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && (!flag)))
1266	return 1;
1267
1268	return 0;
1269	}
1270
1271	/*
1272	* monster_apply_below():
1273	* Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
1274	* eager to apply things, encounters something apply-able,
1275	* then make him apply it
1276	*/
1277	void
1278	monster_apply_below (object *monster)
1279	{
1280	object *tmp, *next;
1281
1282	for (tmp = monster->below; tmp != NULL; tmp = next)
1283	{
1284	next = tmp->below;
1285	switch (tmp->type)
1286	{
1287	case CF_HANDLE:
1288	case TRIGGER:
1289	if (monster->will_apply & 1)
1290	manual_apply (monster, tmp, 0);
1291	break;
1292
1293	case TREASURE:
1294	if (monster->will_apply & 2)
1295	manual_apply (monster, tmp, 0);
1296	break;
1297
1298	}
1299	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1300	break;
1301	}
1302	}	558	}
1303		559
1304	/*	560	/*
1305	* 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
1306	* inserted in a monster.	562	* inserted in a monster.
…		…
1417	* monsters have some advantages after all.	673	* monsters have some advantages after all.
1418	*/	674	*/
1419	manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);	675	manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);
1420	}	676	}
1421		677
1422	void	678	static int
1423	npc_call_help (object *op)	679	can_hit (object *ob1, object *ob2, rv_vector * rv)
1424	{	680	{
1425	unordered_mapwalk (op, -7, -7, 7, 7)	681	object *more;
1426	{	682	rv_vector rv1;
1427	mapspace &ms = m->at (nx, ny);
1428		683
1429	/* If nothing alive on this space, no need to search the space. */	684	if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(rndm (3)))
1430	if (!(ms.flags () & P_IS_ALIVE))	685	return 0;
1431	continue;
1432		686
1433	for (object *npc = ms.bot; npc; npc = npc->above)	687	if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)
1434	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))	688	return 1;
1435	npc->enemy = op->enemy;	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)
1436	}	694	{
1437	}	695	get_rangevector (ob1, more, &rv1, 0);
		696	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
		697	return 1;
		698	}
1438		699
1439	int	700	return 0;
		701	}
		702
		703	static int
1440	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)
1441	{	705	{
1442	if (can_hit (part, enemy, rv))	706	if (can_hit (part, enemy, rv))
1443	return dir;	707	return dir;
1444		708
…		…
1448	return dir;	712	return dir;
1449		713
1450	return 0;	714	return 0;
1451	}	715	}
1452		716
1453	int	717	static int
1454	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)
1455	{	719	{
1456	if (can_hit (part, enemy, rv))	720	if (can_hit (part, enemy, rv))
1457	return dir;	721	return dir;
1458	else	722	else
1459	return absdir (dir + 4);	723	return absdir (dir + 4);
1460	}	724	}
1461		725
1462	int	726	static int
1463	hitrun_att (int dir, object *ob, object *enemy)	727	hitrun_att (int dir, object *ob, object *enemy)
1464	{	728	{
1465	if (ob->move_status++ < 25)	729	if (ob->move_status++ < 25)
1466	return dir;	730	return dir;
1467	else if (ob->move_status < 50)	731	else if (ob->move_status < 50)
…		…
1470	ob->move_status = 0;	734	ob->move_status = 0;
1471		735
1472	return absdir (dir + 4);	736	return absdir (dir + 4);
1473	}	737	}
1474		738
1475	int	739	static int
1476	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)
1477	{	741	{
1478	int inrange = can_hit (part, enemy, rv);	742	int inrange = can_hit (part, enemy, rv);
1479		743
1480	if (ob->move_status || inrange)	744	if (ob->move_status || inrange)
…		…
1489		753
1490	ob->move_status = 0;	754	ob->move_status = 0;
1491	return 0;	755	return 0;
1492	}	756	}
1493		757
1494	int	758	static int
1495	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)
1496	{	760	{
1497	/* The logic below here looked plain wrong before. Basically, what should	761	/* The logic below here looked plain wrong before. Basically, what should
1498	* 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,
1499	* the creature should run away (dir+4)	763	* the creature should run away (dir+4)
1500	* 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
1501	* 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
1502	* server should try to be resilant enough to avoid the problem	766	* server should try to be resilant enough to avoid the problem
1503	*/	767	*/
1504	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)
1505	return absdir (dir + 4);	769	return absdir (dir + 4);
1506		770
1507	return dist_att (dir, ob, enemy, part, rv);	771	return dist_att (dir, ob, enemy, part, rv);
1508	}	772	}
1509		773
1510	int	774	static int
1511	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)
1512	{	776	{
1513	if (rv->distance < 9)	777	if (rv->distance < 9)
1514	return absdir (dir + 4);	778	return absdir (dir + 4);
1515		779
1516	return 0;	780	return 0;
1517	}	781	}
1518		782
1519	void	783	static void
1520	circ1_move (object *ob)	784	circ1_move (object *ob)
1521	{	785	{
1522	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 };
1523		787
1524	if (++ob->move_status > 11)	788	if (++ob->move_status > 11)
…		…
1526		790
1527	if (!(move_object (ob, circle[ob->move_status])))	791	if (!(move_object (ob, circle[ob->move_status])))
1528	move_object (ob, rndm (8) + 1);	792	move_object (ob, rndm (8) + 1);
1529	}	793	}
1530		794
1531	void	795	static void
1532	circ2_move (object *ob)	796	circ2_move (object *ob)
1533	{	797	{
1534	static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };	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 };
1535		799
1536	if (++ob->move_status > 19)	800	if (++ob->move_status > 19)
…		…
1538		802
1539	if (!(move_object (ob, circle[ob->move_status])))	803	if (!(move_object (ob, circle[ob->move_status])))
1540	move_object (ob, rndm (8) + 1);	804	move_object (ob, rndm (8) + 1);
1541	}	805	}
1542		806
1543	void	807	static void
1544	pace_movev (object *ob)	808	pace_movev (object *ob)
1545	{	809	{
1546	if (ob->move_status++ > 6)	810	if (ob->move_status++ > 6)
1547	ob->move_status = 0;	811	ob->move_status = 0;
1548		812
…		…
1550	move_object (ob, 5);	814	move_object (ob, 5);
1551	else	815	else
1552	move_object (ob, 1);	816	move_object (ob, 1);
1553	}	817	}
1554		818
1555	void	819	static void
1556	pace_moveh (object *ob)	820	pace_moveh (object *ob)
1557	{	821	{
1558	if (ob->move_status++ > 6)	822	if (ob->move_status++ > 6)
1559	ob->move_status = 0;	823	ob->move_status = 0;
1560		824
…		…
1562	move_object (ob, 3);	826	move_object (ob, 3);
1563	else	827	else
1564	move_object (ob, 7);	828	move_object (ob, 7);
1565	}	829	}
1566		830
1567	void	831	static void
1568	pace2_movev (object *ob)	832	pace2_movev (object *ob)
1569	{	833	{
1570	if (ob->move_status++ > 16)	834	if (ob->move_status++ > 16)
1571	ob->move_status = 0;	835	ob->move_status = 0;
1572		836
…		…
1578	move_object (ob, 1);	842	move_object (ob, 1);
1579	else	843	else
1580	return;	844	return;
1581	}	845	}
1582		846
1583	void	847	static void
1584	pace2_moveh (object *ob)	848	pace2_moveh (object *ob)
1585	{	849	{
1586	if (ob->move_status++ > 16)	850	if (ob->move_status++ > 16)
1587	ob->move_status = 0;	851	ob->move_status = 0;
1588		852
…		…
1594	move_object (ob, 7);	858	move_object (ob, 7);
1595	else	859	else
1596	return;	860	return;
1597	}	861	}
1598		862
1599	void	863	static void
1600	rand_move (object *ob)	864	rand_move (object *ob)
1601	{	865	{
1602	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)))))
1603	for (int i = 0; i < 5; i++)	867	for (int i = 0; i < 5; i++)
1604	if (move_object (ob, ob->move_status = rndm (8) + 1))	868	if (move_object (ob, ob->move_status = rndm (8) + 1))
1605	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	}
1606	}	1198	}
1607		1199
1608	void	1200	void
1609	check_earthwalls (object *op, maptile *m, int x, int y)	1201	check_earthwalls (object *op, maptile *m, int x, int y)
1610	{	1202	{
…		…
1661	#ifdef DEBUG_THROW	1253	#ifdef DEBUG_THROW
1662	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);
1663	#endif	1255	#endif
1664		1256
1665	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;
1666	}	1672	}
1667		1673
1668	/* 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
1669	* 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
1670	* 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.
…		…
1834		1840
1835	if (op->glow_radius > 0)	1841	if (op->glow_radius > 0)
1836	return 1;	1842	return 1;
1837		1843
1838	if (op->map)	1844	if (op->map)
1839	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)
1840	{	1846	{
1841	/* 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
1842	* 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.
1843	*/	1849	*/
1844	int light = m->at (nx, ny).light;	1850	int light = m->at (nx, ny).light;
…		…
1918	return 0;	1924	return 0;
1919		1925
1920	return 1;	1926	return 1;
1921	}	1927	}
1922		1928
		1929	//-GPL

Diff Legend

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