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.29 by root, Mon Jan 29 16:11:48 2007 UTC

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

Diff Legend

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