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.3 by elmex, Tue Aug 15 16:19:55 2006 UTC vs.
Revision 1.42 by root, Sun Jul 1 05:00:20 2007 UTC

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

Diff Legend

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