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

Diff Legend

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