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.41 by root, Sat Jun 9 21:16:12 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
351
352		341
353	/***************************************************************************	342	/***************************************************************************
354	*	343	*
355	* BULLET/BALL CODE	344	* BULLET/BALL CODE
356	*	345	*
…		…
361	* At least that is what I think this does.	350	* At least that is what I think this does.
362	*/	351	*/
363	void	352	void
364	explosion (object *op)	353	explosion (object *op)
365	{	354	{
366	object *tmp;
367	mapstruct *m = op->map;	355	maptile *m = op->map;
368	int i;	356	int i;
369		357
370	if (--(op->duration) < 0)	358	if (--op->duration < 0)
371	{	359	{
372	remove_ob (op);	360	op->destroy ();
373	free_object (op);
374	return;	361	return;
375	}	362	}
		363
376	hit_map (op, 0, op->attacktype, 0);	364	hit_map (op, 0, op->attacktype, 0);
377		365
378	if (op->range > 0)	366	if (op->range > 0)
379	{	367	{
380	for (i = 1; i < 9; i++)	368	for (i = 1; i < 9; i++)
381	{	369	{
382	sint16 dx, dy;	370	sint16 dx, dy;
383		371
384	dx = op->x + freearr_x[i];	372	dx = op->x + freearr_x[i];
385	dy = op->y + freearr_y[i];	373	dy = op->y + freearr_y[i];
		374
386	/* ok_to_put_more already does things like checks for walls,	375	/* ok_to_put_more already does things like checks for walls,
387	* out of map, etc.	376	* out of map, etc.
388	*/	377	*/
389	if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))	378	if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
390	{	379	{
391	tmp = get_object ();	380	object *tmp = op->clone ();
392	copy_object (op, tmp);	381
393	tmp->state = 0;	382	tmp->state = 0;
394	tmp->speed_left = -0.21;	383	tmp->speed_left = -0.21f;
395	tmp->range--;	384	tmp->range--;
396	tmp->value = 0;	385	tmp->value = 0;
397	tmp->x = dx;	386
398	tmp->y = dy;	387	m->insert (tmp, dx, dy, op);
399	insert_ob_in_map (tmp, m, op, 0);
400	}	388	}
401	}	389	}
402	}	390	}
403	}	391	}
404
405		392
406	/* Causes an object to explode, eg, a firebullet,	393	/* Causes an object to explode, eg, a firebullet,
407	* poison cloud ball, etc. op is the object to	394	* poison cloud ball, etc. op is the object to
408	* explode.	395	* explode.
409	*/	396	*/
410	void	397	void
411	explode_bullet (object *op)	398	explode_bullet (object *op)
412	{	399	{
413	tag_t op_tag = op->count;
414	object *tmp, *owner;	400	object *tmp, *owner;
415		401
416	if (op->other_arch == NULL)	402	if (op->other_arch == NULL)
417	{	403	{
418	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	404	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
419	remove_ob (op);	405	op->destroy ();
420	free_object (op);
421	return;	406	return;
422	}	407	}
423		408
424	if (op->env)	409	if (op->env)
425	{	410	{
426	object *env;
427
428	env = object_get_env_recursive (op);	411	object *env = object_get_env_recursive (op);
429	if (env->map == NULL || out_of_map (env->map, env->x, env->y))	412	if (env->map == NULL || out_of_map (env->map, env->x, env->y))
430	{	413	{
431	LOG (llevError, "BUG: explode_bullet(): env out of map\n");	414	LOG (llevError, "BUG: explode_bullet(): env out of map\n");
432	remove_ob (op);	415	op->destroy ();
433	free_object (op);
434	return;	416	return;
435	}	417	}
436	remove_ob (op);	418
437	op->x = env->x;	419	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	}	420	}
441	else if (out_of_map (op->map, op->x, op->y))	421	else if (out_of_map (op->map, op->x, op->y))
442	{	422	{
443	LOG (llevError, "BUG: explode_bullet(): op out of map\n");	423	LOG (llevError, "BUG: explode_bullet(): op out of map\n");
444	remove_ob (op);	424	op->destroy ();
445	free_object (op);
446	return;	425	return;
447	}	426	}
448		427
449	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps	428	// 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	429	// NOTE: If this breaks something important: remove this. I can't think of anything
451	// bad at the moment that might happen from this.	430	// 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)	431	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
453	{	432	{
454	remove_ob (op);	433	op->destroy ();
455	free_object (op);
456	return;	434	return;
457	}	435	}
458		436
459	if (op->attacktype)	437	if (op->attacktype)
460	{	438	{
461	hit_map (op, 0, op->attacktype, 1);	439	hit_map (op, 0, op->attacktype, 1);
462	if (was_destroyed (op, op_tag))	440	if (op->destroyed ())
463	return;	441	return;
464	}	442	}
465		443
466	/* other_arch contains what this explodes into */	444	/* other_arch contains what this explodes into */
467	tmp = arch_to_object (op->other_arch);	445	tmp = arch_to_object (op->other_arch);
468		446
469	copy_owner (tmp, op);	447	tmp->set_owner (op);
470	tmp->skill = op->skill;	448	tmp->skill = op->skill;
471		449
472	owner = get_owner (op);	450	owner = op->owner;
473		451
474	if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))	452	if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))
475	{	453	{
476	remove_ob (op);	454	op->destroy ();
477	free_object (op);
478	return;	455	return;
479	}	456	}
480
481	tmp->x = op->x;
482	tmp->y = op->y;
483		457
484	/* special for bombs - it actually has sane values for these */	458	/* special for bombs - it actually has sane values for these */
485	if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)	459	if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)
486	{	460	{
487	tmp->attacktype = op->attacktype;	461	tmp->attacktype = op->attacktype;
…		…
491	}	465	}
492	else	466	else
493	{	467	{
494	if (op->attacktype & AT_MAGIC)	468	if (op->attacktype & AT_MAGIC)
495	tmp->attacktype |= AT_MAGIC;	469	tmp->attacktype |= AT_MAGIC;
		470
496	/* Spell doc describes what is going on here */	471	/* Spell doc describes what is going on here */
497	tmp->stats.dam = op->dam_modifier;	472	tmp->stats.dam = op->dam_modifier;
498	tmp->range = op->stats.maxhp;	473	tmp->range = op->stats.maxhp;
499	tmp->duration = op->stats.hp;	474	tmp->duration = op->stats.hp;
500	/* Used for spell tracking - just need a unique val for this spell -	475	/* Used for spell tracking - just need a unique val for this spell -
…		…
508	tmp->stats.sp = op->direction;	483	tmp->stats.sp = op->direction;
509		484
510	/* Prevent recursion */	485	/* Prevent recursion */
511	op->move_on = 0;	486	op->move_on = 0;
512		487
513	insert_ob_in_map (tmp, op->map, op, 0);	488	tmp->insert_at (op, op);
514	/* remove the firebullet */	489	/* remove the firebullet */
515	if (!was_destroyed (op, op_tag))	490	op->destroy ();
516	{
517	remove_ob (op);
518	free_object (op);
519	}
520	}	491	}
521
522
523		492
524	/* checks to see what op should do, given the space it is on	493	/* checks to see what op should do, given the space it is on
525	* (eg, explode, damage player, etc)	494	* (eg, explode, damage player, etc)
526	*/	495	*/
527
528	void	496	void
529	check_bullet (object *op)	497	check_bullet (object *op)
530	{	498	{
531	tag_t op_tag = op->count, tmp_tag;
532	object *tmp;	499	object *tmp;
533	int dam, mflags;	500	int dam, mflags;
534	mapstruct *m;	501	maptile *m;
535	sint16 sx, sy;	502	sint16 sx, sy;
536		503
537	mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy);	504	mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy);
538		505
539	if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	506	if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
…		…
548		515
549	/* If nothing alive on this space, no reason to do anything further */	516	/* If nothing alive on this space, no reason to do anything further */
550	if (!(mflags & P_IS_ALIVE))	517	if (!(mflags & P_IS_ALIVE))
551	return;	518	return;
552		519
553	for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	520	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
554	{	521	{
555	if (QUERY_FLAG (tmp, FLAG_ALIVE))	522	if (QUERY_FLAG (tmp, FLAG_ALIVE))
556	{	523	{
557	tmp_tag = tmp->count;
558	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	524	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)	525	if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
560	{	526	{
561	if (!QUERY_FLAG (op, FLAG_REMOVED))	527	if (!QUERY_FLAG (op, FLAG_REMOVED))
562	{	528	{
563	remove_ob (op);	529	op->destroy ();
564	free_object (op);
565	return;	530	return;
566	}	531	}
567	}	532	}
568	}	533	}
569	}	534	}
570	}	535	}
571
572		536
573	/* Basically, we move 'op' one square, and if it hits something,	537	/* Basically, we move 'op' one square, and if it hits something,
574	* call check_bullet.	538	* call check_bullet.
575	* This function is only applicable to bullets, but not to all	539	* This function is only applicable to bullets, but not to all
576	* fired arches (eg, bolts).	540	* fired arches (eg, bolts).
577	*/	541	*/
578
579	void	542	void
580	move_bullet (object *op)	543	move_bullet (object *op)
581	{	544	{
582	sint16 new_x, new_y;	545	sint16 new_x, new_y;
583	int mflags;	546	int mflags;
584	mapstruct *m;	547	maptile *m;
585		548
586	#if 0	549	#if 0
587	/* We need a better general purpose way to do this */	550	/* We need a better general purpose way to do this */
588		551
589	/* peterm: added to make comet leave a trail of burnouts	552	/* peterm: added to make comet leave a trail of burnouts
590	it's an unadulterated hack, but the effect is cool. */	553	it's an unadulterated hack, but the effect is cool. */
591	if (op->stats.sp == SP_METEOR)	554	if (op->stats.sp == SP_METEOR)
592	{	555	{
593	replace_insert_ob_in_map ("fire_trail", op);	556	replace_insert_ob_in_map ("fire_trail", op);
594	if (was_destroyed (op, op_tag))	557	if (op->destroyed ())
595	return;	558	return;
596	} /* end addition. */	559	} /* end addition. */
597	#endif	560	#endif
598		561
599	/* Reached the end of its life - remove it */	562	/* Reached the end of its life - remove it */
600	if (--op->range <= 0)	563	if (--op->range <= 0)
601	{	564	{
602	if (op->other_arch)	565	if (op->other_arch)
603	{
604	explode_bullet (op);	566	explode_bullet (op);
605	}
606	else	567	else
607	{	568	op->destroy ();
608	remove_ob (op);	569
609	free_object (op);
610	}
611	return;	570	return;
612	}	571	}
613		572
614	new_x = op->x + DIRX (op);	573	new_x = op->x + DIRX (op);
615	new_y = op->y + DIRY (op);	574	new_y = op->y + DIRY (op);
616	m = op->map;	575	m = op->map;
617	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);	576	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
618		577
619	if (mflags & P_OUT_OF_MAP)	578	if (mflags & P_OUT_OF_MAP)
620	{	579	{
621	remove_ob (op);	580	op->destroy ();
622	free_object (op);
623	return;	581	return;
624	}	582	}
625		583
626	if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))	584	if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))
627	{	585	{
628	if (op->other_arch)	586	if (op->other_arch)
629	{
630	explode_bullet (op);	587	explode_bullet (op);
631	}
632	else	588	else
633	{	589	op->destroy ();
634	remove_ob (op);	590
635	free_object (op);
636	}
637	return;	591	return;
638	}	592	}
639		593
640	remove_ob (op);	594	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;	595	return;
645		596
646	if (reflwall (op->map, op->x, op->y, op))	597	if (reflwall (op->map, op->x, op->y, op))
647	{	598	{
648	op->direction = absdir (op->direction + 4);	599	op->direction = absdir (op->direction + 4);
649	update_turn_face (op);	600	update_turn_face (op);
650	}	601	}
651	else	602	else
652	{
653	check_bullet (op);	603	check_bullet (op);
654	}
655	}	604	}
656
657
658
659		605
660	/* fire_bullet	606	/* fire_bullet
661	* object op (cast from caster) files a bolt in dir.	607	* object op (cast from caster) files a bolt in dir.
662	* spob is the spell object for the bolt.	608	* spob is the spell object for the bolt.
663	* we remove the magic flag - that can be derived from	609	* we remove the magic flag - that can be derived from
664	* spob->attacktype.	610	* spob->attacktype.
665	* This function sets up the appropriate owner and skill	611	* This function sets up the appropriate owner and skill
666	* pointers.	612	* pointers.
667	*/	613	*/
668
669	int	614	int
670	fire_bullet (object *op, object *caster, int dir, object *spob)	615	fire_bullet (object *op, object *caster, int dir, object *spob)
671	{	616	{
672	object *tmp = NULL;	617	object *tmp = NULL;
673	int mflags;	618	int mflags;
…		…
694		639
695	tmp->direction = dir;	640	tmp->direction = dir;
696	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	641	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
697	SET_ANIMATION (tmp, dir);	642	SET_ANIMATION (tmp, dir);
698		643
699	set_owner (tmp, op);	644	tmp->set_owner (op);
700	set_spell_skill (op, caster, spob, tmp);	645	set_spell_skill (op, caster, spob, tmp);
701		646
702	tmp->x = op->x + freearr_x[dir];	647	tmp->x = op->x + freearr_x[dir];
703	tmp->y = op->y + freearr_y[dir];	648	tmp->y = op->y + freearr_y[dir];
704	tmp->map = op->map;	649	tmp->map = op->map;
705		650
		651	maptile *newmap;
706	mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y);	652	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
707	if (mflags & P_OUT_OF_MAP)	653	if (mflags & P_OUT_OF_MAP)
708	{	654	{
709	free_object (tmp);	655	tmp->destroy ();
710	return 0;	656	return 0;
711	}	657	}
		658
		659	tmp->map = newmap;
		660
712	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))	661	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
713	{	662	{
714	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	663	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
715	{	664	{
716	free_object (tmp);	665	tmp->destroy ();
717	return 0;	666	return 0;
718	}	667	}
		668
719	tmp->x = op->x;	669	tmp->x = op->x;
720	tmp->y = op->y;	670	tmp->y = op->y;
721	tmp->direction = absdir (tmp->direction + 4);	671	tmp->direction = absdir (tmp->direction + 4);
722	tmp->map = op->map;	672	tmp->map = op->map;
723	}	673	}
724	if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL)	674
725	{	675	if ((tmp = tmp->insert_at (tmp, op)))
726	check_bullet (tmp);	676	check_bullet (tmp);
727	}	677
728	return 1;	678	return 1;
729	}	679	}
730
731
732
733		680
734	/*****************************************************************************	681	/*****************************************************************************
735	*	682	*
736	* CONE RELATED FUNCTIONS	683	* CONE RELATED FUNCTIONS
737	*	684	*
738	*****************************************************************************/	685	*****************************************************************************/
739		686
740
741	/* drops an object based on what is in the cone's "other_arch" */	687	/* drops an object based on what is in the cone's "other_arch" */
742	void	688	void
743	cone_drop (object *op)	689	cone_drop (object *op)
744	{	690	{
745	object *new_ob = arch_to_object (op->other_arch);	691	object *new_ob = arch_to_object (op->other_arch);
746		692
747	new_ob->x = op->x;
748	new_ob->y = op->y;
749	new_ob->level = op->level;	693	new_ob->level = op->level;
750	set_owner (new_ob, op->owner);	694	new_ob->set_owner (op->owner);
751		695
752	/* preserve skill ownership */	696	/* preserve skill ownership */
753	if (op->skill && op->skill != new_ob->skill)	697	if (op->skill && op->skill != new_ob->skill)
754	{
755	new_ob->skill = op->skill;	698	new_ob->skill = op->skill;
756	}
757	insert_ob_in_map (new_ob, op->map, op, 0);
758		699
		700	new_ob->insert_at (op, op);
759	}	701	}
760		702
761	/* move_cone: causes cone object 'op' to move a space/hit creatures */	703	/* move_cone: causes cone object 'op' to move a space/hit creatures */
762		704
763	void	705	void
764	move_cone (object *op)	706	move_cone (object *op)
765	{	707	{
766	int i;	708	int i;
767	tag_t tag;
768		709
769	/* if no map then hit_map will crash so just ignore object */	710	/* if no map then hit_map will crash so just ignore object */
770	if (!op->map)	711	if (!op->map)
771	{	712	{
772	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");	713	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
773	op->speed = 0;	714	op->set_speed (0);
774	update_ob_speed (op);
775	return;	715	return;
776	}	716	}
777		717
778	/* lava saves it's life, but not yours :) */	718	/* lava saves it's life, but not yours :) */
779	if (QUERY_FLAG (op, FLAG_LIFESAVE))	719	if (QUERY_FLAG (op, FLAG_LIFESAVE))
…		…
785	#if 0	725	#if 0
786	/* Disable this - enabling it makes monsters easier, as	726	/* Disable this - enabling it makes monsters easier, as
787	* when their cone dies when they die.	727	* when their cone dies when they die.
788	*/	728	*/
789	/* If no owner left, the spell dies out. */	729	/* If no owner left, the spell dies out. */
790	if (get_owner (op) == NULL)	730	if (op->owner == NULL)
791	{	731	{
792	remove_ob (op);	732	op->destroy ();
793	free_object (op);
794	return;	733	return;
795	}	734	}
796	#endif	735	#endif
797		736
798	tag = op->count;
799	hit_map (op, 0, op->attacktype, 0);	737	hit_map (op, 0, op->attacktype, 0);
800		738
801	/* Check to see if we should push anything.	739	/* Check to see if we should push anything.
802	* Spell objects with weight push whatever they encounter to some	740	* Spell objects with weight push whatever they encounter to some
803	* degree.	741	* degree.
804	*/	742	*/
805	if (op->weight)	743	if (op->weight)
806	check_spell_knockback (op);	744	check_spell_knockback (op);
807		745
808	if (was_destroyed (op, tag))	746	if (op->destroyed ())
809	return;	747	return;
810		748
811	if ((op->duration--) < 0)	749	if ((op->duration--) < 0)
812	{	750	{
813	remove_ob (op);	751	op->destroy ();
814	free_object (op);
815	return;	752	return;
816	}	753	}
817	/* Object has hit maximum range, so don't have it move	754	/* Object has hit maximum range, so don't have it move
818	* any further. When the duration above expires,	755	* any further. When the duration above expires,
819	* then the object will get removed.	756	* then the object will get removed.
…		…
828	{	765	{
829	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];	766	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
830		767
831	if (ok_to_put_more (op->map, x, y, op, op->attacktype))	768	if (ok_to_put_more (op->map, x, y, op, op->attacktype))
832	{	769	{
833	object *tmp = get_object ();	770	object *tmp = op->clone ();
834
835	copy_object (op, tmp);
836	tmp->x = x;
837	tmp->y = y;
838		771
839	tmp->duration = op->duration + 1;	772	tmp->duration = op->duration + 1;
840		773
841	/* Use for spell tracking - see ok_to_put_more() */	774	/* Use for spell tracking - see ok_to_put_more() */
842	tmp->stats.maxhp = op->stats.maxhp;	775	tmp->stats.maxhp = op->stats.maxhp;
843	insert_ob_in_map (tmp, op->map, op, 0);	776
		777	op->map->insert (tmp, x, y, op);
		778
844	if (tmp->other_arch)	779	if (tmp->other_arch)
845	cone_drop (tmp);	780	cone_drop (tmp);
846	}	781	}
847	}	782	}
848	}	783	}
…		…
858	int	793	int
859	cast_cone (object *op, object *caster, int dir, object *spell)	794	cast_cone (object *op, object *caster, int dir, object *spell)
860	{	795	{
861	object *tmp;	796	object *tmp;
862	int i, success = 0, range_min = -1, range_max = 1;	797	int i, success = 0, range_min = -1, range_max = 1;
863	mapstruct *m;	798	maptile *m;
864	sint16 sx, sy;	799	sint16 sx, sy;
865	MoveType movetype;	800	MoveType movetype;
866		801
867	if (!spell->other_arch)	802	if (!spell->other_arch)
868	return 0;	803	return 0;
…		…
881		816
882	/* Need to know what the movetype of the object we are about	817	/* Need to know what the movetype of the object we are about
883	* to create is, so we can know if the space we are about to	818	* to create is, so we can know if the space we are about to
884	* insert it into is blocked.	819	* insert it into is blocked.
885	*/	820	*/
886	movetype = spell->other_arch->clone.move_type;	821	movetype = spell->other_arch->move_type;
887		822
888	for (i = range_min; i <= range_max; i++)	823	for (i = range_min; i <= range_max; i++)
889	{	824	{
890	sint16 x, y, d;	825	sint16 x, y, d;
891		826
…		…
924	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	859	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
925	continue;	860	continue;
926		861
927	success = 1;	862	success = 1;
928	tmp = arch_to_object (spell->other_arch);	863	tmp = arch_to_object (spell->other_arch);
929	set_owner (tmp, op);	864	tmp->set_owner (op);
930	set_spell_skill (op, caster, spell, tmp);	865	set_spell_skill (op, caster, spell, tmp);
931	tmp->level = caster_level (caster, spell);	866	tmp->level = caster_level (caster, spell);
932	tmp->x = sx;
933	tmp->y = sy;
934	tmp->attacktype = spell->attacktype;	867	tmp->attacktype = spell->attacktype;
935		868
936	/* holy word stuff */	869	/* holy word stuff */
937	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))	870	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
938	if (!tailor_god_spell (tmp, op))	871	if (!tailor_god_spell (tmp, op))
…		…
972	else	905	else
973	tmp->duration += caster->level / 3;	906	tmp->duration += caster->level / 3;
974	}	907	}
975		908
976	if (!(tmp->move_type & MOVE_FLY_LOW))	909	if (!(tmp->move_type & MOVE_FLY_LOW))
977	LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n", &spell->other_arch->name);	910	LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n", &spell->other_arch->archname);
978		911
979	if (!tmp->move_on && tmp->stats.dam)	912	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);	913	LOG (llevDebug, "cast_cone(): arch %s doesn't have move_on set\n", &spell->other_arch->archname);
982	}
983		914
984	insert_ob_in_map (tmp, m, op, 0);	915	m->insert (tmp, sx, sy, op);
985		916
986	/* This is used for tracking spells so that one effect doesn't hit	917	/* This is used for tracking spells so that one effect doesn't hit
987	* a single space too many times.	918	* a single space too many times.
988	*/	919	*/
989	tmp->stats.maxhp = tmp->count;	920	tmp->stats.maxhp = tmp->count;
…		…
999	*	930	*
1000	* BOMB related code	931	* BOMB related code
1001	*	932	*
1002	****************************************************************************/	933	****************************************************************************/
1003		934
1004
1005	/* This handles an exploding bomb.	935	/* This handles an exploding bomb.
1006	* op is the original bomb object.	936	* op is the original bomb object.
1007	*/	937	*/
1008	void	938	void
1009	animate_bomb (object *op)	939	animate_bomb (object *op)
1010	{	940	{
1011	int i;	941	int i;
1012	object *env, *tmp;	942	object *env, *tmp;
1013	archetype *at;
1014		943
1015	if (op->state != NUM_ANIMATIONS (op) - 1)	944	if (op->state != NUM_ANIMATIONS (op) - 1)
1016	return;	945	return;
1017		946
1018	env = object_get_env_recursive (op);	947	env = object_get_env_recursive (op);
…		…
1023	return;	952	return;
1024		953
1025	if (env->type == PLAYER)	954	if (env->type == PLAYER)
1026	esrv_del_item (env->contr, op->count);	955	esrv_del_item (env->contr, op->count);
1027		956
1028	remove_ob (op);	957	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;	958	return;
1033	}	959	}
1034		960
1035	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding	961	// 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	962	// on a safe map. I don't like this special casing, but it seems to be neccessary
1037	// as bombs can be carried.	963	// as bombs can be carried.
1038	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	964	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
1039	{	965	{
1040	remove_ob (op);	966	op->destroy ();
1041	free_object (op);
1042	return;	967	return;
1043	}	968	}
1044		969
1045	/* This copies a lot of the code from the fire bullet,	970	/* This copies a lot of the code from the fire bullet,
1046	* but using the cast_bullet isn't really feasible,	971	* but using the cast_bullet isn't really feasible,
1047	* so just set up the appropriate values.	972	* so just set up the appropriate values.
1048	*/	973	*/
1049	at = find_archetype (SPLINT);	974	if (archetype *at = archetype::find (SPLINT))
1050	if (at)
1051	{	975	{
1052	for (i = 1; i < 9; i++)	976	for (i = 1; i < 9; i++)
1053	{	977	{
1054	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))	978	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
1055	continue;	979	continue;
		980
1056	tmp = arch_to_object (at);	981	tmp = arch_to_object (at);
1057	tmp->direction = i;	982	tmp->direction = i;
1058	tmp->range = op->range;	983	tmp->range = op->range;
1059	tmp->stats.dam = op->stats.dam;	984	tmp->stats.dam = op->stats.dam;
1060	tmp->duration = op->duration;	985	tmp->duration = op->duration;
1061	tmp->attacktype = op->attacktype;	986	tmp->attacktype = op->attacktype;
1062	copy_owner (tmp, op);	987	tmp->set_owner (op);
1063	if (op->skill && op->skill != tmp->skill)	988	if (op->skill && op->skill != tmp->skill)
1064	{
1065	tmp->skill = op->skill;	989	tmp->skill = op->skill;
1066	}	990
1067	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	991	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
1068	SET_ANIMATION (tmp, i);	992	SET_ANIMATION (tmp, i);
1069	tmp->x = op->x + freearr_x[i];	993
1070	tmp->y = op->y + freearr_x[i];	994	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);	995	move_bullet (tmp);
1073	}	996	}
1074	}	997	}
1075		998
1076	explode_bullet (op);	999	explode_bullet (op);
…		…
1081	{	1004	{
1082		1005
1083	object *tmp;	1006	object *tmp;
1084	int mflags;	1007	int mflags;
1085	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];	1008	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1086	mapstruct *m;	1009	maptile *m;
1087		1010
1088	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);	1011	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))	1012	if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1090	{	1013	{
1091	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1014	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
…		…
1097	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1020	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1098	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1021	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1099	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1022	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
1100	tmp->attacktype = spell->attacktype;	1023	tmp->attacktype = spell->attacktype;
1101		1024
1102	set_owner (tmp, op);	1025	tmp->set_owner (op);
1103	set_spell_skill (op, caster, spell, tmp);	1026	set_spell_skill (op, caster, spell, tmp);
1104	tmp->x = dx;	1027
1105	tmp->y = dy;	1028	m->insert (tmp, dx, dy, op);
1106	insert_ob_in_map (tmp, m, op, 0);
1107	return 1;	1029	return 1;
1108	}	1030	}
1109		1031
1110	/****************************************************************************	1032	/****************************************************************************
1111	*	1033	*
…		…
1120	* dir is the direction to look in.	1042	* dir is the direction to look in.
1121	* range is how far out to look.	1043	* range is how far out to look.
1122	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.	1044	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.
1123	* this info is used for blocked magic/unholy spaces.	1045	* this info is used for blocked magic/unholy spaces.
1124	*/	1046	*/
1125
1126	object *	1047	object *
1127	get_pointed_target (object *op, int dir, int range, int type)	1048	get_pointed_target (object *op, int dir, int range, int type)
1128	{	1049	{
1129	object *target;	1050	object *target;
1130	sint16 x, y;	1051	sint16 x, y;
1131	int dist, mflags;	1052	int dist, mflags;
1132	mapstruct *mp;	1053	maptile *mp;
1133		1054
1134	if (dir == 0)	1055	if (dir == 0)
1135	return NULL;	1056	return NULL;
1136		1057
1137	for (dist = 1; dist < range; dist++)	1058	for (dist = 1; dist < range; dist++)
…		…
1149	return NULL;	1070	return NULL;
1150	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1071	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1151	return NULL;	1072	return NULL;
1152		1073
1153	if (mflags & P_IS_ALIVE)	1074	if (mflags & P_IS_ALIVE)
1154	{
1155	for (target = get_map_ob (mp, x, y); target; target = target->above)	1075	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1156	{	1076	if (QUERY_FLAG (target, FLAG_MONSTER))
1157	if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER))
1158	{
1159	return target;	1077	return target;
1160	}
1161	}
1162	}
1163	}	1078	}
		1079
1164	return NULL;	1080	return NULL;
1165	}	1081	}
1166
1167		1082
1168	/* cast_smite_arch() - the priest points to a creature and causes	1083	/* cast_smite_arch() - the priest points to a creature and causes
1169	* a 'godly curse' to decend.	1084	* a 'godly curse' to decend.
1170	* usual params -	1085	* usual params -
1171	* op = player	1086	* op = player
…		…
1227	if (effect->attacktype & AT_DEATH)	1142	if (effect->attacktype & AT_DEATH)
1228	{	1143	{
1229	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1144	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1230		1145
1231	/* casting death spells at undead isn't a good thing */	1146	/* casting death spells at undead isn't a good thing */
1232	if QUERY_FLAG
1233	(target, FLAG_UNDEAD)	1147	if (QUERY_FLAG (target, FLAG_UNDEAD))
1234	{	1148	{
1235	if (random_roll (0, 2, op, PREFER_LOW))	1149	if (random_roll (0, 2, op, PREFER_LOW))
1236	{	1150	{
1237	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1151	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1238	effect->x = op->x;	1152	effect->x = op->x;
…		…
1240	}	1154	}
1241	else	1155	else
1242	{	1156	{
1243	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));	1157	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1244	target->stats.hp = target->stats.maxhp * 2;	1158	target->stats.hp = target->stats.maxhp * 2;
1245	free_object (effect);	1159	effect->destroy ();
1246	return 0;	1160	return 0;
1247	}	1161	}
1248	}	1162	}
1249	}	1163	}
1250	else	1164	else
1251	{	1165	{
1252	/* how much woe to inflict :) */	1166	/* how much woe to inflict :) */
1253	effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1167	effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1254	}	1168	}
1255		1169
1256	set_owner (effect, op);	1170	effect->set_owner (op);
1257	set_spell_skill (op, caster, spell, effect);	1171	set_spell_skill (op, caster, spell, effect);
1258		1172
1259	/* ok, tell it where to be, and insert! */	1173	/* ok, tell it where to be, and insert! */
1260	effect->x = target->x;	1174	effect->insert_at (target, op);
1261	effect->y = target->y;
1262	insert_ob_in_map (effect, target->map, op, 0);
1263		1175
1264	return 1;	1176	return 1;
1265	}	1177	}
1266		1178
1267		1179
…		…
1277	move_missile (object *op)	1189	move_missile (object *op)
1278	{	1190	{
1279	int i, mflags;	1191	int i, mflags;
1280	object *owner;	1192	object *owner;
1281	sint16 new_x, new_y;	1193	sint16 new_x, new_y;
1282	mapstruct *m;	1194	maptile *m;
1283		1195
1284	if (op->range-- <= 0)	1196	if (op->range-- <= 0)
1285	{	1197	{
1286	remove_ob (op);	1198	op->destroy ();
1287	free_object (op);
1288	return;	1199	return;
1289	}	1200	}
1290		1201
1291	owner = get_owner (op);	1202	owner = op->owner;
1292	#if 0	1203	#if 0
1293	/* It'd make things nastier if this wasn't here - spells cast by	1204	/* It'd make things nastier if this wasn't here - spells cast by
1294	* monster that are then killed would continue to survive	1205	* monster that are then killed would continue to survive
1295	*/	1206	*/
1296	if (owner == NULL)	1207	if (owner == NULL)
1297	{	1208	{
1298	remove_ob (op);	1209	op->destroy ();
1299	free_object (op);
1300	return;	1210	return;
1301	}	1211	}
1302	#endif	1212	#endif
1303		1213
1304	new_x = op->x + DIRX (op);	1214	new_x = op->x + DIRX (op);
…		…
1306		1216
1307	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);	1217	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1308		1218
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))))	1219	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	{	1220	{
1311	tag_t tag = op->count;
1312
1313	hit_map (op, op->direction, AT_MAGIC, 1);	1221	hit_map (op, op->direction, AT_MAGIC, 1);
1314	/* Basically, missile only hits one thing then goes away.	1222	/* Basically, missile only hits one thing then goes away.
1315	* we need to remove it if someone hasn't already done so.	1223	* we need to remove it if someone hasn't already done so.
1316	*/	1224	*/
1317	if (!was_destroyed (op, tag))	1225	if (!op->destroyed ())
1318	{	1226	op->destroy ();
1319	remove_ob (op);	1227
1320	free_object (op);
1321	}
1322	return;	1228	return;
1323	}	1229	}
1324		1230
1325	remove_ob (op);	1231	op->remove ();
		1232
1326	if (!op->direction || (mflags & P_OUT_OF_MAP))	1233	if (!op->direction || (mflags & P_OUT_OF_MAP))
1327	{	1234	{
1328	free_object (op);	1235	op->destroy ();
1329	return;	1236	return;
1330	}	1237	}
1331	op->x = new_x;	1238
1332	op->y = new_y;	1239	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)	1240	if (i > 0 && i != op->direction)
1336	{	1241	{
1337	op->direction = i;	1242	op->direction = i;
1338	SET_ANIMATION (op, op->direction);	1243	SET_ANIMATION (op, op->direction);
1339	}	1244	}
1340	insert_ob_in_map (op, op->map, op, 0);	1245
		1246	m->insert (op, new_x, new_y, op);
1341	}	1247	}
1342		1248
1343	/****************************************************************************	1249	/****************************************************************************
1344	* Destruction	1250	* Destruction
1345	****************************************************************************/	1251	****************************************************************************/
…		…
1382	return 0;	1288	return 0;
1383	}	1289	}
1384	return 1;	1290	return 1;
1385	}	1291	}
1386		1292
1387
1388
1389
1390	int	1293	int
1391	cast_destruction (object *op, object *caster, object *spell_ob)	1294	cast_destruction (object *op, object *caster, object *spell_ob)
1392	{	1295	{
1393	int i, j, range, mflags, friendly = 0, dam, dur;	1296	int i, j, range, mflags, friendly = 0, dam, dur;
1394	sint16 sx, sy;	1297	sint16 sx, sy;
1395	mapstruct *m;	1298	maptile *m;
1396	object *tmp;	1299	object *tmp;
1397	const char *skill;	1300	const char *skill;
1398		1301
1399	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1302	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1400	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	1303	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
…		…
1414	else if (caster->skill)	1317	else if (caster->skill)
1415	op->skill = caster->skill;	1318	op->skill = caster->skill;
1416	else	1319	else
1417	op->skill = NULL;	1320	op->skill = NULL;
1418		1321
1419	change_skill (op, find_skill_by_name (op, op->skill), 1);	1322	op->change_skill (find_skill_by_name (op, op->skill));
1420		1323
1421	for (i = -range; i < range; i++)	1324	for (i = -range; i < range; i++)
1422	{	1325	{
1423	for (j = -range; j < range; j++)	1326	for (j = -range; j < range; j++)
1424	{	1327	{
1425	m = op->map;	1328	m = op->map;
1426	sx = op->x + i;	1329	sx = op->x + i;
1427	sy = op->y + j;	1330	sy = op->y + j;
		1331
1428	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	1332	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1429	if (mflags & P_OUT_OF_MAP)	1333	if (mflags & P_OUT_OF_MAP)
1430	continue;	1334	continue;
		1335
1431	if (mflags & P_IS_ALIVE)	1336	if (mflags & P_IS_ALIVE)
1432	{	1337	{
1433	for (tmp = get_map_ob (m, sx, sy); tmp; tmp = tmp->above)	1338	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
1434	{
1435	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)	1339	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1436	break;	1340	break;
1437	}	1341
1438	if (tmp)	1342	if (tmp)
1439	{	1343	{
1440	if (tmp->head)	1344	if (tmp->head)
1441	tmp = tmp->head;	1345	tmp = tmp->head;
1442		1346
…		…
1445	{	1349	{
1446	if (spell_ob->subtype == SP_DESTRUCTION)	1350	if (spell_ob->subtype == SP_DESTRUCTION)
1447	{	1351	{
1448	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1352	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1449	if (spell_ob->other_arch)	1353	if (spell_ob->other_arch)
1450	{
1451	tmp = arch_to_object (spell_ob->other_arch);	1354	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	}	1355	}
1457	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)	1356	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1458	{	1357	{
1459	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1358	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1460	{
1461	object *effect = arch_to_object (spell_ob->other_arch);	1359	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	}	1360	}
1468	}	1361	}
1469	}	1362	}
1470	}	1363	}
1471	}	1364	}
1472	}	1365	}
		1366
1473	op->skill = skill;	1367	op->skill = skill;
1474	return 1;	1368	return 1;
1475	}	1369	}
1476		1370
1477	/***************************************************************************	1371	/***************************************************************************
…		…
1537	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1431	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1538	}	1432	}
1539	return 1;	1433	return 1;
1540	}	1434	}
1541	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1435	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1542	force->speed = 1.0;	1436	force->speed = 1.f;
1543	force->speed_left = -1.0;	1437	force->speed_left = -1.f;
1544	SET_FLAG (force, FLAG_APPLIED);	1438	SET_FLAG (force, FLAG_APPLIED);
1545		1439
1546	if (god)	1440	if (god)
1547	{	1441	{
1548	if (spell_ob->last_grace)	1442	if (spell_ob->last_grace)
…		…
1561	force->stats.ac = spell_ob->stats.ac;	1455	force->stats.ac = spell_ob->stats.ac;
1562	force->stats.wc = spell_ob->stats.wc;	1456	force->stats.wc = spell_ob->stats.wc;
1563		1457
1564	change_abil (tmp, force); /* Mostly to display any messages */	1458	change_abil (tmp, force); /* Mostly to display any messages */
1565	insert_ob_in_ob (force, tmp);	1459	insert_ob_in_ob (force, tmp);
1566	fix_player (tmp);	1460	tmp->update_stats ();
1567	return 1;	1461	return 1;
1568		1462
1569	}	1463	}
1570
1571		1464
1572	/**********************************************************************	1465	/**********************************************************************
1573	* mood change	1466	* mood change
1574	* Arguably, this may or may not be an attack spell. But since it	1467	* 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	1468	* effects monsters, it seems best to put it into this file
…		…
1582	mood_change (object *op, object *caster, object *spell)	1475	mood_change (object *op, object *caster, object *spell)
1583	{	1476	{
1584	object *tmp, *god, *head;	1477	object *tmp, *god, *head;
1585	int done_one, range, mflags, level, at, best_at;	1478	int done_one, range, mflags, level, at, best_at;
1586	sint16 x, y, nx, ny;	1479	sint16 x, y, nx, ny;
1587	mapstruct *m;	1480	maptile *m;
1588	const char *race;	1481	const char *race;
1589		1482
1590	/* We precompute some values here so that we don't have to keep	1483	/* We precompute some values here so that we don't have to keep
1591	* doing it over and over again.	1484	* doing it over and over again.
1592	*/	1485	*/
…		…
1605	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1498	else if (god && !strcmp (spell->race, "GOD_FRIEND"))
1606	race = god->race;	1499	race = god->race;
1607	else	1500	else
1608	race = spell->race;	1501	race = spell->race;
1609		1502
1610
1611	for (x = op->x - range; x <= op->x + range; x++)	1503	for (x = op->x - range; x <= op->x + range; x++)
1612	for (y = op->y - range; y <= op->y + range; y++)	1504	for (y = op->y - range; y <= op->y + range; y++)
1613	{	1505	{
1614
1615	done_one = 0;	1506	done_one = 0;
1616	m = op->map;	1507	m = op->map;
1617	nx = x;	1508	nx = x;
1618	ny = y;	1509	ny = y;
1619	mflags = get_map_flags (m, &m, x, y, &nx, &ny);	1510	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
…		…
1622		1513
1623	/* If there is nothing living on this space, no need to go further */	1514	/* If there is nothing living on this space, no need to go further */
1624	if (!(mflags & P_IS_ALIVE))	1515	if (!(mflags & P_IS_ALIVE))
1625	continue;	1516	continue;
1626		1517
		1518	// players can only affect spaces that they can actually see
		1519	if (caster && caster->contr
		1520	&& caster->contr->visibility_at (m, nx, ny) < 70)
		1521	continue;
		1522
1627	for (tmp = get_map_ob (m, nx, ny); tmp; tmp = tmp->above)	1523	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)
1628	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1524	if (QUERY_FLAG (tmp, FLAG_MONSTER))
1629	break;	1525	break;
1630		1526
1631	/* There can be living objects that are not monsters */	1527	/* There can be living objects that are not monsters */
1632	if (!tmp || tmp->type == PLAYER)	1528	if (!tmp || tmp->type == PLAYER)
…		…
1639	head = tmp;	1535	head = tmp;
1640		1536
1641	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */	1537	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */
1642	if (race && head->race && !strstr (race, head->race))	1538	if (race && head->race && !strstr (race, head->race))
1643	continue;	1539	continue;
		1540
1644	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1541	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))
1645	continue;	1542	continue;
1646		1543
1647	/* Now do a bunch of stuff related to saving throws */	1544	/* Now do a bunch of stuff related to saving throws */
1648	best_at = -1;	1545	best_at = -1;
…		…
1665	at -= level / 5;	1562	at -= level / 5;
1666	if (did_make_save (head, head->level, at))	1563	if (did_make_save (head, head->level, at))
1667	continue;	1564	continue;
1668	}	1565	}
1669	else /* spell->attacktype */	1566	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	{	1567	{
		1568	/*
		1569	Spell has no attacktype (charm & such), so we'll have a specific saving:
		1570	* if spell level < monster level, no go
		1571	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
		1572
		1573	The chance will then be in the range [20-70] percent, not too bad.
		1574
		1575	This is required to fix the 'charm monster' abuse, where a player level 1 can
		1576	charm a level 125 monster...
		1577
		1578	Ryo, august 14th
		1579	*/
1683	if (head->level > level)	1580	if (head->level > level)
1684	continue;	1581	continue;
		1582
1685	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))	1583	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))
1686	/* Failed, no effect */	1584	/* Failed, no effect */
1687	continue;	1585	continue;
1688	}	1586	}
1689		1587
1690	/* Done with saving throw. Now start effecting the monster */	1588	/* Done with saving throw. Now start affecting the monster */
1691		1589
1692	/* aggravation */	1590	/* aggravation */
1693	if (QUERY_FLAG (spell, FLAG_MONSTER))	1591	if (QUERY_FLAG (spell, FLAG_MONSTER))
1694	{	1592	{
1695	CLEAR_FLAG (head, FLAG_SLEEP);	1593	CLEAR_FLAG (head, FLAG_SLEEP);
1696	if (QUERY_FLAG (head, FLAG_FRIENDLY))
1697	remove_friendly_object (head);	1594	remove_friendly_object (head);
1698
1699	done_one = 1;	1595	done_one = 1;
1700	head->enemy = op;	1596	head->enemy = op;
1701	}	1597	}
1702		1598
1703	/* calm monsters */	1599	/* calm monsters */
…		…
1712	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1608	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))
1713	{	1609	{
1714	SET_FLAG (head, FLAG_BERSERK);	1610	SET_FLAG (head, FLAG_BERSERK);
1715	done_one = 1;	1611	done_one = 1;
1716	}	1612	}
		1613
1717	/* charm */	1614	/* charm */
1718	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1615	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
1719	{	1616	{
1720	SET_FLAG (head, FLAG_FRIENDLY);
1721	/* Prevent uncontolled outbreaks of self replicating monsters.	1617	/* Prevent uncontolled outbreaks of self replicating monsters.
1722	Typical use case is charm, go somwhere, use aggravation to make hostile.	1618	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. */	1619	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1724	CLEAR_FLAG (head, FLAG_GENERATOR);	1620	CLEAR_FLAG (head, FLAG_GENERATOR);
1725	set_owner (head, op);	1621	head->set_owner (op);
1726	set_spell_skill (op, caster, spell, head);	1622	set_spell_skill (op, caster, spell, head);
1727	add_friendly_object (head);	1623	add_friendly_object (head);
1728	head->attack_movement = PETMOVE;	1624	head->attack_movement = PETMOVE;
1729	done_one = 1;	1625	done_one = 1;
1730	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1626	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1731	head->stats.exp = 0;	1627	head->stats.exp = 0;
1732	}	1628	}
1733		1629
1734	/* If a monster was effected, put an effect in */	1630	/* If a monster was effected, put an effect in */
1735	if (done_one && spell->other_arch)	1631	if (done_one && spell->other_arch)
1736	{
1737	tmp = arch_to_object (spell->other_arch);	1632	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 */	1633	} /* for y */
1743		1634
1744	return 1;	1635	return 1;
1745	}	1636	}
1746		1637
…		…
1756	move_ball_spell (object *op)	1647	move_ball_spell (object *op)
1757	{	1648	{
1758	int i, j, dam_save, dir, mflags;	1649	int i, j, dam_save, dir, mflags;
1759	sint16 nx, ny, hx, hy;	1650	sint16 nx, ny, hx, hy;
1760	object *owner;	1651	object *owner;
1761	mapstruct *m;	1652	maptile *m;
1762		1653
1763	owner = get_owner (op);	1654	owner = op->owner;
1764		1655
1765	/* the following logic makes sure that the ball doesn't move into a wall,	1656	/* 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	1657	* 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	1658	* 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	1659	* offset to move the ball, eg, keep it mostly on course, with some
…		…
1797	nx = op->x;	1688	nx = op->x;
1798	ny = op->y;	1689	ny = op->y;
1799	m = op->map;	1690	m = op->map;
1800	}	1691	}
1801		1692
1802	remove_ob (op);	1693	m->insert (op, nx, ny, op);
1803	op->y = ny;
1804	op->x = nx;
1805	insert_ob_in_map (op, m, op, 0);
1806		1694
1807	dam_save = op->stats.dam; /* save the original dam: we do halfdam on	1695	dam_save = op->stats.dam; /* save the original dam: we do halfdam on
1808	surrounding squares */	1696	surrounding squares */
1809		1697
1810	/* loop over current square and neighbors to hit.	1698	/* loop over current square and neighbors to hit.
1811	* if this has an other_arch field, we insert that in	1699	* if this has an other_arch field, we insert that in
1812	* the surround spaces.	1700	* the surround spaces.
1813	*/	1701	*/
1814	for (j = 0; j < 9; j++)	1702	for (j = 0; j < 9; j++)
1815	{	1703	{
1816	object *new_ob;
1817
1818	hx = nx + freearr_x[j];	1704	hx = nx + freearr_x[j];
1819	hy = ny + freearr_y[j];	1705	hy = ny + freearr_y[j];
1820		1706
1821	m = op->map;	1707	m = op->map;
1822	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);	1708	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
…		…
1836		1722
1837	}	1723	}
1838		1724
1839	/* insert the other arch */	1725	/* insert the other arch */
1840	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))	1726	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1841	{	1727	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	}	1728	}
1848		1729
1849	/* restore to the center location and damage */	1730	/* restore to the center location and damage */
1850	op->stats.dam = dam_save;	1731	op->stats.dam = dam_save;
1851		1732
1852	i = spell_find_dir (op->map, op->x, op->y, get_owner (op));	1733	i = spell_find_dir (op->map, op->x, op->y, op->owner);
1853		1734
1854	if (i >= 0)	1735	if (i >= 0)
1855	{ /* we have a preferred direction! */	1736	{ /* we have a preferred direction! */
1856	/* pick another direction if the preferred dir is blocked. */	1737	/* 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 ||	1738	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)))	1739	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))
1859	{
1860	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */	1740	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1861	}	1741
1862	op->direction = i;	1742	op->direction = i;
1863	}	1743	}
1864	}	1744	}
1865		1745
1866		1746
…		…
1878	#if 0	1758	#if 0
1879	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };	1759	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 };	1760	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;	1761	sint16 target_x, target_y, origin_x, origin_y;
1882	int adjustdir;	1762	int adjustdir;
1883	mapstruct *m;	1763	maptile *m;
1884	#endif	1764	#endif
1885	int basedir;	1765	int basedir;
1886	object *owner;	1766	object *owner;
1887		1767
1888	owner = get_owner (op);	1768	owner = op->owner;
1889	if (op->duration == 0 || owner == NULL)	1769	if (op->duration == 0 || owner == NULL)
1890	{	1770	{
1891	remove_ob (op);	1771	op->destroy ();
1892	free_object (op);
1893	return;	1772	return;
1894	}	1773	}
		1774
1895	op->duration--;	1775	op->duration--;
1896		1776
1897	basedir = op->direction;	1777	basedir = op->direction;
1898	if (basedir == 0)	1778	if (basedir == 0)
1899	{	1779	{
…		…
1904	#if 0	1784	#if 0
1905	// this is bogus: it causes wrong places to be checked below	1785	// this is bogus: it causes wrong places to be checked below
1906	// (a wall 2 cells away will block the effect...) and	1786	// (a wall 2 cells away will block the effect...) and
1907	// doesn't work for SP_BULLET anyhow, so again tests the wrong	1787	// doesn't work for SP_BULLET anyhow, so again tests the wrong
1908	// space.	1788	// space.
1909	// should be fixed later, but correctness before featurs...	1789	// should be fixed later, but correctness before features...
1910	// (schmorp)	1790	// (schmorp)
1911		1791
1912	/* new offset calculation to make swarm element distribution	1792	/* new offset calculation to make swarm element distribution
1913	* more uniform	1793	* more uniform
1914	*/	1794	*/
…		…
1996		1876
1997	if (!spell->other_arch)	1877	if (!spell->other_arch)
1998	return 0;	1878	return 0;
1999		1879
2000	tmp = get_archetype (SWARM_SPELL);	1880	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. */	1881	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
2004	set_spell_skill (op, caster, spell, tmp);	1882	set_spell_skill (op, caster, spell, tmp);
2005		1883
2006	tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */	1884	tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */
2007	tmp->spell = arch_to_object (spell->other_arch);	1885	tmp->spell = arch_to_object (spell->other_arch);
2008		1886
2009	tmp->attacktype = tmp->spell->attacktype;	1887	tmp->attacktype = tmp->spell->attacktype;
2010		1888
2011	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)	1889	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
2012	{
2013	if (!tailor_god_spell (tmp, op))	1890	if (!tailor_god_spell (tmp, op))
2014	return 1;	1891	return 1;
2015	}	1892
2016	tmp->duration = SP_level_duration_adjust (caster, spell);	1893	tmp->duration = SP_level_duration_adjust (caster, spell);
2017	for (i = 0; i < spell->duration; i++)	1894	for (i = 0; i < spell->duration; i++)
2018	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1895	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
2019		1896
2020	tmp->direction = dir;	1897	tmp->direction = dir;
2021	tmp->invisible = 1;	1898	tmp->invisible = 1;
2022	insert_ob_in_map (tmp, op->map, op, 0);	1899
		1900	tmp->insert_at (op, op);
2023	return 1;	1901	return 1;
2024	}	1902	}
2025		1903
2026		1904
2027	/* See the spells documentation file for why this is its own	1905	/* See the spells documentation file for why this is its own
…		…
2031	cast_light (object *op, object *caster, object *spell, int dir)	1909	cast_light (object *op, object *caster, object *spell, int dir)
2032	{	1910	{
2033	object *target = NULL, *tmp = NULL;	1911	object *target = NULL, *tmp = NULL;
2034	sint16 x, y;	1912	sint16 x, y;
2035	int dam, mflags;	1913	int dam, mflags;
2036	mapstruct *m;	1914	maptile *m;
2037		1915
2038	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1916	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2039		1917
2040	if (!dir)	1918	if (!dir)
2041	{	1919	{
…		…
2055	return 0;	1933	return 0;
2056	}	1934	}
2057		1935
2058	if (mflags & P_IS_ALIVE && spell->attacktype)	1936	if (mflags & P_IS_ALIVE && spell->attacktype)
2059	{	1937	{
2060	for (target = get_map_ob (m, x, y); target; target = target->above)	1938	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
2061	if (QUERY_FLAG (target, FLAG_MONSTER))	1939	if (QUERY_FLAG (target, FLAG_MONSTER))
2062	{	1940	{
2063	/* oky doky. got a target monster. Lets make a blinding attack */	1941	/* oky doky. got a target monster. Lets make a blinding attack */
2064	if (target->head)	1942	if (target->head)
2065	target = target->head;	1943	target = target->head;
…		…
2087	{	1965	{
2088	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);	1966	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);
2089	if (tmp->glow_radius > MAX_LIGHT_RADII)	1967	if (tmp->glow_radius > MAX_LIGHT_RADII)
2090	tmp->glow_radius = MAX_LIGHT_RADII;	1968	tmp->glow_radius = MAX_LIGHT_RADII;
2091	}	1969	}
2092	tmp->x = x;	1970
2093	tmp->y = y;	1971	m->insert (tmp, x, y, op);
2094	insert_ob_in_map (tmp, m, op, 0);
2095	return 1;	1972	return 1;
2096	}	1973	}
2097		1974
2098		1975
2099		1976
…		…
2109	cast_cause_disease (object *op, object *caster, object *spell, int dir)	1986	cast_cause_disease (object *op, object *caster, object *spell, int dir)
2110	{	1987	{
2111	sint16 x, y;	1988	sint16 x, y;
2112	int i, mflags, range, dam_mod, dur_mod;	1989	int i, mflags, range, dam_mod, dur_mod;
2113	object *walk;	1990	object *walk;
2114	mapstruct *m;	1991	maptile *m;
2115		1992
2116	x = op->x;	1993	x = op->x;
2117	y = op->y;	1994	y = op->y;
2118		1995
2119	/* If casting from a scroll, no direction will be available, so refer to the	1996	/* If casting from a scroll, no direction will be available, so refer to the
…		…
2147		2024
2148	/* Only bother looking on this space if there is something living here */	2025	/* Only bother looking on this space if there is something living here */
2149	if (mflags & P_IS_ALIVE)	2026	if (mflags & P_IS_ALIVE)
2150	{	2027	{
2151	/* search this square for a victim */	2028	/* search this square for a victim */
2152	for (walk = get_map_ob (m, x, y); walk; walk = walk->above)	2029	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
2153	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))	2030	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
2154	{ /* found a victim */	2031	{ /* found a victim */
2155	object *disease = arch_to_object (spell->other_arch);	2032	object *disease = arch_to_object (spell->other_arch);
2156		2033
2157	set_owner (disease, op);	2034	disease->set_owner (op);
2158	set_spell_skill (op, caster, spell, disease);	2035	set_spell_skill (op, caster, spell, disease);
2159	disease->stats.exp = 0;	2036	disease->stats.exp = 0;
2160	disease->level = caster_level (caster, spell);	2037	disease->level = caster_level (caster, spell);
2161		2038
2162	/* do level adjustments */	2039	/* do level adjustments */
…		…
2207	if (disease->stats.sp)	2084	if (disease->stats.sp)
2208	disease->stats.sp -= dam_mod;	2085	disease->stats.sp -= dam_mod;
2209		2086
2210	if (infect_object (walk, disease, 1))	2087	if (infect_object (walk, disease, 1))
2211	{	2088	{
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);	2089	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2215		2090
2216	free_object (disease); /* don't need this one anymore */	2091	disease->destroy (); /* don't need this one anymore */
2217	flash = get_archetype (ARCH_DETECT_MAGIC);	2092	walk->map->insert (get_archetype ("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;	2093	return 1;
2223	}	2094	}
2224	free_object (disease);	2095
		2096	disease->destroy ();
2225	}	2097	}
2226	} /* if living creature */	2098	} /* if living creature */
2227	} /* for range of spaces */	2099	} /* for range of spaces */
		2100
2228	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");	2101	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
2229	return 1;	2102	return 1;
2230	}	2103	}

Diff Legend

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