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.7 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.31 by root, Fri Mar 30 21:53:09 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.7 2006/09/03 00:18:42 root 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.1;
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.1;
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.21;
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.0;
1377	force->speed_left = -1.0;	1452	force->speed_left = -1.0;
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))	1608	if (QUERY_FLAG (head, FLAG_FRIENDLY))
1506	remove_friendly_object(head);	1609	remove_friendly_object (head);
1507		1610
1508	done_one = 1;	1611	done_one = 1;
1509	head->enemy = op;	1612	head->enemy = op;
1510	}	1613	}
1511		1614
1512	/* calm monsters */	1615	/* calm monsters */
1513	if (QUERY_FLAG(spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG(head, FLAG_UNAGGRESSIVE)) {	1616	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))
		1617	{
1514	SET_FLAG(head, FLAG_UNAGGRESSIVE);	1618	SET_FLAG (head, FLAG_UNAGGRESSIVE);
1515	head->enemy = NULL;	1619	head->enemy = NULL;
1516	done_one = 1;	1620	done_one = 1;
1517	}	1621	}
1518		1622
1519	/* berserk monsters */	1623	/* berserk monsters */
1520	if (QUERY_FLAG(spell, FLAG_BERSERK) && !QUERY_FLAG(head, FLAG_BERSERK)) {	1624	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))
		1625	{
1521	SET_FLAG(head, FLAG_BERSERK);	1626	SET_FLAG (head, FLAG_BERSERK);
1522	done_one = 1;	1627	done_one = 1;
1523	}	1628	}
		1629
1524	/* charm */	1630	/* charm */
1525	if (QUERY_FLAG(spell, FLAG_NO_ATTACK) && !QUERY_FLAG(head, FLAG_FRIENDLY)) {	1631	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
1526	SET_FLAG(head, FLAG_FRIENDLY);	1632	{
1527	/* Prevent uncontolled outbreaks of self replicating monsters.	1633	/* Prevent uncontolled outbreaks of self replicating monsters.
1528	Typical use case is charm, go somwhere, use aggravation to make hostile.	1634	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. */	1635	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1530	CLEAR_FLAG(head, FLAG_GENERATOR);	1636	CLEAR_FLAG (head, FLAG_GENERATOR);
1531	set_owner(head, op);	1637	head->set_owner (op);
1532	set_spell_skill(op, caster, spell, head);	1638	set_spell_skill (op, caster, spell, head);
1533	add_friendly_object(head);	1639	add_friendly_object (head);
1534	head->attack_movement = PETMOVE;	1640	head->attack_movement = PETMOVE;
1535	done_one = 1;	1641	done_one = 1;
1536	change_exp(op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1642	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1537	head->stats.exp = 0;	1643	head->stats.exp = 0;
1538	}	1644	}
1539		1645
1540	/* If a monster was effected, put an effect in */	1646	/* If a monster was effected, put an effect in */
1541	if (done_one && spell->other_arch) {	1647	if (done_one && spell->other_arch)
1542	tmp = arch_to_object(spell->other_arch);	1648	m->insert (arch_to_object (spell->other_arch), nx, ny, op);
1543	tmp->x = nx;	1649	} /* for y */
1544	tmp->y = ny;
1545	insert_ob_in_map(tmp, m, op, 0);
1546	}
1547	} /* for y */
1548		1650
1549	return 1;	1651	return 1;
1550	}	1652	}
1551		1653
1552		1654
1553	/* Move_ball_spell: This handles ball type spells that just sort of wander	1655	/* 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	1656	* about. was called move_ball_lightning, but since more than the ball
1555	* lightning spell used it, that seemed misnamed.	1657	* lightning spell used it, that seemed misnamed.
1556	* op is the spell effect.	1658	* op is the spell effect.
1557	* note that duration is handled by process_object() in time.c	1659	* note that duration is handled by process_object() in time.c
1558	*/	1660	*/
1559		1661
		1662	void
1560	void move_ball_spell(object *op) {	1663	move_ball_spell (object *op)
		1664	{
1561	int i,j,dam_save,dir, mflags;	1665	int i, j, dam_save, dir, mflags;
1562	sint16 nx,ny, hx, hy;	1666	sint16 nx, ny, hx, hy;
1563	object *owner;	1667	object *owner;
1564	mapstruct *m;	1668	maptile *m;
1565		1669
1566	owner = get_owner(op);	1670	owner = op->owner;
1567		1671
1568	/* the following logic makes sure that the ball doesn't move into a wall,	1672	/* 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	1673	* 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	1674	* 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	1675	* offset to move the ball, eg, keep it mostly on course, with some
1572	* deviations.	1676	* deviations.
1573	*/	1677	*/
1574		1678
1575	dir = 0;	1679	dir = 0;
1576	if(!(rndm(0, 3)))	1680	if (!(rndm (0, 3)))
1577	j = rndm(0, 1);	1681	j = rndm (0, 1);
1578	else j=0;	1682	else
		1683	j = 0;
1579		1684
1580	for(i = 1; i < 9; i++) {	1685	for (i = 1; i < 9; i++)
		1686	{
1581	/* i bit 0: alters sign of offset	1687	/* i bit 0: alters sign of offset
1582	* other bits (i / 2): absolute value of offset	1688	* other bits (i / 2): absolute value of offset
1583	*/	1689	*/
1584		1690
1585	int offset = ((i ^ j) & 1) ? (i / 2) : - (i / 2);	1691	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1586	int tmpdir = absdir (op->direction + offset);	1692	int tmpdir = absdir (op->direction + offset);
1587		1693
1588	nx = op->x + freearr_x[tmpdir];	1694	nx = op->x + freearr_x[tmpdir];
1589	ny = op->y + freearr_y[tmpdir];	1695	ny = op->y + freearr_y[tmpdir];
1590	if ( ! (get_map_flags(op->map, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) &&	1696	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)))) {	1697	{
1592	dir = tmpdir;	1698	dir = tmpdir;
1593	break;	1699	break;
1594	}	1700	}
1595	}	1701	}
1596	if (dir == 0) {	1702	if (dir == 0)
		1703	{
1597	nx = op->x;	1704	nx = op->x;
1598	ny = op->y;	1705	ny = op->y;
1599	m = op->map;	1706	m = op->map;
1600	}	1707	}
1601		1708
1602	remove_ob(op);	1709	m->insert (op, nx, ny, op);
1603	op->y=ny;	1710
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	1711	dam_save = op->stats.dam; /* save the original dam: we do halfdam on
1608	surrounding squares */	1712	surrounding squares */
1609		1713
1610	/* loop over current square and neighbors to hit.	1714	/* loop over current square and neighbors to hit.
1611	* if this has an other_arch field, we insert that in	1715	* if this has an other_arch field, we insert that in
1612	* the surround spaces.	1716	* the surround spaces.
1613	*/	1717	*/
1614	for(j=0;j<9;j++) {	1718	for (j = 0; j < 9; j++)
1615	object *new_ob;	1719	{
1616
1617	hx = nx+freearr_x[j];	1720	hx = nx + freearr_x[j];
1618	hy = ny+freearr_y[j];	1721	hy = ny + freearr_y[j];
1619		1722
1620	m = op->map;	1723	m = op->map;
1621	mflags = get_map_flags(m, &m, hx, hy, &hx, &hy);	1724	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
1622		1725
1623	if (mflags & P_OUT_OF_MAP) continue;	1726	if (mflags & P_OUT_OF_MAP)
		1727	continue;
1624		1728
1625	/* first, don't ever, ever hit the owner. Don't hit out	1729	/* first, don't ever, ever hit the owner. Don't hit out
1626	* of the map either.	1730	* of the map either.
1627	*/	1731	*/
1628		1732
1629	if((mflags & P_IS_ALIVE) && (!owner || owner->x!=hx || owner->y!=hy || !on_same_map(owner,op))) {	1733	if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
		1734	{
		1735	if (j)
1630	if(j) op->stats.dam = dam_save/2;	1736	op->stats.dam = dam_save / 2;
1631	hit_map(op,j,op->attacktype,1);	1737	hit_map (op, j, op->attacktype, 1);
1632		1738
1633	}	1739	}
1634		1740
1635	/* insert the other arch */	1741	/* insert the other arch */
1636	if(op->other_arch && !(OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(m, hx, hy)))) {	1742	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);	1743	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	}	1744	}
1643		1745
1644	/* restore to the center location and damage*/	1746	/* restore to the center location and damage */
1645	op->stats.dam = dam_save;	1747	op->stats.dam = dam_save;
1646		1748
1647	i=spell_find_dir(op->map,op->x,op->y,get_owner(op));	1749	i = spell_find_dir (op->map, op->x, op->y, op->owner);
1648		1750
1649	if(i>=0) { /* we have a preferred direction! */	1751	if (i >= 0)
		1752	{ /* we have a preferred direction! */
1650	/* pick another direction if the preferred dir is blocked. */	1753	/* 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 ||	1754	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))) {	1755	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))
1653	i= absdir(i + rndm(0, 2) -1); /* -1, 0, +1 */	1756	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1654	}	1757
1655	op->direction=i;	1758	op->direction = i;
1656	}	1759	}
1657	}	1760	}
1658		1761
1659		1762
1660	/* move_swarm_spell: peterm	1763	/* move_swarm_spell: peterm
…		…
1663	* is a special type of object that casts swarms of other types	1766	* 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	1767	* 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.	1768	* from a set of squares surrounding the caster, in a given direction.
1666	*/	1769	*/
1667		1770
		1771	void
1668	void move_swarm_spell(object *op)	1772	move_swarm_spell (object *op)
1669	{	1773	{
1670	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1671	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1672	sint16 target_x, target_y, origin_x, origin_y;
1673	int basedir, adjustdir;
1674	mapstruct *m;
1675	object *owner;
1676
1677	owner = get_owner(op);
1678	if(op->duration == 0 || owner == NULL) {
1679	remove_ob(op);
1680	free_object(op);
1681	return;
1682	}
1683	op->duration--;
1684
1685	basedir = op->direction;
1686	if(basedir == 0) {
1687	/* spray in all directions! 8) */
1688	basedir = rndm(1, 8);
1689	}
1690
1691	#if 0	1774	#if 0
1692	// this is bogus: it causes wrong places to be checked below	1775	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1693	// (a wall 2 cells away will block the effect...) and	1776	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1694	// doesn't work for SP_BULLET anyhow, so again tests the wrong	1777	sint16 target_x, target_y, origin_x, origin_y;
1695	// space.	1778	int adjustdir;
1696	// should be fixed later, but correctness before featurs...	1779	maptile *m;
1697	// (schmorp)
1698
1699	/* new offset calculation to make swarm element distribution
1700	* more uniform
1701	*/
1702	if(op->duration) {
1703	if(basedir & 1) {
1704	adjustdir = cardinal_adjust[rndm(0, 8)];
1705	} else {
1706	adjustdir = diagonal_adjust[rndm(0, 9)];
1707	}
1708	} else {
1709	adjustdir = 0; /* fire the last one from forward. */
1710	}
1711
1712	target_x = op->x + freearr_x[absdir(basedir + adjustdir)];
1713	target_y = op->y + freearr_y[absdir(basedir + adjustdir)];
1714
1715	/* back up one space so we can hit point-blank targets, but this
1716	* necessitates extra out_of_map check below
1717	*/
1718	origin_x = target_x - freearr_x[basedir];
1719	origin_y = target_y - freearr_y[basedir];
1720
1721
1722	/* spell pointer is set up for the spell this casts. Since this
1723	* should just be a pointer to the spell in some inventory,
1724	* it is unlikely to disappear by the time we need it. However,
1725	* do some sanity checking anyways.
1726	*/
1727
1728	if (op->spell && op->spell->type == SPELL &&
1729	!(get_map_flags(op->map, &m, target_x, target_y, &target_x, &target_y) & P_OUT_OF_MAP) &&
1730	!(OB_TYPE_MOVE_BLOCK(op->spell, GET_MAP_MOVE_BLOCK(m, target_x, target_y)))) {
1731
1732	/* Bullet spells have a bunch more customization that needs to be done */
1733	if (op->spell->subtype == SP_BULLET)
1734	fire_bullet(owner, op, basedir, op->spell);
1735	else if (op->spell->subtype == SP_MAGIC_MISSILE)
1736	fire_arch_from_position (owner, op, origin_x, origin_y, basedir, op->spell);
1737	}
1738	#endif	1780	#endif
		1781	int basedir;
		1782	object *owner;
1739		1783
		1784	owner = op->owner;
		1785	if (op->duration == 0 || owner == NULL)
		1786	{
		1787	op->destroy ();
		1788	return;
		1789	}
		1790
		1791	op->duration--;
		1792
		1793	basedir = op->direction;
		1794	if (basedir == 0)
		1795	{
		1796	/* spray in all directions! 8) */
		1797	basedir = rndm (1, 8);
		1798	}
		1799
		1800	#if 0
		1801	// this is bogus: it causes wrong places to be checked below
		1802	// (a wall 2 cells away will block the effect...) and
		1803	// doesn't work for SP_BULLET anyhow, so again tests the wrong
		1804	// space.
		1805	// should be fixed later, but correctness before features...
		1806	// (schmorp)
		1807
		1808	/* new offset calculation to make swarm element distribution
		1809	* more uniform
		1810	*/
		1811	if (op->duration)
		1812	{
		1813	if (basedir & 1)
		1814	{
		1815	adjustdir = cardinal_adjust[rndm (0, 8)];
		1816	}
		1817	else
		1818	{
		1819	adjustdir = diagonal_adjust[rndm (0, 9)];
		1820	}
		1821	}
		1822	else
		1823	{
		1824	adjustdir = 0; /* fire the last one from forward. */
		1825	}
		1826
		1827	target_x = op->x + freearr_x[absdir (basedir + adjustdir)];
		1828	target_y = op->y + freearr_y[absdir (basedir + adjustdir)];
		1829
		1830	/* back up one space so we can hit point-blank targets, but this
		1831	* necessitates extra out_of_map check below
		1832	*/
		1833	origin_x = target_x - freearr_x[basedir];
		1834	origin_y = target_y - freearr_y[basedir];
		1835
		1836
1740	/* spell pointer is set up for the spell this casts. Since this	1837	/* spell pointer is set up for the spell this casts. Since this
1741	* should just be a pointer to the spell in some inventory,	1838	* should just be a pointer to the spell in some inventory,
1742	* it is unlikely to disappear by the time we need it. However,	1839	* it is unlikely to disappear by the time we need it. However,
1743	* do some sanity checking anyways.	1840	* do some sanity checking anyways.
1744	*/	1841	*/
1745		1842
1746	if (op->spell && op->spell->type == SPELL)	1843	if (op->spell && op->spell->type == SPELL &&
		1844	!(get_map_flags (op->map, &m, target_x, target_y, &target_x, &target_y) & P_OUT_OF_MAP) &&
		1845	!(OB_TYPE_MOVE_BLOCK (op->spell, GET_MAP_MOVE_BLOCK (m, target_x, target_y))))
1747	{	1846	{
		1847
1748	/* Bullet spells have a bunch more customization that needs to be done */	1848	/* Bullet spells have a bunch more customization that needs to be done */
1749	if (op->spell->subtype == SP_BULLET)	1849	if (op->spell->subtype == SP_BULLET)
1750	fire_bullet(owner, op, basedir, op->spell);	1850	fire_bullet (owner, op, basedir, op->spell);
1751	else if (op->spell->subtype == SP_MAGIC_MISSILE)	1851	else if (op->spell->subtype == SP_MAGIC_MISSILE)
		1852	fire_arch_from_position (owner, op, origin_x, origin_y, basedir, op->spell);
		1853	}
		1854	#endif
		1855
		1856	/* spell pointer is set up for the spell this casts. Since this
		1857	* should just be a pointer to the spell in some inventory,
		1858	* it is unlikely to disappear by the time we need it. However,
		1859	* do some sanity checking anyways.
		1860	*/
		1861
		1862	if (op->spell && op->spell->type == SPELL)
		1863	{
		1864	/* Bullet spells have a bunch more customization that needs to be done */
		1865	if (op->spell->subtype == SP_BULLET)
		1866	fire_bullet (owner, op, basedir, op->spell);
		1867	else if (op->spell->subtype == SP_MAGIC_MISSILE)
1752	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);	1868	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);
1753	}	1869	}
1754	}	1870	}
1755		1871
1756		1872
1757		1873
1758		1874
…		…
1766	* dir: the direction everything will be fired in	1882	* dir: the direction everything will be fired in
1767	* spell - the spell that is this spell.	1883	* spell - the spell that is this spell.
1768	* n: the number to be fired.	1884	* n: the number to be fired.
1769	*/	1885	*/
1770		1886
		1887	int
1771	int fire_swarm (object *op, object *caster, object *spell, int dir)	1888	fire_swarm (object *op, object *caster, object *spell, int dir)
1772	{	1889	{
1773	object *tmp;	1890	object *tmp;
1774	int i;	1891	int i;
1775		1892
1776	if (!spell->other_arch) return 0;	1893	if (!spell->other_arch)
		1894	return 0;
1777		1895
1778	tmp=get_archetype(SWARM_SPELL);	1896	tmp = get_archetype (SWARM_SPELL);
1779	tmp->x=op->x;
1780	tmp->y=op->y;
1781	set_owner(tmp,op); /* needed so that if swarm elements kill, caster gets xp.*/	1897	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
1782	set_spell_skill(op, caster, spell, tmp);	1898	set_spell_skill (op, caster, spell, tmp);
1783		1899
1784	tmp->level=caster_level(caster, spell); /*needed later, to get level dep. right.*/	1900	tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */
1785	tmp->spell = arch_to_object(spell->other_arch);	1901	tmp->spell = arch_to_object (spell->other_arch);
1786		1902
1787	tmp->attacktype = tmp->spell->attacktype;	1903	tmp->attacktype = tmp->spell->attacktype;
1788		1904
1789	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) {	1905	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1790	if ( ! tailor_god_spell (tmp, op))	1906	if (!tailor_god_spell (tmp, op))
1791	return 1;	1907	return 1;
1792	}	1908
1793	tmp->duration = SP_level_duration_adjust(caster, spell);	1909	tmp->duration = SP_level_duration_adjust (caster, spell);
1794	for (i=0; i< spell->duration; i++)	1910	for (i = 0; i < spell->duration; i++)
1795	tmp->duration += die_roll(1, 3, op, PREFER_HIGH);	1911	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1796		1912
1797	tmp->direction=dir;	1913	tmp->direction = dir;
1798	tmp->invisible=1;	1914	tmp->invisible = 1;
1799	insert_ob_in_map(tmp,op->map,op,0);	1915
		1916	tmp->insert_at (op, op);
1800	return 1;	1917	return 1;
1801	}	1918	}
1802		1919
1803		1920
1804	/* See the spells documentation file for why this is its own	1921	/* See the spells documentation file for why this is its own
1805	* function.	1922	* function.
1806	*/	1923	*/
		1924	int
1807	int cast_light(object *op,object *caster,object *spell, int dir) {	1925	cast_light (object *op, object *caster, object *spell, int dir)
		1926	{
1808	object *target=NULL,*tmp=NULL;	1927	object *target = NULL, *tmp = NULL;
1809	sint16 x,y;	1928	sint16 x, y;
1810	int dam, mflags;	1929	int dam, mflags;
1811	mapstruct *m;	1930	maptile *m;
1812		1931
1813	dam = spell->stats.dam + SP_level_dam_adjust(caster,spell);	1932	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1814		1933
1815	if(!dir) {	1934	if (!dir)
		1935	{
1816	new_draw_info(NDI_UNIQUE, 0,op,"In what direction?");	1936	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1817	return 0;	1937	return 0;
1818	}	1938	}
1819		1939
1820	x=op->x+freearr_x[dir];	1940	x = op->x + freearr_x[dir];
1821	y=op->y+freearr_y[dir];	1941	y = op->y + freearr_y[dir];
1822	m = op->map;	1942	m = op->map;
1823		1943
1824	mflags = get_map_flags(m, &m, x, y, &x, &y);	1944	mflags = get_map_flags (m, &m, x, y, &x, &y);
1825		1945
1826	if (mflags & P_OUT_OF_MAP) {	1946	if (mflags & P_OUT_OF_MAP)
		1947	{
1827	new_draw_info(NDI_UNIQUE, 0,op,"Nothing is there.");	1948	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
1828	return 0;	1949	return 0;
1829	}	1950	}
1830		1951
1831	if (mflags & P_IS_ALIVE && spell->attacktype) {	1952	if (mflags & P_IS_ALIVE && spell->attacktype)
		1953	{
1832	for(target=get_map_ob(m,x,y);target;target=target->above)	1954	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1833	if(QUERY_FLAG(target,FLAG_MONSTER)) {	1955	if (QUERY_FLAG (target, FLAG_MONSTER))
		1956	{
1834	/* oky doky. got a target monster. Lets make a blinding attack */	1957	/* oky doky. got a target monster. Lets make a blinding attack */
		1958	if (target->head)
1835	if(target->head) target = target->head;	1959	target = target->head;
1836	(void) hit_player(target,dam,op,spell->attacktype,1);	1960	(void) hit_player (target, dam, op, spell->attacktype, 1);
1837	return 1; /* one success only! */	1961	return 1; /* one success only! */
1838	}	1962	}
1839	}	1963	}
1840		1964
1841	/* no live target, perhaps a wall is in the way? */	1965	/* no live target, perhaps a wall is in the way? */
1842	if (OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(m, x, y))) {	1966	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
		1967	{
1843	new_draw_info(NDI_UNIQUE, 0,op,"Something is in the way.");	1968	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1844	return 0;	1969	return 0;
1845	}	1970	}
1846		1971
1847	/* ok, looks groovy to just insert a new light on the map */	1972	/* ok, looks groovy to just insert a new light on the map */
1848	tmp=arch_to_object(spell->other_arch);	1973	tmp = arch_to_object (spell->other_arch);
1849	if(!tmp) {	1974	if (!tmp)
		1975	{
1850	LOG(llevError,"Error: spell arch for cast_light() missing.\n");	1976	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1851	return 0;	1977	return 0;
1852	}	1978	}
1853	tmp->stats.food = spell->duration + SP_level_duration_adjust(caster,spell);	1979	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
1854	if (tmp->glow_radius) {	1980	if (tmp->glow_radius)
		1981	{
1855	tmp->glow_radius= spell->range + SP_level_range_adjust(caster,spell);	1982	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);
1856	if (tmp->glow_radius > MAX_LIGHT_RADII) tmp->glow_radius = MAX_LIGHT_RADII;	1983	if (tmp->glow_radius > MAX_LIGHT_RADII)
		1984	tmp->glow_radius = MAX_LIGHT_RADII;
1857	}	1985	}
1858	tmp->x=x;	1986
1859	tmp->y=y;	1987	m->insert (tmp, x, y, op);
1860	insert_ob_in_map(tmp,m,op,0);
1861	return 1;	1988	return 1;
1862	}	1989	}
1863		1990
1864		1991
1865		1992
1866		1993
…		…
1869	* op is the player/monster, caster is the object, dir is the direction	1996	* op is the player/monster, caster is the object, dir is the direction
1870	* to cast, disease_arch is the specific disease, and type is the spell number	1997	* to cast, disease_arch is the specific disease, and type is the spell number
1871	* perhaps this should actually be in disease.c?	1998	* perhaps this should actually be in disease.c?
1872	*/	1999	*/
1873		2000
		2001	int
1874	int cast_cause_disease(object *op, object *caster, object *spell, int dir) {	2002	cast_cause_disease (object *op, object *caster, object *spell, int dir)
		2003	{
1875	sint16 x,y;	2004	sint16 x, y;
1876	int i, mflags, range, dam_mod, dur_mod;	2005	int i, mflags, range, dam_mod, dur_mod;
1877	object *walk;	2006	object *walk;
1878	mapstruct *m;	2007	maptile *m;
1879		2008
1880	x = op->x;	2009	x = op->x;
1881	y = op->y;	2010	y = op->y;
1882		2011
1883	/* If casting from a scroll, no direction will be available, so refer to the	2012	/* If casting from a scroll, no direction will be available, so refer to the
1884	* direction the player is pointing.	2013	* direction the player is pointing.
1885	*/	2014	*/
		2015	if (!dir)
1886	if (!dir) dir=op->facing;	2016	dir = op->facing;
		2017	if (!dir)
1887	if (!dir) return 0; /* won't find anything if casting on ourself, so just return */	2018	return 0; /* won't find anything if casting on ourself, so just return */
1888		2019
1889	/* Calculate these once here */	2020	/* Calculate these once here */
1890	range = spell->range + SP_level_range_adjust(caster, spell);	2021	range = spell->range + SP_level_range_adjust (caster, spell);
1891	dam_mod = SP_level_dam_adjust(caster, spell);	2022	dam_mod = SP_level_dam_adjust (caster, spell);
1892	dur_mod = SP_level_duration_adjust(caster, spell);	2023	dur_mod = SP_level_duration_adjust (caster, spell);
1893		2024
1894	/* search in a line for a victim */	2025	/* search in a line for a victim */
1895	for(i=1; i<range; i++) {	2026	for (i = 1; i < range; i++)
		2027	{
1896	x = op->x + i * freearr_x[dir];	2028	x = op->x + i * freearr_x[dir];
1897	y = op->y + i * freearr_y[dir];	2029	y = op->y + i * freearr_y[dir];
1898	m = op->map;	2030	m = op->map;
1899		2031
1900	mflags = get_map_flags(m, &m, x, y, &x, &y);	2032	mflags = get_map_flags (m, &m, x, y, &x, &y);
1901		2033
1902	if (mflags & P_OUT_OF_MAP) return 0;	2034	if (mflags & P_OUT_OF_MAP)
		2035	return 0;
1903		2036
1904	/* don't go through walls - presume diseases are airborne */	2037	/* don't go through walls - presume diseases are airborne */
1905	if (GET_MAP_MOVE_BLOCK(m, x, y) & MOVE_FLY_LOW) return 0;	2038	if (GET_MAP_MOVE_BLOCK (m, x, y) & MOVE_FLY_LOW)
		2039	return 0;
1906		2040
1907	/* Only bother looking on this space if there is something living here */	2041	/* Only bother looking on this space if there is something living here */
1908	if (mflags & P_IS_ALIVE) {	2042	if (mflags & P_IS_ALIVE)
		2043	{
1909	/* search this square for a victim */	2044	/* search this square for a victim */
1910	for(walk=get_map_ob(m,x,y);walk;walk=walk->above)	2045	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
1911	if (QUERY_FLAG(walk,FLAG_MONSTER) || (walk->type==PLAYER)) { /* found a victim */	2046	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
		2047	{ /* found a victim */
1912	object *disease = arch_to_object(spell->other_arch);	2048	object *disease = arch_to_object (spell->other_arch);
1913		2049
1914	set_owner(disease,op);	2050	disease->set_owner (op);
1915	set_spell_skill(op, caster, spell, disease);	2051	set_spell_skill (op, caster, spell, disease);
1916	disease->stats.exp = 0;	2052	disease->stats.exp = 0;
1917	disease->level = caster_level(caster, spell);	2053	disease->level = caster_level (caster, spell);
1918		2054
1919	/* do level adjustments */	2055	/* do level adjustments */
1920	if(disease->stats.wc)	2056	if (disease->stats.wc)
1921	disease->stats.wc += dur_mod/2;	2057	disease->stats.wc += dur_mod / 2;
1922		2058
1923	if(disease->magic> 0)	2059	if (disease->magic > 0)
1924	disease->magic += dur_mod/4;	2060	disease->magic += dur_mod / 4;
1925		2061
1926	if(disease->stats.maxhp>0)	2062	if (disease->stats.maxhp > 0)
1927	disease->stats.maxhp += dur_mod;	2063	disease->stats.maxhp += dur_mod;
1928		2064
1929	if(disease->stats.maxgrace>0)	2065	if (disease->stats.maxgrace > 0)
1930	disease->stats.maxgrace += dur_mod;	2066	disease->stats.maxgrace += dur_mod;
1931		2067
1932	if(disease->stats.dam) {	2068	if (disease->stats.dam)
1933	if(disease->stats.dam > 0)
1934	disease->stats.dam += dam_mod;
1935	else disease->stats.dam -= dam_mod;
1936	}
1937
1938	if(disease->last_sp) {
1939	disease->last_sp -= 2*dam_mod;
1940	if(disease->last_sp <1) disease->last_sp = 1;
1941	}
1942
1943	if(disease->stats.maxsp) {
1944	if(disease->stats.maxsp > 0)
1945	disease->stats.maxsp += dam_mod;
1946	else disease->stats.maxsp -= dam_mod;
1947	}
1948		2069	{
1949	if(disease->stats.ac)	2070	if (disease->stats.dam > 0)
1950	disease->stats.ac += dam_mod;	2071	disease->stats.dam += dam_mod;
1951		2072	else
1952	if(disease->last_eat)
1953	disease->last_eat -= dam_mod;
1954
1955	if(disease->stats.hp)
1956	disease->stats.hp -= dam_mod;	2073	disease->stats.dam -= dam_mod;
1957
1958	if(disease->stats.sp)
1959	disease->stats.sp -= dam_mod;
1960
1961	if(infect_object(walk,disease,1)) {
1962	object *flash; /* visual effect for inflicting disease */
1963
1964	new_draw_info_format(NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
1965
1966	free_object(disease); /* don't need this one anymore */
1967	flash=get_archetype(ARCH_DETECT_MAGIC);
1968	flash->x = x;
1969	flash->y = y;
1970	flash->map = walk->map;
1971	insert_ob_in_map(flash,walk->map,op,0);
1972	return 1;
1973	}	2074	}
1974	free_object(disease);	2075
		2076	if (disease->last_sp)
		2077	{
		2078	disease->last_sp -= 2 * dam_mod;
		2079	if (disease->last_sp < 1)
		2080	disease->last_sp = 1;
1975	}	2081	}
		2082
		2083	if (disease->stats.maxsp)
		2084	{
		2085	if (disease->stats.maxsp > 0)
		2086	disease->stats.maxsp += dam_mod;
		2087	else
		2088	disease->stats.maxsp -= dam_mod;
		2089	}
		2090
		2091	if (disease->stats.ac)
		2092	disease->stats.ac += dam_mod;
		2093
		2094	if (disease->last_eat)
		2095	disease->last_eat -= dam_mod;
		2096
		2097	if (disease->stats.hp)
		2098	disease->stats.hp -= dam_mod;
		2099
		2100	if (disease->stats.sp)
		2101	disease->stats.sp -= dam_mod;
		2102
		2103	if (infect_object (walk, disease, 1))
		2104	{
		2105	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
		2106
		2107	disease->destroy (); /* don't need this one anymore */
		2108	walk->map->insert (get_archetype (ARCH_DETECT_MAGIC), x, y, op);
		2109	return 1;
		2110	}
		2111
		2112	disease->destroy ();
		2113	}
1976	} /* if living creature */	2114	} /* if living creature */
1977	} /* for range of spaces */	2115	} /* for range of spaces */
		2116
1978	new_draw_info(NDI_UNIQUE,0,op,"No one caught anything!");	2117	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
1979	return 1;	2118	return 1;
1980	}	2119	}

Diff Legend

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