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.8 by pippijn, Thu Sep 7 10:01:58 2006 UTC vs.
Revision 1.33 by root, Sat May 12 22:04:20 2007 UTC

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

Diff Legend

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