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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.58 by root, Sat May 17 14:57:23 2008 UTC vs.
Revision 1.110 by root, Fri Jan 27 22:00:40 2012 UTC

…		…
1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002-2003 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/* This file contains all the spell attack code. Grouping this code	25	/* This file contains all the spell attack code. Grouping this code
36	/* this function checks to see if a spell pushes objects as well	37	/* this function checks to see if a spell pushes objects as well
37	* as flies over and damages them (only used for cones for now)	38	* as flies over and damages them (only used for cones for now)
38	* but moved here so it could be applied to bolts too	39	* but moved here so it could be applied to bolts too
39	* op is the spell object.	40	* op is the spell object.
40	*/	41	*/
41	void	42	static void
42	check_spell_knockback (object *op)	43	check_spell_knockback (object *op)
43	{	44	{
44	int weight_move;	45	int weight_move;
45	int frictionmod = 2; /poor man's physics - multipy targets weight by this amount /	46	int frictionmod = 2; /poor man's physics - multipy targets weight by this amount /
46		47
…		…
58	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)	59	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
59	{	60	{
60	int num_sections = 1;	61	int num_sections = 1;
61		62
62	/* don't move DM */	63	/* don't move DM */
63	if (QUERY_FLAG (tmp, FLAG_WIZ))	64	if (tmp->flag [FLAG_WIZ])
64	return;	65	return;
65		66
66	/* don't move parts of objects */	67	/* don't move parts of objects */
67	if (tmp->head)	68	if (tmp->head)
68	continue;	69	continue;
69		70
70	/* don't move floors or immobile objects */	71	/* don't move floors or immobile objects */
71	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) \|\| (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))	72	if (tmp->flag [FLAG_IS_FLOOR] \|\| (!tmp->flag [FLAG_ALIVE] && tmp->flag [FLAG_NO_PICK]))
72	continue;	73	continue;
73		74
74	/* count the object's sections */	75	/* count the object's sections */
75	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)	76	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
76	num_sections++;	77	num_sections++;
…		…
92	* also be safe for objects.	93	* also be safe for objects.
93	* This does return if successful or not, but	94	* This does return if successful or not, but
94	* I don't see us doing anything useful with that information	95	* I don't see us doing anything useful with that information
95	* right now.	96	* right now.
96	*/	97	*/
97	move_object (tmp, absdir (op->stats.sp));	98	tmp->move (absdir (op->stats.sp));
98	}	99	}
99		100
100	}	101	}
101	}	102	}
102		103
…		…
107	***************************************************************************/	108	***************************************************************************/
108		109
109	/* Causes op to fork. op is the original bolt, tmp	110	/* Causes op to fork. op is the original bolt, tmp
110	* is the first piece of the fork.	111	* is the first piece of the fork.
111	*/	112	*/
112	void	113	static void
113	forklightning (object op, object tmp)	114	forklightning (object op, object tmp)
114	{	115	{
115	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */	116	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
116	int t_dir; /* stores temporary dir calculation */	117	int t_dir; /* stores temporary dir calculation */
117	maptile *m;	118	maptile *m;
…		…
148	new_bolt->duration++;	149	new_bolt->duration++;
149	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */	150	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
150	new_bolt->stats.dam++;	151	new_bolt->stats.dam++;
151	tmp->stats.dam /= 2; /* reduce father bolt damage */	152	tmp->stats.dam /= 2; /* reduce father bolt damage */
152	tmp->stats.dam++;	153	tmp->stats.dam++;
		154
153	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))	155	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
154	update_turn_face (new_bolt);	156	update_turn_face (new_bolt);
155	}	157	}
156		158
157	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,	159	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
…		…
164	sint16 x, y;	166	sint16 x, y;
165	maptile *m;	167	maptile *m;
166		168
167	if (--op->duration < 0)	169	if (--op->duration < 0)
168	{	170	{
169	op->destroy ();	171	op->drop_and_destroy ();
170	return;	172	return;
171	}	173	}
172		174
173	hit_map (op, 0, op->attacktype, 1);	175	hit_map (op, 0, op->attacktype, 1);
174		176
…		…
192	* on the space. So only call reflwall if we think the data it returns	194	* on the space. So only call reflwall if we think the data it returns
193	* will be useful.	195	* will be useful.
194	*/	196	*/
195	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) \|\| ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))	197	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) \|\| ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))
196	{	198	{
197	if (!QUERY_FLAG (op, FLAG_REFLECTING))	199	if (!op->flag [FLAG_REFLECTING])
198	return;	200	return;
199		201
200	/* Since walls don't run diagonal, if the bolt is in	202	/* Since walls don't run diagonal, if the bolt is in
201	* one of 4 main directions, it just reflects back in the	203	* one of 4 main directions, it just reflects back in the
202	* opposite direction. However, if the bolt is travelling	204	* opposite direction. However, if the bolt is travelling
…		…
275	int mflags;	277	int mflags;
276		278
277	if (!spob->other_arch)	279	if (!spob->other_arch)
278	return 0;	280	return 0;
279		281
280	tmp = arch_to_object (spob->other_arch);	282	tmp = spob->other_arch->instance ();
281	if (tmp == NULL)	283	if (tmp == NULL)
282	return 0;	284	return 0;
283		285
284	/* peterm: level dependency for bolts */	286	/* peterm: level dependency for bolts */
285	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->duration = spob->duration + SP_level_duration_adjust (caster, spob);	294	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
293	tmp->stats.Dex = spob->stats.Dex;	295	tmp->stats.Dex = spob->stats.Dex;
294	tmp->stats.Con = spob->stats.Con;	296	tmp->stats.Con = spob->stats.Con;
295		297
296	tmp->direction = dir;	298	tmp->direction = dir;
297	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	299	if (tmp->flag [FLAG_IS_TURNABLE])
298	SET_ANIMATION (tmp, dir);	300	SET_ANIMATION (tmp, dir);
299		301
300	tmp->set_owner (op);	302	tmp->set_owner (op);
301	set_spell_skill (op, caster, spob, tmp);	303	set_spell_skill (op, caster, spob, tmp);
302		304
…		…
306		308
307	maptile *newmap;	309	maptile *newmap;
308	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);
309	if (mflags & P_OUT_OF_MAP)	311	if (mflags & P_OUT_OF_MAP)
310	{	312	{
311	tmp->destroy ();	313	tmp->drop_and_destroy ();
312	return 0;	314	return 0;
313	}	315	}
314		316
315	tmp->map = newmap;	317	tmp->map = newmap;
316		318
317	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)))
318	{	320	{
319	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	321	if (!tmp->flag [FLAG_REFLECTING])
320	{	322	{
321	tmp->destroy ();	323	tmp->drop_and_destroy ();
322	return 0;	324	return 0;
323	}	325	}
324		326
325	tmp->x = op->x;	327	tmp->x = op->x;
326	tmp->y = op->y;	328	tmp->y = op->y;
…		…
387		389
388	/* Causes an object to explode, eg, a firebullet,	390	/* Causes an object to explode, eg, a firebullet,
389	* poison cloud ball, etc. op is the object to	391	* poison cloud ball, etc. op is the object to
390	* explode.	392	* explode.
391	*/	393	*/
392	void	394	static void
393	explode_bullet (object *op)	395	explode_bullet (object *op)
394	{	396	{
395	object tmp, owner;	397	object tmp, owner;
396		398
397	if (op->other_arch == NULL)	399	if (!op->other_arch)
398	{	400	{
399	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	401	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
400	op->destroy ();	402	op->destroy ();
401	return;	403	return;
402	}	404	}
…		…
437	if (op->destroyed ())	439	if (op->destroyed ())
438	return;	440	return;
439	}	441	}
440		442
441	/* other_arch contains what this explodes into */	443	/* other_arch contains what this explodes into */
442	tmp = arch_to_object (op->other_arch);	444	tmp = op->other_arch->instance ();
443		445
444	tmp->set_owner (op);	446	tmp->set_owner (op);
445	tmp->skill = op->skill;	447	tmp->skill = op->skill;
446		448
447	owner = op->owner;	449	owner = op->owner;
448		450
449	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))
450	{	455	{
451	op->destroy ();	456	op->destroy ();
452	return;	457	return;
453	}	458	}
454		459
…		…
516	if (!(mflags & P_IS_ALIVE))	521	if (!(mflags & P_IS_ALIVE))
517	return;	522	return;
518		523
519	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	524	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
520	{	525	{
521	if (QUERY_FLAG (tmp, FLAG_ALIVE))	526	if (tmp->flag [FLAG_ALIVE])
522	{	527	{
523	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	528	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
524		529
		530	// TODO: can't understand the following if's
525	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)	531	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)
526	{	532	{
527	if (!QUERY_FLAG (op, FLAG_REMOVED))	533	if (!op->flag [FLAG_REMOVED])
528	{	534	{
529	op->destroy ();	535	op->destroy ();
530	return;	536	return;
531	}	537	}
532	}	538	}
…		…
540	* fired arches (eg, bolts).	546	* fired arches (eg, bolts).
541	*/	547	*/
542	void	548	void
543	move_bullet (object *op)	549	move_bullet (object *op)
544	{	550	{
545	sint16 new_x, new_y;
546	int mflags;
547	maptile *m;
548
549	#if 0	551	#if 0
550	/* We need a better general purpose way to do this */	552	/* We need a better general purpose way to do this */
551		553
552	/* peterm: added to make comet leave a trail of burnouts	554	/* peterm: added to make comet leave a trail of burnouts
553	it's an unadulterated hack, but the effect is cool. */	555	it's an unadulterated hack, but the effect is cool. */
…		…
568	op->destroy ();	570	op->destroy ();
569		571
570	return;	572	return;
571	}	573	}
572		574
573	new_x = op->x + DIRX (op);	575	mapxy pos (op);
574	new_y = op->y + DIRY (op);	576	pos.move (op->direction);
575	m = op->map;
576	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
577		577
578	if (mflags & P_OUT_OF_MAP)	578	if (!pos.normalise ())
579	{	579	{
580	op->destroy ();	580	op->destroy ();
581	return;	581	return;
582	}	582	}
583		583
584	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))
585	{	589	{
586	if (op->other_arch)	590	if (op->other_arch)
587	explode_bullet (op);	591	explode_bullet (op);
588	else	592	else
589	op->destroy ();	593	op->destroy ();
590		594
591	return;	595	return;
592	}	596	}
593		597
594	if (!(op = m->insert (op, new_x, new_y, op)))	598	if (!(op = pos.insert (op, op)))
595	return;	599	return;
596		600
597	if (reflwall (op->map, op->x, op->y, op))	601	if (reflwall (op->map, op->x, op->y, op))
598	{	602	{
599	op->direction = absdir (op->direction + 4);	603	op->direction = absdir (op->direction + 4);
…		…
636	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);	640	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
637	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);	641	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
638	tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);	642	tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);
639		643
640	tmp->direction = dir;	644	tmp->direction = dir;
641	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	645	if (tmp->flag [FLAG_IS_TURNABLE])
642	SET_ANIMATION (tmp, dir);	646	SET_ANIMATION (tmp, dir);
643		647
644	tmp->set_owner (op);	648	tmp->set_owner (op);
645	set_spell_skill (op, caster, spob, tmp);	649	set_spell_skill (op, caster, spob, tmp);
646		650
…		…
656	return 0;	660	return 0;
657	}	661	}
658		662
659	tmp->map = newmap;	663	tmp->map = newmap;
660		664
		665	// in case the bullet has direction 0 we explode it in place.
		666	// direction 0 is possible for instance when a poison cloud trap springs.
		667	if (tmp->direction == 0)
		668	{
		669	if (tmp->other_arch
		670	&& (tmp = tmp->insert_at (tmp, op))) // insert before explode cleanly
		671	explode_bullet (tmp); // explode object will/should remove tmp
		672	else
		673	tmp->destroy ();
		674
		675	return 0;
		676	}
		677
661	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)))
662	{	679	{
663	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	680	if (!tmp->flag [FLAG_REFLECTING])
664	{	681	{
665	tmp->destroy ();	682	tmp->destroy ();
666	return 0;	683	return 0;
667	}	684	}
668		685
…		…
683	* CONE RELATED FUNCTIONS	700	* CONE RELATED FUNCTIONS
684	*	701	*
685	*****************************************************************************/	702	*****************************************************************************/
686		703
687	/* 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" */
688	void	705	static void
689	cone_drop (object *op)	706	cone_drop (object *op)
690	{	707	{
691	object *new_ob = arch_to_object (op->other_arch);	708	object *new_ob = op->other_arch->instance ();
692		709
693	new_ob->level = op->level;	710	new_ob->level = op->level;
694	new_ob->set_owner (op->owner);	711	new_ob->set_owner (op->owner);
695		712
696	/* preserve skill ownership */	713	/* preserve skill ownership */
…		…
712	op->set_speed (0);	729	op->set_speed (0);
713	return;	730	return;
714	}	731	}
715		732
716	/* lava saves it's life, but not yours :) */	733	/* lava saves it's life, but not yours :) */
717	if (QUERY_FLAG (op, FLAG_LIFESAVE))	734	if (op->flag [FLAG_LIFESAVE])
718	{	735	{
719	hit_map (op, 0, op->attacktype, 0);	736	hit_map (op, 0, op->attacktype, 0);
720	return;	737	return;
721	}	738	}
722		739
…		…
732	}	749	}
733	#endif	750	#endif
734		751
735	hit_map (op, 0, op->attacktype, 0);	752	hit_map (op, 0, op->attacktype, 0);
736		753
		754	if (!op->is_on_map ())
		755	return;
		756
737	/* Check to see if we should push anything.	757	/* Check to see if we should push anything.
738	* Spell objects with weight push whatever they encounter to some	758	* Spell objects with weight push whatever they encounter to some
739	* degree.	759	* degree.
740	*/	760	*/
741	if (op->weight)	761	if (op->weight)
		762	{
742	check_spell_knockback (op);	763	check_spell_knockback (op);
743		764
744	if (op->destroyed ())	765	if (!op->is_on_map ())
745	return;	766	return;
		767	}
746		768
747	if ((op->duration--) < 0)	769	if (op->duration-- < 0)
748	{	770	{
749	op->destroy ();	771	op->destroy ();
750	return;	772	return;
751	}	773	}
752	/* Object has hit maximum range, so don't have it move	774	/* Object has hit maximum range, so don't have it move
…		…
798	MoveType movetype;	820	MoveType movetype;
799		821
800	if (!spell->other_arch)	822	if (!spell->other_arch)
801	return 0;	823	return 0;
802		824
803	if (op->type == PLAYER && QUERY_FLAG (op, FLAG_UNDEAD) && op->attacktype & AT_TURN_UNDEAD)	825	if (op->type == PLAYER && op->flag [FLAG_UNDEAD] && op->attacktype & AT_TURN_UNDEAD)
804	{	826	{
805	new_draw_info (NDI_UNIQUE, 0, op, "Your undead nature prevents you from turning undead!");	827	op->failmsg ("Your undead nature prevents you from turning undead!");
806	return 0;	828	return 0;
807	}	829	}
808		830
809	if (!dir)	831	if (!dir)
810	{	832	{
…		…
818	*/	840	*/
819	movetype = spell->other_arch->move_type;	841	movetype = spell->other_arch->move_type;
820		842
821	for (i = range_min; i <= range_max; i++)	843	for (i = range_min; i <= range_max; i++)
822	{	844	{
823	sint16 x, y, d;	845	sint16 x, y;
824		846
825	/* We can't use absdir here, because it never returns	847	/* We can't use absdir here, because it never returns
826	* 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
827	* 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
828	* to hit that person.	850	* to hit that person.
829	*/	851	*/
830	d = dir + i;	852	int d = dir ? absdir (dir + i) : i;
831	while (d < 0)
832	d += 8;
833	while (d > 8)
834	d -= 8;
835		853
836	/* 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.
837	* In that case, we have to see - if dir is specified,	855	* In that case, we have to see - if dir is specified,
838	* turn this into direction 8. If dir is not specified (all	856	* turn this into direction 8. If dir is not specified (all
839	* direction) skip - otherwise, one line would do more damage	857	* direction) skip - otherwise, one line would do more damage
…		…
856		874
857	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	875	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
858	continue;	876	continue;
859		877
860	success = 1;	878	success = 1;
861	tmp = arch_to_object (spell->other_arch);	879	tmp = spell->other_arch->instance ();
862	tmp->set_owner (op);	880	tmp->set_owner (op);
863	set_spell_skill (op, caster, spell, tmp);	881	set_spell_skill (op, caster, spell, tmp);
864	tmp->level = caster_level (caster, spell);	882	tmp->level = casting_level (caster, spell);
865	tmp->attacktype = spell->attacktype;	883	tmp->attacktype = spell->attacktype;
866		884
867	/* holy word stuff */	885	/* holy word stuff */
868	if ((tmp->attacktype & AT_HOLYWORD) \|\| (tmp->attacktype & AT_GODPOWER))	886	if ((tmp->attacktype & AT_HOLYWORD) \|\| (tmp->attacktype & AT_GODPOWER))
869	if (!tailor_god_spell (tmp, op))	887	if (!tailor_god_spell (tmp, op))
…		…
941		959
942	object *env = op->outer_env ();	960	object *env = op->outer_env ();
943		961
944	if (op->env)	962	if (op->env)
945	{	963	{
946	if (env->map == NULL)	964	if (!env->map)
947	return;	965	return;
948		966
949	if (!(op = op->insert_at (env, op)))	967	if (!(op = op->insert_at (env, op)))
950	return;	968	return;
951	}	969	}
952		970
953	// 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
954	// 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
955	// as bombs can be carried.	973	// as bombs can be carried.
956	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	974	if (op->ms ().flags () & P_SAFE)
957	{	975	{
958	op->destroy ();	976	op->destroy ();
959	return;	977	return;
960	}	978	}
961		979
…		…
968	for (int i = 1; i < 9; i++)	986	for (int i = 1; i < 9; i++)
969	{	987	{
970	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]))
971	continue;	989	continue;
972		990
973	object *tmp = arch_to_object (at);	991	object *tmp = at->instance ();
974	tmp->direction = i;	992	tmp->direction = i;
975	tmp->range = op->range;	993	tmp->range = op->range;
976	tmp->stats.dam = op->stats.dam;	994	tmp->stats.dam = op->stats.dam;
977	tmp->duration = op->duration;	995	tmp->duration = op->duration;
978	tmp->attacktype = op->attacktype;	996	tmp->attacktype = op->attacktype;
979	tmp->set_owner (op);	997	tmp->set_owner (op);
980	if (op->skill && op->skill != tmp->skill)	998	if (op->skill && op->skill != tmp->skill)
981	tmp->skill = op->skill;	999	tmp->skill = op->skill;
982		1000
983	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	1001	if (tmp->flag [FLAG_IS_TURNABLE])
984	SET_ANIMATION (tmp, i);	1002	SET_ANIMATION (tmp, i);
985		1003
986	op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);	1004	op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);
987	move_bullet (tmp);	1005	move_bullet (tmp);
988	}	1006	}
…		…
998	int mflags;	1016	int mflags;
999	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];
1000	maptile *m;	1018	maptile *m;
1001		1019
1002	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	{
1003	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))
1004	{	1029	{
1005	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1030	op->failmsg ("There is something in the way.");
1006	return 0;	1031	return 0;
		1032	}
1007	}	1033	}
1008		1034
1009	tmp = arch_to_object (spell->other_arch);	1035	tmp = spell->other_arch->instance ();
1010		1036
1011	/* level dependencies for bomb */	1037	/* level dependencies for bomb */
1012	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1038	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1013	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);
1014	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1040	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
1034	* dir is the direction to look in.	1060	* dir is the direction to look in.
1035	* range is how far out to look.	1061	* range is how far out to look.
1036	* 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.
1037	* this info is used for blocked magic/unholy spaces.	1063	* this info is used for blocked magic/unholy spaces.
1038	*/	1064	*/
1039	object *	1065	static object *
1040	get_pointed_target (object *op, int dir, int range, int type)	1066	get_pointed_target (object *op, int dir, int range, int type)
1041	{	1067	{
1042	object *target;	1068	object *target;
1043	sint16 x, y;	1069	sint16 x, y;
1044	int dist, mflags;	1070	int dist, mflags;
…		…
1063	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1089	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1064	return NULL;	1090	return NULL;
1065		1091
1066	if (mflags & P_IS_ALIVE)	1092	if (mflags & P_IS_ALIVE)
1067	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)	1093	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1068	if (QUERY_FLAG (target, FLAG_MONSTER))	1094	if (target->flag [FLAG_MONSTER])
1069	return target;	1095	return target;
1070	}	1096	}
1071		1097
1072	return NULL;	1098	return NULL;
1073	}	1099	}
…		…
1083	int	1109	int
1084	cast_smite_spell (object op, object caster, int dir, object *spell)	1110	cast_smite_spell (object op, object caster, int dir, object *spell)
1085	{	1111	{
1086	object effect, target;	1112	object effect, target;
1087	object *god = find_god (determine_god (op));	1113	object *god = find_god (determine_god (op));
1088	int range;
1089		1114
1090	range = spell->range + SP_level_range_adjust (caster, spell);
1091	target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);	1115	target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);
1092		1116
1093	/* Bunch of conditions for casting this spell. Note that only	1117	/* Bunch of conditions for casting this spell. Note that only
1094	* require a god if this is a cleric spell (requires grace).	1118	* require a god if this is a cleric spell (requires grace).
1095	* This makes this spell much more general purpose - it can be used	1119	* This makes this spell much more general purpose - it can be used
…		…
1097	* interesting spell.	1121	* interesting spell.
1098	* if it is a cleric spell, you need a god, and the creature	1122	* if it is a cleric spell, you need a god, and the creature
1099	* can't be friendly to your god.	1123	* can't be friendly to your god.
1100	*/	1124	*/
1101		1125
1102	if (!target \|\| QUERY_FLAG (target, FLAG_REFL_SPELL)	1126	if (!target
		1127	\|\| target->flag [FLAG_REFL_SPELL]
1103	\|\| (!god && spell->stats.grace)	1128	\|\| (!god && spell->stats.grace)
1104	\|\| (target->title && god && !strcmp (target->title, god->name)) \|\| (target->race && god && strstr (target->race, god->race)))	1129	\|\| (god && target->title == god->name)
		1130	\|\| (god && target->race.contains (god->race)))
1105	{	1131	{
1106	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1132	op->failmsg ("Your request is unheeded.");
1107	return 0;	1133	return 0;
1108	}	1134	}
1109		1135
1110	if (spell->other_arch)	1136	if (spell->other_arch)
1111	effect = arch_to_object (spell->other_arch);	1137	effect = spell->other_arch->instance ();
1112	else	1138	else
1113	return 0;	1139	return 0;
1114		1140
1115	/* tailor the effect by priest level and worshipped God */	1141	/* tailor the effect by priest level and worshipped God */
1116	effect->level = caster_level (caster, spell);	1142	effect->level = casting_level (caster, spell);
1117	effect->attacktype = spell->attacktype;	1143	effect->attacktype = spell->attacktype;
1118	if (effect->attacktype & (AT_HOLYWORD \| AT_GODPOWER))	1144	if (effect->attacktype & (AT_HOLYWORD \| AT_GODPOWER))
1119	{	1145	{
1120	if (tailor_god_spell (effect, op))	1146	if (tailor_god_spell (effect, op))
1121	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));	1147	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", (const char *)determine_god (op));
1122	else	1148	else
1123	{	1149	{
1124	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1150	op->failmsg ("Your request is ignored.");
1125	return 0;	1151	return 0;
1126	}	1152	}
1127	}	1153	}
1128		1154
1129	/* size of the area of destruction */	1155	/* size of the area of destruction */
…		…
1133	if (effect->attacktype & AT_DEATH)	1159	if (effect->attacktype & AT_DEATH)
1134	{	1160	{
1135	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1161	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1136		1162
1137	/* casting death spells at undead isn't a good thing */	1163	/* casting death spells at undead isn't a good thing */
1138	if (QUERY_FLAG (target, FLAG_UNDEAD))	1164	if (target->flag [FLAG_UNDEAD])
1139	{	1165	{
1140	if (random_roll (0, 2, op, PREFER_LOW))	1166	if (random_roll (0, 2, op, PREFER_LOW))
1141	{	1167	{
1142	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1168	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1143	effect->x = op->x;	1169	effect->x = op->x;
…		…
1178	void	1204	void
1179	move_missile (object *op)	1205	move_missile (object *op)
1180	{	1206	{
1181	if (op->range-- <= 0)	1207	if (op->range-- <= 0)
1182	{	1208	{
1183	op->destroy ();	1209	op->drop_and_destroy ();
1184	return;	1210	return;
1185	}	1211	}
1186		1212
1187	mapxy pos (op);	1213	mapxy pos (op);
1188	pos.move (op->direction);	1214	pos.move (op->direction);
…		…
1229	* we do this by creating a force and inserting it in the	1255	* we do this by creating a force and inserting it in the
1230	* object. if time is 0, the object glows permanently. To truely	1256	* object. if time is 0, the object glows permanently. To truely
1231	* make this work for non-living objects, we would have to	1257	* make this work for non-living objects, we would have to
1232	* give them the capability to have an inventory. b.t.	1258	* give them the capability to have an inventory. b.t.
1233	*/	1259	*/
1234	int	1260	static int
1235	make_object_glow (object *op, int radius, int time)	1261	make_object_glow (object *op, int radius, int time)
1236	{	1262	{
1237	/* some things are unaffected... */	1263	/* some things are unaffected... */
1238	if (op->path_denied & PATH_LIGHT)	1264	if (op->path_denied & PATH_LIGHT)
1239	return 0;	1265	return 0;
1240		1266
1241	object *tmp = get_archetype (FORCE_NAME);	1267	object *tmp = archetype::get (FORCE_NAME);
1242	tmp->speed = 0.01;	1268	tmp->set_speed (0.01);
1243	tmp->stats.food = time;	1269	tmp->stats.food = time;
1244	SET_FLAG (tmp, FLAG_IS_USED_UP);	1270	tmp->set_flag (FLAG_IS_USED_UP);
1245	tmp->glow_radius = radius;	1271	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1246	if (tmp->glow_radius > MAX_LIGHT_RADII)
1247	tmp->glow_radius = MAX_LIGHT_RADII;
1248
1249	tmp = insert_ob_in_ob (tmp, op);	1272	tmp = insert_ob_in_ob (tmp, op);
1250		1273
1251	if (tmp->glow_radius > op->glow_radius)	1274	if (tmp->glow_radius > op->glow_radius)
1252	op->glow_radius = tmp->glow_radius;	1275	op->set_glow_radius (tmp->glow_radius);
1253		1276
1254	return 1;	1277	return 1;
1255	}	1278	}
1256		1279
1257	int	1280	int
1258	cast_destruction (object op, object caster, object *spell_ob)	1281	cast_destruction (object op, object caster, object *spell_ob)
1259	{	1282	{
1260	int i, j, range, mflags, friendly = 0, dam, dur;
1261	sint16 sx, sy;
1262	maptile *m;
1263	object *tmp;
1264	const char *skill;
1265
1266	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1283	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1267	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	1284	int dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1268	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1285	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1269	if (QUERY_FLAG (op, FLAG_FRIENDLY) \|\| op->type == PLAYER)
1270	friendly = 1;
1271		1286
1272	/* destruction doesn't use another spell object, so we need	1287	bool friendly = op->flag [FLAG_FRIENDLY] \|\| op->is_player ();
1273	* update op's skill pointer so that exp is properly awarded.
1274	* We do some shortcuts here - since this is just temporary
1275	* and we'll reset the values back, we don't need to go through
1276	* the full share string/free_string route.
1277	*/
1278	skill = op->skill;
1279	if (caster == op)
1280	op->skill = spell_ob->skill;
1281	else if (caster->skill)
1282	op->skill = caster->skill;
1283	else
1284	op->skill = NULL;
1285		1288
1286	op->change_skill (find_skill_by_name (op, op->skill));	1289	dynbuf buf;
1287		1290	unordered_mapwalk (buf, op, -range, -range, range, range)
1288	for (i = -range; i <= range; i++)
1289	{	1291	{
1290	for (j = -range; j <= range; j++)	1292	mapspace &ms = m->at (nx, ny);
1291	{
1292	m = op->map;
1293	sx = op->x + i;
1294	sy = op->y + j;
1295		1293
1296	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1297	if (mflags & P_OUT_OF_MAP)
1298	continue;
1299
1300	if (mflags & P_IS_ALIVE)	1294	if (ms.flags () & P_IS_ALIVE)
		1295	for (object next, tmp = ms.bot; tmp; tmp = next)
1301	{	1296	{
1302	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1297	next = tmp->above;
1303	if (QUERY_FLAG (tmp, FLAG_ALIVE) \|\| tmp->type == PLAYER)
1304	break;
1305		1298
1306	if (tmp)	1299	if (tmp->flag [FLAG_ALIVE] \|\| tmp->is_player ())
1307	{	1300	{
1308	if (tmp->head)
1309	tmp = tmp->head;	1301	tmp = tmp->head_ ();
1310		1302
1311	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) \|\|	1303	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1312	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) \|\| tmp->type == PLAYER)))	1304	\|\| (!friendly && (tmp->flag [FLAG_FRIENDLY] \|\| tmp->is_player ())))
1313	{	1305	{
1314	if (spell_ob->subtype == SP_DESTRUCTION)	1306	if (spell_ob->subtype == SP_DESTRUCTION)
1315	{	1307	{
1316	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1308	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1317		1309
1318	if (spell_ob->other_arch)	1310	if (spell_ob->other_arch)
1319	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1311	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1320	}	1312	}
1321	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)	1313	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist [ATNR_MAGIC] != 100)
1322	{	1314	{
1323	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1315	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1324	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1316	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1325	}	1317	}
1326	}	1318	}
1327	}	1319	}
1328	}	1320	}
1329	}
1330	}	1321	}
1331		1322
1332	op->skill = skill;
1333	return 1;	1323	return 1;
1334	}	1324	}
1335		1325
1336	/***************************************************************************	1326	/***************************************************************************
1337	*	1327	*
1338	* CURSE	1328	* CURSE
1339	*	1329	*
1340	***************************************************************************/	1330	***************************************************************************/
1341
1342	int	1331	int
1343	cast_curse (object op, object caster, object *spell_ob, int dir)	1332	cast_curse (object op, object caster, object *spell_ob, int dir)
1344	{	1333	{
1345	object *god = find_god (determine_god (op));	1334	object *god = find_god (determine_god (op));
1346	object tmp, force;	1335	object tmp, force;
1347		1336
1348	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);	1337	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);
1349	if (!tmp)	1338	if (!tmp)
1350	{	1339	{
1351	new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");	1340	op->failmsg ("There is no one in that direction to curse.");
1352	return 0;	1341	return 0;
1353	}	1342	}
1354		1343
1355	tmp = tmp->head_ ();	1344	tmp = tmp->head_ ();
1356		1345
…		…
1371	}	1360	}
1372	}	1361	}
1373		1362
1374	if (!force)	1363	if (!force)
1375	{	1364	{
1376	force = get_archetype (FORCE_NAME);	1365	force = archetype::get (FORCE_NAME);
1377	force->subtype = FORCE_CHANGE_ABILITY;	1366	force->subtype = FORCE_CHANGE_ABILITY;
1378		1367
1379	if (spell_ob->race)	1368	if (spell_ob->race)
1380	force->name = spell_ob->race;	1369	force->name = spell_ob->race;
1381	else	1370	else
…		…
1399		1388
1400	return 1;	1389	return 1;
1401	}	1390	}
1402		1391
1403	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1392	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1404	force->speed = 1.f;
1405	force->speed_left = -1.f;	1393	force->speed_left = -1.f;
1406	SET_FLAG (force, FLAG_APPLIED);	1394	force->set_speed (1.f);
		1395	force->set_flag (FLAG_APPLIED);
1407		1396
1408	if (god)	1397	if (god)
1409	{	1398	{
1410	if (spell_ob->last_grace)	1399	if (spell_ob->last_grace)
1411	force->path_repelled = god->path_repelled;	1400	force->path_repelled = god->path_repelled;
…		…
1424	force->stats.wc = spell_ob->stats.wc;	1413	force->stats.wc = spell_ob->stats.wc;
1425		1414
1426	change_abil (tmp, force); /* Mostly to display any messages */	1415	change_abil (tmp, force); /* Mostly to display any messages */
1427	insert_ob_in_ob (force, tmp);	1416	insert_ob_in_ob (force, tmp);
1428	tmp->update_stats ();	1417	tmp->update_stats ();
		1418
1429	return 1;	1419	return 1;
1430
1431	}	1420	}
1432		1421
1433	/**********************************************************************	1422	/**********************************************************************
1434	* mood change	1423	* mood change
1435	* Arguably, this may or may not be an attack spell. But since it	1424	* Arguably, this may or may not be an attack spell. But since it
…		…
1441	*/	1430	*/
1442	int	1431	int
1443	mood_change (object op, object caster, object *spell)	1432	mood_change (object op, object caster, object *spell)
1444	{	1433	{
1445	object tmp, god, *head;	1434	object tmp, god, *head;
1446	int done_one, range, mflags, level, at, best_at;	1435	int done_one, range, level, at, best_at;
1447	sint16 x, y, nx, ny;
1448	maptile *m;
1449	const char *race;	1436	const char *race;
1450		1437
1451	/* We precompute some values here so that we don't have to keep	1438	/* We precompute some values here so that we don't have to keep
1452	* doing it over and over again.	1439	* doing it over and over again.
1453	*/	1440	*/
1454	god = find_god (determine_god (op));	1441	god = find_god (determine_god (op));
1455	level = caster_level (caster, spell);	1442	level = casting_level (caster, spell);
1456	range = spell->range + SP_level_range_adjust (caster, spell);	1443	range = spell->range + SP_level_range_adjust (caster, spell);
1457		1444
1458	/* On the bright side, no monster should ever have a race of GOD_...	1445	/* On the bright side, no monster should ever have a race of GOD_...
1459	* so even if the player doesn't worship a god, if race=GOD_.., it	1446	* so even if the player doesn't worship a god, if race=GOD_.., it
1460	* won't ever match anything.	1447	* won't ever match anything.
1461	*/	1448	*/
1462	if (!spell->race)	1449	if (!spell->race)
1463	race = NULL;	1450	race = NULL;
1464	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1451	else if (god && spell->race == shstr_GOD_SLAYING)
1465	race = god->slaying;	1452	race = god->slaying;
1466	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1453	else if (god && spell->race == shstr_GOD_FRIEND)
1467	race = god->race;	1454	race = god->race;
1468	else	1455	else
1469	race = spell->race;	1456	race = spell->race;
1470		1457
1471	for (x = op->x - range; x <= op->x + range; x++)	1458	dynbuf buf;
1472	for (y = op->y - range; y <= op->y + range; y++)	1459	unordered_mapwalk (buf, op, -range, -range, range, range)
1473	{	1460	{
1474	done_one = 0;	1461	mapspace &ms = m->at (nx, ny);
1475	m = op->map;
1476	nx = x;
1477	ny = y;
1478	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1479	if (mflags & P_OUT_OF_MAP)
1480	continue;
1481		1462
1482	/* If there is nothing living on this space, no need to go further */	1463	/* If there is nothing living on this space, no need to go further */
1483	if (!(mflags & P_IS_ALIVE))	1464	if (!(ms.flags () & P_IS_ALIVE))
1484	continue;	1465	continue;
1485		1466
1486	// players can only affect spaces that they can actually see	1467	// players can only affect spaces that they can actually see
		1468	if (caster
1487	if (caster && caster->contr	1469	&& caster->contr
1488	&& caster->contr->visibility_at (m, nx, ny) < 70)	1470	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1489	continue;	1471	continue;
1490		1472
1491	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1473	for (tmp = ms.top; tmp; tmp = tmp->below)
1492	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1474	if (tmp->flag [FLAG_MONSTER])
1493	break;	1475	break;
1494		1476
1495	/* There can be living objects that are not monsters */	1477	/* There can be living objects that are not monsters */
1496	if (!tmp \|\| tmp->type == PLAYER)	1478	if (!tmp)
1497	continue;	1479	continue;
1498		1480
1499	/* Only the head has meaningful data, so resolve to that */	1481	/* Only the head has meaningful data, so resolve to that */
1500	if (tmp->head)
1501	head = tmp->head;	1482	head = tmp->head_ ();
1502	else
1503	head = tmp;
1504		1483
1505	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */	1484	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */
1506	if (race && head->race && !strstr (race, head->race))	1485	if (race && head->race && !strstr (race, head->race))
1507	continue;	1486	continue;
1508		1487
1509	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1488	if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
1510	continue;	1489	continue;
1511		1490
1512	/* Now do a bunch of stuff related to saving throws */	1491	/* Now do a bunch of stuff related to saving throws */
1513	best_at = -1;	1492	best_at = -1;
1514	if (spell->attacktype)	1493	if (spell->attacktype)
1515	{	1494	{
1516	for (at = 0; at < NROFATTACKS; at++)	1495	for (at = 0; at < NROFATTACKS; at++)
1517	if (spell->attacktype & (1 << at))	1496	if (spell->attacktype & (1 << at))
1518	if (best_at == -1 \|\| head->resist[at] > head->resist[best_at])	1497	if (best_at == -1 \|\| head->resist[at] > head->resist[best_at])
1519	best_at = at;	1498	best_at = at;
1520		1499
1521	if (best_at == -1)	1500	if (best_at == -1)
1522	at = 0;	1501	at = 0;
1523	else	1502	else
1524	{	1503	{
1525	if (head->resist[best_at] == 100)	1504	if (head->resist[best_at] == 100)
1526	continue;	1505	continue;
1527	else	1506	else
1528	at = head->resist[best_at] / 5;	1507	at = head->resist[best_at] / 5;
1529	}	1508	}
		1509
1530	at -= level / 5;	1510	at -= level / 5;
1531	if (did_make_save (head, head->level, at))	1511	if (did_make_save (head, head->level, at))
1532	continue;	1512	continue;
1533	}	1513	}
1534	else /* spell->attacktype */	1514	else /* spell->attacktype */
1535	{	1515	{
1536	/*	1516	/*
1537	Spell has no attacktype (charm & such), so we'll have a specific saving:	1517	Spell has no attacktype (charm & such), so we'll have a specific saving:
1538	* if spell level < monster level, no go	1518	* if spell level < monster level, no go
1539	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )	1519	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1540		1520
1541	The chance will then be in the range [20-70] percent, not too bad.	1521	The chance will then be in the range [20-70] percent, not too bad.
1542		1522
1543	This is required to fix the 'charm monster' abuse, where a player level 1 can	1523	This is required to fix the 'charm monster' abuse, where a player level 1 can
1544	charm a level 125 monster...	1524	charm a level 125 monster...
1545		1525
1546	Ryo, august 14th	1526	Ryo, august 14th
1547	*/	1527	*/
1548	if (head->level > level)	1528	if (head->level > level)
1549	continue;	1529	continue;
1550		1530
1551	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))	1531	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + min (50, 2 * (level - head->level))))
1552	/* Failed, no effect */	1532	/* Failed, no effect */
1553	continue;	1533	continue;
1554	}	1534	}
1555		1535
1556	/* Done with saving throw. Now start affecting the monster */	1536	/* Done with saving throw. Now start affecting the monster */
		1537	done_one = 0;
1557		1538
1558	/* aggravation */	1539	/* aggravation */
1559	if (QUERY_FLAG (spell, FLAG_MONSTER))	1540	if (spell->flag [FLAG_MONSTER])
1560	{	1541	{
1561	CLEAR_FLAG (head, FLAG_SLEEP);	1542	head->clr_flag (FLAG_SLEEP);
1562	remove_friendly_object (head);	1543	remove_friendly_object (head);
1563	done_one = 1;	1544	done_one = 1;
1564	head->enemy = op;	1545	head->enemy = op;
1565	}	1546	}
1566		1547
1567	/* calm monsters */	1548	/* calm monsters */
1568	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1549	if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
1569	{	1550	{
1570	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1551	head->set_flag (FLAG_UNAGGRESSIVE);
1571	head->enemy = NULL;	1552	head->enemy = NULL;
1572	done_one = 1;	1553	done_one = 1;
1573	}	1554	}
1574		1555
1575	/* berserk monsters */	1556	/* berserk monsters */
1576	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1557	if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
1577	{	1558	{
1578	SET_FLAG (head, FLAG_BERSERK);	1559	head->set_flag (FLAG_BERSERK);
1579	done_one = 1;	1560	done_one = 1;
1580	}	1561	}
1581		1562
1582	/* charm */	1563	/* charm */
1583	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1564	if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
1584	{	1565	{
1585	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));	1566	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
1586		1567
1587	/* Prevent uncontrolled outbreaks of self replicating monsters.	1568	/* Prevent uncontrolled outbreaks of self replicating monsters.
1588	Typical use case is charm, go somwhere, use aggravation to make hostile.	1569	Typical use case is charm, go somwhere, use aggravation to make hostile.
1589	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */	1570	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1590	CLEAR_FLAG (head, FLAG_GENERATOR);	1571	head->clr_flag (FLAG_GENERATOR);
1591	head->set_owner (op);	1572	head->set_owner (op);
1592	set_spell_skill (op, caster, spell, head);	1573	set_spell_skill (op, caster, spell, head);
1593	add_friendly_object (head);	1574	add_friendly_object (head);
1594	head->attack_movement = PETMOVE;	1575	head->attack_movement = PETMOVE;
1595	done_one = 1;	1576	done_one = 1;
1596	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1577	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1597	head->stats.exp = 0;	1578	head->stats.exp = 0;
1598	}	1579	}
1599		1580
1600	/* If a monster was effected, put an effect in */	1581	/* If a monster was effected, put an effect in */
1601	if (done_one && spell->other_arch)	1582	if (done_one && spell->other_arch)
1602	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1583	m->insert (spell->other_arch->instance (), nx, ny, op);
1603	} /* for y */	1584	}
1604		1585
1605	return 1;	1586	return 1;
1606	}	1587	}
1607
1608		1588
1609	/* Move_ball_spell: This handles ball type spells that just sort of wander	1589	/* Move_ball_spell: This handles ball type spells that just sort of wander
1610	* about. was called move_ball_lightning, but since more than the ball	1590	* about. was called move_ball_lightning, but since more than the ball
1611	* lightning spell used it, that seemed misnamed.	1591	* lightning spell used it, that seemed misnamed.
1612	* op is the spell effect.	1592	* op is the spell effect.
1613	* note that duration is handled by process_object() in time.c	1593	* note that duration is handled by process_object() in time.c
1614	*/	1594	*/
1615
1616	void	1595	void
1617	move_ball_spell (object *op)	1596	move_ball_spell (object *op)
1618	{	1597	{
1619	int i, j, dam_save, dir, mflags;	1598	int i, j, dam_save, dir, mflags;
1620	sint16 nx, ny, hx, hy;	1599	sint16 nx, ny, hx, hy;
…		…
1639	for (i = 1; i < 9; i++)	1618	for (i = 1; i < 9; i++)
1640	{	1619	{
1641	/* i bit 0: alters sign of offset	1620	/* i bit 0: alters sign of offset
1642	* other bits (i / 2): absolute value of offset	1621	* other bits (i / 2): absolute value of offset
1643	*/	1622	*/
1644
1645	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);	1623	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1646	int tmpdir = absdir (op->direction + offset);	1624	int tmpdir = absdir (op->direction + offset);
1647		1625
1648	nx = op->x + freearr_x[tmpdir];	1626	nx = op->x + freearr_x[tmpdir];
1649	ny = op->y + freearr_y[tmpdir];	1627	ny = op->y + freearr_y[tmpdir];
…		…
1651	{	1629	{
1652	dir = tmpdir;	1630	dir = tmpdir;
1653	break;	1631	break;
1654	}	1632	}
1655	}	1633	}
		1634
1656	if (dir == 0)	1635	if (dir == 0)
1657	{	1636	{
1658	nx = op->x;	1637	nx = op->x;
1659	ny = op->y;	1638	ny = op->y;
1660	m = op->map;	1639	m = op->map;
…		…
1692	hit_map (op, j, op->attacktype, 1);	1671	hit_map (op, j, op->attacktype, 1);
1693	}	1672	}
1694		1673
1695	/* insert the other arch */	1674	/* insert the other arch */
1696	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))	1675	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1697	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1676	m->insert (op->other_arch->instance (), hx, hy, op);
1698	}	1677	}
1699		1678
1700	/* restore to the center location and damage */	1679	/* restore to the center location and damage */
1701	op->stats.dam = dam_save;	1680	op->stats.dam = dam_save;
1702		1681
…		…
1730	int adjustdir;	1709	int adjustdir;
1731	maptile *m;	1710	maptile *m;
1732	#endif	1711	#endif
1733	object *owner = op->env;	1712	object *owner = op->env;
1734		1713
		1714	if (!owner) // MUST not happen, remove when true TODO
		1715	{
		1716	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
		1717	op->destroy ();
		1718	return;
		1719	}
		1720
1735	if (!op->duration \|\| !owner->is_on_map ())	1721	if (!op->duration \|\| !owner->is_on_map ())
1736	{	1722	{
1737	op->destroy ();	1723	op->drop_and_destroy ();
1738	return;	1724	return;
1739	}	1725	}
1740		1726
1741	op->duration--;	1727	op->duration--;
1742		1728
1743	int basedir = op->direction;	1729	int basedir = op->direction;
1744	if (!basedir)	1730	if (!basedir)
		1731	{
1745	/* spray in all directions! 8) */	1732	/* spray in all directions! 8) */
1746	basedir = (op->facing += op->state) % 8 + 1;	1733	op->facing = (op->facing + op->state) & 7;
		1734	basedir = op->facing + 1;
		1735	}
1747		1736
1748	#if 0	1737	#if 0
1749	// this is bogus: it causes wrong places to be checked below	1738	// this is bogus: it causes wrong places to be checked below
1750	// (a wall 2 cells away will block the effect...) and	1739	// (a wall 2 cells away will block the effect...) and
1751	// doesn't work for SP_BULLET anyhow, so again tests the wrong	1740	// doesn't work for SP_BULLET anyhow, so again tests the wrong
…		…
1833	{	1822	{
1834	if (!spell->other_arch)	1823	if (!spell->other_arch)
1835	return 0;	1824	return 0;
1836		1825
1837	object *tmp = archetype::get (SWARM_SPELL);	1826	object *tmp = archetype::get (SWARM_SPELL);
		1827
1838	set_spell_skill (op, caster, spell, tmp);	1828	set_spell_skill (op, caster, spell, tmp);
1839	tmp->level = caster_level (caster, spell); /* needed later, to get level dep. right. */	1829	tmp->level = casting_level (caster, spell); /* needed later, to get level dep. right. */
1840	tmp->spell = spell->other_arch->instance ();	1830	tmp->spell = spell->other_arch->instance ();
1841	tmp->attacktype = tmp->spell->attacktype;	1831	tmp->attacktype = tmp->spell->attacktype;
1842		1832
1843	if (tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER)	1833	if (tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER)
1844	if (!tailor_god_spell (tmp, op))	1834	if (!tailor_god_spell (tmp, op))
…		…
1846		1836
1847	tmp->duration = SP_level_duration_adjust (caster, spell);	1837	tmp->duration = SP_level_duration_adjust (caster, spell);
1848	for (int i = 0; i < spell->duration; i++)	1838	for (int i = 0; i < spell->duration; i++)
1849	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1839	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1850		1840
		1841	tmp->invisible = 1;
		1842	tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1851	tmp->direction = dir;	1843	tmp->direction = dir;
1852	tmp->invisible = 1;
1853	tmp->facing = rndm (1, 8); // initial firing direction	1844	tmp->facing = rndm (1, 8); // initial firing direction
1854	tmp->state = rndm (4) * 2 + 1; // direction increment	1845	tmp->state = rndm (4) * 2 + 1; // direction increment
1855		1846
1856	op->insert (tmp);	1847	op->insert (tmp);
1857		1848
…		…
1869	int dam, mflags;	1860	int dam, mflags;
1870	maptile *m;	1861	maptile *m;
1871		1862
1872	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1863	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1873		1864
1874	if (!dir)	1865	if (dir)
1875	{
1876	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1877	return 0;
1878	}	1866	{
1879
1880	x = op->x + freearr_x[dir];	1867	x = op->x + freearr_x[dir];
1881	y = op->y + freearr_y[dir];	1868	y = op->y + freearr_y[dir];
1882	m = op->map;	1869	m = op->map;
1883		1870
1884	mflags = get_map_flags (m, &m, x, y, &x, &y);	1871	mflags = get_map_flags (m, &m, x, y, &x, &y);
1885		1872
1886	if (mflags & P_OUT_OF_MAP)	1873	if (mflags & P_OUT_OF_MAP)
1887	{	1874	{
1888	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1875	op->failmsg ("Nothing is there.");
1889	return 0;	1876	return 0;
1890	}	1877	}
1891		1878
1892	if (mflags & P_IS_ALIVE && spell->attacktype)	1879	if (mflags & P_IS_ALIVE && spell->attacktype)
1893	{	1880	{
1894	for (target = GET_MAP_OB (m, x, y); target; target = target->above)	1881	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1895	if (QUERY_FLAG (target, FLAG_MONSTER))	1882	if (target->flag [FLAG_MONSTER])
1896	{	1883	{
1897	/* oky doky. got a target monster. Lets make a blinding attack */	1884	/* oky doky. got a target monster. Lets make a blinding attack */
1898	if (target->head)	1885	if (target->head)
1899	target = target->head;	1886	target = target->head;
1900		1887
1901	hit_player (target, dam, op, spell->attacktype, 1);	1888	hit_player (target, dam, op, spell->attacktype, 1);
1902	return 1; /* one success only! */	1889	return 1; /* one success only! */
		1890	}
1903	}	1891	}
1904	}
1905		1892
1906	/* no live target, perhaps a wall is in the way? */	1893	/* no live target, perhaps a wall is in the way? */
1907	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))	1894	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
1908	{	1895	{
1909	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1896	op->failmsg ("Something is in the way.");
1910	return 0;	1897	return 0;
		1898	}
1911	}	1899	}
1912		1900
1913	/* ok, looks groovy to just insert a new light on the map */	1901	/* ok, looks groovy to just insert a new light on the map */
1914	tmp = arch_to_object (spell->other_arch);	1902	tmp = spell->other_arch->instance ();
1915	if (!tmp)	1903	if (!tmp)
1916	{	1904	{
1917	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1905	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1918	return 0;	1906	return 0;
1919	}	1907	}
		1908
1920	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1909	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
		1910
1921	if (tmp->glow_radius)	1911	if (tmp->glow_radius)
1922	{	1912	tmp->set_glow_radius (
1923	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);	1913	clamp (spell->range + SP_level_range_adjust (caster, spell), 1, MAX_LIGHT_RADIUS)
1924	if (tmp->glow_radius > MAX_LIGHT_RADII)	1914	);
1925	tmp->glow_radius = MAX_LIGHT_RADII;
1926	}
1927		1915
		1916	if (dir)
1928	m->insert (tmp, x, y, op);	1917	m->insert (tmp, x, y, op);
		1918	else
		1919	caster->outer_env_or_self ()->insert (tmp);
		1920
1929	return 1;	1921	return 1;
1930	}	1922	}
1931		1923
1932	/* cast_cause_disease: this spell looks along <dir> from the	1924	/* cast_cause_disease: this spell looks along <dir> from the
1933	* player and infects someone.	1925	* player and infects someone.
…		…
1979	/* Only bother looking on this space if there is something living here */	1971	/* Only bother looking on this space if there is something living here */
1980	if (mflags & P_IS_ALIVE)	1972	if (mflags & P_IS_ALIVE)
1981	{	1973	{
1982	/* search this square for a victim */	1974	/* search this square for a victim */
1983	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)	1975	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
1984	if (QUERY_FLAG (walk, FLAG_MONSTER) \|\| (walk->type == PLAYER))	1976	if (walk->flag [FLAG_MONSTER] \|\| (walk->type == PLAYER))
1985	{ /* found a victim */	1977	{ /* found a victim */
1986	object *disease = arch_to_object (spell->other_arch);	1978	object *disease = spell->other_arch->instance ();
1987		1979
1988	disease->set_owner (op);	1980	disease->set_owner (op);
1989	set_spell_skill (op, caster, spell, disease);	1981	set_spell_skill (op, caster, spell, disease);
1990	disease->stats.exp = 0;	1982	disease->stats.exp = 0;
1991	disease->level = caster_level (caster, spell);	1983	disease->level = casting_level (caster, spell);
1992		1984
1993	/* do level adjustments */	1985	/* do level adjustments */
1994	if (disease->stats.wc)	1986	if (disease->stats.wc ) disease->stats.wc += dur_mod / 2;
1995	disease->stats.wc += dur_mod / 2;	1987	if (disease->magic > 0) disease->magic += dur_mod / 8;
1996		1988	if (disease->stats.maxhp > 0) disease->stats.maxhp += dur_mod;
1997	if (disease->magic > 0)	1989	if (disease->stats.maxgrace > 0) disease->stats.maxgrace += dur_mod;
1998	disease->magic += dur_mod / 8;
1999
2000	if (disease->stats.maxhp > 0)
2001	disease->stats.maxhp += dur_mod;
2002
2003	if (disease->stats.maxgrace > 0)
2004	disease->stats.maxgrace += dur_mod;
2005
2006	if (disease->stats.dam)
2007	{
2008	if (disease->stats.dam > 0)
2009	disease->stats.dam += dam_mod;
2010	else
2011	disease->stats.dam -= dam_mod;
2012	}
2013		1990
2014	if (disease->last_sp)	1991	if (disease->last_sp)
2015	{	1992	{
2016	disease->last_sp -= 2 * dam_mod;	1993	disease->last_sp -= 2 * dam_mod;
		1994
2017	if (disease->last_sp < 1)	1995	if (disease->last_sp < 1)
2018	disease->last_sp = 1;	1996	disease->last_sp = 1;
2019	}	1997	}
2020		1998
2021	if (disease->stats.maxsp)	1999	if (disease->stats.dam ) disease->stats.dam += copysign (disease->stats.dam , dam_mod);
2022	{	2000	if (disease->stats.maxsp) disease->stats.maxsp += copysign (disease->stats.maxsp, dam_mod);
2023	if (disease->stats.maxsp > 0)	2001	if (disease->stats.ac ) disease->stats.ac += dam_mod;
2024	disease->stats.maxsp += dam_mod;	2002	if (disease->last_eat ) disease->last_eat -= dam_mod;
2025	else	2003	if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2026	disease->stats.maxsp -= dam_mod;	2004	if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2027	}
2028
2029	if (disease->stats.ac)
2030	disease->stats.ac += dam_mod;
2031
2032	if (disease->last_eat)
2033	disease->last_eat -= dam_mod;
2034
2035	if (disease->stats.hp)
2036	disease->stats.hp -= dam_mod;
2037
2038	if (disease->stats.sp)
2039	disease->stats.sp -= dam_mod;
2040		2005
2041	if (infect_object (walk, disease, 1))	2006	if (infect_object (walk, disease, 1))
2042	{	2007	{
2043	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);	2008	op->statusmsg (format ("You inflict %s on %s!", &disease->name, &walk->name));
2044		2009
2045	disease->destroy (); /* don't need this one anymore */	2010	disease->destroy (); /* don't need this one anymore */
2046	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2011	walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
2047	return 1;	2012	return 1;
2048	}	2013	}
2049		2014
2050	disease->destroy ();	2015	disease->destroy ();
2051	}	2016	}

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.58 by root, Sat May 17 14:57:23 2008 UTC vs. Revision 1.110 by root, Fri Jan 27 22:00:40 2012 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.58 by root, Sat May 17 14:57:23 2008 UTC vs.
Revision 1.110 by root, Fri Jan 27 22:00:40 2012 UTC