[ViewVC] Diff of: cvs/deliantra/server/server/spell

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.66 by root, Mon Sep 29 10:31:32 2008 UTC vs.
Revision 1.113 by root, Wed Nov 16 22:14:06 2016 UTC

…		…
1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002-2003 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 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	*/
23		24
24	/* This file contains all the spell attack code. Grouping this code	25	/* This file contains all the spell attack code. Grouping this code
25	* together should hopefully make it easier to find the relevent bits	26	* together should hopefully make it easier to find the relevent bits
36	/* this function checks to see if a spell pushes objects as well	37	/* this function checks to see if a spell pushes objects as well
37	* as flies over and damages them (only used for cones for now)	38	* as flies over and damages them (only used for cones for now)
38	* but moved here so it could be applied to bolts too	39	* but moved here so it could be applied to bolts too
39	* op is the spell object.	40	* op is the spell object.
40	*/	41	*/
41	void	42	static void
42	check_spell_knockback (object *op)	43	check_spell_knockback (object *op)
43	{	44	{
44	int weight_move;	45	int weight_move;
45	int frictionmod = 2; /poor man's physics - multipy targets weight by this amount /	46	int frictionmod = 2; /poor man's physics - multipy targets weight by this amount /
46		47
…		…
58	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)	59	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
59	{	60	{
60	int num_sections = 1;	61	int num_sections = 1;
61		62
62	/* don't move DM */	63	/* don't move DM */
63	if (QUERY_FLAG (tmp, FLAG_WIZ))	64	if (tmp->flag [FLAG_WIZ])
64	return;	65	return;
65		66
66	/* don't move parts of objects */	67	/* don't move parts of objects */
67	if (tmp->head)	68	if (tmp->head)
68	continue;	69	continue;
69		70
70	/* don't move floors or immobile objects */	71	/* don't move floors or immobile objects */
71	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) \|\| (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))	72	if (tmp->flag [FLAG_IS_FLOOR] \|\| (!tmp->flag [FLAG_ALIVE] && tmp->flag [FLAG_NO_PICK]))
72	continue;	73	continue;
73		74
74	/* count the object's sections */	75	/* count the object's sections */
75	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)	76	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
76	num_sections++;	77	num_sections++;
…		…
92	* also be safe for objects.	93	* also be safe for objects.
93	* This does return if successful or not, but	94	* This does return if successful or not, but
94	* I don't see us doing anything useful with that information	95	* I don't see us doing anything useful with that information
95	* right now.	96	* right now.
96	*/	97	*/
97	move_object (tmp, absdir (op->stats.sp));	98	tmp->move (absdir (op->stats.sp));
98	}	99	}
99		100
100	}	101	}
101	}	102	}
102		103
…		…
107	***************************************************************************/	108	***************************************************************************/
108		109
109	/* Causes op to fork. op is the original bolt, tmp	110	/* Causes op to fork. op is the original bolt, tmp
110	* is the first piece of the fork.	111	* is the first piece of the fork.
111	*/	112	*/
112	void	113	static void
113	forklightning (object op, object tmp)	114	forklightning (object op, object tmp)
114	{	115	{
115	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */	116	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
116	int t_dir; /* stores temporary dir calculation */	117	int t_dir; /* stores temporary dir calculation */
117	maptile *m;	118	maptile *m;
…		…
193	* on the space. So only call reflwall if we think the data it returns	194	* on the space. So only call reflwall if we think the data it returns
194	* will be useful.	195	* will be useful.
195	*/	196	*/
196	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) \|\| ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))	197	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) \|\| ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))
197	{	198	{
198	if (!QUERY_FLAG (op, FLAG_REFLECTING))	199	if (!op->flag [FLAG_REFLECTING])
199	return;	200	return;
200		201
201	/* Since walls don't run diagonal, if the bolt is in	202	/* Since walls don't run diagonal, if the bolt is in
202	* one of 4 main directions, it just reflects back in the	203	* one of 4 main directions, it just reflects back in the
203	* opposite direction. However, if the bolt is travelling	204	* opposite direction. However, if the bolt is travelling
…		…
276	int mflags;	277	int mflags;
277		278
278	if (!spob->other_arch)	279	if (!spob->other_arch)
279	return 0;	280	return 0;
280		281
281	tmp = arch_to_object (spob->other_arch);	282	tmp = spob->other_arch->instance ();
282	if (tmp == NULL)	283	if (tmp == NULL)
283	return 0;	284	return 0;
284		285
285	/* peterm: level dependency for bolts */	286	/* peterm: level dependency for bolts */
286	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);	287	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
…		…
293	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);	294	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
294	tmp->stats.Dex = spob->stats.Dex;	295	tmp->stats.Dex = spob->stats.Dex;
295	tmp->stats.Con = spob->stats.Con;	296	tmp->stats.Con = spob->stats.Con;
296		297
297	tmp->direction = dir;	298	tmp->direction = dir;
298	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	299	if (tmp->flag [FLAG_IS_TURNABLE])
299	SET_ANIMATION (tmp, dir);	300	SET_ANIMATION (tmp, dir);
300		301
301	tmp->set_owner (op);	302	tmp->set_owner (op);
302	set_spell_skill (op, caster, spob, tmp);	303	set_spell_skill (op, caster, spob, tmp);
303		304
…		…
315		316
316	tmp->map = newmap;	317	tmp->map = newmap;
317		318
318	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))	319	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
319	{	320	{
320	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	321	if (!tmp->flag [FLAG_REFLECTING])
321	{	322	{
322	tmp->drop_and_destroy ();	323	tmp->drop_and_destroy ();
323	return 0;	324	return 0;
324	}	325	}
325		326
…		…
351	maptile *m = op->map;	352	maptile *m = op->map;
352	int i;	353	int i;
353		354
354	if (--op->duration < 0)	355	if (--op->duration < 0)
355	{	356	{
356	op->destroy (true);	357	op->destroy ();
357	return;	358	return;
358	}	359	}
359		360
360	hit_map (op, 0, op->attacktype, 0);	361	hit_map (op, 0, op->attacktype, 0);
361		362
…		…
388		389
389	/* Causes an object to explode, eg, a firebullet,	390	/* Causes an object to explode, eg, a firebullet,
390	* poison cloud ball, etc. op is the object to	391	* poison cloud ball, etc. op is the object to
391	* explode.	392	* explode.
392	*/	393	*/
393	void	394	static void
394	explode_bullet (object *op)	395	explode_bullet (object *op)
395	{	396	{
396	object tmp, owner;	397	object tmp, owner;
397		398
398	if (!op->other_arch)	399	if (!op->other_arch)
399	{	400	{
400	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	401	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
401	op->destroy (true);	402	op->destroy ();
402	return;	403	return;
403	}	404	}
404		405
405	if (op->env)	406	if (op->env)
406	{	407	{
407	object *env = op->outer_env ();	408	object *env = op->outer_env ();
408		409
409	if (!env->map \|\| out_of_map (env->map, env->x, env->y))	410	if (!env->map \|\| out_of_map (env->map, env->x, env->y))
410	{	411	{
411	LOG (llevError, "BUG: explode_bullet(): env out of map\n");	412	LOG (llevError, "BUG: explode_bullet(): env out of map\n");
412	op->destroy (true);	413	op->destroy ();
413	return;	414	return;
414	}	415	}
415		416
416	op->insert_at (env, op, INS_NO_MERGE \| INS_NO_WALK_ON);	417	op->insert_at (env, op, INS_NO_MERGE \| INS_NO_WALK_ON);
417	}	418	}
418	else if (out_of_map (op->map, op->x, op->y))	419	else if (out_of_map (op->map, op->x, op->y))
419	{	420	{
420	LOG (llevError, "BUG: explode_bullet(): op out of map\n");	421	LOG (llevError, "BUG: explode_bullet(): op out of map\n");
421	op->destroy (true);	422	op->destroy ();
422	return;	423	return;
423	}	424	}
424		425
425	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps	426	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps
426	// NOTE: If this breaks something important: remove this. I can't think of anything	427	// NOTE: If this breaks something important: remove this. I can't think of anything
427	// bad at the moment that might happen from this.	428	// bad at the moment that might happen from this.
428	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	429	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
429	{	430	{
430	op->destroy (true);	431	op->destroy ();
431	return;	432	return;
432	}	433	}
433		434
434	if (op->attacktype)	435	if (op->attacktype)
435	{	436	{
…		…
438	if (op->destroyed ())	439	if (op->destroyed ())
439	return;	440	return;
440	}	441	}
441		442
442	/* other_arch contains what this explodes into */	443	/* other_arch contains what this explodes into */
443	tmp = arch_to_object (op->other_arch);	444	tmp = op->other_arch->instance ();
444		445
445	tmp->set_owner (op);	446	tmp->set_owner (op);
446	tmp->skill = op->skill;	447	tmp->skill = op->skill;
447		448
448	owner = op->owner;	449	owner = op->owner;
…		…
450	if ((tmp->attacktype & AT_HOLYWORD	451	if ((tmp->attacktype & AT_HOLYWORD
451	\|\| tmp->attacktype & AT_GODPOWER)	452	\|\| tmp->attacktype & AT_GODPOWER)
452	&& owner	453	&& owner
453	&& !tailor_god_spell (tmp, owner))	454	&& !tailor_god_spell (tmp, owner))
454	{	455	{
455	op->destroy (true);	456	op->destroy ();
456	return;	457	return;
457	}	458	}
458		459
459	/* special for bombs - it actually has sane values for these */	460	/* special for bombs - it actually has sane values for these */
460	if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)	461	if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)
…		…
488		489
489	tmp->insert_at (op, op);	490	tmp->insert_at (op, op);
490	tmp->play_sound (tmp->sound);	491	tmp->play_sound (tmp->sound);
491		492
492	/* remove the firebullet */	493	/* remove the firebullet */
493	op->destroy (true);	494	op->destroy ();
494	}	495	}
495		496
496	/* checks to see what op should do, given the space it is on	497	/* checks to see what op should do, given the space it is on
497	* (eg, explode, damage player, etc)	498	* (eg, explode, damage player, etc)
498	*/	499	*/
…		…
520	if (!(mflags & P_IS_ALIVE))	521	if (!(mflags & P_IS_ALIVE))
521	return;	522	return;
522		523
523	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	524	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
524	{	525	{
525	if (QUERY_FLAG (tmp, FLAG_ALIVE))	526	if (tmp->flag [FLAG_ALIVE])
526	{	527	{
527	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	528	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
528		529
529	// TODO: can't understand the following if's	530	// TODO: can't understand the following if's
530	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)	531	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)
531	{	532	{
532	if (!QUERY_FLAG (op, FLAG_REMOVED))	533	if (!op->flag [FLAG_REMOVED])
533	{	534	{
534	op->destroy (true);	535	op->destroy ();
535	return;	536	return;
536	}	537	}
537	}	538	}
538	}	539	}
539	}	540	}
…		…
545	* fired arches (eg, bolts).	546	* fired arches (eg, bolts).
546	*/	547	*/
547	void	548	void
548	move_bullet (object *op)	549	move_bullet (object *op)
549	{	550	{
550	sint16 new_x, new_y;
551	int mflags;
552	maptile *m;
553
554	#if 0	551	#if 0
555	/* We need a better general purpose way to do this */	552	/* We need a better general purpose way to do this */
556		553
557	/* peterm: added to make comet leave a trail of burnouts	554	/* peterm: added to make comet leave a trail of burnouts
558	it's an unadulterated hack, but the effect is cool. */	555	it's an unadulterated hack, but the effect is cool. */
…		…
568	if (--op->range <= 0)	565	if (--op->range <= 0)
569	{	566	{
570	if (op->other_arch)	567	if (op->other_arch)
571	explode_bullet (op);	568	explode_bullet (op);
572	else	569	else
573	op->destroy (true);	570	op->destroy ();
574		571
575	return;	572	return;
576	}
577
578	new_x = op->x + DIRX (op);
579	new_y = op->y + DIRY (op);
580	m = op->map;
581	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
582
583	if (mflags & P_OUT_OF_MAP)
584	{	573	}
		574
		575	mapxy pos (op);
		576	pos.move (op->direction);
		577
		578	if (!pos.normalise ())
		579	{
585	op->destroy (true);	580	op->destroy ();
586	return;	581	return;
587	}	582	}
588		583
589	if (!op->direction \|\| OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))	584	mapspace &ms = pos.ms ();
		585
		586	ms.update ();
		587
		588	if (!op->direction \|\| OB_TYPE_MOVE_BLOCK (op, ms.move_block))
590	{	589	{
591	if (op->other_arch)	590	if (op->other_arch)
592	explode_bullet (op);	591	explode_bullet (op);
593	else	592	else
594	op->destroy (true);	593	op->destroy ();
595		594
596	return;	595	return;
597	}	596	}
598		597
599	if (!(op = m->insert (op, new_x, new_y, op)))	598	if (!(op = pos.insert (op, op)))
600	return;	599	return;
601		600
602	if (reflwall (op->map, op->x, op->y, op))	601	if (reflwall (op->map, op->x, op->y, op))
603	{	602	{
604	op->direction = absdir (op->direction + 4);	603	op->direction = absdir (op->direction + 4);
…		…
641	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);	640	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
642	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);	641	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
643	tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);	642	tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);
644		643
645	tmp->direction = dir;	644	tmp->direction = dir;
646	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	645	if (tmp->flag [FLAG_IS_TURNABLE])
647	SET_ANIMATION (tmp, dir);	646	SET_ANIMATION (tmp, dir);
648		647
649	tmp->set_owner (op);	648	tmp->set_owner (op);
650	set_spell_skill (op, caster, spob, tmp);	649	set_spell_skill (op, caster, spob, tmp);
651		650
…		…
655		654
656	maptile *newmap;	655	maptile *newmap;
657	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);	656	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
658	if (mflags & P_OUT_OF_MAP)	657	if (mflags & P_OUT_OF_MAP)
659	{	658	{
660	tmp->destroy (true);	659	tmp->destroy ();
661	return 0;	660	return 0;
662	}	661	}
663		662
664	tmp->map = newmap;	663	tmp->map = newmap;
665		664
		665	// in case the bullet has direction 0 we explode it in place.
		666	// direction 0 is possible for instance when a poison cloud trap springs.
		667	if (tmp->direction == 0)
		668	{
		669	if (tmp->other_arch
		670	&& (tmp = tmp->insert_at (tmp, op))) // insert before explode cleanly
		671	explode_bullet (tmp); // explode object will/should remove tmp
		672	else
		673	tmp->destroy ();
		674
		675	return 0;
		676	}
		677
666	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))	678	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
667	{	679	{
668	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	680	if (!tmp->flag [FLAG_REFLECTING])
669	{	681	{
670	tmp->destroy (true);	682	tmp->destroy ();
671	return 0;	683	return 0;
672	}	684	}
673		685
674	tmp->x = op->x;	686	tmp->x = op->x;
675	tmp->y = op->y;	687	tmp->y = op->y;
…		…
688	* CONE RELATED FUNCTIONS	700	* CONE RELATED FUNCTIONS
689	*	701	*
690	*****************************************************************************/	702	*****************************************************************************/
691		703
692	/* drops an object based on what is in the cone's "other_arch" */	704	/* drops an object based on what is in the cone's "other_arch" */
693	void	705	static void
694	cone_drop (object *op)	706	cone_drop (object *op)
695	{	707	{
696	object *new_ob = arch_to_object (op->other_arch);	708	object *new_ob = op->other_arch->instance ();
697		709
698	new_ob->level = op->level;	710	new_ob->level = op->level;
699	new_ob->set_owner (op->owner);	711	new_ob->set_owner (op->owner);
700		712
701	/* preserve skill ownership */	713	/* preserve skill ownership */
…		…
717	op->set_speed (0);	729	op->set_speed (0);
718	return;	730	return;
719	}	731	}
720		732
721	/* lava saves it's life, but not yours :) */	733	/* lava saves it's life, but not yours :) */
722	if (QUERY_FLAG (op, FLAG_LIFESAVE))	734	if (op->flag [FLAG_LIFESAVE])
723	{	735	{
724	hit_map (op, 0, op->attacktype, 0);	736	hit_map (op, 0, op->attacktype, 0);
725	return;	737	return;
726	}	738	}
727		739
…		…
730	* when their cone dies when they die.	742	* when their cone dies when they die.
731	*/	743	*/
732	/* If no owner left, the spell dies out. */	744	/* If no owner left, the spell dies out. */
733	if (op->owner == NULL)	745	if (op->owner == NULL)
734	{	746	{
735	op->destroy (true);	747	op->destroy ();
736	return;	748	return;
737	}	749	}
738	#endif	750	#endif
739		751
740	hit_map (op, 0, op->attacktype, 0);	752	hit_map (op, 0, op->attacktype, 0);
		753
		754	if (!op->is_on_map ())
		755	return;
741		756
742	/* Check to see if we should push anything.	757	/* Check to see if we should push anything.
743	* Spell objects with weight push whatever they encounter to some	758	* Spell objects with weight push whatever they encounter to some
744	* degree.	759	* degree.
745	*/	760	*/
746	if (op->weight)	761	if (op->weight)
		762	{
747	check_spell_knockback (op);	763	check_spell_knockback (op);
748		764
749	if (op->destroyed ())	765	if (!op->is_on_map ())
750	return;	766	return;
		767	}
751		768
752	if (op->duration-- < 0)	769	if (op->duration-- < 0)
753	{	770	{
754	op->destroy (true);	771	op->destroy ();
755	return;	772	return;
756	}	773	}
757	/* Object has hit maximum range, so don't have it move	774	/* Object has hit maximum range, so don't have it move
758	* any further. When the duration above expires,	775	* any further. When the duration above expires,
759	* then the object will get removed.	776	* then the object will get removed.
…		…
803	MoveType movetype;	820	MoveType movetype;
804		821
805	if (!spell->other_arch)	822	if (!spell->other_arch)
806	return 0;	823	return 0;
807		824
808	if (op->type == PLAYER && QUERY_FLAG (op, FLAG_UNDEAD) && op->attacktype & AT_TURN_UNDEAD)	825	if (op->type == PLAYER && op->flag [FLAG_UNDEAD] && op->attacktype & AT_TURN_UNDEAD)
809	{	826	{
810	new_draw_info (NDI_UNIQUE, 0, op, "Your undead nature prevents you from turning undead!");	827	op->failmsg ("Your undead nature prevents you from turning undead!");
811	return 0;	828	return 0;
812	}	829	}
813		830
814	if (!dir)	831	if (!dir)
815	{	832	{
…		…
823	*/	840	*/
824	movetype = spell->other_arch->move_type;	841	movetype = spell->other_arch->move_type;
825		842
826	for (i = range_min; i <= range_max; i++)	843	for (i = range_min; i <= range_max; i++)
827	{	844	{
828	sint16 x, y, d;	845	sint16 x, y;
829		846
830	/* We can't use absdir here, because it never returns	847	/* We can't use absdir here, because it never returns
831	* 0. If this is a rune, we want to hit the person on top	848	* 0. If this is a rune, we want to hit the person on top
832	* of the trap (d==0). If it is not a rune, then we don't want	849	* of the trap (d==0). If it is not a rune, then we don't want
833	* to hit that person.	850	* to hit that person.
834	*/	851	*/
835	d = dir + i;	852	int d = dir ? absdir (dir + i) : i;
836	while (d < 0)
837	d += 8;
838	while (d > 8)
839	d -= 8;
840		853
841	/* If it's not a rune, we don't want to blast the caster.	854	/* If it's not a rune, we don't want to blast the caster.
842	* In that case, we have to see - if dir is specified,	855	* In that case, we have to see - if dir is specified,
843	* turn this into direction 8. If dir is not specified (all	856	* turn this into direction 8. If dir is not specified (all
844	* direction) skip - otherwise, one line would do more damage	857	* direction) skip - otherwise, one line would do more damage
…		…
861		874
862	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	875	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
863	continue;	876	continue;
864		877
865	success = 1;	878	success = 1;
866	tmp = arch_to_object (spell->other_arch);	879	tmp = spell->other_arch->instance ();
867	tmp->set_owner (op);	880	tmp->set_owner (op);
868	set_spell_skill (op, caster, spell, tmp);	881	set_spell_skill (op, caster, spell, tmp);
869	tmp->level = casting_level (caster, spell);	882	tmp->level = casting_level (caster, spell);
870	tmp->attacktype = spell->attacktype;	883	tmp->attacktype = spell->attacktype;
871		884
…		…
946		959
947	object *env = op->outer_env ();	960	object *env = op->outer_env ();
948		961
949	if (op->env)	962	if (op->env)
950	{	963	{
951	if (env->map == NULL)	964	if (!env->map)
952	return;	965	return;
953		966
954	if (!(op = op->insert_at (env, op)))	967	if (!(op = op->insert_at (env, op)))
955	return;	968	return;
956	}	969	}
957		970
958	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding	971	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
959	// on a safe map. I don't like this special casing, but it seems to be neccessary	972	// on a safe map. I don't like this special casing, but it seems to be neccessary
960	// as bombs can be carried.	973	// as bombs can be carried.
961	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	974	if (op->ms ().flags () & P_SAFE)
962	{	975	{
963	op->destroy (true);	976	op->destroy ();
964	return;	977	return;
965	}	978	}
966		979
967	/* This copies a lot of the code from the fire bullet,	980	/* This copies a lot of the code from the fire bullet,
968	* but using the cast_bullet isn't really feasible,	981	* but using the cast_bullet isn't really feasible,
…		…
973	for (int i = 1; i < 9; i++)	986	for (int i = 1; i < 9; i++)
974	{	987	{
975	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))	988	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
976	continue;	989	continue;
977		990
978	object *tmp = arch_to_object (at);	991	object *tmp = at->instance ();
979	tmp->direction = i;	992	tmp->direction = i;
980	tmp->range = op->range;	993	tmp->range = op->range;
981	tmp->stats.dam = op->stats.dam;	994	tmp->stats.dam = op->stats.dam;
982	tmp->duration = op->duration;	995	tmp->duration = op->duration;
983	tmp->attacktype = op->attacktype;	996	tmp->attacktype = op->attacktype;
984	tmp->set_owner (op);	997	tmp->set_owner (op);
985	if (op->skill && op->skill != tmp->skill)	998	if (op->skill && op->skill != tmp->skill)
986	tmp->skill = op->skill;	999	tmp->skill = op->skill;
987		1000
988	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	1001	if (tmp->flag [FLAG_IS_TURNABLE])
989	SET_ANIMATION (tmp, i);	1002	SET_ANIMATION (tmp, i);
990		1003
991	op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);	1004	op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);
992	move_bullet (tmp);	1005	move_bullet (tmp);
993	}	1006	}
…		…
1003	int mflags;	1016	int mflags;
1004	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];	1017	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1005	maptile *m;	1018	maptile *m;
1006		1019
1007	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);	1020	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
		1021
		1022	// when creating a bomb below ourself it should always work, even
		1023	// when movement is blocked (somehow we got here, somehow we are here,
		1024	// so we should also be able to make a bomb here). (originally added
		1025	// to fix create bomb traps in doors, which cast with dir=0).
		1026	if (dir)
		1027	{
1008	if ((mflags & P_OUT_OF_MAP) \|\| (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))	1028	if ((mflags & P_OUT_OF_MAP) \|\| (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1009	{	1029	{
1010	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1030	op->failmsg ("There is something in the way.");
1011	return 0;	1031	return 0;
		1032	}
1012	}	1033	}
1013		1034
1014	tmp = arch_to_object (spell->other_arch);	1035	tmp = spell->other_arch->instance ();
1015		1036
1016	/* level dependencies for bomb */	1037	/* level dependencies for bomb */
1017	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1038	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1018	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1039	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1019	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1040	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
1039	* dir is the direction to look in.	1060	* dir is the direction to look in.
1040	* range is how far out to look.	1061	* range is how far out to look.
1041	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.	1062	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.
1042	* this info is used for blocked magic/unholy spaces.	1063	* this info is used for blocked magic/unholy spaces.
1043	*/	1064	*/
1044	object *	1065	static object *
1045	get_pointed_target (object *op, int dir, int range, int type)	1066	get_pointed_target (object *op, int dir, int range, int type)
1046	{	1067	{
1047	object *target;	1068	object *target;
1048	sint16 x, y;	1069	sint16 x, y;
1049	int dist, mflags;	1070	int dist, mflags;
…		…
1068	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1089	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1069	return NULL;	1090	return NULL;
1070		1091
1071	if (mflags & P_IS_ALIVE)	1092	if (mflags & P_IS_ALIVE)
1072	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)	1093	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1073	if (QUERY_FLAG (target, FLAG_MONSTER))	1094	if (target->flag [FLAG_MONSTER])
1074	return target;	1095	return target;
1075	}	1096	}
1076		1097
1077	return NULL;	1098	return NULL;
1078	}	1099	}
1079		1100
1080	/* cast_smite_arch() - the priest points to a creature and causes	1101	/* cast_smite_spell() - the priest points to a creature and causes
1081	* a 'godly curse' to decend.	1102	* a 'godly curse' to decend.
1082	* usual params -	1103	* usual params -
1083	* op = player	1104	* op = player
1084	* caster = object casting the spell.	1105	* caster = object casting the spell.
1085	* dir = direction being cast	1106	* dir = direction being cast
…		…
1088	int	1109	int
1089	cast_smite_spell (object op, object caster, int dir, object *spell)	1110	cast_smite_spell (object op, object caster, int dir, object *spell)
1090	{	1111	{
1091	object effect, target;	1112	object effect, target;
1092	object *god = find_god (determine_god (op));	1113	object *god = find_god (determine_god (op));
1093	int range;
1094		1114
1095	range = spell->range + SP_level_range_adjust (caster, spell);
1096	target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);	1115	target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);
1097		1116
1098	/* Bunch of conditions for casting this spell. Note that only	1117	/* Bunch of conditions for casting this spell. Note that only
1099	* require a god if this is a cleric spell (requires grace).	1118	* require a god if this is a cleric spell (requires grace).
1100	* This makes this spell much more general purpose - it can be used	1119	* This makes this spell much more general purpose - it can be used
…		…
1102	* interesting spell.	1121	* interesting spell.
1103	* if it is a cleric spell, you need a god, and the creature	1122	* if it is a cleric spell, you need a god, and the creature
1104	* can't be friendly to your god.	1123	* can't be friendly to your god.
1105	*/	1124	*/
1106		1125
1107	if (!target \|\| QUERY_FLAG (target, FLAG_REFL_SPELL)	1126	if (!target
		1127	\|\| target->flag [FLAG_REFL_SPELL]
1108	\|\| (!god && spell->stats.grace)	1128	\|\| (!god && spell->stats.grace)
1109	\|\| (target->title && god && !strcmp (target->title, god->name)) \|\| (target->race && god && strstr (target->race, god->race)))	1129	\|\| (god && target->title == god->name)
		1130	\|\| (god && target->race.contains (god->race)))
1110	{	1131	{
1111	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1132	op->failmsg ("Your request is unheeded.");
1112	return 0;	1133	return 0;
1113	}	1134	}
1114		1135
1115	if (spell->other_arch)	1136	if (spell->other_arch)
1116	effect = arch_to_object (spell->other_arch);	1137	effect = spell->other_arch->instance ();
1117	else	1138	else
1118	return 0;	1139	return 0;
1119		1140
1120	/* tailor the effect by priest level and worshipped God */	1141	/* tailor the effect by priest level and worshipped God */
1121	effect->level = casting_level (caster, spell);	1142	effect->level = casting_level (caster, spell);
1122	effect->attacktype = spell->attacktype;	1143	effect->attacktype = spell->attacktype;
1123	if (effect->attacktype & (AT_HOLYWORD \| AT_GODPOWER))	1144	if (effect->attacktype & (AT_HOLYWORD \| AT_GODPOWER))
1124	{	1145	{
1125	if (tailor_god_spell (effect, op))	1146	if (tailor_god_spell (effect, op))
1126	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));	1147	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", (const char *)determine_god (op));
1127	else	1148	else
1128	{	1149	{
1129	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1150	op->failmsg ("Your request is ignored.");
1130	return 0;	1151	return 0;
1131	}	1152	}
1132	}	1153	}
1133		1154
1134	/* size of the area of destruction */	1155	/* size of the area of destruction */
…		…
1138	if (effect->attacktype & AT_DEATH)	1159	if (effect->attacktype & AT_DEATH)
1139	{	1160	{
1140	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1161	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1141		1162
1142	/* casting death spells at undead isn't a good thing */	1163	/* casting death spells at undead isn't a good thing */
1143	if (QUERY_FLAG (target, FLAG_UNDEAD))	1164	if (target->flag [FLAG_UNDEAD])
1144	{	1165	{
1145	if (random_roll (0, 2, op, PREFER_LOW))	1166	if (random_roll (0, 2, op, PREFER_LOW))
1146	{	1167	{
1147	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1168	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1148	effect->x = op->x;	1169	effect->x = op->x;
…		…
1150	}	1171	}
1151	else	1172	else
1152	{	1173	{
1153	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));	1174	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1154	target->stats.hp = target->stats.maxhp * 2;	1175	target->stats.hp = target->stats.maxhp * 2;
1155	effect->destroy (true);	1176	effect->destroy ();
1156	return 0;	1177	return 0;
1157	}	1178	}
1158	}	1179	}
1159	}	1180	}
1160	else	1181	else
…		…
1192	mapxy pos (op);	1213	mapxy pos (op);
1193	pos.move (op->direction);	1214	pos.move (op->direction);
1194		1215
1195	if (!pos.normalise ())	1216	if (!pos.normalise ())
1196	{	1217	{
1197	op->destroy (true);	1218	op->destroy ();
1198	return;	1219	return;
1199	}	1220	}
1200		1221
1201	mapspace &ms = pos.ms ();	1222	mapspace &ms = pos.ms ();
1202		1223
…		…
1204	{	1225	{
1205	hit_map (op, op->direction, AT_MAGIC, 1);	1226	hit_map (op, op->direction, AT_MAGIC, 1);
1206	/* Basically, missile only hits one thing then goes away.	1227	/* Basically, missile only hits one thing then goes away.
1207	* we need to remove it if someone hasn't already done so.	1228	* we need to remove it if someone hasn't already done so.
1208	*/	1229	*/
1209	op->destroy (true);	1230	op->destroy ();
1210	return;	1231	return;
1211	}	1232	}
1212		1233
1213	if (!op->direction)	1234	if (!op->direction)
1214	{	1235	{
1215	op->destroy (true);	1236	op->destroy ();
1216	return;	1237	return;
1217	}	1238	}
1218		1239
1219	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);	1240	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1220	if (i > 0 && i != op->direction)	1241	if (i > 0 && i != op->direction)
…		…
1234	* we do this by creating a force and inserting it in the	1255	* we do this by creating a force and inserting it in the
1235	* object. if time is 0, the object glows permanently. To truely	1256	* object. if time is 0, the object glows permanently. To truely
1236	* make this work for non-living objects, we would have to	1257	* make this work for non-living objects, we would have to
1237	* give them the capability to have an inventory. b.t.	1258	* give them the capability to have an inventory. b.t.
1238	*/	1259	*/
1239	int	1260	static int
1240	make_object_glow (object *op, int radius, int time)	1261	make_object_glow (object *op, int radius, int time)
1241	{	1262	{
1242	/* some things are unaffected... */	1263	/* some things are unaffected... */
1243	if (op->path_denied & PATH_LIGHT)	1264	if (op->path_denied & PATH_LIGHT)
1244	return 0;	1265	return 0;
1245		1266
1246	object *tmp = get_archetype (FORCE_NAME);	1267	object *tmp = archetype::get (FORCE_NAME);
1247	tmp->speed = 0.01;	1268	tmp->set_speed (0.01);
1248	tmp->stats.food = time;	1269	tmp->stats.food = time;
1249	SET_FLAG (tmp, FLAG_IS_USED_UP);	1270	tmp->set_flag (FLAG_IS_USED_UP);
1250	tmp->glow_radius = radius;	1271	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1251	if (tmp->glow_radius > MAX_LIGHT_RADII)
1252	tmp->glow_radius = MAX_LIGHT_RADII;
1253
1254	tmp = insert_ob_in_ob (tmp, op);	1272	tmp = insert_ob_in_ob (tmp, op);
1255		1273
1256	if (tmp->glow_radius > op->glow_radius)	1274	if (tmp->glow_radius > op->glow_radius)
1257	op->glow_radius = tmp->glow_radius;	1275	op->set_glow_radius (tmp->glow_radius);
1258		1276
1259	return 1;	1277	return 1;
1260	}	1278	}
1261		1279
1262	int	1280	int
1263	cast_destruction (object op, object caster, object *spell_ob)	1281	cast_destruction (object op, object caster, object *spell_ob)
1264	{	1282	{
1265	int i, j, range, mflags, friendly = 0, dam, dur;
1266	sint16 sx, sy;
1267	maptile *m;
1268	object *tmp;
1269	const char *skill;
1270
1271	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1283	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1272	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	1284	int dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1273	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1285	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1274	if (QUERY_FLAG (op, FLAG_FRIENDLY) \|\| op->type == PLAYER)
1275	friendly = 1;
1276		1286
1277	/* destruction doesn't use another spell object, so we need	1287	bool friendly = op->flag [FLAG_FRIENDLY] \|\| op->is_player ();
1278	* update op's skill pointer so that exp is properly awarded.
1279	* We do some shortcuts here - since this is just temporary
1280	* and we'll reset the values back, we don't need to go through
1281	* the full share string/free_string route.
1282	*/
1283	skill = op->skill;
1284	if (caster == op)
1285	op->skill = spell_ob->skill;
1286	else if (caster->skill)
1287	op->skill = caster->skill;
1288	else
1289	op->skill = NULL;
1290		1288
1291	op->change_skill (find_skill_by_name (op, op->skill));	1289	dynbuf buf;
1292		1290	unordered_mapwalk (buf, op, -range, -range, range, range)
1293	for (i = -range; i <= range; i++)
1294	{	1291	{
1295	for (j = -range; j <= range; j++)	1292	mapspace &ms = m->at (nx, ny);
1296	{
1297	m = op->map;
1298	sx = op->x + i;
1299	sy = op->y + j;
1300		1293
1301	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1302	if (mflags & P_OUT_OF_MAP)
1303	continue;
1304
1305	if (mflags & P_IS_ALIVE)	1294	if (ms.flags () & P_IS_ALIVE)
		1295	for (object next, tmp = ms.bot; tmp; tmp = next)
1306	{	1296	{
1307	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1297	next = tmp->above;
1308	if (QUERY_FLAG (tmp, FLAG_ALIVE) \|\| tmp->type == PLAYER)
1309	break;
1310		1298
1311	if (tmp)	1299	if (tmp->flag [FLAG_ALIVE] \|\| tmp->is_player ())
1312	{	1300	{
1313	if (tmp->head)
1314	tmp = tmp->head;	1301	tmp = tmp->head_ ();
1315		1302
1316	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) \|\|	1303	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1317	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) \|\| tmp->type == PLAYER)))	1304	\|\| (!friendly && (tmp->flag [FLAG_FRIENDLY] \|\| tmp->is_player ())))
1318	{	1305	{
1319	if (spell_ob->subtype == SP_DESTRUCTION)	1306	if (spell_ob->subtype == SP_DESTRUCTION)
1320	{	1307	{
1321	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1308	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1322		1309
1323	if (spell_ob->other_arch)	1310	if (spell_ob->other_arch)
1324	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1311	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1325	}	1312	}
1326	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)	1313	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist [ATNR_MAGIC] != 100)
1327	{	1314	{
1328	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1315	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1329	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1316	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1330	}	1317	}
1331	}	1318	}
1332	}	1319	}
1333	}	1320	}
1334	}
1335	}	1321	}
1336		1322
1337	op->skill = skill;
1338	return 1;	1323	return 1;
1339	}	1324	}
1340		1325
1341	/***************************************************************************	1326	/***************************************************************************
1342	*	1327	*
1343	* CURSE	1328	* CURSE
1344	*	1329	*
1345	***************************************************************************/	1330	***************************************************************************/
1346
1347	int	1331	int
1348	cast_curse (object op, object caster, object *spell_ob, int dir)	1332	cast_curse (object op, object caster, object *spell_ob, int dir)
1349	{	1333	{
1350	object *god = find_god (determine_god (op));	1334	object *god = find_god (determine_god (op));
1351	object tmp, force;	1335	object tmp, force;
1352		1336
1353	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);	1337	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);
1354	if (!tmp)	1338	if (!tmp)
1355	{	1339	{
1356	new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");	1340	op->failmsg ("There is no one in that direction to curse.");
1357	return 0;	1341	return 0;
1358	}	1342	}
1359		1343
1360	tmp = tmp->head_ ();	1344	tmp = tmp->head_ ();
1361		1345
…		…
1376	}	1360	}
1377	}	1361	}
1378		1362
1379	if (!force)	1363	if (!force)
1380	{	1364	{
1381	force = get_archetype (FORCE_NAME);	1365	force = archetype::get (FORCE_NAME);
1382	force->subtype = FORCE_CHANGE_ABILITY;	1366	force->subtype = FORCE_CHANGE_ABILITY;
1383		1367
1384	if (spell_ob->race)	1368	if (spell_ob->race)
1385	force->name = spell_ob->race;	1369	force->name = spell_ob->race;
1386	else	1370	else
…		…
1404		1388
1405	return 1;	1389	return 1;
1406	}	1390	}
1407		1391
1408	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1392	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1409	force->speed = 1.f;
1410	force->speed_left = -1.f;	1393	force->speed_left = -1.f;
1411	SET_FLAG (force, FLAG_APPLIED);	1394	force->set_speed (1.f);
		1395	force->set_flag (FLAG_APPLIED);
1412		1396
1413	if (god)	1397	if (god)
1414	{	1398	{
1415	if (spell_ob->last_grace)	1399	if (spell_ob->last_grace)
1416	force->path_repelled = god->path_repelled;	1400	force->path_repelled = god->path_repelled;
…		…
1429	force->stats.wc = spell_ob->stats.wc;	1413	force->stats.wc = spell_ob->stats.wc;
1430		1414
1431	change_abil (tmp, force); /* Mostly to display any messages */	1415	change_abil (tmp, force); /* Mostly to display any messages */
1432	insert_ob_in_ob (force, tmp);	1416	insert_ob_in_ob (force, tmp);
1433	tmp->update_stats ();	1417	tmp->update_stats ();
		1418
1434	return 1;	1419	return 1;
1435
1436	}	1420	}
1437		1421
1438	/**********************************************************************	1422	/**********************************************************************
1439	* mood change	1423	* mood change
1440	* Arguably, this may or may not be an attack spell. But since it	1424	* Arguably, this may or may not be an attack spell. But since it
…		…
1446	*/	1430	*/
1447	int	1431	int
1448	mood_change (object op, object caster, object *spell)	1432	mood_change (object op, object caster, object *spell)
1449	{	1433	{
1450	object tmp, god, *head;	1434	object tmp, god, *head;
1451	int done_one, range, mflags, level, at, best_at;	1435	int done_one, range, level, at, best_at;
1452	sint16 x, y, nx, ny;
1453	maptile *m;
1454	const char *race;	1436	const char *race;
1455		1437
1456	/* We precompute some values here so that we don't have to keep	1438	/* We precompute some values here so that we don't have to keep
1457	* doing it over and over again.	1439	* doing it over and over again.
1458	*/	1440	*/
…		…
1464	* so even if the player doesn't worship a god, if race=GOD_.., it	1446	* so even if the player doesn't worship a god, if race=GOD_.., it
1465	* won't ever match anything.	1447	* won't ever match anything.
1466	*/	1448	*/
1467	if (!spell->race)	1449	if (!spell->race)
1468	race = NULL;	1450	race = NULL;
1469	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1451	else if (god && spell->race == shstr_GOD_SLAYING)
1470	race = god->slaying;	1452	race = god->slaying;
1471	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1453	else if (god && spell->race == shstr_GOD_FRIEND)
1472	race = god->race;	1454	race = god->race;
1473	else	1455	else
1474	race = spell->race;	1456	race = spell->race;
1475		1457
1476	for (x = op->x - range; x <= op->x + range; x++)	1458	dynbuf buf;
1477	for (y = op->y - range; y <= op->y + range; y++)	1459	unordered_mapwalk (buf, op, -range, -range, range, range)
1478	{	1460	{
1479	done_one = 0;	1461	mapspace &ms = m->at (nx, ny);
1480	m = op->map;
1481	nx = x;
1482	ny = y;
1483	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1484	if (mflags & P_OUT_OF_MAP)
1485	continue;
1486		1462
1487	/* If there is nothing living on this space, no need to go further */	1463	/* If there is nothing living on this space, no need to go further */
1488	if (!(mflags & P_IS_ALIVE))	1464	if (!(ms.flags () & P_IS_ALIVE))
1489	continue;	1465	continue;
1490		1466
1491	// players can only affect spaces that they can actually see	1467	// players can only affect spaces that they can actually see
		1468	if (caster
1492	if (caster && caster->contr	1469	&& caster->contr
1493	&& caster->contr->visibility_at (m, nx, ny) < 70)	1470	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1494	continue;	1471	continue;
1495		1472
1496	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1473	for (tmp = ms.top; tmp; tmp = tmp->below)
1497	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1474	if (tmp->flag [FLAG_MONSTER])
1498	break;	1475	break;
1499		1476
1500	/* There can be living objects that are not monsters */	1477	/* There can be living objects that are not monsters */
1501	if (!tmp \|\| tmp->type == PLAYER)	1478	if (!tmp)
1502	continue;	1479	continue;
1503		1480
1504	/* Only the head has meaningful data, so resolve to that */	1481	/* Only the head has meaningful data, so resolve to that */
1505	if (tmp->head)
1506	head = tmp->head;	1482	head = tmp->head_ ();
1507	else
1508	head = tmp;
1509		1483
1510	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */	1484	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */
1511	if (race && head->race && !strstr (race, head->race))	1485	if (race && head->race && !strstr (race, head->race))
1512	continue;	1486	continue;
1513		1487
1514	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1488	if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
1515	continue;	1489	continue;
1516		1490
1517	/* Now do a bunch of stuff related to saving throws */	1491	/* Now do a bunch of stuff related to saving throws */
1518	best_at = -1;	1492	best_at = -1;
1519	if (spell->attacktype)	1493	if (spell->attacktype)
1520	{	1494	{
1521	for (at = 0; at < NROFATTACKS; at++)	1495	for (at = 0; at < NROFATTACKS; at++)
1522	if (spell->attacktype & (1 << at))	1496	if (spell->attacktype & (1 << at))
1523	if (best_at == -1 \|\| head->resist[at] > head->resist[best_at])	1497	if (best_at == -1 \|\| head->resist[at] > head->resist[best_at])
1524	best_at = at;	1498	best_at = at;
1525		1499
1526	if (best_at == -1)	1500	if (best_at == -1)
1527	at = 0;	1501	at = 0;
1528	else	1502	else
1529	{	1503	{
1530	if (head->resist[best_at] == 100)	1504	if (head->resist[best_at] == 100)
1531	continue;	1505	continue;
1532	else	1506	else
1533	at = head->resist[best_at] / 5;	1507	at = head->resist[best_at] / 5;
1534	}	1508	}
		1509
1535	at -= level / 5;	1510	at -= level / 5;
1536	if (did_make_save (head, head->level, at))	1511	if (did_make_save (head, head->level, at))
1537	continue;	1512	continue;
1538	}	1513	}
1539	else /* spell->attacktype */	1514	else /* spell->attacktype */
1540	{	1515	{
1541	/*	1516	/*
1542	Spell has no attacktype (charm & such), so we'll have a specific saving:	1517	Spell has no attacktype (charm & such), so we'll have a specific saving:
1543	* if spell level < monster level, no go	1518	* if spell level < monster level, no go
1544	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )	1519	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1545		1520
1546	The chance will then be in the range [20-70] percent, not too bad.	1521	The chance will then be in the range [20-70] percent, not too bad.
1547		1522
1548	This is required to fix the 'charm monster' abuse, where a player level 1 can	1523	This is required to fix the 'charm monster' abuse, where a player level 1 can
1549	charm a level 125 monster...	1524	charm a level 125 monster...
1550		1525
1551	Ryo, august 14th	1526	Ryo, august 14th
1552	*/	1527	*/
1553	if (head->level > level)	1528	if (head->level > level)
1554	continue;	1529	continue;
1555		1530
1556	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))	1531	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + min (50, 2 * (level - head->level))))
1557	/* Failed, no effect */	1532	/* Failed, no effect */
1558	continue;	1533	continue;
1559	}	1534	}
1560		1535
1561	/* Done with saving throw. Now start affecting the monster */	1536	/* Done with saving throw. Now start affecting the monster */
		1537	done_one = 0;
1562		1538
1563	/* aggravation */	1539	/* aggravation */
1564	if (QUERY_FLAG (spell, FLAG_MONSTER))	1540	if (spell->flag [FLAG_MONSTER])
1565	{	1541	{
1566	CLEAR_FLAG (head, FLAG_SLEEP);	1542	head->clr_flag (FLAG_SLEEP);
1567	remove_friendly_object (head);	1543	remove_friendly_object (head);
1568	done_one = 1;	1544	done_one = 1;
1569	head->enemy = op;	1545	head->enemy = op;
1570	}	1546	}
1571		1547
1572	/* calm monsters */	1548	/* calm monsters */
1573	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1549	if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
1574	{	1550	{
1575	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1551	head->set_flag (FLAG_UNAGGRESSIVE);
1576	head->enemy = NULL;	1552	head->enemy = NULL;
1577	done_one = 1;	1553	done_one = 1;
1578	}	1554	}
1579		1555
1580	/* berserk monsters */	1556	/* berserk monsters */
1581	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1557	if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
1582	{	1558	{
1583	SET_FLAG (head, FLAG_BERSERK);	1559	head->set_flag (FLAG_BERSERK);
1584	done_one = 1;	1560	done_one = 1;
1585	}	1561	}
1586		1562
1587	/* charm */	1563	/* charm */
1588	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1564	if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
1589	{	1565	{
1590	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));	1566	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
1591		1567
1592	/* Prevent uncontrolled outbreaks of self replicating monsters.	1568	/* Prevent uncontrolled outbreaks of self replicating monsters.
1593	Typical use case is charm, go somwhere, use aggravation to make hostile.	1569	Typical use case is charm, go somwhere, use aggravation to make hostile.
1594	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */	1570	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1595	CLEAR_FLAG (head, FLAG_GENERATOR);	1571	head->clr_flag (FLAG_GENERATOR);
1596	head->set_owner (op);	1572	head->set_owner (op);
1597	set_spell_skill (op, caster, spell, head);	1573	set_spell_skill (op, caster, spell, head);
1598	add_friendly_object (head);	1574	add_friendly_object (head);
1599	head->attack_movement = PETMOVE;	1575	head->attack_movement = PETMOVE;
1600	done_one = 1;	1576	done_one = 1;
1601	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1577	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1602	head->stats.exp = 0;	1578	head->stats.exp = 0;
1603	}	1579	}
1604		1580
1605	/* If a monster was effected, put an effect in */	1581	/* If a monster was effected, put an effect in */
1606	if (done_one && spell->other_arch)	1582	if (done_one && spell->other_arch)
1607	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1583	m->insert (spell->other_arch->instance (), nx, ny, op);
1608	} /* for y */	1584	}
1609		1585
1610	return 1;	1586	return 1;
1611	}	1587	}
1612
1613		1588
1614	/* Move_ball_spell: This handles ball type spells that just sort of wander	1589	/* Move_ball_spell: This handles ball type spells that just sort of wander
1615	* about. was called move_ball_lightning, but since more than the ball	1590	* about. was called move_ball_lightning, but since more than the ball
1616	* lightning spell used it, that seemed misnamed.	1591	* lightning spell used it, that seemed misnamed.
1617	* op is the spell effect.	1592	* op is the spell effect.
…		…
1643	for (i = 1; i < 9; i++)	1618	for (i = 1; i < 9; i++)
1644	{	1619	{
1645	/* i bit 0: alters sign of offset	1620	/* i bit 0: alters sign of offset
1646	* other bits (i / 2): absolute value of offset	1621	* other bits (i / 2): absolute value of offset
1647	*/	1622	*/
1648
1649	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);	1623	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1650	int tmpdir = absdir (op->direction + offset);	1624	int tmpdir = absdir (op->direction + offset);
1651		1625
1652	nx = op->x + freearr_x[tmpdir];	1626	nx = op->x + freearr_x[tmpdir];
1653	ny = op->y + freearr_y[tmpdir];	1627	ny = op->y + freearr_y[tmpdir];
…		…
1655	{	1629	{
1656	dir = tmpdir;	1630	dir = tmpdir;
1657	break;	1631	break;
1658	}	1632	}
1659	}	1633	}
		1634
1660	if (dir == 0)	1635	if (dir == 0)
1661	{	1636	{
1662	nx = op->x;	1637	nx = op->x;
1663	ny = op->y;	1638	ny = op->y;
1664	m = op->map;	1639	m = op->map;
…		…
1696	hit_map (op, j, op->attacktype, 1);	1671	hit_map (op, j, op->attacktype, 1);
1697	}	1672	}
1698		1673
1699	/* insert the other arch */	1674	/* insert the other arch */
1700	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))	1675	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1701	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1676	m->insert (op->other_arch->instance (), hx, hy, op);
1702	}	1677	}
1703		1678
1704	/* restore to the center location and damage */	1679	/* restore to the center location and damage */
1705	op->stats.dam = dam_save;	1680	op->stats.dam = dam_save;
1706		1681
…		…
1737	object *owner = op->env;	1712	object *owner = op->env;
1738		1713
1739	if (!owner) // MUST not happen, remove when true TODO	1714	if (!owner) // MUST not happen, remove when true TODO
1740	{	1715	{
1741	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());	1716	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1742	op->destroy (true);	1717	op->destroy ();
1743	return;	1718	return;
1744	}	1719	}
1745		1720
1746	if (!op->duration \|\| !owner->is_on_map ())	1721	if (!op->duration \|\| !owner->is_on_map ())
1747	{	1722	{
…		…
1885	int dam, mflags;	1860	int dam, mflags;
1886	maptile *m;	1861	maptile *m;
1887		1862
1888	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1863	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1889		1864
1890	if (!dir)	1865	if (dir)
1891	{
1892	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1893	return 0;
1894	}	1866	{
1895
1896	x = op->x + freearr_x[dir];	1867	x = op->x + freearr_x[dir];
1897	y = op->y + freearr_y[dir];	1868	y = op->y + freearr_y[dir];
1898	m = op->map;	1869	m = op->map;
1899		1870
1900	mflags = get_map_flags (m, &m, x, y, &x, &y);	1871	mflags = get_map_flags (m, &m, x, y, &x, &y);
1901		1872
1902	if (mflags & P_OUT_OF_MAP)	1873	if (mflags & P_OUT_OF_MAP)
1903	{	1874	{
1904	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1875	op->failmsg ("Nothing is there.");
1905	return 0;	1876	return 0;
1906	}	1877	}
1907		1878
1908	if (mflags & P_IS_ALIVE && spell->attacktype)	1879	if (mflags & P_IS_ALIVE && spell->attacktype)
1909	{	1880	{
1910	for (target = GET_MAP_OB (m, x, y); target; target = target->above)	1881	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1911	if (QUERY_FLAG (target, FLAG_MONSTER))	1882	if (target->flag [FLAG_MONSTER])
1912	{	1883	{
1913	/* oky doky. got a target monster. Lets make a blinding attack */	1884	/* oky doky. got a target monster. Lets make a blinding attack */
1914	if (target->head)	1885	if (target->head)
1915	target = target->head;	1886	target = target->head;
1916		1887
1917	hit_player (target, dam, op, spell->attacktype, 1);	1888	hit_player (target, dam, op, spell->attacktype, 1);
1918	return 1; /* one success only! */	1889	return 1; /* one success only! */
		1890	}
1919	}	1891	}
1920	}
1921		1892
1922	/* no live target, perhaps a wall is in the way? */	1893	/* no live target, perhaps a wall is in the way? */
1923	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))	1894	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
1924	{	1895	{
1925	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1896	op->failmsg ("Something is in the way.");
1926	return 0;	1897	return 0;
		1898	}
1927	}	1899	}
1928		1900
1929	/* ok, looks groovy to just insert a new light on the map */	1901	/* ok, looks groovy to just insert a new light on the map */
1930	tmp = arch_to_object (spell->other_arch);	1902	tmp = spell->other_arch->instance ();
1931	if (!tmp)	1903	if (!tmp)
1932	{	1904	{
1933	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1905	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1934	return 0;	1906	return 0;
1935	}	1907	}
		1908
1936	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1909	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
		1910
1937	if (tmp->glow_radius)	1911	if (tmp->glow_radius)
1938	{	1912	tmp->set_glow_radius (
1939	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);	1913	clamp (spell->range + SP_level_range_adjust (caster, spell), 1, MAX_LIGHT_RADIUS)
1940	if (tmp->glow_radius > MAX_LIGHT_RADII)	1914	);
1941	tmp->glow_radius = MAX_LIGHT_RADII;
1942	}
1943		1915
		1916	if (dir)
1944	m->insert (tmp, x, y, op);	1917	m->insert (tmp, x, y, op);
		1918	else
		1919	caster->outer_env_or_self ()->insert (tmp);
		1920
1945	return 1;	1921	return 1;
1946	}	1922	}
1947		1923
1948	/* cast_cause_disease: this spell looks along <dir> from the	1924	/* cast_cause_disease: this spell looks along <dir> from the
1949	* player and infects someone.	1925	* player and infects someone.
…		…
1995	/* Only bother looking on this space if there is something living here */	1971	/* Only bother looking on this space if there is something living here */
1996	if (mflags & P_IS_ALIVE)	1972	if (mflags & P_IS_ALIVE)
1997	{	1973	{
1998	/* search this square for a victim */	1974	/* search this square for a victim */
1999	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)	1975	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
2000	if (QUERY_FLAG (walk, FLAG_MONSTER) \|\| (walk->type == PLAYER))	1976	if (walk->flag [FLAG_MONSTER] \|\| (walk->type == PLAYER))
2001	{ /* found a victim */	1977	{ /* found a victim */
2002	object *disease = arch_to_object (spell->other_arch);	1978	object *disease = spell->other_arch->instance ();
2003		1979
2004	disease->set_owner (op);	1980	disease->set_owner (op);
2005	set_spell_skill (op, caster, spell, disease);	1981	set_spell_skill (op, caster, spell, disease);
2006	disease->stats.exp = 0;	1982	disease->stats.exp = 0;
2007	disease->level = casting_level (caster, spell);	1983	disease->level = casting_level (caster, spell);
2008		1984
2009	/* do level adjustments */	1985	/* do level adjustments */
2010	if (disease->stats.wc)	1986	if (disease->stats.wc ) disease->stats.wc += dur_mod / 2;
2011	disease->stats.wc += dur_mod / 2;	1987	if (disease->magic > 0) disease->magic += dur_mod / 8;
2012		1988	if (disease->stats.maxhp > 0) disease->stats.maxhp += dur_mod;
2013	if (disease->magic > 0)	1989	if (disease->stats.maxgrace > 0) disease->stats.maxgrace += dur_mod;
2014	disease->magic += dur_mod / 8;
2015
2016	if (disease->stats.maxhp > 0)
2017	disease->stats.maxhp += dur_mod;
2018
2019	if (disease->stats.maxgrace > 0)
2020	disease->stats.maxgrace += dur_mod;
2021
2022	if (disease->stats.dam)
2023	{
2024	if (disease->stats.dam > 0)
2025	disease->stats.dam += dam_mod;
2026	else
2027	disease->stats.dam -= dam_mod;
2028	}
2029		1990
2030	if (disease->last_sp)	1991	if (disease->last_sp)
2031	{	1992	{
2032	disease->last_sp -= 2 * dam_mod;	1993	disease->last_sp -= 2 * dam_mod;
		1994
2033	if (disease->last_sp < 1)	1995	if (disease->last_sp < 1)
2034	disease->last_sp = 1;	1996	disease->last_sp = 1;
2035	}	1997	}
2036		1998
2037	if (disease->stats.maxsp)	1999	if (disease->stats.dam ) disease->stats.dam += copysignl (disease->stats.dam , dam_mod);
2038	{	2000	if (disease->stats.maxsp) disease->stats.maxsp += copysignl (disease->stats.maxsp, dam_mod);
2039	if (disease->stats.maxsp > 0)	2001	if (disease->stats.ac ) disease->stats.ac += dam_mod;
2040	disease->stats.maxsp += dam_mod;	2002	if (disease->last_eat ) disease->last_eat -= dam_mod;
2041	else	2003	if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2042	disease->stats.maxsp -= dam_mod;	2004	if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2043	}
2044
2045	if (disease->stats.ac)
2046	disease->stats.ac += dam_mod;
2047
2048	if (disease->last_eat)
2049	disease->last_eat -= dam_mod;
2050
2051	if (disease->stats.hp)
2052	disease->stats.hp -= dam_mod;
2053
2054	if (disease->stats.sp)
2055	disease->stats.sp -= dam_mod;
2056		2005
2057	if (infect_object (walk, disease, 1))	2006	if (infect_object (walk, disease, 1))
2058	{	2007	{
2059	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);	2008	op->statusmsg (format ("You inflict %s on %s!", &disease->name, &walk->name));
2060		2009
2061	disease->destroy (true); /* don't need this one anymore */	2010	disease->destroy (); /* don't need this one anymore */
2062	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2011	walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
2063	return 1;	2012	return 1;
2064	}	2013	}
2065		2014
2066	disease->destroy (true);	2015	disease->destroy ();
2067	}	2016	}
2068	} /* if living creature */	2017	} /* if living creature */
2069	} /* for range of spaces */	2018	} /* for range of spaces */
2070		2019
2071	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");	2020	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.66 by root, Mon Sep 29 10:31:32 2008 UTC vs. Revision 1.113 by root, Wed Nov 16 22:14:06 2016 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.66 by root, Mon Sep 29 10:31:32 2008 UTC vs.
Revision 1.113 by root, Wed Nov 16 22:14:06 2016 UTC