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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.48 by root, Fri Aug 24 01:41:02 2007 UTC vs.
Revision 1.95 by elmex, Tue Jan 19 16:13:05 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.48 by root, Fri Aug 24 01:41:02 2007 UTC vs. Revision 1.95 by elmex, Tue Jan 19 16:13:05 2010 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.48 by root, Fri Aug 24 01:41:02 2007 UTC vs.
Revision 1.95 by elmex, Tue Jan 19 16:13:05 2010 UTC