[ViewVC] Diff of: cvs/deliantra/server/server/spell

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.58 by root, Sat May 17 14:57:23 2008 UTC

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

Diff Legend

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

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.58 by root, Sat May 17 14:57:23 2008 UTC

Diff Legend

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.58 by root, Sat May 17 14:57:23 2008 UTC