ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/spell_attack.C

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.5 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.117 by root, Sat Nov 17 23:40:04 2018 UTC

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

Diff Legend

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