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.10 by root, Sun Sep 10 23:24:12 2006 UTC vs.
Revision 1.37 by root, Mon May 28 21:28:36 2007 UTC

1
2	/*	1	/*
3	* static char *rcsid_spell_attack_c =	2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
4	* "$Id: spell_attack.C,v 1.10 2006/09/10 23:24:12 root Exp $";	3	*
		4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
		5	* Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team
		6	* Copyright (©) 1992,2007 Frank Tore Johansen
		7	*
		8	* Crossfire TRT is free software; you can redistribute it and/or modify it
		9	* under the terms of the GNU General Public License as published by the Free
		10	* Software Foundation; either version 2 of the License, or (at your option)
		11	* any later version.
		12	*
		13	* This program is distributed in the hope that it will be useful, but
		14	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
		15	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
		16	* for more details.
		17	*
		18	* You should have received a copy of the GNU General Public License along
		19	* with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
		20	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		21	*
		22	* The authors can be reached via e-mail to <crossfire@schmorp.de>
5	*/	23	*/
6
7
8	/*
9	CrossFire, A Multiplayer game for X-windows
10
11	Copyright (C) 2002-2003 Mark Wedel & Crossfire Development Team
12	Copyright (C) 1992 Frank Tore Johansen
13
14	This program is free software; you can redistribute it and/or modify
15	it under the terms of the GNU General Public License as published by
16	the Free Software Foundation; either version 2 of the License, or
17	(at your option) any later version.
18
19	This program is distributed in the hope that it will be useful,
20	but WITHOUT ANY WARRANTY; without even the implied warranty of
21	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22	GNU General Public License for more details.
23
24	You should have received a copy of the GNU General Public License
25	along with this program; if not, write to the Free Software
26	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27
28	The authors can be reached via e-mail at crossfire-devel@real-time.com
29	*/
30		24
31	/* This file contains all the spell attack code. Grouping this code	25	/* This file contains all the spell attack code. Grouping this code
32	* together should hopefully make it easier to find the relevent bits	26	* together should hopefully make it easier to find the relevent bits
33	* of code	27	* of code
34	*/	28	*/
35		29
36	#include <global.h>	30	#include <global.h>
37	#include <object.h>	31	#include <object.h>
38	#include <living.h>	32	#include <living.h>
39	#ifndef __CEXTRACT__
40	# include <sproto.h>	33	#include <sproto.h>
41	#endif
42	#include <spells.h>	34	#include <spells.h>
43	#include <sounds.h>	35	#include <sounds.h>
44		36
45	/* 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
46	* 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)
…		…
64	{	56	{
65	weight_move = op->weight + (op->weight * op->level) / 3;	57	weight_move = op->weight + (op->weight * op->level) / 3;
66	/*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */	58	/*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */
67	}	59	}
68		60
69	for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	61	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
70	{	62	{
71	int num_sections = 1;	63	int num_sections = 1;
72		64
73	/* don't move DM */	65	/* don't move DM */
74	if (QUERY_FLAG (tmp, FLAG_WIZ))	66	if (QUERY_FLAG (tmp, FLAG_WIZ))
…		…
124	void	116	void
125	forklightning (object *op, object *tmp)	117	forklightning (object *op, object *tmp)
126	{	118	{
127	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */	119	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
128	int t_dir; /* stores temporary dir calculation */	120	int t_dir; /* stores temporary dir calculation */
129	mapstruct *m;	121	maptile *m;
130	sint16 sx, sy;	122	sint16 sx, sy;
131	object *new_bolt;	123	object *new_bolt;
132		124
133	/* pick a fork direction. tmp->stats.Con is the left bias	125	/* pick a fork direction. tmp->stats.Con is the left bias
134	* i.e., the chance in 100 of forking LEFT	126	* i.e., the chance in 100 of forking LEFT
…		…
147		139
148	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy)))	140	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy)))
149	return;	141	return;
150		142
151	/* OK, we made a fork */	143	/* OK, we made a fork */
152	new_bolt = get_object ();	144	new_bolt = tmp->clone ();
153	copy_object (tmp, new_bolt);
154		145
155	/* reduce chances of subsequent forking */	146	/* reduce chances of subsequent forking */
156	new_bolt->stats.Dex -= 10;	147	new_bolt->stats.Dex -= 10;
157	tmp->stats.Dex -= 10; /* less forks from main bolt too */	148	tmp->stats.Dex -= 10; /* less forks from main bolt too */
158	new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */	149	new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */
159	new_bolt->speed_left = -0.1;	150	new_bolt->speed_left = -0.1f;
160	new_bolt->direction = t_dir;	151	new_bolt->direction = t_dir;
161	new_bolt->duration++;	152	new_bolt->duration++;
162	new_bolt->x = sx;
163	new_bolt->y = sy;
164	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */	153	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
165	new_bolt->stats.dam++;	154	new_bolt->stats.dam++;
166	tmp->stats.dam /= 2; /* reduce father bolt damage */	155	tmp->stats.dam /= 2; /* reduce father bolt damage */
167	tmp->stats.dam++;	156	tmp->stats.dam++;
168	new_bolt = insert_ob_in_map (new_bolt, m, op, 0);	157	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
169	update_turn_face (new_bolt);	158	update_turn_face (new_bolt);
170	}	159	}
171		160
172	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,	161	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
173	* and checks for various things that may stop it.	162	* and checks for various things that may stop it.
174	*/	163	*/
175		164
176	void	165	void
177	move_bolt (object *op)	166	move_bolt (object *op)
178	{	167	{
179	object *tmp;
180	int mflags;	168	int mflags;
181	sint16 x, y;	169	sint16 x, y;
182	mapstruct *m;	170	maptile *m;
183		171
184	if (--(op->duration) < 0)	172	if (--op->duration < 0)
185	{	173	{
186	remove_ob (op);	174	op->destroy ();
187	free_object (op);
188	return;	175	return;
189	}	176	}
		177
190	hit_map (op, 0, op->attacktype, 1);	178	hit_map (op, 0, op->attacktype, 1);
191		179
192	if (!op->direction)	180	if (!op->direction)
193	return;	181	return;
194		182
195	if (--op->range < 0)	183	if (--op->range < 0)
196	{
197	op->range = 0;	184	op->range = 0;
198	}
199	else	185	else
200	{	186	{
201	x = op->x + DIRX (op);	187	x = op->x + DIRX (op);
202	y = op->y + DIRY (op);	188	y = op->y + DIRY (op);
203	m = op->map;	189	m = op->map;
…		…
211	* on the space. So only call reflwall if we think the data it returns	197	* on the space. So only call reflwall if we think the data it returns
212	* will be useful.	198	* will be useful.
213	*/	199	*/
214	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) || ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))	200	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) || ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))
215	{	201	{
216
217	if (!QUERY_FLAG (op, FLAG_REFLECTING))	202	if (!QUERY_FLAG (op, FLAG_REFLECTING))
218	return;	203	return;
219		204
220	/* Since walls don't run diagonal, if the bolt is in	205	/* Since walls don't run diagonal, if the bolt is in
221	* one of 4 main directions, it just reflects back in the	206	* one of 4 main directions, it just reflects back in the
…		…
251	else if (left)	236	else if (left)
252	op->direction = absdir (op->direction + 2);	237	op->direction = absdir (op->direction + 2);
253	else if (right)	238	else if (right)
254	op->direction = absdir (op->direction - 2);	239	op->direction = absdir (op->direction - 2);
255	}	240	}
		241
256	update_turn_face (op); /* A bolt *must* be IS_TURNABLE */	242	update_turn_face (op); /* A bolt *must* be IS_TURNABLE */
257	return;	243	return;
258	}	244	}
259	else	245	else
260	{ /* Create a copy of this object and put it ahead */	246	{ /* Create a copy of this object and put it ahead */
261	tmp = get_object ();	247	object *tmp = op->clone ();
262	copy_object (op, tmp);	248
		249	m->insert (tmp, x, y, op);
263	tmp->speed_left = -0.1;	250	tmp->speed_left = -0.1f;
264	tmp->x += DIRX (tmp), tmp->y += DIRY (tmp);
265	tmp = insert_ob_in_map (tmp, op->map, op, 0);
266	/* To make up for the decrease at the top of the function */	251	/* To make up for the decrease at the top of the function */
267	tmp->duration++;	252	tmp->duration++;
268		253
269	/* New forking code. Possibly create forks of this object	254	/* New forking code. Possibly create forks of this object
270	* going off in other directions.	255	* going off in other directions.
271	*/	256	*/
272
273	if (rndm (0, 99) < tmp->stats.Dex)	257	if (rndm (0, 99) < tmp->stats.Dex)
274	{ /* stats.Dex % of forking */	258	{ /* stats.Dex % of forking */
275	forklightning (op, tmp);	259	forklightning (op, tmp);
276	}	260	}
		261
277	/* In this way, the object left behind sticks on the space, but	262	/* In this way, the object left behind sticks on the space, but
278	* doesn't create any bolts that continue to move onward.	263	* doesn't create any bolts that continue to move onward.
279	*/	264	*/
280	op->range = 0;	265	op->range = 0;
281	} /* copy object and move it along */	266	} /* copy object and move it along */
…		…
288	* we remove the magic flag - that can be derived from	273	* we remove the magic flag - that can be derived from
289	* spob->attacktype.	274	* spob->attacktype.
290	* This function sets up the appropriate owner and skill	275	* This function sets up the appropriate owner and skill
291	* pointers.	276	* pointers.
292	*/	277	*/
293
294	int	278	int
295	fire_bolt (object *op, object *caster, int dir, object *spob, object *skill)	279	fire_bolt (object *op, object *caster, int dir, object *spob, object *skill)
296	{	280	{
297	object *tmp = NULL;	281	object *tmp = NULL;
298	int mflags;	282	int mflags;
…		…
316		300
317	tmp->direction = dir;	301	tmp->direction = dir;
318	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	302	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
319	SET_ANIMATION (tmp, dir);	303	SET_ANIMATION (tmp, dir);
320		304
321	set_owner (tmp, op);	305	tmp->set_owner (op);
322	set_spell_skill (op, caster, spob, tmp);	306	set_spell_skill (op, caster, spob, tmp);
323		307
324	tmp->x = op->x + DIRX (tmp);	308	tmp->x = op->x + DIRX (tmp);
325	tmp->y = op->y + DIRY (tmp);	309	tmp->y = op->y + DIRY (tmp);
326	tmp->map = op->map;	310	tmp->map = op->map;
327		311
		312	maptile *newmap;
328	mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y);	313	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
329	if (mflags & P_OUT_OF_MAP)	314	if (mflags & P_OUT_OF_MAP)
330	{	315	{
331	free_object (tmp);	316	tmp->destroy ();
332	return 0;	317	return 0;
333	}	318	}
		319
		320	tmp->map = newmap;
		321
334	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))	322	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
335	{	323	{
336	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	324	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
337	{	325	{
338	free_object (tmp);	326	tmp->destroy ();
339	return 0;	327	return 0;
340	}	328	}
		329
341	tmp->x = op->x;	330	tmp->x = op->x;
342	tmp->y = op->y;	331	tmp->y = op->y;
343	tmp->direction = absdir (tmp->direction + 4);	332	tmp->direction = absdir (tmp->direction + 4);
344	tmp->map = op->map;	333	tmp->map = op->map;
345	}	334	}
346	if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL)	335
		336	if ((tmp = tmp->insert_at (tmp, op)))
347	move_bolt (tmp);	337	move_bolt (tmp);
		338
348	return 1;	339	return 1;
349	}	340	}
350		341
351		342
352		343
…		…
361	* At least that is what I think this does.	352	* At least that is what I think this does.
362	*/	353	*/
363	void	354	void
364	explosion (object *op)	355	explosion (object *op)
365	{	356	{
366	object *tmp;
367	mapstruct *m = op->map;	357	maptile *m = op->map;
368	int i;	358	int i;
369		359
370	if (--(op->duration) < 0)	360	if (--op->duration < 0)
371	{	361	{
372	remove_ob (op);	362	op->destroy ();
373	free_object (op);
374	return;	363	return;
375	}	364	}
		365
376	hit_map (op, 0, op->attacktype, 0);	366	hit_map (op, 0, op->attacktype, 0);
377		367
378	if (op->range > 0)	368	if (op->range > 0)
379	{	369	{
380	for (i = 1; i < 9; i++)	370	for (i = 1; i < 9; i++)
381	{	371	{
382	sint16 dx, dy;	372	sint16 dx, dy;
383		373
384	dx = op->x + freearr_x[i];	374	dx = op->x + freearr_x[i];
385	dy = op->y + freearr_y[i];	375	dy = op->y + freearr_y[i];
		376
386	/* ok_to_put_more already does things like checks for walls,	377	/* ok_to_put_more already does things like checks for walls,
387	* out of map, etc.	378	* out of map, etc.
388	*/	379	*/
389	if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))	380	if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
390	{	381	{
391	tmp = get_object ();	382	object *tmp = op->clone ();
392	copy_object (op, tmp);	383
393	tmp->state = 0;	384	tmp->state = 0;
394	tmp->speed_left = -0.21;	385	tmp->speed_left = -0.21f;
395	tmp->range--;	386	tmp->range--;
396	tmp->value = 0;	387	tmp->value = 0;
397	tmp->x = dx;	388
398	tmp->y = dy;	389	m->insert (tmp, dx, dy, op);
399	insert_ob_in_map (tmp, m, op, 0);
400	}	390	}
401	}	391	}
402	}	392	}
403	}	393	}
404		394
…		…
408	* explode.	398	* explode.
409	*/	399	*/
410	void	400	void
411	explode_bullet (object *op)	401	explode_bullet (object *op)
412	{	402	{
413	tag_t op_tag = op->count;
414	object *tmp, *owner;	403	object *tmp, *owner;
415		404
416	if (op->other_arch == NULL)	405	if (op->other_arch == NULL)
417	{	406	{
418	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	407	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
419	remove_ob (op);	408	op->destroy ();
420	free_object (op);
421	return;	409	return;
422	}	410	}
423		411
424	if (op->env)	412	if (op->env)
425	{	413	{
426	object *env;
427
428	env = object_get_env_recursive (op);	414	object *env = object_get_env_recursive (op);
429	if (env->map == NULL || out_of_map (env->map, env->x, env->y))	415	if (env->map == NULL || out_of_map (env->map, env->x, env->y))
430	{	416	{
431	LOG (llevError, "BUG: explode_bullet(): env out of map\n");	417	LOG (llevError, "BUG: explode_bullet(): env out of map\n");
432	remove_ob (op);	418	op->destroy ();
433	free_object (op);
434	return;	419	return;
435	}	420	}
436	remove_ob (op);	421
437	op->x = env->x;	422	op->insert_at (env, op, INS_NO_MERGE | INS_NO_WALK_ON);
438	op->y = env->y;
439	insert_ob_in_map (op, env->map, op, INS_NO_MERGE | INS_NO_WALK_ON);
440	}	423	}
441	else if (out_of_map (op->map, op->x, op->y))	424	else if (out_of_map (op->map, op->x, op->y))
442	{	425	{
443	LOG (llevError, "BUG: explode_bullet(): op out of map\n");	426	LOG (llevError, "BUG: explode_bullet(): op out of map\n");
444	remove_ob (op);	427	op->destroy ();
445	free_object (op);
446	return;	428	return;
447	}	429	}
448		430
449	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps	431	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps
450	// NOTE: If this breaks something important: remove this. I can't think of anything	432	// NOTE: If this breaks something important: remove this. I can't think of anything
451	// bad at the moment that might happen from this.	433	// bad at the moment that might happen from this.
452	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	434	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
453	{	435	{
454	remove_ob (op);	436	op->destroy ();
455	free_object (op);
456	return;	437	return;
457	}	438	}
458		439
459	if (op->attacktype)	440	if (op->attacktype)
460	{	441	{
461	hit_map (op, 0, op->attacktype, 1);	442	hit_map (op, 0, op->attacktype, 1);
462	if (was_destroyed (op, op_tag))	443	if (op->destroyed ())
463	return;	444	return;
464	}	445	}
465		446
466	/* other_arch contains what this explodes into */	447	/* other_arch contains what this explodes into */
467	tmp = arch_to_object (op->other_arch);	448	tmp = arch_to_object (op->other_arch);
468		449
469	copy_owner (tmp, op);	450	tmp->set_owner (op);
470	tmp->skill = op->skill;	451	tmp->skill = op->skill;
471		452
472	owner = get_owner (op);	453	owner = op->owner;
473		454
474	if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))	455	if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))
475	{	456	{
476	remove_ob (op);	457	op->destroy ();
477	free_object (op);
478	return;	458	return;
479	}	459	}
480
481	tmp->x = op->x;
482	tmp->y = op->y;
483		460
484	/* special for bombs - it actually has sane values for these */	461	/* special for bombs - it actually has sane values for these */
485	if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)	462	if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)
486	{	463	{
487	tmp->attacktype = op->attacktype;	464	tmp->attacktype = op->attacktype;
…		…
491	}	468	}
492	else	469	else
493	{	470	{
494	if (op->attacktype & AT_MAGIC)	471	if (op->attacktype & AT_MAGIC)
495	tmp->attacktype |= AT_MAGIC;	472	tmp->attacktype |= AT_MAGIC;
		473
496	/* Spell doc describes what is going on here */	474	/* Spell doc describes what is going on here */
497	tmp->stats.dam = op->dam_modifier;	475	tmp->stats.dam = op->dam_modifier;
498	tmp->range = op->stats.maxhp;	476	tmp->range = op->stats.maxhp;
499	tmp->duration = op->stats.hp;	477	tmp->duration = op->stats.hp;
500	/* Used for spell tracking - just need a unique val for this spell -	478	/* Used for spell tracking - just need a unique val for this spell -
…		…
508	tmp->stats.sp = op->direction;	486	tmp->stats.sp = op->direction;
509		487
510	/* Prevent recursion */	488	/* Prevent recursion */
511	op->move_on = 0;	489	op->move_on = 0;
512		490
513	insert_ob_in_map (tmp, op->map, op, 0);	491	tmp->insert_at (op, op);
514	/* remove the firebullet */	492	/* remove the firebullet */
515	if (!was_destroyed (op, op_tag))	493	op->destroy ();
516	{
517	remove_ob (op);
518	free_object (op);
519	}
520	}	494	}
521
522
523		495
524	/* checks to see what op should do, given the space it is on	496	/* checks to see what op should do, given the space it is on
525	* (eg, explode, damage player, etc)	497	* (eg, explode, damage player, etc)
526	*/	498	*/
527
528	void	499	void
529	check_bullet (object *op)	500	check_bullet (object *op)
530	{	501	{
531	tag_t op_tag = op->count, tmp_tag;
532	object *tmp;	502	object *tmp;
533	int dam, mflags;	503	int dam, mflags;
534	mapstruct *m;	504	maptile *m;
535	sint16 sx, sy;	505	sint16 sx, sy;
536		506
537	mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy);	507	mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy);
538		508
539	if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	509	if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
…		…
548		518
549	/* If nothing alive on this space, no reason to do anything further */	519	/* If nothing alive on this space, no reason to do anything further */
550	if (!(mflags & P_IS_ALIVE))	520	if (!(mflags & P_IS_ALIVE))
551	return;	521	return;
552		522
553	for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	523	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
554	{	524	{
555	if (QUERY_FLAG (tmp, FLAG_ALIVE))	525	if (QUERY_FLAG (tmp, FLAG_ALIVE))
556	{	526	{
557	tmp_tag = tmp->count;
558	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	527	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
559	if (was_destroyed (op, op_tag) || !was_destroyed (tmp, tmp_tag) || (op->stats.dam -= dam) < 0)	528	if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
560	{	529	{
561	if (!QUERY_FLAG (op, FLAG_REMOVED))	530	if (!QUERY_FLAG (op, FLAG_REMOVED))
562	{	531	{
563	remove_ob (op);	532	op->destroy ();
564	free_object (op);
565	return;	533	return;
566	}	534	}
567	}	535	}
568	}	536	}
569	}	537	}
570	}	538	}
571
572		539
573	/* Basically, we move 'op' one square, and if it hits something,	540	/* Basically, we move 'op' one square, and if it hits something,
574	* call check_bullet.	541	* call check_bullet.
575	* This function is only applicable to bullets, but not to all	542	* This function is only applicable to bullets, but not to all
576	* fired arches (eg, bolts).	543	* fired arches (eg, bolts).
577	*/	544	*/
578
579	void	545	void
580	move_bullet (object *op)	546	move_bullet (object *op)
581	{	547	{
582	sint16 new_x, new_y;	548	sint16 new_x, new_y;
583	int mflags;	549	int mflags;
584	mapstruct *m;	550	maptile *m;
585		551
586	#if 0	552	#if 0
587	/* We need a better general purpose way to do this */	553	/* We need a better general purpose way to do this */
588		554
589	/* peterm: added to make comet leave a trail of burnouts	555	/* peterm: added to make comet leave a trail of burnouts
590	it's an unadulterated hack, but the effect is cool. */	556	it's an unadulterated hack, but the effect is cool. */
591	if (op->stats.sp == SP_METEOR)	557	if (op->stats.sp == SP_METEOR)
592	{	558	{
593	replace_insert_ob_in_map ("fire_trail", op);	559	replace_insert_ob_in_map ("fire_trail", op);
594	if (was_destroyed (op, op_tag))	560	if (op->destroyed ())
595	return;	561	return;
596	} /* end addition. */	562	} /* end addition. */
597	#endif	563	#endif
598		564
599	/* Reached the end of its life - remove it */	565	/* Reached the end of its life - remove it */
600	if (--op->range <= 0)	566	if (--op->range <= 0)
601	{	567	{
602	if (op->other_arch)	568	if (op->other_arch)
603	{
604	explode_bullet (op);	569	explode_bullet (op);
605	}
606	else	570	else
607	{	571	op->destroy ();
608	remove_ob (op);	572
609	free_object (op);
610	}
611	return;	573	return;
612	}	574	}
613		575
614	new_x = op->x + DIRX (op);	576	new_x = op->x + DIRX (op);
615	new_y = op->y + DIRY (op);	577	new_y = op->y + DIRY (op);
616	m = op->map;	578	m = op->map;
617	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);	579	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
618		580
619	if (mflags & P_OUT_OF_MAP)	581	if (mflags & P_OUT_OF_MAP)
620	{	582	{
621	remove_ob (op);	583	op->destroy ();
622	free_object (op);
623	return;	584	return;
624	}	585	}
625		586
626	if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))	587	if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))
627	{	588	{
628	if (op->other_arch)	589	if (op->other_arch)
629	{
630	explode_bullet (op);	590	explode_bullet (op);
631	}
632	else	591	else
633	{	592	op->destroy ();
634	remove_ob (op);	593
635	free_object (op);
636	}
637	return;	594	return;
638	}	595	}
639		596
640	remove_ob (op);	597	if (!(op = m->insert (op, new_x, new_y, op)))
641	op->x = new_x;
642	op->y = new_y;
643	if ((op = insert_ob_in_map (op, m, op, 0)) == NULL)
644	return;	598	return;
645		599
646	if (reflwall (op->map, op->x, op->y, op))	600	if (reflwall (op->map, op->x, op->y, op))
647	{	601	{
648	op->direction = absdir (op->direction + 4);	602	op->direction = absdir (op->direction + 4);
649	update_turn_face (op);	603	update_turn_face (op);
650	}	604	}
651	else	605	else
652	{
653	check_bullet (op);	606	check_bullet (op);
654	}
655	}	607	}
656
657
658
659		608
660	/* fire_bullet	609	/* fire_bullet
661	* object op (cast from caster) files a bolt in dir.	610	* object op (cast from caster) files a bolt in dir.
662	* spob is the spell object for the bolt.	611	* spob is the spell object for the bolt.
663	* we remove the magic flag - that can be derived from	612	* we remove the magic flag - that can be derived from
…		…
694		643
695	tmp->direction = dir;	644	tmp->direction = dir;
696	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	645	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
697	SET_ANIMATION (tmp, dir);	646	SET_ANIMATION (tmp, dir);
698		647
699	set_owner (tmp, op);	648	tmp->set_owner (op);
700	set_spell_skill (op, caster, spob, tmp);	649	set_spell_skill (op, caster, spob, tmp);
701		650
702	tmp->x = op->x + freearr_x[dir];	651	tmp->x = op->x + freearr_x[dir];
703	tmp->y = op->y + freearr_y[dir];	652	tmp->y = op->y + freearr_y[dir];
704	tmp->map = op->map;	653	tmp->map = op->map;
705		654
		655	maptile *newmap;
706	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);
707	if (mflags & P_OUT_OF_MAP)	657	if (mflags & P_OUT_OF_MAP)
708	{	658	{
709	free_object (tmp);	659	tmp->destroy ();
710	return 0;	660	return 0;
711	}	661	}
		662
		663	tmp->map = newmap;
		664
712	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))	665	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
713	{	666	{
714	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	667	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
715	{	668	{
716	free_object (tmp);	669	tmp->destroy ();
717	return 0;	670	return 0;
718	}	671	}
		672
719	tmp->x = op->x;	673	tmp->x = op->x;
720	tmp->y = op->y;	674	tmp->y = op->y;
721	tmp->direction = absdir (tmp->direction + 4);	675	tmp->direction = absdir (tmp->direction + 4);
722	tmp->map = op->map;	676	tmp->map = op->map;
723	}	677	}
724	if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL)	678
725	{	679	if ((tmp = tmp->insert_at (tmp, op)))
726	check_bullet (tmp);	680	check_bullet (tmp);
727	}	681
728	return 1;	682	return 1;
729	}	683	}
730
731
732
733		684
734	/*****************************************************************************	685	/*****************************************************************************
735	*	686	*
736	* CONE RELATED FUNCTIONS	687	* CONE RELATED FUNCTIONS
737	*	688	*
738	*****************************************************************************/	689	*****************************************************************************/
739		690
740
741	/* drops an object based on what is in the cone's "other_arch" */	691	/* drops an object based on what is in the cone's "other_arch" */
742	void	692	void
743	cone_drop (object *op)	693	cone_drop (object *op)
744	{	694	{
745	object *new_ob = arch_to_object (op->other_arch);	695	object *new_ob = arch_to_object (op->other_arch);
746		696
747	new_ob->x = op->x;
748	new_ob->y = op->y;
749	new_ob->level = op->level;	697	new_ob->level = op->level;
750	set_owner (new_ob, op->owner);	698	new_ob->set_owner (op->owner);
751		699
752	/* preserve skill ownership */	700	/* preserve skill ownership */
753	if (op->skill && op->skill != new_ob->skill)	701	if (op->skill && op->skill != new_ob->skill)
754	{
755	new_ob->skill = op->skill;	702	new_ob->skill = op->skill;
756	}
757	insert_ob_in_map (new_ob, op->map, op, 0);
758		703
		704	new_ob->insert_at (op, op);
759	}	705	}
760		706
761	/* move_cone: causes cone object 'op' to move a space/hit creatures */	707	/* move_cone: causes cone object 'op' to move a space/hit creatures */
762		708
763	void	709	void
764	move_cone (object *op)	710	move_cone (object *op)
765	{	711	{
766	int i;	712	int i;
767	tag_t tag;
768		713
769	/* if no map then hit_map will crash so just ignore object */	714	/* if no map then hit_map will crash so just ignore object */
770	if (!op->map)	715	if (!op->map)
771	{	716	{
772	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");	717	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
773	op->speed = 0;	718	op->set_speed (0);
774	update_ob_speed (op);
775	return;	719	return;
776	}	720	}
777		721
778	/* lava saves it's life, but not yours :) */	722	/* lava saves it's life, but not yours :) */
779	if (QUERY_FLAG (op, FLAG_LIFESAVE))	723	if (QUERY_FLAG (op, FLAG_LIFESAVE))
…		…
785	#if 0	729	#if 0
786	/* Disable this - enabling it makes monsters easier, as	730	/* Disable this - enabling it makes monsters easier, as
787	* when their cone dies when they die.	731	* when their cone dies when they die.
788	*/	732	*/
789	/* If no owner left, the spell dies out. */	733	/* If no owner left, the spell dies out. */
790	if (get_owner (op) == NULL)	734	if (op->owner == NULL)
791	{	735	{
792	remove_ob (op);	736	op->destroy ();
793	free_object (op);
794	return;	737	return;
795	}	738	}
796	#endif	739	#endif
797		740
798	tag = op->count;
799	hit_map (op, 0, op->attacktype, 0);	741	hit_map (op, 0, op->attacktype, 0);
800		742
801	/* Check to see if we should push anything.	743	/* Check to see if we should push anything.
802	* Spell objects with weight push whatever they encounter to some	744	* Spell objects with weight push whatever they encounter to some
803	* degree.	745	* degree.
804	*/	746	*/
805	if (op->weight)	747	if (op->weight)
806	check_spell_knockback (op);	748	check_spell_knockback (op);
807		749
808	if (was_destroyed (op, tag))	750	if (op->destroyed ())
809	return;	751	return;
810		752
811	if ((op->duration--) < 0)	753	if ((op->duration--) < 0)
812	{	754	{
813	remove_ob (op);	755	op->destroy ();
814	free_object (op);
815	return;	756	return;
816	}	757	}
817	/* Object has hit maximum range, so don't have it move	758	/* Object has hit maximum range, so don't have it move
818	* any further. When the duration above expires,	759	* any further. When the duration above expires,
819	* then the object will get removed.	760	* then the object will get removed.
…		…
828	{	769	{
829	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];	770	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
830		771
831	if (ok_to_put_more (op->map, x, y, op, op->attacktype))	772	if (ok_to_put_more (op->map, x, y, op, op->attacktype))
832	{	773	{
833	object *tmp = get_object ();	774	object *tmp = op->clone ();
834
835	copy_object (op, tmp);
836	tmp->x = x;
837	tmp->y = y;
838		775
839	tmp->duration = op->duration + 1;	776	tmp->duration = op->duration + 1;
840		777
841	/* Use for spell tracking - see ok_to_put_more() */	778	/* Use for spell tracking - see ok_to_put_more() */
842	tmp->stats.maxhp = op->stats.maxhp;	779	tmp->stats.maxhp = op->stats.maxhp;
843	insert_ob_in_map (tmp, op->map, op, 0);	780
		781	op->map->insert (tmp, x, y, op);
		782
844	if (tmp->other_arch)	783	if (tmp->other_arch)
845	cone_drop (tmp);	784	cone_drop (tmp);
846	}	785	}
847	}	786	}
848	}	787	}
…		…
858	int	797	int
859	cast_cone (object *op, object *caster, int dir, object *spell)	798	cast_cone (object *op, object *caster, int dir, object *spell)
860	{	799	{
861	object *tmp;	800	object *tmp;
862	int i, success = 0, range_min = -1, range_max = 1;	801	int i, success = 0, range_min = -1, range_max = 1;
863	mapstruct *m;	802	maptile *m;
864	sint16 sx, sy;	803	sint16 sx, sy;
865	MoveType movetype;	804	MoveType movetype;
866		805
867	if (!spell->other_arch)	806	if (!spell->other_arch)
868	return 0;	807	return 0;
…		…
924	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	863	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
925	continue;	864	continue;
926		865
927	success = 1;	866	success = 1;
928	tmp = arch_to_object (spell->other_arch);	867	tmp = arch_to_object (spell->other_arch);
929	set_owner (tmp, op);	868	tmp->set_owner (op);
930	set_spell_skill (op, caster, spell, tmp);	869	set_spell_skill (op, caster, spell, tmp);
931	tmp->level = caster_level (caster, spell);	870	tmp->level = caster_level (caster, spell);
932	tmp->x = sx;
933	tmp->y = sy;
934	tmp->attacktype = spell->attacktype;	871	tmp->attacktype = spell->attacktype;
935		872
936	/* holy word stuff */	873	/* holy word stuff */
937	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))	874	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
938	if (!tailor_god_spell (tmp, op))	875	if (!tailor_god_spell (tmp, op))
…		…
975		912
976	if (!(tmp->move_type & MOVE_FLY_LOW))	913	if (!(tmp->move_type & MOVE_FLY_LOW))
977	LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n", &spell->other_arch->name);	914	LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n", &spell->other_arch->name);
978		915
979	if (!tmp->move_on && tmp->stats.dam)	916	if (!tmp->move_on && tmp->stats.dam)
980	{
981	LOG (llevDebug, "cast_cone(): arch %s doesn't have move_on set\n", &spell->other_arch->name);	917	LOG (llevDebug, "cast_cone(): arch %s doesn't have move_on set\n", &spell->other_arch->name);
982	}
983		918
984	insert_ob_in_map (tmp, m, op, 0);	919	m->insert (tmp, sx, sy, op);
985		920
986	/* This is used for tracking spells so that one effect doesn't hit	921	/* This is used for tracking spells so that one effect doesn't hit
987	* a single space too many times.	922	* a single space too many times.
988	*/	923	*/
989	tmp->stats.maxhp = tmp->count;	924	tmp->stats.maxhp = tmp->count;
…		…
1008	void	943	void
1009	animate_bomb (object *op)	944	animate_bomb (object *op)
1010	{	945	{
1011	int i;	946	int i;
1012	object *env, *tmp;	947	object *env, *tmp;
1013	archetype *at;
1014		948
1015	if (op->state != NUM_ANIMATIONS (op) - 1)	949	if (op->state != NUM_ANIMATIONS (op) - 1)
1016	return;	950	return;
1017		951
1018	env = object_get_env_recursive (op);	952	env = object_get_env_recursive (op);
…		…
1023	return;	957	return;
1024		958
1025	if (env->type == PLAYER)	959	if (env->type == PLAYER)
1026	esrv_del_item (env->contr, op->count);	960	esrv_del_item (env->contr, op->count);
1027		961
1028	remove_ob (op);	962	if (!(op = op->insert_at (env, op)))
1029	op->x = env->x;
1030	op->y = env->y;
1031	if ((op = insert_ob_in_map (op, env->map, op, 0)) == NULL)
1032	return;	963	return;
1033	}	964	}
1034		965
1035	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding	966	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
1036	// on a safe map. I don't like this special casing, but it seems to be neccessary	967	// on a safe map. I don't like this special casing, but it seems to be neccessary
1037	// as bombs can be carried.	968	// as bombs can be carried.
1038	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	969	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
1039	{	970	{
1040	remove_ob (op);	971	op->destroy ();
1041	free_object (op);
1042	return;	972	return;
1043	}	973	}
1044		974
1045	/* This copies a lot of the code from the fire bullet,	975	/* This copies a lot of the code from the fire bullet,
1046	* but using the cast_bullet isn't really feasible,	976	* but using the cast_bullet isn't really feasible,
1047	* so just set up the appropriate values.	977	* so just set up the appropriate values.
1048	*/	978	*/
1049	at = find_archetype (SPLINT);	979	if (archetype *at = archetype::find (SPLINT))
1050	if (at)
1051	{	980	{
1052	for (i = 1; i < 9; i++)	981	for (i = 1; i < 9; i++)
1053	{	982	{
1054	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))	983	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
1055	continue;	984	continue;
		985
1056	tmp = arch_to_object (at);	986	tmp = arch_to_object (at);
1057	tmp->direction = i;	987	tmp->direction = i;
1058	tmp->range = op->range;	988	tmp->range = op->range;
1059	tmp->stats.dam = op->stats.dam;	989	tmp->stats.dam = op->stats.dam;
1060	tmp->duration = op->duration;	990	tmp->duration = op->duration;
1061	tmp->attacktype = op->attacktype;	991	tmp->attacktype = op->attacktype;
1062	copy_owner (tmp, op);	992	tmp->set_owner (op);
1063	if (op->skill && op->skill != tmp->skill)	993	if (op->skill && op->skill != tmp->skill)
1064	{
1065	tmp->skill = op->skill;	994	tmp->skill = op->skill;
1066	}	995
1067	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	996	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
1068	SET_ANIMATION (tmp, i);	997	SET_ANIMATION (tmp, i);
1069	tmp->x = op->x + freearr_x[i];	998
1070	tmp->y = op->y + freearr_x[i];	999	op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);
1071	insert_ob_in_map (tmp, op->map, op, 0);
1072	move_bullet (tmp);	1000	move_bullet (tmp);
1073	}	1001	}
1074	}	1002	}
1075		1003
1076	explode_bullet (op);	1004	explode_bullet (op);
…		…
1081	{	1009	{
1082		1010
1083	object *tmp;	1011	object *tmp;
1084	int mflags;	1012	int mflags;
1085	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];	1013	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1086	mapstruct *m;	1014	maptile *m;
1087		1015
1088	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);	1016	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
1089	if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))	1017	if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1090	{	1018	{
1091	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1019	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
…		…
1097	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1025	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1098	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1026	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1099	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1027	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
1100	tmp->attacktype = spell->attacktype;	1028	tmp->attacktype = spell->attacktype;
1101		1029
1102	set_owner (tmp, op);	1030	tmp->set_owner (op);
1103	set_spell_skill (op, caster, spell, tmp);	1031	set_spell_skill (op, caster, spell, tmp);
1104	tmp->x = dx;	1032
1105	tmp->y = dy;	1033	m->insert (tmp, dx, dy, op);
1106	insert_ob_in_map (tmp, m, op, 0);
1107	return 1;	1034	return 1;
1108	}	1035	}
1109		1036
1110	/****************************************************************************	1037	/****************************************************************************
1111	*	1038	*
…		…
1127	get_pointed_target (object *op, int dir, int range, int type)	1054	get_pointed_target (object *op, int dir, int range, int type)
1128	{	1055	{
1129	object *target;	1056	object *target;
1130	sint16 x, y;	1057	sint16 x, y;
1131	int dist, mflags;	1058	int dist, mflags;
1132	mapstruct *mp;	1059	maptile *mp;
1133		1060
1134	if (dir == 0)	1061	if (dir == 0)
1135	return NULL;	1062	return NULL;
1136		1063
1137	for (dist = 1; dist < range; dist++)	1064	for (dist = 1; dist < range; dist++)
…		…
1150	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1077	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1151	return NULL;	1078	return NULL;
1152		1079
1153	if (mflags & P_IS_ALIVE)	1080	if (mflags & P_IS_ALIVE)
1154	{	1081	{
1155	for (target = get_map_ob (mp, x, y); target; target = target->above)	1082	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1156	{	1083	{
1157	if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER))	1084	if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER))
1158	{	1085	{
1159	return target;	1086	return target;
1160	}	1087	}
…		…
1227	if (effect->attacktype & AT_DEATH)	1154	if (effect->attacktype & AT_DEATH)
1228	{	1155	{
1229	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1156	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1230		1157
1231	/* casting death spells at undead isn't a good thing */	1158	/* casting death spells at undead isn't a good thing */
1232	if QUERY_FLAG
1233	(target, FLAG_UNDEAD)	1159	if (QUERY_FLAG (target, FLAG_UNDEAD))
1234	{	1160	{
1235	if (random_roll (0, 2, op, PREFER_LOW))	1161	if (random_roll (0, 2, op, PREFER_LOW))
1236	{	1162	{
1237	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1163	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1238	effect->x = op->x;	1164	effect->x = op->x;
…		…
1240	}	1166	}
1241	else	1167	else
1242	{	1168	{
1243	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));	1169	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1244	target->stats.hp = target->stats.maxhp * 2;	1170	target->stats.hp = target->stats.maxhp * 2;
1245	free_object (effect);	1171	effect->destroy ();
1246	return 0;	1172	return 0;
1247	}	1173	}
1248	}	1174	}
1249	}	1175	}
1250	else	1176	else
1251	{	1177	{
1252	/* how much woe to inflict :) */	1178	/* how much woe to inflict :) */
1253	effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1179	effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1254	}	1180	}
1255		1181
1256	set_owner (effect, op);	1182	effect->set_owner (op);
1257	set_spell_skill (op, caster, spell, effect);	1183	set_spell_skill (op, caster, spell, effect);
1258		1184
1259	/* ok, tell it where to be, and insert! */	1185	/* ok, tell it where to be, and insert! */
1260	effect->x = target->x;	1186	effect->insert_at (target, op);
1261	effect->y = target->y;
1262	insert_ob_in_map (effect, target->map, op, 0);
1263		1187
1264	return 1;	1188	return 1;
1265	}	1189	}
1266		1190
1267		1191
…		…
1277	move_missile (object *op)	1201	move_missile (object *op)
1278	{	1202	{
1279	int i, mflags;	1203	int i, mflags;
1280	object *owner;	1204	object *owner;
1281	sint16 new_x, new_y;	1205	sint16 new_x, new_y;
1282	mapstruct *m;	1206	maptile *m;
1283		1207
1284	if (op->range-- <= 0)	1208	if (op->range-- <= 0)
1285	{	1209	{
1286	remove_ob (op);	1210	op->destroy ();
1287	free_object (op);
1288	return;	1211	return;
1289	}	1212	}
1290		1213
1291	owner = get_owner (op);	1214	owner = op->owner;
1292	#if 0	1215	#if 0
1293	/* It'd make things nastier if this wasn't here - spells cast by	1216	/* It'd make things nastier if this wasn't here - spells cast by
1294	* monster that are then killed would continue to survive	1217	* monster that are then killed would continue to survive
1295	*/	1218	*/
1296	if (owner == NULL)	1219	if (owner == NULL)
1297	{	1220	{
1298	remove_ob (op);	1221	op->destroy ();
1299	free_object (op);
1300	return;	1222	return;
1301	}	1223	}
1302	#endif	1224	#endif
1303		1225
1304	new_x = op->x + DIRX (op);	1226	new_x = op->x + DIRX (op);
…		…
1306		1228
1307	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);	1229	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1308		1230
1309	if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))	1231	if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1310	{	1232	{
1311	tag_t tag = op->count;
1312
1313	hit_map (op, op->direction, AT_MAGIC, 1);	1233	hit_map (op, op->direction, AT_MAGIC, 1);
1314	/* Basically, missile only hits one thing then goes away.	1234	/* Basically, missile only hits one thing then goes away.
1315	* we need to remove it if someone hasn't already done so.	1235	* we need to remove it if someone hasn't already done so.
1316	*/	1236	*/
1317	if (!was_destroyed (op, tag))	1237	if (!op->destroyed ())
1318	{	1238	op->destroy ();
1319	remove_ob (op);	1239
1320	free_object (op);
1321	}
1322	return;	1240	return;
1323	}	1241	}
1324		1242
1325	remove_ob (op);	1243	op->remove ();
		1244
1326	if (!op->direction || (mflags & P_OUT_OF_MAP))	1245	if (!op->direction || (mflags & P_OUT_OF_MAP))
1327	{	1246	{
1328	free_object (op);	1247	op->destroy ();
1329	return;	1248	return;
1330	}	1249	}
1331	op->x = new_x;	1250
1332	op->y = new_y;	1251	i = spell_find_dir (m, new_x, new_y, op->owner);
1333	op->map = m;
1334	i = spell_find_dir (op->map, op->x, op->y, get_owner (op));
1335	if (i > 0 && i != op->direction)	1252	if (i > 0 && i != op->direction)
1336	{	1253	{
1337	op->direction = i;	1254	op->direction = i;
1338	SET_ANIMATION (op, op->direction);	1255	SET_ANIMATION (op, op->direction);
1339	}	1256	}
1340	insert_ob_in_map (op, op->map, op, 0);	1257
		1258	m->insert (op, new_x, new_y, op);
1341	}	1259	}
1342		1260
1343	/****************************************************************************	1261	/****************************************************************************
1344	* Destruction	1262	* Destruction
1345	****************************************************************************/	1263	****************************************************************************/
…		…
1382	return 0;	1300	return 0;
1383	}	1301	}
1384	return 1;	1302	return 1;
1385	}	1303	}
1386		1304
1387
1388
1389
1390	int	1305	int
1391	cast_destruction (object *op, object *caster, object *spell_ob)	1306	cast_destruction (object *op, object *caster, object *spell_ob)
1392	{	1307	{
1393	int i, j, range, mflags, friendly = 0, dam, dur;	1308	int i, j, range, mflags, friendly = 0, dam, dur;
1394	sint16 sx, sy;	1309	sint16 sx, sy;
1395	mapstruct *m;	1310	maptile *m;
1396	object *tmp;	1311	object *tmp;
1397	const char *skill;	1312	const char *skill;
1398		1313
1399	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1314	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1400	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	1315	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
…		…
1414	else if (caster->skill)	1329	else if (caster->skill)
1415	op->skill = caster->skill;	1330	op->skill = caster->skill;
1416	else	1331	else
1417	op->skill = NULL;	1332	op->skill = NULL;
1418		1333
1419	change_skill (op, find_skill_by_name (op, op->skill), 1);	1334	op->change_skill (find_skill_by_name (op, op->skill));
1420		1335
1421	for (i = -range; i < range; i++)	1336	for (i = -range; i < range; i++)
1422	{	1337	{
1423	for (j = -range; j < range; j++)	1338	for (j = -range; j < range; j++)
1424	{	1339	{
1425	m = op->map;	1340	m = op->map;
1426	sx = op->x + i;	1341	sx = op->x + i;
1427	sy = op->y + j;	1342	sy = op->y + j;
		1343
1428	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	1344	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1429	if (mflags & P_OUT_OF_MAP)	1345	if (mflags & P_OUT_OF_MAP)
1430	continue;	1346	continue;
		1347
1431	if (mflags & P_IS_ALIVE)	1348	if (mflags & P_IS_ALIVE)
1432	{	1349	{
1433	for (tmp = get_map_ob (m, sx, sy); tmp; tmp = tmp->above)	1350	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
1434	{
1435	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)	1351	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1436	break;	1352	break;
1437	}	1353
1438	if (tmp)	1354	if (tmp)
1439	{	1355	{
1440	if (tmp->head)	1356	if (tmp->head)
1441	tmp = tmp->head;	1357	tmp = tmp->head;
1442		1358
…		…
1445	{	1361	{
1446	if (spell_ob->subtype == SP_DESTRUCTION)	1362	if (spell_ob->subtype == SP_DESTRUCTION)
1447	{	1363	{
1448	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1364	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1449	if (spell_ob->other_arch)	1365	if (spell_ob->other_arch)
1450	{
1451	tmp = arch_to_object (spell_ob->other_arch);	1366	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1452	tmp->x = sx;
1453	tmp->y = sy;
1454	insert_ob_in_map (tmp, m, op, 0);
1455	}
1456	}	1367	}
1457	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)	1368	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1458	{	1369	{
1459	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1370	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1460	{
1461	object *effect = arch_to_object (spell_ob->other_arch);	1371	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1462
1463	effect->x = sx;
1464	effect->y = sy;
1465	insert_ob_in_map (effect, m, op, 0);
1466	}
1467	}	1372	}
1468	}	1373	}
1469	}	1374	}
1470	}	1375	}
1471	}	1376	}
1472	}	1377	}
		1378
1473	op->skill = skill;	1379	op->skill = skill;
1474	return 1;	1380	return 1;
1475	}	1381	}
1476		1382
1477	/***************************************************************************	1383	/***************************************************************************
…		…
1537	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1443	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1538	}	1444	}
1539	return 1;	1445	return 1;
1540	}	1446	}
1541	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1447	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1542	force->speed = 1.0;	1448	force->speed = 1.f;
1543	force->speed_left = -1.0;	1449	force->speed_left = -1.f;
1544	SET_FLAG (force, FLAG_APPLIED);	1450	SET_FLAG (force, FLAG_APPLIED);
1545		1451
1546	if (god)	1452	if (god)
1547	{	1453	{
1548	if (spell_ob->last_grace)	1454	if (spell_ob->last_grace)
…		…
1561	force->stats.ac = spell_ob->stats.ac;	1467	force->stats.ac = spell_ob->stats.ac;
1562	force->stats.wc = spell_ob->stats.wc;	1468	force->stats.wc = spell_ob->stats.wc;
1563		1469
1564	change_abil (tmp, force); /* Mostly to display any messages */	1470	change_abil (tmp, force); /* Mostly to display any messages */
1565	insert_ob_in_ob (force, tmp);	1471	insert_ob_in_ob (force, tmp);
1566	fix_player (tmp);	1472	tmp->update_stats ();
1567	return 1;	1473	return 1;
1568		1474
1569	}	1475	}
1570
1571		1476
1572	/**********************************************************************	1477	/**********************************************************************
1573	* mood change	1478	* mood change
1574	* Arguably, this may or may not be an attack spell. But since it	1479	* Arguably, this may or may not be an attack spell. But since it
1575	* effects monsters, it seems best to put it into this file	1480	* effects monsters, it seems best to put it into this file
…		…
1582	mood_change (object *op, object *caster, object *spell)	1487	mood_change (object *op, object *caster, object *spell)
1583	{	1488	{
1584	object *tmp, *god, *head;	1489	object *tmp, *god, *head;
1585	int done_one, range, mflags, level, at, best_at;	1490	int done_one, range, mflags, level, at, best_at;
1586	sint16 x, y, nx, ny;	1491	sint16 x, y, nx, ny;
1587	mapstruct *m;	1492	maptile *m;
1588	const char *race;	1493	const char *race;
1589		1494
1590	/* We precompute some values here so that we don't have to keep	1495	/* We precompute some values here so that we don't have to keep
1591	* doing it over and over again.	1496	* doing it over and over again.
1592	*/	1497	*/
…		…
1605	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1510	else if (god && !strcmp (spell->race, "GOD_FRIEND"))
1606	race = god->race;	1511	race = god->race;
1607	else	1512	else
1608	race = spell->race;	1513	race = spell->race;
1609		1514
1610
1611	for (x = op->x - range; x <= op->x + range; x++)	1515	for (x = op->x - range; x <= op->x + range; x++)
1612	for (y = op->y - range; y <= op->y + range; y++)	1516	for (y = op->y - range; y <= op->y + range; y++)
1613	{	1517	{
1614
1615	done_one = 0;	1518	done_one = 0;
1616	m = op->map;	1519	m = op->map;
1617	nx = x;	1520	nx = x;
1618	ny = y;	1521	ny = y;
1619	mflags = get_map_flags (m, &m, x, y, &nx, &ny);	1522	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
…		…
1622		1525
1623	/* If there is nothing living on this space, no need to go further */	1526	/* If there is nothing living on this space, no need to go further */
1624	if (!(mflags & P_IS_ALIVE))	1527	if (!(mflags & P_IS_ALIVE))
1625	continue;	1528	continue;
1626		1529
		1530	// players can only affect spaces that they can actually see
		1531	if (caster && caster->contr
		1532	&& caster->contr->visibility_at (m, nx, ny) < 70)
		1533	continue;
		1534
1627	for (tmp = get_map_ob (m, nx, ny); tmp; tmp = tmp->above)	1535	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)
1628	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1536	if (QUERY_FLAG (tmp, FLAG_MONSTER))
1629	break;	1537	break;
1630		1538
1631	/* There can be living objects that are not monsters */	1539	/* There can be living objects that are not monsters */
1632	if (!tmp || tmp->type == PLAYER)	1540	if (!tmp || tmp->type == PLAYER)
…		…
1639	head = tmp;	1547	head = tmp;
1640		1548
1641	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */	1549	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */
1642	if (race && head->race && !strstr (race, head->race))	1550	if (race && head->race && !strstr (race, head->race))
1643	continue;	1551	continue;
		1552
1644	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1553	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))
1645	continue;	1554	continue;
1646		1555
1647	/* Now do a bunch of stuff related to saving throws */	1556	/* Now do a bunch of stuff related to saving throws */
1648	best_at = -1;	1557	best_at = -1;
…		…
1665	at -= level / 5;	1574	at -= level / 5;
1666	if (did_make_save (head, head->level, at))	1575	if (did_make_save (head, head->level, at))
1667	continue;	1576	continue;
1668	}	1577	}
1669	else /* spell->attacktype */	1578	else /* spell->attacktype */
1670	/*
1671	Spell has no attacktype (charm & such), so we'll have a specific saving:
1672	* if spell level < monster level, no go
1673	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1674
1675	The chance will then be in the range [20-70] percent, not too bad.
1676
1677	This is required to fix the 'charm monster' abuse, where a player level 1 can
1678	charm a level 125 monster...
1679
1680	Ryo, august 14th
1681	*/
1682	{	1579	{
		1580	/*
		1581	Spell has no attacktype (charm & such), so we'll have a specific saving:
		1582	* if spell level < monster level, no go
		1583	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
		1584
		1585	The chance will then be in the range [20-70] percent, not too bad.
		1586
		1587	This is required to fix the 'charm monster' abuse, where a player level 1 can
		1588	charm a level 125 monster...
		1589
		1590	Ryo, august 14th
		1591	*/
1683	if (head->level > level)	1592	if (head->level > level)
1684	continue;	1593	continue;
		1594
1685	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))	1595	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))
1686	/* Failed, no effect */	1596	/* Failed, no effect */
1687	continue;	1597	continue;
1688	}	1598	}
1689		1599
1690	/* Done with saving throw. Now start effecting the monster */	1600	/* Done with saving throw. Now start affecting the monster */
1691		1601
1692	/* aggravation */	1602	/* aggravation */
1693	if (QUERY_FLAG (spell, FLAG_MONSTER))	1603	if (QUERY_FLAG (spell, FLAG_MONSTER))
1694	{	1604	{
1695	CLEAR_FLAG (head, FLAG_SLEEP);	1605	CLEAR_FLAG (head, FLAG_SLEEP);
1696	if (QUERY_FLAG (head, FLAG_FRIENDLY))
1697	remove_friendly_object (head);	1606	remove_friendly_object (head);
1698
1699	done_one = 1;	1607	done_one = 1;
1700	head->enemy = op;	1608	head->enemy = op;
1701	}	1609	}
1702		1610
1703	/* calm monsters */	1611	/* calm monsters */
…		…
1712	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1620	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))
1713	{	1621	{
1714	SET_FLAG (head, FLAG_BERSERK);	1622	SET_FLAG (head, FLAG_BERSERK);
1715	done_one = 1;	1623	done_one = 1;
1716	}	1624	}
		1625
1717	/* charm */	1626	/* charm */
1718	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1627	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
1719	{	1628	{
1720	SET_FLAG (head, FLAG_FRIENDLY);
1721	/* Prevent uncontolled outbreaks of self replicating monsters.	1629	/* Prevent uncontolled outbreaks of self replicating monsters.
1722	Typical use case is charm, go somwhere, use aggravation to make hostile.	1630	Typical use case is charm, go somwhere, use aggravation to make hostile.
1723	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */	1631	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1724	CLEAR_FLAG (head, FLAG_GENERATOR);	1632	CLEAR_FLAG (head, FLAG_GENERATOR);
1725	set_owner (head, op);	1633	head->set_owner (op);
1726	set_spell_skill (op, caster, spell, head);	1634	set_spell_skill (op, caster, spell, head);
1727	add_friendly_object (head);	1635	add_friendly_object (head);
1728	head->attack_movement = PETMOVE;	1636	head->attack_movement = PETMOVE;
1729	done_one = 1;	1637	done_one = 1;
1730	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1638	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1731	head->stats.exp = 0;	1639	head->stats.exp = 0;
1732	}	1640	}
1733		1641
1734	/* If a monster was effected, put an effect in */	1642	/* If a monster was effected, put an effect in */
1735	if (done_one && spell->other_arch)	1643	if (done_one && spell->other_arch)
1736	{
1737	tmp = arch_to_object (spell->other_arch);	1644	m->insert (arch_to_object (spell->other_arch), nx, ny, op);
1738	tmp->x = nx;
1739	tmp->y = ny;
1740	insert_ob_in_map (tmp, m, op, 0);
1741	}
1742	} /* for y */	1645	} /* for y */
1743		1646
1744	return 1;	1647	return 1;
1745	}	1648	}
1746		1649
…		…
1756	move_ball_spell (object *op)	1659	move_ball_spell (object *op)
1757	{	1660	{
1758	int i, j, dam_save, dir, mflags;	1661	int i, j, dam_save, dir, mflags;
1759	sint16 nx, ny, hx, hy;	1662	sint16 nx, ny, hx, hy;
1760	object *owner;	1663	object *owner;
1761	mapstruct *m;	1664	maptile *m;
1762		1665
1763	owner = get_owner (op);	1666	owner = op->owner;
1764		1667
1765	/* the following logic makes sure that the ball doesn't move into a wall,	1668	/* the following logic makes sure that the ball doesn't move into a wall,
1766	* and makes sure that it will move along a wall to try and get at it's	1669	* and makes sure that it will move along a wall to try and get at it's
1767	* victim. The block immediately below more or less chooses a random	1670	* victim. The block immediately below more or less chooses a random
1768	* offset to move the ball, eg, keep it mostly on course, with some	1671	* offset to move the ball, eg, keep it mostly on course, with some
…		…
1797	nx = op->x;	1700	nx = op->x;
1798	ny = op->y;	1701	ny = op->y;
1799	m = op->map;	1702	m = op->map;
1800	}	1703	}
1801		1704
1802	remove_ob (op);	1705	m->insert (op, nx, ny, op);
1803	op->y = ny;
1804	op->x = nx;
1805	insert_ob_in_map (op, m, op, 0);
1806		1706
1807	dam_save = op->stats.dam; /* save the original dam: we do halfdam on	1707	dam_save = op->stats.dam; /* save the original dam: we do halfdam on
1808	surrounding squares */	1708	surrounding squares */
1809		1709
1810	/* loop over current square and neighbors to hit.	1710	/* loop over current square and neighbors to hit.
1811	* if this has an other_arch field, we insert that in	1711	* if this has an other_arch field, we insert that in
1812	* the surround spaces.	1712	* the surround spaces.
1813	*/	1713	*/
1814	for (j = 0; j < 9; j++)	1714	for (j = 0; j < 9; j++)
1815	{	1715	{
1816	object *new_ob;
1817
1818	hx = nx + freearr_x[j];	1716	hx = nx + freearr_x[j];
1819	hy = ny + freearr_y[j];	1717	hy = ny + freearr_y[j];
1820		1718
1821	m = op->map;	1719	m = op->map;
1822	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);	1720	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
…		…
1836		1734
1837	}	1735	}
1838		1736
1839	/* insert the other arch */	1737	/* insert the other arch */
1840	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))	1738	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1841	{	1739	m->insert (arch_to_object (op->other_arch), hx, hy, op);
1842	new_ob = arch_to_object (op->other_arch);
1843	new_ob->x = hx;
1844	new_ob->y = hy;
1845	insert_ob_in_map (new_ob, m, op, 0);
1846	}
1847	}	1740	}
1848		1741
1849	/* restore to the center location and damage */	1742	/* restore to the center location and damage */
1850	op->stats.dam = dam_save;	1743	op->stats.dam = dam_save;
1851		1744
1852	i = spell_find_dir (op->map, op->x, op->y, get_owner (op));	1745	i = spell_find_dir (op->map, op->x, op->y, op->owner);
1853		1746
1854	if (i >= 0)	1747	if (i >= 0)
1855	{ /* we have a preferred direction! */	1748	{ /* we have a preferred direction! */
1856	/* pick another direction if the preferred dir is blocked. */	1749	/* pick another direction if the preferred dir is blocked. */
1857	if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP ||	1750	if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP ||
1858	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))	1751	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))
1859	{
1860	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */	1752	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1861	}	1753
1862	op->direction = i;	1754	op->direction = i;
1863	}	1755	}
1864	}	1756	}
1865		1757
1866		1758
…		…
1878	#if 0	1770	#if 0
1879	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };	1771	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1880	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };	1772	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1881	sint16 target_x, target_y, origin_x, origin_y;	1773	sint16 target_x, target_y, origin_x, origin_y;
1882	int adjustdir;	1774	int adjustdir;
1883	mapstruct *m;	1775	maptile *m;
1884	#endif	1776	#endif
1885	int basedir;	1777	int basedir;
1886	object *owner;	1778	object *owner;
1887		1779
1888	owner = get_owner (op);	1780	owner = op->owner;
1889	if (op->duration == 0 || owner == NULL)	1781	if (op->duration == 0 || owner == NULL)
1890	{	1782	{
1891	remove_ob (op);	1783	op->destroy ();
1892	free_object (op);
1893	return;	1784	return;
1894	}	1785	}
		1786
1895	op->duration--;	1787	op->duration--;
1896		1788
1897	basedir = op->direction;	1789	basedir = op->direction;
1898	if (basedir == 0)	1790	if (basedir == 0)
1899	{	1791	{
…		…
1904	#if 0	1796	#if 0
1905	// this is bogus: it causes wrong places to be checked below	1797	// this is bogus: it causes wrong places to be checked below
1906	// (a wall 2 cells away will block the effect...) and	1798	// (a wall 2 cells away will block the effect...) and
1907	// doesn't work for SP_BULLET anyhow, so again tests the wrong	1799	// doesn't work for SP_BULLET anyhow, so again tests the wrong
1908	// space.	1800	// space.
1909	// should be fixed later, but correctness before featurs...	1801	// should be fixed later, but correctness before features...
1910	// (schmorp)	1802	// (schmorp)
1911		1803
1912	/* new offset calculation to make swarm element distribution	1804	/* new offset calculation to make swarm element distribution
1913	* more uniform	1805	* more uniform
1914	*/	1806	*/
…		…
1996		1888
1997	if (!spell->other_arch)	1889	if (!spell->other_arch)
1998	return 0;	1890	return 0;
1999		1891
2000	tmp = get_archetype (SWARM_SPELL);	1892	tmp = get_archetype (SWARM_SPELL);
2001	tmp->x = op->x;
2002	tmp->y = op->y;
2003	set_owner (tmp, op); /* needed so that if swarm elements kill, caster gets xp. */	1893	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
2004	set_spell_skill (op, caster, spell, tmp);	1894	set_spell_skill (op, caster, spell, tmp);
2005		1895
2006	tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */	1896	tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */
2007	tmp->spell = arch_to_object (spell->other_arch);	1897	tmp->spell = arch_to_object (spell->other_arch);
2008		1898
2009	tmp->attacktype = tmp->spell->attacktype;	1899	tmp->attacktype = tmp->spell->attacktype;
2010		1900
2011	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)	1901	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
2012	{
2013	if (!tailor_god_spell (tmp, op))	1902	if (!tailor_god_spell (tmp, op))
2014	return 1;	1903	return 1;
2015	}	1904
2016	tmp->duration = SP_level_duration_adjust (caster, spell);	1905	tmp->duration = SP_level_duration_adjust (caster, spell);
2017	for (i = 0; i < spell->duration; i++)	1906	for (i = 0; i < spell->duration; i++)
2018	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1907	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
2019		1908
2020	tmp->direction = dir;	1909	tmp->direction = dir;
2021	tmp->invisible = 1;	1910	tmp->invisible = 1;
2022	insert_ob_in_map (tmp, op->map, op, 0);	1911
		1912	tmp->insert_at (op, op);
2023	return 1;	1913	return 1;
2024	}	1914	}
2025		1915
2026		1916
2027	/* See the spells documentation file for why this is its own	1917	/* See the spells documentation file for why this is its own
…		…
2031	cast_light (object *op, object *caster, object *spell, int dir)	1921	cast_light (object *op, object *caster, object *spell, int dir)
2032	{	1922	{
2033	object *target = NULL, *tmp = NULL;	1923	object *target = NULL, *tmp = NULL;
2034	sint16 x, y;	1924	sint16 x, y;
2035	int dam, mflags;	1925	int dam, mflags;
2036	mapstruct *m;	1926	maptile *m;
2037		1927
2038	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1928	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2039		1929
2040	if (!dir)	1930	if (!dir)
2041	{	1931	{
…		…
2055	return 0;	1945	return 0;
2056	}	1946	}
2057		1947
2058	if (mflags & P_IS_ALIVE && spell->attacktype)	1948	if (mflags & P_IS_ALIVE && spell->attacktype)
2059	{	1949	{
2060	for (target = get_map_ob (m, x, y); target; target = target->above)	1950	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
2061	if (QUERY_FLAG (target, FLAG_MONSTER))	1951	if (QUERY_FLAG (target, FLAG_MONSTER))
2062	{	1952	{
2063	/* oky doky. got a target monster. Lets make a blinding attack */	1953	/* oky doky. got a target monster. Lets make a blinding attack */
2064	if (target->head)	1954	if (target->head)
2065	target = target->head;	1955	target = target->head;
…		…
2087	{	1977	{
2088	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);	1978	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);
2089	if (tmp->glow_radius > MAX_LIGHT_RADII)	1979	if (tmp->glow_radius > MAX_LIGHT_RADII)
2090	tmp->glow_radius = MAX_LIGHT_RADII;	1980	tmp->glow_radius = MAX_LIGHT_RADII;
2091	}	1981	}
2092	tmp->x = x;	1982
2093	tmp->y = y;	1983	m->insert (tmp, x, y, op);
2094	insert_ob_in_map (tmp, m, op, 0);
2095	return 1;	1984	return 1;
2096	}	1985	}
2097		1986
2098		1987
2099		1988
…		…
2109	cast_cause_disease (object *op, object *caster, object *spell, int dir)	1998	cast_cause_disease (object *op, object *caster, object *spell, int dir)
2110	{	1999	{
2111	sint16 x, y;	2000	sint16 x, y;
2112	int i, mflags, range, dam_mod, dur_mod;	2001	int i, mflags, range, dam_mod, dur_mod;
2113	object *walk;	2002	object *walk;
2114	mapstruct *m;	2003	maptile *m;
2115		2004
2116	x = op->x;	2005	x = op->x;
2117	y = op->y;	2006	y = op->y;
2118		2007
2119	/* If casting from a scroll, no direction will be available, so refer to the	2008	/* If casting from a scroll, no direction will be available, so refer to the
…		…
2147		2036
2148	/* Only bother looking on this space if there is something living here */	2037	/* Only bother looking on this space if there is something living here */
2149	if (mflags & P_IS_ALIVE)	2038	if (mflags & P_IS_ALIVE)
2150	{	2039	{
2151	/* search this square for a victim */	2040	/* search this square for a victim */
2152	for (walk = get_map_ob (m, x, y); walk; walk = walk->above)	2041	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
2153	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))	2042	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
2154	{ /* found a victim */	2043	{ /* found a victim */
2155	object *disease = arch_to_object (spell->other_arch);	2044	object *disease = arch_to_object (spell->other_arch);
2156		2045
2157	set_owner (disease, op);	2046	disease->set_owner (op);
2158	set_spell_skill (op, caster, spell, disease);	2047	set_spell_skill (op, caster, spell, disease);
2159	disease->stats.exp = 0;	2048	disease->stats.exp = 0;
2160	disease->level = caster_level (caster, spell);	2049	disease->level = caster_level (caster, spell);
2161		2050
2162	/* do level adjustments */	2051	/* do level adjustments */
…		…
2207	if (disease->stats.sp)	2096	if (disease->stats.sp)
2208	disease->stats.sp -= dam_mod;	2097	disease->stats.sp -= dam_mod;
2209		2098
2210	if (infect_object (walk, disease, 1))	2099	if (infect_object (walk, disease, 1))
2211	{	2100	{
2212	object *flash; /* visual effect for inflicting disease */
2213
2214	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);	2101	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2215		2102
2216	free_object (disease); /* don't need this one anymore */	2103	disease->destroy (); /* don't need this one anymore */
2217	flash = get_archetype (ARCH_DETECT_MAGIC);	2104	walk->map->insert (get_archetype (ARCH_DETECT_MAGIC), x, y, op);
2218	flash->x = x;
2219	flash->y = y;
2220	flash->map = walk->map;
2221	insert_ob_in_map (flash, walk->map, op, 0);
2222	return 1;	2105	return 1;
2223	}	2106	}
2224	free_object (disease);	2107
		2108	disease->destroy ();
2225	}	2109	}
2226	} /* if living creature */	2110	} /* if living creature */
2227	} /* for range of spaces */	2111	} /* for range of spaces */
		2112
2228	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");	2113	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
2229	return 1;	2114	return 1;
2230	}	2115	}

Diff Legend

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