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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.5 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.67 by root, Mon Sep 29 10:32:50 2008 UTC

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

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.5 by root, Sat Aug 26 23:36:34 2006 UTC vs. Revision 1.67 by root, Mon Sep 29 10:32:50 2008 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.5 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.67 by root, Mon Sep 29 10:32:50 2008 UTC