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.68 by root, Fri Sep 25 19:09:20 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>
…		…
150	* Currently, only move_monster calls this function.	153	* Currently, only move_monster calls this function.
151	* Fix function so that we always make calls to get_rangevector	154	* Fix function so that we always make calls to get_rangevector
152	* 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
153	* many cases.	156	* many cases.
154	*/	157	*/
155	object *	158	static object *
156	find_enemy (object *npc, rv_vector * rv)	159	find_enemy (object *npc, rv_vector * rv)
157	{	160	{
158	object *attacker, *tmp = NULL;	161	object *attacker, *tmp = NULL;
159		162
160	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. */
…		…
228	/* Sees if this monster should wake up.	231	/* Sees if this monster should wake up.
229	* Currently, this is only called from move_monster, and	232	* Currently, this is only called from move_monster, and
230	* if enemy is set, then so should be rv.	233	* if enemy is set, then so should be rv.
231	* returns 1 if the monster should wake up, 0 otherwise.	234	* returns 1 if the monster should wake up, 0 otherwise.
232	*/	235	*/
233	int	236	static int
234	check_wakeup (object *op, object *enemy, rv_vector *rv)	237	check_wakeup (object *op, object *enemy, rv_vector *rv)
235	{	238	{
236	/* Trim work - if no enemy, no need to do anything below */	239	/* Trim work - if no enemy, no need to do anything below */
237	if (!enemy)	240	if (!enemy)
238	return 0;	241	return 0;
…		…
269	}	272	}
270		273
271	return 0;	274	return 0;
272	}	275	}
273		276
274	int	277	static int
275	move_randomly (object *op)	278	move_randomly (object *op)
276	{	279	{
277	/* Give up to 15 chances for a monster to move randomly */	280	/* Give up to 15 chances for a monster to move randomly */
278	for (int i = 0; i < 15; i++)	281	for (int i = 0; i < 15; i++)
279	if (move_object (op, rndm (8) + 1))	282	if (move_object (op, rndm (8) + 1))
…		…
281		284
282	return 0;	285	return 0;
283	}	286	}
284		287
285	/*	288	/*
286	* 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.
287	*/	293	*/
288	int	294	static int
289	move_monster (object *op)	295	monster_can_pick (object *monster, object *item)
290	{	296	{
291	int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */	297	int flag = 0;
292	object *owner, *enemy, *part, *oph = op;	298	int i;
293	rv_vector rv;
294		299
295	/* Monsters not on maps don't do anything. These monsters are things	300	if (!can_pick (monster, item))
296	* 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.
297	*/	365	*/
298	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)))
299	return 0;	376	return 1;
300		377
301	/* for target facing, we copy this value here for fast access */	378	return 0;
302	if (oph->head) /* force update the head - one arch one pic */	379	}
303	oph = oph->head;
304		380
305	if (QUERY_FLAG (op, FLAG_NO_ATTACK)) /* we never ever attack */	381	/*
306	enemy = op->enemy = NULL;	382	* monster_check_pickup(): checks for items that monster can pick up.
307	else if ((enemy = find_enemy (op, &rv)))	383	*
308	/* 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.
309	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;
310		400
311	/* generate hp, if applicable */	401	for (tmp = monster->below; tmp != NULL; tmp = next)
312	if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp)
313	{	402	{
314	/* last heal is in funny units. Dividing by speed puts	403	next = tmp->below;
315	* the regeneration rate on a basis of time instead of	404	if (monster_can_pick (monster, tmp))
316	* #moves the monster makes. The scaling by 8 is
317	* to capture 8th's of a hp fraction regens
318	*	405	{
319	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)	406	tmp->remove ();
320	* 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.
321	*/	413	*/
322		414	if (next && next->destroyed ())
323	op->last_heal += (int) ((float) (8 * op->stats.Con) / FABS (op->speed));
324	op->stats.hp = MIN ((sint32) op->stats.hp + op->last_heal / 32, op->stats.maxhp); /* causes Con/4 hp/tick */
325	op->last_heal %= 32;
326
327	/* So if the monster has gained enough HP that they are no longer afraid */
328	if (QUERY_FLAG (op, FLAG_RUN_AWAY) && op->stats.hp >= (signed short)(((float)op->run_away / 100.f) * (float)op->stats.maxhp))
329	CLEAR_FLAG (op, FLAG_RUN_AWAY);
330
331	if (op->stats.hp > op->stats.maxhp)
332	op->stats.hp = op->stats.maxhp;
333	}
334
335	/* generate sp, if applicable */
336	if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp)
337	{
338	/* last_sp is in funny units. Dividing by speed puts
339	* the regeneration rate on a basis of time instead of
340	* #moves the monster makes. The scaling by 8 is
341	* to capture 8th's of a sp fraction regens
342	*
343	* Cast to sint32 before comparing to maxhp since otherwise an (sint16)
344	* overflow might produce monsters with negative sp.
345	*/
346
347	op->last_sp += (int) ((float) (8 * op->stats.Pow) / fabsf (op->speed));
348	op->stats.sp = min (op->stats.sp + op->last_sp / 128, op->stats.maxsp); /* causes Pow/16 sp/tick */
349	op->last_sp %= 128;
350	}
351
352	/* this should probably get modified by many more values.
353	* (eg, creatures resistance to fear, level, etc. )
354	*/
355	if (QUERY_FLAG (op, FLAG_SCARED) && !(rndm (20)))
356	CLEAR_FLAG (op, FLAG_SCARED); /* Time to regain some "guts"... */
357
358	if (INVOKE_OBJECT (MONSTER_MOVE, op, ARG_OBJECT (op->enemy)))
359	return QUERY_FLAG (op, FLAG_FREED);
360
361	if (QUERY_FLAG (op, FLAG_SLEEP) || QUERY_FLAG (op, FLAG_BLIND) ||
362	((op->map->darklevel () > 0) && !QUERY_FLAG (op, FLAG_SEE_IN_DARK) && !QUERY_FLAG (op, FLAG_SEE_INVISIBLE)))
363	if (!check_wakeup (op, enemy, &rv))
364	return 0;
365
366	/* check if monster pops out of hidden spot */
367	if (op->flag [FLAG_HIDDEN])
368	do_hidden_move (op);
369
370	if (op->pick_up)
371	monster_check_pickup (op);
372
373	if (op->will_apply)
374	monster_apply_below (op); /* Check for items to apply below */
375
376	/* If we don't have an enemy, do special movement or the like */
377	if (!enemy)
378	{
379	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
380	{
381	op->drop_and_destroy ();
382	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)
383	}	434	{
384
385	/* Probably really a bug for a creature to have both
386	* stand still and a movement type set.
387	*/
388	if (!QUERY_FLAG (op, FLAG_STAND_STILL))
389	{
390	if (op->attack_movement & HI4)
391	{
392	switch (op->attack_movement & HI4)
393	{
394	case PETMOVE:
395	pet_move (op);
396	break;
397
398	case CIRCLE1:
399	circ1_move (op);
400	break;
401
402	case CIRCLE2:
403	circ2_move (op);
404	break;
405
406	case PACEV:
407	pace_movev (op);
408	break;
409
410	case PACEH:
411	pace_moveh (op);
412	break;
413
414	case PACEV2:
415	pace2_movev (op);
416	break;
417
418	case PACEH2:
419	pace2_moveh (op);
420	break;
421
422	case RANDO:	435	case T_HANDLE:
423	rand_move (op);	436	case TRIGGER:
424	break;	437	if (monster->will_apply & 1)
425		438	manual_apply (monster, tmp, 0);
426	case RANDO2:
427	move_randomly (op);
428	break;
429	}
430
431	return 0;
432	}
433	else if (QUERY_FLAG (op, FLAG_RANDOM_MOVE))
434	move_randomly (op);
435	} /* stand still */
436
437	return 0;
438	} /* no enemy */
439
440	/* We have an enemy. Block immediately below is for pets */
441	if ((op->attack_movement & HI4) == PETMOVE
442	&& (owner = op->owner) != NULL
443	&& !on_same_map (op, owner)
444	&& !owner->flag [FLAG_REMOVED])
445	return follow_owner (op, owner);
446
447	/* doppleganger code to change monster facing to that of the nearest
448	* player. Hmm. The code is here, but no monster in the current
449	* arch set uses it.
450	*/
451	if (op->race == shstr_doppleganger)
452	{
453	op->face = enemy->face;
454	op->name = enemy->name;
455	}
456
457	/* Calculate range information for closest body part - this
458	* is used for the 'skill' code, which isn't that smart when
459	* it comes to figuring it out - otherwise, giants throw boulders
460	* into themselves.
461	*/
462	get_rangevector (op, enemy, &rv, 0);
463
464	/* Move the check for scared up here - if the monster was scared,
465	* we were not doing any of the logic below, so might as well save
466	* a few cpu cycles.
467	*/
468	if (!QUERY_FLAG (op, FLAG_SCARED))
469	{
470	rv_vector rv1;
471
472	/* now we test every part of an object .... this is a real ugly piece of code */
473	for (part = op; part; part = part->more)
474	{
475	get_rangevector (part, enemy, &rv1, 0x1);
476	dir = rv1.direction;
477
478	/* hm, not sure about this part - in original was a scared flag here too
479	* but that we test above... so can be old code here
480	*/
481	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
482	dir = absdir (dir + 4);
483
484	if (QUERY_FLAG (op, FLAG_CONFUSED))
485	dir = absdir (dir + rndm (3) + rndm (3) - 2);
486
487	if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(rndm (3)))
488	if (monster_cast_spell (op, part, enemy, dir, &rv1))
489	return 0;
490
491	if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(rndm (3)))
492	if (monster_use_scroll (op, part, enemy, dir, &rv1))
493	return 0;
494
495	if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(rndm (3)))
496	if (monster_use_range (op, part, enemy, dir))
497	return 0;
498
499	if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(rndm (3)))
500	if (monster_use_skill (op, rv.part, enemy, rv.direction))
501	return 0;
502
503	if (QUERY_FLAG (op, FLAG_READY_BOW) && !(rndm (2)))
504	if (monster_use_bow (op, part, enemy, dir))
505	return 0;
506	} /* for processing of all parts */
507	} /* If not scared */
508
509	part = rv.part;
510	dir = rv.direction;
511
512	// if the enemy is a player, we have los. if los says we
513	// can directly reach the player, we do not deviate.
514	// for non-players, we never deviate
515	if (op->stats.Wis >= 8
516	&& enemy->contr && enemy->contr->darkness_at (op->map, op->x, op->y) == LOS_BLOCKED)
517	{
518	int sdir = 0;
519	uint32_t &smell = op->ms ().smell;
520
521	for (int ndir = 1; ndir <= 8; ++ndir)
522	{
523	mapxy pos (op); pos.move (ndir);
524
525	if (pos.normalise ())
526	{
527	mapspace &ms = pos.ms ();
528
529	if (ms.smell > smell)
530	{
531	//printf ("%s: found smell, following it, apparently (%d, %d)\n",& op->name,op->ms().smell,ms.smell);//D
532	if (op->stats.Wis >= 10)
533	smell = ms.smell - 1; // smarter: tell others
534
535	sdir = ndir;
536
537	// perturbing the path might let the monster lose track,
538	// but it will also widen the actual path, spreading information
539	if (op->stats.Wis >= 15 && !rndm (20)) // even smarter, deviate and spread?
540	sdir = absdir (sdir + 1 - rndm (2) * 2);
541	}
542	}
543	}
544
545	if (sdir)
546	dir = sdir;
547	else if (smell)
548	{
549	// no better smell found, so assume the player jumped, and erase this smell
550	//printf ("erasing smell %d\n", op->ms ().smell);//D
551	unordered_mapwalk (op, -1, -1, 1, 1)
552	m->at (nx, ny).smell = 0;
553	}
554	}
555
556	if (QUERY_FLAG (op, FLAG_SCARED) || QUERY_FLAG (op, FLAG_RUN_AWAY))
557	dir = absdir (dir + 4);
558
559	if (QUERY_FLAG (op, FLAG_CONFUSED))
560	dir = absdir (dir + rndm (3) + rndm (3) - 2);
561
562	pre_att_dir = dir; /* remember the original direction */
563
564	if ((op->attack_movement & LO4) && !QUERY_FLAG (op, FLAG_SCARED))
565	{
566	switch (op->attack_movement & LO4)
567	{
568	case DISTATT:
569	dir = dist_att (dir, op, enemy, part, &rv);
570	break;	439	break;
571		440
572	case RUNATT:	441	case TREASURE:
573	dir = run_att (dir, op, enemy, part, &rv);	442	if (monster->will_apply & 2)
		443	manual_apply (monster, tmp, 0);
574	break;	444	break;
575		445
576	case HITRUN:
577	dir = hitrun_att (dir, op, enemy);
578	break;
579
580	case WAITATT:
581	dir = wait_att (dir, op, enemy, part, &rv);
582	break;
583
584	case RUSH: /* default - monster normally moves towards player */
585	case ALLRUN:
586	break;
587
588	case DISTHIT:
589	dir = disthit_att (dir, op, enemy, part, &rv);
590	break;
591
592	case WAIT2:
593	dir = wait_att2 (dir, op, enemy, part, &rv);
594	break;
595
596	default:
597	LOG (llevDebug, "Illegal low mon-move: %d\n", op->attack_movement & LO4);
598	}
599	}
600
601	if (!dir)
602	return 0;
603
604	if (!QUERY_FLAG (op, FLAG_STAND_STILL))
605	{
606	if (move_object (op, dir)) /* Can the monster move directly toward player? */
607	{	446	}
608	/* elmex: Turn our monster after it moved if it has DISTATT attack */	447	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
609	if ((op->attack_movement & LO4) == DISTATT)	448	break;
610	op->direction = pre_att_dir;
611
612	return 0;
613	}
614
615	if (QUERY_FLAG (op, FLAG_SCARED) || !can_hit (part, enemy, &rv) || QUERY_FLAG (op, FLAG_RUN_AWAY))
616	{
617	/* Try move around corners if !close */
618	int maxdiff = (QUERY_FLAG (op, FLAG_ONLY_ATTACK) || rndm (2)) ? 1 : 2;
619
620	for (diff = 1; diff <= maxdiff; diff++)
621	{
622	/* try different detours */
623	int m = 1 - rndm (2) * 2; /* Try left or right first? */
624
625	if (move_object (op, absdir (dir + diff * m)) || move_object (op, absdir (dir - diff * m)))
626	return 0;
627	}
628	}
629	} /* if monster is not standing still */
630
631	/* elmex: Turn our monster after it moved if it has DISTATT attack */
632	if ((op->attack_movement & LO4) == DISTATT)
633	op->direction = pre_att_dir;
634
635	/*
636	* Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random
637	* direction if they can't move away.
638	*/
639	if (!QUERY_FLAG (op, FLAG_ONLY_ATTACK) && (QUERY_FLAG (op, FLAG_RUN_AWAY) || QUERY_FLAG (op, FLAG_SCARED)))
640	if (move_randomly (op))
641	return 0;
642
643	/*
644	* Try giving the monster a new enemy - the player that is closest
645	* to it. In this way, it won't just keep trying to get to a target
646	* that is inaccessible.
647	* This could be more clever - it should go through a list of several
648	* enemies, as it is now, you could perhaps get situations where there
649	* are two players flanking the monster at close distance, but which
650	* the monster can't get to, and a third one at a far distance that
651	* the monster could get to - as it is, the monster won't look at that
652	* third one.
653	*/
654	if (!QUERY_FLAG (op, FLAG_FRIENDLY) && enemy == op->enemy)
655	{	449	}
656	object *nearest_player = get_nearest_player (op);
657
658	if (nearest_player && nearest_player != enemy && !can_hit (part, enemy, &rv))
659	{
660	op->enemy = 0;
661	enemy = nearest_player;
662	}
663	}
664
665	if (!QUERY_FLAG (op, FLAG_SCARED) && can_hit (part, enemy, &rv))
666	{
667	/* The adjustement to wc that was here before looked totally bogus -
668	* since wc can in fact get negative, that would mean by adding
669	* the current wc, the creature gets better? Instead, just
670	* add a fixed amount - nasty creatures that are runny away should
671	* still be pretty nasty.
672	*/
673	if (QUERY_FLAG (op, FLAG_RUN_AWAY))
674	{
675	part->stats.wc += 10;
676	skill_attack (enemy, part, 0, NULL, NULL);
677	part->stats.wc -= 10;
678	}
679	else
680	skill_attack (enemy, part, 0, NULL, NULL);
681	} /* if monster is in attack range */
682
683	if (QUERY_FLAG (part, FLAG_FREED)) /* Might be freed by ghost-attack or hit-back */
684	return 1;
685
686	if (QUERY_FLAG (op, FLAG_ONLY_ATTACK))
687	{
688	op->drop_and_destroy ();
689	return 1;
690	}
691
692	return 0;
693	}
694
695	int
696	can_hit (object *ob1, object *ob2, rv_vector * rv)
697	{
698	object *more;
699	rv_vector rv1;
700
701	if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(rndm (3)))
702	return 0;
703
704	if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)
705	return 1;
706
707	/* check all the parts of ob2 - just because we can't get to
708	* its head doesn't mean we don't want to pound its feet
709	*/
710	for (more = ob2->more; more; more = more->more)
711	{
712	get_rangevector (ob1, more, &rv1, 0);
713	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
714	return 1;
715	}
716
717	return 0;
718	}	450	}
719		451
720	/* Returns 1 is monster should cast spell sp at an enemy	452	/* Returns 1 is monster should cast spell sp at an enemy
721	* Returns 0 if the monster should not cast this spell.	453	* Returns 0 if the monster should not cast this spell.
722	*	454	*
…		…
730	*	462	*
731	* 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,
732	* 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,
733	* the right type of healing spell could be useful.	465	* the right type of healing spell could be useful.
734	*/	466	*/
735
736	static int	467	static int
737	monster_should_cast_spell (object *monster, object *spell_ob)	468	monster_should_cast_spell (object *monster, object *spell_ob)
738	{	469	{
739	if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||	470	if (spell_ob->subtype == SP_BOLT || spell_ob->subtype == SP_BULLET ||
740	spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||	471	spell_ob->subtype == SP_EXPLOSION || spell_ob->subtype == SP_CONE ||
…		…
745	return 1;	476	return 1;
746		477
747	return 0;	478	return 0;
748	}	479	}
749		480
750	#define MAX_KNOWN_SPELLS 20
751
752	/* Returns a randomly selected spell. This logic is still
753	* less than ideal. This code also only seems to deal with
754	* wizard spells, as the check is against sp, and not grace.
755	* can mosnters know cleric spells?
756	*/
757	object *
758	monster_choose_random_spell (object *monster)
759	{
760	object *altern[MAX_KNOWN_SPELLS];
761	int i = 0;
762
763	for (object *tmp = monster->inv; tmp; tmp = tmp->below)
764	if (tmp->type == SPELLBOOK || tmp->type == SPELL)
765	{
766	/* Check and see if it's actually a useful spell.
767	* If its a spellbook, the spell is actually the inventory item.
768	* if it is a spell, then it is just the object itself.
769	*/
770	if (monster_should_cast_spell (monster, (tmp->type == SPELLBOOK) ? tmp->inv : tmp))
771	{
772	altern [i++] = tmp;
773
774	if (i == MAX_KNOWN_SPELLS)
775	break;
776	}
777	}
778
779	return i ? altern [rndm (i)] : 0;
780	}
781
782	/* This checks to see if the monster should cast a spell/ability.
783	* it returns true if the monster casts a spell, 0 if he doesn't.
784	* head is the head of the monster.
785	* part is the part of the monster we are checking against.
786	* pl is the target.
787	* dir is the direction to case.
788	* rv is the vector which describes where the enemy is.
789	*/
790	int
791	monster_cast_spell (object *head, object *part, object *pl, int dir, rv_vector * rv)
792	{
793	object *spell_item;
794	object *owner;
795	rv_vector rv1;
796
797	/* If you want monsters to cast spells over friends, this spell should
798	* be removed. It probably should be in most cases, since monsters still
799	* don't care about residual effects (ie, casting a cone which may have a
800	* clear path to the player, the side aspects of the code will still hit
801	* other monsters)
802	*/
803	if (!(dir = path_to_player (part, pl, 0)))
804	return 0;
805
806	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
807	{
808	get_rangevector (head, owner, &rv1, 0x1);
809	if (dirdiff (dir, rv1.direction) < 2)
810	return 0; /* Might hit owner with spell */
811	}
812
813	if (QUERY_FLAG (head, FLAG_CONFUSED))
814	dir = absdir (dir + rndm (3) + rndm (3) - 2);
815
816	/* If the monster hasn't already chosen a spell, choose one
817	* I'm not sure if it really make sense to pre-select spells (events
818	* could be different by the time the monster goes again).
819	*/
820	if (head->spellitem == NULL)
821	{
822	if ((spell_item = monster_choose_random_spell (head)) == NULL)
823	{
824	LOG (llevMonster, "Turned off spells in %s\n", &head->name);
825	CLEAR_FLAG (head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
826	return 0;
827	}
828
829	if (spell_item->type == SPELLBOOK)
830	{
831	if (!spell_item->inv)
832	{
833	LOG (llevError, "spellbook %s does not contain a spell?\n", &spell_item->name);
834	return 0;
835	}
836
837	spell_item = spell_item->inv;
838	}
839	}
840	else
841	spell_item = head->spellitem;
842
843	if (!spell_item)
844	return 0;
845
846	/* Best guess this is a defensive/healing spell */
847	if (spell_item->range <= 1 || spell_item->stats.dam < 0)
848	dir = 0;
849
850	/* Monster doesn't have enough spell-points */
851	if (head->stats.sp < SP_level_spellpoint_cost (head, spell_item, SPELL_MANA))
852	return 0;
853
854	if (head->stats.grace < SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE))
855	return 0;
856
857	head->stats.sp -= SP_level_spellpoint_cost (head, spell_item, SPELL_MANA);
858	head->stats.grace -= SP_level_spellpoint_cost (head, spell_item, SPELL_GRACE);
859
860	/* set this to null, so next time monster will choose something different */
861	head->spellitem = NULL;
862
863	return cast_spell (part, part, dir, spell_item, NULL);
864	}
865
866	int
867	monster_use_scroll (object *head, object *part, object *pl, int dir, rv_vector * rv)
868	{
869	object *scroll;
870	object *owner;
871	rv_vector rv1;
872
873	/* If you want monsters to cast spells over friends, this spell should
874	* be removed. It probably should be in most cases, since monsters still
875	* don't care about residual effects (ie, casting a cone which may have a
876	* clear path to the player, the side aspects of the code will still hit
877	* other monsters)
878	*/
879	if (!(dir = path_to_player (part, pl, 0)))
880	return 0;
881
882	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
883	{
884	get_rangevector (head, owner, &rv1, 0x1);
885	if (dirdiff (dir, rv1.direction) < 2)
886	{
887	return 0; /* Might hit owner with spell */
888	}
889	}
890
891	if (QUERY_FLAG (head, FLAG_CONFUSED))
892	dir = absdir (dir + rndm (3) + rndm (3) - 2);
893
894	for (scroll = head->inv; scroll; scroll = scroll->below)
895	if (scroll->type == SCROLL && monster_should_cast_spell (head, scroll->inv))
896	break;
897
898	/* Used up all his scrolls, so nothing do to */
899	if (!scroll)
900	{
901	CLEAR_FLAG (head, FLAG_READY_SCROLL);
902	return 0;
903	}
904
905	/* Spell should be cast on caster (ie, heal, strength) */
906	if (scroll->inv->range == 0)
907	dir = 0;
908
909	apply_scroll (part, scroll, dir);
910	return 1;
911	}
912
913	/* monster_use_skill()-implemented 95-04-28 to allow monster skill use.
914	* Note that monsters do not need the skills SK_MELEE_WEAPON and
915	* SK_MISSILE_WEAPON to make those respective attacks, if we
916	* required that we would drastically increase the memory
917	* requirements of CF!!
918	*
919	* The skills we are treating here are all but those. -b.t.
920	*
921	* At the moment this is only useful for throwing, perhaps for
922	* stealing. TODO: This should be more integrated in the game. -MT, 25.11.01
923	*/
924	int
925	monster_use_skill (object *head, object *part, object *pl, int dir)
926	{
927	object *skill, *owner;
928
929	if (!(dir = path_to_player (part, pl, 0)))
930	return 0;
931
932	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
933	{
934	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
935
936	if (dirdiff (dir, dir2) < 1)
937	return 0; /* Might hit owner with skill -thrown rocks for example ? */
938	}
939
940	if (QUERY_FLAG (head, FLAG_CONFUSED))
941	dir = absdir (dir + rndm (3) + rndm (3) - 2);
942
943	/* skill selection - monster will use the next unused skill.
944	* well...the following scenario will allow the monster to
945	* toggle between 2 skills. One day it would be nice to make
946	* more skills available to monsters.
947	*/
948	for (skill = head->inv; skill; skill = skill->below)
949	if (skill->type == SKILL && skill != head->chosen_skill)
950	{
951	head->chosen_skill = skill;
952	break;
953	}
954
955	if (!skill && !head->chosen_skill)
956	{
957	LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);
958	CLEAR_FLAG (head, FLAG_READY_SKILL);
959	return 0;
960	}
961
962	/* use skill */
963	return do_skill (head, part, head->chosen_skill, dir, NULL);
964	}
965
966	/* Monster will use a ranged spell attack. */
967	int
968	monster_use_range (object *head, object *part, object *pl, int dir)
969	{
970	object *wand, *owner;
971	int at_least_one = 0;
972
973	if (!(dir = path_to_player (part, pl, 0)))
974	return 0;
975
976	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
977	{
978	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
979
980	if (dirdiff (dir, dir2) < 2)
981	return 0; /* Might hit owner with spell */
982	}
983
984	if (QUERY_FLAG (head, FLAG_CONFUSED))
985	dir = absdir (dir + rndm (3) + rndm (3) - 2);
986
987	for (wand = head->inv; wand; wand = wand->below)
988	{
989	if (wand->type == WAND)
990	{
991	/* Found a wand, let's see if it has charges left */
992	at_least_one = 1;
993	if (wand->stats.food <= 0)
994	continue;
995
996	cast_spell (head, wand, dir, wand->inv, NULL);
997
998	if (!(--wand->stats.food))
999	{
1000	if (wand->arch)
1001	{
1002	CLEAR_FLAG (wand, FLAG_ANIMATE);
1003	wand->face = wand->arch->face;
1004	wand->set_speed (0);
1005	}
1006	}
1007	/* Success */
1008	return 1;
1009	}
1010	else if (wand->type == ROD || wand->type == HORN)
1011	{
1012	/* Found rod/horn, let's use it if possible */
1013	at_least_one = 1;
1014	if (wand->stats.hp < MAX (wand->inv->stats.sp, wand->inv->stats.grace))
1015	continue;
1016
1017	/* drain charge before casting spell - can be a case where the
1018	* spell destroys the monster, and rod, so if done after, results
1019	* in crash.
1020	*/
1021	drain_rod_charge (wand);
1022	cast_spell (head, wand, dir, wand->inv, NULL);
1023
1024	/* Success */
1025	return 1;
1026	}
1027	}
1028
1029	if (at_least_one)
1030	return 0;
1031
1032	LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANGE() without wand/horn/rod.\n", &head->name, head->count);
1033	CLEAR_FLAG (head, FLAG_READY_RANGE);
1034	return 0;
1035	}
1036
1037	int
1038	monster_use_bow (object *head, object *part, object *pl, int dir)
1039	{
1040	object *owner;
1041
1042	if (!(dir = path_to_player (part, pl, 0)))
1043	return 0;
1044
1045	if (QUERY_FLAG (head, FLAG_CONFUSED))
1046	dir = absdir (dir + rndm (3) + rndm (3) - 2);
1047
1048	if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
1049	{
1050	int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
1051
1052	if (dirdiff (dir, dir2) < 1)
1053	return 0; /* Might hit owner with arrow */
1054	}
1055
1056	/* in server/player.c */
1057	return fire_bow (head, part, NULL, dir, 0, part->x, part->y);
1058
1059	}
1060
1061	/* Checks if putting on 'item' will make 'who' do more	481	/* Checks if putting on 'item' will make 'who' do more
1062	* damage. This is a very simplistic check - also checking things	482	* damage. This is a very simplistic check - also checking things
1063	* like speed and ac are also relevant.	483	* like speed and ac are also relevant.
1064	*	484	*
1065	* return true if item is a better object.	485	* return true if item is a better object.
1066	*/	486	*/
1067	int	487	static int
1068	check_good_weapon (object *who, object *item)	488	check_good_weapon (object *who, object *item)
1069	{	489	{
1070	object *other_weap;	490	object *other_weap;
1071	int val = 0, i;	491	int val = 0, i;
1072		492
…		…
1095	return 1;	515	return 1;
1096	else	516	else
1097	return 0;	517	return 0;
1098	}	518	}
1099		519
1100	int	520	static int
1101	check_good_armour (object *who, object *item)	521	check_good_armour (object *who, object *item)
1102	{	522	{
1103	object *other_armour;	523	object *other_armour;
1104	int val = 0, i;	524	int val = 0, i;
1105		525
…		…
1133		553
1134	if (val > 0)	554	if (val > 0)
1135	return 1;	555	return 1;
1136	else	556	else
1137	return 0;	557	return 0;
1138	}
1139
1140	/*
1141	* monster_check_pickup(): checks for items that monster can pick up.
1142	*
1143	* Vick's (vick@bern.docs.uu.se) fix 921030 for the sweeper blob.
1144	* Each time the blob passes over some treasure, it will
1145	* grab it a.s.a.p.
1146	*
1147	* Eneq(@csd.uu.se): This can now be defined in the archetypes, added code
1148	* to handle this.
1149	*
1150	* This function was seen be continueing looping at one point (tmp->below
1151	* became a recursive loop. It may be better to call monster_check_apply
1152	* after we pick everything up, since that function may call others which
1153	* affect stacking on this space.
1154	*/
1155	void
1156	monster_check_pickup (object *monster)
1157	{
1158	object *tmp, *next;
1159
1160	for (tmp = monster->below; tmp != NULL; tmp = next)
1161	{
1162	next = tmp->below;
1163	if (monster_can_pick (monster, tmp))
1164	{
1165	tmp->remove ();
1166	tmp = insert_ob_in_ob (tmp, monster);
1167	(void) monster_check_apply (monster, tmp);
1168	}
1169	/* We could try to re-establish the cycling, of the space, but probably
1170	* not a big deal to just bail out.
1171	*/
1172	if (next && next->destroyed ())
1173	return;
1174	}
1175	}
1176
1177	/*
1178	* monster_can_pick(): If the monster is interested in picking up
1179	* the item, then return 0. Otherwise 0.
1180	* Instead of pick_up, flags for "greed", etc, should be used.
1181	* I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
1182	*/
1183	int
1184	monster_can_pick (object *monster, object *item)
1185	{
1186	int flag = 0;
1187	int i;
1188
1189	if (!can_pick (monster, item))
1190	return 0;
1191
1192	if (QUERY_FLAG (item, FLAG_UNPAID))
1193	return 0;
1194
1195	if (monster->pick_up & 64) /* All */
1196	flag = 1;
1197
1198	else
1199	switch (item->type)
1200	{
1201	case MONEY:
1202	case GEM:
1203	flag = monster->pick_up & 2;
1204	break;
1205
1206	case FOOD:
1207	flag = monster->pick_up & 4;
1208	break;
1209
1210	case WEAPON:
1211	flag = (monster->pick_up & 8) || QUERY_FLAG (monster, FLAG_USE_WEAPON);
1212	break;
1213
1214	case ARMOUR:
1215	case SHIELD:
1216	case HELMET:
1217	case BOOTS:
1218	case GLOVES:
1219	case GIRDLE:
1220	flag = (monster->pick_up & 16) || QUERY_FLAG (monster, FLAG_USE_ARMOUR);
1221	break;
1222
1223	case SKILL:
1224	flag = QUERY_FLAG (monster, FLAG_CAN_USE_SKILL);
1225	break;
1226
1227	case RING:
1228	flag = QUERY_FLAG (monster, FLAG_USE_RING);
1229	break;
1230
1231	case WAND:
1232	case HORN:
1233	case ROD:
1234	flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1235	break;
1236
1237	case SPELLBOOK:
1238	flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1239	break;
1240
1241	case SCROLL:
1242	flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1243	break;
1244
1245	case BOW:
1246	case ARROW:
1247	flag = QUERY_FLAG (monster, FLAG_USE_BOW);
1248	break;
1249	}
1250
1251	/* Simplistic check - if the monster has a location to equip it, he will
1252	* pick it up. Note that this doesn't handle cases where an item may
1253	* use several locations.
1254	*/
1255	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1256	{
1257	if (monster->slot[i].info && item->slot[i].info)
1258	{
1259	flag = 1;
1260	break;
1261	}
1262	}
1263
1264	if (((!(monster->pick_up & 32)) && flag) || ((monster->pick_up & 32) && (!flag)))
1265	return 1;
1266
1267	return 0;
1268	}
1269
1270	/*
1271	* monster_apply_below():
1272	* Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
1273	* eager to apply things, encounters something apply-able,
1274	* then make him apply it
1275	*/
1276	void
1277	monster_apply_below (object *monster)
1278	{
1279	object *tmp, *next;
1280
1281	for (tmp = monster->below; tmp != NULL; tmp = next)
1282	{
1283	next = tmp->below;
1284	switch (tmp->type)
1285	{
1286	case CF_HANDLE:
1287	case TRIGGER:
1288	if (monster->will_apply & 1)
1289	manual_apply (monster, tmp, 0);
1290	break;
1291
1292	case TREASURE:
1293	if (monster->will_apply & 2)
1294	manual_apply (monster, tmp, 0);
1295	break;
1296
1297	}
1298	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1299	break;
1300	}
1301	}	558	}
1302		559
1303	/*	560	/*
1304	* 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
1305	* inserted in a monster.	562	* inserted in a monster.
…		…
1416	* monsters have some advantages after all.	673	* monsters have some advantages after all.
1417	*/	674	*/
1418	manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);	675	manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);
1419	}	676	}
1420		677
1421	void	678	static int
1422	npc_call_help (object *op)	679	can_hit (object *ob1, object *ob2, rv_vector * rv)
1423	{	680	{
1424	unordered_mapwalk (op, -7, -7, 7, 7)	681	object *more;
1425	{	682	rv_vector rv1;
1426	mapspace &ms = m->at (nx, ny);
1427		683
1428	/* If nothing alive on this space, no need to search the space. */	684	if (QUERY_FLAG (ob1, FLAG_CONFUSED) && !(rndm (3)))
1429	if (!(ms.flags () & P_IS_ALIVE))	685	return 0;
1430	continue;
1431		686
1432	for (object *npc = ms.bot; npc; npc = npc->above)	687	if (abs (rv->distance_x) < 2 && abs (rv->distance_y) < 2)
1433	if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))	688	return 1;
1434	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)
1435	}	694	{
1436	}	695	get_rangevector (ob1, more, &rv1, 0);
		696	if (abs (rv1.distance_x) < 2 && abs (rv1.distance_y) < 2)
		697	return 1;
		698	}
1437		699
1438	int	700	return 0;
		701	}
		702
		703	static int
1439	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)
1440	{	705	{
1441	if (can_hit (part, enemy, rv))	706	if (can_hit (part, enemy, rv))
1442	return dir;	707	return dir;
1443		708
…		…
1447	return dir;	712	return dir;
1448		713
1449	return 0;	714	return 0;
1450	}	715	}
1451		716
1452	int	717	static int
1453	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)
1454	{	719	{
1455	if (can_hit (part, enemy, rv))	720	if (can_hit (part, enemy, rv))
1456	return dir;	721	return dir;
1457	else	722	else
1458	return absdir (dir + 4);	723	return absdir (dir + 4);
1459	}	724	}
1460		725
1461	int	726	static int
1462	hitrun_att (int dir, object *ob, object *enemy)	727	hitrun_att (int dir, object *ob, object *enemy)
1463	{	728	{
1464	if (ob->move_status++ < 25)	729	if (ob->move_status++ < 25)
1465	return dir;	730	return dir;
1466	else if (ob->move_status < 50)	731	else if (ob->move_status < 50)
…		…
1469	ob->move_status = 0;	734	ob->move_status = 0;
1470		735
1471	return absdir (dir + 4);	736	return absdir (dir + 4);
1472	}	737	}
1473		738
1474	int	739	static int
1475	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)
1476	{	741	{
1477	int inrange = can_hit (part, enemy, rv);	742	int inrange = can_hit (part, enemy, rv);
1478		743
1479	if (ob->move_status || inrange)	744	if (ob->move_status || inrange)
…		…
1488		753
1489	ob->move_status = 0;	754	ob->move_status = 0;
1490	return 0;	755	return 0;
1491	}	756	}
1492		757
1493	int	758	static int
1494	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)
1495	{	760	{
1496	/* The logic below here looked plain wrong before. Basically, what should	761	/* The logic below here looked plain wrong before. Basically, what should
1497	* 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,
1498	* the creature should run away (dir+4)	763	* the creature should run away (dir+4)
…		…
1504	return absdir (dir + 4);	769	return absdir (dir + 4);
1505		770
1506	return dist_att (dir, ob, enemy, part, rv);	771	return dist_att (dir, ob, enemy, part, rv);
1507	}	772	}
1508		773
1509	int	774	static int
1510	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)
1511	{	776	{
1512	if (rv->distance < 9)	777	if (rv->distance < 9)
1513	return absdir (dir + 4);	778	return absdir (dir + 4);
1514		779
1515	return 0;	780	return 0;
1516	}	781	}
1517		782
1518	void	783	static void
1519	circ1_move (object *ob)	784	circ1_move (object *ob)
1520	{	785	{
1521	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 };
1522		787
1523	if (++ob->move_status > 11)	788	if (++ob->move_status > 11)
…		…
1525		790
1526	if (!(move_object (ob, circle[ob->move_status])))	791	if (!(move_object (ob, circle[ob->move_status])))
1527	move_object (ob, rndm (8) + 1);	792	move_object (ob, rndm (8) + 1);
1528	}	793	}
1529		794
1530	void	795	static void
1531	circ2_move (object *ob)	796	circ2_move (object *ob)
1532	{	797	{
1533	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 };
1534		799
1535	if (++ob->move_status > 19)	800	if (++ob->move_status > 19)
…		…
1537		802
1538	if (!(move_object (ob, circle[ob->move_status])))	803	if (!(move_object (ob, circle[ob->move_status])))
1539	move_object (ob, rndm (8) + 1);	804	move_object (ob, rndm (8) + 1);
1540	}	805	}
1541		806
1542	void	807	static void
1543	pace_movev (object *ob)	808	pace_movev (object *ob)
1544	{	809	{
1545	if (ob->move_status++ > 6)	810	if (ob->move_status++ > 6)
1546	ob->move_status = 0;	811	ob->move_status = 0;
1547		812
…		…
1549	move_object (ob, 5);	814	move_object (ob, 5);
1550	else	815	else
1551	move_object (ob, 1);	816	move_object (ob, 1);
1552	}	817	}
1553		818
1554	void	819	static void
1555	pace_moveh (object *ob)	820	pace_moveh (object *ob)
1556	{	821	{
1557	if (ob->move_status++ > 6)	822	if (ob->move_status++ > 6)
1558	ob->move_status = 0;	823	ob->move_status = 0;
1559		824
…		…
1561	move_object (ob, 3);	826	move_object (ob, 3);
1562	else	827	else
1563	move_object (ob, 7);	828	move_object (ob, 7);
1564	}	829	}
1565		830
1566	void	831	static void
1567	pace2_movev (object *ob)	832	pace2_movev (object *ob)
1568	{	833	{
1569	if (ob->move_status++ > 16)	834	if (ob->move_status++ > 16)
1570	ob->move_status = 0;	835	ob->move_status = 0;
1571		836
…		…
1577	move_object (ob, 1);	842	move_object (ob, 1);
1578	else	843	else
1579	return;	844	return;
1580	}	845	}
1581		846
1582	void	847	static void
1583	pace2_moveh (object *ob)	848	pace2_moveh (object *ob)
1584	{	849	{
1585	if (ob->move_status++ > 16)	850	if (ob->move_status++ > 16)
1586	ob->move_status = 0;	851	ob->move_status = 0;
1587		852
…		…
1593	move_object (ob, 7);	858	move_object (ob, 7);
1594	else	859	else
1595	return;	860	return;
1596	}	861	}
1597		862
1598	void	863	static void
1599	rand_move (object *ob)	864	rand_move (object *ob)
1600	{	865	{
1601	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)))))
1602	for (int i = 0; i < 5; i++)	867	for (int i = 0; i < 5; i++)
1603	if (move_object (ob, ob->move_status = rndm (8) + 1))	868	if (move_object (ob, ob->move_status = rndm (8) + 1))
1604	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	}
1605	}	1198	}
1606		1199
1607	void	1200	void
1608	check_earthwalls (object *op, maptile *m, int x, int y)	1201	check_earthwalls (object *op, maptile *m, int x, int y)
1609	{	1202	{
…		…
1660	#ifdef DEBUG_THROW	1253	#ifdef DEBUG_THROW
1661	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);
1662	#endif	1255	#endif
1663		1256
1664	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;
1665	}	1672	}
1666		1673
1667	/* 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
1668	* 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
1669	* 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.
…		…
1833		1840
1834	if (op->glow_radius > 0)	1841	if (op->glow_radius > 0)
1835	return 1;	1842	return 1;
1836		1843
1837	if (op->map)	1844	if (op->map)
1838	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)
1839	{	1846	{
1840	/* 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
1841	* 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.
1842	*/	1849	*/
1843	int light = m->at (nx, ny).light;	1850	int light = m->at (nx, ny).light;
…		…
1917	return 0;	1924	return 0;
1918		1925
1919	return 1;	1926	return 1;
1920	}	1927	}
1921		1928
		1929	//-GPL

Diff Legend

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