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.17 by root, Tue Dec 12 21:39:57 2006 UTC vs.
Revision 1.108 by root, Tue Jan 3 11:25:37 2012 UTC

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

Diff Legend

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