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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.53 by root, Tue Apr 22 07:01:47 2008 UTC vs.
Revision 1.96 by root, Sun Feb 7 04:22:33 2010 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002-2003,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	*/
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
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		42	static void
42	void
43	check_spell_knockback (object *op)	43	check_spell_knockback (object *op)
44	{	44	{
45	object tmp, tmp2; /* object on the map */
46	int weight_move;	45	int weight_move;
47	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 /
48		47
49	if (!op->weight)	48	if (!op->weight)
50	{ /shouldn't happen but if cone object has no weight drop out /	49	{ /shouldn't happen but if cone object has no weight drop out /
…		…
55	{	54	{
56	weight_move = op->weight + (op->weight * op->level) / 3;	55	weight_move = op->weight + (op->weight * op->level) / 3;
57	/LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); /	56	/LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); /
58	}	57	}
59		58
60	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	59	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
61	{	60	{
62	int num_sections = 1;	61	int num_sections = 1;
63		62
64	/* don't move DM */	63	/* don't move DM */
65	if (QUERY_FLAG (tmp, FLAG_WIZ))	64	if (QUERY_FLAG (tmp, FLAG_WIZ))
…		…
72	/* don't move floors or immobile objects */	71	/* don't move floors or immobile objects */
73	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) \|\| (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))	72	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) \|\| (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))
74	continue;	73	continue;
75		74
76	/* count the object's sections */	75	/* count the object's sections */
77	for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more)	76	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
78	num_sections++;	77	num_sections++;
79		78
80	/* I'm not sure if it makes sense to divide by num_sections - bigger	79	/* I'm not sure if it makes sense to divide by num_sections - bigger
81	* objects should be harder to move, and we are moving the entire	80	* objects should be harder to move, and we are moving the entire
82	* object, not just the head, so the total weight should be relevant.	81	* object, not just the head, so the total weight should be relevant.
…		…
106	*	105	*
107	* BOLT CODE	106	* BOLT CODE
108	*	107	*
109	***************************************************************************/	108	***************************************************************************/
110		109
111	/* Causes op to fork. op is the original bolt, tmp	110	/* Causes op to fork. op is the original bolt, tmp
112	* is the first piece of the fork.	111	* is the first piece of the fork.
113	*/	112	*/
114		113	static void
115	void
116	forklightning (object op, object tmp)	114	forklightning (object op, object tmp)
117	{	115	{
118	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 */
119	int t_dir; /* stores temporary dir calculation */	117	int t_dir; /* stores temporary dir calculation */
120	maptile *m;	118	maptile *m;
…		…
151	new_bolt->duration++;	149	new_bolt->duration++;
152	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */	150	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
153	new_bolt->stats.dam++;	151	new_bolt->stats.dam++;
154	tmp->stats.dam /= 2; /* reduce father bolt damage */	152	tmp->stats.dam /= 2; /* reduce father bolt damage */
155	tmp->stats.dam++;	153	tmp->stats.dam++;
		154
156	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))	155	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
157	update_turn_face (new_bolt);	156	update_turn_face (new_bolt);
158	}	157	}
159		158
160	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,	159	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
161	* and checks for various things that may stop it.	160	* and checks for various things that may stop it.
162	*/	161	*/
163
164	void	162	void
165	move_bolt (object *op)	163	move_bolt (object *op)
166	{	164	{
167	int mflags;	165	int mflags;
168	sint16 x, y;	166	sint16 x, y;
169	maptile *m;	167	maptile *m;
170		168
171	if (--op->duration < 0)	169	if (--op->duration < 0)
172	{	170	{
173	op->destroy ();	171	op->drop_and_destroy ();
174	return;	172	return;
175	}	173	}
176		174
177	hit_map (op, 0, op->attacktype, 1);	175	hit_map (op, 0, op->attacktype, 1);
178		176
…		…
251	tmp->duration++;	249	tmp->duration++;
252		250
253	/* New forking code. Possibly create forks of this object	251	/* New forking code. Possibly create forks of this object
254	* going off in other directions.	252	* going off in other directions.
255	*/	253	*/
256	if (rndm (0, 99) < tmp->stats.Dex)	254	if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
257	{ /* stats.Dex % of forking */	255	forklightning (op, tmp); /* stats.Dex % of forking */
258	forklightning (op, tmp);
259	}
260		256
261	/* In this way, the object left behind sticks on the space, but	257	/* In this way, the object left behind sticks on the space, but
262	* doesn't create any bolts that continue to move onward.	258	* doesn't create any bolts that continue to move onward.
263	*/	259	*/
264	op->range = 0;	260	op->range = 0;
…		…
281	int mflags;	277	int mflags;
282		278
283	if (!spob->other_arch)	279	if (!spob->other_arch)
284	return 0;	280	return 0;
285		281
286	tmp = arch_to_object (spob->other_arch);	282	tmp = spob->other_arch->instance ();
287	if (tmp == NULL)	283	if (tmp == NULL)
288	return 0;	284	return 0;
289		285
290	/* peterm: level dependency for bolts */	286	/* peterm: level dependency for bolts */
291	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);
292	tmp->attacktype = spob->attacktype;	288	tmp->attacktype = spob->attacktype;
		289
293	if (spob->slaying)	290	if (spob->slaying)
294	tmp->slaying = spob->slaying;	291	tmp->slaying = spob->slaying;
		292
295	tmp->range = spob->range + SP_level_range_adjust (caster, spob);	293	tmp->range = spob->range + SP_level_range_adjust (caster, spob);
296	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);	294	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
297	tmp->stats.Dex = spob->stats.Dex;	295	tmp->stats.Dex = spob->stats.Dex;
298	tmp->stats.Con = spob->stats.Con;	296	tmp->stats.Con = spob->stats.Con;
299		297
…		…
310		308
311	maptile *newmap;	309	maptile *newmap;
312	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);	310	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
313	if (mflags & P_OUT_OF_MAP)	311	if (mflags & P_OUT_OF_MAP)
314	{	312	{
315	tmp->destroy ();	313	tmp->drop_and_destroy ();
316	return 0;	314	return 0;
317	}	315	}
318		316
319	tmp->map = newmap;	317	tmp->map = newmap;
320		318
321	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)))
322	{	320	{
323	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	321	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
324	{	322	{
325	tmp->destroy ();	323	tmp->drop_and_destroy ();
326	return 0;	324	return 0;
327	}	325	}
328		326
329	tmp->x = op->x;	327	tmp->x = op->x;
330	tmp->y = op->y;	328	tmp->y = op->y;
…		…
391		389
392	/* Causes an object to explode, eg, a firebullet,	390	/* Causes an object to explode, eg, a firebullet,
393	* poison cloud ball, etc. op is the object to	391	* poison cloud ball, etc. op is the object to
394	* explode.	392	* explode.
395	*/	393	*/
396	void	394	static void
397	explode_bullet (object *op)	395	explode_bullet (object *op)
398	{	396	{
399	object tmp, owner;	397	object tmp, owner;
400		398
401	if (op->other_arch == NULL)	399	if (!op->other_arch)
402	{	400	{
403	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	401	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
404	op->destroy ();	402	op->destroy ();
405	return;	403	return;
406	}	404	}
…		…
435	}	433	}
436		434
437	if (op->attacktype)	435	if (op->attacktype)
438	{	436	{
439	hit_map (op, 0, op->attacktype, 1);	437	hit_map (op, 0, op->attacktype, 1);
		438
440	if (op->destroyed ())	439	if (op->destroyed ())
441	return;	440	return;
442	}	441	}
443		442
444	/* other_arch contains what this explodes into */	443	/* other_arch contains what this explodes into */
445	tmp = arch_to_object (op->other_arch);	444	tmp = op->other_arch->instance ();
446		445
447	tmp->set_owner (op);	446	tmp->set_owner (op);
448	tmp->skill = op->skill;	447	tmp->skill = op->skill;
449		448
450	owner = op->owner;	449	owner = op->owner;
451		450
452	if ((tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))	451	if ((tmp->attacktype & AT_HOLYWORD
		452	\|\| tmp->attacktype & AT_GODPOWER)
		453	&& owner
		454	&& !tailor_god_spell (tmp, owner))
453	{	455	{
454	op->destroy ();	456	op->destroy ();
455	return;	457	return;
456	}	458	}
457		459
…		…
522	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	524	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
523	{	525	{
524	if (QUERY_FLAG (tmp, FLAG_ALIVE))	526	if (QUERY_FLAG (tmp, FLAG_ALIVE))
525	{	527	{
526	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	528	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
		529
		530	// TODO: can't understand the following if's
527	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)	531	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)
528	{	532	{
529	if (!QUERY_FLAG (op, FLAG_REMOVED))	533	if (!QUERY_FLAG (op, FLAG_REMOVED))
530	{	534	{
531	op->destroy ();	535	op->destroy ();
…		…
542	* fired arches (eg, bolts).	546	* fired arches (eg, bolts).
543	*/	547	*/
544	void	548	void
545	move_bullet (object *op)	549	move_bullet (object *op)
546	{	550	{
547	sint16 new_x, new_y;
548	int mflags;
549	maptile *m;
550
551	#if 0	551	#if 0
552	/* We need a better general purpose way to do this */	552	/* We need a better general purpose way to do this */
553		553
554	/* peterm: added to make comet leave a trail of burnouts	554	/* peterm: added to make comet leave a trail of burnouts
555	it's an unadulterated hack, but the effect is cool. */	555	it's an unadulterated hack, but the effect is cool. */
…		…
570	op->destroy ();	570	op->destroy ();
571		571
572	return;	572	return;
573	}	573	}
574		574
575	new_x = op->x + DIRX (op);	575	mapxy pos (op);
576	new_y = op->y + DIRY (op);	576	pos.move (op->direction);
577	m = op->map;
578	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
579		577
580	if (mflags & P_OUT_OF_MAP)	578	if (!pos.normalise ())
581	{	579	{
582	op->destroy ();	580	op->destroy ();
583	return;	581	return;
584	}	582	}
585		583
586	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))
587	{	589	{
588	if (op->other_arch)	590	if (op->other_arch)
589	explode_bullet (op);	591	explode_bullet (op);
590	else	592	else
591	op->destroy ();	593	op->destroy ();
592		594
593	return;	595	return;
594	}	596	}
595		597
596	if (!(op = m->insert (op, new_x, new_y, op)))	598	if (!(op = pos.insert (op, op)))
597	return;	599	return;
598		600
599	if (reflwall (op->map, op->x, op->y, op))	601	if (reflwall (op->map, op->x, op->y, op))
600	{	602	{
601	op->direction = absdir (op->direction + 4);	603	op->direction = absdir (op->direction + 4);
…		…
620	int mflags;	622	int mflags;
621		623
622	if (!spob->other_arch)	624	if (!spob->other_arch)
623	return 0;	625	return 0;
624		626
625	tmp = arch_to_object (spob->other_arch);	627	tmp = spob->other_arch->instance ();
626	if (tmp == NULL)	628	if (!tmp)
627	return 0;	629	return 0;
628		630
629	/* peterm: level dependency for bolts */	631	/* peterm: level dependency for bolts */
630	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);	632	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
631	tmp->attacktype = spob->attacktype;	633	tmp->attacktype = spob->attacktype;
632	if (spob->slaying)	634	if (spob->slaying)
633	tmp->slaying = spob->slaying;	635	tmp->slaying = spob->slaying;
634		636
…		…
644	SET_ANIMATION (tmp, dir);	646	SET_ANIMATION (tmp, dir);
645		647
646	tmp->set_owner (op);	648	tmp->set_owner (op);
647	set_spell_skill (op, caster, spob, tmp);	649	set_spell_skill (op, caster, spob, tmp);
648		650
649	tmp->x = op->x + freearr_x[dir];	651	tmp->x = op->x + freearr_x[dir];
650	tmp->y = op->y + freearr_y[dir];	652	tmp->y = op->y + freearr_y[dir];
651	tmp->map = op->map;	653	tmp->map = op->map;
652		654
653	maptile *newmap;	655	maptile *newmap;
654	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);
655	if (mflags & P_OUT_OF_MAP)	657	if (mflags & P_OUT_OF_MAP)
…		…
657	tmp->destroy ();	659	tmp->destroy ();
658	return 0;	660	return 0;
659	}	661	}
660		662
661	tmp->map = newmap;	663	tmp->map = newmap;
		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	}
662		677
663	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)))
664	{	679	{
665	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	680	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
666	{	681	{
…		…
685	* CONE RELATED FUNCTIONS	700	* CONE RELATED FUNCTIONS
686	*	701	*
687	*****************************************************************************/	702	*****************************************************************************/
688		703
689	/* 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" */
690	void	705	static void
691	cone_drop (object *op)	706	cone_drop (object *op)
692	{	707	{
693	object *new_ob = arch_to_object (op->other_arch);	708	object *new_ob = op->other_arch->instance ();
694		709
695	new_ob->level = op->level;	710	new_ob->level = op->level;
696	new_ob->set_owner (op->owner);	711	new_ob->set_owner (op->owner);
697		712
698	/* preserve skill ownership */	713	/* preserve skill ownership */
…		…
705	/* move_cone: causes cone object 'op' to move a space/hit creatures */	720	/* move_cone: causes cone object 'op' to move a space/hit creatures */
706		721
707	void	722	void
708	move_cone (object *op)	723	move_cone (object *op)
709	{	724	{
710	int i;
711
712	/* if no map then hit_map will crash so just ignore object */	725	/* if no map then hit_map will crash so just ignore object */
713	if (!op->map)	726	if (!op->map)
714	{	727	{
715	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");	728	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
716	op->set_speed (0);	729	op->set_speed (0);
…		…
736	}	749	}
737	#endif	750	#endif
738		751
739	hit_map (op, 0, op->attacktype, 0);	752	hit_map (op, 0, op->attacktype, 0);
740		753
		754	if (!op->is_on_map ())
		755	return;
		756
741	/* Check to see if we should push anything.	757	/* Check to see if we should push anything.
742	* Spell objects with weight push whatever they encounter to some	758	* Spell objects with weight push whatever they encounter to some
743	* degree.	759	* degree.
744	*/	760	*/
745	if (op->weight)	761	if (op->weight)
		762	{
746	check_spell_knockback (op);	763	check_spell_knockback (op);
747		764
748	if (op->destroyed ())	765	if (!op->is_on_map ())
749	return;	766	return;
		767	}
750		768
751	if ((op->duration--) < 0)	769	if (op->duration-- < 0)
752	{	770	{
753	op->destroy ();	771	op->destroy ();
754	return;	772	return;
755	}	773	}
756	/* Object has hit maximum range, so don't have it move	774	/* Object has hit maximum range, so don't have it move
…		…
761	{	779	{
762	op->range = 0; /* just so it doesn't wrap */	780	op->range = 0; /* just so it doesn't wrap */
763	return;	781	return;
764	}	782	}
765		783
766	for (i = -1; i < 2; i++)	784	for (int i = -1; i <= 1; i++)
767	{	785	{
768	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];	786	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
769		787
770	if (ok_to_put_more (op->map, x, y, op, op->attacktype))	788	if (ok_to_put_more (op->map, x, y, op, op->attacktype))
771	{	789	{
…		…
822	*/	840	*/
823	movetype = spell->other_arch->move_type;	841	movetype = spell->other_arch->move_type;
824		842
825	for (i = range_min; i <= range_max; i++)	843	for (i = range_min; i <= range_max; i++)
826	{	844	{
827	sint16 x, y, d;	845	sint16 x, y;
828		846
829	/* We can't use absdir here, because it never returns	847	/* We can't use absdir here, because it never returns
830	* 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
831	* 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
832	* to hit that person.	850	* to hit that person.
833	*/	851	*/
834	d = dir + i;	852	int d = dir ? absdir (dir + i) : i;
835	while (d < 0)
836	d += 8;
837	while (d > 8)
838	d -= 8;
839		853
840	/* 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.
841	* In that case, we have to see - if dir is specified,	855	* In that case, we have to see - if dir is specified,
842	* turn this into direction 8. If dir is not specified (all	856	* turn this into direction 8. If dir is not specified (all
843	* direction) skip - otherwise, one line would do more damage	857	* direction) skip - otherwise, one line would do more damage
…		…
860		874
861	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	875	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
862	continue;	876	continue;
863		877
864	success = 1;	878	success = 1;
865	tmp = arch_to_object (spell->other_arch);	879	tmp = spell->other_arch->instance ();
866	tmp->set_owner (op);	880	tmp->set_owner (op);
867	set_spell_skill (op, caster, spell, tmp);	881	set_spell_skill (op, caster, spell, tmp);
868	tmp->level = caster_level (caster, spell);	882	tmp->level = casting_level (caster, spell);
869	tmp->attacktype = spell->attacktype;	883	tmp->attacktype = spell->attacktype;
870		884
871	/* holy word stuff */	885	/* holy word stuff */
872	if ((tmp->attacktype & AT_HOLYWORD) \|\| (tmp->attacktype & AT_GODPOWER))	886	if ((tmp->attacktype & AT_HOLYWORD) \|\| (tmp->attacktype & AT_GODPOWER))
873	if (!tailor_god_spell (tmp, op))	887	if (!tailor_god_spell (tmp, op))
…		…
945		959
946	object *env = op->outer_env ();	960	object *env = op->outer_env ();
947		961
948	if (op->env)	962	if (op->env)
949	{	963	{
950	if (env->map == NULL)	964	if (!env->map)
951	return;	965	return;
952		966
953	if (!(op = op->insert_at (env, op)))	967	if (!(op = op->insert_at (env, op)))
954	return;	968	return;
955	}	969	}
956		970
957	// 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
958	// 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
959	// as bombs can be carried.	973	// as bombs can be carried.
960	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	974	if (op->ms ().flags () & P_SAFE)
961	{	975	{
962	op->destroy ();	976	op->destroy ();
963	return;	977	return;
964	}	978	}
965		979
…		…
972	for (int i = 1; i < 9; i++)	986	for (int i = 1; i < 9; i++)
973	{	987	{
974	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]))
975	continue;	989	continue;
976		990
977	object *tmp = arch_to_object (at);	991	object *tmp = at->instance ();
978	tmp->direction = i;	992	tmp->direction = i;
979	tmp->range = op->range;	993	tmp->range = op->range;
980	tmp->stats.dam = op->stats.dam;	994	tmp->stats.dam = op->stats.dam;
981	tmp->duration = op->duration;	995	tmp->duration = op->duration;
982	tmp->attacktype = op->attacktype;	996	tmp->attacktype = op->attacktype;
…		…
1002	int mflags;	1016	int mflags;
1003	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];
1004	maptile *m;	1018	maptile *m;
1005		1019
1006	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	{
1007	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))
1008	{	1029	{
1009	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1030	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1010	return 0;	1031	return 0;
		1032	}
1011	}	1033	}
1012		1034
1013	tmp = arch_to_object (spell->other_arch);	1035	tmp = spell->other_arch->instance ();
1014		1036
1015	/* level dependencies for bomb */	1037	/* level dependencies for bomb */
1016	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1038	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1017	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);
1018	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1040	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
1038	* dir is the direction to look in.	1060	* dir is the direction to look in.
1039	* range is how far out to look.	1061	* range is how far out to look.
1040	* 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.
1041	* this info is used for blocked magic/unholy spaces.	1063	* this info is used for blocked magic/unholy spaces.
1042	*/	1064	*/
1043	object *	1065	static object *
1044	get_pointed_target (object *op, int dir, int range, int type)	1066	get_pointed_target (object *op, int dir, int range, int type)
1045	{	1067	{
1046	object *target;	1068	object *target;
1047	sint16 x, y;	1069	sint16 x, y;
1048	int dist, mflags;	1070	int dist, mflags;
…		…
1101	* interesting spell.	1123	* interesting spell.
1102	* if it is a cleric spell, you need a god, and the creature	1124	* if it is a cleric spell, you need a god, and the creature
1103	* can't be friendly to your god.	1125	* can't be friendly to your god.
1104	*/	1126	*/
1105		1127
1106	if (!target \|\| QUERY_FLAG (target, FLAG_REFL_SPELL)	1128	if (!target
		1129	\|\| target->flag [FLAG_REFL_SPELL]
1107	\|\| (!god && spell->stats.grace)	1130	\|\| (!god && spell->stats.grace)
1108	\|\| (target->title && god && !strcmp (target->title, god->name)) \|\| (target->race && god && strstr (target->race, god->race)))	1131	\|\| (god && target->title == god->name)
		1132	\|\| (god && target->race.contains (god->race)))
1109	{	1133	{
1110	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1134	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");
1111	return 0;	1135	return 0;
1112	}	1136	}
1113		1137
1114	if (spell->other_arch)	1138	if (spell->other_arch)
1115	effect = arch_to_object (spell->other_arch);	1139	effect = spell->other_arch->instance ();
1116	else	1140	else
1117	return 0;	1141	return 0;
1118		1142
1119	/* tailor the effect by priest level and worshipped God */	1143	/* tailor the effect by priest level and worshipped God */
1120	effect->level = caster_level (caster, spell);	1144	effect->level = casting_level (caster, spell);
1121	effect->attacktype = spell->attacktype;	1145	effect->attacktype = spell->attacktype;
1122	if (effect->attacktype & (AT_HOLYWORD \| AT_GODPOWER))	1146	if (effect->attacktype & (AT_HOLYWORD \| AT_GODPOWER))
1123	{	1147	{
1124	if (tailor_god_spell (effect, op))	1148	if (tailor_god_spell (effect, op))
1125	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));	1149	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", (const char *)determine_god (op));
1126	else	1150	else
1127	{	1151	{
1128	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1152	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");
1129	return 0;	1153	return 0;
1130	}	1154	}
…		…
1180		1204
1181	/* op is a missile that needs to be moved */	1205	/* op is a missile that needs to be moved */
1182	void	1206	void
1183	move_missile (object *op)	1207	move_missile (object *op)
1184	{	1208	{
1185	int i, mflags;
1186	object *owner;
1187	sint16 new_x, new_y;
1188	maptile *m;
1189
1190	if (op->range-- <= 0)	1209	if (op->range-- <= 0)
1191	{	1210	{
		1211	op->drop_and_destroy ();
		1212	return;
		1213	}
		1214
		1215	mapxy pos (op);
		1216	pos.move (op->direction);
		1217
		1218	if (!pos.normalise ())
		1219	{
1192	op->destroy ();	1220	op->destroy ();
1193	return;	1221	return;
1194	}	1222	}
1195		1223
1196	owner = op->owner;	1224	mapspace &ms = pos.ms ();
1197	#if 0
1198	/* It'd make things nastier if this wasn't here - spells cast by
1199	* monster that are then killed would continue to survive
1200	*/
1201	if (owner == NULL)
1202	{
1203	op->destroy ();
1204	return;
1205	}
1206	#endif
1207		1225
1208	new_x = op->x + DIRX (op);	1226	if (ms.flags () & P_IS_ALIVE \|\| ms.blocks (op))
1209	new_y = op->y + DIRY (op);
1210
1211	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1212
1213	if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) \|\| OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1214	{	1227	{
1215	hit_map (op, op->direction, AT_MAGIC, 1);	1228	hit_map (op, op->direction, AT_MAGIC, 1);
1216	/* Basically, missile only hits one thing then goes away.	1229	/* Basically, missile only hits one thing then goes away.
1217	* we need to remove it if someone hasn't already done so.	1230	* we need to remove it if someone hasn't already done so.
1218	*/	1231	*/
1219	if (!op->destroyed ())
1220	op->destroy ();
1221
1222	return;
1223	}
1224
1225	op->remove ();
1226
1227	if (!op->direction \|\| (mflags & P_OUT_OF_MAP))
1228	{
1229	op->destroy ();	1232	op->destroy ();
1230	return;	1233	return;
1231	}	1234	}
1232		1235
		1236	if (!op->direction)
		1237	{
		1238	op->destroy ();
		1239	return;
		1240	}
		1241
1233	i = spell_find_dir (m, new_x, new_y, op->owner);	1242	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1234	if (i > 0 && i != op->direction)	1243	if (i > 0 && i != op->direction)
1235	{	1244	{
1236	op->direction = i;	1245	op->direction = i;
1237	SET_ANIMATION (op, op->direction);	1246	SET_ANIMATION (op, op->direction);
1238	}	1247	}
1239		1248
1240	m->insert (op, new_x, new_y, op);	1249	pos.insert (op, op);
1241	}	1250	}
1242		1251
1243	/****************************************************************************	1252	/****************************************************************************
1244	* Destruction	1253	* Destruction
1245	****************************************************************************/	1254	****************************************************************************/
…		…
1248	* we do this by creating a force and inserting it in the	1257	* we do this by creating a force and inserting it in the
1249	* object. if time is 0, the object glows permanently. To truely	1258	* object. if time is 0, the object glows permanently. To truely
1250	* make this work for non-living objects, we would have to	1259	* make this work for non-living objects, we would have to
1251	* give them the capability to have an inventory. b.t.	1260	* give them the capability to have an inventory. b.t.
1252	*/	1261	*/
1253	int	1262	static int
1254	make_object_glow (object *op, int radius, int time)	1263	make_object_glow (object *op, int radius, int time)
1255	{	1264	{
1256	/* some things are unaffected... */	1265	/* some things are unaffected... */
1257	if (op->path_denied & PATH_LIGHT)	1266	if (op->path_denied & PATH_LIGHT)
1258	return 0;	1267	return 0;
1259		1268
1260	object *tmp = get_archetype (FORCE_NAME);	1269	object *tmp = get_archetype (FORCE_NAME);
1261	tmp->speed = 0.01;	1270	tmp->speed = 0.01;
1262	tmp->stats.food = time;	1271	tmp->stats.food = time;
1263	SET_FLAG (tmp, FLAG_IS_USED_UP);	1272	SET_FLAG (tmp, FLAG_IS_USED_UP);
1264	tmp->glow_radius = radius;	1273	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1265	if (tmp->glow_radius > MAX_LIGHT_RADII)
1266	tmp->glow_radius = MAX_LIGHT_RADII;
1267
1268	tmp = insert_ob_in_ob (tmp, op);	1274	tmp = insert_ob_in_ob (tmp, op);
1269		1275
1270	if (tmp->glow_radius > op->glow_radius)	1276	if (tmp->glow_radius > op->glow_radius)
1271	op->glow_radius = tmp->glow_radius;	1277	op->set_glow_radius (tmp->glow_radius);
1272		1278
1273	return 1;	1279	return 1;
1274	}	1280	}
1275		1281
1276	int	1282	int
1277	cast_destruction (object op, object caster, object *spell_ob)	1283	cast_destruction (object op, object caster, object *spell_ob)
1278	{	1284	{
1279	int i, j, range, mflags, friendly = 0, dam, dur;
1280	sint16 sx, sy;
1281	maptile *m;
1282	object *tmp;
1283	const char *skill;
1284
1285	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1285	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1286	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	1286	int dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1287	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1287	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1288	if (QUERY_FLAG (op, FLAG_FRIENDLY) \|\| op->type == PLAYER)	1288
1289	friendly = 1;	1289	bool friendly = op->flag [FLAG_FRIENDLY] \|\| op->is_player ();
1290		1290
1291	/* destruction doesn't use another spell object, so we need	1291	/* destruction doesn't use another spell object, so we need
1292	* update op's skill pointer so that exp is properly awarded.	1292	* update op's skill pointer so that exp is properly awarded.
1293	* We do some shortcuts here - since this is just temporary
1294	* and we'll reset the values back, we don't need to go through
1295	* the full share string/free_string route.
1296	*/	1293	*/
1297	skill = op->skill;	1294	const shstr skill = op->skill;
		1295
1298	if (caster == op)	1296	if (caster == op)
1299	op->skill = spell_ob->skill;	1297	op->skill = spell_ob->skill;
1300	else if (caster->skill)	1298	else if (caster->skill)
1301	op->skill = caster->skill;	1299	op->skill = caster->skill;
1302	else	1300	else
1303	op->skill = NULL;	1301	op->skill = 0;
1304		1302
1305	op->change_skill (find_skill_by_name (op, op->skill));	1303	op->change_skill (find_skill_by_name (op, op->skill));
1306		1304
1307	for (i = -range; i < range; i++)	1305	dynbuf buf;
		1306	unordered_mapwalk (buf, op, -range, -range, range, range)
1308	{	1307	{
1309	for (j = -range; j < range; j++)	1308	mapspace &ms = m->at (nx, ny);
1310	{
1311	m = op->map;
1312	sx = op->x + i;
1313	sy = op->y + j;
1314		1309
1315	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1316	if (mflags & P_OUT_OF_MAP)
1317	continue;
1318
1319	if (mflags & P_IS_ALIVE)	1310	if (ms.flags () & P_IS_ALIVE)
		1311	for (object next, tmp = ms.bot; tmp; tmp = next)
1320	{	1312	{
1321	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1313	next = tmp->above;
1322	if (QUERY_FLAG (tmp, FLAG_ALIVE) \|\| tmp->type == PLAYER)
1323	break;
1324		1314
1325	if (tmp)	1315	if (tmp->flag [FLAG_ALIVE] \|\| tmp->is_player ())
1326	{	1316	{
1327	if (tmp->head)
1328	tmp = tmp->head;	1317	tmp = tmp->head_ ();
1329		1318
1330	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) \|\|	1319	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1331	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) \|\| tmp->type == PLAYER)))	1320	\|\| (!friendly && (tmp->flag [FLAG_FRIENDLY] \|\| tmp->is_player ())))
1332	{	1321	{
1333	if (spell_ob->subtype == SP_DESTRUCTION)	1322	if (spell_ob->subtype == SP_DESTRUCTION)
1334	{	1323	{
1335	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1324	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
		1325
1336	if (spell_ob->other_arch)	1326	if (spell_ob->other_arch)
1337	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1327	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1338	}	1328	}
1339	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)	1329	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist [ATNR_MAGIC] != 100)
1340	{	1330	{
1341	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1331	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1342	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1332	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1343	}	1333	}
1344	}	1334	}
1345	}	1335	}
1346	}	1336	}
1347	}
1348	}	1337	}
1349		1338
1350	op->skill = skill;	1339	op->skill = skill;
1351	return 1;	1340	return 1;
1352	}	1341	}
…		…
1354	/***************************************************************************	1343	/***************************************************************************
1355	*	1344	*
1356	* CURSE	1345	* CURSE
1357	*	1346	*
1358	***************************************************************************/	1347	***************************************************************************/
1359
1360	int	1348	int
1361	cast_curse (object op, object caster, object *spell_ob, int dir)	1349	cast_curse (object op, object caster, object *spell_ob, int dir)
1362	{	1350	{
1363	object *god = find_god (determine_god (op));	1351	object *god = find_god (determine_god (op));
1364	object tmp, force;	1352	object tmp, force;
…		…
1442	force->stats.wc = spell_ob->stats.wc;	1430	force->stats.wc = spell_ob->stats.wc;
1443		1431
1444	change_abil (tmp, force); /* Mostly to display any messages */	1432	change_abil (tmp, force); /* Mostly to display any messages */
1445	insert_ob_in_ob (force, tmp);	1433	insert_ob_in_ob (force, tmp);
1446	tmp->update_stats ();	1434	tmp->update_stats ();
		1435
1447	return 1;	1436	return 1;
1448
1449	}	1437	}
1450		1438
1451	/**********************************************************************	1439	/**********************************************************************
1452	* mood change	1440	* mood change
1453	* Arguably, this may or may not be an attack spell. But since it	1441	* Arguably, this may or may not be an attack spell. But since it
…		…
1459	*/	1447	*/
1460	int	1448	int
1461	mood_change (object op, object caster, object *spell)	1449	mood_change (object op, object caster, object *spell)
1462	{	1450	{
1463	object tmp, god, *head;	1451	object tmp, god, *head;
1464	int done_one, range, mflags, level, at, best_at;	1452	int done_one, range, level, at, best_at;
1465	sint16 x, y, nx, ny;
1466	maptile *m;
1467	const char *race;	1453	const char *race;
1468		1454
1469	/* We precompute some values here so that we don't have to keep	1455	/* We precompute some values here so that we don't have to keep
1470	* doing it over and over again.	1456	* doing it over and over again.
1471	*/	1457	*/
1472	god = find_god (determine_god (op));	1458	god = find_god (determine_god (op));
1473	level = caster_level (caster, spell);	1459	level = casting_level (caster, spell);
1474	range = spell->range + SP_level_range_adjust (caster, spell);	1460	range = spell->range + SP_level_range_adjust (caster, spell);
1475		1461
1476	/* On the bright side, no monster should ever have a race of GOD_...	1462	/* On the bright side, no monster should ever have a race of GOD_...
1477	* so even if the player doesn't worship a god, if race=GOD_.., it	1463	* so even if the player doesn't worship a god, if race=GOD_.., it
1478	* won't ever match anything.	1464	* won't ever match anything.
1479	*/	1465	*/
1480	if (!spell->race)	1466	if (!spell->race)
1481	race = NULL;	1467	race = NULL;
1482	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1468	else if (god && spell->race == shstr_GOD_SLAYING)
1483	race = god->slaying;	1469	race = god->slaying;
1484	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1470	else if (god && spell->race == shstr_GOD_FRIEND)
1485	race = god->race;	1471	race = god->race;
1486	else	1472	else
1487	race = spell->race;	1473	race = spell->race;
1488		1474
1489	for (x = op->x - range; x <= op->x + range; x++)	1475	dynbuf buf;
1490	for (y = op->y - range; y <= op->y + range; y++)	1476	unordered_mapwalk (buf, op, -range, -range, range, range)
1491	{	1477	{
1492	done_one = 0;	1478	mapspace &ms = m->at (nx, ny);
1493	m = op->map;
1494	nx = x;
1495	ny = y;
1496	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1497	if (mflags & P_OUT_OF_MAP)
1498	continue;
1499		1479
1500	/* If there is nothing living on this space, no need to go further */	1480	/* If there is nothing living on this space, no need to go further */
1501	if (!(mflags & P_IS_ALIVE))	1481	if (!ms.flags () & P_IS_ALIVE)
1502	continue;	1482	continue;
1503		1483
1504	// players can only affect spaces that they can actually see	1484	// players can only affect spaces that they can actually see
		1485	if (caster
1505	if (caster && caster->contr	1486	&& caster->contr
1506	&& caster->contr->visibility_at (m, nx, ny) < 70)	1487	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1507	continue;	1488	continue;
1508		1489
1509	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1490	for (tmp = ms.top; tmp; tmp = tmp->below)
1510	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1491	if (tmp->flag [FLAG_MONSTER])
1511	break;	1492	break;
1512		1493
1513	/* There can be living objects that are not monsters */	1494	/* There can be living objects that are not monsters */
1514	if (!tmp \|\| tmp->type == PLAYER)	1495	if (!tmp)
1515	continue;	1496	continue;
1516		1497
1517	/* Only the head has meaningful data, so resolve to that */	1498	/* Only the head has meaningful data, so resolve to that */
1518	if (tmp->head)
1519	head = tmp->head;	1499	head = tmp->head_ ();
1520	else
1521	head = tmp;
1522		1500
1523	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */	1501	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */
1524	if (race && head->race && !strstr (race, head->race))	1502	if (race && head->race && !strstr (race, head->race))
1525	continue;	1503	continue;
1526		1504
1527	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1505	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))
1528	continue;	1506	continue;
1529		1507
1530	/* Now do a bunch of stuff related to saving throws */	1508	/* Now do a bunch of stuff related to saving throws */
1531	best_at = -1;	1509	best_at = -1;
1532	if (spell->attacktype)	1510	if (spell->attacktype)
1533	{	1511	{
1534	for (at = 0; at < NROFATTACKS; at++)	1512	for (at = 0; at < NROFATTACKS; at++)
1535	if (spell->attacktype & (1 << at))	1513	if (spell->attacktype & (1 << at))
1536	if (best_at == -1 \|\| head->resist[at] > head->resist[best_at])	1514	if (best_at == -1 \|\| head->resist[at] > head->resist[best_at])
1537	best_at = at;	1515	best_at = at;
1538		1516
1539	if (best_at == -1)	1517	if (best_at == -1)
1540	at = 0;	1518	at = 0;
1541	else	1519	else
1542	{	1520	{
1543	if (head->resist[best_at] == 100)	1521	if (head->resist[best_at] == 100)
1544	continue;	1522	continue;
1545	else	1523	else
1546	at = head->resist[best_at] / 5;	1524	at = head->resist[best_at] / 5;
1547	}	1525	}
		1526
1548	at -= level / 5;	1527	at -= level / 5;
1549	if (did_make_save (head, head->level, at))	1528	if (did_make_save (head, head->level, at))
1550	continue;	1529	continue;
1551	}	1530	}
1552	else /* spell->attacktype */	1531	else /* spell->attacktype */
1553	{	1532	{
1554	/*	1533	/*
1555	Spell has no attacktype (charm & such), so we'll have a specific saving:	1534	Spell has no attacktype (charm & such), so we'll have a specific saving:
1556	* if spell level < monster level, no go	1535	* if spell level < monster level, no go
1557	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )	1536	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1558		1537
1559	The chance will then be in the range [20-70] percent, not too bad.	1538	The chance will then be in the range [20-70] percent, not too bad.
1560		1539
1561	This is required to fix the 'charm monster' abuse, where a player level 1 can	1540	This is required to fix the 'charm monster' abuse, where a player level 1 can
1562	charm a level 125 monster...	1541	charm a level 125 monster...
1563		1542
1564	Ryo, august 14th	1543	Ryo, august 14th
1565	*/	1544	*/
1566	if (head->level > level)	1545	if (head->level > level)
1567	continue;	1546	continue;
1568		1547
1569	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))	1548	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + min (50, 2 * (level - head->level))))
1570	/* Failed, no effect */	1549	/* Failed, no effect */
1571	continue;	1550	continue;
1572	}	1551	}
1573		1552
1574	/* Done with saving throw. Now start affecting the monster */	1553	/* Done with saving throw. Now start affecting the monster */
		1554	done_one = 0;
1575		1555
1576	/* aggravation */	1556	/* aggravation */
1577	if (QUERY_FLAG (spell, FLAG_MONSTER))	1557	if (QUERY_FLAG (spell, FLAG_MONSTER))
1578	{	1558	{
1579	CLEAR_FLAG (head, FLAG_SLEEP);	1559	CLEAR_FLAG (head, FLAG_SLEEP);
1580	remove_friendly_object (head);	1560	remove_friendly_object (head);
1581	done_one = 1;	1561	done_one = 1;
1582	head->enemy = op;	1562	head->enemy = op;
1583	}	1563	}
1584		1564
1585	/* calm monsters */	1565	/* calm monsters */
1586	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1566	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))
1587	{	1567	{
1588	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1568	SET_FLAG (head, FLAG_UNAGGRESSIVE);
1589	head->enemy = NULL;	1569	head->enemy = NULL;
1590	done_one = 1;	1570	done_one = 1;
1591	}	1571	}
1592		1572
1593	/* berserk monsters */	1573	/* berserk monsters */
1594	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1574	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))
1595	{	1575	{
1596	SET_FLAG (head, FLAG_BERSERK);	1576	SET_FLAG (head, FLAG_BERSERK);
1597	done_one = 1;	1577	done_one = 1;
1598	}	1578	}
1599		1579
1600	/* charm */	1580	/* charm */
1601	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1581	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
1602	{	1582	{
		1583	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
		1584
1603	/* Prevent uncontolled outbreaks of self replicating monsters.	1585	/* Prevent uncontrolled outbreaks of self replicating monsters.
1604	Typical use case is charm, go somwhere, use aggravation to make hostile.	1586	Typical use case is charm, go somwhere, use aggravation to make hostile.
1605	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */	1587	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1606	CLEAR_FLAG (head, FLAG_GENERATOR);	1588	CLEAR_FLAG (head, FLAG_GENERATOR);
1607	head->set_owner (op);	1589	head->set_owner (op);
1608	set_spell_skill (op, caster, spell, head);	1590	set_spell_skill (op, caster, spell, head);
1609	add_friendly_object (head);	1591	add_friendly_object (head);
1610	head->attack_movement = PETMOVE;	1592	head->attack_movement = PETMOVE;
1611	done_one = 1;	1593	done_one = 1;
1612	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1594	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1613	head->stats.exp = 0;	1595	head->stats.exp = 0;
1614	}	1596	}
1615		1597
1616	/* If a monster was effected, put an effect in */	1598	/* If a monster was effected, put an effect in */
1617	if (done_one && spell->other_arch)	1599	if (done_one && spell->other_arch)
1618	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1600	m->insert (spell->other_arch->instance (), nx, ny, op);
1619	} /* for y */	1601	}
1620		1602
1621	return 1;	1603	return 1;
1622	}	1604	}
1623
1624		1605
1625	/* Move_ball_spell: This handles ball type spells that just sort of wander	1606	/* Move_ball_spell: This handles ball type spells that just sort of wander
1626	* about. was called move_ball_lightning, but since more than the ball	1607	* about. was called move_ball_lightning, but since more than the ball
1627	* lightning spell used it, that seemed misnamed.	1608	* lightning spell used it, that seemed misnamed.
1628	* op is the spell effect.	1609	* op is the spell effect.
1629	* note that duration is handled by process_object() in time.c	1610	* note that duration is handled by process_object() in time.c
1630	*/	1611	*/
1631
1632	void	1612	void
1633	move_ball_spell (object *op)	1613	move_ball_spell (object *op)
1634	{	1614	{
1635	int i, j, dam_save, dir, mflags;	1615	int i, j, dam_save, dir, mflags;
1636	sint16 nx, ny, hx, hy;	1616	sint16 nx, ny, hx, hy;
…		…
1655	for (i = 1; i < 9; i++)	1635	for (i = 1; i < 9; i++)
1656	{	1636	{
1657	/* i bit 0: alters sign of offset	1637	/* i bit 0: alters sign of offset
1658	* other bits (i / 2): absolute value of offset	1638	* other bits (i / 2): absolute value of offset
1659	*/	1639	*/
1660
1661	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);	1640	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1662	int tmpdir = absdir (op->direction + offset);	1641	int tmpdir = absdir (op->direction + offset);
1663		1642
1664	nx = op->x + freearr_x[tmpdir];	1643	nx = op->x + freearr_x[tmpdir];
1665	ny = op->y + freearr_y[tmpdir];	1644	ny = op->y + freearr_y[tmpdir];
…		…
1667	{	1646	{
1668	dir = tmpdir;	1647	dir = tmpdir;
1669	break;	1648	break;
1670	}	1649	}
1671	}	1650	}
		1651
1672	if (dir == 0)	1652	if (dir == 0)
1673	{	1653	{
1674	nx = op->x;	1654	nx = op->x;
1675	ny = op->y;	1655	ny = op->y;
1676	m = op->map;	1656	m = op->map;
…		…
1702		1682
1703	if ((mflags & P_IS_ALIVE) && (!owner \|\| owner->x != hx \|\| owner->y != hy \|\| !on_same_map (owner, op)))	1683	if ((mflags & P_IS_ALIVE) && (!owner \|\| owner->x != hx \|\| owner->y != hy \|\| !on_same_map (owner, op)))
1704	{	1684	{
1705	if (j)	1685	if (j)
1706	op->stats.dam = dam_save / 2;	1686	op->stats.dam = dam_save / 2;
		1687
1707	hit_map (op, j, op->attacktype, 1);	1688	hit_map (op, j, op->attacktype, 1);
1708
1709	}	1689	}
1710		1690
1711	/* insert the other arch */	1691	/* insert the other arch */
1712	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))	1692	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1713	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1693	m->insert (op->other_arch->instance (), hx, hy, op);
1714	}	1694	}
1715		1695
1716	/* restore to the center location and damage */	1696	/* restore to the center location and damage */
1717	op->stats.dam = dam_save;	1697	op->stats.dam = dam_save;
1718		1698
…		…
1727		1707
1728	op->direction = i;	1708	op->direction = i;
1729	}	1709	}
1730	}	1710	}
1731		1711
1732
1733	/* move_swarm_spell: peterm	1712	/* move_swarm_spell: peterm
1734	* This is an implementation of the swarm spell. It was written for	1713	* This is an implementation of the swarm spell. It was written for
1735	* meteor swarm, but it could be used for any swarm. A swarm spell	1714	* meteor swarm, but it could be used for any swarm. A swarm spell
1736	* is a special type of object that casts swarms of other types	1715	* is a special type of object that casts swarms of other types
1737	* of spells. Which spell it casts is flexible. It fires the spells	1716	* of spells. Which spell it casts is flexible. It fires the spells
1738	* from a set of squares surrounding the caster, in a given direction.	1717	* from a set of squares surrounding the caster, in a given direction.
1739	*/	1718	*/
1740
1741	void	1719	void
1742	move_swarm_spell (object *op)	1720	move_swarm_spell (object *op)
1743	{	1721	{
1744	#if 0	1722	#if 0
1745	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };	1723	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1746	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };	1724	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1747	sint16 target_x, target_y, origin_x, origin_y;	1725	sint16 target_x, target_y, origin_x, origin_y;
1748	int adjustdir;	1726	int adjustdir;
1749	maptile *m;	1727	maptile *m;
1750	#endif	1728	#endif
1751	int basedir;
1752	object *owner;	1729	object *owner = op->env;
1753		1730
1754	owner = op->owner;	1731	if (!owner) // MUST not happen, remove when true TODO
1755	if (op->duration == 0 \|\| owner == NULL)
1756	{	1732	{
		1733	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1757	op->destroy ();	1734	op->destroy ();
1758	return;	1735	return;
1759	}	1736	}
1760		1737
		1738	if (!op->duration \|\| !owner->is_on_map ())
		1739	{
		1740	op->drop_and_destroy ();
		1741	return;
		1742	}
		1743
1761	op->duration--;	1744	op->duration--;
1762		1745
1763	basedir = op->direction;	1746	int basedir = op->direction;
1764	if (basedir == 0)	1747	if (!basedir)
1765	{	1748	{
1766	/* spray in all directions! 8) */	1749	/* spray in all directions! 8) */
1767	basedir = rndm (1, 8);	1750	op->facing = (op->facing + op->state) & 7;
		1751	basedir = op->facing + 1;
1768	}	1752	}
1769		1753
1770	#if 0	1754	#if 0
1771	// this is bogus: it causes wrong places to be checked below	1755	// this is bogus: it causes wrong places to be checked below
1772	// (a wall 2 cells away will block the effect...) and	1756	// (a wall 2 cells away will block the effect...) and
…		…
1833	{	1817	{
1834	/* Bullet spells have a bunch more customization that needs to be done */	1818	/* Bullet spells have a bunch more customization that needs to be done */
1835	if (op->spell->subtype == SP_BULLET)	1819	if (op->spell->subtype == SP_BULLET)
1836	fire_bullet (owner, op, basedir, op->spell);	1820	fire_bullet (owner, op, basedir, op->spell);
1837	else if (op->spell->subtype == SP_MAGIC_MISSILE)	1821	else if (op->spell->subtype == SP_MAGIC_MISSILE)
1838	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);	1822	fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1839	}	1823	}
1840	}	1824	}
1841
1842
1843
1844		1825
1845	/* fire_swarm:	1826	/* fire_swarm:
1846	* The following routine creates a swarm of objects. It actually	1827	* The following routine creates a swarm of objects. It actually
1847	* sets up a specific swarm object, which then fires off all	1828	* sets up a specific swarm object, which then fires off all
1848	* the parts of the swarm.	1829	* the parts of the swarm.
…		…
1851	* caster: the caster (owner, wand, rod, scroll)	1832	* caster: the caster (owner, wand, rod, scroll)
1852	* dir: the direction everything will be fired in	1833	* dir: the direction everything will be fired in
1853	* spell - the spell that is this spell.	1834	* spell - the spell that is this spell.
1854	* n: the number to be fired.	1835	* n: the number to be fired.
1855	*/	1836	*/
1856
1857	int	1837	int
1858	fire_swarm (object op, object caster, object *spell, int dir)	1838	fire_swarm (object op, object caster, object *spell, int dir)
1859	{	1839	{
1860	object *tmp;
1861	int i;
1862
1863	if (!spell->other_arch)	1840	if (!spell->other_arch)
1864	return 0;	1841	return 0;
1865		1842
1866	tmp = get_archetype (SWARM_SPELL);	1843	object *tmp = archetype::get (SWARM_SPELL);
1867	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */	1844
1868	set_spell_skill (op, caster, spell, tmp);	1845	set_spell_skill (op, caster, spell, tmp);
1869
1870	tmp->level = caster_level (caster, spell); /needed later, to get level dep. right. /	1846	tmp->level = casting_level (caster, spell); /* needed later, to get level dep. right. */
1871	tmp->spell = arch_to_object (spell->other_arch);	1847	tmp->spell = spell->other_arch->instance ();
1872
1873	tmp->attacktype = tmp->spell->attacktype;	1848	tmp->attacktype = tmp->spell->attacktype;
1874		1849
1875	if (tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER)	1850	if (tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER)
1876	if (!tailor_god_spell (tmp, op))	1851	if (!tailor_god_spell (tmp, op))
1877	return 1;	1852	return 1;
1878		1853
1879	tmp->duration = SP_level_duration_adjust (caster, spell);	1854	tmp->duration = SP_level_duration_adjust (caster, spell);
1880	for (i = 0; i < spell->duration; i++)	1855	for (int i = 0; i < spell->duration; i++)
1881	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1856	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1882		1857
		1858	tmp->invisible = 1;
		1859	tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1883	tmp->direction = dir;	1860	tmp->direction = dir;
1884	tmp->invisible = 1;	1861	tmp->facing = rndm (1, 8); // initial firing direction
		1862	tmp->state = rndm (4) * 2 + 1; // direction increment
1885		1863
1886	tmp->insert_at (op, op);	1864	op->insert (tmp);
		1865
1887	return 1;	1866	return 1;
1888	}	1867	}
1889
1890		1868
1891	/* See the spells documentation file for why this is its own	1869	/* See the spells documentation file for why this is its own
1892	* function.	1870	* function.
1893	*/	1871	*/
1894	int	1872	int
…		…
1899	int dam, mflags;	1877	int dam, mflags;
1900	maptile *m;	1878	maptile *m;
1901		1879
1902	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1880	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1903		1881
1904	if (!dir)	1882	if (dir)
1905	{
1906	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1907	return 0;
1908	}	1883	{
1909
1910	x = op->x + freearr_x[dir];	1884	x = op->x + freearr_x[dir];
1911	y = op->y + freearr_y[dir];	1885	y = op->y + freearr_y[dir];
1912	m = op->map;	1886	m = op->map;
1913		1887
1914	mflags = get_map_flags (m, &m, x, y, &x, &y);	1888	mflags = get_map_flags (m, &m, x, y, &x, &y);
1915		1889
1916	if (mflags & P_OUT_OF_MAP)	1890	if (mflags & P_OUT_OF_MAP)
1917	{	1891	{
1918	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1892	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
1919	return 0;	1893	return 0;
1920	}	1894	}
1921		1895
1922	if (mflags & P_IS_ALIVE && spell->attacktype)	1896	if (mflags & P_IS_ALIVE && spell->attacktype)
1923	{	1897	{
1924	for (target = GET_MAP_OB (m, x, y); target; target = target->above)	1898	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1925	if (QUERY_FLAG (target, FLAG_MONSTER))	1899	if (QUERY_FLAG (target, FLAG_MONSTER))
1926	{	1900	{
1927	/* oky doky. got a target monster. Lets make a blinding attack */	1901	/* oky doky. got a target monster. Lets make a blinding attack */
1928	if (target->head)	1902	if (target->head)
1929	target = target->head;	1903	target = target->head;
		1904
1930	(void) hit_player (target, dam, op, spell->attacktype, 1);	1905	hit_player (target, dam, op, spell->attacktype, 1);
1931	return 1; /* one success only! */	1906	return 1; /* one success only! */
		1907	}
1932	}	1908	}
1933	}
1934		1909
1935	/* no live target, perhaps a wall is in the way? */	1910	/* no live target, perhaps a wall is in the way? */
1936	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))	1911	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
1937	{	1912	{
1938	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1913	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1939	return 0;	1914	return 0;
		1915	}
1940	}	1916	}
1941		1917
1942	/* ok, looks groovy to just insert a new light on the map */	1918	/* ok, looks groovy to just insert a new light on the map */
1943	tmp = arch_to_object (spell->other_arch);	1919	tmp = spell->other_arch->instance ();
1944	if (!tmp)	1920	if (!tmp)
1945	{	1921	{
1946	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1922	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1947	return 0;	1923	return 0;
1948	}	1924	}
		1925
1949	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1926	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
		1927
1950	if (tmp->glow_radius)	1928	if (tmp->glow_radius)
1951	{	1929	tmp->set_glow_radius (
1952	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);	1930	clamp (spell->range + SP_level_range_adjust (caster, spell), 1, MAX_LIGHT_RADIUS)
1953	if (tmp->glow_radius > MAX_LIGHT_RADII)	1931	);
1954	tmp->glow_radius = MAX_LIGHT_RADII;
1955	}
1956		1932
		1933	if (dir)
1957	m->insert (tmp, x, y, op);	1934	m->insert (tmp, x, y, op);
		1935	else
		1936	caster->outer_env_or_self ()->insert (tmp);
		1937
1958	return 1;	1938	return 1;
1959	}	1939	}
1960		1940
1961	/* cast_cause_disease: this spell looks along <dir> from the	1941	/* cast_cause_disease: this spell looks along <dir> from the
1962	* player and infects someone.	1942	* player and infects someone.
…		…
2010	{	1990	{
2011	/* search this square for a victim */	1991	/* search this square for a victim */
2012	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)	1992	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
2013	if (QUERY_FLAG (walk, FLAG_MONSTER) \|\| (walk->type == PLAYER))	1993	if (QUERY_FLAG (walk, FLAG_MONSTER) \|\| (walk->type == PLAYER))
2014	{ /* found a victim */	1994	{ /* found a victim */
2015	object *disease = arch_to_object (spell->other_arch);	1995	object *disease = spell->other_arch->instance ();
2016		1996
2017	disease->set_owner (op);	1997	disease->set_owner (op);
2018	set_spell_skill (op, caster, spell, disease);	1998	set_spell_skill (op, caster, spell, disease);
2019	disease->stats.exp = 0;	1999	disease->stats.exp = 0;
2020	disease->level = caster_level (caster, spell);	2000	disease->level = casting_level (caster, spell);
2021		2001
2022	/* do level adjustments */	2002	/* do level adjustments */
2023	if (disease->stats.wc)	2003	if (disease->stats.wc)
2024	disease->stats.wc += dur_mod / 2;	2004	disease->stats.wc += dur_mod / 2;
2025		2005
…		…
2070	if (infect_object (walk, disease, 1))	2050	if (infect_object (walk, disease, 1))
2071	{	2051	{
2072	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);	2052	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2073		2053
2074	disease->destroy (); /* don't need this one anymore */	2054	disease->destroy (); /* don't need this one anymore */
2075	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2055	walk->map->insert (get_archetype (shstr_detect_magic), x, y, op);
2076	return 1;	2056	return 1;
2077	}	2057	}
2078		2058
2079	disease->destroy ();	2059	disease->destroy ();
2080	}	2060	}

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.53 by root, Tue Apr 22 07:01:47 2008 UTC vs. Revision 1.96 by root, Sun Feb 7 04:22:33 2010 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.53 by root, Tue Apr 22 07:01:47 2008 UTC vs.
Revision 1.96 by root, Sun Feb 7 04:22:33 2010 UTC