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.30 by pippijn, Thu Mar 1 12:28:16 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 = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; 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		608
592		609
593		610
594		611
…		…
599	* spob->attacktype.	616	* spob->attacktype.
600	* This function sets up the appropriate owner and skill	617	* This function sets up the appropriate owner and skill
601	* pointers.	618	* pointers.
602	*/	619	*/
603		620
		621	int
604	int fire_bullet(object *op,object *caster,int dir,object *spob) {	622	fire_bullet (object *op, object *caster, int dir, object *spob)
		623	{
605	object *tmp=NULL;	624	object *tmp = NULL;
606	int mflags;	625	int mflags;
607		626
608	if (!spob->other_arch)	627	if (!spob->other_arch)
609	return 0;	628	return 0;
610		629
611	tmp=arch_to_object(spob->other_arch);	630	tmp = arch_to_object (spob->other_arch);
612	if(tmp==NULL)	631	if (tmp == NULL)
613	return 0;	632	return 0;
614		633
615	/* peterm: level dependency for bolts */	634	/* peterm: level dependency for bolts */
616	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust(caster,spob);	635	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
617	tmp->attacktype = spob->attacktype;	636	tmp->attacktype = spob->attacktype;
		637	if (spob->slaying)
618	if (spob->slaying) tmp->slaying = spob->slaying;	638	tmp->slaying = spob->slaying;
619		639
620	tmp->range = 50;	640	tmp->range = 50;
621		641
622	/* Need to store duration/range for the ball to use */	642	/* Need to store duration/range for the ball to use */
623	tmp->stats.hp = spob->duration + SP_level_duration_adjust(caster,spob);	643	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
624	tmp->stats.maxhp = spob->range + SP_level_range_adjust(caster,spob);	644	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
625	tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust(caster,spob);	645	tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);
626		646
627	tmp->direction=dir;	647	tmp->direction = dir;
628	if(QUERY_FLAG(tmp, FLAG_IS_TURNABLE))	648	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
629	SET_ANIMATION(tmp, dir);	649	SET_ANIMATION (tmp, dir);
630		650
631	set_owner(tmp,op);	651	tmp->set_owner (op);
632	set_spell_skill(op, caster, spob, tmp);	652	set_spell_skill (op, caster, spob, tmp);
633		653
634	tmp->x=op->x + freearr_x[dir];	654	tmp->x = op->x + freearr_x[dir];
635	tmp->y=op->y + freearr_y[dir];	655	tmp->y = op->y + freearr_y[dir];
636	tmp->map = op->map;	656	tmp->map = op->map;
637		657
		658	maptile *newmap;
638	mflags = get_map_flags(tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y);	659	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
639	if (mflags & P_OUT_OF_MAP) {	660	if (mflags & P_OUT_OF_MAP)
640	free_object(tmp);	661	{
		662	tmp->destroy ();
641	return 0;	663	return 0;
642	}	664	}
		665
		666	tmp->map = newmap;
		667
643	if (OB_TYPE_MOVE_BLOCK(tmp, GET_MAP_MOVE_BLOCK(tmp->map, tmp->x, tmp->y))) {	668	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
		669	{
644	if(!QUERY_FLAG(tmp, FLAG_REFLECTING)) {	670	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
645	free_object(tmp);	671	{
		672	tmp->destroy ();
646	return 0;	673	return 0;
647	}	674	}
		675
648	tmp->x=op->x;	676	tmp->x = op->x;
649	tmp->y=op->y;	677	tmp->y = op->y;
650	tmp->direction=absdir(tmp->direction+4);	678	tmp->direction = absdir (tmp->direction + 4);
651	tmp->map = op->map;	679	tmp->map = op->map;
652	}	680	}
653	if ((tmp = insert_ob_in_map(tmp,tmp->map,op,0)) != NULL) {	681
		682	if ((tmp = tmp->insert_at (tmp, op)))
654	check_bullet (tmp);	683	check_bullet (tmp);
655	}	684
656	return 1;	685	return 1;
657	}	686	}
658		687
659		688
660		689
661		690
…		…
665	*	694	*
666	*****************************************************************************/	695	*****************************************************************************/
667		696
668		697
669	/* drops an object based on what is in the cone's "other_arch" */	698	/* drops an object based on what is in the cone's "other_arch" */
		699	void
670	void cone_drop(object *op) {	700	cone_drop (object *op)
		701	{
671	object *new_ob = arch_to_object(op->other_arch);	702	object *new_ob = arch_to_object (op->other_arch);
672		703
673	new_ob->x = op->x;
674	new_ob->y = op->y;
675	new_ob->level = op->level;	704	new_ob->level = op->level;
676	set_owner(new_ob,op->owner);	705	new_ob->set_owner (op->owner);
677		706
678	/* preserve skill ownership */	707	/* preserve skill ownership */
679	if(op->skill && op->skill != new_ob->skill) {	708	if (op->skill && op->skill != new_ob->skill)
680	new_ob->skill = op->skill;	709	new_ob->skill = op->skill;
681	}	710
682	insert_ob_in_map(new_ob,op->map,op,0);	711	new_ob->insert_at (op, op);
683
684	}	712	}
685		713
686	/* move_cone: causes cone object 'op' to move a space/hit creatures */	714	/* move_cone: causes cone object 'op' to move a space/hit creatures */
687		715
		716	void
688	void move_cone(object *op) {	717	move_cone (object *op)
		718	{
689	int i;	719	int i;
690	tag_t tag;
691		720
692	/* if no map then hit_map will crash so just ignore object */	721	/* if no map then hit_map will crash so just ignore object */
693	if (! op->map) {	722	if (!op->map)
		723	{
694	LOG(llevError,"Tried to move_cone object %s without a map.\n",	724	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;	725	op->set_speed (0);
697	update_ob_speed (op);
698	return;	726	return;
699	}	727	}
700		728
701	/* lava saves it's life, but not yours :) */	729	/* lava saves it's life, but not yours :) */
702	if (QUERY_FLAG(op, FLAG_LIFESAVE)) {	730	if (QUERY_FLAG (op, FLAG_LIFESAVE))
		731	{
703	hit_map(op,0,op->attacktype,0);	732	hit_map (op, 0, op->attacktype, 0);
704	return;	733	return;
705	}	734	}
706		735
707	#if 0	736	#if 0
708	/* Disable this - enabling it makes monsters easier, as	737	/* Disable this - enabling it makes monsters easier, as
709	* when their cone dies when they die.	738	* when their cone dies when they die.
710	*/	739	*/
711	/* If no owner left, the spell dies out. */	740	/* If no owner left, the spell dies out. */
712	if(get_owner(op)==NULL) {	741	if (op->owner == NULL)
713	remove_ob(op);	742	{
714	free_object(op);	743	op->destroy ();
715	return;	744	return;
716	}	745	}
717	#endif	746	#endif
718		747
719	tag = op->count;
720	hit_map(op,0,op->attacktype,0);	748	hit_map (op, 0, op->attacktype, 0);
721		749
722	/* Check to see if we should push anything.	750	/* Check to see if we should push anything.
723	* Spell objects with weight push whatever they encounter to some	751	* Spell objects with weight push whatever they encounter to some
724	* degree.	752	* degree.
725	*/	753	*/
		754	if (op->weight)
726	if(op->weight) check_spell_knockback(op);	755	check_spell_knockback (op);
727		756
728	if (was_destroyed (op, tag))	757	if (op->destroyed ())
		758	return;
		759
		760	if ((op->duration--) < 0)
		761	{
		762	op->destroy ();
729	return;	763	return;
730
731	if((op->duration--)<0) {
732	remove_ob(op);
733	free_object(op);
734	return;
735	}	764	}
736	/* Object has hit maximum range, so don't have it move	765	/* Object has hit maximum range, so don't have it move
737	* any further. When the duration above expires,	766	* any further. When the duration above expires,
738	* then the object will get removed.	767	* then the object will get removed.
739	*/	768	*/
740	if (--op->range < 0) {	769	if (--op->range < 0)
		770	{
741	op->range=0; /* just so it doesn't wrap */	771	op->range = 0; /* just so it doesn't wrap */
742	return;	772	return;
743	}	773	}
744		774
745	for(i= -1;i<2;i++) {	775	for (i = -1; i < 2; i++)
746	sint16 x=op->x+freearr_x[absdir(op->stats.sp+i)],	776	{
747	y=op->y+freearr_y[absdir(op->stats.sp+i)];	777	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
748		778
749	if(ok_to_put_more(op->map,x,y,op,op->attacktype)) {	779	if (ok_to_put_more (op->map, x, y, op, op->attacktype))
750	object *tmp=get_object();	780	{
751	copy_object(op, tmp);	781	object *tmp = op->clone ();
752	tmp->x=x;
753	tmp->y=y;
754		782
755	tmp->duration = op->duration + 1;	783	tmp->duration = op->duration + 1;
756		784
757	/* Use for spell tracking - see ok_to_put_more() */	785	/* Use for spell tracking - see ok_to_put_more() */
758	tmp->stats.maxhp = op->stats.maxhp;	786	tmp->stats.maxhp = op->stats.maxhp;
759	insert_ob_in_map(tmp,op->map,op,0);	787
		788	op->map->insert (tmp, x, y, op);
		789
760	if (tmp->other_arch) cone_drop(tmp);	790	if (tmp->other_arch)
		791	cone_drop (tmp);
761	}	792	}
762	}	793	}
763	}	794	}
764		795
765	/* cast_cone: casts a cone spell.	796	/* cast_cone: casts a cone spell.
…		…
768	* dir: direction to fire in.	799	* dir: direction to fire in.
769	* spell: spell that is being fired. It uses other_arch for the archetype	800	* spell: spell that is being fired. It uses other_arch for the archetype
770	* to fire.	801	* to fire.
771	* returns 0 on failure, 1 on success.	802	* returns 0 on failure, 1 on success.
772	*/	803	*/
		804	int
773	int cast_cone(object *op, object *caster,int dir, object *spell)	805	cast_cone (object *op, object *caster, int dir, object *spell)
774	{	806	{
775	object *tmp;	807	object *tmp;
776	int i,success=0,range_min= -1,range_max=1;	808	int i, success = 0, range_min = -1, range_max = 1;
777	mapstruct *m;	809	maptile *m;
778	sint16 sx, sy;	810	sint16 sx, sy;
779	MoveType movetype;	811	MoveType movetype;
780		812
781	if (!spell->other_arch) return 0;	813	if (!spell->other_arch)
		814	return 0;
782		815
783	if (op->type == PLAYER && QUERY_FLAG(op, FLAG_UNDEAD) &&	816	if (op->type == PLAYER && QUERY_FLAG (op, FLAG_UNDEAD) && op->attacktype & AT_TURN_UNDEAD)
784	op->attacktype & AT_TURN_UNDEAD) {	817	{
785	new_draw_info(NDI_UNIQUE, 0,op,
786	"Your undead nature prevents you from turning undead!");	818	new_draw_info (NDI_UNIQUE, 0, op, "Your undead nature prevents you from turning undead!");
787	return 0;	819	return 0;
788	}	820	}
789		821
790	if(!dir) {	822	if (!dir)
		823	{
791	range_min= 0;	824	range_min = 0;
792	range_max=8;	825	range_max = 8;
793	}	826	}
794		827
795	/* Need to know what the movetype of the object we are about	828	/* 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	829	* to create is, so we can know if the space we are about to
797	* insert it into is blocked.	830	* insert it into is blocked.
798	*/	831	*/
799	movetype = spell->other_arch->clone.move_type;	832	movetype = spell->other_arch->clone.move_type;
800		833
801	for(i=range_min;i<=range_max;i++) {	834	for (i = range_min; i <= range_max; i++)
		835	{
802	sint16 x,y, d;	836	sint16 x, y, d;
803		837
804	/* We can't use absdir here, because it never returns	838	/* 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	839	* 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	840	* of the trap (d==0). If it is not a rune, then we don't want
807	* to hit that person.	841	* to hit that person.
808	*/	842	*/
809	d = dir + i;	843	d = dir + i;
810	while (d < 0) d+=8;	844	while (d < 0)
		845	d += 8;
811	while (d > 8) d-=8;	846	while (d > 8)
		847	d -= 8;
812		848
813	/* If it's not a rune, we don't want to blast the caster.	849	/* 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,	850	* In that case, we have to see - if dir is specified,
815	* turn this into direction 8. If dir is not specified (all	851	* turn this into direction 8. If dir is not specified (all
816	* direction) skip - otherwise, one line would do more damage	852	* direction) skip - otherwise, one line would do more damage
817	* becase 0 direction will go through 9 directions - necessary	853	* becase 0 direction will go through 9 directions - necessary
818	* for the rune code.	854	* for the rune code.
819	*/	855	*/
820	if (caster->type != RUNE && d==0) {	856	if (caster->type != RUNE && d == 0)
821	if (dir!=0) d=8;
822	else continue;
823	}	857	{
824		858	if (dir != 0)
825	x = op->x+freearr_x[d];	859	d = 8;
826	y = op->y+freearr_y[d];	860	else
827
828	if(get_map_flags(op->map, &m, x,y, &sx, &sy) & P_OUT_OF_MAP)
829	continue;	861	continue;
		862	}
830		863
		864	x = op->x + freearr_x[d];
		865	y = op->y + freearr_y[d];
		866
		867	if (get_map_flags (op->map, &m, x, y, &sx, &sy) & P_OUT_OF_MAP)
		868	continue;
		869
831	if ((movetype & GET_MAP_MOVE_BLOCK(m, sx, sy)) == movetype)	870	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
832	continue;	871	continue;
833		872
834	success=1;	873	success = 1;
835	tmp=arch_to_object(spell->other_arch);	874	tmp = arch_to_object (spell->other_arch);
836	set_owner(tmp,op);	875	tmp->set_owner (op);
837	set_spell_skill(op, caster, spell, tmp);	876	set_spell_skill (op, caster, spell, tmp);
838	tmp->level = caster_level (caster, spell);	877	tmp->level = caster_level (caster, spell);
839	tmp->x = sx;
840	tmp->y = sy;
841	tmp->attacktype=spell->attacktype;	878	tmp->attacktype = spell->attacktype;
842		879
843	/* holy word stuff */	880	/* holy word stuff */
844	if((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER)) {	881	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
845	if(!tailor_god_spell(tmp,op)) return 0;	882	if (!tailor_god_spell (tmp, op))
846	}	883	return 0;
847		884
848	if(dir)	885	if (dir)
849	tmp->stats.sp=dir;	886	tmp->stats.sp = dir;
850	else	887	else
851	tmp->stats.sp=i;	888	tmp->stats.sp = i;
852		889
853	tmp->range=spell->range + SP_level_range_adjust(caster,spell);	890	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
854		891
855	/* If casting it in all directions, it doesn't go as far */	892	/* If casting it in all directions, it doesn't go as far */
856	if (dir == 0) {	893	if (dir == 0)
		894	{
857	tmp->range /= 4;	895	tmp->range /= 4;
858	if (tmp->range < 2 && spell->range >=2) tmp->range = 2;	896	if (tmp->range < 2 && spell->range >= 2)
		897	tmp->range = 2;
859	}	898	}
		899
860	tmp->stats.dam=spell->stats.dam + SP_level_dam_adjust(caster,spell);	900	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
861	tmp->duration=spell->duration + SP_level_duration_adjust(caster,spell);	901	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
862		902
863	/* Special bonus for fear attacks */	903	/* Special bonus for fear attacks */
864	if (tmp->attacktype & AT_FEAR) {	904	if (tmp->attacktype & AT_FEAR)
		905	{
		906	if (caster->type == PLAYER)
865	if (caster->type == PLAYER) tmp->duration += fear_bonus[caster->stats.Cha];	907	tmp->duration += fear_bonus[caster->stats.Cha];
866	else	908	else
867	tmp->duration += caster->level/3;	909	tmp->duration += caster->level / 3;
868	}	910	}
		911
869	if (tmp->attacktype & (AT_HOLYWORD | AT_TURN_UNDEAD)) {	912	if (tmp->attacktype & (AT_HOLYWORD | AT_TURN_UNDEAD))
		913	{
		914	if (caster->type == PLAYER)
870	if (caster->type == PLAYER) tmp->duration += turn_bonus[caster->stats.Wis]/5;	915	tmp->duration += turn_bonus[caster->stats.Wis] / 5;
871	else	916	else
872	tmp->duration += caster->level/3;	917	tmp->duration += caster->level / 3;
873	}	918	}
874		919
875
876	if ( !(tmp->move_type & MOVE_FLY_LOW))	920	if (!(tmp->move_type & MOVE_FLY_LOW))
877	LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n",	921	LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n", &spell->other_arch->name);
878	&spell->other_arch->name);
879		922
880	if (!tmp->move_on && tmp->stats.dam) {	923	if (!tmp->move_on && tmp->stats.dam)
881	LOG (llevDebug,	924	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		925
		926	m->insert (tmp, sx, sy, op);
		927
887	/* This is used for tracking spells so that one effect doesn't hit	928	/* This is used for tracking spells so that one effect doesn't hit
888	* a single space too many times.	929	* a single space too many times.
889	*/	930	*/
890	tmp->stats.maxhp = tmp->count;	931	tmp->stats.maxhp = tmp->count;
891		932
892	if(tmp->other_arch) cone_drop(tmp);	933	if (tmp->other_arch)
		934	cone_drop (tmp);
893	}	935	}
		936
894	return success;	937	return success;
895	}	938	}
896		939
897	/****************************************************************************	940	/****************************************************************************
898	*	941	*
899	* BOMB related code	942	* BOMB related code
…		…
902		945
903		946
904	/* This handles an exploding bomb.	947	/* This handles an exploding bomb.
905	* op is the original bomb object.	948	* op is the original bomb object.
906	*/	949	*/
		950	void
907	void animate_bomb(object *op) {	951	animate_bomb (object *op)
		952	{
908	int i;	953	int i;
909	object *env, *tmp;	954	object *env, *tmp;
910	archetype *at;
911		955
912	if(op->state!=NUM_ANIMATIONS(op)-1)	956	if (op->state != NUM_ANIMATIONS (op) - 1)
		957	return;
		958
		959	env = object_get_env_recursive (op);
		960
		961	if (op->env)
		962	{
		963	if (env->map == NULL)
913	return;	964	return;
914		965
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)	966	if (env->type == PLAYER)
923	esrv_del_item(env->contr, op->count);	967	esrv_del_item (env->contr, op->count);
924		968
925	remove_ob(op);	969	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;	970	return;
940	}	971	}
941		972
		973	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
		974	// on a safe map. I don't like this special casing, but it seems to be neccessary
		975	// as bombs can be carried.
		976	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
		977	{
		978	op->destroy ();
		979	return;
		980	}
		981
942	/* This copies a lot of the code from the fire bullet,	982	/* This copies a lot of the code from the fire bullet,
943	* but using the cast_bullet isn't really feasible,	983	* but using the cast_bullet isn't really feasible,
944	* so just set up the appropriate values.	984	* so just set up the appropriate values.
945	*/	985	*/
946	at = find_archetype(SPLINT);	986	if (archetype *at = archetype::find (SPLINT))
947	if (at) {	987	{
948	for(i=1;i<9;i++) {	988	for (i = 1; i < 9; i++)
		989	{
949	if (out_of_map(op->map, op->x + freearr_x[i], op->y + freearr_x[i]))	990	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
950	continue;	991	continue;
		992
951	tmp = arch_to_object(at);	993	tmp = arch_to_object (at);
952	tmp->direction = i;	994	tmp->direction = i;
953	tmp->range = op->range;	995	tmp->range = op->range;
954	tmp->stats.dam = op->stats.dam;	996	tmp->stats.dam = op->stats.dam;
955	tmp->duration = op->duration;	997	tmp->duration = op->duration;
956	tmp->attacktype = op->attacktype;	998	tmp->attacktype = op->attacktype;
957	copy_owner (tmp, op);	999	tmp->set_owner (op);
958	if(op->skill && op->skill != tmp->skill) {	1000	if (op->skill && op->skill != tmp->skill)
959	tmp->skill = op->skill;	1001	tmp->skill = op->skill;
960	}	1002
961	if(QUERY_FLAG(tmp, FLAG_IS_TURNABLE))	1003	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
962	SET_ANIMATION(tmp, i);	1004	SET_ANIMATION (tmp, i);
963	tmp->x = op->x + freearr_x[i];	1005
964	tmp->y = op->y + freearr_x[i];	1006	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);	1007	move_bullet (tmp);
967	}	1008	}
968	}	1009	}
969		1010
970	explode_bullet(op);	1011	explode_bullet (op);
971	}	1012	}
972		1013
		1014	int
973	int create_bomb(object *op,object *caster,int dir, object *spell) {	1015	create_bomb (object *op, object *caster, int dir, object *spell)
		1016	{
974		1017
975	object *tmp;	1018	object *tmp;
976	int mflags;	1019	int mflags;
977	sint16 dx=op->x+freearr_x[dir], dy=op->y+freearr_y[dir];	1020	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
978	mapstruct *m;	1021	maptile *m;
979		1022
980	mflags = get_map_flags(op->map, &m, dx,dy, &dx,&dy);	1023	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)) {	1024	if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
		1025	{
982	new_draw_info(NDI_UNIQUE, 0,op,"There is something in the way.");	1026	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
983	return 0;	1027	return 0;
984	}	1028	}
985	tmp=arch_to_object(spell->other_arch);	1029	tmp = arch_to_object (spell->other_arch);
986		1030
987	/* level dependencies for bomb */	1031	/* level dependencies for bomb */
988	tmp->range=spell->range + SP_level_range_adjust(caster,spell);	1032	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
989	tmp->stats.dam=spell->stats.dam + SP_level_dam_adjust(caster,spell);	1033	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
990	tmp->duration = spell->duration + SP_level_duration_adjust(caster,spell);	1034	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
991	tmp->attacktype = spell->attacktype;	1035	tmp->attacktype = spell->attacktype;
992		1036
993	set_owner(tmp,op);	1037	tmp->set_owner (op);
994	set_spell_skill(op, caster, spell, tmp);	1038	set_spell_skill (op, caster, spell, tmp);
995	tmp->x=dx;	1039
996	tmp->y=dy;	1040	m->insert (tmp, dx, dy, op);
997	insert_ob_in_map(tmp,m,op,0);
998	return 1;	1041	return 1;
999	}	1042	}
1000		1043
1001	/****************************************************************************	1044	/****************************************************************************
1002	*	1045	*
1003	* smite related spell code.	1046	* smite related spell code.
…		…
1011	* dir is the direction to look in.	1054	* dir is the direction to look in.
1012	* range is how far out to look.	1055	* range is how far out to look.
1013	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.	1056	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.
1014	* this info is used for blocked magic/unholy spaces.	1057	* this info is used for blocked magic/unholy spaces.
1015	*/	1058	*/
1016		1059
		1060	object *
1017	object *get_pointed_target(object *op, int dir, int range, int type) {	1061	get_pointed_target (object *op, int dir, int range, int type)
		1062	{
1018	object *target;	1063	object *target;
1019	sint16 x,y;	1064	sint16 x, y;
1020	int dist, mflags;	1065	int dist, mflags;
1021	mapstruct *mp;	1066	maptile *mp;
1022		1067
1023	if (dir==0) return NULL;	1068	if (dir == 0)
		1069	return NULL;
1024		1070
1025	for (dist=1; dist<range; dist++) {	1071	for (dist = 1; dist < range; dist++)
		1072	{
1026	x = op->x + freearr_x[dir] * dist;	1073	x = op->x + freearr_x[dir] * dist;
1027	y = op->y + freearr_y[dir] * dist;	1074	y = op->y + freearr_y[dir] * dist;
1028	mp = op->map;	1075	mp = op->map;
1029	mflags = get_map_flags(op->map, &mp, x, y, &x, &y);	1076	mflags = get_map_flags (op->map, &mp, x, y, &x, &y);
1030		1077
1031	if (mflags & P_OUT_OF_MAP) return NULL;	1078	if (mflags & P_OUT_OF_MAP)
		1079	return NULL;
1032	if ((type & SPELL_MANA) && (mflags & P_NO_MAGIC)) return NULL;	1080	if ((type & SPELL_MANA) && (mflags & P_NO_MAGIC))
		1081	return NULL;
1033	if ((type & SPELL_GRACE) && (mflags & P_NO_CLERIC)) return NULL;	1082	if ((type & SPELL_GRACE) && (mflags & P_NO_CLERIC))
		1083	return NULL;
1034	if (GET_MAP_MOVE_BLOCK(mp, x, y) & MOVE_FLY_LOW) return NULL;	1084	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
		1085	return NULL;
1035		1086
1036	if (mflags & P_IS_ALIVE) {	1087	if (mflags & P_IS_ALIVE)
		1088	{
1037	for(target=get_map_ob(mp,x,y); target; target=target->above) {	1089	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
		1090	{
1038	if(QUERY_FLAG(target->head?target->head:target,FLAG_MONSTER)) {	1091	if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER))
		1092	{
1039	return target;	1093	return target;
1040	}	1094	}
1041	}	1095	}
1042	}	1096	}
1043	}	1097	}
1044	return NULL;	1098	return NULL;
1045	}	1099	}
1046		1100
1047		1101
1048	/* cast_smite_arch() - the priest points to a creature and causes	1102	/* cast_smite_arch() - the priest points to a creature and causes
1049	* a 'godly curse' to decend.	1103	* a 'godly curse' to decend.
…		…
1052	* caster = object casting the spell.	1106	* caster = object casting the spell.
1053	* dir = direction being cast	1107	* dir = direction being cast
1054	* spell = spell object	1108	* spell = spell object
1055	*/	1109	*/
1056		1110
		1111	int
1057	int cast_smite_spell (object *op, object *caster,int dir, object *spell) {	1112	cast_smite_spell (object *op, object *caster, int dir, object *spell)
		1113	{
1058	object *effect, *target;	1114	object *effect, *target;
1059	object *god = find_god(determine_god(op));	1115	object *god = find_god (determine_god (op));
1060	int range;	1116	int range;
1061		1117
1062	range = spell->range + SP_level_range_adjust(caster,spell);	1118	range = spell->range + SP_level_range_adjust (caster, spell);
1063	target = get_pointed_target(op,dir, 50, spell->stats.grace?SPELL_GRACE:SPELL_MANA);	1119	target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);
1064		1120
1065	/* Bunch of conditions for casting this spell. Note that only	1121	/* Bunch of conditions for casting this spell. Note that only
1066	* require a god if this is a cleric spell (requires grace).	1122	* require a god if this is a cleric spell (requires grace).
1067	* This makes this spell much more general purpose - it can be used	1123	* 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	1124	* by wizards also, which is good, because I think this is a very
1069	* interesting spell.	1125	* interesting spell.
1070	* if it is a cleric spell, you need a god, and the creature	1126	* if it is a cleric spell, you need a god, and the creature
1071	* can't be friendly to your god.	1127	* can't be friendly to your god.
1072	*/	1128	*/
1073		1129
1074	if(!target || QUERY_FLAG(target,FLAG_REFL_SPELL)	1130	if (!target || QUERY_FLAG (target, FLAG_REFL_SPELL)
1075	||(!god && spell->stats.grace)	1131	|| (!god && spell->stats.grace)
1076	||(target->title && god && !strcmp(target->title,god->name))	1132	|| (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))) {	1133	{
1078	new_draw_info(NDI_UNIQUE,0,op,"Your request is unheeded.");	1134	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");
1079	return 0;	1135	return 0;
1080	}	1136	}
1081		1137
1082	if (spell->other_arch)	1138	if (spell->other_arch)
1083	effect = arch_to_object(spell->other_arch);	1139	effect = arch_to_object (spell->other_arch);
1084	else	1140	else
1085	return 0;	1141	return 0;
1086		1142
1087	/* tailor the effect by priest level and worshipped God */	1143	/* tailor the effect by priest level and worshipped God */
1088	effect->level = caster_level (caster, spell);	1144	effect->level = caster_level (caster, spell);
1089	effect->attacktype = spell->attacktype;	1145	effect->attacktype = spell->attacktype;
1090	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER)) {	1146	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
		1147	{
1091	if(tailor_god_spell(effect,op))	1148	if (tailor_god_spell (effect, op))
1092	new_draw_info_format(NDI_UNIQUE,0,op,	1149	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 {	1150	else
		1151	{
1095	new_draw_info(NDI_UNIQUE,0,op,"Your request is ignored.");	1152	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");
1096	return 0;	1153	return 0;
1097	}	1154	}
1098	}	1155	}
1099		1156
1100	/* size of the area of destruction */	1157	/* size of the area of destruction */
1101	effect->range=spell->range +	1158	effect->range = spell->range + SP_level_range_adjust (caster, spell);
1102	SP_level_range_adjust(caster,spell);	1159	effect->duration = spell->duration + SP_level_range_adjust (caster, spell);
1103	effect->duration=spell->duration +
1104	SP_level_range_adjust(caster,spell);
1105		1160
1106	if (effect->attacktype & AT_DEATH) {	1161	if (effect->attacktype & AT_DEATH)
1107	effect->level=spell->stats.dam +	1162	{
1108	SP_level_dam_adjust(caster,spell);	1163	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1109		1164
1110	/* casting death spells at undead isn't a good thing */	1165	/* casting death spells at undead isn't a good thing */
1111	if QUERY_FLAG(target, FLAG_UNDEAD) {	1166	if (QUERY_FLAG (target, FLAG_UNDEAD))
		1167	{
1112	if(random_roll(0, 2, op, PREFER_LOW)) {	1168	if (random_roll (0, 2, op, PREFER_LOW))
		1169	{
1113	new_draw_info(NDI_UNIQUE,0,op,"Idiot! Your spell boomerangs!");	1170	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1114	effect->x=op->x;	1171	effect->x = op->x;
1115	effect->y=op->y;	1172	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	}	1173	}
		1174	else
		1175	{
		1176	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
		1177	target->stats.hp = target->stats.maxhp * 2;
		1178	effect->destroy ();
		1179	return 0;
1123	}	1180	}
1124	} else {	1181	}
		1182	}
		1183	else
		1184	{
1125	/* how much woe to inflict :) */	1185	/* how much woe to inflict :) */
1126	effect->stats.dam=spell->stats.dam +	1186	effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1127	SP_level_dam_adjust(caster,spell);
1128	}	1187	}
1129		1188
1130	set_owner(effect,op);	1189	effect->set_owner (op);
1131	set_spell_skill(op, caster, spell, effect);	1190	set_spell_skill (op, caster, spell, effect);
1132		1191
1133	/* ok, tell it where to be, and insert! */	1192	/* ok, tell it where to be, and insert! */
1134	effect->x=target->x;	1193	effect->insert_at (target, op);
1135	effect->y=target->y;	1194
1136	insert_ob_in_map(effect,target->map,op,0);
1137
1138	return 1;	1195	return 1;
1139	}	1196	}
1140		1197
1141		1198
1142	/****************************************************************************	1199	/****************************************************************************
1143	*	1200	*
…		…
1145	* note that the fire_bullet is used to fire the missile. The	1202	* note that the fire_bullet is used to fire the missile. The
1146	* code here is just to move the missile.	1203	* code here is just to move the missile.
1147	****************************************************************************/	1204	****************************************************************************/
1148		1205
1149	/* op is a missile that needs to be moved */	1206	/* op is a missile that needs to be moved */
		1207	void
1150	void move_missile(object *op) {	1208	move_missile (object *op)
		1209	{
1151	int i, mflags;	1210	int i, mflags;
1152	object *owner;	1211	object *owner;
1153	sint16 new_x, new_y;	1212	sint16 new_x, new_y;
1154	mapstruct *m;	1213	maptile *m;
1155		1214
1156	if (op->range-- <=0) {	1215	if (op->range-- <= 0)
1157	remove_ob(op);	1216	{
1158	free_object(op);	1217	op->destroy ();
1159	return;	1218	return;
1160	}	1219	}
1161		1220
1162	owner = get_owner(op);	1221	owner = op->owner;
1163	#if 0	1222	#if 0
1164	/* It'd make things nastier if this wasn't here - spells cast by	1223	/* It'd make things nastier if this wasn't here - spells cast by
1165	* monster that are then killed would continue to survive	1224	* monster that are then killed would continue to survive
1166	*/	1225	*/
1167	if (owner == NULL) {	1226	if (owner == NULL)
1168	remove_ob(op);	1227	{
1169	free_object(op);	1228	op->destroy ();
1170	return;	1229	return;
1171	}	1230	}
1172	#endif	1231	#endif
1173		1232
1174	new_x = op->x + DIRX(op);	1233	new_x = op->x + DIRX (op);
1175	new_y = op->y + DIRY(op);	1234	new_y = op->y + DIRY (op);
1176		1235
1177	mflags = get_map_flags(op->map, &m, new_x, new_y, &new_x, &new_y);	1236	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1178		1237
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)))) {	1238	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;	1239	{
1182	hit_map (op, op->direction, AT_MAGIC, 1);	1240	hit_map (op, op->direction, AT_MAGIC, 1);
1183	/* Basically, missile only hits one thing then goes away.	1241	/* Basically, missile only hits one thing then goes away.
1184	* we need to remove it if someone hasn't already done so.	1242	* we need to remove it if someone hasn't already done so.
1185	*/	1243	*/
1186	if ( ! was_destroyed (op, tag)) {	1244	if (!op->destroyed ())
1187	remove_ob (op);	1245	op->destroy ();
1188	free_object(op);	1246
1189	}
1190	return;	1247	return;
1191	}	1248	}
1192		1249
1193	remove_ob(op);	1250	op->remove ();
		1251
1194	if ( ! op->direction || (mflags & P_OUT_OF_MAP)) {	1252	if (!op->direction || (mflags & P_OUT_OF_MAP))
1195	free_object(op);	1253	{
		1254	op->destroy ();
1196	return;	1255	return;
1197	}	1256	}
1198	op->x = new_x;	1257
1199	op->y = new_y;	1258	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){	1259	if (i > 0 && i != op->direction)
		1260	{
1203	op->direction=i;	1261	op->direction = i;
1204	SET_ANIMATION(op, op->direction);	1262	SET_ANIMATION (op, op->direction);
1205	}	1263	}
1206	insert_ob_in_map(op,op->map,op,0);	1264
		1265	m->insert (op, new_x, new_y, op);
1207	}	1266	}
1208		1267
1209	/****************************************************************************	1268	/****************************************************************************
1210	* Destruction	1269	* Destruction
1211	****************************************************************************/	1270	****************************************************************************/
		1271
1212	/* make_object_glow() - currently only makes living objects glow.	1272	/* make_object_glow() - currently only makes living objects glow.
1213	* we do this by creating a force and inserting it in the	1273	* we do this by creating a force and inserting it in the
1214	* object. if time is 0, the object glows permanently. To truely	1274	* object. if time is 0, the object glows permanently. To truely
1215	* make this work for non-living objects, we would have to	1275	* make this work for non-living objects, we would have to
1216	* give them the capability to have an inventory. b.t.	1276	* give them the capability to have an inventory. b.t.
1217	*/	1277	*/
1218		1278
		1279	int
1219	int make_object_glow(object *op, int radius, int time) {	1280	make_object_glow (object *op, int radius, int time)
		1281	{
1220	object *tmp;	1282	object *tmp;
1221		1283
1222	/* some things are unaffected... */	1284	/* some things are unaffected... */
1223	if(op->path_denied&PATH_LIGHT)	1285	if (op->path_denied & PATH_LIGHT)
1224	return 0;	1286	return 0;
1225		1287
1226	tmp=get_archetype(FORCE_NAME);	1288	tmp = get_archetype (FORCE_NAME);
1227	tmp->speed = 0.01;	1289	tmp->speed = 0.01;
1228	tmp->stats.food = time;	1290	tmp->stats.food = time;
1229	SET_FLAG(tmp, FLAG_IS_USED_UP);	1291	SET_FLAG (tmp, FLAG_IS_USED_UP);
1230	tmp->glow_radius=radius;	1292	tmp->glow_radius = radius;
1231	if (tmp->glow_radius > MAX_LIGHT_RADII)	1293	if (tmp->glow_radius > MAX_LIGHT_RADII)
1232	tmp->glow_radius = MAX_LIGHT_RADII;	1294	tmp->glow_radius = MAX_LIGHT_RADII;
1233		1295
1234	tmp->x=op->x;	1296	tmp->x = op->x;
1235	tmp->y=op->y;	1297	tmp->y = op->y;
1236	if(tmp->speed<MIN_ACTIVE_SPEED) tmp->speed = MIN_ACTIVE_SPEED; /* safety */	1298	if (tmp->speed < MIN_ACTIVE_SPEED)
		1299	tmp->speed = MIN_ACTIVE_SPEED; /* safety */
1237	tmp=insert_ob_in_ob(tmp,op);	1300	tmp = insert_ob_in_ob (tmp, op);
1238	if (tmp->glow_radius > op->glow_radius)	1301	if (tmp->glow_radius > op->glow_radius)
1239	op->glow_radius = tmp->glow_radius;	1302	op->glow_radius = tmp->glow_radius;
1240		1303
1241	if(!tmp->env||op!=tmp->env) {	1304	if (!tmp->env || op != tmp->env)
		1305	{
1242	LOG(llevError,"make_object_glow() failed to insert glowing force in %s\n",	1306	LOG (llevError, "make_object_glow() failed to insert glowing force in %s\n", &op->name);
1243	&op->name);
1244	return 0;	1307	return 0;
1245	}	1308	}
1246	return 1;	1309	return 1;
1247	}	1310	}
1248		1311
1249		1312
1250
1251		1313
		1314
		1315	int
1252	int cast_destruction(object *op, object *caster, object *spell_ob) {	1316	cast_destruction (object *op, object *caster, object *spell_ob)
		1317	{
1253	int i,j, range, mflags, friendly=0, dam, dur;	1318	int i, j, range, mflags, friendly = 0, dam, dur;
1254	sint16 sx,sy;	1319	sint16 sx, sy;
1255	mapstruct *m;	1320	maptile *m;
1256	object *tmp;	1321	object *tmp;
1257	const char *skill;	1322	const char *skill;
1258		1323
1259	range = spell_ob->range + SP_level_range_adjust(caster, spell_ob);	1324	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1260	dam = spell_ob->stats.dam + SP_level_dam_adjust(caster, spell_ob);	1325	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1261	dur = spell_ob->duration + SP_level_duration_adjust(caster, spell_ob);	1326	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1262	if (QUERY_FLAG(op, FLAG_FRIENDLY) || op->type == PLAYER) friendly=1;	1327	if (QUERY_FLAG (op, FLAG_FRIENDLY) || op->type == PLAYER)
		1328	friendly = 1;
1263		1329
1264	/* destruction doesn't use another spell object, so we need	1330	/* destruction doesn't use another spell object, so we need
1265	* update op's skill pointer so that exp is properly awarded.	1331	* update op's skill pointer so that exp is properly awarded.
1266	* We do some shortcuts here - since this is just temporary	1332	* 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	1333	* and we'll reset the values back, we don't need to go through
1268	* the full share string/free_string route.	1334	* the full share string/free_string route.
1269	*/	1335	*/
1270	skill = op->skill;	1336	skill = op->skill;
		1337	if (caster == op)
1271	if (caster == op) op->skill = spell_ob->skill;	1338	op->skill = spell_ob->skill;
1272	else if (caster->skill) op->skill = caster->skill;	1339	else if (caster->skill)
		1340	op->skill = caster->skill;
		1341	else
1273	else op->skill = NULL;	1342	op->skill = NULL;
1274		1343
1275	change_skill(op, find_skill_by_name(op, op->skill), 1);	1344	change_skill (op, find_skill_by_name (op, op->skill), 1);
1276		1345
1277	for(i= -range; i<range; i++) {	1346	for (i = -range; i < range; i++)
		1347	{
1278	for(j=-range; j<range ; j++) {	1348	for (j = -range; j < range; j++)
		1349	{
1279	m = op->map;	1350	m = op->map;
1280	sx = op->x + i;	1351	sx = op->x + i;
1281	sy = op->y + j;	1352	sy = op->y + j;
		1353
1282	mflags = get_map_flags(m, &m, sx, sy, &sx, &sy);	1354	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1283	if (mflags & P_OUT_OF_MAP) continue;	1355	if (mflags & P_OUT_OF_MAP)
		1356	continue;
		1357
1284	if (mflags & P_IS_ALIVE) {	1358	if (mflags & P_IS_ALIVE)
		1359	{
1285	for (tmp=get_map_ob(m, sx, sy); tmp; tmp=tmp->above) {	1360	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
1286	if (QUERY_FLAG(tmp, FLAG_ALIVE) || tmp->type==PLAYER) break;	1361	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
		1362	break;
		1363
		1364	if (tmp)
1287	}	1365	{
1288	if (tmp) {	1366	if (tmp->head)
1289	if (tmp->head) tmp=tmp->head;	1367	tmp = tmp->head;
1290		1368
1291	if ((friendly && !QUERY_FLAG(tmp, FLAG_FRIENDLY) && tmp->type!=PLAYER) ||	1369	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) ||
1292	(!friendly && (QUERY_FLAG(tmp, FLAG_FRIENDLY) || tmp->type==PLAYER))) {	1370	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
		1371	{
1293	if (spell_ob->subtype == SP_DESTRUCTION) {	1372	if (spell_ob->subtype == SP_DESTRUCTION)
		1373	{
1294	hit_player(tmp,dam,op,spell_ob->attacktype,0);	1374	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1295	if (spell_ob->other_arch) {	1375	if (spell_ob->other_arch)
1296	tmp = arch_to_object(spell_ob->other_arch);	1376	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	}	1377	}
1302	else if (spell_ob->subtype == SP_FAERY_FIRE &&	1378	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1303	tmp->resist[ATNR_MAGIC]!=100) {	1379	{
1304	if (make_object_glow(tmp, 1, dur) && spell_ob->other_arch) {	1380	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1305	object *effect = arch_to_object(spell_ob->other_arch);	1381	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	}	1382	}
1311	}	1383	}
1312	}	1384	}
1313	}	1385	}
1314	}	1386	}
1315	}	1387	}
		1388
1316	op->skill = skill;	1389	op->skill = skill;
1317	return 1;	1390	return 1;
1318	}	1391	}
1319		1392
1320	/***************************************************************************	1393	/***************************************************************************
1321	*	1394	*
1322	* CURSE	1395	* CURSE
1323	*	1396	*
1324	***************************************************************************/	1397	***************************************************************************/
1325		1398
		1399	int
1326	int cast_curse(object *op, object *caster, object *spell_ob, int dir) {	1400	cast_curse (object *op, object *caster, object *spell_ob, int dir)
		1401	{
1327	object *god = find_god(determine_god(op));	1402	object *god = find_god (determine_god (op));
1328	object *tmp, *force;	1403	object *tmp, *force;
1329		1404
1330	tmp = get_pointed_target(op, (dir==0)?op->direction:dir,	1405	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);
1331	spell_ob->range, SPELL_GRACE);
1332	if (!tmp) {	1406	if (!tmp)
1333	new_draw_info(NDI_UNIQUE, 0, op,	1407	{
1334	"There is no one in that direction to curse.");	1408	new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");
1335	return 0;	1409	return 0;
1336	}	1410	}
1337		1411
1338	/* If we've already got a force of this type, don't add a new one. */	1412	/* 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) {	1413	for (force = tmp->inv; force != NULL; force = force->below)
		1414	{
1340	if (force->type==FORCE && force->subtype == FORCE_CHANGE_ABILITY) {	1415	if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
		1416	{
1341	if (force->name == spell_ob->name) {	1417	if (force->name == spell_ob->name)
		1418	{
1342	break;	1419	break;
1343	}	1420	}
1344	else if (spell_ob->race && spell_ob->race == force->name) {	1421	else if (spell_ob->race && spell_ob->race == force->name)
1345	new_draw_info_format(NDI_UNIQUE, 0, op,	1422	{
1346	"You can not cast %s while %s is in effect",	1423	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;	1424	return 0;
1349	}	1425	}
1350	}	1426	}
1351	}	1427	}
1352		1428
1353	if(force==NULL) {	1429	if (force == NULL)
		1430	{
1354	force=get_archetype(FORCE_NAME);	1431	force = get_archetype (FORCE_NAME);
1355	force->subtype = FORCE_CHANGE_ABILITY;	1432	force->subtype = FORCE_CHANGE_ABILITY;
1356	if (spell_ob->race)	1433	if (spell_ob->race)
1357	force->name = spell_ob->race;	1434	force->name = spell_ob->race;
1358	else	1435	else
1359	force->name = spell_ob->name;	1436	force->name = spell_ob->name;
1360		1437
1361	force->name_pl = spell_ob->name;	1438	force->name_pl = spell_ob->name;
1362		1439
1363	} else {	1440	}
		1441	else
		1442	{
1364	int duration;	1443	int duration;
1365		1444
1366	duration = spell_ob->duration + SP_level_duration_adjust(caster, spell_ob) * 50;	1445	duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1367	if (duration > force->duration) {	1446	if (duration > force->duration)
		1447	{
1368	force->duration = duration;	1448	force->duration = duration;
1369	new_draw_info(NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1449	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
		1450	}
1370	} else {	1451	else
		1452	{
1371	new_draw_info(NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1453	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1372	}	1454	}
1373	return 1;	1455	return 1;
1374	}	1456	}
1375	force->duration = spell_ob->duration + SP_level_duration_adjust(caster, spell_ob) * 50;	1457	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1376	force->speed = 1.0;	1458	force->speed = 1.0;
1377	force->speed_left = -1.0;	1459	force->speed_left = -1.0;
1378	SET_FLAG(force, FLAG_APPLIED);	1460	SET_FLAG (force, FLAG_APPLIED);
1379		1461
1380	if(god) {	1462	if (god)
		1463	{
1381	if (spell_ob->last_grace)	1464	if (spell_ob->last_grace)
1382	force->path_repelled=god->path_repelled;	1465	force->path_repelled = god->path_repelled;
1383	if (spell_ob->last_grace)	1466	if (spell_ob->last_grace)
1384	force->path_denied=god->path_denied;	1467	force->path_denied = god->path_denied;
1385	new_draw_info_format(NDI_UNIQUE, 0,tmp,	1468	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);	1469	}
1387	} else	1470	else
1388	new_draw_info(NDI_UNIQUE, 0,op,"Your curse seems empty.");	1471	new_draw_info (NDI_UNIQUE, 0, op, "Your curse seems empty.");
1389		1472
1390		1473
1391	if(tmp!=op && op->type==PLAYER)	1474	if (tmp != op && op->type == PLAYER)
1392	new_draw_info_format(NDI_UNIQUE, 0, op, "You curse %s!", &tmp->name);	1475	new_draw_info_format (NDI_UNIQUE, 0, op, "You curse %s!", &tmp->name);
1393		1476
1394	force->stats.ac = spell_ob->stats.ac;	1477	force->stats.ac = spell_ob->stats.ac;
1395	force->stats.wc = spell_ob->stats.wc;	1478	force->stats.wc = spell_ob->stats.wc;
1396		1479
1397	change_abil(tmp,force); /* Mostly to display any messages */	1480	change_abil (tmp, force); /* Mostly to display any messages */
1398	insert_ob_in_ob(force,tmp);	1481	insert_ob_in_ob (force, tmp);
1399	fix_player(tmp);	1482	tmp->update_stats ();
1400	return 1;	1483	return 1;
1401		1484
1402	}	1485	}
1403
1404		1486
1405	/**********************************************************************	1487	/**********************************************************************
1406	* mood change	1488	* mood change
1407	* Arguably, this may or may not be an attack spell. But since it	1489	* 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	1490	* effects monsters, it seems best to put it into this file
1409	***********************************************************************/	1491	***********************************************************************/
1410		1492
1411	/* This covers the various spells that change the moods of monsters -	1493	/* This covers the various spells that change the moods of monsters -
1412	* makes them angry, peacful, friendly, etc.	1494	* makes them angry, peacful, friendly, etc.
1413	*/	1495	*/
		1496	int
1414	int mood_change(object *op, object *caster, object *spell) {	1497	mood_change (object *op, object *caster, object *spell)
		1498	{
1415	object *tmp, *god, *head;	1499	object *tmp, *god, *head;
1416	int done_one, range, mflags, level, at, best_at;	1500	int done_one, range, mflags, level, at, best_at;
1417	sint16 x, y, nx, ny;	1501	sint16 x, y, nx, ny;
1418	mapstruct *m;	1502	maptile *m;
1419	const char *race;	1503	const char *race;
1420		1504
1421	/* We precompute some values here so that we don't have to keep	1505	/* We precompute some values here so that we don't have to keep
1422	* doing it over and over again.	1506	* doing it over and over again.
1423	*/	1507	*/
1424	god=find_god(determine_god(op));	1508	god = find_god (determine_god (op));
1425	level=caster_level(caster, spell);	1509	level = caster_level (caster, spell);
1426	range = spell->range + SP_level_range_adjust(caster, spell);	1510	range = spell->range + SP_level_range_adjust (caster, spell);
1427		1511
1428	/* On the bright side, no monster should ever have a race of GOD_...	1512	/* 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	1513	* so even if the player doesn't worship a god, if race=GOD_.., it
1430	* won't ever match anything.	1514	* won't ever match anything.
1431	*/	1515	*/
1432	if (!spell->race) race=NULL;	1516	if (!spell->race)
		1517	race = NULL;
1433	else if (god && !strcmp(spell->race, "GOD_SLAYING")) race = god->slaying;	1518	else if (god && !strcmp (spell->race, "GOD_SLAYING"))
		1519	race = god->slaying;
1434	else if (god && !strcmp(spell->race, "GOD_FRIEND")) race = god->race;	1520	else if (god && !strcmp (spell->race, "GOD_FRIEND"))
		1521	race = god->race;
		1522	else
1435	else race = spell->race;	1523	race = spell->race;
1436
1437		1524
1438	for (x = op->x - range; x <= op->x + range; x++)	1525	for (x = op->x - range; x <= op->x + range; x++)
1439	for (y = op->y - range; y <= op->y + range; y++) {	1526	for (y = op->y - range; y <= op->y + range; y++)
1440		1527	{
1441	done_one=0;	1528	done_one = 0;
1442	m = op->map;	1529	m = op->map;
1443	nx = x;	1530	nx = x;
1444	ny = y;	1531	ny = y;
1445	mflags = get_map_flags(m, &m, x, y, &nx, &ny);	1532	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1446	if (mflags & P_OUT_OF_MAP) continue;	1533	if (mflags & P_OUT_OF_MAP)
		1534	continue;
1447		1535
1448	/* If there is nothing living on this space, no need to go further */	1536	/* If there is nothing living on this space, no need to go further */
1449	if (!(mflags & P_IS_ALIVE)) continue;	1537	if (!(mflags & P_IS_ALIVE))
		1538	continue;
1450		1539
		1540	// players can only affect spaces that they can actually see
		1541	if (caster && caster->contr
		1542	&& caster->contr->visibility_at (m, nx, ny) < 70)
		1543	continue;
		1544
1451	for (tmp = get_map_ob(m, nx, ny); tmp; tmp = tmp->above)	1545	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)
1452	if (QUERY_FLAG(tmp, FLAG_MONSTER)) break;	1546	if (QUERY_FLAG (tmp, FLAG_MONSTER))
		1547	break;
1453		1548
1454	/* There can be living objects that are not monsters */	1549	/* There can be living objects that are not monsters */
1455	if (!tmp || tmp->type==PLAYER) continue;	1550	if (!tmp || tmp->type == PLAYER)
		1551	continue;
1456		1552
1457	/* Only the head has meaningful data, so resolve to that */	1553	/* Only the head has meaningful data, so resolve to that */
1458	if (tmp->head) head=tmp->head;	1554	if (tmp->head)
		1555	head = tmp->head;
		1556	else
1459	else head=tmp;	1557	head = tmp;
1460		1558
1461	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */	1559	/* 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;	1560	if (race && head->race && !strstr (race, head->race))
		1561	continue;
		1562
1463	if (QUERY_FLAG(head, FLAG_UNDEAD) && !QUERY_FLAG(spell, FLAG_UNDEAD)) continue;	1563	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))
		1564	continue;
1464		1565
1465	/* Now do a bunch of stuff related to saving throws */	1566	/* Now do a bunch of stuff related to saving throws */
1466	best_at = -1;	1567	best_at = -1;
1467	if (spell->attacktype) {	1568	if (spell->attacktype)
		1569	{
1468	for (at=0; at < NROFATTACKS; at++)	1570	for (at = 0; at < NROFATTACKS; at++)
1469	if (spell->attacktype & (1 << at))	1571	if (spell->attacktype & (1 << at))
1470	if (best_at == -1 || head->resist[at] > head->resist[best_at]) best_at = at;	1572	if (best_at == -1 || head->resist[at] > head->resist[best_at])
		1573	best_at = at;
1471		1574
1472	if (best_at == -1) at=0;	1575	if (best_at == -1)
		1576	at = 0;
		1577	else
		1578	{
		1579	if (head->resist[best_at] == 100)
		1580	continue;
1473	else {	1581	else
1474	if (head->resist[best_at] == 100) continue;
1475	else at = head->resist[best_at] / 5;	1582	at = head->resist[best_at] / 5;
1476	}	1583	}
1477	at -= level / 5;	1584	at -= level / 5;
1478	if (did_make_save(head, head->level, at)) continue;	1585	if (did_make_save (head, head->level, at))
		1586	continue;
1479	}	1587	}
1480	else /* spell->attacktype */	1588	else /* spell->attacktype */
1481	/*	1589	/*
1482	Spell has no attacktype (charm & such), so we'll have a specific saving:	1590	Spell has no attacktype (charm & such), so we'll have a specific saving:
1483	* if spell level < monster level, no go	1591	* if spell level < monster level, no go
1484	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )	1592	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1485		1593
1486	The chance will then be in the range [20-70] percent, not too bad.	1594	The chance will then be in the range [20-70] percent, not too bad.
1487		1595
1488	This is required to fix the 'charm monster' abuse, where a player level 1 can	1596	This is required to fix the 'charm monster' abuse, where a player level 1 can
1489	charm a level 125 monster...	1597	charm a level 125 monster...
1490		1598
1491	Ryo, august 14th	1599	Ryo, august 14th
1492	*/	1600	*/
1493	{	1601	{
1494	if ( head->level > level ) continue;	1602	if (head->level > level)
		1603	continue;
1495	if ( random_roll( 0, 100, caster, PREFER_LOW ) >= ( 20 + MIN( 50, 2 * ( level - head->level ) ) ) )	1604	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))
1496	/* Failed, no effect */	1605	/* Failed, no effect */
1497	continue;	1606	continue;
1498	}	1607	}
1499		1608
1500	/* Done with saving throw. Now start effecting the monster */	1609	/* Done with saving throw. Now start affecting the monster */
1501		1610
1502	/* aggravation */	1611	/* aggravation */
1503	if (QUERY_FLAG(spell, FLAG_MONSTER)) {	1612	if (QUERY_FLAG (spell, FLAG_MONSTER))
		1613	{
1504	CLEAR_FLAG(head, FLAG_SLEEP);	1614	CLEAR_FLAG (head, FLAG_SLEEP);
1505	if (QUERY_FLAG(head, FLAG_FRIENDLY))	1615	if (QUERY_FLAG (head, FLAG_FRIENDLY))
1506	remove_friendly_object(head);	1616	remove_friendly_object (head);
1507		1617
1508	done_one = 1;	1618	done_one = 1;
1509	head->enemy = op;	1619	head->enemy = op;
1510	}	1620	}
1511		1621
1512	/* calm monsters */	1622	/* calm monsters */
1513	if (QUERY_FLAG(spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG(head, FLAG_UNAGGRESSIVE)) {	1623	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))
		1624	{
1514	SET_FLAG(head, FLAG_UNAGGRESSIVE);	1625	SET_FLAG (head, FLAG_UNAGGRESSIVE);
1515	head->enemy = NULL;	1626	head->enemy = NULL;
1516	done_one = 1;	1627	done_one = 1;
1517	}	1628	}
1518		1629
1519	/* berserk monsters */	1630	/* berserk monsters */
1520	if (QUERY_FLAG(spell, FLAG_BERSERK) && !QUERY_FLAG(head, FLAG_BERSERK)) {	1631	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))
		1632	{
1521	SET_FLAG(head, FLAG_BERSERK);	1633	SET_FLAG (head, FLAG_BERSERK);
1522	done_one = 1;	1634	done_one = 1;
1523	}	1635	}
		1636
1524	/* charm */	1637	/* charm */
1525	if (QUERY_FLAG(spell, FLAG_NO_ATTACK) && !QUERY_FLAG(head, FLAG_FRIENDLY)) {	1638	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
1526	SET_FLAG(head, FLAG_FRIENDLY);	1639	{
1527	/* Prevent uncontolled outbreaks of self replicating monsters.	1640	/* Prevent uncontolled outbreaks of self replicating monsters.
1528	Typical use case is charm, go somwhere, use aggravation to make hostile.	1641	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. */	1642	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1530	CLEAR_FLAG(head, FLAG_GENERATOR);	1643	CLEAR_FLAG (head, FLAG_GENERATOR);
1531	set_owner(head, op);	1644	head->set_owner (op);
1532	set_spell_skill(op, caster, spell, head);	1645	set_spell_skill (op, caster, spell, head);
1533	add_friendly_object(head);	1646	add_friendly_object (head);
1534	head->attack_movement = PETMOVE;	1647	head->attack_movement = PETMOVE;
1535	done_one = 1;	1648	done_one = 1;
1536	change_exp(op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1649	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1537	head->stats.exp = 0;	1650	head->stats.exp = 0;
1538	}	1651	}
1539		1652
1540	/* If a monster was effected, put an effect in */	1653	/* If a monster was effected, put an effect in */
1541	if (done_one && spell->other_arch) {	1654	if (done_one && spell->other_arch)
1542	tmp = arch_to_object(spell->other_arch);	1655	m->insert (arch_to_object (spell->other_arch), nx, ny, op);
1543	tmp->x = nx;	1656	} /* for y */
1544	tmp->y = ny;
1545	insert_ob_in_map(tmp, m, op, 0);
1546	}
1547	} /* for y */
1548		1657
1549	return 1;	1658	return 1;
1550	}	1659	}
1551		1660
1552		1661
1553	/* Move_ball_spell: This handles ball type spells that just sort of wander	1662	/* 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	1663	* about. was called move_ball_lightning, but since more than the ball
1555	* lightning spell used it, that seemed misnamed.	1664	* lightning spell used it, that seemed misnamed.
1556	* op is the spell effect.	1665	* op is the spell effect.
1557	* note that duration is handled by process_object() in time.c	1666	* note that duration is handled by process_object() in time.c
1558	*/	1667	*/
1559		1668
		1669	void
1560	void move_ball_spell(object *op) {	1670	move_ball_spell (object *op)
		1671	{
1561	int i,j,dam_save,dir, mflags;	1672	int i, j, dam_save, dir, mflags;
1562	sint16 nx,ny, hx, hy;	1673	sint16 nx, ny, hx, hy;
1563	object *owner;	1674	object *owner;
1564	mapstruct *m;	1675	maptile *m;
1565		1676
1566	owner = get_owner(op);	1677	owner = op->owner;
1567		1678
1568	/* the following logic makes sure that the ball doesn't move into a wall,	1679	/* 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	1680	* 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	1681	* 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	1682	* offset to move the ball, eg, keep it mostly on course, with some
1572	* deviations.	1683	* deviations.
1573	*/	1684	*/
1574		1685
1575	dir = 0;	1686	dir = 0;
1576	if(!(rndm(0, 3)))	1687	if (!(rndm (0, 3)))
1577	j = rndm(0, 1);	1688	j = rndm (0, 1);
1578	else j=0;	1689	else
		1690	j = 0;
1579		1691
1580	for(i = 1; i < 9; i++) {	1692	for (i = 1; i < 9; i++)
		1693	{
1581	/* i bit 0: alters sign of offset	1694	/* i bit 0: alters sign of offset
1582	* other bits (i / 2): absolute value of offset	1695	* other bits (i / 2): absolute value of offset
1583	*/	1696	*/
1584		1697
1585	int offset = ((i ^ j) & 1) ? (i / 2) : - (i / 2);	1698	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1586	int tmpdir = absdir (op->direction + offset);	1699	int tmpdir = absdir (op->direction + offset);
1587		1700
1588	nx = op->x + freearr_x[tmpdir];	1701	nx = op->x + freearr_x[tmpdir];
1589	ny = op->y + freearr_y[tmpdir];	1702	ny = op->y + freearr_y[tmpdir];
1590	if ( ! (get_map_flags(op->map, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) &&	1703	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)))) {	1704	{
1592	dir = tmpdir;	1705	dir = tmpdir;
1593	break;	1706	break;
1594	}	1707	}
1595	}	1708	}
1596	if (dir == 0) {	1709	if (dir == 0)
		1710	{
1597	nx = op->x;	1711	nx = op->x;
1598	ny = op->y;	1712	ny = op->y;
1599	m = op->map;	1713	m = op->map;
1600	}	1714	}
1601		1715
1602	remove_ob(op);	1716	m->insert (op, nx, ny, op);
1603	op->y=ny;	1717
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	1718	dam_save = op->stats.dam; /* save the original dam: we do halfdam on
1608	surrounding squares */	1719	surrounding squares */
1609		1720
1610	/* loop over current square and neighbors to hit.	1721	/* loop over current square and neighbors to hit.
1611	* if this has an other_arch field, we insert that in	1722	* if this has an other_arch field, we insert that in
1612	* the surround spaces.	1723	* the surround spaces.
1613	*/	1724	*/
1614	for(j=0;j<9;j++) {	1725	for (j = 0; j < 9; j++)
1615	object *new_ob;	1726	{
1616
1617	hx = nx+freearr_x[j];	1727	hx = nx + freearr_x[j];
1618	hy = ny+freearr_y[j];	1728	hy = ny + freearr_y[j];
1619		1729
1620	m = op->map;	1730	m = op->map;
1621	mflags = get_map_flags(m, &m, hx, hy, &hx, &hy);	1731	mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
1622		1732
1623	if (mflags & P_OUT_OF_MAP) continue;	1733	if (mflags & P_OUT_OF_MAP)
		1734	continue;
1624		1735
1625	/* first, don't ever, ever hit the owner. Don't hit out	1736	/* first, don't ever, ever hit the owner. Don't hit out
1626	* of the map either.	1737	* of the map either.
1627	*/	1738	*/
1628		1739
1629	if((mflags & P_IS_ALIVE) && (!owner || owner->x!=hx || owner->y!=hy || !on_same_map(owner,op))) {	1740	if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
		1741	{
		1742	if (j)
1630	if(j) op->stats.dam = dam_save/2;	1743	op->stats.dam = dam_save / 2;
1631	hit_map(op,j,op->attacktype,1);	1744	hit_map (op, j, op->attacktype, 1);
1632		1745
1633	}	1746	}
1634		1747
1635	/* insert the other arch */	1748	/* insert the other arch */
1636	if(op->other_arch && !(OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(m, hx, hy)))) {	1749	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);	1750	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	}	1751	}
1643		1752
1644	/* restore to the center location and damage*/	1753	/* restore to the center location and damage */
1645	op->stats.dam = dam_save;	1754	op->stats.dam = dam_save;
1646		1755
1647	i=spell_find_dir(op->map,op->x,op->y,get_owner(op));	1756	i = spell_find_dir (op->map, op->x, op->y, op->owner);
1648		1757
1649	if(i>=0) { /* we have a preferred direction! */	1758	if (i >= 0)
		1759	{ /* we have a preferred direction! */
1650	/* pick another direction if the preferred dir is blocked. */	1760	/* 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 ||	1761	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))) {	1762	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))
1653	i= absdir(i + rndm(0, 2) -1); /* -1, 0, +1 */	1763	i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1654	}	1764
1655	op->direction=i;	1765	op->direction = i;
1656	}	1766	}
1657	}	1767	}
1658		1768
1659		1769
1660	/* move_swarm_spell: peterm	1770	/* move_swarm_spell: peterm
…		…
1663	* is a special type of object that casts swarms of other types	1773	* 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	1774	* 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.	1775	* from a set of squares surrounding the caster, in a given direction.
1666	*/	1776	*/
1667		1777
		1778	void
1668	void move_swarm_spell(object *op)	1779	move_swarm_spell (object *op)
1669	{	1780	{
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	1781	#if 0
1692	// this is bogus: it causes wrong places to be checked below	1782	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	1783	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	1784	sint16 target_x, target_y, origin_x, origin_y;
1695	// space.	1785	int adjustdir;
1696	// should be fixed later, but correctness before featurs...	1786	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	1787	#endif
		1788	int basedir;
		1789	object *owner;
1739		1790
		1791	owner = op->owner;
		1792	if (op->duration == 0 || owner == NULL)
		1793	{
		1794	op->destroy ();
		1795	return;
		1796	}
		1797
		1798	op->duration--;
		1799
		1800	basedir = op->direction;
		1801	if (basedir == 0)
		1802	{
		1803	/* spray in all directions! 8) */
		1804	basedir = rndm (1, 8);
		1805	}
		1806
		1807	#if 0
		1808	// this is bogus: it causes wrong places to be checked below
		1809	// (a wall 2 cells away will block the effect...) and
		1810	// doesn't work for SP_BULLET anyhow, so again tests the wrong
		1811	// space.
		1812	// should be fixed later, but correctness before featurs...
		1813	// (schmorp)
		1814
		1815	/* new offset calculation to make swarm element distribution
		1816	* more uniform
		1817	*/
		1818	if (op->duration)
		1819	{
		1820	if (basedir & 1)
		1821	{
		1822	adjustdir = cardinal_adjust[rndm (0, 8)];
		1823	}
		1824	else
		1825	{
		1826	adjustdir = diagonal_adjust[rndm (0, 9)];
		1827	}
		1828	}
		1829	else
		1830	{
		1831	adjustdir = 0; /* fire the last one from forward. */
		1832	}
		1833
		1834	target_x = op->x + freearr_x[absdir (basedir + adjustdir)];
		1835	target_y = op->y + freearr_y[absdir (basedir + adjustdir)];
		1836
		1837	/* back up one space so we can hit point-blank targets, but this
		1838	* necessitates extra out_of_map check below
		1839	*/
		1840	origin_x = target_x - freearr_x[basedir];
		1841	origin_y = target_y - freearr_y[basedir];
		1842
		1843
1740	/* spell pointer is set up for the spell this casts. Since this	1844	/* spell pointer is set up for the spell this casts. Since this
1741	* should just be a pointer to the spell in some inventory,	1845	* should just be a pointer to the spell in some inventory,
1742	* it is unlikely to disappear by the time we need it. However,	1846	* it is unlikely to disappear by the time we need it. However,
1743	* do some sanity checking anyways.	1847	* do some sanity checking anyways.
1744	*/	1848	*/
1745		1849
1746	if (op->spell && op->spell->type == SPELL)	1850	if (op->spell && op->spell->type == SPELL &&
		1851	!(get_map_flags (op->map, &m, target_x, target_y, &target_x, &target_y) & P_OUT_OF_MAP) &&
		1852	!(OB_TYPE_MOVE_BLOCK (op->spell, GET_MAP_MOVE_BLOCK (m, target_x, target_y))))
1747	{	1853	{
		1854
1748	/* Bullet spells have a bunch more customization that needs to be done */	1855	/* Bullet spells have a bunch more customization that needs to be done */
1749	if (op->spell->subtype == SP_BULLET)	1856	if (op->spell->subtype == SP_BULLET)
1750	fire_bullet(owner, op, basedir, op->spell);	1857	fire_bullet (owner, op, basedir, op->spell);
1751	else if (op->spell->subtype == SP_MAGIC_MISSILE)	1858	else if (op->spell->subtype == SP_MAGIC_MISSILE)
		1859	fire_arch_from_position (owner, op, origin_x, origin_y, basedir, op->spell);
		1860	}
		1861	#endif
		1862
		1863	/* spell pointer is set up for the spell this casts. Since this
		1864	* should just be a pointer to the spell in some inventory,
		1865	* it is unlikely to disappear by the time we need it. However,
		1866	* do some sanity checking anyways.
		1867	*/
		1868
		1869	if (op->spell && op->spell->type == SPELL)
		1870	{
		1871	/* Bullet spells have a bunch more customization that needs to be done */
		1872	if (op->spell->subtype == SP_BULLET)
		1873	fire_bullet (owner, op, basedir, op->spell);
		1874	else if (op->spell->subtype == SP_MAGIC_MISSILE)
1752	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);	1875	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);
1753	}	1876	}
1754	}	1877	}
1755		1878
1756		1879
1757		1880
1758		1881
…		…
1766	* dir: the direction everything will be fired in	1889	* dir: the direction everything will be fired in
1767	* spell - the spell that is this spell.	1890	* spell - the spell that is this spell.
1768	* n: the number to be fired.	1891	* n: the number to be fired.
1769	*/	1892	*/
1770		1893
		1894	int
1771	int fire_swarm (object *op, object *caster, object *spell, int dir)	1895	fire_swarm (object *op, object *caster, object *spell, int dir)
1772	{	1896	{
1773	object *tmp;	1897	object *tmp;
1774	int i;	1898	int i;
1775		1899
1776	if (!spell->other_arch) return 0;	1900	if (!spell->other_arch)
		1901	return 0;
1777		1902
1778	tmp=get_archetype(SWARM_SPELL);	1903	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.*/	1904	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
1782	set_spell_skill(op, caster, spell, tmp);	1905	set_spell_skill (op, caster, spell, tmp);
1783		1906
1784	tmp->level=caster_level(caster, spell); /*needed later, to get level dep. right.*/	1907	tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */
1785	tmp->spell = arch_to_object(spell->other_arch);	1908	tmp->spell = arch_to_object (spell->other_arch);
1786		1909
1787	tmp->attacktype = tmp->spell->attacktype;	1910	tmp->attacktype = tmp->spell->attacktype;
1788		1911
1789	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) {	1912	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1790	if ( ! tailor_god_spell (tmp, op))	1913	if (!tailor_god_spell (tmp, op))
1791	return 1;	1914	return 1;
1792	}	1915
1793	tmp->duration = SP_level_duration_adjust(caster, spell);	1916	tmp->duration = SP_level_duration_adjust (caster, spell);
1794	for (i=0; i< spell->duration; i++)	1917	for (i = 0; i < spell->duration; i++)
1795	tmp->duration += die_roll(1, 3, op, PREFER_HIGH);	1918	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1796		1919
1797	tmp->direction=dir;	1920	tmp->direction = dir;
1798	tmp->invisible=1;	1921	tmp->invisible = 1;
1799	insert_ob_in_map(tmp,op->map,op,0);	1922
		1923	tmp->insert_at (op, op);
1800	return 1;	1924	return 1;
1801	}	1925	}
1802		1926
1803		1927
1804	/* See the spells documentation file for why this is its own	1928	/* See the spells documentation file for why this is its own
1805	* function.	1929	* function.
1806	*/	1930	*/
		1931	int
1807	int cast_light(object *op,object *caster,object *spell, int dir) {	1932	cast_light (object *op, object *caster, object *spell, int dir)
		1933	{
1808	object *target=NULL,*tmp=NULL;	1934	object *target = NULL, *tmp = NULL;
1809	sint16 x,y;	1935	sint16 x, y;
1810	int dam, mflags;	1936	int dam, mflags;
1811	mapstruct *m;	1937	maptile *m;
1812		1938
1813	dam = spell->stats.dam + SP_level_dam_adjust(caster,spell);	1939	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1814		1940
1815	if(!dir) {	1941	if (!dir)
		1942	{
1816	new_draw_info(NDI_UNIQUE, 0,op,"In what direction?");	1943	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1817	return 0;	1944	return 0;
1818	}	1945	}
1819		1946
1820	x=op->x+freearr_x[dir];	1947	x = op->x + freearr_x[dir];
1821	y=op->y+freearr_y[dir];	1948	y = op->y + freearr_y[dir];
1822	m = op->map;	1949	m = op->map;
1823		1950
1824	mflags = get_map_flags(m, &m, x, y, &x, &y);	1951	mflags = get_map_flags (m, &m, x, y, &x, &y);
1825		1952
1826	if (mflags & P_OUT_OF_MAP) {	1953	if (mflags & P_OUT_OF_MAP)
		1954	{
1827	new_draw_info(NDI_UNIQUE, 0,op,"Nothing is there.");	1955	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
1828	return 0;	1956	return 0;
1829	}	1957	}
1830		1958
1831	if (mflags & P_IS_ALIVE && spell->attacktype) {	1959	if (mflags & P_IS_ALIVE && spell->attacktype)
		1960	{
1832	for(target=get_map_ob(m,x,y);target;target=target->above)	1961	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1833	if(QUERY_FLAG(target,FLAG_MONSTER)) {	1962	if (QUERY_FLAG (target, FLAG_MONSTER))
		1963	{
1834	/* oky doky. got a target monster. Lets make a blinding attack */	1964	/* oky doky. got a target monster. Lets make a blinding attack */
		1965	if (target->head)
1835	if(target->head) target = target->head;	1966	target = target->head;
1836	(void) hit_player(target,dam,op,spell->attacktype,1);	1967	(void) hit_player (target, dam, op, spell->attacktype, 1);
1837	return 1; /* one success only! */	1968	return 1; /* one success only! */
1838	}	1969	}
1839	}	1970	}
1840		1971
1841	/* no live target, perhaps a wall is in the way? */	1972	/* no live target, perhaps a wall is in the way? */
1842	if (OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(m, x, y))) {	1973	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
		1974	{
1843	new_draw_info(NDI_UNIQUE, 0,op,"Something is in the way.");	1975	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1844	return 0;	1976	return 0;
1845	}	1977	}
1846		1978
1847	/* ok, looks groovy to just insert a new light on the map */	1979	/* ok, looks groovy to just insert a new light on the map */
1848	tmp=arch_to_object(spell->other_arch);	1980	tmp = arch_to_object (spell->other_arch);
1849	if(!tmp) {	1981	if (!tmp)
		1982	{
1850	LOG(llevError,"Error: spell arch for cast_light() missing.\n");	1983	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1851	return 0;	1984	return 0;
1852	}	1985	}
1853	tmp->stats.food = spell->duration + SP_level_duration_adjust(caster,spell);	1986	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
1854	if (tmp->glow_radius) {	1987	if (tmp->glow_radius)
		1988	{
1855	tmp->glow_radius= spell->range + SP_level_range_adjust(caster,spell);	1989	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;	1990	if (tmp->glow_radius > MAX_LIGHT_RADII)
		1991	tmp->glow_radius = MAX_LIGHT_RADII;
1857	}	1992	}
1858	tmp->x=x;	1993
1859	tmp->y=y;	1994	m->insert (tmp, x, y, op);
1860	insert_ob_in_map(tmp,m,op,0);
1861	return 1;	1995	return 1;
1862	}	1996	}
1863		1997
1864		1998
1865		1999
1866		2000
…		…
1869	* op is the player/monster, caster is the object, dir is the direction	2003	* 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	2004	* to cast, disease_arch is the specific disease, and type is the spell number
1871	* perhaps this should actually be in disease.c?	2005	* perhaps this should actually be in disease.c?
1872	*/	2006	*/
1873		2007
		2008	int
1874	int cast_cause_disease(object *op, object *caster, object *spell, int dir) {	2009	cast_cause_disease (object *op, object *caster, object *spell, int dir)
		2010	{
1875	sint16 x,y;	2011	sint16 x, y;
1876	int i, mflags, range, dam_mod, dur_mod;	2012	int i, mflags, range, dam_mod, dur_mod;
1877	object *walk;	2013	object *walk;
1878	mapstruct *m;	2014	maptile *m;
1879		2015
1880	x = op->x;	2016	x = op->x;
1881	y = op->y;	2017	y = op->y;
1882		2018
1883	/* If casting from a scroll, no direction will be available, so refer to the	2019	/* If casting from a scroll, no direction will be available, so refer to the
1884	* direction the player is pointing.	2020	* direction the player is pointing.
1885	*/	2021	*/
		2022	if (!dir)
1886	if (!dir) dir=op->facing;	2023	dir = op->facing;
		2024	if (!dir)
1887	if (!dir) return 0; /* won't find anything if casting on ourself, so just return */	2025	return 0; /* won't find anything if casting on ourself, so just return */
1888		2026
1889	/* Calculate these once here */	2027	/* Calculate these once here */
1890	range = spell->range + SP_level_range_adjust(caster, spell);	2028	range = spell->range + SP_level_range_adjust (caster, spell);
1891	dam_mod = SP_level_dam_adjust(caster, spell);	2029	dam_mod = SP_level_dam_adjust (caster, spell);
1892	dur_mod = SP_level_duration_adjust(caster, spell);	2030	dur_mod = SP_level_duration_adjust (caster, spell);
1893		2031
1894	/* search in a line for a victim */	2032	/* search in a line for a victim */
1895	for(i=1; i<range; i++) {	2033	for (i = 1; i < range; i++)
		2034	{
1896	x = op->x + i * freearr_x[dir];	2035	x = op->x + i * freearr_x[dir];
1897	y = op->y + i * freearr_y[dir];	2036	y = op->y + i * freearr_y[dir];
1898	m = op->map;	2037	m = op->map;
1899		2038
1900	mflags = get_map_flags(m, &m, x, y, &x, &y);	2039	mflags = get_map_flags (m, &m, x, y, &x, &y);
1901		2040
1902	if (mflags & P_OUT_OF_MAP) return 0;	2041	if (mflags & P_OUT_OF_MAP)
		2042	return 0;
1903		2043
1904	/* don't go through walls - presume diseases are airborne */	2044	/* don't go through walls - presume diseases are airborne */
1905	if (GET_MAP_MOVE_BLOCK(m, x, y) & MOVE_FLY_LOW) return 0;	2045	if (GET_MAP_MOVE_BLOCK (m, x, y) & MOVE_FLY_LOW)
		2046	return 0;
1906		2047
1907	/* Only bother looking on this space if there is something living here */	2048	/* Only bother looking on this space if there is something living here */
1908	if (mflags & P_IS_ALIVE) {	2049	if (mflags & P_IS_ALIVE)
		2050	{
1909	/* search this square for a victim */	2051	/* search this square for a victim */
1910	for(walk=get_map_ob(m,x,y);walk;walk=walk->above)	2052	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 */	2053	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
		2054	{ /* found a victim */
1912	object *disease = arch_to_object(spell->other_arch);	2055	object *disease = arch_to_object (spell->other_arch);
1913		2056
1914	set_owner(disease,op);	2057	disease->set_owner (op);
1915	set_spell_skill(op, caster, spell, disease);	2058	set_spell_skill (op, caster, spell, disease);
1916	disease->stats.exp = 0;	2059	disease->stats.exp = 0;
1917	disease->level = caster_level(caster, spell);	2060	disease->level = caster_level (caster, spell);
1918		2061
1919	/* do level adjustments */	2062	/* do level adjustments */
1920	if(disease->stats.wc)	2063	if (disease->stats.wc)
1921	disease->stats.wc += dur_mod/2;	2064	disease->stats.wc += dur_mod / 2;
1922		2065
1923	if(disease->magic> 0)	2066	if (disease->magic > 0)
1924	disease->magic += dur_mod/4;	2067	disease->magic += dur_mod / 4;
1925		2068
1926	if(disease->stats.maxhp>0)	2069	if (disease->stats.maxhp > 0)
1927	disease->stats.maxhp += dur_mod;	2070	disease->stats.maxhp += dur_mod;
1928		2071
1929	if(disease->stats.maxgrace>0)	2072	if (disease->stats.maxgrace > 0)
1930	disease->stats.maxgrace += dur_mod;	2073	disease->stats.maxgrace += dur_mod;
1931		2074
1932	if(disease->stats.dam) {	2075	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		2076	{
1949	if(disease->stats.ac)	2077	if (disease->stats.dam > 0)
1950	disease->stats.ac += dam_mod;	2078	disease->stats.dam += dam_mod;
1951		2079	else
1952	if(disease->last_eat)
1953	disease->last_eat -= dam_mod;
1954
1955	if(disease->stats.hp)
1956	disease->stats.hp -= dam_mod;	2080	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	}	2081	}
1974	free_object(disease);	2082
		2083	if (disease->last_sp)
		2084	{
		2085	disease->last_sp -= 2 * dam_mod;
		2086	if (disease->last_sp < 1)
		2087	disease->last_sp = 1;
1975	}	2088	}
		2089
		2090	if (disease->stats.maxsp)
		2091	{
		2092	if (disease->stats.maxsp > 0)
		2093	disease->stats.maxsp += dam_mod;
		2094	else
		2095	disease->stats.maxsp -= dam_mod;
		2096	}
		2097
		2098	if (disease->stats.ac)
		2099	disease->stats.ac += dam_mod;
		2100
		2101	if (disease->last_eat)
		2102	disease->last_eat -= dam_mod;
		2103
		2104	if (disease->stats.hp)
		2105	disease->stats.hp -= dam_mod;
		2106
		2107	if (disease->stats.sp)
		2108	disease->stats.sp -= dam_mod;
		2109
		2110	if (infect_object (walk, disease, 1))
		2111	{
		2112	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
		2113
		2114	disease->destroy (); /* don't need this one anymore */
		2115	walk->map->insert (get_archetype (ARCH_DETECT_MAGIC), x, y, op);
		2116	return 1;
		2117	}
		2118
		2119	disease->destroy ();
		2120	}
1976	} /* if living creature */	2121	} /* if living creature */
1977	} /* for range of spaces */	2122	} /* for range of spaces */
		2123
1978	new_draw_info(NDI_UNIQUE,0,op,"No one caught anything!");	2124	new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
1979	return 1;	2125	return 1;
1980	}	2126	}

Diff Legend

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