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.66 by root, Mon Sep 29 10:31:32 2008 UTC vs.
Revision 1.117 by root, Sat Nov 17 23:40:04 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	void	43	static void
42	check_spell_knockback (object *op)	44	check_spell_knockback (object *op)
43	{	45	{
44	int weight_move;	46	int weight_move;
45	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 */
46		48
…		…
58	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)	60	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
59	{	61	{
60	int num_sections = 1;	62	int num_sections = 1;
61		63
62	/* don't move DM */	64	/* don't move DM */
63	if (QUERY_FLAG (tmp, FLAG_WIZ))	65	if (tmp->flag [FLAG_WIZ])
64	return;	66	return;
65		67
66	/* don't move parts of objects */	68	/* don't move parts of objects */
67	if (tmp->head)	69	if (tmp->head)
68	continue;	70	continue;
69		71
70	/* don't move floors or immobile objects */	72	/* don't move floors or immobile objects */
71	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))	73	if (tmp->flag [FLAG_IS_FLOOR] || (!tmp->flag [FLAG_ALIVE] && tmp->flag [FLAG_NO_PICK]))
72	continue;	74	continue;
73		75
74	/* count the object's sections */	76	/* count the object's sections */
75	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)	77	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
76	num_sections++;	78	num_sections++;
…		…
85	if (tmp->move_type & MOVE_FLYING)	87	if (tmp->move_type & MOVE_FLYING)
86	frictionmod = 1; /* flying objects loose the friction modifier */	88	frictionmod = 1; /* flying objects loose the friction modifier */
87		89
88	if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))	90	if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))
89	{ /* move it. */	91	{ /* move it. */
90	/* move_object is really for monsters, but looking at	92	/* move_object is really for monsters, but looking at
91	* the move_object function, it appears that it should	93	* the move_object function, it appears that it should
92	* also be safe for objects.	94	* also be safe for objects.
93	* This does return if successful or not, but	95	* This does return if successful or not, but
94	* I don't see us doing anything useful with that information	96	* I don't see us doing anything useful with that information
95	* right now.	97	* right now.
96	*/	98	*/
97	move_object (tmp, absdir (op->stats.sp));	99	tmp->move (absdir (op->stats.sp));
98	}	100	}
99		101
100	}	102	}
101	}	103	}
102		104
…		…
107	***************************************************************************/	109	***************************************************************************/
108		110
109	/* Causes op to fork. op is the original bolt, tmp	111	/* Causes op to fork. op is the original bolt, tmp
110	* is the first piece of the fork.	112	* is the first piece of the fork.
111	*/	113	*/
112	void	114	static void
113	forklightning (object *op, object *tmp)	115	forklightning (object *op, object *tmp)
114	{	116	{
115	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 */
116	int t_dir; /* stores temporary dir calculation */	118	int t_dir; /* stores temporary dir calculation */
117	maptile *m;	119	maptile *m;
…		…
128	new_dir = -1;	130	new_dir = -1;
129		131
130	/* check the new dir for a wall and in the map */	132	/* check the new dir for a wall and in the map */
131	t_dir = absdir (tmp->direction + new_dir);	133	t_dir = absdir (tmp->direction + new_dir);
132		134
133	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)
134	return;	136	return;
135		137
136	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)))
137	return;	139	return;
138		140
…		…
178		180
179	if (--op->range < 0)	181	if (--op->range < 0)
180	op->range = 0;	182	op->range = 0;
181	else	183	else
182	{	184	{
183	x = op->x + DIRX (op);	185	x = op->x + DIRX (op->direction);
184	y = op->y + DIRY (op);	186	y = op->y + DIRY (op->direction);
185	m = op->map;	187	m = op->map;
186	mflags = get_map_flags (m, &m, x, y, &x, &y);	188	mflags = get_map_flags (m, &m, x, y, &x, &y);
187		189
188	if (mflags & P_OUT_OF_MAP)	190	if (mflags & P_OUT_OF_MAP)
189	return;	191	return;
…		…
193	* 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
194	* will be useful.	196	* will be useful.
195	*/	197	*/
196	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)))
197	{	199	{
198	if (!QUERY_FLAG (op, FLAG_REFLECTING))	200	if (!op->flag [FLAG_REFLECTING])
199	return;	201	return;
200		202
201	/* Since walls don't run diagonal, if the bolt is in	203	/* Since walls don't run diagonal, if the bolt is in
202	* one of 4 main directions, it just reflects back in the	204	* one of 4 main directions, it just reflects back in the
203	* opposite direction. However, if the bolt is travelling	205	* opposite direction. However, if the bolt is travelling
…		…
216	/* 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
217	* over a corner in a tiled map, it is possible that	219	* over a corner in a tiled map, it is possible that
218	* op->direction is within an adjacent map but either	220	* op->direction is within an adjacent map but either
219	* op->direction-1 or op->direction+1 does not exist.	221	* op->direction-1 or op->direction+1 does not exist.
220	*/	222	*/
221	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)),
222	op->y + freearr_y[absdir (op->direction - 1)], &x, &y);	224	op->y + DIRY (absdir (op->direction - 1)), &x, &y);
223		225
224	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));
225		227
226	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)),
227	op->y + freearr_y[absdir (op->direction + 1)], &x, &y);	229	op->y + DIRY (absdir (op->direction + 1)), &x, &y);
228	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));
229		231
230	if (left == right)	232	if (left == right)
231	op->direction = absdir (op->direction + 4);	233	op->direction = absdir (op->direction + 4);
232	else if (left)	234	else if (left)
…		…
246	tmp->speed_left = -0.1f;	248	tmp->speed_left = -0.1f;
247	/* 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 */
248	tmp->duration++;	250	tmp->duration++;
249		251
250	/* New forking code. Possibly create forks of this object	252	/* New forking code. Possibly create forks of this object
251	* going off in other directions.	253	* going off in other directions.
252	*/	254	*/
253	if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)	255	if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
254	forklightning (op, tmp); /* stats.Dex % of forking */	256	forklightning (op, tmp); /* stats.Dex % of forking */
255		257
256	/* 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
…		…
276	int mflags;	278	int mflags;
277		279
278	if (!spob->other_arch)	280	if (!spob->other_arch)
279	return 0;	281	return 0;
280		282
281	tmp = arch_to_object (spob->other_arch);	283	tmp = spob->other_arch->instance ();
282	if (tmp == NULL)	284	if (tmp == NULL)
283	return 0;	285	return 0;
284		286
285	/* peterm: level dependency for bolts */	287	/* peterm: level dependency for bolts */
286	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);
…		…
293	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);	295	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
294	tmp->stats.Dex = spob->stats.Dex;	296	tmp->stats.Dex = spob->stats.Dex;
295	tmp->stats.Con = spob->stats.Con;	297	tmp->stats.Con = spob->stats.Con;
296		298
297	tmp->direction = dir;	299	tmp->direction = dir;
298	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	300	if (tmp->flag [FLAG_IS_TURNABLE])
299	SET_ANIMATION (tmp, dir);	301	SET_ANIMATION (tmp, dir);
300		302
301	tmp->set_owner (op);	303	tmp->set_owner (op);
302	set_spell_skill (op, caster, spob, tmp);	304	set_spell_skill (op, caster, spob, tmp);
303		305
304	tmp->x = op->x + DIRX (tmp);	306	tmp->x = op->x + DIRX (tmp->direction);
305	tmp->y = op->y + DIRY (tmp);	307	tmp->y = op->y + DIRY (tmp->direction);
306	tmp->map = op->map;	308	tmp->map = op->map;
307		309
308	maptile *newmap;	310	maptile *newmap;
309	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);
310	if (mflags & P_OUT_OF_MAP)	312	if (mflags & P_OUT_OF_MAP)
…		…
315		317
316	tmp->map = newmap;	318	tmp->map = newmap;
317		319
318	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)))
319	{	321	{
320	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	322	if (!tmp->flag [FLAG_REFLECTING])
321	{	323	{
322	tmp->drop_and_destroy ();	324	tmp->drop_and_destroy ();
323	return 0;	325	return 0;
324	}	326	}
325		327
…		…
351	maptile *m = op->map;	353	maptile *m = op->map;
352	int i;	354	int i;
353		355
354	if (--op->duration < 0)	356	if (--op->duration < 0)
355	{	357	{
356	op->destroy (true);	358	op->destroy ();
357	return;	359	return;
358	}	360	}
359		361
360	hit_map (op, 0, op->attacktype, 0);	362	hit_map (op, 0, op->attacktype, 0);
361		363
…		…
363	{	365	{
364	for (i = 1; i < 9; i++)	366	for (i = 1; i < 9; i++)
365	{	367	{
366	sint16 dx, dy;	368	sint16 dx, dy;
367		369
368	dx = op->x + freearr_x[i];	370	dx = op->x + DIRX (i);
369	dy = op->y + freearr_y[i];	371	dy = op->y + DIRY (i);
370		372
371	/* ok_to_put_more already does things like checks for walls,	373	/* ok_to_put_more already does things like checks for walls,
372	* out of map, etc.	374	* out of map, etc.
373	*/	375	*/
374	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))
375	{	377	{
376	object *tmp = op->clone ();	378	object *tmp = op->clone ();
…		…
388		390
389	/* Causes an object to explode, eg, a firebullet,	391	/* Causes an object to explode, eg, a firebullet,
390	* poison cloud ball, etc. op is the object to	392	* poison cloud ball, etc. op is the object to
391	* explode.	393	* explode.
392	*/	394	*/
393	void	395	static void
394	explode_bullet (object *op)	396	explode_bullet (object *op)
395	{	397	{
396	object *tmp, *owner;	398	object *tmp, *owner;
397		399
398	if (!op->other_arch)	400	if (!op->other_arch)
399	{	401	{
400	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	402	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
401	op->destroy (true);	403	op->destroy ();
402	return;	404	return;
403	}	405	}
404		406
405	if (op->env)	407	if (op->env)
406	{	408	{
407	object *env = op->outer_env ();	409	object *env = op->outer_env ();
408		410
409	if (!env->map || out_of_map (env->map, env->x, env->y))	411	if (!env->map || out_of_map (env->map, env->x, env->y))
410	{	412	{
411	LOG (llevError, "BUG: explode_bullet(): env out of map\n");	413	LOG (llevError, "BUG: explode_bullet(): env out of map\n");
412	op->destroy (true);	414	op->destroy ();
413	return;	415	return;
414	}	416	}
415		417
416	op->insert_at (env, op, INS_NO_MERGE | INS_NO_WALK_ON);	418	op->insert_at (env, op, INS_NO_MERGE | INS_NO_WALK_ON);
417	}	419	}
418	else if (out_of_map (op->map, op->x, op->y))	420	else if (out_of_map (op->map, op->x, op->y))
419	{	421	{
420	LOG (llevError, "BUG: explode_bullet(): op out of map\n");	422	LOG (llevError, "BUG: explode_bullet(): op out of map\n");
421	op->destroy (true);	423	op->destroy ();
422	return;	424	return;
423	}	425	}
424		426
425	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps	427	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps
426	// NOTE: If this breaks something important: remove this. I can't think of anything	428	// NOTE: If this breaks something important: remove this. I can't think of anything
427	// bad at the moment that might happen from this.	429	// bad at the moment that might happen from this.
428	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	430	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
429	{	431	{
430	op->destroy (true);	432	op->destroy ();
431	return;	433	return;
432	}	434	}
433		435
434	if (op->attacktype)	436	if (op->attacktype)
435	{	437	{
…		…
438	if (op->destroyed ())	440	if (op->destroyed ())
439	return;	441	return;
440	}	442	}
441		443
442	/* other_arch contains what this explodes into */	444	/* other_arch contains what this explodes into */
443	tmp = arch_to_object (op->other_arch);	445	tmp = op->other_arch->instance ();
444		446
445	tmp->set_owner (op);	447	tmp->set_owner (op);
446	tmp->skill = op->skill;	448	tmp->skill = op->skill;
447		449
448	owner = op->owner;	450	owner = op->owner;
…		…
450	if ((tmp->attacktype & AT_HOLYWORD	452	if ((tmp->attacktype & AT_HOLYWORD
451	|| tmp->attacktype & AT_GODPOWER)	453	|| tmp->attacktype & AT_GODPOWER)
452	&& owner	454	&& owner
453	&& !tailor_god_spell (tmp, owner))	455	&& !tailor_god_spell (tmp, owner))
454	{	456	{
455	op->destroy (true);	457	op->destroy ();
456	return;	458	return;
457	}	459	}
458		460
459	/* special for bombs - it actually has sane values for these */	461	/* special for bombs - it actually has sane values for these */
460	if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)	462	if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)
…		…
488		490
489	tmp->insert_at (op, op);	491	tmp->insert_at (op, op);
490	tmp->play_sound (tmp->sound);	492	tmp->play_sound (tmp->sound);
491		493
492	/* remove the firebullet */	494	/* remove the firebullet */
493	op->destroy (true);	495	op->destroy ();
494	}	496	}
495		497
496	/* checks to see what op should do, given the space it is on	498	/* checks to see what op should do, given the space it is on
497	* (eg, explode, damage player, etc)	499	* (eg, explode, damage player, etc)
498	*/	500	*/
…		…
520	if (!(mflags & P_IS_ALIVE))	522	if (!(mflags & P_IS_ALIVE))
521	return;	523	return;
522		524
523	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	525	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
524	{	526	{
525	if (QUERY_FLAG (tmp, FLAG_ALIVE))	527	if (tmp->flag [FLAG_ALIVE])
526	{	528	{
527	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	529	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
528		530
529	// TODO: can't understand the following if's	531	// TODO: can't understand the following if's
530	if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)	532	if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
531	{	533	{
532	if (!QUERY_FLAG (op, FLAG_REMOVED))	534	if (!op->flag [FLAG_REMOVED])
533	{	535	{
534	op->destroy (true);	536	op->destroy ();
535	return;	537	return;
536	}	538	}
537	}	539	}
538	}	540	}
539	}	541	}
…		…
545	* fired arches (eg, bolts).	547	* fired arches (eg, bolts).
546	*/	548	*/
547	void	549	void
548	move_bullet (object *op)	550	move_bullet (object *op)
549	{	551	{
550	sint16 new_x, new_y;
551	int mflags;
552	maptile *m;
553
554	#if 0	552	#if 0
555	/* We need a better general purpose way to do this */	553	/* We need a better general purpose way to do this */
556		554
557	/* peterm: added to make comet leave a trail of burnouts	555	/* peterm: added to make comet leave a trail of burnouts
558	it's an unadulterated hack, but the effect is cool. */	556	it's an unadulterated hack, but the effect is cool. */
559	if (op->stats.sp == SP_METEOR)	557	if (op->stats.sp == SP_METEOR)
560	{	558	{
561	replace_insert_ob_in_map ("fire_trail", op);	559	replace_insert_ob_in_map ("fire_trail", op);
562	if (op->destroyed ())	560	if (op->destroyed ())
…		…
568	if (--op->range <= 0)	566	if (--op->range <= 0)
569	{	567	{
570	if (op->other_arch)	568	if (op->other_arch)
571	explode_bullet (op);	569	explode_bullet (op);
572	else	570	else
573	op->destroy (true);	571	op->destroy ();
574		572
575	return;	573	return;
576	}
577
578	new_x = op->x + DIRX (op);
579	new_y = op->y + DIRY (op);
580	m = op->map;
581	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
582
583	if (mflags & P_OUT_OF_MAP)
584	{	574	}
		575
		576	mapxy pos (op);
		577	pos.move (op->direction);
		578
		579	if (!pos.normalise ())
		580	{
585	op->destroy (true);	581	op->destroy ();
586	return;	582	return;
587	}	583	}
588		584
589	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))
590	{	590	{
591	if (op->other_arch)	591	if (op->other_arch)
592	explode_bullet (op);	592	explode_bullet (op);
593	else	593	else
594	op->destroy (true);	594	op->destroy ();
595		595
596	return;	596	return;
597	}	597	}
598		598
599	if (!(op = m->insert (op, new_x, new_y, op)))	599	if (!(op = pos.insert (op, op)))
600	return;	600	return;
601		601
602	if (reflwall (op->map, op->x, op->y, op))	602	if (reflwall (op->map, op->x, op->y, op))
603	{	603	{
604	op->direction = absdir (op->direction + 4);	604	op->direction = absdir (op->direction + 4);
…		…
641	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);	641	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
642	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);	642	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
643	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);
644		644
645	tmp->direction = dir;	645	tmp->direction = dir;
646	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	646	if (tmp->flag [FLAG_IS_TURNABLE])
647	SET_ANIMATION (tmp, dir);	647	SET_ANIMATION (tmp, dir);
648		648
649	tmp->set_owner (op);	649	tmp->set_owner (op);
650	set_spell_skill (op, caster, spob, tmp);	650	set_spell_skill (op, caster, spob, tmp);
651		651
652	tmp->x = op->x + freearr_x[dir];	652	tmp->x = op->x + DIRX (dir);
653	tmp->y = op->y + freearr_y[dir];	653	tmp->y = op->y + DIRY (dir);
654	tmp->map = op->map;	654	tmp->map = op->map;
655		655
656	maptile *newmap;	656	maptile *newmap;
657	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);
658	if (mflags & P_OUT_OF_MAP)	658	if (mflags & P_OUT_OF_MAP)
659	{	659	{
660	tmp->destroy (true);	660	tmp->destroy ();
661	return 0;	661	return 0;
662	}	662	}
663		663
664	tmp->map = newmap;	664	tmp->map = newmap;
665		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
666	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)))
667	{	680	{
668	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	681	if (!tmp->flag [FLAG_REFLECTING])
669	{	682	{
670	tmp->destroy (true);	683	tmp->destroy ();
671	return 0;	684	return 0;
672	}	685	}
673		686
674	tmp->x = op->x;	687	tmp->x = op->x;
675	tmp->y = op->y;	688	tmp->y = op->y;
…		…
688	* CONE RELATED FUNCTIONS	701	* CONE RELATED FUNCTIONS
689	*	702	*
690	*****************************************************************************/	703	*****************************************************************************/
691		704
692	/* 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" */
693	void	706	static void
694	cone_drop (object *op)	707	cone_drop (object *op)
695	{	708	{
696	object *new_ob = arch_to_object (op->other_arch);	709	object *new_ob = op->other_arch->instance ();
697		710
698	new_ob->level = op->level;	711	new_ob->level = op->level;
699	new_ob->set_owner (op->owner);	712	new_ob->set_owner (op->owner);
700		713
701	/* preserve skill ownership */	714	/* preserve skill ownership */
…		…
717	op->set_speed (0);	730	op->set_speed (0);
718	return;	731	return;
719	}	732	}
720		733
721	/* lava saves it's life, but not yours :) */	734	/* lava saves it's life, but not yours :) */
722	if (QUERY_FLAG (op, FLAG_LIFESAVE))	735	if (op->flag [FLAG_LIFESAVE])
723	{	736	{
724	hit_map (op, 0, op->attacktype, 0);	737	hit_map (op, 0, op->attacktype, 0);
725	return;	738	return;
726	}	739	}
727		740
…		…
730	* when their cone dies when they die.	743	* when their cone dies when they die.
731	*/	744	*/
732	/* If no owner left, the spell dies out. */	745	/* If no owner left, the spell dies out. */
733	if (op->owner == NULL)	746	if (op->owner == NULL)
734	{	747	{
735	op->destroy (true);	748	op->destroy ();
736	return;	749	return;
737	}	750	}
738	#endif	751	#endif
739		752
740	hit_map (op, 0, op->attacktype, 0);	753	hit_map (op, 0, op->attacktype, 0);
		754
		755	if (!op->is_on_map ())
		756	return;
741		757
742	/* Check to see if we should push anything.	758	/* Check to see if we should push anything.
743	* Spell objects with weight push whatever they encounter to some	759	* Spell objects with weight push whatever they encounter to some
744	* degree.	760	* degree.
745	*/	761	*/
746	if (op->weight)	762	if (op->weight)
		763	{
747	check_spell_knockback (op);	764	check_spell_knockback (op);
748		765
749	if (op->destroyed ())	766	if (!op->is_on_map ())
750	return;	767	return;
		768	}
751		769
752	if (op->duration-- < 0)	770	if (op->duration-- < 0)
753	{	771	{
754	op->destroy (true);	772	op->destroy ();
755	return;	773	return;
756	}	774	}
757	/* Object has hit maximum range, so don't have it move	775	/* Object has hit maximum range, so don't have it move
758	* any further. When the duration above expires,	776	* any further. When the duration above expires,
759	* then the object will get removed.	777	* then the object will get removed.
…		…
764	return;	782	return;
765	}	783	}
766		784
767	for (int i = -1; i <= 1; i++)	785	for (int i = -1; i <= 1; i++)
768	{	786	{
769	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));
770		788
771	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))
772	{	790	{
773	object *tmp = op->clone ();	791	object *tmp = op->clone ();
774		792
…		…
803	MoveType movetype;	821	MoveType movetype;
804		822
805	if (!spell->other_arch)	823	if (!spell->other_arch)
806	return 0;	824	return 0;
807		825
808	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)
809	{	827	{
810	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!");
811	return 0;	829	return 0;
812	}	830	}
813		831
814	if (!dir)	832	if (!dir)
815	{	833	{
…		…
823	*/	841	*/
824	movetype = spell->other_arch->move_type;	842	movetype = spell->other_arch->move_type;
825		843
826	for (i = range_min; i <= range_max; i++)	844	for (i = range_min; i <= range_max; i++)
827	{	845	{
828	sint16 x, y, d;	846	sint16 x, y;
829		847
830	/* We can't use absdir here, because it never returns	848	/* We can't use absdir here, because it never returns
831	* 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
832	* 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
833	* to hit that person.	851	* to hit that person.
834	*/	852	*/
835	d = dir + i;	853	int d = dir ? absdir (dir + i) : i;
836	while (d < 0)
837	d += 8;
838	while (d > 8)
839	d -= 8;
840		854
841	/* 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.
842	* In that case, we have to see - if dir is specified,	856	* In that case, we have to see - if dir is specified,
843	* turn this into direction 8. If dir is not specified (all	857	* turn this into direction 8. If dir is not specified (all
844	* direction) skip - otherwise, one line would do more damage	858	* direction) skip - otherwise, one line would do more damage
…		…
851	d = 8;	865	d = 8;
852	else	866	else
853	continue;	867	continue;
854	}	868	}
855		869
856	x = op->x + freearr_x[d];	870	x = op->x + DIRX (d);
857	y = op->y + freearr_y[d];	871	y = op->y + DIRY (d);
858		872
859	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)
860	continue;	874	continue;
861		875
862	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	876	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
863	continue;	877	continue;
864		878
865	success = 1;	879	success = 1;
866	tmp = arch_to_object (spell->other_arch);	880	tmp = spell->other_arch->instance ();
867	tmp->set_owner (op);	881	tmp->set_owner (op);
868	set_spell_skill (op, caster, spell, tmp);	882	set_spell_skill (op, caster, spell, tmp);
869	tmp->level = casting_level (caster, spell);	883	tmp->level = casting_level (caster, spell);
870	tmp->attacktype = spell->attacktype;	884	tmp->attacktype = spell->attacktype;
871		885
…		…
946		960
947	object *env = op->outer_env ();	961	object *env = op->outer_env ();
948		962
949	if (op->env)	963	if (op->env)
950	{	964	{
951	if (env->map == NULL)	965	if (!env->map)
952	return;	966	return;
953		967
954	if (!(op = op->insert_at (env, op)))	968	if (!(op = op->insert_at (env, op)))
955	return;	969	return;
956	}	970	}
957		971
958	// 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
959	// 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
960	// as bombs can be carried.	974	// as bombs can be carried.
961	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	975	if (op->ms ().flags () & P_SAFE)
962	{	976	{
963	op->destroy (true);	977	op->destroy ();
964	return;	978	return;
965	}	979	}
966		980
967	/* This copies a lot of the code from the fire bullet,	981	/* This copies a lot of the code from the fire bullet,
968	* but using the cast_bullet isn't really feasible,	982	* but using the cast_bullet isn't really feasible,
…		…
970	*/	984	*/
971	if (archetype *at = archetype::find (SPLINT))	985	if (archetype *at = archetype::find (SPLINT))
972	{	986	{
973	for (int i = 1; i < 9; i++)	987	for (int i = 1; i < 9; i++)
974	{	988	{
975	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)))
976	continue;	990	continue;
977		991
978	object *tmp = arch_to_object (at);	992	object *tmp = at->instance ();
979	tmp->direction = i;	993	tmp->direction = i;
980	tmp->range = op->range;	994	tmp->range = op->range;
981	tmp->stats.dam = op->stats.dam;	995	tmp->stats.dam = op->stats.dam;
982	tmp->duration = op->duration;	996	tmp->duration = op->duration;
983	tmp->attacktype = op->attacktype;	997	tmp->attacktype = op->attacktype;
984	tmp->set_owner (op);	998	tmp->set_owner (op);
985	if (op->skill && op->skill != tmp->skill)	999	if (op->skill && op->skill != tmp->skill)
986	tmp->skill = op->skill;	1000	tmp->skill = op->skill;
987		1001
988	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	1002	if (tmp->flag [FLAG_IS_TURNABLE])
989	SET_ANIMATION (tmp, i);	1003	SET_ANIMATION (tmp, i);
990		1004
991	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);
992	move_bullet (tmp);	1006	move_bullet (tmp);
993	}	1007	}
994	}	1008	}
995		1009
996	explode_bullet (op);	1010	explode_bullet (op);
…		…
999	int	1013	int
1000	create_bomb (object *op, object *caster, int dir, object *spell)	1014	create_bomb (object *op, object *caster, int dir, object *spell)
1001	{	1015	{
1002	object *tmp;	1016	object *tmp;
1003	int mflags;	1017	int mflags;
1004	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);
1005	maptile *m;	1019	maptile *m;
1006		1020
1007	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	{
1008	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))
1009	{	1030	{
1010	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1031	op->failmsg ("There is something in the way.");
1011	return 0;	1032	return 0;
		1033	}
1012	}	1034	}
1013		1035
1014	tmp = arch_to_object (spell->other_arch);	1036	tmp = spell->other_arch->instance ();
1015		1037
1016	/* level dependencies for bomb */	1038	/* level dependencies for bomb */
1017	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1039	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1018	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);
1019	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1041	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
1039	* dir is the direction to look in.	1061	* dir is the direction to look in.
1040	* range is how far out to look.	1062	* range is how far out to look.
1041	* 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.
1042	* this info is used for blocked magic/unholy spaces.	1064	* this info is used for blocked magic/unholy spaces.
1043	*/	1065	*/
1044	object *	1066	static object *
1045	get_pointed_target (object *op, int dir, int range, int type)	1067	get_pointed_target (object *op, int dir, int range, int type)
1046	{	1068	{
1047	object *target;	1069	object *target;
1048	sint16 x, y;	1070	sint16 x, y;
1049	int dist, mflags;	1071	int dist, mflags;
…		…
1052	if (dir == 0)	1074	if (dir == 0)
1053	return NULL;	1075	return NULL;
1054		1076
1055	for (dist = 1; dist < range; dist++)	1077	for (dist = 1; dist < range; dist++)
1056	{	1078	{
1057	x = op->x + freearr_x[dir] * dist;	1079	x = op->x + DIRX (dir) * dist;
1058	y = op->y + freearr_y[dir] * dist;	1080	y = op->y + DIRY (dir) * dist;
1059	mp = op->map;	1081	mp = op->map;
1060	mflags = get_map_flags (op->map, &mp, x, y, &x, &y);	1082	mflags = get_map_flags (op->map, &mp, x, y, &x, &y);
1061		1083
1062	if (mflags & P_OUT_OF_MAP)	1084	if (mflags & P_OUT_OF_MAP)
1063	return NULL;	1085	return NULL;
…		…
1068	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1090	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1069	return NULL;	1091	return NULL;
1070		1092
1071	if (mflags & P_IS_ALIVE)	1093	if (mflags & P_IS_ALIVE)
1072	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)
1073	if (QUERY_FLAG (target, FLAG_MONSTER))	1095	if (target->flag [FLAG_MONSTER])
1074	return target;	1096	return target;
1075	}	1097	}
1076		1098
1077	return NULL;	1099	return NULL;
1078	}	1100	}
1079		1101
1080	/* cast_smite_arch() - the priest points to a creature and causes	1102	/* cast_smite_spell() - the priest points to a creature and causes
1081	* a 'godly curse' to decend.	1103	* a 'godly curse' to decend.
1082	* usual params -	1104	* usual params -
1083	* op = player	1105	* op = player
1084	* caster = object casting the spell.	1106	* caster = object casting the spell.
1085	* dir = direction being cast	1107	* dir = direction being cast
1086	* spell = spell object	1108	* spell = spell object
…		…
1088	int	1110	int
1089	cast_smite_spell (object *op, object *caster, int dir, object *spell)	1111	cast_smite_spell (object *op, object *caster, int dir, object *spell)
1090	{	1112	{
1091	object *effect, *target;	1113	object *effect, *target;
1092	object *god = find_god (determine_god (op));	1114	object *god = find_god (determine_god (op));
1093	int range;
1094		1115
1095	range = spell->range + SP_level_range_adjust (caster, spell);
1096	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);
1097		1117
1098	/* Bunch of conditions for casting this spell. Note that only	1118	/* Bunch of conditions for casting this spell. Note that only
1099	* require a god if this is a cleric spell (requires grace).	1119	* require a god if this is a cleric spell (requires grace).
1100	* 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
1101	* 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
1102	* interesting spell.	1122	* interesting spell.
1103	* 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
1104	* can't be friendly to your god.	1124	* can't be friendly to your god.
1105	*/	1125	*/
1106		1126
1107	if (!target || QUERY_FLAG (target, FLAG_REFL_SPELL)	1127	if (!target
		1128	|| target->flag [FLAG_REFL_SPELL]
1108	|| (!god && spell->stats.grace)	1129	|| (!god && spell->stats.grace)
1109	|| (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)))
1110	{	1132	{
1111	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1133	op->failmsg ("Your request is unheeded.");
1112	return 0;	1134	return 0;
1113	}	1135	}
1114		1136
1115	if (spell->other_arch)	1137	if (spell->other_arch)
1116	effect = arch_to_object (spell->other_arch);	1138	effect = spell->other_arch->instance ();
1117	else	1139	else
1118	return 0;	1140	return 0;
1119		1141
1120	/* tailor the effect by priest level and worshipped God */	1142	/* tailor the effect by priest level and worshipped God */
1121	effect->level = casting_level (caster, spell);	1143	effect->level = casting_level (caster, spell);
1122	effect->attacktype = spell->attacktype;	1144	effect->attacktype = spell->attacktype;
1123	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))	1145	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1124	{	1146	{
1125	if (tailor_god_spell (effect, op))	1147	if (tailor_god_spell (effect, op))
1126	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));
1127	else	1149	else
1128	{	1150	{
1129	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1151	op->failmsg ("Your request is ignored.");
1130	return 0;	1152	return 0;
1131	}	1153	}
1132	}	1154	}
1133		1155
1134	/* size of the area of destruction */	1156	/* size of the area of destruction */
…		…
1138	if (effect->attacktype & AT_DEATH)	1160	if (effect->attacktype & AT_DEATH)
1139	{	1161	{
1140	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1162	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1141		1163
1142	/* casting death spells at undead isn't a good thing */	1164	/* casting death spells at undead isn't a good thing */
1143	if (QUERY_FLAG (target, FLAG_UNDEAD))	1165	if (target->flag [FLAG_UNDEAD])
1144	{	1166	{
1145	if (random_roll (0, 2, op, PREFER_LOW))	1167	if (random_roll (0, 2, op, PREFER_LOW))
1146	{	1168	{
1147	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1169	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1148	effect->x = op->x;	1170	effect->x = op->x;
…		…
1150	}	1172	}
1151	else	1173	else
1152	{	1174	{
1153	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));	1175	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1154	target->stats.hp = target->stats.maxhp * 2;	1176	target->stats.hp = target->stats.maxhp * 2;
1155	effect->destroy (true);	1177	effect->destroy ();
1156	return 0;	1178	return 0;
1157	}	1179	}
1158	}	1180	}
1159	}	1181	}
1160	else	1182	else
…		…
1192	mapxy pos (op);	1214	mapxy pos (op);
1193	pos.move (op->direction);	1215	pos.move (op->direction);
1194		1216
1195	if (!pos.normalise ())	1217	if (!pos.normalise ())
1196	{	1218	{
1197	op->destroy (true);	1219	op->destroy ();
1198	return;	1220	return;
1199	}	1221	}
1200		1222
1201	mapspace &ms = pos.ms ();	1223	mapspace &ms = pos.ms ();
1202		1224
…		…
1204	{	1226	{
1205	hit_map (op, op->direction, AT_MAGIC, 1);	1227	hit_map (op, op->direction, AT_MAGIC, 1);
1206	/* Basically, missile only hits one thing then goes away.	1228	/* Basically, missile only hits one thing then goes away.
1207	* 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.
1208	*/	1230	*/
1209	op->destroy (true);	1231	op->destroy ();
1210	return;	1232	return;
1211	}	1233	}
1212		1234
1213	if (!op->direction)	1235	if (!op->direction)
1214	{	1236	{
1215	op->destroy (true);	1237	op->destroy ();
1216	return;	1238	return;
1217	}	1239	}
1218		1240
1219	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);	1241	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1220	if (i > 0 && i != op->direction)	1242	if (i > 0 && i != op->direction)
…		…
1229	/****************************************************************************	1251	/****************************************************************************
1230	* Destruction	1252	* Destruction
1231	****************************************************************************/	1253	****************************************************************************/
1232		1254
1233	/* make_object_glow() - currently only makes living objects glow.	1255	/* make_object_glow() - currently only makes living objects glow.
1234	* 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
1235	* object. if time is 0, the object glows permanently. To truely	1257	* object. if time is 0, the object glows permanently. To truely
1236	* make this work for non-living objects, we would have to	1258	* make this work for non-living objects, we would have to
1237	* give them the capability to have an inventory. b.t.	1259	* give them the capability to have an inventory. b.t.
1238	*/	1260	*/
1239	int	1261	static int
1240	make_object_glow (object *op, int radius, int time)	1262	make_object_glow (object *op, int radius, int time)
1241	{	1263	{
1242	/* some things are unaffected... */	1264	/* some things are unaffected... */
1243	if (op->path_denied & PATH_LIGHT)	1265	if (op->path_denied & PATH_LIGHT)
1244	return 0;	1266	return 0;
1245		1267
1246	object *tmp = get_archetype (FORCE_NAME);	1268	object *tmp = archetype::get (FORCE_NAME);
1247	tmp->speed = 0.01;	1269	tmp->set_speed (0.01);
1248	tmp->stats.food = time;	1270	tmp->stats.food = time;
1249	SET_FLAG (tmp, FLAG_IS_USED_UP);	1271	tmp->set_flag (FLAG_IS_USED_UP);
1250	tmp->glow_radius = radius;	1272	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1251	if (tmp->glow_radius > MAX_LIGHT_RADII)
1252	tmp->glow_radius = MAX_LIGHT_RADII;
1253
1254	tmp = insert_ob_in_ob (tmp, op);	1273	tmp = insert_ob_in_ob (tmp, op);
1255		1274
1256	if (tmp->glow_radius > op->glow_radius)	1275	if (tmp->glow_radius > op->glow_radius)
1257	op->glow_radius = tmp->glow_radius;	1276	op->set_glow_radius (tmp->glow_radius);
1258		1277
1259	return 1;	1278	return 1;
1260	}	1279	}
1261		1280
1262	int	1281	int
1263	cast_destruction (object *op, object *caster, object *spell_ob)	1282	cast_destruction (object *op, object *caster, object *spell_ob)
1264	{	1283	{
1265	int i, j, range, mflags, friendly = 0, dam, dur;
1266	sint16 sx, sy;
1267	maptile *m;
1268	object *tmp;
1269	const char *skill;
1270
1271	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1284	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1272	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);
1273	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1286	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1274	if (QUERY_FLAG (op, FLAG_FRIENDLY) || op->type == PLAYER)
1275	friendly = 1;
1276		1287
1277	/* destruction doesn't use another spell object, so we need	1288	bool friendly = op->flag [FLAG_FRIENDLY] || op->is_player ();
1278	* update op's skill pointer so that exp is properly awarded.
1279	* We do some shortcuts here - since this is just temporary
1280	* and we'll reset the values back, we don't need to go through
1281	* the full share string/free_string route.
1282	*/
1283	skill = op->skill;
1284	if (caster == op)
1285	op->skill = spell_ob->skill;
1286	else if (caster->skill)
1287	op->skill = caster->skill;
1288	else
1289	op->skill = NULL;
1290		1289
1291	op->change_skill (find_skill_by_name (op, op->skill));	1290	dynbuf buf;
1292		1291	unordered_mapwalk (buf, op, -range, -range, range, range)
1293	for (i = -range; i <= range; i++)
1294	{	1292	{
1295	for (j = -range; j <= range; j++)	1293	mapspace &ms = m->at (nx, ny);
1296	{
1297	m = op->map;
1298	sx = op->x + i;
1299	sy = op->y + j;
1300		1294
1301	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1302	if (mflags & P_OUT_OF_MAP)
1303	continue;
1304
1305	if (mflags & P_IS_ALIVE)	1295	if (ms.flags () & P_IS_ALIVE)
		1296	for (object *next, *tmp = ms.bot; tmp; tmp = next)
1306	{	1297	{
1307	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1298	next = tmp->above;
1308	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1309	break;
1310		1299
1311	if (tmp)	1300	if (tmp->flag [FLAG_ALIVE] || tmp->is_player ())
1312	{	1301	{
1313	if (tmp->head)
1314	tmp = tmp->head;	1302	tmp = tmp->head_ ();
1315		1303
1316	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) ||	1304	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1317	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))	1305	|| (!friendly && (tmp->flag [FLAG_FRIENDLY] || tmp->is_player ())))
1318	{	1306	{
1319	if (spell_ob->subtype == SP_DESTRUCTION)	1307	if (spell_ob->subtype == SP_DESTRUCTION)
1320	{	1308	{
1321	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1309	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1322		1310
1323	if (spell_ob->other_arch)	1311	if (spell_ob->other_arch)
1324	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1312	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1325	}	1313	}
1326	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)
1327	{	1315	{
1328	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1316	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1329	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1317	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1330	}	1318	}
1331	}	1319	}
1332	}	1320	}
1333	}	1321	}
1334	}
1335	}	1322	}
1336		1323
1337	op->skill = skill;
1338	return 1;	1324	return 1;
1339	}	1325	}
1340		1326
1341	/***************************************************************************	1327	/***************************************************************************
1342	*	1328	*
1343	* CURSE	1329	* CURSE
1344	*	1330	*
1345	***************************************************************************/	1331	***************************************************************************/
1346
1347	int	1332	int
1348	cast_curse (object *op, object *caster, object *spell_ob, int dir)	1333	cast_curse (object *op, object *caster, object *spell_ob, int dir)
1349	{	1334	{
1350	object *god = find_god (determine_god (op));	1335	object *god = find_god (determine_god (op));
1351	object *tmp, *force;	1336	object *tmp, *force;
1352		1337
1353	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);
1354	if (!tmp)	1339	if (!tmp)
1355	{	1340	{
1356	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.");
1357	return 0;	1342	return 0;
1358	}	1343	}
1359		1344
1360	tmp = tmp->head_ ();	1345	tmp = tmp->head_ ();
1361		1346
…		…
1376	}	1361	}
1377	}	1362	}
1378		1363
1379	if (!force)	1364	if (!force)
1380	{	1365	{
1381	force = get_archetype (FORCE_NAME);	1366	force = archetype::get (FORCE_NAME);
1382	force->subtype = FORCE_CHANGE_ABILITY;	1367	force->subtype = FORCE_CHANGE_ABILITY;
1383		1368
1384	if (spell_ob->race)	1369	if (spell_ob->race)
1385	force->name = spell_ob->race;	1370	force->name = spell_ob->race;
1386	else	1371	else
…		…
1404		1389
1405	return 1;	1390	return 1;
1406	}	1391	}
1407		1392
1408	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;
1409	force->speed = 1.f;
1410	force->speed_left = -1.f;	1394	force->speed_left = -1.f;
1411	SET_FLAG (force, FLAG_APPLIED);	1395	force->set_speed (1.f);
		1396	force->set_flag (FLAG_APPLIED);
1412		1397
1413	if (god)	1398	if (god)
1414	{	1399	{
1415	if (spell_ob->last_grace)	1400	if (spell_ob->last_grace)
1416	force->path_repelled = god->path_repelled;	1401	force->path_repelled = god->path_repelled;
…		…
1429	force->stats.wc = spell_ob->stats.wc;	1414	force->stats.wc = spell_ob->stats.wc;
1430		1415
1431	change_abil (tmp, force); /* Mostly to display any messages */	1416	change_abil (tmp, force); /* Mostly to display any messages */
1432	insert_ob_in_ob (force, tmp);	1417	insert_ob_in_ob (force, tmp);
1433	tmp->update_stats ();	1418	tmp->update_stats ();
		1419
1434	return 1;	1420	return 1;
1435
1436	}	1421	}
1437		1422
1438	/**********************************************************************	1423	/**********************************************************************
1439	* mood change	1424	* mood change
1440	* 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
…		…
1446	*/	1431	*/
1447	int	1432	int
1448	mood_change (object *op, object *caster, object *spell)	1433	mood_change (object *op, object *caster, object *spell)
1449	{	1434	{
1450	object *tmp, *god, *head;	1435	object *tmp, *god, *head;
1451	int done_one, range, mflags, level, at, best_at;	1436	int done_one, range, level, at, best_at;
1452	sint16 x, y, nx, ny;
1453	maptile *m;
1454	const char *race;	1437	const char *race;
1455		1438
1456	/* 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
1457	* doing it over and over again.	1440	* doing it over and over again.
1458	*/	1441	*/
…		…
1464	* 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
1465	* won't ever match anything.	1448	* won't ever match anything.
1466	*/	1449	*/
1467	if (!spell->race)	1450	if (!spell->race)
1468	race = NULL;	1451	race = NULL;
1469	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1452	else if (god && spell->race == shstr_GOD_SLAYING)
1470	race = god->slaying;	1453	race = god->slaying;
1471	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1454	else if (god && spell->race == shstr_GOD_FRIEND)
1472	race = god->race;	1455	race = god->race;
1473	else	1456	else
1474	race = spell->race;	1457	race = spell->race;
1475		1458
1476	for (x = op->x - range; x <= op->x + range; x++)	1459	dynbuf buf;
1477	for (y = op->y - range; y <= op->y + range; y++)	1460	unordered_mapwalk (buf, op, -range, -range, range, range)
1478	{	1461	{
1479	done_one = 0;	1462	mapspace &ms = m->at (nx, ny);
1480	m = op->map;
1481	nx = x;
1482	ny = y;
1483	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1484	if (mflags & P_OUT_OF_MAP)
1485	continue;
1486		1463
1487	/* 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 */
1488	if (!(mflags & P_IS_ALIVE))	1465	if (!(ms.flags () & P_IS_ALIVE))
1489	continue;	1466	continue;
1490		1467
1491	// players can only affect spaces that they can actually see	1468	// players can only affect spaces that they can actually see
		1469	if (caster
1492	if (caster && caster->contr	1470	&& caster->contr
1493	&& caster->contr->visibility_at (m, nx, ny) < 70)	1471	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1494	continue;	1472	continue;
1495		1473
1496	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1474	for (tmp = ms.top; tmp; tmp = tmp->below)
1497	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1475	if (tmp->flag [FLAG_MONSTER])
1498	break;	1476	break;
1499		1477
1500	/* There can be living objects that are not monsters */	1478	/* There can be living objects that are not monsters */
1501	if (!tmp || tmp->type == PLAYER)	1479	if (!tmp)
1502	continue;	1480	continue;
1503		1481
1504	/* Only the head has meaningful data, so resolve to that */	1482	/* Only the head has meaningful data, so resolve to that */
1505	if (tmp->head)
1506	head = tmp->head;	1483	head = tmp->head_ ();
1507	else
1508	head = tmp;
1509		1484
1510	/* 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 */
1511	if (race && head->race && !strstr (race, head->race))	1486	if (race && head->race && !strstr (race, head->race))
1512	continue;	1487	continue;
1513		1488
1514	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1489	if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
1515	continue;	1490	continue;
1516		1491
1517	/* Now do a bunch of stuff related to saving throws */	1492	/* Now do a bunch of stuff related to saving throws */
1518	best_at = -1;	1493	best_at = -1;
1519	if (spell->attacktype)	1494	if (spell->attacktype)
1520	{	1495	{
1521	for (at = 0; at < NROFATTACKS; at++)	1496	for (at = 0; at < NROFATTACKS; at++)
1522	if (spell->attacktype & (1 << at))	1497	if (spell->attacktype & (1 << at))
1523	if (best_at == -1 || head->resist[at] > head->resist[best_at])	1498	if (best_at == -1 || head->resist[at] > head->resist[best_at])
1524	best_at = at;	1499	best_at = at;
1525		1500
1526	if (best_at == -1)	1501	if (best_at == -1)
1527	at = 0;	1502	at = 0;
1528	else	1503	else
1529	{	1504	{
1530	if (head->resist[best_at] == 100)	1505	if (head->resist[best_at] == 100)
1531	continue;	1506	continue;
1532	else	1507	else
1533	at = head->resist[best_at] / 5;	1508	at = head->resist[best_at] / 5;
1534	}	1509	}
		1510
1535	at -= level / 5;	1511	at -= level / 5;
1536	if (did_make_save (head, head->level, at))	1512	if (did_make_save (head, head->level, at))
1537	continue;	1513	continue;
1538	}	1514	}
1539	else /* spell->attacktype */	1515	else /* spell->attacktype */
1540	{	1516	{
1541	/*	1517	/*
1542	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:
1543	* if spell level < monster level, no go	1519	* if spell level < monster level, no go
1544	* 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 ) )
1545		1521
1546	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.
1547		1523
1548	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
1549	charm a level 125 monster...	1525	charm a level 125 monster...
1550		1526
1551	Ryo, august 14th	1527	Ryo, august 14th
1552	*/	1528	*/
1553	if (head->level > level)	1529	if (head->level > level)
1554	continue;	1530	continue;
1555		1531
1556	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))))
1557	/* Failed, no effect */	1533	/* Failed, no effect */
1558	continue;	1534	continue;
1559	}	1535	}
1560		1536
1561	/* Done with saving throw. Now start affecting the monster */	1537	/* Done with saving throw. Now start affecting the monster */
		1538	done_one = 0;
1562		1539
1563	/* aggravation */	1540	/* aggravation */
1564	if (QUERY_FLAG (spell, FLAG_MONSTER))	1541	if (spell->flag [FLAG_MONSTER])
1565	{	1542	{
1566	CLEAR_FLAG (head, FLAG_SLEEP);	1543	head->clr_flag (FLAG_SLEEP);
1567	remove_friendly_object (head);	1544	remove_friendly_object (head);
1568	done_one = 1;	1545	done_one = 1;
1569	head->enemy = op;	1546	head->enemy = op;
1570	}	1547	}
1571		1548
1572	/* calm monsters */	1549	/* calm monsters */
1573	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1550	if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
1574	{	1551	{
1575	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1552	head->set_flag (FLAG_UNAGGRESSIVE);
1576	head->enemy = NULL;	1553	head->enemy = NULL;
1577	done_one = 1;	1554	done_one = 1;
1578	}	1555	}
1579		1556
1580	/* berserk monsters */	1557	/* berserk monsters */
1581	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1558	if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
1582	{	1559	{
1583	SET_FLAG (head, FLAG_BERSERK);	1560	head->set_flag (FLAG_BERSERK);
1584	done_one = 1;	1561	done_one = 1;
1585	}	1562	}
1586		1563
1587	/* charm */	1564	/* charm */
1588	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1565	if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
1589	{	1566	{
1590	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));	1567	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
1591		1568
1592	/* Prevent uncontrolled outbreaks of self replicating monsters.	1569	/* Prevent uncontrolled outbreaks of self replicating monsters.
1593	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.
1594	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. */
1595	CLEAR_FLAG (head, FLAG_GENERATOR);	1572	head->clr_flag (FLAG_GENERATOR);
1596	head->set_owner (op);	1573	head->set_owner (op);
1597	set_spell_skill (op, caster, spell, head);	1574	set_spell_skill (op, caster, spell, head);
1598	add_friendly_object (head);	1575	add_friendly_object (head);
1599	head->attack_movement = PETMOVE;	1576	head->attack_movement = PETMOVE;
1600	done_one = 1;	1577	done_one = 1;
1601	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);
1602	head->stats.exp = 0;	1579	head->stats.exp = 0;
1603	}	1580	}
1604		1581
1605	/* If a monster was effected, put an effect in */	1582	/* If a monster was effected, put an effect in */
1606	if (done_one && spell->other_arch)	1583	if (done_one && spell->other_arch)
1607	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1584	m->insert (spell->other_arch->instance (), nx, ny, op);
1608	} /* for y */	1585	}
1609		1586
1610	return 1;	1587	return 1;
1611	}	1588	}
1612
1613		1589
1614	/* 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
1615	* 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
1616	* lightning spell used it, that seemed misnamed.	1592	* lightning spell used it, that seemed misnamed.
1617	* op is the spell effect.	1593	* op is the spell effect.
…		…
1643	for (i = 1; i < 9; i++)	1619	for (i = 1; i < 9; i++)
1644	{	1620	{
1645	/* i bit 0: alters sign of offset	1621	/* i bit 0: alters sign of offset
1646	* other bits (i / 2): absolute value of offset	1622	* other bits (i / 2): absolute value of offset
1647	*/	1623	*/
1648
1649	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);	1624	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1650	int tmpdir = absdir (op->direction + offset);	1625	int tmpdir = absdir (op->direction + offset);
1651		1626
1652	nx = op->x + freearr_x[tmpdir];	1627	nx = op->x + DIRX (tmpdir);
1653	ny = op->y + freearr_y[tmpdir];	1628	ny = op->y + DIRY (tmpdir);
1654	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))))
1655	{	1630	{
1656	dir = tmpdir;	1631	dir = tmpdir;
1657	break;	1632	break;
1658	}	1633	}
1659	}	1634	}
		1635
1660	if (dir == 0)	1636	if (dir == 0)
1661	{	1637	{
1662	nx = op->x;	1638	nx = op->x;
1663	ny = op->y;	1639	ny = op->y;
1664	m = op->map;	1640	m = op->map;
1665	}	1641	}
1666		1642
1667	m->insert (op, nx, ny, op);	1643	m->insert (op, nx, ny, op);
1668		1644
1669	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
1670	surrounding squares */	1646	surrounding squares */
1671		1647
1672	/* loop over current square and neighbors to hit.	1648	/* loop over current square and neighbors to hit.
1673	* if this has an other_arch field, we insert that in	1649	* if this has an other_arch field, we insert that in
1674	* the surround spaces.	1650	* the surround spaces.
1675	*/	1651	*/
1676	for (j = 0; j < 9; j++)	1652	for (j = 0; j < 9; j++)
1677	{	1653	{
1678	hx = nx + freearr_x[j];	1654	hx = nx + DIRX (j);
1679	hy = ny + freearr_y[j];	1655	hy = ny + DIRY (j);
1680		1656
1681	m = op->map;	1657	m = op->map;
1682	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);	1658	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
1683		1659
1684	if (mflags & P_OUT_OF_MAP)	1660	if (mflags & P_OUT_OF_MAP)
…		…
1696	hit_map (op, j, op->attacktype, 1);	1672	hit_map (op, j, op->attacktype, 1);
1697	}	1673	}
1698		1674
1699	/* insert the other arch */	1675	/* insert the other arch */
1700	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))))
1701	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1677	m->insert (op->other_arch->instance (), hx, hy, op);
1702	}	1678	}
1703		1679
1704	/* restore to the center location and damage */	1680	/* restore to the center location and damage */
1705	op->stats.dam = dam_save;	1681	op->stats.dam = dam_save;
1706		1682
1707	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);
1708		1684
1709	if (i >= 0)	1685	if (i >= 0)
1710	{ /* we have a preferred direction! */	1686	{ /* we have a preferred direction! */
1711	/* pick another direction if the preferred dir is blocked. */	1687	/* pick another direction if the preferred dir is blocked. */
1712	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 ||
1713	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)))
1714	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */	1690	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1715		1691
1716	op->direction = i;	1692	op->direction = i;
1717	}	1693	}
1718	}	1694	}
1719		1695
1720	/* move_swarm_spell: peterm	1696	/* move_swarm_spell: peterm
1721	* 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
1722	* 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
1723	* 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
1724	* 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
1725	* 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.
1726	*/	1702	*/
1727	void	1703	void
1728	move_swarm_spell (object *op)	1704	move_swarm_spell (object *op)
1729	{	1705	{
1730	#if 0	1706	#if 0
…		…
1737	object *owner = op->env;	1713	object *owner = op->env;
1738		1714
1739	if (!owner) // MUST not happen, remove when true TODO	1715	if (!owner) // MUST not happen, remove when true TODO
1740	{	1716	{
1741	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());	1717	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1742	op->destroy (true);	1718	op->destroy ();
1743	return;	1719	return;
1744	}	1720	}
1745		1721
1746	if (!op->duration || !owner->is_on_map ())	1722	if (!op->duration || !owner->is_on_map ())
1747	{	1723	{
…		…
1766	// space.	1742	// space.
1767	// should be fixed later, but correctness before features...	1743	// should be fixed later, but correctness before features...
1768	// (schmorp)	1744	// (schmorp)
1769		1745
1770	/* new offset calculation to make swarm element distribution	1746	/* new offset calculation to make swarm element distribution
1771	* more uniform	1747	* more uniform
1772	*/	1748	*/
1773	if (op->duration)	1749	if (op->duration)
1774	{	1750	{
1775	if (basedir & 1)	1751	if (basedir & 1)
1776	{	1752	{
…		…
1784	else	1760	else
1785	{	1761	{
1786	adjustdir = 0; /* fire the last one from forward. */	1762	adjustdir = 0; /* fire the last one from forward. */
1787	}	1763	}
1788		1764
1789	target_x = op->x + freearr_x[absdir (basedir + adjustdir)];	1765	target_x = op->x + DIRX (absdir (basedir + adjustdir));
1790	target_y = op->y + freearr_y[absdir (basedir + adjustdir)];	1766	target_y = op->y + DIRY (absdir (basedir + adjustdir));
1791		1767
1792	/* 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
1793	* necessitates extra out_of_map check below	1769	* necessitates extra out_of_map check below
1794	*/	1770	*/
1795	origin_x = target_x - freearr_x[basedir];	1771	origin_x = target_x - DIRX (basedir);
1796	origin_y = target_y - freearr_y[basedir];	1772	origin_y = target_y - DIRY (basedir);
1797		1773
1798		1774
1799	/* 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
1800	* should just be a pointer to the spell in some inventory,	1776	* should just be a pointer to the spell in some inventory,
1801	* 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,
…		…
1832	}	1808	}
1833		1809
1834	/* fire_swarm:	1810	/* fire_swarm:
1835	* The following routine creates a swarm of objects. It actually	1811	* The following routine creates a swarm of objects. It actually
1836	* sets up a specific swarm object, which then fires off all	1812	* sets up a specific swarm object, which then fires off all
1837	* the parts of the swarm.	1813	* the parts of the swarm.
1838	*	1814	*
1839	* op: the owner	1815	* op: the owner
1840	* caster: the caster (owner, wand, rod, scroll)	1816	* caster: the caster (owner, wand, rod, scroll)
1841	* dir: the direction everything will be fired in	1817	* dir: the direction everything will be fired in
1842	* spell - the spell that is this spell.	1818	* spell - the spell that is this spell.
…		…
1885	int dam, mflags;	1861	int dam, mflags;
1886	maptile *m;	1862	maptile *m;
1887		1863
1888	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1864	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1889		1865
1890	if (!dir)	1866	if (dir)
1891	{
1892	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1893	return 0;
1894	}	1867	{
1895		1868	x = op->x + DIRX (dir);
1896	x = op->x + freearr_x[dir];	1869	y = op->y + DIRY (dir);
1897	y = op->y + freearr_y[dir];
1898	m = op->map;	1870	m = op->map;
1899		1871
1900	mflags = get_map_flags (m, &m, x, y, &x, &y);	1872	mflags = get_map_flags (m, &m, x, y, &x, &y);
1901		1873
1902	if (mflags & P_OUT_OF_MAP)	1874	if (mflags & P_OUT_OF_MAP)
1903	{	1875	{
1904	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1876	op->failmsg ("Nothing is there.");
1905	return 0;	1877	return 0;
1906	}	1878	}
1907		1879
1908	if (mflags & P_IS_ALIVE && spell->attacktype)	1880	if (mflags & P_IS_ALIVE && spell->attacktype)
1909	{	1881	{
1910	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)
1911	if (QUERY_FLAG (target, FLAG_MONSTER))	1883	if (target->flag [FLAG_MONSTER])
1912	{	1884	{
1913	/* oky doky. got a target monster. Lets make a blinding attack */	1885	/* oky doky. got a target monster. Lets make a blinding attack */
1914	if (target->head)	1886	if (target->head)
1915	target = target->head;	1887	target = target->head;
1916		1888
1917	hit_player (target, dam, op, spell->attacktype, 1);	1889	hit_player (target, dam, op, spell->attacktype, 1);
1918	return 1; /* one success only! */	1890	return 1; /* one success only! */
		1891	}
1919	}	1892	}
1920	}
1921		1893
1922	/* no live target, perhaps a wall is in the way? */	1894	/* no live target, perhaps a wall is in the way? */
1923	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)))
1924	{	1896	{
1925	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1897	op->failmsg ("Something is in the way.");
1926	return 0;	1898	return 0;
		1899	}
1927	}	1900	}
1928		1901
1929	/* 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 */
1930	tmp = arch_to_object (spell->other_arch);	1903	tmp = spell->other_arch->instance ();
1931	if (!tmp)	1904	if (!tmp)
1932	{	1905	{
1933	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1906	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1934	return 0;	1907	return 0;
1935	}	1908	}
		1909
1936	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1910	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
		1911
1937	if (tmp->glow_radius)	1912	if (tmp->glow_radius)
1938	{	1913	tmp->set_glow_radius (
1939	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)
1940	if (tmp->glow_radius > MAX_LIGHT_RADII)	1915	);
1941	tmp->glow_radius = MAX_LIGHT_RADII;
1942	}
1943		1916
		1917	if (dir)
1944	m->insert (tmp, x, y, op);	1918	m->insert (tmp, x, y, op);
		1919	else
		1920	caster->outer_env_or_self ()->insert (tmp);
		1921
1945	return 1;	1922	return 1;
1946	}	1923	}
1947		1924
1948	/* cast_cause_disease: this spell looks along <dir> from the	1925	/* cast_cause_disease: this spell looks along <dir> from the
1949	* player and infects someone.	1926	* player and infects someone.
1950	* 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
1951	* 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
1952	* perhaps this should actually be in disease.c?	1929	* perhaps this should actually be in disease.c?
1953	*/	1930	*/
1954	int	1931	int
…		…
1960	maptile *m;	1937	maptile *m;
1961		1938
1962	x = op->x;	1939	x = op->x;
1963	y = op->y;	1940	y = op->y;
1964		1941
1965	/* 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
1966	* direction the player is pointing.	1943	* direction the player is pointing.
1967	*/	1944	*/
1968	if (!dir)	1945	if (!dir)
1969	dir = op->facing;	1946	dir = op->facing;
1970		1947
…		…
1977	dur_mod = SP_level_duration_adjust (caster, spell);	1954	dur_mod = SP_level_duration_adjust (caster, spell);
1978		1955
1979	/* search in a line for a victim */	1956	/* search in a line for a victim */
1980	for (i = 1; i < range; i++)	1957	for (i = 1; i < range; i++)
1981	{	1958	{
1982	x = op->x + i * freearr_x[dir];	1959	x = op->x + i * DIRX (dir);
1983	y = op->y + i * freearr_y[dir];	1960	y = op->y + i * DIRY (dir);
1984	m = op->map;	1961	m = op->map;
1985		1962
1986	mflags = get_map_flags (m, &m, x, y, &x, &y);	1963	mflags = get_map_flags (m, &m, x, y, &x, &y);
1987		1964
1988	if (mflags & P_OUT_OF_MAP)	1965	if (mflags & P_OUT_OF_MAP)
…		…
1995	/* 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 */
1996	if (mflags & P_IS_ALIVE)	1973	if (mflags & P_IS_ALIVE)
1997	{	1974	{
1998	/* search this square for a victim */	1975	/* search this square for a victim */
1999	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)
2000	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))	1977	if (walk->flag [FLAG_MONSTER] || (walk->type == PLAYER))
2001	{ /* found a victim */	1978	{ /* found a victim */
2002	object *disease = arch_to_object (spell->other_arch);	1979	object *disease = spell->other_arch->instance ();
2003		1980
2004	disease->set_owner (op);	1981	disease->set_owner (op);
2005	set_spell_skill (op, caster, spell, disease);	1982	set_spell_skill (op, caster, spell, disease);
2006	disease->stats.exp = 0;	1983	disease->stats.exp = 0;
2007	disease->level = casting_level (caster, spell);	1984	disease->level = casting_level (caster, spell);
2008		1985
2009	/* do level adjustments */	1986	/* do level adjustments */
2010	if (disease->stats.wc)	1987	if (disease->stats.wc ) disease->stats.wc += dur_mod / 2;
2011	disease->stats.wc += dur_mod / 2;	1988	if (disease->magic > 0) disease->magic += dur_mod / 8;
2012		1989	if (disease->stats.maxhp > 0) disease->stats.maxhp += dur_mod;
2013	if (disease->magic > 0)	1990	if (disease->stats.maxgrace > 0) disease->stats.maxgrace += dur_mod;
2014	disease->magic += dur_mod / 8;
2015
2016	if (disease->stats.maxhp > 0)
2017	disease->stats.maxhp += dur_mod;
2018
2019	if (disease->stats.maxgrace > 0)
2020	disease->stats.maxgrace += dur_mod;
2021
2022	if (disease->stats.dam)
2023	{
2024	if (disease->stats.dam > 0)
2025	disease->stats.dam += dam_mod;
2026	else
2027	disease->stats.dam -= dam_mod;
2028	}
2029		1991
2030	if (disease->last_sp)	1992	if (disease->last_sp)
2031	{	1993	{
2032	disease->last_sp -= 2 * dam_mod;	1994	disease->last_sp -= 2 * dam_mod;
		1995
2033	if (disease->last_sp < 1)	1996	if (disease->last_sp < 1)
2034	disease->last_sp = 1;	1997	disease->last_sp = 1;
2035	}	1998	}
2036		1999
2037	if (disease->stats.maxsp)	2000	if (disease->stats.dam ) disease->stats.dam += copysignl (disease->stats.dam , dam_mod);
2038	{	2001	if (disease->stats.maxsp) disease->stats.maxsp += copysignl (disease->stats.maxsp, dam_mod);
2039	if (disease->stats.maxsp > 0)	2002	if (disease->stats.ac ) disease->stats.ac += dam_mod;
2040	disease->stats.maxsp += dam_mod;	2003	if (disease->last_eat ) disease->last_eat -= dam_mod;
2041	else	2004	if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2042	disease->stats.maxsp -= dam_mod;	2005	if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2043	}
2044
2045	if (disease->stats.ac)
2046	disease->stats.ac += dam_mod;
2047
2048	if (disease->last_eat)
2049	disease->last_eat -= dam_mod;
2050
2051	if (disease->stats.hp)
2052	disease->stats.hp -= dam_mod;
2053
2054	if (disease->stats.sp)
2055	disease->stats.sp -= dam_mod;
2056		2006
2057	if (infect_object (walk, disease, 1))	2007	if (infect_object (walk, disease, 1))
2058	{	2008	{
2059	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));
2060		2010
2061	disease->destroy (true); /* don't need this one anymore */	2011	disease->destroy (); /* don't need this one anymore */
2062	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2012	walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
2063	return 1;	2013	return 1;
2064	}	2014	}
2065		2015
2066	disease->destroy (true);	2016	disease->destroy ();
2067	}	2017	}
2068	} /* if living creature */	2018	} /* if living creature */
2069	} /* for range of spaces */	2019	} /* for range of spaces */
2070		2020
2071	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");	2021	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");

Diff Legend

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