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

Diff Legend

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