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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:04 2006 UTC vs.
Revision 1.89 by root, Fri Nov 6 12:49:19 2009 UTC

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

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.1 by elmex, Sun Aug 13 17:16:04 2006 UTC vs. Revision 1.89 by root, Fri Nov 6 12:49:19 2009 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:04 2006 UTC vs.
Revision 1.89 by root, Fri Nov 6 12:49:19 2009 UTC