ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/spell_attack.C

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.54 by root, Wed Apr 30 10:31:04 2008 UTC vs.
Revision 1.116 by root, Sat Sep 16 22:17:42 2017 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,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002-2003 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/* This file contains all the spell attack code. Grouping this code	25	/* This file contains all the spell attack code. Grouping this code
25	* together should hopefully make it easier to find the relevent bits	26	* together should hopefully make it easier to find the relevent bits
…		…
36	/* this function checks to see if a spell pushes objects as well	37	/* this function checks to see if a spell pushes objects as well
37	* as flies over and damages them (only used for cones for now)	38	* as flies over and damages them (only used for cones for now)
38	* but moved here so it could be applied to bolts too	39	* but moved here so it could be applied to bolts too
39	* op is the spell object.	40	* op is the spell object.
40	*/	41	*/
41		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 (tmp->flag [FLAG_WIZ])
66	return;	65	return;
67		66
68	/* don't move parts of objects */	67	/* don't move parts of objects */
69	if (tmp->head)	68	if (tmp->head)
70	continue;	69	continue;
71		70
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 (tmp->flag [FLAG_IS_FLOOR] || (!tmp->flag [FLAG_ALIVE] && tmp->flag [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.
…		…
87	if (tmp->move_type & MOVE_FLYING)	86	if (tmp->move_type & MOVE_FLYING)
88	frictionmod = 1; /* flying objects loose the friction modifier */	87	frictionmod = 1; /* flying objects loose the friction modifier */
89		88
90	if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))	89	if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))
91	{ /* move it. */	90	{ /* move it. */
92	/* move_object is really for monsters, but looking at	91	/* move_object is really for monsters, but looking at
93	* the move_object function, it appears that it should	92	* the move_object function, it appears that it should
94	* also be safe for objects.	93	* also be safe for objects.
95	* This does return if successful or not, but	94	* This does return if successful or not, but
96	* I don't see us doing anything useful with that information	95	* I don't see us doing anything useful with that information
97	* right now.	96	* right now.
98	*/	97	*/
99	move_object (tmp, absdir (op->stats.sp));	98	tmp->move (absdir (op->stats.sp));
100	}	99	}
101		100
102	}	101	}
103	}	102	}
104		103
…		…
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;
…		…
131	new_dir = -1;	129	new_dir = -1;
132		130
133	/* check the new dir for a wall and in the map */	131	/* check the new dir for a wall and in the map */
134	t_dir = absdir (tmp->direction + new_dir);	132	t_dir = absdir (tmp->direction + new_dir);
135		133
136	if (get_map_flags (tmp->map, &m, tmp->x + freearr_x[t_dir], tmp->y + freearr_y[t_dir], &sx, &sy) & P_OUT_OF_MAP)	134	if (get_map_flags (tmp->map, &m, tmp->x + DIRX (t_dir), tmp->y + DIRY (t_dir), &sx, &sy) & P_OUT_OF_MAP)
137	return;	135	return;
138		136
139	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy)))	137	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy)))
140	return;	138	return;
141		139
…		…
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
…		…
181		179
182	if (--op->range < 0)	180	if (--op->range < 0)
183	op->range = 0;	181	op->range = 0;
184	else	182	else
185	{	183	{
186	x = op->x + DIRX (op);	184	x = op->x + DIRX (op->direction);
187	y = op->y + DIRY (op);	185	y = op->y + DIRY (op->direction);
188	m = op->map;	186	m = op->map;
189	mflags = get_map_flags (m, &m, x, y, &x, &y);	187	mflags = get_map_flags (m, &m, x, y, &x, &y);
190		188
191	if (mflags & P_OUT_OF_MAP)	189	if (mflags & P_OUT_OF_MAP)
192	return;	190	return;
…		…
196	* 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
197	* will be useful.	195	* will be useful.
198	*/	196	*/
199	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)))
200	{	198	{
201	if (!QUERY_FLAG (op, FLAG_REFLECTING))	199	if (!op->flag [FLAG_REFLECTING])
202	return;	200	return;
203		201
204	/* Since walls don't run diagonal, if the bolt is in	202	/* Since walls don't run diagonal, if the bolt is in
205	* one of 4 main directions, it just reflects back in the	203	* one of 4 main directions, it just reflects back in the
206	* opposite direction. However, if the bolt is travelling	204	* opposite direction. However, if the bolt is travelling
…		…
219	/* Need to check for P_OUT_OF_MAP: if the bolt is tavelling	217	/* Need to check for P_OUT_OF_MAP: if the bolt is tavelling
220	* over a corner in a tiled map, it is possible that	218	* over a corner in a tiled map, it is possible that
221	* op->direction is within an adjacent map but either	219	* op->direction is within an adjacent map but either
222	* op->direction-1 or op->direction+1 does not exist.	220	* op->direction-1 or op->direction+1 does not exist.
223	*/	221	*/
224	mflags = get_map_flags (op->map, &m, op->x + freearr_x[absdir (op->direction - 1)],	222	mflags = get_map_flags (op->map, &m, op->x + DIRX (absdir (op->direction - 1)),
225	op->y + freearr_y[absdir (op->direction - 1)], &x, &y);	223	op->y + DIRY (absdir (op->direction - 1)), &x, &y);
226		224
227	left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));	225	left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));
228		226
229	mflags = get_map_flags (op->map, &m, op->x + freearr_x[absdir (op->direction + 1)],	227	mflags = get_map_flags (op->map, &m, op->x + DIRX (absdir (op->direction + 1)),
230	op->y + freearr_y[absdir (op->direction + 1)], &x, &y);	228	op->y + DIRY (absdir (op->direction + 1)), &x, &y);
231	right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));	229	right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));
232		230
233	if (left == right)	231	if (left == right)
234	op->direction = absdir (op->direction + 4);	232	op->direction = absdir (op->direction + 4);
235	else if (left)	233	else if (left)
…		…
249	tmp->speed_left = -0.1f;	247	tmp->speed_left = -0.1f;
250	/* To make up for the decrease at the top of the function */	248	/* To make up for the decrease at the top of the function */
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
300	tmp->direction = dir;	298	tmp->direction = dir;
301	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	299	if (tmp->flag [FLAG_IS_TURNABLE])
302	SET_ANIMATION (tmp, dir);	300	SET_ANIMATION (tmp, dir);
303		301
304	tmp->set_owner (op);	302	tmp->set_owner (op);
305	set_spell_skill (op, caster, spob, tmp);	303	set_spell_skill (op, caster, spob, tmp);
306		304
307	tmp->x = op->x + DIRX (tmp);	305	tmp->x = op->x + DIRX (tmp->direction);
308	tmp->y = op->y + DIRY (tmp);	306	tmp->y = op->y + DIRY (tmp->direction);
309	tmp->map = op->map;	307	tmp->map = op->map;
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 (!tmp->flag [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;
…		…
366	{	364	{
367	for (i = 1; i < 9; i++)	365	for (i = 1; i < 9; i++)
368	{	366	{
369	sint16 dx, dy;	367	sint16 dx, dy;
370		368
371	dx = op->x + freearr_x[i];	369	dx = op->x + DIRX (i);
372	dy = op->y + freearr_y[i];	370	dy = op->y + DIRY (i);
373		371
374	/* ok_to_put_more already does things like checks for walls,	372	/* ok_to_put_more already does things like checks for walls,
375	* out of map, etc.	373	* out of map, etc.
376	*/	374	*/
377	if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))	375	if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
378	{	376	{
379	object *tmp = op->clone ();	377	object *tmp = op->clone ();
…		…
391		389
392	/* Causes an object to explode, eg, a firebullet,	390	/* Causes an object to explode, eg, a firebullet,
393	* poison cloud ball, etc. op is the object to	391	* poison cloud ball, etc. op is the object to
394	* explode.	392	* explode.
395	*/	393	*/
396	void	394	static void
397	explode_bullet (object *op)	395	explode_bullet (object *op)
398	{	396	{
399	object *tmp, *owner;	397	object *tmp, *owner;
400		398
401	if (op->other_arch == NULL)	399	if (!op->other_arch)
402	{	400	{
403	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	401	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
404	op->destroy ();	402	op->destroy ();
405	return;	403	return;
406	}	404	}
…		…
435	}	433	}
436		434
437	if (op->attacktype)	435	if (op->attacktype)
438	{	436	{
439	hit_map (op, 0, op->attacktype, 1);	437	hit_map (op, 0, op->attacktype, 1);
		438
440	if (op->destroyed ())	439	if (op->destroyed ())
441	return;	440	return;
442	}	441	}
443		442
444	/* other_arch contains what this explodes into */	443	/* other_arch contains what this explodes into */
445	tmp = arch_to_object (op->other_arch);	444	tmp = op->other_arch->instance ();
446		445
447	tmp->set_owner (op);	446	tmp->set_owner (op);
448	tmp->skill = op->skill;	447	tmp->skill = op->skill;
449		448
450	owner = op->owner;	449	owner = op->owner;
451		450
452	if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))	451	if ((tmp->attacktype & AT_HOLYWORD
		452	|| tmp->attacktype & AT_GODPOWER)
		453	&& owner
		454	&& !tailor_god_spell (tmp, owner))
453	{	455	{
454	op->destroy ();	456	op->destroy ();
455	return;	457	return;
456	}	458	}
457		459
…		…
519	if (!(mflags & P_IS_ALIVE))	521	if (!(mflags & P_IS_ALIVE))
520	return;	522	return;
521		523
522	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	524	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
523	{	525	{
524	if (QUERY_FLAG (tmp, FLAG_ALIVE))	526	if (tmp->flag [FLAG_ALIVE])
525	{	527	{
526	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	528	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
		529
		530	// TODO: can't understand the following if's
527	if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)	531	if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
528	{	532	{
529	if (!QUERY_FLAG (op, FLAG_REMOVED))	533	if (!op->flag [FLAG_REMOVED])
530	{	534	{
531	op->destroy ();	535	op->destroy ();
532	return;	536	return;
533	}	537	}
534	}	538	}
…		…
542	* fired arches (eg, bolts).	546	* fired arches (eg, bolts).
543	*/	547	*/
544	void	548	void
545	move_bullet (object *op)	549	move_bullet (object *op)
546	{	550	{
547	sint16 new_x, new_y;
548	int mflags;
549	maptile *m;
550
551	#if 0	551	#if 0
552	/* We need a better general purpose way to do this */	552	/* We need a better general purpose way to do this */
553		553
554	/* peterm: added to make comet leave a trail of burnouts	554	/* peterm: added to make comet leave a trail of burnouts
555	it's an unadulterated hack, but the effect is cool. */	555	it's an unadulterated hack, but the effect is cool. */
556	if (op->stats.sp == SP_METEOR)	556	if (op->stats.sp == SP_METEOR)
557	{	557	{
558	replace_insert_ob_in_map ("fire_trail", op);	558	replace_insert_ob_in_map ("fire_trail", op);
559	if (op->destroyed ())	559	if (op->destroyed ())
…		…
570	op->destroy ();	570	op->destroy ();
571		571
572	return;	572	return;
573	}	573	}
574		574
575	new_x = op->x + DIRX (op);	575	mapxy pos (op);
576	new_y = op->y + DIRY (op);	576	pos.move (op->direction);
577	m = op->map;
578	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
579		577
580	if (mflags & P_OUT_OF_MAP)	578	if (!pos.normalise ())
581	{	579	{
582	op->destroy ();	580	op->destroy ();
583	return;	581	return;
584	}	582	}
585		583
586	if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))	584	mapspace &ms = pos.ms ();
		585
		586	ms.update ();
		587
		588	if (!op->direction || OB_TYPE_MOVE_BLOCK (op, ms.move_block))
587	{	589	{
588	if (op->other_arch)	590	if (op->other_arch)
589	explode_bullet (op);	591	explode_bullet (op);
590	else	592	else
591	op->destroy ();	593	op->destroy ();
592		594
593	return;	595	return;
594	}	596	}
595		597
596	if (!(op = m->insert (op, new_x, new_y, op)))	598	if (!(op = pos.insert (op, op)))
597	return;	599	return;
598		600
599	if (reflwall (op->map, op->x, op->y, op))	601	if (reflwall (op->map, op->x, op->y, op))
600	{	602	{
601	op->direction = absdir (op->direction + 4);	603	op->direction = absdir (op->direction + 4);
…		…
620	int mflags;	622	int mflags;
621		623
622	if (!spob->other_arch)	624	if (!spob->other_arch)
623	return 0;	625	return 0;
624		626
625	tmp = arch_to_object (spob->other_arch);	627	tmp = spob->other_arch->instance ();
626	if (tmp == NULL)	628	if (!tmp)
627	return 0;	629	return 0;
628		630
629	/* peterm: level dependency for bolts */	631	/* peterm: level dependency for bolts */
630	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);	632	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
631	tmp->attacktype = spob->attacktype;	633	tmp->attacktype = spob->attacktype;
632	if (spob->slaying)	634	if (spob->slaying)
633	tmp->slaying = spob->slaying;	635	tmp->slaying = spob->slaying;
634		636
…		…
638	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);	640	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
639	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);	641	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
640	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);
641		643
642	tmp->direction = dir;	644	tmp->direction = dir;
643	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	645	if (tmp->flag [FLAG_IS_TURNABLE])
644	SET_ANIMATION (tmp, dir);	646	SET_ANIMATION (tmp, dir);
645		647
646	tmp->set_owner (op);	648	tmp->set_owner (op);
647	set_spell_skill (op, caster, spob, tmp);	649	set_spell_skill (op, caster, spob, tmp);
648		650
649	tmp->x = op->x + freearr_x[dir];	651	tmp->x = op->x + DIRX (dir);
650	tmp->y = op->y + freearr_y[dir];	652	tmp->y = op->y + DIRY (dir);
651	tmp->map = op->map;	653	tmp->map = op->map;
652		654
653	maptile *newmap;	655	maptile *newmap;
654	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);	656	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
655	if (mflags & P_OUT_OF_MAP)	657	if (mflags & P_OUT_OF_MAP)
…		…
658	return 0;	660	return 0;
659	}	661	}
660		662
661	tmp->map = newmap;	663	tmp->map = newmap;
662		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
663	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))	678	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
664	{	679	{
665	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	680	if (!tmp->flag [FLAG_REFLECTING])
666	{	681	{
667	tmp->destroy ();	682	tmp->destroy ();
668	return 0;	683	return 0;
669	}	684	}
670		685
…		…
685	* CONE RELATED FUNCTIONS	700	* CONE RELATED FUNCTIONS
686	*	701	*
687	*****************************************************************************/	702	*****************************************************************************/
688		703
689	/* drops an object based on what is in the cone's "other_arch" */	704	/* drops an object based on what is in the cone's "other_arch" */
690	void	705	static void
691	cone_drop (object *op)	706	cone_drop (object *op)
692	{	707	{
693	object *new_ob = arch_to_object (op->other_arch);	708	object *new_ob = op->other_arch->instance ();
694		709
695	new_ob->level = op->level;	710	new_ob->level = op->level;
696	new_ob->set_owner (op->owner);	711	new_ob->set_owner (op->owner);
697		712
698	/* preserve skill ownership */	713	/* preserve skill ownership */
…		…
705	/* move_cone: causes cone object 'op' to move a space/hit creatures */	720	/* move_cone: causes cone object 'op' to move a space/hit creatures */
706		721
707	void	722	void
708	move_cone (object *op)	723	move_cone (object *op)
709	{	724	{
710	int i;
711
712	/* if no map then hit_map will crash so just ignore object */	725	/* if no map then hit_map will crash so just ignore object */
713	if (!op->map)	726	if (!op->map)
714	{	727	{
715	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");	728	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
716	op->set_speed (0);	729	op->set_speed (0);
717	return;	730	return;
718	}	731	}
719		732
720	/* lava saves it's life, but not yours :) */	733	/* lava saves it's life, but not yours :) */
721	if (QUERY_FLAG (op, FLAG_LIFESAVE))	734	if (op->flag [FLAG_LIFESAVE])
722	{	735	{
723	hit_map (op, 0, op->attacktype, 0);	736	hit_map (op, 0, op->attacktype, 0);
724	return;	737	return;
725	}	738	}
726		739
…		…
736	}	749	}
737	#endif	750	#endif
738		751
739	hit_map (op, 0, op->attacktype, 0);	752	hit_map (op, 0, op->attacktype, 0);
740		753
		754	if (!op->is_on_map ())
		755	return;
		756
741	/* Check to see if we should push anything.	757	/* Check to see if we should push anything.
742	* Spell objects with weight push whatever they encounter to some	758	* Spell objects with weight push whatever they encounter to some
743	* degree.	759	* degree.
744	*/	760	*/
745	if (op->weight)	761	if (op->weight)
		762	{
746	check_spell_knockback (op);	763	check_spell_knockback (op);
747		764
748	if (op->destroyed ())	765	if (!op->is_on_map ())
749	return;	766	return;
		767	}
750		768
751	if ((op->duration--) < 0)	769	if (op->duration-- < 0)
752	{	770	{
753	op->destroy ();	771	op->destroy ();
754	return;	772	return;
755	}	773	}
756	/* Object has hit maximum range, so don't have it move	774	/* Object has hit maximum range, so don't have it move
…		…
761	{	779	{
762	op->range = 0; /* just so it doesn't wrap */	780	op->range = 0; /* just so it doesn't wrap */
763	return;	781	return;
764	}	782	}
765		783
766	for (i = -1; i < 2; i++)	784	for (int i = -1; i <= 1; i++)
767	{	785	{
768	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];	786	sint16 x = op->x + DIRX (absdir (op->stats.sp + i)), y = op->y + DIRY (absdir (op->stats.sp + i));
769		787
770	if (ok_to_put_more (op->map, x, y, op, op->attacktype))	788	if (ok_to_put_more (op->map, x, y, op, op->attacktype))
771	{	789	{
772	object *tmp = op->clone ();	790	object *tmp = op->clone ();
773		791
…		…
802	MoveType movetype;	820	MoveType movetype;
803		821
804	if (!spell->other_arch)	822	if (!spell->other_arch)
805	return 0;	823	return 0;
806		824
807	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)
808	{	826	{
809	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!");
810	return 0;	828	return 0;
811	}	829	}
812		830
813	if (!dir)	831	if (!dir)
814	{	832	{
…		…
822	*/	840	*/
823	movetype = spell->other_arch->move_type;	841	movetype = spell->other_arch->move_type;
824		842
825	for (i = range_min; i <= range_max; i++)	843	for (i = range_min; i <= range_max; i++)
826	{	844	{
827	sint16 x, y, d;	845	sint16 x, y;
828		846
829	/* We can't use absdir here, because it never returns	847	/* We can't use absdir here, because it never returns
830	* 0. If this is a rune, we want to hit the person on top	848	* 0. If this is a rune, we want to hit the person on top
831	* of the trap (d==0). If it is not a rune, then we don't want	849	* of the trap (d==0). If it is not a rune, then we don't want
832	* to hit that person.	850	* to hit that person.
833	*/	851	*/
834	d = dir + i;	852	int d = dir ? absdir (dir + i) : i;
835	while (d < 0)
836	d += 8;
837	while (d > 8)
838	d -= 8;
839		853
840	/* If it's not a rune, we don't want to blast the caster.	854	/* If it's not a rune, we don't want to blast the caster.
841	* In that case, we have to see - if dir is specified,	855	* In that case, we have to see - if dir is specified,
842	* turn this into direction 8. If dir is not specified (all	856	* turn this into direction 8. If dir is not specified (all
843	* direction) skip - otherwise, one line would do more damage	857	* direction) skip - otherwise, one line would do more damage
…		…
850	d = 8;	864	d = 8;
851	else	865	else
852	continue;	866	continue;
853	}	867	}
854		868
855	x = op->x + freearr_x[d];	869	x = op->x + DIRX (d);
856	y = op->y + freearr_y[d];	870	y = op->y + DIRY (d);
857		871
858	if (get_map_flags (op->map, &m, x, y, &sx, &sy) & P_OUT_OF_MAP)	872	if (get_map_flags (op->map, &m, x, y, &sx, &sy) & P_OUT_OF_MAP)
859	continue;	873	continue;
860		874
861	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	875	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
862	continue;	876	continue;
863		877
864	success = 1;	878	success = 1;
865	tmp = arch_to_object (spell->other_arch);	879	tmp = spell->other_arch->instance ();
866	tmp->set_owner (op);	880	tmp->set_owner (op);
867	set_spell_skill (op, caster, spell, tmp);	881	set_spell_skill (op, caster, spell, tmp);
868	tmp->level = caster_level (caster, spell);	882	tmp->level = casting_level (caster, spell);
869	tmp->attacktype = spell->attacktype;	883	tmp->attacktype = spell->attacktype;
870		884
871	/* holy word stuff */	885	/* holy word stuff */
872	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))	886	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
873	if (!tailor_god_spell (tmp, op))	887	if (!tailor_god_spell (tmp, op))
…		…
945		959
946	object *env = op->outer_env ();	960	object *env = op->outer_env ();
947		961
948	if (op->env)	962	if (op->env)
949	{	963	{
950	if (env->map == NULL)	964	if (!env->map)
951	return;	965	return;
952		966
953	if (!(op = op->insert_at (env, op)))	967	if (!(op = op->insert_at (env, op)))
954	return;	968	return;
955	}	969	}
956		970
957	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding	971	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
958	// on a safe map. I don't like this special casing, but it seems to be neccessary	972	// on a safe map. I don't like this special casing, but it seems to be neccessary
959	// as bombs can be carried.	973	// as bombs can be carried.
960	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	974	if (op->ms ().flags () & P_SAFE)
961	{	975	{
962	op->destroy ();	976	op->destroy ();
963	return;	977	return;
964	}	978	}
965		979
…		…
969	*/	983	*/
970	if (archetype *at = archetype::find (SPLINT))	984	if (archetype *at = archetype::find (SPLINT))
971	{	985	{
972	for (int i = 1; i < 9; i++)	986	for (int i = 1; i < 9; i++)
973	{	987	{
974	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))	988	if (out_of_map (op->map, op->x + DIRX (i), op->y + DIRX (i)))
975	continue;	989	continue;
976		990
977	object *tmp = arch_to_object (at);	991	object *tmp = at->instance ();
978	tmp->direction = i;	992	tmp->direction = i;
979	tmp->range = op->range;	993	tmp->range = op->range;
980	tmp->stats.dam = op->stats.dam;	994	tmp->stats.dam = op->stats.dam;
981	tmp->duration = op->duration;	995	tmp->duration = op->duration;
982	tmp->attacktype = op->attacktype;	996	tmp->attacktype = op->attacktype;
983	tmp->set_owner (op);	997	tmp->set_owner (op);
984	if (op->skill && op->skill != tmp->skill)	998	if (op->skill && op->skill != tmp->skill)
985	tmp->skill = op->skill;	999	tmp->skill = op->skill;
986		1000
987	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	1001	if (tmp->flag [FLAG_IS_TURNABLE])
988	SET_ANIMATION (tmp, i);	1002	SET_ANIMATION (tmp, i);
989		1003
990	op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);	1004	op->map->insert (tmp, op->x + DIRX (i), op->y + DIRX (i), op);
991	move_bullet (tmp);	1005	move_bullet (tmp);
992	}	1006	}
993	}	1007	}
994		1008
995	explode_bullet (op);	1009	explode_bullet (op);
…		…
998	int	1012	int
999	create_bomb (object *op, object *caster, int dir, object *spell)	1013	create_bomb (object *op, object *caster, int dir, object *spell)
1000	{	1014	{
1001	object *tmp;	1015	object *tmp;
1002	int mflags;	1016	int mflags;
1003	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];	1017	sint16 dx = op->x + DIRX (dir), dy = op->y + DIRY (dir);
1004	maptile *m;	1018	maptile *m;
1005		1019
1006	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);	1020	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
		1021
		1022	// when creating a bomb below ourself it should always work, even
		1023	// when movement is blocked (somehow we got here, somehow we are here,
		1024	// so we should also be able to make a bomb here). (originally added
		1025	// to fix create bomb traps in doors, which cast with dir=0).
		1026	if (dir)
		1027	{
1007	if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))	1028	if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1008	{	1029	{
1009	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1030	op->failmsg ("There is something in the way.");
1010	return 0;	1031	return 0;
		1032	}
1011	}	1033	}
1012		1034
1013	tmp = arch_to_object (spell->other_arch);	1035	tmp = spell->other_arch->instance ();
1014		1036
1015	/* level dependencies for bomb */	1037	/* level dependencies for bomb */
1016	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1038	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1017	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1039	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1018	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1040	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
1038	* dir is the direction to look in.	1060	* dir is the direction to look in.
1039	* range is how far out to look.	1061	* range is how far out to look.
1040	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.	1062	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.
1041	* this info is used for blocked magic/unholy spaces.	1063	* this info is used for blocked magic/unholy spaces.
1042	*/	1064	*/
1043	object *	1065	static object *
1044	get_pointed_target (object *op, int dir, int range, int type)	1066	get_pointed_target (object *op, int dir, int range, int type)
1045	{	1067	{
1046	object *target;	1068	object *target;
1047	sint16 x, y;	1069	sint16 x, y;
1048	int dist, mflags;	1070	int dist, mflags;
…		…
1051	if (dir == 0)	1073	if (dir == 0)
1052	return NULL;	1074	return NULL;
1053		1075
1054	for (dist = 1; dist < range; dist++)	1076	for (dist = 1; dist < range; dist++)
1055	{	1077	{
1056	x = op->x + freearr_x[dir] * dist;	1078	x = op->x + DIRX (dir) * dist;
1057	y = op->y + freearr_y[dir] * dist;	1079	y = op->y + DIRY (dir) * dist;
1058	mp = op->map;	1080	mp = op->map;
1059	mflags = get_map_flags (op->map, &mp, x, y, &x, &y);	1081	mflags = get_map_flags (op->map, &mp, x, y, &x, &y);
1060		1082
1061	if (mflags & P_OUT_OF_MAP)	1083	if (mflags & P_OUT_OF_MAP)
1062	return NULL;	1084	return NULL;
…		…
1067	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1089	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1068	return NULL;	1090	return NULL;
1069		1091
1070	if (mflags & P_IS_ALIVE)	1092	if (mflags & P_IS_ALIVE)
1071	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)
1072	if (QUERY_FLAG (target, FLAG_MONSTER))	1094	if (target->flag [FLAG_MONSTER])
1073	return target;	1095	return target;
1074	}	1096	}
1075		1097
1076	return NULL;	1098	return NULL;
1077	}	1099	}
1078		1100
1079	/* cast_smite_arch() - the priest points to a creature and causes	1101	/* cast_smite_spell() - the priest points to a creature and causes
1080	* a 'godly curse' to decend.	1102	* a 'godly curse' to decend.
1081	* usual params -	1103	* usual params -
1082	* op = player	1104	* op = player
1083	* caster = object casting the spell.	1105	* caster = object casting the spell.
1084	* dir = direction being cast	1106	* dir = direction being cast
1085	* spell = spell object	1107	* spell = spell object
…		…
1087	int	1109	int
1088	cast_smite_spell (object *op, object *caster, int dir, object *spell)	1110	cast_smite_spell (object *op, object *caster, int dir, object *spell)
1089	{	1111	{
1090	object *effect, *target;	1112	object *effect, *target;
1091	object *god = find_god (determine_god (op));	1113	object *god = find_god (determine_god (op));
1092	int range;
1093		1114
1094	range = spell->range + SP_level_range_adjust (caster, spell);
1095	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);
1096		1116
1097	/* Bunch of conditions for casting this spell. Note that only	1117	/* Bunch of conditions for casting this spell. Note that only
1098	* require a god if this is a cleric spell (requires grace).	1118	* require a god if this is a cleric spell (requires grace).
1099	* 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
1100	* by wizards also, which is good, because I think this is a very	1120	* by wizards also, which is good, because I think this is a very
1101	* interesting spell.	1121	* interesting spell.
1102	* 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
1103	* can't be friendly to your god.	1123	* can't be friendly to your god.
1104	*/	1124	*/
1105		1125
1106	if (!target || QUERY_FLAG (target, FLAG_REFL_SPELL)	1126	if (!target
		1127	|| target->flag [FLAG_REFL_SPELL]
1107	|| (!god && spell->stats.grace)	1128	|| (!god && spell->stats.grace)
1108	|| (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)))
1109	{	1131	{
1110	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1132	op->failmsg ("Your request is unheeded.");
1111	return 0;	1133	return 0;
1112	}	1134	}
1113		1135
1114	if (spell->other_arch)	1136	if (spell->other_arch)
1115	effect = arch_to_object (spell->other_arch);	1137	effect = spell->other_arch->instance ();
1116	else	1138	else
1117	return 0;	1139	return 0;
1118		1140
1119	/* tailor the effect by priest level and worshipped God */	1141	/* tailor the effect by priest level and worshipped God */
1120	effect->level = caster_level (caster, spell);	1142	effect->level = casting_level (caster, spell);
1121	effect->attacktype = spell->attacktype;	1143	effect->attacktype = spell->attacktype;
1122	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))	1144	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1123	{	1145	{
1124	if (tailor_god_spell (effect, op))	1146	if (tailor_god_spell (effect, op))
1125	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));
1126	else	1148	else
1127	{	1149	{
1128	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1150	op->failmsg ("Your request is ignored.");
1129	return 0;	1151	return 0;
1130	}	1152	}
1131	}	1153	}
1132		1154
1133	/* size of the area of destruction */	1155	/* size of the area of destruction */
…		…
1137	if (effect->attacktype & AT_DEATH)	1159	if (effect->attacktype & AT_DEATH)
1138	{	1160	{
1139	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1161	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1140		1162
1141	/* casting death spells at undead isn't a good thing */	1163	/* casting death spells at undead isn't a good thing */
1142	if (QUERY_FLAG (target, FLAG_UNDEAD))	1164	if (target->flag [FLAG_UNDEAD])
1143	{	1165	{
1144	if (random_roll (0, 2, op, PREFER_LOW))	1166	if (random_roll (0, 2, op, PREFER_LOW))
1145	{	1167	{
1146	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1168	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1147	effect->x = op->x;	1169	effect->x = op->x;
…		…
1180		1202
1181	/* op is a missile that needs to be moved */	1203	/* op is a missile that needs to be moved */
1182	void	1204	void
1183	move_missile (object *op)	1205	move_missile (object *op)
1184	{	1206	{
1185	int i, mflags;
1186	object *owner;
1187	sint16 new_x, new_y;
1188	maptile *m;
1189
1190	if (op->range-- <= 0)	1207	if (op->range-- <= 0)
1191	{	1208	{
		1209	op->drop_and_destroy ();
		1210	return;
		1211	}
		1212
		1213	mapxy pos (op);
		1214	pos.move (op->direction);
		1215
		1216	if (!pos.normalise ())
		1217	{
1192	op->destroy ();	1218	op->destroy ();
1193	return;	1219	return;
1194	}	1220	}
1195		1221
1196	owner = op->owner;	1222	mapspace &ms = pos.ms ();
1197	#if 0
1198	/* It'd make things nastier if this wasn't here - spells cast by
1199	* monster that are then killed would continue to survive
1200	*/
1201	if (owner == NULL)
1202	{
1203	op->destroy ();
1204	return;
1205	}
1206	#endif
1207		1223
1208	new_x = op->x + DIRX (op);	1224	if (ms.flags () & P_IS_ALIVE || ms.blocks (op))
1209	new_y = op->y + DIRY (op);
1210
1211	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1212
1213	if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1214	{	1225	{
1215	hit_map (op, op->direction, AT_MAGIC, 1);	1226	hit_map (op, op->direction, AT_MAGIC, 1);
1216	/* Basically, missile only hits one thing then goes away.	1227	/* Basically, missile only hits one thing then goes away.
1217	* we need to remove it if someone hasn't already done so.	1228	* we need to remove it if someone hasn't already done so.
1218	*/	1229	*/
1219	if (!op->destroyed ())
1220	op->destroy ();
1221
1222	return;
1223	}
1224
1225	op->remove ();
1226
1227	if (!op->direction || (mflags & P_OUT_OF_MAP))
1228	{
1229	op->destroy ();	1230	op->destroy ();
1230	return;	1231	return;
1231	}	1232	}
1232		1233
		1234	if (!op->direction)
		1235	{
		1236	op->destroy ();
		1237	return;
		1238	}
		1239
1233	i = spell_find_dir (m, new_x, new_y, op->owner);	1240	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1234	if (i > 0 && i != op->direction)	1241	if (i > 0 && i != op->direction)
1235	{	1242	{
1236	op->direction = i;	1243	op->direction = i;
1237	SET_ANIMATION (op, op->direction);	1244	SET_ANIMATION (op, op->direction);
1238	}	1245	}
1239		1246
1240	m->insert (op, new_x, new_y, op);	1247	pos.insert (op, op);
1241	}	1248	}
1242		1249
1243	/****************************************************************************	1250	/****************************************************************************
1244	* Destruction	1251	* Destruction
1245	****************************************************************************/	1252	****************************************************************************/
1246		1253
1247	/* make_object_glow() - currently only makes living objects glow.	1254	/* make_object_glow() - currently only makes living objects glow.
1248	* 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
1249	* object. if time is 0, the object glows permanently. To truely	1256	* object. if time is 0, the object glows permanently. To truely
1250	* make this work for non-living objects, we would have to	1257	* make this work for non-living objects, we would have to
1251	* give them the capability to have an inventory. b.t.	1258	* give them the capability to have an inventory. b.t.
1252	*/	1259	*/
1253	int	1260	static int
1254	make_object_glow (object *op, int radius, int time)	1261	make_object_glow (object *op, int radius, int time)
1255	{	1262	{
1256	/* some things are unaffected... */	1263	/* some things are unaffected... */
1257	if (op->path_denied & PATH_LIGHT)	1264	if (op->path_denied & PATH_LIGHT)
1258	return 0;	1265	return 0;
1259		1266
1260	object *tmp = get_archetype (FORCE_NAME);	1267	object *tmp = archetype::get (FORCE_NAME);
1261	tmp->speed = 0.01;	1268	tmp->set_speed (0.01);
1262	tmp->stats.food = time;	1269	tmp->stats.food = time;
1263	SET_FLAG (tmp, FLAG_IS_USED_UP);	1270	tmp->set_flag (FLAG_IS_USED_UP);
1264	tmp->glow_radius = radius;	1271	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1265	if (tmp->glow_radius > MAX_LIGHT_RADII)
1266	tmp->glow_radius = MAX_LIGHT_RADII;
1267
1268	tmp = insert_ob_in_ob (tmp, op);	1272	tmp = insert_ob_in_ob (tmp, op);
1269		1273
1270	if (tmp->glow_radius > op->glow_radius)	1274	if (tmp->glow_radius > op->glow_radius)
1271	op->glow_radius = tmp->glow_radius;	1275	op->set_glow_radius (tmp->glow_radius);
1272		1276
1273	return 1;	1277	return 1;
1274	}	1278	}
1275		1279
1276	int	1280	int
1277	cast_destruction (object *op, object *caster, object *spell_ob)	1281	cast_destruction (object *op, object *caster, object *spell_ob)
1278	{	1282	{
1279	int i, j, range, mflags, friendly = 0, dam, dur;
1280	sint16 sx, sy;
1281	maptile *m;
1282	object *tmp;
1283	const char *skill;
1284
1285	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1283	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1286	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	1284	int dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1287	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1285	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1288	if (QUERY_FLAG (op, FLAG_FRIENDLY) || op->type == PLAYER)
1289	friendly = 1;
1290		1286
1291	/* destruction doesn't use another spell object, so we need	1287	bool friendly = op->flag [FLAG_FRIENDLY] || op->is_player ();
1292	* update op's skill pointer so that exp is properly awarded.
1293	* We do some shortcuts here - since this is just temporary
1294	* and we'll reset the values back, we don't need to go through
1295	* the full share string/free_string route.
1296	*/
1297	skill = op->skill;
1298	if (caster == op)
1299	op->skill = spell_ob->skill;
1300	else if (caster->skill)
1301	op->skill = caster->skill;
1302	else
1303	op->skill = NULL;
1304		1288
1305	op->change_skill (find_skill_by_name (op, op->skill));	1289	dynbuf buf;
1306		1290	unordered_mapwalk (buf, op, -range, -range, range, range)
1307	for (i = -range; i < range; i++)
1308	{	1291	{
1309	for (j = -range; j < range; j++)	1292	mapspace &ms = m->at (nx, ny);
1310	{
1311	m = op->map;
1312	sx = op->x + i;
1313	sy = op->y + j;
1314		1293
1315	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1316	if (mflags & P_OUT_OF_MAP)
1317	continue;
1318
1319	if (mflags & P_IS_ALIVE)	1294	if (ms.flags () & P_IS_ALIVE)
		1295	for (object *next, *tmp = ms.bot; tmp; tmp = next)
1320	{	1296	{
1321	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1297	next = tmp->above;
1322	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1323	break;
1324		1298
1325	if (tmp)	1299	if (tmp->flag [FLAG_ALIVE] || tmp->is_player ())
1326	{	1300	{
1327	if (tmp->head)
1328	tmp = tmp->head;	1301	tmp = tmp->head_ ();
1329		1302
1330	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) ||	1303	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1331	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))	1304	|| (!friendly && (tmp->flag [FLAG_FRIENDLY] || tmp->is_player ())))
1332	{	1305	{
1333	if (spell_ob->subtype == SP_DESTRUCTION)	1306	if (spell_ob->subtype == SP_DESTRUCTION)
1334	{	1307	{
1335	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1308	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
		1309
1336	if (spell_ob->other_arch)	1310	if (spell_ob->other_arch)
1337	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1311	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1338	}	1312	}
1339	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)
1340	{	1314	{
1341	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1315	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1342	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1316	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1343	}	1317	}
1344	}	1318	}
1345	}	1319	}
1346	}	1320	}
1347	}
1348	}	1321	}
1349		1322
1350	op->skill = skill;
1351	return 1;	1323	return 1;
1352	}	1324	}
1353		1325
1354	/***************************************************************************	1326	/***************************************************************************
1355	*	1327	*
1356	* CURSE	1328	* CURSE
1357	*	1329	*
1358	***************************************************************************/	1330	***************************************************************************/
1359
1360	int	1331	int
1361	cast_curse (object *op, object *caster, object *spell_ob, int dir)	1332	cast_curse (object *op, object *caster, object *spell_ob, int dir)
1362	{	1333	{
1363	object *god = find_god (determine_god (op));	1334	object *god = find_god (determine_god (op));
1364	object *tmp, *force;	1335	object *tmp, *force;
1365		1336
1366	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);
1367	if (!tmp)	1338	if (!tmp)
1368	{	1339	{
1369	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.");
1370	return 0;	1341	return 0;
1371	}	1342	}
1372		1343
1373	tmp = tmp->head_ ();	1344	tmp = tmp->head_ ();
1374		1345
…		…
1389	}	1360	}
1390	}	1361	}
1391		1362
1392	if (!force)	1363	if (!force)
1393	{	1364	{
1394	force = get_archetype (FORCE_NAME);	1365	force = archetype::get (FORCE_NAME);
1395	force->subtype = FORCE_CHANGE_ABILITY;	1366	force->subtype = FORCE_CHANGE_ABILITY;
1396		1367
1397	if (spell_ob->race)	1368	if (spell_ob->race)
1398	force->name = spell_ob->race;	1369	force->name = spell_ob->race;
1399	else	1370	else
…		…
1417		1388
1418	return 1;	1389	return 1;
1419	}	1390	}
1420		1391
1421	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;
1422	force->speed = 1.f;
1423	force->speed_left = -1.f;	1393	force->speed_left = -1.f;
1424	SET_FLAG (force, FLAG_APPLIED);	1394	force->set_speed (1.f);
		1395	force->set_flag (FLAG_APPLIED);
1425		1396
1426	if (god)	1397	if (god)
1427	{	1398	{
1428	if (spell_ob->last_grace)	1399	if (spell_ob->last_grace)
1429	force->path_repelled = god->path_repelled;	1400	force->path_repelled = god->path_repelled;
…		…
1442	force->stats.wc = spell_ob->stats.wc;	1413	force->stats.wc = spell_ob->stats.wc;
1443		1414
1444	change_abil (tmp, force); /* Mostly to display any messages */	1415	change_abil (tmp, force); /* Mostly to display any messages */
1445	insert_ob_in_ob (force, tmp);	1416	insert_ob_in_ob (force, tmp);
1446	tmp->update_stats ();	1417	tmp->update_stats ();
		1418
1447	return 1;	1419	return 1;
1448
1449	}	1420	}
1450		1421
1451	/**********************************************************************	1422	/**********************************************************************
1452	* mood change	1423	* mood change
1453	* 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
…		…
1459	*/	1430	*/
1460	int	1431	int
1461	mood_change (object *op, object *caster, object *spell)	1432	mood_change (object *op, object *caster, object *spell)
1462	{	1433	{
1463	object *tmp, *god, *head;	1434	object *tmp, *god, *head;
1464	int done_one, range, mflags, level, at, best_at;	1435	int done_one, range, level, at, best_at;
1465	sint16 x, y, nx, ny;
1466	maptile *m;
1467	const char *race;	1436	const char *race;
1468		1437
1469	/* 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
1470	* doing it over and over again.	1439	* doing it over and over again.
1471	*/	1440	*/
1472	god = find_god (determine_god (op));	1441	god = find_god (determine_god (op));
1473	level = caster_level (caster, spell);	1442	level = casting_level (caster, spell);
1474	range = spell->range + SP_level_range_adjust (caster, spell);	1443	range = spell->range + SP_level_range_adjust (caster, spell);
1475		1444
1476	/* 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_...
1477	* 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
1478	* won't ever match anything.	1447	* won't ever match anything.
1479	*/	1448	*/
1480	if (!spell->race)	1449	if (!spell->race)
1481	race = NULL;	1450	race = NULL;
1482	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1451	else if (god && spell->race == shstr_GOD_SLAYING)
1483	race = god->slaying;	1452	race = god->slaying;
1484	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1453	else if (god && spell->race == shstr_GOD_FRIEND)
1485	race = god->race;	1454	race = god->race;
1486	else	1455	else
1487	race = spell->race;	1456	race = spell->race;
1488		1457
1489	for (x = op->x - range; x <= op->x + range; x++)	1458	dynbuf buf;
1490	for (y = op->y - range; y <= op->y + range; y++)	1459	unordered_mapwalk (buf, op, -range, -range, range, range)
1491	{	1460	{
1492	done_one = 0;	1461	mapspace &ms = m->at (nx, ny);
1493	m = op->map;
1494	nx = x;
1495	ny = y;
1496	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1497	if (mflags & P_OUT_OF_MAP)
1498	continue;
1499		1462
1500	/* 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 */
1501	if (!(mflags & P_IS_ALIVE))	1464	if (!(ms.flags () & P_IS_ALIVE))
1502	continue;	1465	continue;
1503		1466
1504	// players can only affect spaces that they can actually see	1467	// players can only affect spaces that they can actually see
		1468	if (caster
1505	if (caster && caster->contr	1469	&& caster->contr
1506	&& caster->contr->visibility_at (m, nx, ny) < 70)	1470	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1507	continue;	1471	continue;
1508		1472
1509	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1473	for (tmp = ms.top; tmp; tmp = tmp->below)
1510	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1474	if (tmp->flag [FLAG_MONSTER])
1511	break;	1475	break;
1512		1476
1513	/* There can be living objects that are not monsters */	1477	/* There can be living objects that are not monsters */
1514	if (!tmp || tmp->type == PLAYER)	1478	if (!tmp)
1515	continue;	1479	continue;
1516		1480
1517	/* Only the head has meaningful data, so resolve to that */	1481	/* Only the head has meaningful data, so resolve to that */
1518	if (tmp->head)
1519	head = tmp->head;	1482	head = tmp->head_ ();
1520	else
1521	head = tmp;
1522		1483
1523	/* 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 */
1524	if (race && head->race && !strstr (race, head->race))	1485	if (race && head->race && !strstr (race, head->race))
1525	continue;	1486	continue;
1526		1487
1527	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1488	if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
1528	continue;	1489	continue;
1529		1490
1530	/* Now do a bunch of stuff related to saving throws */	1491	/* Now do a bunch of stuff related to saving throws */
1531	best_at = -1;	1492	best_at = -1;
1532	if (spell->attacktype)	1493	if (spell->attacktype)
1533	{	1494	{
1534	for (at = 0; at < NROFATTACKS; at++)	1495	for (at = 0; at < NROFATTACKS; at++)
1535	if (spell->attacktype & (1 << at))	1496	if (spell->attacktype & (1 << at))
1536	if (best_at == -1 || head->resist[at] > head->resist[best_at])	1497	if (best_at == -1 || head->resist[at] > head->resist[best_at])
1537	best_at = at;	1498	best_at = at;
1538		1499
1539	if (best_at == -1)	1500	if (best_at == -1)
1540	at = 0;	1501	at = 0;
1541	else	1502	else
1542	{	1503	{
1543	if (head->resist[best_at] == 100)	1504	if (head->resist[best_at] == 100)
1544	continue;	1505	continue;
1545	else	1506	else
1546	at = head->resist[best_at] / 5;	1507	at = head->resist[best_at] / 5;
1547	}	1508	}
		1509
1548	at -= level / 5;	1510	at -= level / 5;
1549	if (did_make_save (head, head->level, at))	1511	if (did_make_save (head, head->level, at))
1550	continue;	1512	continue;
1551	}	1513	}
1552	else /* spell->attacktype */	1514	else /* spell->attacktype */
1553	{	1515	{
1554	/*	1516	/*
1555	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:
1556	* if spell level < monster level, no go	1518	* if spell level < monster level, no go
1557	* 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 ) )
1558		1520
1559	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.
1560		1522
1561	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
1562	charm a level 125 monster...	1524	charm a level 125 monster...
1563		1525
1564	Ryo, august 14th	1526	Ryo, august 14th
1565	*/	1527	*/
1566	if (head->level > level)	1528	if (head->level > level)
1567	continue;	1529	continue;
1568		1530
1569	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))))
1570	/* Failed, no effect */	1532	/* Failed, no effect */
1571	continue;	1533	continue;
1572	}	1534	}
1573		1535
1574	/* Done with saving throw. Now start affecting the monster */	1536	/* Done with saving throw. Now start affecting the monster */
		1537	done_one = 0;
1575		1538
1576	/* aggravation */	1539	/* aggravation */
1577	if (QUERY_FLAG (spell, FLAG_MONSTER))	1540	if (spell->flag [FLAG_MONSTER])
1578	{	1541	{
1579	CLEAR_FLAG (head, FLAG_SLEEP);	1542	head->clr_flag (FLAG_SLEEP);
1580	remove_friendly_object (head);	1543	remove_friendly_object (head);
1581	done_one = 1;	1544	done_one = 1;
1582	head->enemy = op;	1545	head->enemy = op;
1583	}	1546	}
1584		1547
1585	/* calm monsters */	1548	/* calm monsters */
1586	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1549	if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
1587	{	1550	{
1588	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1551	head->set_flag (FLAG_UNAGGRESSIVE);
1589	head->enemy = NULL;	1552	head->enemy = NULL;
1590	done_one = 1;	1553	done_one = 1;
1591	}	1554	}
1592		1555
1593	/* berserk monsters */	1556	/* berserk monsters */
1594	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1557	if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
1595	{	1558	{
1596	SET_FLAG (head, FLAG_BERSERK);	1559	head->set_flag (FLAG_BERSERK);
1597	done_one = 1;	1560	done_one = 1;
1598	}	1561	}
1599		1562
1600	/* charm */	1563	/* charm */
1601	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1564	if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
1602	{	1565	{
1603	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));	1566	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
1604		1567
1605	/* Prevent uncontrolled outbreaks of self replicating monsters.	1568	/* Prevent uncontrolled outbreaks of self replicating monsters.
1606	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.
1607	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. */
1608	CLEAR_FLAG (head, FLAG_GENERATOR);	1571	head->clr_flag (FLAG_GENERATOR);
1609	head->set_owner (op);	1572	head->set_owner (op);
1610	set_spell_skill (op, caster, spell, head);	1573	set_spell_skill (op, caster, spell, head);
1611	add_friendly_object (head);	1574	add_friendly_object (head);
1612	head->attack_movement = PETMOVE;	1575	head->attack_movement = PETMOVE;
1613	done_one = 1;	1576	done_one = 1;
1614	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);
1615	head->stats.exp = 0;	1578	head->stats.exp = 0;
1616	}	1579	}
1617		1580
1618	/* If a monster was effected, put an effect in */	1581	/* If a monster was effected, put an effect in */
1619	if (done_one && spell->other_arch)	1582	if (done_one && spell->other_arch)
1620	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1583	m->insert (spell->other_arch->instance (), nx, ny, op);
1621	} /* for y */	1584	}
1622		1585
1623	return 1;	1586	return 1;
1624	}	1587	}
1625
1626		1588
1627	/* 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
1628	* 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
1629	* lightning spell used it, that seemed misnamed.	1591	* lightning spell used it, that seemed misnamed.
1630	* op is the spell effect.	1592	* op is the spell effect.
1631	* note that duration is handled by process_object() in time.c	1593	* note that duration is handled by process_object() in time.c
1632	*/	1594	*/
1633
1634	void	1595	void
1635	move_ball_spell (object *op)	1596	move_ball_spell (object *op)
1636	{	1597	{
1637	int i, j, dam_save, dir, mflags;	1598	int i, j, dam_save, dir, mflags;
1638	sint16 nx, ny, hx, hy;	1599	sint16 nx, ny, hx, hy;
…		…
1657	for (i = 1; i < 9; i++)	1618	for (i = 1; i < 9; i++)
1658	{	1619	{
1659	/* i bit 0: alters sign of offset	1620	/* i bit 0: alters sign of offset
1660	* other bits (i / 2): absolute value of offset	1621	* other bits (i / 2): absolute value of offset
1661	*/	1622	*/
1662
1663	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);	1623	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1664	int tmpdir = absdir (op->direction + offset);	1624	int tmpdir = absdir (op->direction + offset);
1665		1625
1666	nx = op->x + freearr_x[tmpdir];	1626	nx = op->x + DIRX (tmpdir);
1667	ny = op->y + freearr_y[tmpdir];	1627	ny = op->y + DIRY (tmpdir);
1668	if (!(get_map_flags (op->map, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, nx, ny))))	1628	if (!(get_map_flags (op->map, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, nx, ny))))
1669	{	1629	{
1670	dir = tmpdir;	1630	dir = tmpdir;
1671	break;	1631	break;
1672	}	1632	}
1673	}	1633	}
		1634
1674	if (dir == 0)	1635	if (dir == 0)
1675	{	1636	{
1676	nx = op->x;	1637	nx = op->x;
1677	ny = op->y;	1638	ny = op->y;
1678	m = op->map;	1639	m = op->map;
1679	}	1640	}
1680		1641
1681	m->insert (op, nx, ny, op);	1642	m->insert (op, nx, ny, op);
1682		1643
1683	dam_save = op->stats.dam; /* save the original dam: we do halfdam on	1644	dam_save = op->stats.dam; /* save the original dam: we do halfdam on
1684	surrounding squares */	1645	surrounding squares */
1685		1646
1686	/* loop over current square and neighbors to hit.	1647	/* loop over current square and neighbors to hit.
1687	* if this has an other_arch field, we insert that in	1648	* if this has an other_arch field, we insert that in
1688	* the surround spaces.	1649	* the surround spaces.
1689	*/	1650	*/
1690	for (j = 0; j < 9; j++)	1651	for (j = 0; j < 9; j++)
1691	{	1652	{
1692	hx = nx + freearr_x[j];	1653	hx = nx + DIRX (j);
1693	hy = ny + freearr_y[j];	1654	hy = ny + DIRY (j);
1694		1655
1695	m = op->map;	1656	m = op->map;
1696	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);	1657	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
1697		1658
1698	if (mflags & P_OUT_OF_MAP)	1659	if (mflags & P_OUT_OF_MAP)
…		…
1704		1665
1705	if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))	1666	if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
1706	{	1667	{
1707	if (j)	1668	if (j)
1708	op->stats.dam = dam_save / 2;	1669	op->stats.dam = dam_save / 2;
		1670
1709	hit_map (op, j, op->attacktype, 1);	1671	hit_map (op, j, op->attacktype, 1);
1710
1711	}	1672	}
1712		1673
1713	/* insert the other arch */	1674	/* insert the other arch */
1714	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))))
1715	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1676	m->insert (op->other_arch->instance (), hx, hy, op);
1716	}	1677	}
1717		1678
1718	/* restore to the center location and damage */	1679	/* restore to the center location and damage */
1719	op->stats.dam = dam_save;	1680	op->stats.dam = dam_save;
1720		1681
1721	i = spell_find_dir (op->map, op->x, op->y, op->owner);	1682	i = spell_find_dir (op->map, op->x, op->y, op->owner);
1722		1683
1723	if (i >= 0)	1684	if (i >= 0)
1724	{ /* we have a preferred direction! */	1685	{ /* we have a preferred direction! */
1725	/* pick another direction if the preferred dir is blocked. */	1686	/* pick another direction if the preferred dir is blocked. */
1726	if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP ||	1687	if (get_map_flags (op->map, &m, nx + DIRX (i), ny + DIRY (i), &hx, &hy) & P_OUT_OF_MAP ||
1727	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))	1688	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))
1728	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */	1689	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1729		1690
1730	op->direction = i;	1691	op->direction = i;
1731	}	1692	}
1732	}	1693	}
1733		1694
1734
1735	/* move_swarm_spell: peterm	1695	/* move_swarm_spell: peterm
1736	* This is an implementation of the swarm spell. It was written for	1696	* This is an implementation of the swarm spell. It was written for
1737	* meteor swarm, but it could be used for any swarm. A swarm spell	1697	* meteor swarm, but it could be used for any swarm. A swarm spell
1738	* is a special type of object that casts swarms of other types	1698	* is a special type of object that casts swarms of other types
1739	* of spells. Which spell it casts is flexible. It fires the spells	1699	* of spells. Which spell it casts is flexible. It fires the spells
1740	* from a set of squares surrounding the caster, in a given direction.	1700	* from a set of squares surrounding the caster, in a given direction.
1741	*/	1701	*/
1742
1743	void	1702	void
1744	move_swarm_spell (object *op)	1703	move_swarm_spell (object *op)
1745	{	1704	{
1746	#if 0	1705	#if 0
1747	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };	1706	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1748	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };	1707	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1749	sint16 target_x, target_y, origin_x, origin_y;	1708	sint16 target_x, target_y, origin_x, origin_y;
1750	int adjustdir;	1709	int adjustdir;
1751	maptile *m;	1710	maptile *m;
1752	#endif	1711	#endif
1753	int basedir;
1754	object *owner;	1712	object *owner = op->env;
1755		1713
1756	owner = op->owner;	1714	if (!owner) // MUST not happen, remove when true TODO
1757	if (op->duration == 0 || owner == NULL)
1758	{	1715	{
		1716	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1759	op->destroy ();	1717	op->destroy ();
1760	return;	1718	return;
1761	}	1719	}
1762		1720
		1721	if (!op->duration || !owner->is_on_map ())
		1722	{
		1723	op->drop_and_destroy ();
		1724	return;
		1725	}
		1726
1763	op->duration--;	1727	op->duration--;
1764		1728
1765	basedir = op->direction;	1729	int basedir = op->direction;
1766	if (basedir == 0)	1730	if (!basedir)
1767	{	1731	{
1768	/* spray in all directions! 8) */	1732	/* spray in all directions! 8) */
1769	basedir = rndm (1, 8);	1733	op->facing = (op->facing + op->state) & 7;
		1734	basedir = op->facing + 1;
1770	}	1735	}
1771		1736
1772	#if 0	1737	#if 0
1773	// this is bogus: it causes wrong places to be checked below	1738	// this is bogus: it causes wrong places to be checked below
1774	// (a wall 2 cells away will block the effect...) and	1739	// (a wall 2 cells away will block the effect...) and
…		…
1776	// space.	1741	// space.
1777	// should be fixed later, but correctness before features...	1742	// should be fixed later, but correctness before features...
1778	// (schmorp)	1743	// (schmorp)
1779		1744
1780	/* new offset calculation to make swarm element distribution	1745	/* new offset calculation to make swarm element distribution
1781	* more uniform	1746	* more uniform
1782	*/	1747	*/
1783	if (op->duration)	1748	if (op->duration)
1784	{	1749	{
1785	if (basedir & 1)	1750	if (basedir & 1)
1786	{	1751	{
…		…
1794	else	1759	else
1795	{	1760	{
1796	adjustdir = 0; /* fire the last one from forward. */	1761	adjustdir = 0; /* fire the last one from forward. */
1797	}	1762	}
1798		1763
1799	target_x = op->x + freearr_x[absdir (basedir + adjustdir)];	1764	target_x = op->x + DIRX (absdir (basedir + adjustdir));
1800	target_y = op->y + freearr_y[absdir (basedir + adjustdir)];	1765	target_y = op->y + DIRY (absdir (basedir + adjustdir));
1801		1766
1802	/* back up one space so we can hit point-blank targets, but this	1767	/* back up one space so we can hit point-blank targets, but this
1803	* necessitates extra out_of_map check below	1768	* necessitates extra out_of_map check below
1804	*/	1769	*/
1805	origin_x = target_x - freearr_x[basedir];	1770	origin_x = target_x - DIRX (basedir);
1806	origin_y = target_y - freearr_y[basedir];	1771	origin_y = target_y - DIRY (basedir);
1807		1772
1808		1773
1809	/* spell pointer is set up for the spell this casts. Since this	1774	/* spell pointer is set up for the spell this casts. Since this
1810	* should just be a pointer to the spell in some inventory,	1775	* should just be a pointer to the spell in some inventory,
1811	* it is unlikely to disappear by the time we need it. However,	1776	* it is unlikely to disappear by the time we need it. However,
…		…
1835	{	1800	{
1836	/* Bullet spells have a bunch more customization that needs to be done */	1801	/* Bullet spells have a bunch more customization that needs to be done */
1837	if (op->spell->subtype == SP_BULLET)	1802	if (op->spell->subtype == SP_BULLET)
1838	fire_bullet (owner, op, basedir, op->spell);	1803	fire_bullet (owner, op, basedir, op->spell);
1839	else if (op->spell->subtype == SP_MAGIC_MISSILE)	1804	else if (op->spell->subtype == SP_MAGIC_MISSILE)
1840	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);	1805	fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1841	}	1806	}
1842	}	1807	}
1843
1844
1845
1846		1808
1847	/* fire_swarm:	1809	/* fire_swarm:
1848	* The following routine creates a swarm of objects. It actually	1810	* The following routine creates a swarm of objects. It actually
1849	* sets up a specific swarm object, which then fires off all	1811	* sets up a specific swarm object, which then fires off all
1850	* the parts of the swarm.	1812	* the parts of the swarm.
1851	*	1813	*
1852	* op: the owner	1814	* op: the owner
1853	* caster: the caster (owner, wand, rod, scroll)	1815	* caster: the caster (owner, wand, rod, scroll)
1854	* dir: the direction everything will be fired in	1816	* dir: the direction everything will be fired in
1855	* spell - the spell that is this spell.	1817	* spell - the spell that is this spell.
1856	* n: the number to be fired.	1818	* n: the number to be fired.
1857	*/	1819	*/
1858
1859	int	1820	int
1860	fire_swarm (object *op, object *caster, object *spell, int dir)	1821	fire_swarm (object *op, object *caster, object *spell, int dir)
1861	{	1822	{
1862	object *tmp;
1863	int i;
1864
1865	if (!spell->other_arch)	1823	if (!spell->other_arch)
1866	return 0;	1824	return 0;
1867		1825
1868	tmp = get_archetype (SWARM_SPELL);	1826	object *tmp = archetype::get (SWARM_SPELL);
1869	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */	1827
1870	set_spell_skill (op, caster, spell, tmp);	1828	set_spell_skill (op, caster, spell, tmp);
1871
1872	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. */
1873	tmp->spell = arch_to_object (spell->other_arch);	1830	tmp->spell = spell->other_arch->instance ();
1874
1875	tmp->attacktype = tmp->spell->attacktype;	1831	tmp->attacktype = tmp->spell->attacktype;
1876		1832
1877	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)	1833	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1878	if (!tailor_god_spell (tmp, op))	1834	if (!tailor_god_spell (tmp, op))
1879	return 1;	1835	return 1;
1880		1836
1881	tmp->duration = SP_level_duration_adjust (caster, spell);	1837	tmp->duration = SP_level_duration_adjust (caster, spell);
1882	for (i = 0; i < spell->duration; i++)	1838	for (int i = 0; i < spell->duration; i++)
1883	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1839	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1884		1840
		1841	tmp->invisible = 1;
		1842	tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1885	tmp->direction = dir;	1843	tmp->direction = dir;
1886	tmp->invisible = 1;	1844	tmp->facing = rndm (1, 8); // initial firing direction
		1845	tmp->state = rndm (4) * 2 + 1; // direction increment
1887		1846
1888	tmp->insert_at (op, op);	1847	op->insert (tmp);
		1848
1889	return 1;	1849	return 1;
1890	}	1850	}
1891
1892		1851
1893	/* See the spells documentation file for why this is its own	1852	/* See the spells documentation file for why this is its own
1894	* function.	1853	* function.
1895	*/	1854	*/
1896	int	1855	int
…		…
1901	int dam, mflags;	1860	int dam, mflags;
1902	maptile *m;	1861	maptile *m;
1903		1862
1904	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1863	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1905		1864
1906	if (!dir)	1865	if (dir)
1907	{
1908	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1909	return 0;
1910	}	1866	{
1911		1867	x = op->x + DIRX (dir);
1912	x = op->x + freearr_x[dir];	1868	y = op->y + DIRY (dir);
1913	y = op->y + freearr_y[dir];
1914	m = op->map;	1869	m = op->map;
1915		1870
1916	mflags = get_map_flags (m, &m, x, y, &x, &y);	1871	mflags = get_map_flags (m, &m, x, y, &x, &y);
1917		1872
1918	if (mflags & P_OUT_OF_MAP)	1873	if (mflags & P_OUT_OF_MAP)
1919	{	1874	{
1920	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1875	op->failmsg ("Nothing is there.");
1921	return 0;	1876	return 0;
1922	}	1877	}
1923		1878
1924	if (mflags & P_IS_ALIVE && spell->attacktype)	1879	if (mflags & P_IS_ALIVE && spell->attacktype)
1925	{	1880	{
1926	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)
1927	if (QUERY_FLAG (target, FLAG_MONSTER))	1882	if (target->flag [FLAG_MONSTER])
1928	{	1883	{
1929	/* oky doky. got a target monster. Lets make a blinding attack */	1884	/* oky doky. got a target monster. Lets make a blinding attack */
1930	if (target->head)	1885	if (target->head)
1931	target = target->head;	1886	target = target->head;
		1887
1932	(void) hit_player (target, dam, op, spell->attacktype, 1);	1888	hit_player (target, dam, op, spell->attacktype, 1);
1933	return 1; /* one success only! */	1889	return 1; /* one success only! */
		1890	}
1934	}	1891	}
1935	}
1936		1892
1937	/* no live target, perhaps a wall is in the way? */	1893	/* no live target, perhaps a wall is in the way? */
1938	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)))
1939	{	1895	{
1940	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1896	op->failmsg ("Something is in the way.");
1941	return 0;	1897	return 0;
		1898	}
1942	}	1899	}
1943		1900
1944	/* 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 */
1945	tmp = arch_to_object (spell->other_arch);	1902	tmp = spell->other_arch->instance ();
1946	if (!tmp)	1903	if (!tmp)
1947	{	1904	{
1948	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1905	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1949	return 0;	1906	return 0;
1950	}	1907	}
		1908
1951	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1909	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
		1910
1952	if (tmp->glow_radius)	1911	if (tmp->glow_radius)
1953	{	1912	tmp->set_glow_radius (
1954	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)
1955	if (tmp->glow_radius > MAX_LIGHT_RADII)	1914	);
1956	tmp->glow_radius = MAX_LIGHT_RADII;
1957	}
1958		1915
		1916	if (dir)
1959	m->insert (tmp, x, y, op);	1917	m->insert (tmp, x, y, op);
		1918	else
		1919	caster->outer_env_or_self ()->insert (tmp);
		1920
1960	return 1;	1921	return 1;
1961	}	1922	}
1962		1923
1963	/* cast_cause_disease: this spell looks along <dir> from the	1924	/* cast_cause_disease: this spell looks along <dir> from the
1964	* player and infects someone.	1925	* player and infects someone.
1965	* op is the player/monster, caster is the object, dir is the direction	1926	* op is the player/monster, caster is the object, dir is the direction
1966	* to cast, disease_arch is the specific disease, and type is the spell number	1927	* to cast, disease_arch is the specific disease, and type is the spell number
1967	* perhaps this should actually be in disease.c?	1928	* perhaps this should actually be in disease.c?
1968	*/	1929	*/
1969	int	1930	int
…		…
1975	maptile *m;	1936	maptile *m;
1976		1937
1977	x = op->x;	1938	x = op->x;
1978	y = op->y;	1939	y = op->y;
1979		1940
1980	/* If casting from a scroll, no direction will be available, so refer to the	1941	/* If casting from a scroll, no direction will be available, so refer to the
1981	* direction the player is pointing.	1942	* direction the player is pointing.
1982	*/	1943	*/
1983	if (!dir)	1944	if (!dir)
1984	dir = op->facing;	1945	dir = op->facing;
1985		1946
…		…
1992	dur_mod = SP_level_duration_adjust (caster, spell);	1953	dur_mod = SP_level_duration_adjust (caster, spell);
1993		1954
1994	/* search in a line for a victim */	1955	/* search in a line for a victim */
1995	for (i = 1; i < range; i++)	1956	for (i = 1; i < range; i++)
1996	{	1957	{
1997	x = op->x + i * freearr_x[dir];	1958	x = op->x + i * DIRX (dir);
1998	y = op->y + i * freearr_y[dir];	1959	y = op->y + i * DIRY (dir);
1999	m = op->map;	1960	m = op->map;
2000		1961
2001	mflags = get_map_flags (m, &m, x, y, &x, &y);	1962	mflags = get_map_flags (m, &m, x, y, &x, &y);
2002		1963
2003	if (mflags & P_OUT_OF_MAP)	1964	if (mflags & P_OUT_OF_MAP)
…		…
2010	/* 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 */
2011	if (mflags & P_IS_ALIVE)	1972	if (mflags & P_IS_ALIVE)
2012	{	1973	{
2013	/* search this square for a victim */	1974	/* search this square for a victim */
2014	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)
2015	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))	1976	if (walk->flag [FLAG_MONSTER] || (walk->type == PLAYER))
2016	{ /* found a victim */	1977	{ /* found a victim */
2017	object *disease = arch_to_object (spell->other_arch);	1978	object *disease = spell->other_arch->instance ();
2018		1979
2019	disease->set_owner (op);	1980	disease->set_owner (op);
2020	set_spell_skill (op, caster, spell, disease);	1981	set_spell_skill (op, caster, spell, disease);
2021	disease->stats.exp = 0;	1982	disease->stats.exp = 0;
2022	disease->level = caster_level (caster, spell);	1983	disease->level = casting_level (caster, spell);
2023		1984
2024	/* do level adjustments */	1985	/* do level adjustments */
2025	if (disease->stats.wc)	1986	if (disease->stats.wc ) disease->stats.wc += dur_mod / 2;
2026	disease->stats.wc += dur_mod / 2;	1987	if (disease->magic > 0) disease->magic += dur_mod / 8;
2027		1988	if (disease->stats.maxhp > 0) disease->stats.maxhp += dur_mod;
2028	if (disease->magic > 0)	1989	if (disease->stats.maxgrace > 0) disease->stats.maxgrace += dur_mod;
2029	disease->magic += dur_mod / 8;
2030
2031	if (disease->stats.maxhp > 0)
2032	disease->stats.maxhp += dur_mod;
2033
2034	if (disease->stats.maxgrace > 0)
2035	disease->stats.maxgrace += dur_mod;
2036
2037	if (disease->stats.dam)
2038	{
2039	if (disease->stats.dam > 0)
2040	disease->stats.dam += dam_mod;
2041	else
2042	disease->stats.dam -= dam_mod;
2043	}
2044		1990
2045	if (disease->last_sp)	1991	if (disease->last_sp)
2046	{	1992	{
2047	disease->last_sp -= 2 * dam_mod;	1993	disease->last_sp -= 2 * dam_mod;
		1994
2048	if (disease->last_sp < 1)	1995	if (disease->last_sp < 1)
2049	disease->last_sp = 1;	1996	disease->last_sp = 1;
2050	}	1997	}
2051		1998
2052	if (disease->stats.maxsp)	1999	if (disease->stats.dam ) disease->stats.dam += copysignl (disease->stats.dam , dam_mod);
2053	{	2000	if (disease->stats.maxsp) disease->stats.maxsp += copysignl (disease->stats.maxsp, dam_mod);
2054	if (disease->stats.maxsp > 0)	2001	if (disease->stats.ac ) disease->stats.ac += dam_mod;
2055	disease->stats.maxsp += dam_mod;	2002	if (disease->last_eat ) disease->last_eat -= dam_mod;
2056	else	2003	if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2057	disease->stats.maxsp -= dam_mod;	2004	if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2058	}
2059
2060	if (disease->stats.ac)
2061	disease->stats.ac += dam_mod;
2062
2063	if (disease->last_eat)
2064	disease->last_eat -= dam_mod;
2065
2066	if (disease->stats.hp)
2067	disease->stats.hp -= dam_mod;
2068
2069	if (disease->stats.sp)
2070	disease->stats.sp -= dam_mod;
2071		2005
2072	if (infect_object (walk, disease, 1))	2006	if (infect_object (walk, disease, 1))
2073	{	2007	{
2074	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));
2075		2009
2076	disease->destroy (); /* don't need this one anymore */	2010	disease->destroy (); /* don't need this one anymore */
2077	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2011	walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
2078	return 1;	2012	return 1;
2079	}	2013	}
2080		2014
2081	disease->destroy ();	2015	disease->destroy ();
2082	}	2016	}

Diff Legend

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