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.2 by elmex, Tue Aug 15 15:00:20 2006 UTC vs.
Revision 1.37 by root, Mon May 28 21:28:36 2007 UTC

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

Diff Legend

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