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.57 by root, Sat May 17 14:11:13 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	void	42	static void
42	check_spell_knockback (object *op)	43	check_spell_knockback (object *op)
43	{	44	{
44	object *tmp, *tmp2; /* object on the map */
45	int weight_move;	45	int weight_move;
46	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 */
47		47
48	if (!op->weight)	48	if (!op->weight)
49	{ /*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 */
…		…
54	{	54	{
55	weight_move = op->weight + (op->weight * op->level) / 3;	55	weight_move = op->weight + (op->weight * op->level) / 3;
56	/*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); */
57	}	57	}
58		58
59	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)
60	{	60	{
61	int num_sections = 1;	61	int num_sections = 1;
62		62
63	/* don't move DM */	63	/* don't move DM */
64	if (QUERY_FLAG (tmp, FLAG_WIZ))	64	if (tmp->flag [FLAG_WIZ])
65	return;	65	return;
66		66
67	/* don't move parts of objects */	67	/* don't move parts of objects */
68	if (tmp->head)	68	if (tmp->head)
69	continue;	69	continue;
70		70
71	/* don't move floors or immobile objects */	71	/* don't move floors or immobile objects */
72	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]))
73	continue;	73	continue;
74		74
75	/* count the object's sections */	75	/* count the object's sections */
76	for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more)	76	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
77	num_sections++;	77	num_sections++;
78		78
79	/* 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
80	* 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
81	* 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.
…		…
86	if (tmp->move_type & MOVE_FLYING)	86	if (tmp->move_type & MOVE_FLYING)
87	frictionmod = 1; /* flying objects loose the friction modifier */	87	frictionmod = 1; /* flying objects loose the friction modifier */
88		88
89	if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))	89	if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))
90	{ /* move it. */	90	{ /* move it. */
91	/* move_object is really for monsters, but looking at	91	/* move_object is really for monsters, but looking at
92	* the move_object function, it appears that it should	92	* the move_object function, it appears that it should
93	* also be safe for objects.	93	* also be safe for objects.
94	* This does return if successful or not, but	94	* This does return if successful or not, but
95	* I don't see us doing anything useful with that information	95	* I don't see us doing anything useful with that information
96	* right now.	96	* right now.
97	*/	97	*/
98	move_object (tmp, absdir (op->stats.sp));	98	tmp->move (absdir (op->stats.sp));
99	}	99	}
100		100
101	}	101	}
102	}	102	}
103		103
…		…
108	***************************************************************************/	108	***************************************************************************/
109		109
110	/* Causes op to fork. op is the original bolt, tmp	110	/* Causes op to fork. op is the original bolt, tmp
111	* is the first piece of the fork.	111	* is the first piece of the fork.
112	*/	112	*/
113	void	113	static void
114	forklightning (object *op, object *tmp)	114	forklightning (object *op, object *tmp)
115	{	115	{
116	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 */
117	int t_dir; /* stores temporary dir calculation */	117	int t_dir; /* stores temporary dir calculation */
118	maptile *m;	118	maptile *m;
…		…
129	new_dir = -1;	129	new_dir = -1;
130		130
131	/* check the new dir for a wall and in the map */	131	/* check the new dir for a wall and in the map */
132	t_dir = absdir (tmp->direction + new_dir);	132	t_dir = absdir (tmp->direction + new_dir);
133		133
134	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)
135	return;	135	return;
136		136
137	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)))
138	return;	138	return;
139		139
…		…
149	new_bolt->duration++;	149	new_bolt->duration++;
150	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */	150	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
151	new_bolt->stats.dam++;	151	new_bolt->stats.dam++;
152	tmp->stats.dam /= 2; /* reduce father bolt damage */	152	tmp->stats.dam /= 2; /* reduce father bolt damage */
153	tmp->stats.dam++;	153	tmp->stats.dam++;
		154
154	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))	155	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
155	update_turn_face (new_bolt);	156	update_turn_face (new_bolt);
156	}	157	}
157		158
158	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,	159	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
159	* and checks for various things that may stop it.	160	* and checks for various things that may stop it.
160	*/	161	*/
161
162	void	162	void
163	move_bolt (object *op)	163	move_bolt (object *op)
164	{	164	{
165	int mflags;	165	int mflags;
166	sint16 x, y;	166	sint16 x, y;
167	maptile *m;	167	maptile *m;
168		168
169	if (--op->duration < 0)	169	if (--op->duration < 0)
170	{	170	{
171	op->destroy ();	171	op->drop_and_destroy ();
172	return;	172	return;
173	}	173	}
174		174
175	hit_map (op, 0, op->attacktype, 1);	175	hit_map (op, 0, op->attacktype, 1);
176		176
…		…
179		179
180	if (--op->range < 0)	180	if (--op->range < 0)
181	op->range = 0;	181	op->range = 0;
182	else	182	else
183	{	183	{
184	x = op->x + DIRX (op);	184	x = op->x + DIRX (op->direction);
185	y = op->y + DIRY (op);	185	y = op->y + DIRY (op->direction);
186	m = op->map;	186	m = op->map;
187	mflags = get_map_flags (m, &m, x, y, &x, &y);	187	mflags = get_map_flags (m, &m, x, y, &x, &y);
188		188
189	if (mflags & P_OUT_OF_MAP)	189	if (mflags & P_OUT_OF_MAP)
190	return;	190	return;
…		…
194	* 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
195	* will be useful.	195	* will be useful.
196	*/	196	*/
197	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)))
198	{	198	{
199	if (!QUERY_FLAG (op, FLAG_REFLECTING))	199	if (!op->flag [FLAG_REFLECTING])
200	return;	200	return;
201		201
202	/* Since walls don't run diagonal, if the bolt is in	202	/* Since walls don't run diagonal, if the bolt is in
203	* one of 4 main directions, it just reflects back in the	203	* one of 4 main directions, it just reflects back in the
204	* opposite direction. However, if the bolt is travelling	204	* opposite direction. However, if the bolt is travelling
…		…
217	/* 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
218	* over a corner in a tiled map, it is possible that	218	* over a corner in a tiled map, it is possible that
219	* op->direction is within an adjacent map but either	219	* op->direction is within an adjacent map but either
220	* op->direction-1 or op->direction+1 does not exist.	220	* op->direction-1 or op->direction+1 does not exist.
221	*/	221	*/
222	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)),
223	op->y + freearr_y[absdir (op->direction - 1)], &x, &y);	223	op->y + DIRY (absdir (op->direction - 1)), &x, &y);
224		224
225	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));
226		226
227	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)),
228	op->y + freearr_y[absdir (op->direction + 1)], &x, &y);	228	op->y + DIRY (absdir (op->direction + 1)), &x, &y);
229	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));
230		230
231	if (left == right)	231	if (left == right)
232	op->direction = absdir (op->direction + 4);	232	op->direction = absdir (op->direction + 4);
233	else if (left)	233	else if (left)
…		…
247	tmp->speed_left = -0.1f;	247	tmp->speed_left = -0.1f;
248	/* 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 */
249	tmp->duration++;	249	tmp->duration++;
250		250
251	/* New forking code. Possibly create forks of this object	251	/* New forking code. Possibly create forks of this object
252	* going off in other directions.	252	* going off in other directions.
253	*/	253	*/
254	if (rndm (0, 99) < tmp->stats.Dex)	254	if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
255	{ /* stats.Dex % of forking */	255	forklightning (op, tmp); /* stats.Dex % of forking */
256	forklightning (op, tmp);
257	}
258		256
259	/* 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
260	* doesn't create any bolts that continue to move onward.	258	* doesn't create any bolts that continue to move onward.
261	*/	259	*/
262	op->range = 0;	260	op->range = 0;
…		…
279	int mflags;	277	int mflags;
280		278
281	if (!spob->other_arch)	279	if (!spob->other_arch)
282	return 0;	280	return 0;
283		281
284	tmp = arch_to_object (spob->other_arch);	282	tmp = spob->other_arch->instance ();
285	if (tmp == NULL)	283	if (tmp == NULL)
286	return 0;	284	return 0;
287		285
288	/* peterm: level dependency for bolts */	286	/* peterm: level dependency for bolts */
289	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);
290	tmp->attacktype = spob->attacktype;	288	tmp->attacktype = spob->attacktype;
		289
291	if (spob->slaying)	290	if (spob->slaying)
292	tmp->slaying = spob->slaying;	291	tmp->slaying = spob->slaying;
		292
293	tmp->range = spob->range + SP_level_range_adjust (caster, spob);	293	tmp->range = spob->range + SP_level_range_adjust (caster, spob);
294	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);	294	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
295	tmp->stats.Dex = spob->stats.Dex;	295	tmp->stats.Dex = spob->stats.Dex;
296	tmp->stats.Con = spob->stats.Con;	296	tmp->stats.Con = spob->stats.Con;
297		297
298	tmp->direction = dir;	298	tmp->direction = dir;
299	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	299	if (tmp->flag [FLAG_IS_TURNABLE])
300	SET_ANIMATION (tmp, dir);	300	SET_ANIMATION (tmp, dir);
301		301
302	tmp->set_owner (op);	302	tmp->set_owner (op);
303	set_spell_skill (op, caster, spob, tmp);	303	set_spell_skill (op, caster, spob, tmp);
304		304
305	tmp->x = op->x + DIRX (tmp);	305	tmp->x = op->x + DIRX (tmp->direction);
306	tmp->y = op->y + DIRY (tmp);	306	tmp->y = op->y + DIRY (tmp->direction);
307	tmp->map = op->map;	307	tmp->map = op->map;
308		308
309	maptile *newmap;	309	maptile *newmap;
310	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);
311	if (mflags & P_OUT_OF_MAP)	311	if (mflags & P_OUT_OF_MAP)
312	{	312	{
313	tmp->destroy ();	313	tmp->drop_and_destroy ();
314	return 0;	314	return 0;
315	}	315	}
316		316
317	tmp->map = newmap;	317	tmp->map = newmap;
318		318
319	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)))
320	{	320	{
321	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	321	if (!tmp->flag [FLAG_REFLECTING])
322	{	322	{
323	tmp->destroy ();	323	tmp->drop_and_destroy ();
324	return 0;	324	return 0;
325	}	325	}
326		326
327	tmp->x = op->x;	327	tmp->x = op->x;
328	tmp->y = op->y;	328	tmp->y = op->y;
…		…
364	{	364	{
365	for (i = 1; i < 9; i++)	365	for (i = 1; i < 9; i++)
366	{	366	{
367	sint16 dx, dy;	367	sint16 dx, dy;
368		368
369	dx = op->x + freearr_x[i];	369	dx = op->x + DIRX (i);
370	dy = op->y + freearr_y[i];	370	dy = op->y + DIRY (i);
371		371
372	/* ok_to_put_more already does things like checks for walls,	372	/* ok_to_put_more already does things like checks for walls,
373	* out of map, etc.	373	* out of map, etc.
374	*/	374	*/
375	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))
376	{	376	{
377	object *tmp = op->clone ();	377	object *tmp = op->clone ();
…		…
389		389
390	/* Causes an object to explode, eg, a firebullet,	390	/* Causes an object to explode, eg, a firebullet,
391	* poison cloud ball, etc. op is the object to	391	* poison cloud ball, etc. op is the object to
392	* explode.	392	* explode.
393	*/	393	*/
394	void	394	static void
395	explode_bullet (object *op)	395	explode_bullet (object *op)
396	{	396	{
397	object *tmp, *owner;	397	object *tmp, *owner;
398		398
399	if (op->other_arch == NULL)	399	if (!op->other_arch)
400	{	400	{
401	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	401	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
402	op->destroy ();	402	op->destroy ();
403	return;	403	return;
404	}	404	}
…		…
433	}	433	}
434		434
435	if (op->attacktype)	435	if (op->attacktype)
436	{	436	{
437	hit_map (op, 0, op->attacktype, 1);	437	hit_map (op, 0, op->attacktype, 1);
		438
438	if (op->destroyed ())	439	if (op->destroyed ())
439	return;	440	return;
440	}	441	}
441		442
442	/* other_arch contains what this explodes into */	443	/* other_arch contains what this explodes into */
443	tmp = arch_to_object (op->other_arch);	444	tmp = op->other_arch->instance ();
444		445
445	tmp->set_owner (op);	446	tmp->set_owner (op);
446	tmp->skill = op->skill;	447	tmp->skill = op->skill;
447		448
448	owner = op->owner;	449	owner = op->owner;
449		450
450	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))
451	{	455	{
452	op->destroy ();	456	op->destroy ();
453	return;	457	return;
454	}	458	}
455		459
…		…
517	if (!(mflags & P_IS_ALIVE))	521	if (!(mflags & P_IS_ALIVE))
518	return;	522	return;
519		523
520	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	524	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
521	{	525	{
522	if (QUERY_FLAG (tmp, FLAG_ALIVE))	526	if (tmp->flag [FLAG_ALIVE])
523	{	527	{
524	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
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. */
554	if (op->stats.sp == SP_METEOR)	556	if (op->stats.sp == SP_METEOR)
555	{	557	{
556	replace_insert_ob_in_map ("fire_trail", op);	558	replace_insert_ob_in_map ("fire_trail", op);
557	if (op->destroyed ())	559	if (op->destroyed ())
…		…
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
647	tmp->x = op->x + freearr_x[dir];	651	tmp->x = op->x + DIRX (dir);
648	tmp->y = op->y + freearr_y[dir];	652	tmp->y = op->y + DIRY (dir);
649	tmp->map = op->map;	653	tmp->map = op->map;
650		654
651	maptile *newmap;	655	maptile *newmap;
652	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);
653	if (mflags & P_OUT_OF_MAP)	657	if (mflags & P_OUT_OF_MAP)
…		…
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 */
…		…
703	/* 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 */
704		721
705	void	722	void
706	move_cone (object *op)	723	move_cone (object *op)
707	{	724	{
708	int i;
709
710	/* 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 */
711	if (!op->map)	726	if (!op->map)
712	{	727	{
713	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");
714	op->set_speed (0);	729	op->set_speed (0);
715	return;	730	return;
716	}	731	}
717		732
718	/* lava saves it's life, but not yours :) */	733	/* lava saves it's life, but not yours :) */
719	if (QUERY_FLAG (op, FLAG_LIFESAVE))	734	if (op->flag [FLAG_LIFESAVE])
720	{	735	{
721	hit_map (op, 0, op->attacktype, 0);	736	hit_map (op, 0, op->attacktype, 0);
722	return;	737	return;
723	}	738	}
724		739
…		…
734	}	749	}
735	#endif	750	#endif
736		751
737	hit_map (op, 0, op->attacktype, 0);	752	hit_map (op, 0, op->attacktype, 0);
738		753
		754	if (!op->is_on_map ())
		755	return;
		756
739	/* Check to see if we should push anything.	757	/* Check to see if we should push anything.
740	* Spell objects with weight push whatever they encounter to some	758	* Spell objects with weight push whatever they encounter to some
741	* degree.	759	* degree.
742	*/	760	*/
743	if (op->weight)	761	if (op->weight)
		762	{
744	check_spell_knockback (op);	763	check_spell_knockback (op);
745		764
746	if (op->destroyed ())	765	if (!op->is_on_map ())
747	return;	766	return;
		767	}
748		768
749	if ((op->duration--) < 0)	769	if (op->duration-- < 0)
750	{	770	{
751	op->destroy ();	771	op->destroy ();
752	return;	772	return;
753	}	773	}
754	/* Object has hit maximum range, so don't have it move	774	/* Object has hit maximum range, so don't have it move
…		…
759	{	779	{
760	op->range = 0; /* just so it doesn't wrap */	780	op->range = 0; /* just so it doesn't wrap */
761	return;	781	return;
762	}	782	}
763		783
764	for (i = -1; i < 2; i++)	784	for (int i = -1; i <= 1; i++)
765	{	785	{
766	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));
767		787
768	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))
769	{	789	{
770	object *tmp = op->clone ();	790	object *tmp = op->clone ();
771		791
…		…
800	MoveType movetype;	820	MoveType movetype;
801		821
802	if (!spell->other_arch)	822	if (!spell->other_arch)
803	return 0;	823	return 0;
804		824
805	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)
806	{	826	{
807	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!");
808	return 0;	828	return 0;
809	}	829	}
810		830
811	if (!dir)	831	if (!dir)
812	{	832	{
…		…
820	*/	840	*/
821	movetype = spell->other_arch->move_type;	841	movetype = spell->other_arch->move_type;
822		842
823	for (i = range_min; i <= range_max; i++)	843	for (i = range_min; i <= range_max; i++)
824	{	844	{
825	sint16 x, y, d;	845	sint16 x, y;
826		846
827	/* We can't use absdir here, because it never returns	847	/* We can't use absdir here, because it never returns
828	* 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
829	* 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
830	* to hit that person.	850	* to hit that person.
831	*/	851	*/
832	d = dir + i;	852	int d = dir ? absdir (dir + i) : i;
833	while (d < 0)
834	d += 8;
835	while (d > 8)
836	d -= 8;
837		853
838	/* 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.
839	* In that case, we have to see - if dir is specified,	855	* In that case, we have to see - if dir is specified,
840	* turn this into direction 8. If dir is not specified (all	856	* turn this into direction 8. If dir is not specified (all
841	* direction) skip - otherwise, one line would do more damage	857	* direction) skip - otherwise, one line would do more damage
…		…
848	d = 8;	864	d = 8;
849	else	865	else
850	continue;	866	continue;
851	}	867	}
852		868
853	x = op->x + freearr_x[d];	869	x = op->x + DIRX (d);
854	y = op->y + freearr_y[d];	870	y = op->y + DIRY (d);
855		871
856	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)
857	continue;	873	continue;
858		874
859	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	875	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
860	continue;	876	continue;
861		877
862	success = 1;	878	success = 1;
863	tmp = arch_to_object (spell->other_arch);	879	tmp = spell->other_arch->instance ();
864	tmp->set_owner (op);	880	tmp->set_owner (op);
865	set_spell_skill (op, caster, spell, tmp);	881	set_spell_skill (op, caster, spell, tmp);
866	tmp->level = caster_level (caster, spell);	882	tmp->level = casting_level (caster, spell);
867	tmp->attacktype = spell->attacktype;	883	tmp->attacktype = spell->attacktype;
868		884
869	/* holy word stuff */	885	/* holy word stuff */
870	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))	886	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
871	if (!tailor_god_spell (tmp, op))	887	if (!tailor_god_spell (tmp, op))
…		…
943		959
944	object *env = op->outer_env ();	960	object *env = op->outer_env ();
945		961
946	if (op->env)	962	if (op->env)
947	{	963	{
948	if (env->map == NULL)	964	if (!env->map)
949	return;	965	return;
950		966
951	if (!(op = op->insert_at (env, op)))	967	if (!(op = op->insert_at (env, op)))
952	return;	968	return;
953	}	969	}
954		970
955	// 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
956	// 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
957	// as bombs can be carried.	973	// as bombs can be carried.
958	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	974	if (op->ms ().flags () & P_SAFE)
959	{	975	{
960	op->destroy ();	976	op->destroy ();
961	return;	977	return;
962	}	978	}
963		979
…		…
967	*/	983	*/
968	if (archetype *at = archetype::find (SPLINT))	984	if (archetype *at = archetype::find (SPLINT))
969	{	985	{
970	for (int i = 1; i < 9; i++)	986	for (int i = 1; i < 9; i++)
971	{	987	{
972	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)))
973	continue;	989	continue;
974		990
975	object *tmp = arch_to_object (at);	991	object *tmp = at->instance ();
976	tmp->direction = i;	992	tmp->direction = i;
977	tmp->range = op->range;	993	tmp->range = op->range;
978	tmp->stats.dam = op->stats.dam;	994	tmp->stats.dam = op->stats.dam;
979	tmp->duration = op->duration;	995	tmp->duration = op->duration;
980	tmp->attacktype = op->attacktype;	996	tmp->attacktype = op->attacktype;
981	tmp->set_owner (op);	997	tmp->set_owner (op);
982	if (op->skill && op->skill != tmp->skill)	998	if (op->skill && op->skill != tmp->skill)
983	tmp->skill = op->skill;	999	tmp->skill = op->skill;
984		1000
985	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	1001	if (tmp->flag [FLAG_IS_TURNABLE])
986	SET_ANIMATION (tmp, i);	1002	SET_ANIMATION (tmp, i);
987		1003
988	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);
989	move_bullet (tmp);	1005	move_bullet (tmp);
990	}	1006	}
991	}	1007	}
992		1008
993	explode_bullet (op);	1009	explode_bullet (op);
…		…
996	int	1012	int
997	create_bomb (object *op, object *caster, int dir, object *spell)	1013	create_bomb (object *op, object *caster, int dir, object *spell)
998	{	1014	{
999	object *tmp;	1015	object *tmp;
1000	int mflags;	1016	int mflags;
1001	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);
1002	maptile *m;	1018	maptile *m;
1003		1019
1004	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	{
1005	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))
1006	{	1029	{
1007	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1030	op->failmsg ("There is something in the way.");
1008	return 0;	1031	return 0;
		1032	}
1009	}	1033	}
1010		1034
1011	tmp = arch_to_object (spell->other_arch);	1035	tmp = spell->other_arch->instance ();
1012		1036
1013	/* level dependencies for bomb */	1037	/* level dependencies for bomb */
1014	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1038	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1015	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);
1016	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1040	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
1036	* dir is the direction to look in.	1060	* dir is the direction to look in.
1037	* range is how far out to look.	1061	* range is how far out to look.
1038	* 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.
1039	* this info is used for blocked magic/unholy spaces.	1063	* this info is used for blocked magic/unholy spaces.
1040	*/	1064	*/
1041	object *	1065	static object *
1042	get_pointed_target (object *op, int dir, int range, int type)	1066	get_pointed_target (object *op, int dir, int range, int type)
1043	{	1067	{
1044	object *target;	1068	object *target;
1045	sint16 x, y;	1069	sint16 x, y;
1046	int dist, mflags;	1070	int dist, mflags;
…		…
1049	if (dir == 0)	1073	if (dir == 0)
1050	return NULL;	1074	return NULL;
1051		1075
1052	for (dist = 1; dist < range; dist++)	1076	for (dist = 1; dist < range; dist++)
1053	{	1077	{
1054	x = op->x + freearr_x[dir] * dist;	1078	x = op->x + DIRX (dir) * dist;
1055	y = op->y + freearr_y[dir] * dist;	1079	y = op->y + DIRY (dir) * dist;
1056	mp = op->map;	1080	mp = op->map;
1057	mflags = get_map_flags (op->map, &mp, x, y, &x, &y);	1081	mflags = get_map_flags (op->map, &mp, x, y, &x, &y);
1058		1082
1059	if (mflags & P_OUT_OF_MAP)	1083	if (mflags & P_OUT_OF_MAP)
1060	return NULL;	1084	return NULL;
…		…
1065	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1089	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1066	return NULL;	1090	return NULL;
1067		1091
1068	if (mflags & P_IS_ALIVE)	1092	if (mflags & P_IS_ALIVE)
1069	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)
1070	if (QUERY_FLAG (target, FLAG_MONSTER))	1094	if (target->flag [FLAG_MONSTER])
1071	return target;	1095	return target;
1072	}	1096	}
1073		1097
1074	return NULL;	1098	return NULL;
1075	}	1099	}
1076		1100
1077	/* cast_smite_arch() - the priest points to a creature and causes	1101	/* cast_smite_spell() - the priest points to a creature and causes
1078	* a 'godly curse' to decend.	1102	* a 'godly curse' to decend.
1079	* usual params -	1103	* usual params -
1080	* op = player	1104	* op = player
1081	* caster = object casting the spell.	1105	* caster = object casting the spell.
1082	* dir = direction being cast	1106	* dir = direction being cast
1083	* spell = spell object	1107	* spell = spell object
…		…
1085	int	1109	int
1086	cast_smite_spell (object *op, object *caster, int dir, object *spell)	1110	cast_smite_spell (object *op, object *caster, int dir, object *spell)
1087	{	1111	{
1088	object *effect, *target;	1112	object *effect, *target;
1089	object *god = find_god (determine_god (op));	1113	object *god = find_god (determine_god (op));
1090	int range;
1091		1114
1092	range = spell->range + SP_level_range_adjust (caster, spell);
1093	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);
1094		1116
1095	/* Bunch of conditions for casting this spell. Note that only	1117	/* Bunch of conditions for casting this spell. Note that only
1096	* require a god if this is a cleric spell (requires grace).	1118	* require a god if this is a cleric spell (requires grace).
1097	* 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
1098	* 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
1099	* interesting spell.	1121	* interesting spell.
1100	* 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
1101	* can't be friendly to your god.	1123	* can't be friendly to your god.
1102	*/	1124	*/
1103		1125
1104	if (!target || QUERY_FLAG (target, FLAG_REFL_SPELL)	1126	if (!target
		1127	|| target->flag [FLAG_REFL_SPELL]
1105	|| (!god && spell->stats.grace)	1128	|| (!god && spell->stats.grace)
1106	|| (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)))
1107	{	1131	{
1108	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1132	op->failmsg ("Your request is unheeded.");
1109	return 0;	1133	return 0;
1110	}	1134	}
1111		1135
1112	if (spell->other_arch)	1136	if (spell->other_arch)
1113	effect = arch_to_object (spell->other_arch);	1137	effect = spell->other_arch->instance ();
1114	else	1138	else
1115	return 0;	1139	return 0;
1116		1140
1117	/* tailor the effect by priest level and worshipped God */	1141	/* tailor the effect by priest level and worshipped God */
1118	effect->level = caster_level (caster, spell);	1142	effect->level = casting_level (caster, spell);
1119	effect->attacktype = spell->attacktype;	1143	effect->attacktype = spell->attacktype;
1120	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))	1144	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1121	{	1145	{
1122	if (tailor_god_spell (effect, op))	1146	if (tailor_god_spell (effect, op))
1123	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));
1124	else	1148	else
1125	{	1149	{
1126	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1150	op->failmsg ("Your request is ignored.");
1127	return 0;	1151	return 0;
1128	}	1152	}
1129	}	1153	}
1130		1154
1131	/* size of the area of destruction */	1155	/* size of the area of destruction */
…		…
1135	if (effect->attacktype & AT_DEATH)	1159	if (effect->attacktype & AT_DEATH)
1136	{	1160	{
1137	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1161	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1138		1162
1139	/* casting death spells at undead isn't a good thing */	1163	/* casting death spells at undead isn't a good thing */
1140	if (QUERY_FLAG (target, FLAG_UNDEAD))	1164	if (target->flag [FLAG_UNDEAD])
1141	{	1165	{
1142	if (random_roll (0, 2, op, PREFER_LOW))	1166	if (random_roll (0, 2, op, PREFER_LOW))
1143	{	1167	{
1144	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1168	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1145	effect->x = op->x;	1169	effect->x = op->x;
…		…
1178		1202
1179	/* op is a missile that needs to be moved */	1203	/* op is a missile that needs to be moved */
1180	void	1204	void
1181	move_missile (object *op)	1205	move_missile (object *op)
1182	{	1206	{
1183	int i, mflags;
1184	object *owner;
1185	sint16 new_x, new_y;
1186	maptile *m;
1187
1188	if (op->range-- <= 0)	1207	if (op->range-- <= 0)
1189	{	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	{
1190	op->destroy ();	1218	op->destroy ();
1191	return;	1219	return;
1192	}	1220	}
1193		1221
1194	owner = op->owner;	1222	mapspace &ms = pos.ms ();
1195	#if 0
1196	/* It'd make things nastier if this wasn't here - spells cast by
1197	* monster that are then killed would continue to survive
1198	*/
1199	if (owner == NULL)
1200	{
1201	op->destroy ();
1202	return;
1203	}
1204	#endif
1205		1223
1206	new_x = op->x + DIRX (op);	1224	if (ms.flags () & P_IS_ALIVE || ms.blocks (op))
1207	new_y = op->y + DIRY (op);
1208
1209	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1210
1211	if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1212	{	1225	{
1213	hit_map (op, op->direction, AT_MAGIC, 1);	1226	hit_map (op, op->direction, AT_MAGIC, 1);
1214	/* Basically, missile only hits one thing then goes away.	1227	/* Basically, missile only hits one thing then goes away.
1215	* 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.
1216	*/	1229	*/
1217	if (!op->destroyed ())
1218	op->destroy ();
1219
1220	return;
1221	}
1222
1223	op->remove ();
1224
1225	if (!op->direction || (mflags & P_OUT_OF_MAP))
1226	{
1227	op->destroy ();	1230	op->destroy ();
1228	return;	1231	return;
1229	}	1232	}
1230		1233
		1234	if (!op->direction)
		1235	{
		1236	op->destroy ();
		1237	return;
		1238	}
		1239
1231	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);
1232	if (i > 0 && i != op->direction)	1241	if (i > 0 && i != op->direction)
1233	{	1242	{
1234	op->direction = i;	1243	op->direction = i;
1235	SET_ANIMATION (op, op->direction);	1244	SET_ANIMATION (op, op->direction);
1236	}	1245	}
1237		1246
1238	m->insert (op, new_x, new_y, op);	1247	pos.insert (op, op);
1239	}	1248	}
1240		1249
1241	/****************************************************************************	1250	/****************************************************************************
1242	* Destruction	1251	* Destruction
1243	****************************************************************************/	1252	****************************************************************************/
1244		1253
1245	/* make_object_glow() - currently only makes living objects glow.	1254	/* make_object_glow() - currently only makes living objects glow.
1246	* 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
1247	* object. if time is 0, the object glows permanently. To truely	1256	* object. if time is 0, the object glows permanently. To truely
1248	* make this work for non-living objects, we would have to	1257	* make this work for non-living objects, we would have to
1249	* give them the capability to have an inventory. b.t.	1258	* give them the capability to have an inventory. b.t.
1250	*/	1259	*/
1251	int	1260	static int
1252	make_object_glow (object *op, int radius, int time)	1261	make_object_glow (object *op, int radius, int time)
1253	{	1262	{
1254	/* some things are unaffected... */	1263	/* some things are unaffected... */
1255	if (op->path_denied & PATH_LIGHT)	1264	if (op->path_denied & PATH_LIGHT)
1256	return 0;	1265	return 0;
1257		1266
1258	object *tmp = get_archetype (FORCE_NAME);	1267	object *tmp = archetype::get (FORCE_NAME);
1259	tmp->speed = 0.01;	1268	tmp->set_speed (0.01);
1260	tmp->stats.food = time;	1269	tmp->stats.food = time;
1261	SET_FLAG (tmp, FLAG_IS_USED_UP);	1270	tmp->set_flag (FLAG_IS_USED_UP);
1262	tmp->glow_radius = radius;	1271	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1263	if (tmp->glow_radius > MAX_LIGHT_RADII)
1264	tmp->glow_radius = MAX_LIGHT_RADII;
1265
1266	tmp = insert_ob_in_ob (tmp, op);	1272	tmp = insert_ob_in_ob (tmp, op);
1267		1273
1268	if (tmp->glow_radius > op->glow_radius)	1274	if (tmp->glow_radius > op->glow_radius)
1269	op->glow_radius = tmp->glow_radius;	1275	op->set_glow_radius (tmp->glow_radius);
1270		1276
1271	return 1;	1277	return 1;
1272	}	1278	}
1273		1279
1274	int	1280	int
1275	cast_destruction (object *op, object *caster, object *spell_ob)	1281	cast_destruction (object *op, object *caster, object *spell_ob)
1276	{	1282	{
1277	int i, j, range, mflags, friendly = 0, dam, dur;
1278	sint16 sx, sy;
1279	maptile *m;
1280	object *tmp;
1281	const char *skill;
1282
1283	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1283	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1284	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);
1285	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1285	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1286	if (QUERY_FLAG (op, FLAG_FRIENDLY) || op->type == PLAYER)
1287	friendly = 1;
1288		1286
1289	/* destruction doesn't use another spell object, so we need	1287	bool friendly = op->flag [FLAG_FRIENDLY] || op->is_player ();
1290	* update op's skill pointer so that exp is properly awarded.
1291	* We do some shortcuts here - since this is just temporary
1292	* and we'll reset the values back, we don't need to go through
1293	* the full share string/free_string route.
1294	*/
1295	skill = op->skill;
1296	if (caster == op)
1297	op->skill = spell_ob->skill;
1298	else if (caster->skill)
1299	op->skill = caster->skill;
1300	else
1301	op->skill = NULL;
1302		1288
1303	op->change_skill (find_skill_by_name (op, op->skill));	1289	dynbuf buf;
1304		1290	unordered_mapwalk (buf, op, -range, -range, range, range)
1305	for (i = -range; i < range; i++)
1306	{	1291	{
1307	for (j = -range; j < range; j++)	1292	mapspace &ms = m->at (nx, ny);
1308	{
1309	m = op->map;
1310	sx = op->x + i;
1311	sy = op->y + j;
1312		1293
1313	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1314	if (mflags & P_OUT_OF_MAP)
1315	continue;
1316
1317	if (mflags & P_IS_ALIVE)	1294	if (ms.flags () & P_IS_ALIVE)
		1295	for (object *next, *tmp = ms.bot; tmp; tmp = next)
1318	{	1296	{
1319	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1297	next = tmp->above;
1320	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1321	break;
1322		1298
1323	if (tmp)	1299	if (tmp->flag [FLAG_ALIVE] || tmp->is_player ())
1324	{	1300	{
1325	if (tmp->head)
1326	tmp = tmp->head;	1301	tmp = tmp->head_ ();
1327		1302
1328	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) ||	1303	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1329	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))	1304	|| (!friendly && (tmp->flag [FLAG_FRIENDLY] || tmp->is_player ())))
1330	{	1305	{
1331	if (spell_ob->subtype == SP_DESTRUCTION)	1306	if (spell_ob->subtype == SP_DESTRUCTION)
1332	{	1307	{
1333	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1308	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
		1309
1334	if (spell_ob->other_arch)	1310	if (spell_ob->other_arch)
1335	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1311	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1336	}	1312	}
1337	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)
1338	{	1314	{
1339	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1315	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1340	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1316	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1341	}	1317	}
1342	}	1318	}
1343	}	1319	}
1344	}	1320	}
1345	}
1346	}	1321	}
1347		1322
1348	op->skill = skill;
1349	return 1;	1323	return 1;
1350	}	1324	}
1351		1325
1352	/***************************************************************************	1326	/***************************************************************************
1353	*	1327	*
1354	* CURSE	1328	* CURSE
1355	*	1329	*
1356	***************************************************************************/	1330	***************************************************************************/
1357
1358	int	1331	int
1359	cast_curse (object *op, object *caster, object *spell_ob, int dir)	1332	cast_curse (object *op, object *caster, object *spell_ob, int dir)
1360	{	1333	{
1361	object *god = find_god (determine_god (op));	1334	object *god = find_god (determine_god (op));
1362	object *tmp, *force;	1335	object *tmp, *force;
1363		1336
1364	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);
1365	if (!tmp)	1338	if (!tmp)
1366	{	1339	{
1367	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.");
1368	return 0;	1341	return 0;
1369	}	1342	}
1370		1343
1371	tmp = tmp->head_ ();	1344	tmp = tmp->head_ ();
1372		1345
…		…
1387	}	1360	}
1388	}	1361	}
1389		1362
1390	if (!force)	1363	if (!force)
1391	{	1364	{
1392	force = get_archetype (FORCE_NAME);	1365	force = archetype::get (FORCE_NAME);
1393	force->subtype = FORCE_CHANGE_ABILITY;	1366	force->subtype = FORCE_CHANGE_ABILITY;
1394		1367
1395	if (spell_ob->race)	1368	if (spell_ob->race)
1396	force->name = spell_ob->race;	1369	force->name = spell_ob->race;
1397	else	1370	else
…		…
1415		1388
1416	return 1;	1389	return 1;
1417	}	1390	}
1418		1391
1419	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;
1420	force->speed = 1.f;
1421	force->speed_left = -1.f;	1393	force->speed_left = -1.f;
1422	SET_FLAG (force, FLAG_APPLIED);	1394	force->set_speed (1.f);
		1395	force->set_flag (FLAG_APPLIED);
1423		1396
1424	if (god)	1397	if (god)
1425	{	1398	{
1426	if (spell_ob->last_grace)	1399	if (spell_ob->last_grace)
1427	force->path_repelled = god->path_repelled;	1400	force->path_repelled = god->path_repelled;
…		…
1440	force->stats.wc = spell_ob->stats.wc;	1413	force->stats.wc = spell_ob->stats.wc;
1441		1414
1442	change_abil (tmp, force); /* Mostly to display any messages */	1415	change_abil (tmp, force); /* Mostly to display any messages */
1443	insert_ob_in_ob (force, tmp);	1416	insert_ob_in_ob (force, tmp);
1444	tmp->update_stats ();	1417	tmp->update_stats ();
		1418
1445	return 1;	1419	return 1;
1446
1447	}	1420	}
1448		1421
1449	/**********************************************************************	1422	/**********************************************************************
1450	* mood change	1423	* mood change
1451	* 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
…		…
1457	*/	1430	*/
1458	int	1431	int
1459	mood_change (object *op, object *caster, object *spell)	1432	mood_change (object *op, object *caster, object *spell)
1460	{	1433	{
1461	object *tmp, *god, *head;	1434	object *tmp, *god, *head;
1462	int done_one, range, mflags, level, at, best_at;	1435	int done_one, range, level, at, best_at;
1463	sint16 x, y, nx, ny;
1464	maptile *m;
1465	const char *race;	1436	const char *race;
1466		1437
1467	/* 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
1468	* doing it over and over again.	1439	* doing it over and over again.
1469	*/	1440	*/
1470	god = find_god (determine_god (op));	1441	god = find_god (determine_god (op));
1471	level = caster_level (caster, spell);	1442	level = casting_level (caster, spell);
1472	range = spell->range + SP_level_range_adjust (caster, spell);	1443	range = spell->range + SP_level_range_adjust (caster, spell);
1473		1444
1474	/* 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_...
1475	* 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
1476	* won't ever match anything.	1447	* won't ever match anything.
1477	*/	1448	*/
1478	if (!spell->race)	1449	if (!spell->race)
1479	race = NULL;	1450	race = NULL;
1480	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1451	else if (god && spell->race == shstr_GOD_SLAYING)
1481	race = god->slaying;	1452	race = god->slaying;
1482	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1453	else if (god && spell->race == shstr_GOD_FRIEND)
1483	race = god->race;	1454	race = god->race;
1484	else	1455	else
1485	race = spell->race;	1456	race = spell->race;
1486		1457
1487	for (x = op->x - range; x <= op->x + range; x++)	1458	dynbuf buf;
1488	for (y = op->y - range; y <= op->y + range; y++)	1459	unordered_mapwalk (buf, op, -range, -range, range, range)
1489	{	1460	{
1490	done_one = 0;	1461	mapspace &ms = m->at (nx, ny);
1491	m = op->map;
1492	nx = x;
1493	ny = y;
1494	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1495	if (mflags & P_OUT_OF_MAP)
1496	continue;
1497		1462
1498	/* 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 */
1499	if (!(mflags & P_IS_ALIVE))	1464	if (!(ms.flags () & P_IS_ALIVE))
1500	continue;	1465	continue;
1501		1466
1502	// players can only affect spaces that they can actually see	1467	// players can only affect spaces that they can actually see
		1468	if (caster
1503	if (caster && caster->contr	1469	&& caster->contr
1504	&& caster->contr->visibility_at (m, nx, ny) < 70)	1470	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1505	continue;	1471	continue;
1506		1472
1507	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1473	for (tmp = ms.top; tmp; tmp = tmp->below)
1508	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1474	if (tmp->flag [FLAG_MONSTER])
1509	break;	1475	break;
1510		1476
1511	/* There can be living objects that are not monsters */	1477	/* There can be living objects that are not monsters */
1512	if (!tmp || tmp->type == PLAYER)	1478	if (!tmp)
1513	continue;	1479	continue;
1514		1480
1515	/* Only the head has meaningful data, so resolve to that */	1481	/* Only the head has meaningful data, so resolve to that */
1516	if (tmp->head)
1517	head = tmp->head;	1482	head = tmp->head_ ();
1518	else
1519	head = tmp;
1520		1483
1521	/* 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 */
1522	if (race && head->race && !strstr (race, head->race))	1485	if (race && head->race && !strstr (race, head->race))
1523	continue;	1486	continue;
1524		1487
1525	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1488	if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
1526	continue;	1489	continue;
1527		1490
1528	/* Now do a bunch of stuff related to saving throws */	1491	/* Now do a bunch of stuff related to saving throws */
1529	best_at = -1;	1492	best_at = -1;
1530	if (spell->attacktype)	1493	if (spell->attacktype)
1531	{	1494	{
1532	for (at = 0; at < NROFATTACKS; at++)	1495	for (at = 0; at < NROFATTACKS; at++)
1533	if (spell->attacktype & (1 << at))	1496	if (spell->attacktype & (1 << at))
1534	if (best_at == -1 || head->resist[at] > head->resist[best_at])	1497	if (best_at == -1 || head->resist[at] > head->resist[best_at])
1535	best_at = at;	1498	best_at = at;
1536		1499
1537	if (best_at == -1)	1500	if (best_at == -1)
1538	at = 0;	1501	at = 0;
1539	else	1502	else
1540	{	1503	{
1541	if (head->resist[best_at] == 100)	1504	if (head->resist[best_at] == 100)
1542	continue;	1505	continue;
1543	else	1506	else
1544	at = head->resist[best_at] / 5;	1507	at = head->resist[best_at] / 5;
1545	}	1508	}
		1509
1546	at -= level / 5;	1510	at -= level / 5;
1547	if (did_make_save (head, head->level, at))	1511	if (did_make_save (head, head->level, at))
1548	continue;	1512	continue;
1549	}	1513	}
1550	else /* spell->attacktype */	1514	else /* spell->attacktype */
1551	{	1515	{
1552	/*	1516	/*
1553	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:
1554	* if spell level < monster level, no go	1518	* if spell level < monster level, no go
1555	* 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 ) )
1556		1520
1557	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.
1558		1522
1559	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
1560	charm a level 125 monster...	1524	charm a level 125 monster...
1561		1525
1562	Ryo, august 14th	1526	Ryo, august 14th
1563	*/	1527	*/
1564	if (head->level > level)	1528	if (head->level > level)
1565	continue;	1529	continue;
1566		1530
1567	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))))
1568	/* Failed, no effect */	1532	/* Failed, no effect */
1569	continue;	1533	continue;
1570	}	1534	}
1571		1535
1572	/* Done with saving throw. Now start affecting the monster */	1536	/* Done with saving throw. Now start affecting the monster */
		1537	done_one = 0;
1573		1538
1574	/* aggravation */	1539	/* aggravation */
1575	if (QUERY_FLAG (spell, FLAG_MONSTER))	1540	if (spell->flag [FLAG_MONSTER])
1576	{	1541	{
1577	CLEAR_FLAG (head, FLAG_SLEEP);	1542	head->clr_flag (FLAG_SLEEP);
1578	remove_friendly_object (head);	1543	remove_friendly_object (head);
1579	done_one = 1;	1544	done_one = 1;
1580	head->enemy = op;	1545	head->enemy = op;
1581	}	1546	}
1582		1547
1583	/* calm monsters */	1548	/* calm monsters */
1584	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1549	if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
1585	{	1550	{
1586	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1551	head->set_flag (FLAG_UNAGGRESSIVE);
1587	head->enemy = NULL;	1552	head->enemy = NULL;
1588	done_one = 1;	1553	done_one = 1;
1589	}	1554	}
1590		1555
1591	/* berserk monsters */	1556	/* berserk monsters */
1592	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1557	if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
1593	{	1558	{
1594	SET_FLAG (head, FLAG_BERSERK);	1559	head->set_flag (FLAG_BERSERK);
1595	done_one = 1;	1560	done_one = 1;
1596	}	1561	}
1597		1562
1598	/* charm */	1563	/* charm */
1599	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1564	if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
1600	{	1565	{
1601	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));	1566	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
1602		1567
1603	/* Prevent uncontrolled outbreaks of self replicating monsters.	1568	/* Prevent uncontrolled outbreaks of self replicating monsters.
1604	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.
1605	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. */
1606	CLEAR_FLAG (head, FLAG_GENERATOR);	1571	head->clr_flag (FLAG_GENERATOR);
1607	head->set_owner (op);	1572	head->set_owner (op);
1608	set_spell_skill (op, caster, spell, head);	1573	set_spell_skill (op, caster, spell, head);
1609	add_friendly_object (head);	1574	add_friendly_object (head);
1610	head->attack_movement = PETMOVE;	1575	head->attack_movement = PETMOVE;
1611	done_one = 1;	1576	done_one = 1;
1612	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);
1613	head->stats.exp = 0;	1578	head->stats.exp = 0;
1614	}	1579	}
1615		1580
1616	/* If a monster was effected, put an effect in */	1581	/* If a monster was effected, put an effect in */
1617	if (done_one && spell->other_arch)	1582	if (done_one && spell->other_arch)
1618	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1583	m->insert (spell->other_arch->instance (), nx, ny, op);
1619	} /* for y */	1584	}
1620		1585
1621	return 1;	1586	return 1;
1622	}	1587	}
1623
1624		1588
1625	/* 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
1626	* 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
1627	* lightning spell used it, that seemed misnamed.	1591	* lightning spell used it, that seemed misnamed.
1628	* op is the spell effect.	1592	* op is the spell effect.
1629	* note that duration is handled by process_object() in time.c	1593	* note that duration is handled by process_object() in time.c
1630	*/	1594	*/
1631
1632	void	1595	void
1633	move_ball_spell (object *op)	1596	move_ball_spell (object *op)
1634	{	1597	{
1635	int i, j, dam_save, dir, mflags;	1598	int i, j, dam_save, dir, mflags;
1636	sint16 nx, ny, hx, hy;	1599	sint16 nx, ny, hx, hy;
…		…
1655	for (i = 1; i < 9; i++)	1618	for (i = 1; i < 9; i++)
1656	{	1619	{
1657	/* i bit 0: alters sign of offset	1620	/* i bit 0: alters sign of offset
1658	* other bits (i / 2): absolute value of offset	1621	* other bits (i / 2): absolute value of offset
1659	*/	1622	*/
1660
1661	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);	1623	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1662	int tmpdir = absdir (op->direction + offset);	1624	int tmpdir = absdir (op->direction + offset);
1663		1625
1664	nx = op->x + freearr_x[tmpdir];	1626	nx = op->x + DIRX (tmpdir);
1665	ny = op->y + freearr_y[tmpdir];	1627	ny = op->y + DIRY (tmpdir);
1666	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))))
1667	{	1629	{
1668	dir = tmpdir;	1630	dir = tmpdir;
1669	break;	1631	break;
1670	}	1632	}
1671	}	1633	}
		1634
1672	if (dir == 0)	1635	if (dir == 0)
1673	{	1636	{
1674	nx = op->x;	1637	nx = op->x;
1675	ny = op->y;	1638	ny = op->y;
1676	m = op->map;	1639	m = op->map;
1677	}	1640	}
1678		1641
1679	m->insert (op, nx, ny, op);	1642	m->insert (op, nx, ny, op);
1680		1643
1681	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
1682	surrounding squares */	1645	surrounding squares */
1683		1646
1684	/* loop over current square and neighbors to hit.	1647	/* loop over current square and neighbors to hit.
1685	* if this has an other_arch field, we insert that in	1648	* if this has an other_arch field, we insert that in
1686	* the surround spaces.	1649	* the surround spaces.
1687	*/	1650	*/
1688	for (j = 0; j < 9; j++)	1651	for (j = 0; j < 9; j++)
1689	{	1652	{
1690	hx = nx + freearr_x[j];	1653	hx = nx + DIRX (j);
1691	hy = ny + freearr_y[j];	1654	hy = ny + DIRY (j);
1692		1655
1693	m = op->map;	1656	m = op->map;
1694	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);	1657	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
1695		1658
1696	if (mflags & P_OUT_OF_MAP)	1659	if (mflags & P_OUT_OF_MAP)
…		…
1702		1665
1703	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)))
1704	{	1667	{
1705	if (j)	1668	if (j)
1706	op->stats.dam = dam_save / 2;	1669	op->stats.dam = dam_save / 2;
		1670
1707	hit_map (op, j, op->attacktype, 1);	1671	hit_map (op, j, op->attacktype, 1);
1708
1709	}	1672	}
1710		1673
1711	/* insert the other arch */	1674	/* insert the other arch */
1712	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))))
1713	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1676	m->insert (op->other_arch->instance (), hx, hy, op);
1714	}	1677	}
1715		1678
1716	/* restore to the center location and damage */	1679	/* restore to the center location and damage */
1717	op->stats.dam = dam_save;	1680	op->stats.dam = dam_save;
1718		1681
1719	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);
1720		1683
1721	if (i >= 0)	1684	if (i >= 0)
1722	{ /* we have a preferred direction! */	1685	{ /* we have a preferred direction! */
1723	/* pick another direction if the preferred dir is blocked. */	1686	/* pick another direction if the preferred dir is blocked. */
1724	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 ||
1725	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)))
1726	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */	1689	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1727		1690
1728	op->direction = i;	1691	op->direction = i;
1729	}	1692	}
1730	}	1693	}
1731		1694
1732	/* move_swarm_spell: peterm	1695	/* move_swarm_spell: peterm
1733	* 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
1734	* 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
1735	* 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
1736	* 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
1737	* 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.
1738	*/	1701	*/
1739	void	1702	void
1740	move_swarm_spell (object *op)	1703	move_swarm_spell (object *op)
1741	{	1704	{
1742	#if 0	1705	#if 0
…		…
1746	int adjustdir;	1709	int adjustdir;
1747	maptile *m;	1710	maptile *m;
1748	#endif	1711	#endif
1749	object *owner = op->env;	1712	object *owner = op->env;
1750		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
1751	if (!op->duration || !owner->is_on_map ())	1721	if (!op->duration || !owner->is_on_map ())
1752	{	1722	{
1753	op->destroy ();	1723	op->drop_and_destroy ();
1754	return;	1724	return;
1755	}	1725	}
1756		1726
1757	op->duration--;	1727	op->duration--;
1758		1728
1759	int basedir = op->direction;	1729	int basedir = op->direction;
1760	if (!basedir)	1730	if (!basedir)
		1731	{
1761	/* spray in all directions! 8) */	1732	/* spray in all directions! 8) */
1762	basedir = (op->facing += op->state) % 8 + 1;	1733	op->facing = (op->facing + op->state) & 7;
		1734	basedir = op->facing + 1;
		1735	}
1763		1736
1764	#if 0	1737	#if 0
1765	// this is bogus: it causes wrong places to be checked below	1738	// this is bogus: it causes wrong places to be checked below
1766	// (a wall 2 cells away will block the effect...) and	1739	// (a wall 2 cells away will block the effect...) and
1767	// 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
1768	// space.	1741	// space.
1769	// should be fixed later, but correctness before features...	1742	// should be fixed later, but correctness before features...
1770	// (schmorp)	1743	// (schmorp)
1771		1744
1772	/* new offset calculation to make swarm element distribution	1745	/* new offset calculation to make swarm element distribution
1773	* more uniform	1746	* more uniform
1774	*/	1747	*/
1775	if (op->duration)	1748	if (op->duration)
1776	{	1749	{
1777	if (basedir & 1)	1750	if (basedir & 1)
1778	{	1751	{
…		…
1786	else	1759	else
1787	{	1760	{
1788	adjustdir = 0; /* fire the last one from forward. */	1761	adjustdir = 0; /* fire the last one from forward. */
1789	}	1762	}
1790		1763
1791	target_x = op->x + freearr_x[absdir (basedir + adjustdir)];	1764	target_x = op->x + DIRX (absdir (basedir + adjustdir));
1792	target_y = op->y + freearr_y[absdir (basedir + adjustdir)];	1765	target_y = op->y + DIRY (absdir (basedir + adjustdir));
1793		1766
1794	/* 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
1795	* necessitates extra out_of_map check below	1768	* necessitates extra out_of_map check below
1796	*/	1769	*/
1797	origin_x = target_x - freearr_x[basedir];	1770	origin_x = target_x - DIRX (basedir);
1798	origin_y = target_y - freearr_y[basedir];	1771	origin_y = target_y - DIRY (basedir);
1799		1772
1800		1773
1801	/* 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
1802	* should just be a pointer to the spell in some inventory,	1775	* should just be a pointer to the spell in some inventory,
1803	* 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,
…		…
1834	}	1807	}
1835		1808
1836	/* fire_swarm:	1809	/* fire_swarm:
1837	* The following routine creates a swarm of objects. It actually	1810	* The following routine creates a swarm of objects. It actually
1838	* sets up a specific swarm object, which then fires off all	1811	* sets up a specific swarm object, which then fires off all
1839	* the parts of the swarm.	1812	* the parts of the swarm.
1840	*	1813	*
1841	* op: the owner	1814	* op: the owner
1842	* caster: the caster (owner, wand, rod, scroll)	1815	* caster: the caster (owner, wand, rod, scroll)
1843	* dir: the direction everything will be fired in	1816	* dir: the direction everything will be fired in
1844	* spell - the spell that is this spell.	1817	* spell - the spell that is this spell.
…		…
1849	{	1822	{
1850	if (!spell->other_arch)	1823	if (!spell->other_arch)
1851	return 0;	1824	return 0;
1852		1825
1853	object *tmp = archetype::get (SWARM_SPELL);	1826	object *tmp = archetype::get (SWARM_SPELL);
		1827
1854	set_spell_skill (op, caster, spell, tmp);	1828	set_spell_skill (op, caster, spell, tmp);
1855	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. */
1856	tmp->spell = spell->other_arch->instance ();	1830	tmp->spell = spell->other_arch->instance ();
1857	tmp->attacktype = tmp->spell->attacktype;	1831	tmp->attacktype = tmp->spell->attacktype;
1858		1832
1859	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)	1833	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1860	if (!tailor_god_spell (tmp, op))	1834	if (!tailor_god_spell (tmp, op))
…		…
1862		1836
1863	tmp->duration = SP_level_duration_adjust (caster, spell);	1837	tmp->duration = SP_level_duration_adjust (caster, spell);
1864	for (int i = 0; i < spell->duration; i++)	1838	for (int i = 0; i < spell->duration; i++)
1865	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1839	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1866		1840
		1841	tmp->invisible = 1;
		1842	tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1867	tmp->direction = dir;	1843	tmp->direction = dir;
1868	tmp->invisible = 1;
1869	tmp->facing = rndm (1, 8); // initial firing direction	1844	tmp->facing = rndm (1, 8); // initial firing direction
1870	tmp->state = rndm (4) * 2 + 1; // direction increment	1845	tmp->state = rndm (4) * 2 + 1; // direction increment
1871		1846
1872	op->insert (tmp);	1847	op->insert (tmp);
1873		1848
…		…
1885	int dam, mflags;	1860	int dam, mflags;
1886	maptile *m;	1861	maptile *m;
1887		1862
1888	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1863	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1889		1864
1890	if (!dir)	1865	if (dir)
1891	{
1892	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1893	return 0;
1894	}	1866	{
1895		1867	x = op->x + DIRX (dir);
1896	x = op->x + freearr_x[dir];	1868	y = op->y + DIRY (dir);
1897	y = op->y + freearr_y[dir];
1898	m = op->map;	1869	m = op->map;
1899		1870
1900	mflags = get_map_flags (m, &m, x, y, &x, &y);	1871	mflags = get_map_flags (m, &m, x, y, &x, &y);
1901		1872
1902	if (mflags & P_OUT_OF_MAP)	1873	if (mflags & P_OUT_OF_MAP)
1903	{	1874	{
1904	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1875	op->failmsg ("Nothing is there.");
1905	return 0;	1876	return 0;
1906	}	1877	}
1907		1878
1908	if (mflags & P_IS_ALIVE && spell->attacktype)	1879	if (mflags & P_IS_ALIVE && spell->attacktype)
1909	{	1880	{
1910	for (target = GET_MAP_OB (m, x, y); target; target = target->above)	1881	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1911	if (QUERY_FLAG (target, FLAG_MONSTER))	1882	if (target->flag [FLAG_MONSTER])
1912	{	1883	{
1913	/* oky doky. got a target monster. Lets make a blinding attack */	1884	/* oky doky. got a target monster. Lets make a blinding attack */
1914	if (target->head)	1885	if (target->head)
1915	target = target->head;	1886	target = target->head;
		1887
1916	(void) hit_player (target, dam, op, spell->attacktype, 1);	1888	hit_player (target, dam, op, spell->attacktype, 1);
1917	return 1; /* one success only! */	1889	return 1; /* one success only! */
		1890	}
1918	}	1891	}
1919	}
1920		1892
1921	/* no live target, perhaps a wall is in the way? */	1893	/* no live target, perhaps a wall is in the way? */
1922	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)))
1923	{	1895	{
1924	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1896	op->failmsg ("Something is in the way.");
1925	return 0;	1897	return 0;
		1898	}
1926	}	1899	}
1927		1900
1928	/* 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 */
1929	tmp = arch_to_object (spell->other_arch);	1902	tmp = spell->other_arch->instance ();
1930	if (!tmp)	1903	if (!tmp)
1931	{	1904	{
1932	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1905	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1933	return 0;	1906	return 0;
1934	}	1907	}
		1908
1935	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1909	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
		1910
1936	if (tmp->glow_radius)	1911	if (tmp->glow_radius)
1937	{	1912	tmp->set_glow_radius (
1938	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)
1939	if (tmp->glow_radius > MAX_LIGHT_RADII)	1914	);
1940	tmp->glow_radius = MAX_LIGHT_RADII;
1941	}
1942		1915
		1916	if (dir)
1943	m->insert (tmp, x, y, op);	1917	m->insert (tmp, x, y, op);
		1918	else
		1919	caster->outer_env_or_self ()->insert (tmp);
		1920
1944	return 1;	1921	return 1;
1945	}	1922	}
1946		1923
1947	/* cast_cause_disease: this spell looks along <dir> from the	1924	/* cast_cause_disease: this spell looks along <dir> from the
1948	* player and infects someone.	1925	* player and infects someone.
1949	* 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
1950	* 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
1951	* perhaps this should actually be in disease.c?	1928	* perhaps this should actually be in disease.c?
1952	*/	1929	*/
1953	int	1930	int
…		…
1959	maptile *m;	1936	maptile *m;
1960		1937
1961	x = op->x;	1938	x = op->x;
1962	y = op->y;	1939	y = op->y;
1963		1940
1964	/* 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
1965	* direction the player is pointing.	1942	* direction the player is pointing.
1966	*/	1943	*/
1967	if (!dir)	1944	if (!dir)
1968	dir = op->facing;	1945	dir = op->facing;
1969		1946
…		…
1976	dur_mod = SP_level_duration_adjust (caster, spell);	1953	dur_mod = SP_level_duration_adjust (caster, spell);
1977		1954
1978	/* search in a line for a victim */	1955	/* search in a line for a victim */
1979	for (i = 1; i < range; i++)	1956	for (i = 1; i < range; i++)
1980	{	1957	{
1981	x = op->x + i * freearr_x[dir];	1958	x = op->x + i * DIRX (dir);
1982	y = op->y + i * freearr_y[dir];	1959	y = op->y + i * DIRY (dir);
1983	m = op->map;	1960	m = op->map;
1984		1961
1985	mflags = get_map_flags (m, &m, x, y, &x, &y);	1962	mflags = get_map_flags (m, &m, x, y, &x, &y);
1986		1963
1987	if (mflags & P_OUT_OF_MAP)	1964	if (mflags & P_OUT_OF_MAP)
…		…
1994	/* 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 */
1995	if (mflags & P_IS_ALIVE)	1972	if (mflags & P_IS_ALIVE)
1996	{	1973	{
1997	/* search this square for a victim */	1974	/* search this square for a victim */
1998	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)
1999	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))	1976	if (walk->flag [FLAG_MONSTER] || (walk->type == PLAYER))
2000	{ /* found a victim */	1977	{ /* found a victim */
2001	object *disease = arch_to_object (spell->other_arch);	1978	object *disease = spell->other_arch->instance ();
2002		1979
2003	disease->set_owner (op);	1980	disease->set_owner (op);
2004	set_spell_skill (op, caster, spell, disease);	1981	set_spell_skill (op, caster, spell, disease);
2005	disease->stats.exp = 0;	1982	disease->stats.exp = 0;
2006	disease->level = caster_level (caster, spell);	1983	disease->level = casting_level (caster, spell);
2007		1984
2008	/* do level adjustments */	1985	/* do level adjustments */
2009	if (disease->stats.wc)	1986	if (disease->stats.wc ) disease->stats.wc += dur_mod / 2;
2010	disease->stats.wc += dur_mod / 2;	1987	if (disease->magic > 0) disease->magic += dur_mod / 8;
2011		1988	if (disease->stats.maxhp > 0) disease->stats.maxhp += dur_mod;
2012	if (disease->magic > 0)	1989	if (disease->stats.maxgrace > 0) disease->stats.maxgrace += dur_mod;
2013	disease->magic += dur_mod / 8;
2014
2015	if (disease->stats.maxhp > 0)
2016	disease->stats.maxhp += dur_mod;
2017
2018	if (disease->stats.maxgrace > 0)
2019	disease->stats.maxgrace += dur_mod;
2020
2021	if (disease->stats.dam)
2022	{
2023	if (disease->stats.dam > 0)
2024	disease->stats.dam += dam_mod;
2025	else
2026	disease->stats.dam -= dam_mod;
2027	}
2028		1990
2029	if (disease->last_sp)	1991	if (disease->last_sp)
2030	{	1992	{
2031	disease->last_sp -= 2 * dam_mod;	1993	disease->last_sp -= 2 * dam_mod;
		1994
2032	if (disease->last_sp < 1)	1995	if (disease->last_sp < 1)
2033	disease->last_sp = 1;	1996	disease->last_sp = 1;
2034	}	1997	}
2035		1998
2036	if (disease->stats.maxsp)	1999	if (disease->stats.dam ) disease->stats.dam += copysignl (disease->stats.dam , dam_mod);
2037	{	2000	if (disease->stats.maxsp) disease->stats.maxsp += copysignl (disease->stats.maxsp, dam_mod);
2038	if (disease->stats.maxsp > 0)	2001	if (disease->stats.ac ) disease->stats.ac += dam_mod;
2039	disease->stats.maxsp += dam_mod;	2002	if (disease->last_eat ) disease->last_eat -= dam_mod;
2040	else	2003	if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2041	disease->stats.maxsp -= dam_mod;	2004	if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2042	}
2043
2044	if (disease->stats.ac)
2045	disease->stats.ac += dam_mod;
2046
2047	if (disease->last_eat)
2048	disease->last_eat -= dam_mod;
2049
2050	if (disease->stats.hp)
2051	disease->stats.hp -= dam_mod;
2052
2053	if (disease->stats.sp)
2054	disease->stats.sp -= dam_mod;
2055		2005
2056	if (infect_object (walk, disease, 1))	2006	if (infect_object (walk, disease, 1))
2057	{	2007	{
2058	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));
2059		2009
2060	disease->destroy (); /* don't need this one anymore */	2010	disease->destroy (); /* don't need this one anymore */
2061	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2011	walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
2062	return 1;	2012	return 1;
2063	}	2013	}
2064		2014
2065	disease->destroy ();	2015	disease->destroy ();
2066	}	2016	}

Diff Legend

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