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

Diff Legend

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