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

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.79 by root, Thu Jan 1 16:05:13 2009 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.79 by root, Thu Jan 1 16:05:13 2009 UTC