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.42 by root, Sun Jul 1 05:00:20 2007 UTC vs.
Revision 1.104 by root, Sun Apr 11 04:41:44 2010 UTC

1	/*	1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002-2003 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Crossfire TRT is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/* This file contains all the spell attack code. Grouping this code	25	/* This file contains all the spell attack code. Grouping this code
25	* together should hopefully make it easier to find the relevent bits	26	* together should hopefully make it easier to find the relevent bits
26	* of code	27	* of code
…		…
36	/* 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
37	* 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)
38	* but moved here so it could be applied to bolts too	39	* but moved here so it could be applied to bolts too
39	* op is the spell object.	40	* op is the spell object.
40	*/	41	*/
41		42	static void
42	void
43	check_spell_knockback (object *op)	43	check_spell_knockback (object *op)
44	{	44	{
45	object *tmp, *tmp2; /* object on the map */
46	int weight_move;	45	int weight_move;
47	int frictionmod = 2; /*poor man's physics - multipy targets weight by this amount */	46	int frictionmod = 2; /*poor man's physics - multipy targets weight by this amount */
48		47
49	if (!op->weight)	48	if (!op->weight)
50	{ /*shouldn't happen but if cone object has no weight drop out */	49	{ /*shouldn't happen but if cone object has no weight drop out */
…		…
55	{	54	{
56	weight_move = op->weight + (op->weight * op->level) / 3;	55	weight_move = op->weight + (op->weight * op->level) / 3;
57	/*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */	56	/*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */
58	}	57	}
59		58
60	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	59	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
61	{	60	{
62	int num_sections = 1;	61	int num_sections = 1;
63		62
64	/* don't move DM */	63	/* don't move DM */
65	if (QUERY_FLAG (tmp, FLAG_WIZ))	64	if (tmp->flag [FLAG_WIZ])
66	return;	65	return;
67		66
68	/* don't move parts of objects */	67	/* don't move parts of objects */
69	if (tmp->head)	68	if (tmp->head)
70	continue;	69	continue;
71		70
72	/* don't move floors or immobile objects */	71	/* don't move floors or immobile objects */
73	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))	72	if (tmp->flag [FLAG_IS_FLOOR] || (!tmp->flag [FLAG_ALIVE] && tmp->flag [FLAG_NO_PICK]))
74	continue;	73	continue;
75		74
76	/* count the object's sections */	75	/* count the object's sections */
77	for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more)	76	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
78	num_sections++;	77	num_sections++;
79		78
80	/* I'm not sure if it makes sense to divide by num_sections - bigger	79	/* I'm not sure if it makes sense to divide by num_sections - bigger
81	* objects should be harder to move, and we are moving the entire	80	* objects should be harder to move, and we are moving the entire
82	* object, not just the head, so the total weight should be relevant.	81	* object, not just the head, so the total weight should be relevant.
…		…
94	* also be safe for objects.	93	* also be safe for objects.
95	* This does return if successful or not, but	94	* This does return if successful or not, but
96	* I don't see us doing anything useful with that information	95	* I don't see us doing anything useful with that information
97	* right now.	96	* right now.
98	*/	97	*/
99	move_object (tmp, absdir (op->stats.sp));	98	tmp->move (absdir (op->stats.sp));
100	}	99	}
101		100
102	}	101	}
103	}	102	}
104		103
…		…
106	*	105	*
107	* BOLT CODE	106	* BOLT CODE
108	*	107	*
109	***************************************************************************/	108	***************************************************************************/
110		109
111	/* Causes op to fork. op is the original bolt, tmp	110	/* Causes op to fork. op is the original bolt, tmp
112	* is the first piece of the fork.	111	* is the first piece of the fork.
113	*/	112	*/
114		113	static void
115	void
116	forklightning (object *op, object *tmp)	114	forklightning (object *op, object *tmp)
117	{	115	{
118	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */	116	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
119	int t_dir; /* stores temporary dir calculation */	117	int t_dir; /* stores temporary dir calculation */
120	maptile *m;	118	maptile *m;
…		…
151	new_bolt->duration++;	149	new_bolt->duration++;
152	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */	150	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
153	new_bolt->stats.dam++;	151	new_bolt->stats.dam++;
154	tmp->stats.dam /= 2; /* reduce father bolt damage */	152	tmp->stats.dam /= 2; /* reduce father bolt damage */
155	tmp->stats.dam++;	153	tmp->stats.dam++;
		154
156	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))	155	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
157	update_turn_face (new_bolt);	156	update_turn_face (new_bolt);
158	}	157	}
159		158
160	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,	159	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
161	* and checks for various things that may stop it.	160	* and checks for various things that may stop it.
162	*/	161	*/
163
164	void	162	void
165	move_bolt (object *op)	163	move_bolt (object *op)
166	{	164	{
167	int mflags;	165	int mflags;
168	sint16 x, y;	166	sint16 x, y;
169	maptile *m;	167	maptile *m;
170		168
171	if (--op->duration < 0)	169	if (--op->duration < 0)
172	{	170	{
173	op->destroy ();	171	op->drop_and_destroy ();
174	return;	172	return;
175	}	173	}
176		174
177	hit_map (op, 0, op->attacktype, 1);	175	hit_map (op, 0, op->attacktype, 1);
178		176
…		…
196	* on the space. So only call reflwall if we think the data it returns	194	* on the space. So only call reflwall if we think the data it returns
197	* will be useful.	195	* will be useful.
198	*/	196	*/
199	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) || ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))	197	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) || ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))
200	{	198	{
201	if (!QUERY_FLAG (op, FLAG_REFLECTING))	199	if (!op->flag [FLAG_REFLECTING])
202	return;	200	return;
203		201
204	/* Since walls don't run diagonal, if the bolt is in	202	/* Since walls don't run diagonal, if the bolt is in
205	* one of 4 main directions, it just reflects back in the	203	* one of 4 main directions, it just reflects back in the
206	* opposite direction. However, if the bolt is travelling	204	* opposite direction. However, if the bolt is travelling
…		…
251	tmp->duration++;	249	tmp->duration++;
252		250
253	/* New forking code. Possibly create forks of this object	251	/* New forking code. Possibly create forks of this object
254	* going off in other directions.	252	* going off in other directions.
255	*/	253	*/
256	if (rndm (0, 99) < tmp->stats.Dex)	254	if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
257	{ /* stats.Dex % of forking */	255	forklightning (op, tmp); /* stats.Dex % of forking */
258	forklightning (op, tmp);
259	}
260		256
261	/* In this way, the object left behind sticks on the space, but	257	/* In this way, the object left behind sticks on the space, but
262	* doesn't create any bolts that continue to move onward.	258	* doesn't create any bolts that continue to move onward.
263	*/	259	*/
264	op->range = 0;	260	op->range = 0;
…		…
281	int mflags;	277	int mflags;
282		278
283	if (!spob->other_arch)	279	if (!spob->other_arch)
284	return 0;	280	return 0;
285		281
286	tmp = arch_to_object (spob->other_arch);	282	tmp = spob->other_arch->instance ();
287	if (tmp == NULL)	283	if (tmp == NULL)
288	return 0;	284	return 0;
289		285
290	/* peterm: level dependency for bolts */	286	/* peterm: level dependency for bolts */
291	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);	287	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
292	tmp->attacktype = spob->attacktype;	288	tmp->attacktype = spob->attacktype;
		289
293	if (spob->slaying)	290	if (spob->slaying)
294	tmp->slaying = spob->slaying;	291	tmp->slaying = spob->slaying;
		292
295	tmp->range = spob->range + SP_level_range_adjust (caster, spob);	293	tmp->range = spob->range + SP_level_range_adjust (caster, spob);
296	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);	294	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
297	tmp->stats.Dex = spob->stats.Dex;	295	tmp->stats.Dex = spob->stats.Dex;
298	tmp->stats.Con = spob->stats.Con;	296	tmp->stats.Con = spob->stats.Con;
299		297
300	tmp->direction = dir;	298	tmp->direction = dir;
301	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	299	if (tmp->flag [FLAG_IS_TURNABLE])
302	SET_ANIMATION (tmp, dir);	300	SET_ANIMATION (tmp, dir);
303		301
304	tmp->set_owner (op);	302	tmp->set_owner (op);
305	set_spell_skill (op, caster, spob, tmp);	303	set_spell_skill (op, caster, spob, tmp);
306		304
…		…
310		308
311	maptile *newmap;	309	maptile *newmap;
312	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);	310	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
313	if (mflags & P_OUT_OF_MAP)	311	if (mflags & P_OUT_OF_MAP)
314	{	312	{
315	tmp->destroy ();	313	tmp->drop_and_destroy ();
316	return 0;	314	return 0;
317	}	315	}
318		316
319	tmp->map = newmap;	317	tmp->map = newmap;
320		318
321	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))	319	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
322	{	320	{
323	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	321	if (!tmp->flag [FLAG_REFLECTING])
324	{	322	{
325	tmp->destroy ();	323	tmp->drop_and_destroy ();
326	return 0;	324	return 0;
327	}	325	}
328		326
329	tmp->x = op->x;	327	tmp->x = op->x;
330	tmp->y = op->y;	328	tmp->y = op->y;
…		…
343	* BULLET/BALL CODE	341	* BULLET/BALL CODE
344	*	342	*
345	***************************************************************************/	343	***************************************************************************/
346		344
347	/* expands an explosion. op is a piece of the	345	/* expands an explosion. op is a piece of the
348	* explosion - this expans it in the different directions.	346	* explosion - this expands it in the different directions.
349	* At least that is what I think this does.	347	* At least that is what I think this does.
350	*/	348	*/
351	void	349	void
352	explosion (object *op)	350	explosion (object *op)
353	{	351	{
…		…
391		389
392	/* Causes an object to explode, eg, a firebullet,	390	/* Causes an object to explode, eg, a firebullet,
393	* poison cloud ball, etc. op is the object to	391	* poison cloud ball, etc. op is the object to
394	* explode.	392	* explode.
395	*/	393	*/
396	void	394	static void
397	explode_bullet (object *op)	395	explode_bullet (object *op)
398	{	396	{
399	object *tmp, *owner;	397	object *tmp, *owner;
400		398
401	if (op->other_arch == NULL)	399	if (!op->other_arch)
402	{	400	{
403	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");	401	LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
404	op->destroy ();	402	op->destroy ();
405	return;	403	return;
406	}	404	}
407		405
408	if (op->env)	406	if (op->env)
409	{	407	{
410	object *env = object_get_env_recursive (op);	408	object *env = op->outer_env ();
		409
411	if (env->map == NULL || out_of_map (env->map, env->x, env->y))	410	if (!env->map || out_of_map (env->map, env->x, env->y))
412	{	411	{
413	LOG (llevError, "BUG: explode_bullet(): env out of map\n");	412	LOG (llevError, "BUG: explode_bullet(): env out of map\n");
414	op->destroy ();	413	op->destroy ();
415	return;	414	return;
416	}	415	}
…		…
434	}	433	}
435		434
436	if (op->attacktype)	435	if (op->attacktype)
437	{	436	{
438	hit_map (op, 0, op->attacktype, 1);	437	hit_map (op, 0, op->attacktype, 1);
		438
439	if (op->destroyed ())	439	if (op->destroyed ())
440	return;	440	return;
441	}	441	}
442		442
443	/* other_arch contains what this explodes into */	443	/* other_arch contains what this explodes into */
444	tmp = arch_to_object (op->other_arch);	444	tmp = op->other_arch->instance ();
445		445
446	tmp->set_owner (op);	446	tmp->set_owner (op);
447	tmp->skill = op->skill;	447	tmp->skill = op->skill;
448		448
449	owner = op->owner;	449	owner = op->owner;
450		450
451	if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))	451	if ((tmp->attacktype & AT_HOLYWORD
		452	|| tmp->attacktype & AT_GODPOWER)
		453	&& owner
		454	&& !tailor_god_spell (tmp, owner))
452	{	455	{
453	op->destroy ();	456	op->destroy ();
454	return;	457	return;
455	}	458	}
456		459
…		…
483		486
484	/* Prevent recursion */	487	/* Prevent recursion */
485	op->move_on = 0;	488	op->move_on = 0;
486		489
487	tmp->insert_at (op, op);	490	tmp->insert_at (op, op);
		491	tmp->play_sound (tmp->sound);
		492
488	/* remove the firebullet */	493	/* remove the firebullet */
489	op->destroy ();	494	op->destroy ();
490	}	495	}
491		496
492	/* 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
…		…
516	if (!(mflags & P_IS_ALIVE))	521	if (!(mflags & P_IS_ALIVE))
517	return;	522	return;
518		523
519	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	524	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
520	{	525	{
521	if (QUERY_FLAG (tmp, FLAG_ALIVE))	526	if (tmp->flag [FLAG_ALIVE])
522	{	527	{
523	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	528	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
		529
		530	// TODO: can't understand the following if's
524	if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)	531	if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
525	{	532	{
526	if (!QUERY_FLAG (op, FLAG_REMOVED))	533	if (!op->flag [FLAG_REMOVED])
527	{	534	{
528	op->destroy ();	535	op->destroy ();
529	return;	536	return;
530	}	537	}
531	}	538	}
…		…
539	* fired arches (eg, bolts).	546	* fired arches (eg, bolts).
540	*/	547	*/
541	void	548	void
542	move_bullet (object *op)	549	move_bullet (object *op)
543	{	550	{
544	sint16 new_x, new_y;
545	int mflags;
546	maptile *m;
547
548	#if 0	551	#if 0
549	/* We need a better general purpose way to do this */	552	/* We need a better general purpose way to do this */
550		553
551	/* peterm: added to make comet leave a trail of burnouts	554	/* peterm: added to make comet leave a trail of burnouts
552	it's an unadulterated hack, but the effect is cool. */	555	it's an unadulterated hack, but the effect is cool. */
…		…
567	op->destroy ();	570	op->destroy ();
568		571
569	return;	572	return;
570	}	573	}
571		574
572	new_x = op->x + DIRX (op);	575	mapxy pos (op);
573	new_y = op->y + DIRY (op);	576	pos.move (op->direction);
574	m = op->map;
575	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
576		577
577	if (mflags & P_OUT_OF_MAP)	578	if (!pos.normalise ())
578	{	579	{
579	op->destroy ();	580	op->destroy ();
580	return;	581	return;
581	}	582	}
582		583
583	if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))	584	mapspace &ms = pos.ms ();
		585
		586	ms.update ();
		587
		588	if (!op->direction || OB_TYPE_MOVE_BLOCK (op, ms.move_block))
584	{	589	{
585	if (op->other_arch)	590	if (op->other_arch)
586	explode_bullet (op);	591	explode_bullet (op);
587	else	592	else
588	op->destroy ();	593	op->destroy ();
589		594
590	return;	595	return;
591	}	596	}
592		597
593	if (!(op = m->insert (op, new_x, new_y, op)))	598	if (!(op = pos.insert (op, op)))
594	return;	599	return;
595		600
596	if (reflwall (op->map, op->x, op->y, op))	601	if (reflwall (op->map, op->x, op->y, op))
597	{	602	{
598	op->direction = absdir (op->direction + 4);	603	op->direction = absdir (op->direction + 4);
…		…
617	int mflags;	622	int mflags;
618		623
619	if (!spob->other_arch)	624	if (!spob->other_arch)
620	return 0;	625	return 0;
621		626
622	tmp = arch_to_object (spob->other_arch);	627	tmp = spob->other_arch->instance ();
623	if (tmp == NULL)	628	if (!tmp)
624	return 0;	629	return 0;
625		630
626	/* peterm: level dependency for bolts */	631	/* peterm: level dependency for bolts */
627	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);	632	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
628	tmp->attacktype = spob->attacktype;	633	tmp->attacktype = spob->attacktype;
629	if (spob->slaying)	634	if (spob->slaying)
630	tmp->slaying = spob->slaying;	635	tmp->slaying = spob->slaying;
631		636
…		…
635	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);	640	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
636	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);	641	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
637	tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);	642	tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);
638		643
639	tmp->direction = dir;	644	tmp->direction = dir;
640	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	645	if (tmp->flag [FLAG_IS_TURNABLE])
641	SET_ANIMATION (tmp, dir);	646	SET_ANIMATION (tmp, dir);
642		647
643	tmp->set_owner (op);	648	tmp->set_owner (op);
644	set_spell_skill (op, caster, spob, tmp);	649	set_spell_skill (op, caster, spob, tmp);
645		650
646	tmp->x = op->x + freearr_x[dir];	651	tmp->x = op->x + freearr_x[dir];
647	tmp->y = op->y + freearr_y[dir];	652	tmp->y = op->y + freearr_y[dir];
648	tmp->map = op->map;	653	tmp->map = op->map;
649		654
650	maptile *newmap;	655	maptile *newmap;
651	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);	656	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
652	if (mflags & P_OUT_OF_MAP)	657	if (mflags & P_OUT_OF_MAP)
…		…
655	return 0;	660	return 0;
656	}	661	}
657		662
658	tmp->map = newmap;	663	tmp->map = newmap;
659		664
		665	// in case the bullet has direction 0 we explode it in place.
		666	// direction 0 is possible for instance when a poison cloud trap springs.
		667	if (tmp->direction == 0)
		668	{
		669	if (tmp->other_arch
		670	&& (tmp = tmp->insert_at (tmp, op))) // insert before explode cleanly
		671	explode_bullet (tmp); // explode object will/should remove tmp
		672	else
		673	tmp->destroy ();
		674
		675	return 0;
		676	}
		677
660	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))	678	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
661	{	679	{
662	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	680	if (!tmp->flag [FLAG_REFLECTING])
663	{	681	{
664	tmp->destroy ();	682	tmp->destroy ();
665	return 0;	683	return 0;
666	}	684	}
667		685
…		…
682	* CONE RELATED FUNCTIONS	700	* CONE RELATED FUNCTIONS
683	*	701	*
684	*****************************************************************************/	702	*****************************************************************************/
685		703
686	/* drops an object based on what is in the cone's "other_arch" */	704	/* drops an object based on what is in the cone's "other_arch" */
687	void	705	static void
688	cone_drop (object *op)	706	cone_drop (object *op)
689	{	707	{
690	object *new_ob = arch_to_object (op->other_arch);	708	object *new_ob = op->other_arch->instance ();
691		709
692	new_ob->level = op->level;	710	new_ob->level = op->level;
693	new_ob->set_owner (op->owner);	711	new_ob->set_owner (op->owner);
694		712
695	/* preserve skill ownership */	713	/* preserve skill ownership */
…		…
702	/* move_cone: causes cone object 'op' to move a space/hit creatures */	720	/* move_cone: causes cone object 'op' to move a space/hit creatures */
703		721
704	void	722	void
705	move_cone (object *op)	723	move_cone (object *op)
706	{	724	{
707	int i;
708
709	/* if no map then hit_map will crash so just ignore object */	725	/* if no map then hit_map will crash so just ignore object */
710	if (!op->map)	726	if (!op->map)
711	{	727	{
712	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");	728	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
713	op->set_speed (0);	729	op->set_speed (0);
714	return;	730	return;
715	}	731	}
716		732
717	/* lava saves it's life, but not yours :) */	733	/* lava saves it's life, but not yours :) */
718	if (QUERY_FLAG (op, FLAG_LIFESAVE))	734	if (op->flag [FLAG_LIFESAVE])
719	{	735	{
720	hit_map (op, 0, op->attacktype, 0);	736	hit_map (op, 0, op->attacktype, 0);
721	return;	737	return;
722	}	738	}
723		739
…		…
733	}	749	}
734	#endif	750	#endif
735		751
736	hit_map (op, 0, op->attacktype, 0);	752	hit_map (op, 0, op->attacktype, 0);
737		753
		754	if (!op->is_on_map ())
		755	return;
		756
738	/* Check to see if we should push anything.	757	/* Check to see if we should push anything.
739	* Spell objects with weight push whatever they encounter to some	758	* Spell objects with weight push whatever they encounter to some
740	* degree.	759	* degree.
741	*/	760	*/
742	if (op->weight)	761	if (op->weight)
		762	{
743	check_spell_knockback (op);	763	check_spell_knockback (op);
744		764
745	if (op->destroyed ())	765	if (!op->is_on_map ())
746	return;	766	return;
		767	}
747		768
748	if ((op->duration--) < 0)	769	if (op->duration-- < 0)
749	{	770	{
750	op->destroy ();	771	op->destroy ();
751	return;	772	return;
752	}	773	}
753	/* Object has hit maximum range, so don't have it move	774	/* Object has hit maximum range, so don't have it move
…		…
758	{	779	{
759	op->range = 0; /* just so it doesn't wrap */	780	op->range = 0; /* just so it doesn't wrap */
760	return;	781	return;
761	}	782	}
762		783
763	for (i = -1; i < 2; i++)	784	for (int i = -1; i <= 1; i++)
764	{	785	{
765	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];	786	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
766		787
767	if (ok_to_put_more (op->map, x, y, op, op->attacktype))	788	if (ok_to_put_more (op->map, x, y, op, op->attacktype))
768	{	789	{
…		…
799	MoveType movetype;	820	MoveType movetype;
800		821
801	if (!spell->other_arch)	822	if (!spell->other_arch)
802	return 0;	823	return 0;
803		824
804	if (op->type == PLAYER && QUERY_FLAG (op, FLAG_UNDEAD) && op->attacktype & AT_TURN_UNDEAD)	825	if (op->type == PLAYER && op->flag [FLAG_UNDEAD] && op->attacktype & AT_TURN_UNDEAD)
805	{	826	{
806	new_draw_info (NDI_UNIQUE, 0, op, "Your undead nature prevents you from turning undead!");	827	op->failmsg ("Your undead nature prevents you from turning undead!");
807	return 0;	828	return 0;
808	}	829	}
809		830
810	if (!dir)	831	if (!dir)
811	{	832	{
…		…
819	*/	840	*/
820	movetype = spell->other_arch->move_type;	841	movetype = spell->other_arch->move_type;
821		842
822	for (i = range_min; i <= range_max; i++)	843	for (i = range_min; i <= range_max; i++)
823	{	844	{
824	sint16 x, y, d;	845	sint16 x, y;
825		846
826	/* We can't use absdir here, because it never returns	847	/* We can't use absdir here, because it never returns
827	* 0. If this is a rune, we want to hit the person on top	848	* 0. If this is a rune, we want to hit the person on top
828	* of the trap (d==0). If it is not a rune, then we don't want	849	* of the trap (d==0). If it is not a rune, then we don't want
829	* to hit that person.	850	* to hit that person.
830	*/	851	*/
831	d = dir + i;	852	int d = dir ? absdir (dir + i) : i;
832	while (d < 0)
833	d += 8;
834	while (d > 8)
835	d -= 8;
836		853
837	/* If it's not a rune, we don't want to blast the caster.	854	/* If it's not a rune, we don't want to blast the caster.
838	* In that case, we have to see - if dir is specified,	855	* In that case, we have to see - if dir is specified,
839	* turn this into direction 8. If dir is not specified (all	856	* turn this into direction 8. If dir is not specified (all
840	* direction) skip - otherwise, one line would do more damage	857	* direction) skip - otherwise, one line would do more damage
…		…
857		874
858	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	875	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
859	continue;	876	continue;
860		877
861	success = 1;	878	success = 1;
862	tmp = arch_to_object (spell->other_arch);	879	tmp = spell->other_arch->instance ();
863	tmp->set_owner (op);	880	tmp->set_owner (op);
864	set_spell_skill (op, caster, spell, tmp);	881	set_spell_skill (op, caster, spell, tmp);
865	tmp->level = caster_level (caster, spell);	882	tmp->level = casting_level (caster, spell);
866	tmp->attacktype = spell->attacktype;	883	tmp->attacktype = spell->attacktype;
867		884
868	/* holy word stuff */	885	/* holy word stuff */
869	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))	886	if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
870	if (!tailor_god_spell (tmp, op))	887	if (!tailor_god_spell (tmp, op))
…		…
935	* op is the original bomb object.	952	* op is the original bomb object.
936	*/	953	*/
937	void	954	void
938	animate_bomb (object *op)	955	animate_bomb (object *op)
939	{	956	{
940	int i;
941	object *env, *tmp;
942
943	if (op->state != NUM_ANIMATIONS (op) - 1)	957	if (op->state != NUM_ANIMATIONS (op) - 1)
944	return;	958	return;
945		959
946	env = object_get_env_recursive (op);	960	object *env = op->outer_env ();
947		961
948	if (op->env)	962	if (op->env)
949	{	963	{
950	if (env->map == NULL)	964	if (!env->map)
951	return;	965	return;
952
953	if (env->type == PLAYER)
954	esrv_del_item (env->contr, op->count);
955		966
956	if (!(op = op->insert_at (env, op)))	967	if (!(op = op->insert_at (env, op)))
957	return;	968	return;
958	}	969	}
959		970
960	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding	971	// elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
961	// on a safe map. I don't like this special casing, but it seems to be neccessary	972	// on a safe map. I don't like this special casing, but it seems to be neccessary
962	// as bombs can be carried.	973	// as bombs can be carried.
963	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	974	if (op->ms ().flags () & P_SAFE)
964	{	975	{
965	op->destroy ();	976	op->destroy ();
966	return;	977	return;
967	}	978	}
968		979
…		…
970	* but using the cast_bullet isn't really feasible,	981	* but using the cast_bullet isn't really feasible,
971	* so just set up the appropriate values.	982	* so just set up the appropriate values.
972	*/	983	*/
973	if (archetype *at = archetype::find (SPLINT))	984	if (archetype *at = archetype::find (SPLINT))
974	{	985	{
975	for (i = 1; i < 9; i++)	986	for (int i = 1; i < 9; i++)
976	{	987	{
977	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))	988	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
978	continue;	989	continue;
979		990
980	tmp = arch_to_object (at);	991	object *tmp = at->instance ();
981	tmp->direction = i;	992	tmp->direction = i;
982	tmp->range = op->range;	993	tmp->range = op->range;
983	tmp->stats.dam = op->stats.dam;	994	tmp->stats.dam = op->stats.dam;
984	tmp->duration = op->duration;	995	tmp->duration = op->duration;
985	tmp->attacktype = op->attacktype;	996	tmp->attacktype = op->attacktype;
986	tmp->set_owner (op);	997	tmp->set_owner (op);
987	if (op->skill && op->skill != tmp->skill)	998	if (op->skill && op->skill != tmp->skill)
988	tmp->skill = op->skill;	999	tmp->skill = op->skill;
989		1000
990	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	1001	if (tmp->flag [FLAG_IS_TURNABLE])
991	SET_ANIMATION (tmp, i);	1002	SET_ANIMATION (tmp, i);
992		1003
993	op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);	1004	op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);
994	move_bullet (tmp);	1005	move_bullet (tmp);
995	}	1006	}
…		…
999	}	1010	}
1000		1011
1001	int	1012	int
1002	create_bomb (object *op, object *caster, int dir, object *spell)	1013	create_bomb (object *op, object *caster, int dir, object *spell)
1003	{	1014	{
1004
1005	object *tmp;	1015	object *tmp;
1006	int mflags;	1016	int mflags;
1007	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];	1017	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1008	maptile *m;	1018	maptile *m;
1009		1019
1010	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);	1020	mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
		1021
		1022	// when creating a bomb below ourself it should always work, even
		1023	// when movement is blocked (somehow we got here, somehow we are here,
		1024	// so we should also be able to make a bomb here). (originally added
		1025	// to fix create bomb traps in doors, which cast with dir=0).
		1026	if (dir)
		1027	{
1011	if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))	1028	if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1012	{	1029	{
1013	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1030	op->failmsg ("There is something in the way.");
1014	return 0;	1031	return 0;
		1032	}
1015	}	1033	}
1016	tmp = arch_to_object (spell->other_arch);	1034
		1035	tmp = spell->other_arch->instance ();
1017		1036
1018	/* level dependencies for bomb */	1037	/* level dependencies for bomb */
1019	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1038	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1020	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1039	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1021	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1040	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
1041	* dir is the direction to look in.	1060	* dir is the direction to look in.
1042	* range is how far out to look.	1061	* range is how far out to look.
1043	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.	1062	* type is the type of spell - either SPELL_MANA or SPELL_GRACE.
1044	* this info is used for blocked magic/unholy spaces.	1063	* this info is used for blocked magic/unholy spaces.
1045	*/	1064	*/
1046	object *	1065	static object *
1047	get_pointed_target (object *op, int dir, int range, int type)	1066	get_pointed_target (object *op, int dir, int range, int type)
1048	{	1067	{
1049	object *target;	1068	object *target;
1050	sint16 x, y;	1069	sint16 x, y;
1051	int dist, mflags;	1070	int dist, mflags;
…		…
1070	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1089	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1071	return NULL;	1090	return NULL;
1072		1091
1073	if (mflags & P_IS_ALIVE)	1092	if (mflags & P_IS_ALIVE)
1074	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)	1093	for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1075	if (QUERY_FLAG (target, FLAG_MONSTER))	1094	if (target->flag [FLAG_MONSTER])
1076	return target;	1095	return target;
1077	}	1096	}
1078		1097
1079	return NULL;	1098	return NULL;
1080	}	1099	}
…		…
1085	* op = player	1104	* op = player
1086	* caster = object casting the spell.	1105	* caster = object casting the spell.
1087	* dir = direction being cast	1106	* dir = direction being cast
1088	* spell = spell object	1107	* spell = spell object
1089	*/	1108	*/
1090
1091	int	1109	int
1092	cast_smite_spell (object *op, object *caster, int dir, object *spell)	1110	cast_smite_spell (object *op, object *caster, int dir, object *spell)
1093	{	1111	{
1094	object *effect, *target;	1112	object *effect, *target;
1095	object *god = find_god (determine_god (op));	1113	object *god = find_god (determine_god (op));
…		…
1105	* interesting spell.	1123	* interesting spell.
1106	* if it is a cleric spell, you need a god, and the creature	1124	* if it is a cleric spell, you need a god, and the creature
1107	* can't be friendly to your god.	1125	* can't be friendly to your god.
1108	*/	1126	*/
1109		1127
1110	if (!target || QUERY_FLAG (target, FLAG_REFL_SPELL)	1128	if (!target
		1129	|| target->flag [FLAG_REFL_SPELL]
1111	|| (!god && spell->stats.grace)	1130	|| (!god && spell->stats.grace)
1112	|| (target->title && god && !strcmp (target->title, god->name)) || (target->race && god && strstr (target->race, god->race)))	1131	|| (god && target->title == god->name)
		1132	|| (god && target->race.contains (god->race)))
1113	{	1133	{
1114	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1134	op->failmsg ("Your request is unheeded.");
1115	return 0;	1135	return 0;
1116	}	1136	}
1117		1137
1118	if (spell->other_arch)	1138	if (spell->other_arch)
1119	effect = arch_to_object (spell->other_arch);	1139	effect = spell->other_arch->instance ();
1120	else	1140	else
1121	return 0;	1141	return 0;
1122		1142
1123	/* tailor the effect by priest level and worshipped God */	1143	/* tailor the effect by priest level and worshipped God */
1124	effect->level = caster_level (caster, spell);	1144	effect->level = casting_level (caster, spell);
1125	effect->attacktype = spell->attacktype;	1145	effect->attacktype = spell->attacktype;
1126	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))	1146	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1127	{	1147	{
1128	if (tailor_god_spell (effect, op))	1148	if (tailor_god_spell (effect, op))
1129	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));	1149	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", (const char *)determine_god (op));
1130	else	1150	else
1131	{	1151	{
1132	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1152	op->failmsg ("Your request is ignored.");
1133	return 0;	1153	return 0;
1134	}	1154	}
1135	}	1155	}
1136		1156
1137	/* size of the area of destruction */	1157	/* size of the area of destruction */
…		…
1141	if (effect->attacktype & AT_DEATH)	1161	if (effect->attacktype & AT_DEATH)
1142	{	1162	{
1143	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1163	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1144		1164
1145	/* casting death spells at undead isn't a good thing */	1165	/* casting death spells at undead isn't a good thing */
1146	if (QUERY_FLAG (target, FLAG_UNDEAD))	1166	if (target->flag [FLAG_UNDEAD])
1147	{	1167	{
1148	if (random_roll (0, 2, op, PREFER_LOW))	1168	if (random_roll (0, 2, op, PREFER_LOW))
1149	{	1169	{
1150	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1170	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1151	effect->x = op->x;	1171	effect->x = op->x;
…		…
1173	effect->insert_at (target, op);	1193	effect->insert_at (target, op);
1174		1194
1175	return 1;	1195	return 1;
1176	}	1196	}
1177		1197
1178
1179	/****************************************************************************	1198	/****************************************************************************
1180	*	1199	*
1181	* MAGIC MISSILE code.	1200	* MAGIC MISSILE code.
1182	* note that the fire_bullet is used to fire the missile. The	1201	* note that the fire_bullet is used to fire the missile. The
1183	* code here is just to move the missile.	1202	* code here is just to move the missile.
…		…
1185		1204
1186	/* op is a missile that needs to be moved */	1205	/* op is a missile that needs to be moved */
1187	void	1206	void
1188	move_missile (object *op)	1207	move_missile (object *op)
1189	{	1208	{
1190	int i, mflags;
1191	object *owner;
1192	sint16 new_x, new_y;
1193	maptile *m;
1194
1195	if (op->range-- <= 0)	1209	if (op->range-- <= 0)
1196	{	1210	{
		1211	op->drop_and_destroy ();
		1212	return;
		1213	}
		1214
		1215	mapxy pos (op);
		1216	pos.move (op->direction);
		1217
		1218	if (!pos.normalise ())
		1219	{
1197	op->destroy ();	1220	op->destroy ();
1198	return;	1221	return;
1199	}	1222	}
1200		1223
1201	owner = op->owner;	1224	mapspace &ms = pos.ms ();
1202	#if 0
1203	/* It'd make things nastier if this wasn't here - spells cast by
1204	* monster that are then killed would continue to survive
1205	*/
1206	if (owner == NULL)
1207	{
1208	op->destroy ();
1209	return;
1210	}
1211	#endif
1212		1225
1213	new_x = op->x + DIRX (op);	1226	if (ms.flags () & P_IS_ALIVE || ms.blocks (op))
1214	new_y = op->y + DIRY (op);
1215
1216	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1217
1218	if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1219	{	1227	{
1220	hit_map (op, op->direction, AT_MAGIC, 1);	1228	hit_map (op, op->direction, AT_MAGIC, 1);
1221	/* Basically, missile only hits one thing then goes away.	1229	/* Basically, missile only hits one thing then goes away.
1222	* we need to remove it if someone hasn't already done so.	1230	* we need to remove it if someone hasn't already done so.
1223	*/	1231	*/
1224	if (!op->destroyed ())
1225	op->destroy ();
1226
1227	return;
1228	}
1229
1230	op->remove ();
1231
1232	if (!op->direction || (mflags & P_OUT_OF_MAP))
1233	{
1234	op->destroy ();	1232	op->destroy ();
1235	return;	1233	return;
1236	}	1234	}
1237		1235
		1236	if (!op->direction)
		1237	{
		1238	op->destroy ();
		1239	return;
		1240	}
		1241
1238	i = spell_find_dir (m, new_x, new_y, op->owner);	1242	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1239	if (i > 0 && i != op->direction)	1243	if (i > 0 && i != op->direction)
1240	{	1244	{
1241	op->direction = i;	1245	op->direction = i;
1242	SET_ANIMATION (op, op->direction);	1246	SET_ANIMATION (op, op->direction);
1243	}	1247	}
1244		1248
1245	m->insert (op, new_x, new_y, op);	1249	pos.insert (op, op);
1246	}	1250	}
1247		1251
1248	/****************************************************************************	1252	/****************************************************************************
1249	* Destruction	1253	* Destruction
1250	****************************************************************************/	1254	****************************************************************************/
…		…
1253	* we do this by creating a force and inserting it in the	1257	* we do this by creating a force and inserting it in the
1254	* object. if time is 0, the object glows permanently. To truely	1258	* object. if time is 0, the object glows permanently. To truely
1255	* make this work for non-living objects, we would have to	1259	* make this work for non-living objects, we would have to
1256	* give them the capability to have an inventory. b.t.	1260	* give them the capability to have an inventory. b.t.
1257	*/	1261	*/
1258		1262	static int
1259	int
1260	make_object_glow (object *op, int radius, int time)	1263	make_object_glow (object *op, int radius, int time)
1261	{	1264	{
1262	object *tmp;
1263
1264	/* some things are unaffected... */	1265	/* some things are unaffected... */
1265	if (op->path_denied & PATH_LIGHT)	1266	if (op->path_denied & PATH_LIGHT)
1266	return 0;	1267	return 0;
1267		1268
1268	tmp = get_archetype (FORCE_NAME);	1269	object *tmp = get_archetype (FORCE_NAME);
1269	tmp->speed = 0.01;	1270	tmp->speed = 0.01;
1270	tmp->stats.food = time;	1271	tmp->stats.food = time;
1271	SET_FLAG (tmp, FLAG_IS_USED_UP);	1272	tmp->set_flag (FLAG_IS_USED_UP);
1272	tmp->glow_radius = radius;	1273	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1273	if (tmp->glow_radius > MAX_LIGHT_RADII)
1274	tmp->glow_radius = MAX_LIGHT_RADII;
1275
1276	tmp->x = op->x;
1277	tmp->y = op->y;
1278	if (tmp->speed < MIN_ACTIVE_SPEED)
1279	tmp->speed = MIN_ACTIVE_SPEED; /* safety */
1280	tmp = insert_ob_in_ob (tmp, op);	1274	tmp = insert_ob_in_ob (tmp, op);
		1275
1281	if (tmp->glow_radius > op->glow_radius)	1276	if (tmp->glow_radius > op->glow_radius)
1282	op->glow_radius = tmp->glow_radius;	1277	op->set_glow_radius (tmp->glow_radius);
1283		1278
1284	if (!tmp->env || op != tmp->env)
1285	{
1286	LOG (llevError, "make_object_glow() failed to insert glowing force in %s\n", &op->name);
1287	return 0;
1288	}
1289	return 1;	1279	return 1;
1290	}	1280	}
1291		1281
1292	int	1282	int
1293	cast_destruction (object *op, object *caster, object *spell_ob)	1283	cast_destruction (object *op, object *caster, object *spell_ob)
1294	{	1284	{
1295	int i, j, range, mflags, friendly = 0, dam, dur;
1296	sint16 sx, sy;
1297	maptile *m;
1298	object *tmp;
1299	const char *skill;
1300
1301	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1285	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1302	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	1286	int dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1303	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1287	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1304	if (QUERY_FLAG (op, FLAG_FRIENDLY) || op->type == PLAYER)
1305	friendly = 1;
1306		1288
1307	/* destruction doesn't use another spell object, so we need	1289	bool friendly = op->flag [FLAG_FRIENDLY] || op->is_player ();
1308	* update op's skill pointer so that exp is properly awarded.
1309	* We do some shortcuts here - since this is just temporary
1310	* and we'll reset the values back, we don't need to go through
1311	* the full share string/free_string route.
1312	*/
1313	skill = op->skill;
1314	if (caster == op)
1315	op->skill = spell_ob->skill;
1316	else if (caster->skill)
1317	op->skill = caster->skill;
1318	else
1319	op->skill = NULL;
1320		1290
1321	op->change_skill (find_skill_by_name (op, op->skill));	1291	dynbuf buf;
1322		1292	unordered_mapwalk (buf, op, -range, -range, range, range)
1323	for (i = -range; i < range; i++)
1324	{	1293	{
1325	for (j = -range; j < range; j++)	1294	mapspace &ms = m->at (nx, ny);
1326	{
1327	m = op->map;
1328	sx = op->x + i;
1329	sy = op->y + j;
1330		1295
1331	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1332	if (mflags & P_OUT_OF_MAP)
1333	continue;
1334
1335	if (mflags & P_IS_ALIVE)	1296	if (ms.flags () & P_IS_ALIVE)
		1297	for (object *next, *tmp = ms.bot; tmp; tmp = next)
1336	{	1298	{
1337	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1299	next = tmp->above;
1338	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1339	break;
1340		1300
1341	if (tmp)	1301	if (tmp->flag [FLAG_ALIVE] || tmp->is_player ())
1342	{	1302	{
1343	if (tmp->head)
1344	tmp = tmp->head;	1303	tmp = tmp->head_ ();
1345		1304
1346	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) ||	1305	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1347	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))	1306	|| (!friendly && (tmp->flag [FLAG_FRIENDLY] || tmp->is_player ())))
1348	{	1307	{
1349	if (spell_ob->subtype == SP_DESTRUCTION)	1308	if (spell_ob->subtype == SP_DESTRUCTION)
1350	{	1309	{
1351	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1310	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
		1311
1352	if (spell_ob->other_arch)	1312	if (spell_ob->other_arch)
1353	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1313	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1354	}	1314	}
1355	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)	1315	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist [ATNR_MAGIC] != 100)
1356	{	1316	{
1357	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1317	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1358	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1318	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1359	}	1319	}
1360	}	1320	}
1361	}	1321	}
1362	}	1322	}
1363	}
1364	}	1323	}
1365		1324
1366	op->skill = skill;
1367	return 1;	1325	return 1;
1368	}	1326	}
1369		1327
1370	/***************************************************************************	1328	/***************************************************************************
1371	*	1329	*
1372	* CURSE	1330	* CURSE
1373	*	1331	*
1374	***************************************************************************/	1332	***************************************************************************/
1375
1376	int	1333	int
1377	cast_curse (object *op, object *caster, object *spell_ob, int dir)	1334	cast_curse (object *op, object *caster, object *spell_ob, int dir)
1378	{	1335	{
1379	object *god = find_god (determine_god (op));	1336	object *god = find_god (determine_god (op));
1380	object *tmp, *force;	1337	object *tmp, *force;
1381		1338
1382	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);	1339	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);
1383	if (!tmp)	1340	if (!tmp)
1384	{	1341	{
1385	new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");	1342	op->failmsg ("There is no one in that direction to curse.");
1386	return 0;	1343	return 0;
1387	}	1344	}
1388		1345
		1346	tmp = tmp->head_ ();
		1347
1389	/* If we've already got a force of this type, don't add a new one. */	1348	/* If we've already got a force of this type, don't add a new one. */
1390	for (force = tmp->inv; force != NULL; force = force->below)	1349	for (force = tmp->inv; force; force = force->below)
1391	{	1350	{
1392	if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)	1351	if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
1393	{	1352	{
1394	if (force->name == spell_ob->name)	1353	if (force->name == spell_ob->name)
1395	{	1354	{
…		…
1401	return 0;	1360	return 0;
1402	}	1361	}
1403	}	1362	}
1404	}	1363	}
1405		1364
1406	if (force == NULL)	1365	if (!force)
1407	{	1366	{
1408	force = get_archetype (FORCE_NAME);	1367	force = get_archetype (FORCE_NAME);
1409	force->subtype = FORCE_CHANGE_ABILITY;	1368	force->subtype = FORCE_CHANGE_ABILITY;
		1369
1410	if (spell_ob->race)	1370	if (spell_ob->race)
1411	force->name = spell_ob->race;	1371	force->name = spell_ob->race;
1412	else	1372	else
1413	force->name = spell_ob->name;	1373	force->name = spell_ob->name;
1414		1374
…		…
1424	{	1384	{
1425	force->duration = duration;	1385	force->duration = duration;
1426	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1386	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1427	}	1387	}
1428	else	1388	else
1429	{
1430	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1389	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1431	}	1390
1432	return 1;	1391	return 1;
1433	}	1392	}
		1393
1434	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1394	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1435	force->speed = 1.f;	1395	force->speed = 1.f;
1436	force->speed_left = -1.f;	1396	force->speed_left = -1.f;
1437	SET_FLAG (force, FLAG_APPLIED);	1397	force->set_flag (FLAG_APPLIED);
1438		1398
1439	if (god)	1399	if (god)
1440	{	1400	{
1441	if (spell_ob->last_grace)	1401	if (spell_ob->last_grace)
1442	force->path_repelled = god->path_repelled;	1402	force->path_repelled = god->path_repelled;
…		…
1455	force->stats.wc = spell_ob->stats.wc;	1415	force->stats.wc = spell_ob->stats.wc;
1456		1416
1457	change_abil (tmp, force); /* Mostly to display any messages */	1417	change_abil (tmp, force); /* Mostly to display any messages */
1458	insert_ob_in_ob (force, tmp);	1418	insert_ob_in_ob (force, tmp);
1459	tmp->update_stats ();	1419	tmp->update_stats ();
		1420
1460	return 1;	1421	return 1;
1461
1462	}	1422	}
1463		1423
1464	/**********************************************************************	1424	/**********************************************************************
1465	* mood change	1425	* mood change
1466	* Arguably, this may or may not be an attack spell. But since it	1426	* Arguably, this may or may not be an attack spell. But since it
…		…
1472	*/	1432	*/
1473	int	1433	int
1474	mood_change (object *op, object *caster, object *spell)	1434	mood_change (object *op, object *caster, object *spell)
1475	{	1435	{
1476	object *tmp, *god, *head;	1436	object *tmp, *god, *head;
1477	int done_one, range, mflags, level, at, best_at;	1437	int done_one, range, level, at, best_at;
1478	sint16 x, y, nx, ny;
1479	maptile *m;
1480	const char *race;	1438	const char *race;
1481		1439
1482	/* We precompute some values here so that we don't have to keep	1440	/* We precompute some values here so that we don't have to keep
1483	* doing it over and over again.	1441	* doing it over and over again.
1484	*/	1442	*/
1485	god = find_god (determine_god (op));	1443	god = find_god (determine_god (op));
1486	level = caster_level (caster, spell);	1444	level = casting_level (caster, spell);
1487	range = spell->range + SP_level_range_adjust (caster, spell);	1445	range = spell->range + SP_level_range_adjust (caster, spell);
1488		1446
1489	/* On the bright side, no monster should ever have a race of GOD_...	1447	/* On the bright side, no monster should ever have a race of GOD_...
1490	* so even if the player doesn't worship a god, if race=GOD_.., it	1448	* so even if the player doesn't worship a god, if race=GOD_.., it
1491	* won't ever match anything.	1449	* won't ever match anything.
1492	*/	1450	*/
1493	if (!spell->race)	1451	if (!spell->race)
1494	race = NULL;	1452	race = NULL;
1495	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1453	else if (god && spell->race == shstr_GOD_SLAYING)
1496	race = god->slaying;	1454	race = god->slaying;
1497	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1455	else if (god && spell->race == shstr_GOD_FRIEND)
1498	race = god->race;	1456	race = god->race;
1499	else	1457	else
1500	race = spell->race;	1458	race = spell->race;
1501		1459
1502	for (x = op->x - range; x <= op->x + range; x++)	1460	dynbuf buf;
1503	for (y = op->y - range; y <= op->y + range; y++)	1461	unordered_mapwalk (buf, op, -range, -range, range, range)
1504	{	1462	{
1505	done_one = 0;	1463	mapspace &ms = m->at (nx, ny);
1506	m = op->map;
1507	nx = x;
1508	ny = y;
1509	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1510	if (mflags & P_OUT_OF_MAP)
1511	continue;
1512		1464
1513	/* If there is nothing living on this space, no need to go further */	1465	/* If there is nothing living on this space, no need to go further */
1514	if (!(mflags & P_IS_ALIVE))	1466	if (!ms.flags () & P_IS_ALIVE)
1515	continue;	1467	continue;
1516		1468
1517	// players can only affect spaces that they can actually see	1469	// players can only affect spaces that they can actually see
		1470	if (caster
1518	if (caster && caster->contr	1471	&& caster->contr
1519	&& caster->contr->visibility_at (m, nx, ny) < 70)	1472	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1520	continue;	1473	continue;
1521		1474
1522	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1475	for (tmp = ms.top; tmp; tmp = tmp->below)
1523	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1476	if (tmp->flag [FLAG_MONSTER])
1524	break;	1477	break;
1525		1478
1526	/* There can be living objects that are not monsters */	1479	/* There can be living objects that are not monsters */
1527	if (!tmp || tmp->type == PLAYER)	1480	if (!tmp)
1528	continue;	1481	continue;
1529		1482
1530	/* Only the head has meaningful data, so resolve to that */	1483	/* Only the head has meaningful data, so resolve to that */
1531	if (tmp->head)
1532	head = tmp->head;	1484	head = tmp->head_ ();
1533	else
1534	head = tmp;
1535		1485
1536	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */	1486	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */
1537	if (race && head->race && !strstr (race, head->race))	1487	if (race && head->race && !strstr (race, head->race))
1538	continue;	1488	continue;
1539		1489
1540	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1490	if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
1541	continue;	1491	continue;
1542		1492
1543	/* Now do a bunch of stuff related to saving throws */	1493	/* Now do a bunch of stuff related to saving throws */
1544	best_at = -1;	1494	best_at = -1;
1545	if (spell->attacktype)	1495	if (spell->attacktype)
1546	{	1496	{
1547	for (at = 0; at < NROFATTACKS; at++)	1497	for (at = 0; at < NROFATTACKS; at++)
1548	if (spell->attacktype & (1 << at))	1498	if (spell->attacktype & (1 << at))
1549	if (best_at == -1 || head->resist[at] > head->resist[best_at])	1499	if (best_at == -1 || head->resist[at] > head->resist[best_at])
1550	best_at = at;	1500	best_at = at;
1551		1501
1552	if (best_at == -1)	1502	if (best_at == -1)
1553	at = 0;	1503	at = 0;
1554	else	1504	else
1555	{	1505	{
1556	if (head->resist[best_at] == 100)	1506	if (head->resist[best_at] == 100)
1557	continue;	1507	continue;
1558	else	1508	else
1559	at = head->resist[best_at] / 5;	1509	at = head->resist[best_at] / 5;
1560	}	1510	}
		1511
1561	at -= level / 5;	1512	at -= level / 5;
1562	if (did_make_save (head, head->level, at))	1513	if (did_make_save (head, head->level, at))
1563	continue;	1514	continue;
1564	}	1515	}
1565	else /* spell->attacktype */	1516	else /* spell->attacktype */
1566	{	1517	{
1567	/*	1518	/*
1568	Spell has no attacktype (charm & such), so we'll have a specific saving:	1519	Spell has no attacktype (charm & such), so we'll have a specific saving:
1569	* if spell level < monster level, no go	1520	* if spell level < monster level, no go
1570	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )	1521	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1571		1522
1572	The chance will then be in the range [20-70] percent, not too bad.	1523	The chance will then be in the range [20-70] percent, not too bad.
1573		1524
1574	This is required to fix the 'charm monster' abuse, where a player level 1 can	1525	This is required to fix the 'charm monster' abuse, where a player level 1 can
1575	charm a level 125 monster...	1526	charm a level 125 monster...
1576		1527
1577	Ryo, august 14th	1528	Ryo, august 14th
1578	*/	1529	*/
1579	if (head->level > level)	1530	if (head->level > level)
1580	continue;	1531	continue;
1581		1532
1582	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))	1533	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + min (50, 2 * (level - head->level))))
1583	/* Failed, no effect */	1534	/* Failed, no effect */
1584	continue;	1535	continue;
1585	}	1536	}
1586		1537
1587	/* Done with saving throw. Now start affecting the monster */	1538	/* Done with saving throw. Now start affecting the monster */
		1539	done_one = 0;
1588		1540
1589	/* aggravation */	1541	/* aggravation */
1590	if (QUERY_FLAG (spell, FLAG_MONSTER))	1542	if (spell->flag [FLAG_MONSTER])
1591	{	1543	{
1592	CLEAR_FLAG (head, FLAG_SLEEP);	1544	head->clr_flag (FLAG_SLEEP);
1593	remove_friendly_object (head);	1545	remove_friendly_object (head);
1594	done_one = 1;	1546	done_one = 1;
1595	head->enemy = op;	1547	head->enemy = op;
1596	}	1548	}
1597		1549
1598	/* calm monsters */	1550	/* calm monsters */
1599	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1551	if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
1600	{	1552	{
1601	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1553	head->set_flag (FLAG_UNAGGRESSIVE);
1602	head->enemy = NULL;	1554	head->enemy = NULL;
1603	done_one = 1;	1555	done_one = 1;
1604	}	1556	}
1605		1557
1606	/* berserk monsters */	1558	/* berserk monsters */
1607	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1559	if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
1608	{	1560	{
1609	SET_FLAG (head, FLAG_BERSERK);	1561	head->set_flag (FLAG_BERSERK);
1610	done_one = 1;	1562	done_one = 1;
1611	}	1563	}
1612		1564
1613	/* charm */	1565	/* charm */
1614	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1566	if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
1615	{	1567	{
		1568	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
		1569
1616	/* Prevent uncontolled outbreaks of self replicating monsters.	1570	/* Prevent uncontrolled outbreaks of self replicating monsters.
1617	Typical use case is charm, go somwhere, use aggravation to make hostile.	1571	Typical use case is charm, go somwhere, use aggravation to make hostile.
1618	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */	1572	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1619	CLEAR_FLAG (head, FLAG_GENERATOR);	1573	head->clr_flag (FLAG_GENERATOR);
1620	head->set_owner (op);	1574	head->set_owner (op);
1621	set_spell_skill (op, caster, spell, head);	1575	set_spell_skill (op, caster, spell, head);
1622	add_friendly_object (head);	1576	add_friendly_object (head);
1623	head->attack_movement = PETMOVE;	1577	head->attack_movement = PETMOVE;
1624	done_one = 1;	1578	done_one = 1;
1625	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1579	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1626	head->stats.exp = 0;	1580	head->stats.exp = 0;
1627	}	1581	}
1628		1582
1629	/* If a monster was effected, put an effect in */	1583	/* If a monster was effected, put an effect in */
1630	if (done_one && spell->other_arch)	1584	if (done_one && spell->other_arch)
1631	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1585	m->insert (spell->other_arch->instance (), nx, ny, op);
1632	} /* for y */	1586	}
1633		1587
1634	return 1;	1588	return 1;
1635	}	1589	}
1636
1637		1590
1638	/* Move_ball_spell: This handles ball type spells that just sort of wander	1591	/* Move_ball_spell: This handles ball type spells that just sort of wander
1639	* about. was called move_ball_lightning, but since more than the ball	1592	* about. was called move_ball_lightning, but since more than the ball
1640	* lightning spell used it, that seemed misnamed.	1593	* lightning spell used it, that seemed misnamed.
1641	* op is the spell effect.	1594	* op is the spell effect.
1642	* note that duration is handled by process_object() in time.c	1595	* note that duration is handled by process_object() in time.c
1643	*/	1596	*/
1644
1645	void	1597	void
1646	move_ball_spell (object *op)	1598	move_ball_spell (object *op)
1647	{	1599	{
1648	int i, j, dam_save, dir, mflags;	1600	int i, j, dam_save, dir, mflags;
1649	sint16 nx, ny, hx, hy;	1601	sint16 nx, ny, hx, hy;
…		…
1668	for (i = 1; i < 9; i++)	1620	for (i = 1; i < 9; i++)
1669	{	1621	{
1670	/* i bit 0: alters sign of offset	1622	/* i bit 0: alters sign of offset
1671	* other bits (i / 2): absolute value of offset	1623	* other bits (i / 2): absolute value of offset
1672	*/	1624	*/
1673
1674	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);	1625	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1675	int tmpdir = absdir (op->direction + offset);	1626	int tmpdir = absdir (op->direction + offset);
1676		1627
1677	nx = op->x + freearr_x[tmpdir];	1628	nx = op->x + freearr_x[tmpdir];
1678	ny = op->y + freearr_y[tmpdir];	1629	ny = op->y + freearr_y[tmpdir];
…		…
1680	{	1631	{
1681	dir = tmpdir;	1632	dir = tmpdir;
1682	break;	1633	break;
1683	}	1634	}
1684	}	1635	}
		1636
1685	if (dir == 0)	1637	if (dir == 0)
1686	{	1638	{
1687	nx = op->x;	1639	nx = op->x;
1688	ny = op->y;	1640	ny = op->y;
1689	m = op->map;	1641	m = op->map;
…		…
1715		1667
1716	if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))	1668	if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
1717	{	1669	{
1718	if (j)	1670	if (j)
1719	op->stats.dam = dam_save / 2;	1671	op->stats.dam = dam_save / 2;
		1672
1720	hit_map (op, j, op->attacktype, 1);	1673	hit_map (op, j, op->attacktype, 1);
1721
1722	}	1674	}
1723		1675
1724	/* insert the other arch */	1676	/* insert the other arch */
1725	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))	1677	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1726	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1678	m->insert (op->other_arch->instance (), hx, hy, op);
1727	}	1679	}
1728		1680
1729	/* restore to the center location and damage */	1681	/* restore to the center location and damage */
1730	op->stats.dam = dam_save;	1682	op->stats.dam = dam_save;
1731		1683
…		…
1740		1692
1741	op->direction = i;	1693	op->direction = i;
1742	}	1694	}
1743	}	1695	}
1744		1696
1745
1746	/* move_swarm_spell: peterm	1697	/* move_swarm_spell: peterm
1747	* This is an implementation of the swarm spell. It was written for	1698	* This is an implementation of the swarm spell. It was written for
1748	* meteor swarm, but it could be used for any swarm. A swarm spell	1699	* meteor swarm, but it could be used for any swarm. A swarm spell
1749	* is a special type of object that casts swarms of other types	1700	* is a special type of object that casts swarms of other types
1750	* of spells. Which spell it casts is flexible. It fires the spells	1701	* of spells. Which spell it casts is flexible. It fires the spells
1751	* from a set of squares surrounding the caster, in a given direction.	1702	* from a set of squares surrounding the caster, in a given direction.
1752	*/	1703	*/
1753
1754	void	1704	void
1755	move_swarm_spell (object *op)	1705	move_swarm_spell (object *op)
1756	{	1706	{
1757	#if 0	1707	#if 0
1758	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };	1708	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1759	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };	1709	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1760	sint16 target_x, target_y, origin_x, origin_y;	1710	sint16 target_x, target_y, origin_x, origin_y;
1761	int adjustdir;	1711	int adjustdir;
1762	maptile *m;	1712	maptile *m;
1763	#endif	1713	#endif
1764	int basedir;
1765	object *owner;	1714	object *owner = op->env;
1766		1715
1767	owner = op->owner;	1716	if (!owner) // MUST not happen, remove when true TODO
1768	if (op->duration == 0 || owner == NULL)
1769	{	1717	{
		1718	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1770	op->destroy ();	1719	op->destroy ();
1771	return;	1720	return;
1772	}	1721	}
1773		1722
		1723	if (!op->duration || !owner->is_on_map ())
		1724	{
		1725	op->drop_and_destroy ();
		1726	return;
		1727	}
		1728
1774	op->duration--;	1729	op->duration--;
1775		1730
1776	basedir = op->direction;	1731	int basedir = op->direction;
1777	if (basedir == 0)	1732	if (!basedir)
1778	{	1733	{
1779	/* spray in all directions! 8) */	1734	/* spray in all directions! 8) */
1780	basedir = rndm (1, 8);	1735	op->facing = (op->facing + op->state) & 7;
		1736	basedir = op->facing + 1;
1781	}	1737	}
1782		1738
1783	#if 0	1739	#if 0
1784	// this is bogus: it causes wrong places to be checked below	1740	// this is bogus: it causes wrong places to be checked below
1785	// (a wall 2 cells away will block the effect...) and	1741	// (a wall 2 cells away will block the effect...) and
…		…
1846	{	1802	{
1847	/* Bullet spells have a bunch more customization that needs to be done */	1803	/* Bullet spells have a bunch more customization that needs to be done */
1848	if (op->spell->subtype == SP_BULLET)	1804	if (op->spell->subtype == SP_BULLET)
1849	fire_bullet (owner, op, basedir, op->spell);	1805	fire_bullet (owner, op, basedir, op->spell);
1850	else if (op->spell->subtype == SP_MAGIC_MISSILE)	1806	else if (op->spell->subtype == SP_MAGIC_MISSILE)
1851	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);	1807	fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1852	}	1808	}
1853	}	1809	}
1854
1855
1856
1857		1810
1858	/* fire_swarm:	1811	/* fire_swarm:
1859	* The following routine creates a swarm of objects. It actually	1812	* The following routine creates a swarm of objects. It actually
1860	* sets up a specific swarm object, which then fires off all	1813	* sets up a specific swarm object, which then fires off all
1861	* the parts of the swarm.	1814	* the parts of the swarm.
…		…
1864	* caster: the caster (owner, wand, rod, scroll)	1817	* caster: the caster (owner, wand, rod, scroll)
1865	* dir: the direction everything will be fired in	1818	* dir: the direction everything will be fired in
1866	* spell - the spell that is this spell.	1819	* spell - the spell that is this spell.
1867	* n: the number to be fired.	1820	* n: the number to be fired.
1868	*/	1821	*/
1869
1870	int	1822	int
1871	fire_swarm (object *op, object *caster, object *spell, int dir)	1823	fire_swarm (object *op, object *caster, object *spell, int dir)
1872	{	1824	{
1873	object *tmp;
1874	int i;
1875
1876	if (!spell->other_arch)	1825	if (!spell->other_arch)
1877	return 0;	1826	return 0;
1878		1827
1879	tmp = get_archetype (SWARM_SPELL);	1828	object *tmp = archetype::get (SWARM_SPELL);
1880	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */	1829
1881	set_spell_skill (op, caster, spell, tmp);	1830	set_spell_skill (op, caster, spell, tmp);
1882
1883	tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */	1831	tmp->level = casting_level (caster, spell); /* needed later, to get level dep. right. */
1884	tmp->spell = arch_to_object (spell->other_arch);	1832	tmp->spell = spell->other_arch->instance ();
1885
1886	tmp->attacktype = tmp->spell->attacktype;	1833	tmp->attacktype = tmp->spell->attacktype;
1887		1834
1888	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)	1835	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1889	if (!tailor_god_spell (tmp, op))	1836	if (!tailor_god_spell (tmp, op))
1890	return 1;	1837	return 1;
1891		1838
1892	tmp->duration = SP_level_duration_adjust (caster, spell);	1839	tmp->duration = SP_level_duration_adjust (caster, spell);
1893	for (i = 0; i < spell->duration; i++)	1840	for (int i = 0; i < spell->duration; i++)
1894	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1841	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1895		1842
		1843	tmp->invisible = 1;
		1844	tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1896	tmp->direction = dir;	1845	tmp->direction = dir;
1897	tmp->invisible = 1;	1846	tmp->facing = rndm (1, 8); // initial firing direction
		1847	tmp->state = rndm (4) * 2 + 1; // direction increment
1898		1848
1899	tmp->insert_at (op, op);	1849	op->insert (tmp);
		1850
1900	return 1;	1851	return 1;
1901	}	1852	}
1902
1903		1853
1904	/* See the spells documentation file for why this is its own	1854	/* See the spells documentation file for why this is its own
1905	* function.	1855	* function.
1906	*/	1856	*/
1907	int	1857	int
…		…
1912	int dam, mflags;	1862	int dam, mflags;
1913	maptile *m;	1863	maptile *m;
1914		1864
1915	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1865	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1916		1866
1917	if (!dir)	1867	if (dir)
1918	{
1919	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1920	return 0;
1921	}	1868	{
1922
1923	x = op->x + freearr_x[dir];	1869	x = op->x + freearr_x[dir];
1924	y = op->y + freearr_y[dir];	1870	y = op->y + freearr_y[dir];
1925	m = op->map;	1871	m = op->map;
1926		1872
1927	mflags = get_map_flags (m, &m, x, y, &x, &y);	1873	mflags = get_map_flags (m, &m, x, y, &x, &y);
1928		1874
1929	if (mflags & P_OUT_OF_MAP)	1875	if (mflags & P_OUT_OF_MAP)
1930	{	1876	{
1931	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1877	op->failmsg ("Nothing is there.");
1932	return 0;	1878	return 0;
1933	}	1879	}
1934		1880
1935	if (mflags & P_IS_ALIVE && spell->attacktype)	1881	if (mflags & P_IS_ALIVE && spell->attacktype)
1936	{	1882	{
1937	for (target = GET_MAP_OB (m, x, y); target; target = target->above)	1883	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1938	if (QUERY_FLAG (target, FLAG_MONSTER))	1884	if (target->flag [FLAG_MONSTER])
1939	{	1885	{
1940	/* oky doky. got a target monster. Lets make a blinding attack */	1886	/* oky doky. got a target monster. Lets make a blinding attack */
1941	if (target->head)	1887	if (target->head)
1942	target = target->head;	1888	target = target->head;
		1889
1943	(void) hit_player (target, dam, op, spell->attacktype, 1);	1890	hit_player (target, dam, op, spell->attacktype, 1);
1944	return 1; /* one success only! */	1891	return 1; /* one success only! */
		1892	}
1945	}	1893	}
1946	}
1947		1894
1948	/* no live target, perhaps a wall is in the way? */	1895	/* no live target, perhaps a wall is in the way? */
1949	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))	1896	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
1950	{	1897	{
1951	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1898	op->failmsg ("Something is in the way.");
1952	return 0;	1899	return 0;
		1900	}
1953	}	1901	}
1954		1902
1955	/* ok, looks groovy to just insert a new light on the map */	1903	/* ok, looks groovy to just insert a new light on the map */
1956	tmp = arch_to_object (spell->other_arch);	1904	tmp = spell->other_arch->instance ();
1957	if (!tmp)	1905	if (!tmp)
1958	{	1906	{
1959	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1907	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1960	return 0;	1908	return 0;
1961	}	1909	}
		1910
1962	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1911	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
		1912
1963	if (tmp->glow_radius)	1913	if (tmp->glow_radius)
1964	{	1914	tmp->set_glow_radius (
1965	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);	1915	clamp (spell->range + SP_level_range_adjust (caster, spell), 1, MAX_LIGHT_RADIUS)
1966	if (tmp->glow_radius > MAX_LIGHT_RADII)	1916	);
1967	tmp->glow_radius = MAX_LIGHT_RADII;
1968	}
1969		1917
		1918	if (dir)
1970	m->insert (tmp, x, y, op);	1919	m->insert (tmp, x, y, op);
		1920	else
		1921	caster->outer_env_or_self ()->insert (tmp);
		1922
1971	return 1;	1923	return 1;
1972	}	1924	}
1973
1974
1975
1976		1925
1977	/* cast_cause_disease: this spell looks along <dir> from the	1926	/* cast_cause_disease: this spell looks along <dir> from the
1978	* player and infects someone.	1927	* player and infects someone.
1979	* op is the player/monster, caster is the object, dir is the direction	1928	* op is the player/monster, caster is the object, dir is the direction
1980	* to cast, disease_arch is the specific disease, and type is the spell number	1929	* to cast, disease_arch is the specific disease, and type is the spell number
1981	* perhaps this should actually be in disease.c?	1930	* perhaps this should actually be in disease.c?
1982	*/	1931	*/
1983
1984	int	1932	int
1985	cast_cause_disease (object *op, object *caster, object *spell, int dir)	1933	cast_cause_disease (object *op, object *caster, object *spell, int dir)
1986	{	1934	{
1987	sint16 x, y;	1935	sint16 x, y;
1988	int i, mflags, range, dam_mod, dur_mod;	1936	int i, mflags, range, dam_mod, dur_mod;
…		…
1995	/* If casting from a scroll, no direction will be available, so refer to the	1943	/* If casting from a scroll, no direction will be available, so refer to the
1996	* direction the player is pointing.	1944	* direction the player is pointing.
1997	*/	1945	*/
1998	if (!dir)	1946	if (!dir)
1999	dir = op->facing;	1947	dir = op->facing;
		1948
2000	if (!dir)	1949	if (!dir)
2001	return 0; /* won't find anything if casting on ourself, so just return */	1950	return 0; /* won't find anything if casting on ourself, so just return */
2002		1951
2003	/* Calculate these once here */	1952	/* Calculate these once here */
2004	range = spell->range + SP_level_range_adjust (caster, spell);	1953	range = spell->range + SP_level_range_adjust (caster, spell);
…		…
2024	/* Only bother looking on this space if there is something living here */	1973	/* Only bother looking on this space if there is something living here */
2025	if (mflags & P_IS_ALIVE)	1974	if (mflags & P_IS_ALIVE)
2026	{	1975	{
2027	/* search this square for a victim */	1976	/* search this square for a victim */
2028	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)	1977	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
2029	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))	1978	if (walk->flag [FLAG_MONSTER] || (walk->type == PLAYER))
2030	{ /* found a victim */	1979	{ /* found a victim */
2031	object *disease = arch_to_object (spell->other_arch);	1980	object *disease = spell->other_arch->instance ();
2032		1981
2033	disease->set_owner (op);	1982	disease->set_owner (op);
2034	set_spell_skill (op, caster, spell, disease);	1983	set_spell_skill (op, caster, spell, disease);
2035	disease->stats.exp = 0;	1984	disease->stats.exp = 0;
2036	disease->level = caster_level (caster, spell);	1985	disease->level = casting_level (caster, spell);
2037		1986
2038	/* do level adjustments */	1987	/* do level adjustments */
2039	if (disease->stats.wc)	1988	if (disease->stats.wc ) disease->stats.wc += dur_mod / 2;
2040	disease->stats.wc += dur_mod / 2;	1989	if (disease->magic > 0) disease->magic += dur_mod / 8;
2041		1990	if (disease->stats.maxhp > 0) disease->stats.maxhp += dur_mod;
2042	if (disease->magic > 0)	1991	if (disease->stats.maxgrace > 0) disease->stats.maxgrace += dur_mod;
2043	disease->magic += dur_mod / 4;
2044
2045	if (disease->stats.maxhp > 0)
2046	disease->stats.maxhp += dur_mod;
2047
2048	if (disease->stats.maxgrace > 0)
2049	disease->stats.maxgrace += dur_mod;
2050
2051	if (disease->stats.dam)
2052	{
2053	if (disease->stats.dam > 0)
2054	disease->stats.dam += dam_mod;
2055	else
2056	disease->stats.dam -= dam_mod;
2057	}
2058		1992
2059	if (disease->last_sp)	1993	if (disease->last_sp)
2060	{	1994	{
2061	disease->last_sp -= 2 * dam_mod;	1995	disease->last_sp -= 2 * dam_mod;
		1996
2062	if (disease->last_sp < 1)	1997	if (disease->last_sp < 1)
2063	disease->last_sp = 1;	1998	disease->last_sp = 1;
2064	}	1999	}
2065		2000
2066	if (disease->stats.maxsp)	2001	if (disease->stats.dam ) disease->stats.dam += copysign (disease->stats.dam , dam_mod);
2067	{	2002	if (disease->stats.maxsp) disease->stats.maxsp += copysign (disease->stats.maxsp, dam_mod);
2068	if (disease->stats.maxsp > 0)	2003	if (disease->stats.ac ) disease->stats.ac += dam_mod;
2069	disease->stats.maxsp += dam_mod;	2004	if (disease->last_eat ) disease->last_eat -= dam_mod;
2070	else	2005	if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2071	disease->stats.maxsp -= dam_mod;	2006	if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2072	}
2073
2074	if (disease->stats.ac)
2075	disease->stats.ac += dam_mod;
2076
2077	if (disease->last_eat)
2078	disease->last_eat -= dam_mod;
2079
2080	if (disease->stats.hp)
2081	disease->stats.hp -= dam_mod;
2082
2083	if (disease->stats.sp)
2084	disease->stats.sp -= dam_mod;
2085		2007
2086	if (infect_object (walk, disease, 1))	2008	if (infect_object (walk, disease, 1))
2087	{	2009	{
2088	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);	2010	op->statusmsg (format ("You inflict %s on %s!", &disease->name, &walk->name));
2089		2011
2090	disease->destroy (); /* don't need this one anymore */	2012	disease->destroy (); /* don't need this one anymore */
2091	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2013	walk->map->insert (get_archetype (shstr_detect_magic), x, y, op);
2092	return 1;	2014	return 1;
2093	}	2015	}
2094		2016
2095	disease->destroy ();	2017	disease->destroy ();
2096	}	2018	}

Diff Legend

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