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.44 by root, Sun Jul 22 14:17:58 2007 UTC vs.
Revision 1.110 by root, Fri Jan 27 22:00:40 2012 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,2011,2012 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	}
…		…
1090	int	1109	int
1091	cast_smite_spell (object *op, object *caster, int dir, object *spell)	1110	cast_smite_spell (object *op, object *caster, int dir, object *spell)
1092	{	1111	{
1093	object *effect, *target;	1112	object *effect, *target;
1094	object *god = find_god (determine_god (op));	1113	object *god = find_god (determine_god (op));
1095	int range;
1096		1114
1097	range = spell->range + SP_level_range_adjust (caster, spell);
1098	target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);	1115	target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);
1099		1116
1100	/* Bunch of conditions for casting this spell. Note that only	1117	/* Bunch of conditions for casting this spell. Note that only
1101	* require a god if this is a cleric spell (requires grace).	1118	* require a god if this is a cleric spell (requires grace).
1102	* This makes this spell much more general purpose - it can be used	1119	* This makes this spell much more general purpose - it can be used
…		…
1104	* interesting spell.	1121	* interesting spell.
1105	* if it is a cleric spell, you need a god, and the creature	1122	* if it is a cleric spell, you need a god, and the creature
1106	* can't be friendly to your god.	1123	* can't be friendly to your god.
1107	*/	1124	*/
1108		1125
1109	if (!target || QUERY_FLAG (target, FLAG_REFL_SPELL)	1126	if (!target
		1127	|| target->flag [FLAG_REFL_SPELL]
1110	|| (!god && spell->stats.grace)	1128	|| (!god && spell->stats.grace)
1111	|| (target->title && god && !strcmp (target->title, god->name)) || (target->race && god && strstr (target->race, god->race)))	1129	|| (god && target->title == god->name)
		1130	|| (god && target->race.contains (god->race)))
1112	{	1131	{
1113	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1132	op->failmsg ("Your request is unheeded.");
1114	return 0;	1133	return 0;
1115	}	1134	}
1116		1135
1117	if (spell->other_arch)	1136	if (spell->other_arch)
1118	effect = arch_to_object (spell->other_arch);	1137	effect = spell->other_arch->instance ();
1119	else	1138	else
1120	return 0;	1139	return 0;
1121		1140
1122	/* tailor the effect by priest level and worshipped God */	1141	/* tailor the effect by priest level and worshipped God */
1123	effect->level = caster_level (caster, spell);	1142	effect->level = casting_level (caster, spell);
1124	effect->attacktype = spell->attacktype;	1143	effect->attacktype = spell->attacktype;
1125	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))	1144	if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1126	{	1145	{
1127	if (tailor_god_spell (effect, op))	1146	if (tailor_god_spell (effect, op))
1128	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));	1147	new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", (const char *)determine_god (op));
1129	else	1148	else
1130	{	1149	{
1131	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1150	op->failmsg ("Your request is ignored.");
1132	return 0;	1151	return 0;
1133	}	1152	}
1134	}	1153	}
1135		1154
1136	/* size of the area of destruction */	1155	/* size of the area of destruction */
…		…
1140	if (effect->attacktype & AT_DEATH)	1159	if (effect->attacktype & AT_DEATH)
1141	{	1160	{
1142	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1161	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1143		1162
1144	/* casting death spells at undead isn't a good thing */	1163	/* casting death spells at undead isn't a good thing */
1145	if (QUERY_FLAG (target, FLAG_UNDEAD))	1164	if (target->flag [FLAG_UNDEAD])
1146	{	1165	{
1147	if (random_roll (0, 2, op, PREFER_LOW))	1166	if (random_roll (0, 2, op, PREFER_LOW))
1148	{	1167	{
1149	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1168	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1150	effect->x = op->x;	1169	effect->x = op->x;
…		…
1172	effect->insert_at (target, op);	1191	effect->insert_at (target, op);
1173		1192
1174	return 1;	1193	return 1;
1175	}	1194	}
1176		1195
1177
1178	/****************************************************************************	1196	/****************************************************************************
1179	*	1197	*
1180	* MAGIC MISSILE code.	1198	* MAGIC MISSILE code.
1181	* note that the fire_bullet is used to fire the missile. The	1199	* note that the fire_bullet is used to fire the missile. The
1182	* code here is just to move the missile.	1200	* code here is just to move the missile.
…		…
1184		1202
1185	/* op is a missile that needs to be moved */	1203	/* op is a missile that needs to be moved */
1186	void	1204	void
1187	move_missile (object *op)	1205	move_missile (object *op)
1188	{	1206	{
1189	int i, mflags;
1190	object *owner;
1191	sint16 new_x, new_y;
1192	maptile *m;
1193
1194	if (op->range-- <= 0)	1207	if (op->range-- <= 0)
1195	{	1208	{
		1209	op->drop_and_destroy ();
		1210	return;
		1211	}
		1212
		1213	mapxy pos (op);
		1214	pos.move (op->direction);
		1215
		1216	if (!pos.normalise ())
		1217	{
1196	op->destroy ();	1218	op->destroy ();
1197	return;	1219	return;
1198	}	1220	}
1199		1221
1200	owner = op->owner;	1222	mapspace &ms = pos.ms ();
1201	#if 0
1202	/* It'd make things nastier if this wasn't here - spells cast by
1203	* monster that are then killed would continue to survive
1204	*/
1205	if (owner == NULL)
1206	{
1207	op->destroy ();
1208	return;
1209	}
1210	#endif
1211		1223
1212	new_x = op->x + DIRX (op);	1224	if (ms.flags () & P_IS_ALIVE || ms.blocks (op))
1213	new_y = op->y + DIRY (op);
1214
1215	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1216
1217	if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1218	{	1225	{
1219	hit_map (op, op->direction, AT_MAGIC, 1);	1226	hit_map (op, op->direction, AT_MAGIC, 1);
1220	/* Basically, missile only hits one thing then goes away.	1227	/* Basically, missile only hits one thing then goes away.
1221	* we need to remove it if someone hasn't already done so.	1228	* we need to remove it if someone hasn't already done so.
1222	*/	1229	*/
1223	if (!op->destroyed ())
1224	op->destroy ();
1225
1226	return;
1227	}
1228
1229	op->remove ();
1230
1231	if (!op->direction || (mflags & P_OUT_OF_MAP))
1232	{
1233	op->destroy ();	1230	op->destroy ();
1234	return;	1231	return;
1235	}	1232	}
1236		1233
		1234	if (!op->direction)
		1235	{
		1236	op->destroy ();
		1237	return;
		1238	}
		1239
1237	i = spell_find_dir (m, new_x, new_y, op->owner);	1240	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1238	if (i > 0 && i != op->direction)	1241	if (i > 0 && i != op->direction)
1239	{	1242	{
1240	op->direction = i;	1243	op->direction = i;
1241	SET_ANIMATION (op, op->direction);	1244	SET_ANIMATION (op, op->direction);
1242	}	1245	}
1243		1246
1244	m->insert (op, new_x, new_y, op);	1247	pos.insert (op, op);
1245	}	1248	}
1246		1249
1247	/****************************************************************************	1250	/****************************************************************************
1248	* Destruction	1251	* Destruction
1249	****************************************************************************/	1252	****************************************************************************/
…		…
1252	* we do this by creating a force and inserting it in the	1255	* we do this by creating a force and inserting it in the
1253	* object. if time is 0, the object glows permanently. To truely	1256	* object. if time is 0, the object glows permanently. To truely
1254	* make this work for non-living objects, we would have to	1257	* make this work for non-living objects, we would have to
1255	* give them the capability to have an inventory. b.t.	1258	* give them the capability to have an inventory. b.t.
1256	*/	1259	*/
1257	int	1260	static int
1258	make_object_glow (object *op, int radius, int time)	1261	make_object_glow (object *op, int radius, int time)
1259	{	1262	{
1260	/* some things are unaffected... */	1263	/* some things are unaffected... */
1261	if (op->path_denied & PATH_LIGHT)	1264	if (op->path_denied & PATH_LIGHT)
1262	return 0;	1265	return 0;
1263		1266
1264	object *tmp = get_archetype (FORCE_NAME);	1267	object *tmp = archetype::get (FORCE_NAME);
1265	tmp->speed = 0.01;	1268	tmp->set_speed (0.01);
1266	tmp->stats.food = time;	1269	tmp->stats.food = time;
1267	SET_FLAG (tmp, FLAG_IS_USED_UP);	1270	tmp->set_flag (FLAG_IS_USED_UP);
1268	tmp->glow_radius = radius;	1271	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1269	if (tmp->glow_radius > MAX_LIGHT_RADII)
1270	tmp->glow_radius = MAX_LIGHT_RADII;
1271
1272	tmp = insert_ob_in_ob (tmp, op);	1272	tmp = insert_ob_in_ob (tmp, op);
1273		1273
1274	if (tmp->glow_radius > op->glow_radius)	1274	if (tmp->glow_radius > op->glow_radius)
1275	op->glow_radius = tmp->glow_radius;	1275	op->set_glow_radius (tmp->glow_radius);
1276		1276
1277	return 1;	1277	return 1;
1278	}	1278	}
1279		1279
1280	int	1280	int
1281	cast_destruction (object *op, object *caster, object *spell_ob)	1281	cast_destruction (object *op, object *caster, object *spell_ob)
1282	{	1282	{
1283	int i, j, range, mflags, friendly = 0, dam, dur;
1284	sint16 sx, sy;
1285	maptile *m;
1286	object *tmp;
1287	const char *skill;
1288
1289	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1283	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1290	dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	1284	int dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1291	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1285	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1292	if (QUERY_FLAG (op, FLAG_FRIENDLY) || op->type == PLAYER)
1293	friendly = 1;
1294		1286
1295	/* destruction doesn't use another spell object, so we need	1287	bool friendly = op->flag [FLAG_FRIENDLY] || op->is_player ();
1296	* update op's skill pointer so that exp is properly awarded.
1297	* We do some shortcuts here - since this is just temporary
1298	* and we'll reset the values back, we don't need to go through
1299	* the full share string/free_string route.
1300	*/
1301	skill = op->skill;
1302	if (caster == op)
1303	op->skill = spell_ob->skill;
1304	else if (caster->skill)
1305	op->skill = caster->skill;
1306	else
1307	op->skill = NULL;
1308		1288
1309	op->change_skill (find_skill_by_name (op, op->skill));	1289	dynbuf buf;
1310		1290	unordered_mapwalk (buf, op, -range, -range, range, range)
1311	for (i = -range; i < range; i++)
1312	{	1291	{
1313	for (j = -range; j < range; j++)	1292	mapspace &ms = m->at (nx, ny);
1314	{
1315	m = op->map;
1316	sx = op->x + i;
1317	sy = op->y + j;
1318		1293
1319	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1320	if (mflags & P_OUT_OF_MAP)
1321	continue;
1322
1323	if (mflags & P_IS_ALIVE)	1294	if (ms.flags () & P_IS_ALIVE)
		1295	for (object *next, *tmp = ms.bot; tmp; tmp = next)
1324	{	1296	{
1325	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1297	next = tmp->above;
1326	if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1327	break;
1328		1298
1329	if (tmp)	1299	if (tmp->flag [FLAG_ALIVE] || tmp->is_player ())
1330	{	1300	{
1331	if (tmp->head)
1332	tmp = tmp->head;	1301	tmp = tmp->head_ ();
1333		1302
1334	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) ||	1303	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1335	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))	1304	|| (!friendly && (tmp->flag [FLAG_FRIENDLY] || tmp->is_player ())))
1336	{	1305	{
1337	if (spell_ob->subtype == SP_DESTRUCTION)	1306	if (spell_ob->subtype == SP_DESTRUCTION)
1338	{	1307	{
1339	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1308	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
		1309
1340	if (spell_ob->other_arch)	1310	if (spell_ob->other_arch)
1341	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1311	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1342	}	1312	}
1343	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)	1313	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist [ATNR_MAGIC] != 100)
1344	{	1314	{
1345	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1315	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1346	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1316	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1347	}	1317	}
1348	}	1318	}
1349	}	1319	}
1350	}	1320	}
1351	}
1352	}	1321	}
1353		1322
1354	op->skill = skill;
1355	return 1;	1323	return 1;
1356	}	1324	}
1357		1325
1358	/***************************************************************************	1326	/***************************************************************************
1359	*	1327	*
1360	* CURSE	1328	* CURSE
1361	*	1329	*
1362	***************************************************************************/	1330	***************************************************************************/
1363
1364	int	1331	int
1365	cast_curse (object *op, object *caster, object *spell_ob, int dir)	1332	cast_curse (object *op, object *caster, object *spell_ob, int dir)
1366	{	1333	{
1367	object *god = find_god (determine_god (op));	1334	object *god = find_god (determine_god (op));
1368	object *tmp, *force;	1335	object *tmp, *force;
1369		1336
1370	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);	1337	tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);
1371	if (!tmp)	1338	if (!tmp)
1372	{	1339	{
1373	new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");	1340	op->failmsg ("There is no one in that direction to curse.");
1374	return 0;	1341	return 0;
1375	}	1342	}
1376		1343
		1344	tmp = tmp->head_ ();
		1345
1377	/* If we've already got a force of this type, don't add a new one. */	1346	/* If we've already got a force of this type, don't add a new one. */
1378	for (force = tmp->inv; force != NULL; force = force->below)	1347	for (force = tmp->inv; force; force = force->below)
1379	{	1348	{
1380	if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)	1349	if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
1381	{	1350	{
1382	if (force->name == spell_ob->name)	1351	if (force->name == spell_ob->name)
1383	{	1352	{
…		…
1389	return 0;	1358	return 0;
1390	}	1359	}
1391	}	1360	}
1392	}	1361	}
1393		1362
1394	if (force == NULL)	1363	if (!force)
1395	{	1364	{
1396	force = get_archetype (FORCE_NAME);	1365	force = archetype::get (FORCE_NAME);
1397	force->subtype = FORCE_CHANGE_ABILITY;	1366	force->subtype = FORCE_CHANGE_ABILITY;
		1367
1398	if (spell_ob->race)	1368	if (spell_ob->race)
1399	force->name = spell_ob->race;	1369	force->name = spell_ob->race;
1400	else	1370	else
1401	force->name = spell_ob->name;	1371	force->name = spell_ob->name;
1402		1372
…		…
1412	{	1382	{
1413	force->duration = duration;	1383	force->duration = duration;
1414	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1384	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1415	}	1385	}
1416	else	1386	else
1417	{
1418	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1387	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1419	}	1388
1420	return 1;	1389	return 1;
1421	}	1390	}
		1391
1422	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1392	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1423	force->speed = 1.f;
1424	force->speed_left = -1.f;	1393	force->speed_left = -1.f;
1425	SET_FLAG (force, FLAG_APPLIED);	1394	force->set_speed (1.f);
		1395	force->set_flag (FLAG_APPLIED);
1426		1396
1427	if (god)	1397	if (god)
1428	{	1398	{
1429	if (spell_ob->last_grace)	1399	if (spell_ob->last_grace)
1430	force->path_repelled = god->path_repelled;	1400	force->path_repelled = god->path_repelled;
…		…
1443	force->stats.wc = spell_ob->stats.wc;	1413	force->stats.wc = spell_ob->stats.wc;
1444		1414
1445	change_abil (tmp, force); /* Mostly to display any messages */	1415	change_abil (tmp, force); /* Mostly to display any messages */
1446	insert_ob_in_ob (force, tmp);	1416	insert_ob_in_ob (force, tmp);
1447	tmp->update_stats ();	1417	tmp->update_stats ();
		1418
1448	return 1;	1419	return 1;
1449
1450	}	1420	}
1451		1421
1452	/**********************************************************************	1422	/**********************************************************************
1453	* mood change	1423	* mood change
1454	* Arguably, this may or may not be an attack spell. But since it	1424	* Arguably, this may or may not be an attack spell. But since it
…		…
1460	*/	1430	*/
1461	int	1431	int
1462	mood_change (object *op, object *caster, object *spell)	1432	mood_change (object *op, object *caster, object *spell)
1463	{	1433	{
1464	object *tmp, *god, *head;	1434	object *tmp, *god, *head;
1465	int done_one, range, mflags, level, at, best_at;	1435	int done_one, range, level, at, best_at;
1466	sint16 x, y, nx, ny;
1467	maptile *m;
1468	const char *race;	1436	const char *race;
1469		1437
1470	/* We precompute some values here so that we don't have to keep	1438	/* We precompute some values here so that we don't have to keep
1471	* doing it over and over again.	1439	* doing it over and over again.
1472	*/	1440	*/
1473	god = find_god (determine_god (op));	1441	god = find_god (determine_god (op));
1474	level = caster_level (caster, spell);	1442	level = casting_level (caster, spell);
1475	range = spell->range + SP_level_range_adjust (caster, spell);	1443	range = spell->range + SP_level_range_adjust (caster, spell);
1476		1444
1477	/* On the bright side, no monster should ever have a race of GOD_...	1445	/* On the bright side, no monster should ever have a race of GOD_...
1478	* so even if the player doesn't worship a god, if race=GOD_.., it	1446	* so even if the player doesn't worship a god, if race=GOD_.., it
1479	* won't ever match anything.	1447	* won't ever match anything.
1480	*/	1448	*/
1481	if (!spell->race)	1449	if (!spell->race)
1482	race = NULL;	1450	race = NULL;
1483	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1451	else if (god && spell->race == shstr_GOD_SLAYING)
1484	race = god->slaying;	1452	race = god->slaying;
1485	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1453	else if (god && spell->race == shstr_GOD_FRIEND)
1486	race = god->race;	1454	race = god->race;
1487	else	1455	else
1488	race = spell->race;	1456	race = spell->race;
1489		1457
1490	for (x = op->x - range; x <= op->x + range; x++)	1458	dynbuf buf;
1491	for (y = op->y - range; y <= op->y + range; y++)	1459	unordered_mapwalk (buf, op, -range, -range, range, range)
1492	{	1460	{
1493	done_one = 0;	1461	mapspace &ms = m->at (nx, ny);
1494	m = op->map;
1495	nx = x;
1496	ny = y;
1497	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1498	if (mflags & P_OUT_OF_MAP)
1499	continue;
1500		1462
1501	/* If there is nothing living on this space, no need to go further */	1463	/* If there is nothing living on this space, no need to go further */
1502	if (!(mflags & P_IS_ALIVE))	1464	if (!(ms.flags () & P_IS_ALIVE))
1503	continue;	1465	continue;
1504		1466
1505	// players can only affect spaces that they can actually see	1467	// players can only affect spaces that they can actually see
		1468	if (caster
1506	if (caster && caster->contr	1469	&& caster->contr
1507	&& caster->contr->visibility_at (m, nx, ny) < 70)	1470	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1508	continue;	1471	continue;
1509		1472
1510	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1473	for (tmp = ms.top; tmp; tmp = tmp->below)
1511	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1474	if (tmp->flag [FLAG_MONSTER])
1512	break;	1475	break;
1513		1476
1514	/* There can be living objects that are not monsters */	1477	/* There can be living objects that are not monsters */
1515	if (!tmp || tmp->type == PLAYER)	1478	if (!tmp)
1516	continue;	1479	continue;
1517		1480
1518	/* Only the head has meaningful data, so resolve to that */	1481	/* Only the head has meaningful data, so resolve to that */
1519	if (tmp->head)
1520	head = tmp->head;	1482	head = tmp->head_ ();
1521	else
1522	head = tmp;
1523		1483
1524	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */	1484	/* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */
1525	if (race && head->race && !strstr (race, head->race))	1485	if (race && head->race && !strstr (race, head->race))
1526	continue;	1486	continue;
1527		1487
1528	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1488	if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
1529	continue;	1489	continue;
1530		1490
1531	/* Now do a bunch of stuff related to saving throws */	1491	/* Now do a bunch of stuff related to saving throws */
1532	best_at = -1;	1492	best_at = -1;
1533	if (spell->attacktype)	1493	if (spell->attacktype)
1534	{	1494	{
1535	for (at = 0; at < NROFATTACKS; at++)	1495	for (at = 0; at < NROFATTACKS; at++)
1536	if (spell->attacktype & (1 << at))	1496	if (spell->attacktype & (1 << at))
1537	if (best_at == -1 || head->resist[at] > head->resist[best_at])	1497	if (best_at == -1 || head->resist[at] > head->resist[best_at])
1538	best_at = at;	1498	best_at = at;
1539		1499
1540	if (best_at == -1)	1500	if (best_at == -1)
1541	at = 0;	1501	at = 0;
1542	else	1502	else
1543	{	1503	{
1544	if (head->resist[best_at] == 100)	1504	if (head->resist[best_at] == 100)
1545	continue;	1505	continue;
1546	else	1506	else
1547	at = head->resist[best_at] / 5;	1507	at = head->resist[best_at] / 5;
1548	}	1508	}
		1509
1549	at -= level / 5;	1510	at -= level / 5;
1550	if (did_make_save (head, head->level, at))	1511	if (did_make_save (head, head->level, at))
1551	continue;	1512	continue;
1552	}	1513	}
1553	else /* spell->attacktype */	1514	else /* spell->attacktype */
1554	{	1515	{
1555	/*	1516	/*
1556	Spell has no attacktype (charm & such), so we'll have a specific saving:	1517	Spell has no attacktype (charm & such), so we'll have a specific saving:
1557	* if spell level < monster level, no go	1518	* if spell level < monster level, no go
1558	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )	1519	* else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1559		1520
1560	The chance will then be in the range [20-70] percent, not too bad.	1521	The chance will then be in the range [20-70] percent, not too bad.
1561		1522
1562	This is required to fix the 'charm monster' abuse, where a player level 1 can	1523	This is required to fix the 'charm monster' abuse, where a player level 1 can
1563	charm a level 125 monster...	1524	charm a level 125 monster...
1564		1525
1565	Ryo, august 14th	1526	Ryo, august 14th
1566	*/	1527	*/
1567	if (head->level > level)	1528	if (head->level > level)
1568	continue;	1529	continue;
1569		1530
1570	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))	1531	if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + min (50, 2 * (level - head->level))))
1571	/* Failed, no effect */	1532	/* Failed, no effect */
1572	continue;	1533	continue;
1573	}	1534	}
1574		1535
1575	/* Done with saving throw. Now start affecting the monster */	1536	/* Done with saving throw. Now start affecting the monster */
		1537	done_one = 0;
1576		1538
1577	/* aggravation */	1539	/* aggravation */
1578	if (QUERY_FLAG (spell, FLAG_MONSTER))	1540	if (spell->flag [FLAG_MONSTER])
1579	{	1541	{
1580	CLEAR_FLAG (head, FLAG_SLEEP);	1542	head->clr_flag (FLAG_SLEEP);
1581	remove_friendly_object (head);	1543	remove_friendly_object (head);
1582	done_one = 1;	1544	done_one = 1;
1583	head->enemy = op;	1545	head->enemy = op;
1584	}	1546	}
1585		1547
1586	/* calm monsters */	1548	/* calm monsters */
1587	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1549	if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
1588	{	1550	{
1589	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1551	head->set_flag (FLAG_UNAGGRESSIVE);
1590	head->enemy = NULL;	1552	head->enemy = NULL;
1591	done_one = 1;	1553	done_one = 1;
1592	}	1554	}
1593		1555
1594	/* berserk monsters */	1556	/* berserk monsters */
1595	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1557	if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
1596	{	1558	{
1597	SET_FLAG (head, FLAG_BERSERK);	1559	head->set_flag (FLAG_BERSERK);
1598	done_one = 1;	1560	done_one = 1;
1599	}	1561	}
1600		1562
1601	/* charm */	1563	/* charm */
1602	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1564	if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
1603	{	1565	{
		1566	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
		1567
1604	/* Prevent uncontolled outbreaks of self replicating monsters.	1568	/* Prevent uncontrolled outbreaks of self replicating monsters.
1605	Typical use case is charm, go somwhere, use aggravation to make hostile.	1569	Typical use case is charm, go somwhere, use aggravation to make hostile.
1606	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */	1570	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1607	CLEAR_FLAG (head, FLAG_GENERATOR);	1571	head->clr_flag (FLAG_GENERATOR);
1608	head->set_owner (op);	1572	head->set_owner (op);
1609	set_spell_skill (op, caster, spell, head);	1573	set_spell_skill (op, caster, spell, head);
1610	add_friendly_object (head);	1574	add_friendly_object (head);
1611	head->attack_movement = PETMOVE;	1575	head->attack_movement = PETMOVE;
1612	done_one = 1;	1576	done_one = 1;
1613	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);	1577	change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1614	head->stats.exp = 0;	1578	head->stats.exp = 0;
1615	}	1579	}
1616		1580
1617	/* If a monster was effected, put an effect in */	1581	/* If a monster was effected, put an effect in */
1618	if (done_one && spell->other_arch)	1582	if (done_one && spell->other_arch)
1619	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1583	m->insert (spell->other_arch->instance (), nx, ny, op);
1620	} /* for y */	1584	}
1621		1585
1622	return 1;	1586	return 1;
1623	}	1587	}
1624
1625		1588
1626	/* Move_ball_spell: This handles ball type spells that just sort of wander	1589	/* Move_ball_spell: This handles ball type spells that just sort of wander
1627	* about. was called move_ball_lightning, but since more than the ball	1590	* about. was called move_ball_lightning, but since more than the ball
1628	* lightning spell used it, that seemed misnamed.	1591	* lightning spell used it, that seemed misnamed.
1629	* op is the spell effect.	1592	* op is the spell effect.
1630	* note that duration is handled by process_object() in time.c	1593	* note that duration is handled by process_object() in time.c
1631	*/	1594	*/
1632
1633	void	1595	void
1634	move_ball_spell (object *op)	1596	move_ball_spell (object *op)
1635	{	1597	{
1636	int i, j, dam_save, dir, mflags;	1598	int i, j, dam_save, dir, mflags;
1637	sint16 nx, ny, hx, hy;	1599	sint16 nx, ny, hx, hy;
…		…
1656	for (i = 1; i < 9; i++)	1618	for (i = 1; i < 9; i++)
1657	{	1619	{
1658	/* i bit 0: alters sign of offset	1620	/* i bit 0: alters sign of offset
1659	* other bits (i / 2): absolute value of offset	1621	* other bits (i / 2): absolute value of offset
1660	*/	1622	*/
1661
1662	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);	1623	int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1663	int tmpdir = absdir (op->direction + offset);	1624	int tmpdir = absdir (op->direction + offset);
1664		1625
1665	nx = op->x + freearr_x[tmpdir];	1626	nx = op->x + freearr_x[tmpdir];
1666	ny = op->y + freearr_y[tmpdir];	1627	ny = op->y + freearr_y[tmpdir];
…		…
1668	{	1629	{
1669	dir = tmpdir;	1630	dir = tmpdir;
1670	break;	1631	break;
1671	}	1632	}
1672	}	1633	}
		1634
1673	if (dir == 0)	1635	if (dir == 0)
1674	{	1636	{
1675	nx = op->x;	1637	nx = op->x;
1676	ny = op->y;	1638	ny = op->y;
1677	m = op->map;	1639	m = op->map;
…		…
1703		1665
1704	if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))	1666	if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
1705	{	1667	{
1706	if (j)	1668	if (j)
1707	op->stats.dam = dam_save / 2;	1669	op->stats.dam = dam_save / 2;
		1670
1708	hit_map (op, j, op->attacktype, 1);	1671	hit_map (op, j, op->attacktype, 1);
1709
1710	}	1672	}
1711		1673
1712	/* insert the other arch */	1674	/* insert the other arch */
1713	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))	1675	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1714	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1676	m->insert (op->other_arch->instance (), hx, hy, op);
1715	}	1677	}
1716		1678
1717	/* restore to the center location and damage */	1679	/* restore to the center location and damage */
1718	op->stats.dam = dam_save;	1680	op->stats.dam = dam_save;
1719		1681
…		…
1728		1690
1729	op->direction = i;	1691	op->direction = i;
1730	}	1692	}
1731	}	1693	}
1732		1694
1733
1734	/* move_swarm_spell: peterm	1695	/* move_swarm_spell: peterm
1735	* This is an implementation of the swarm spell. It was written for	1696	* This is an implementation of the swarm spell. It was written for
1736	* meteor swarm, but it could be used for any swarm. A swarm spell	1697	* meteor swarm, but it could be used for any swarm. A swarm spell
1737	* is a special type of object that casts swarms of other types	1698	* is a special type of object that casts swarms of other types
1738	* of spells. Which spell it casts is flexible. It fires the spells	1699	* of spells. Which spell it casts is flexible. It fires the spells
1739	* from a set of squares surrounding the caster, in a given direction.	1700	* from a set of squares surrounding the caster, in a given direction.
1740	*/	1701	*/
1741
1742	void	1702	void
1743	move_swarm_spell (object *op)	1703	move_swarm_spell (object *op)
1744	{	1704	{
1745	#if 0	1705	#if 0
1746	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };	1706	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1747	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };	1707	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1748	sint16 target_x, target_y, origin_x, origin_y;	1708	sint16 target_x, target_y, origin_x, origin_y;
1749	int adjustdir;	1709	int adjustdir;
1750	maptile *m;	1710	maptile *m;
1751	#endif	1711	#endif
1752	int basedir;
1753	object *owner;	1712	object *owner = op->env;
1754		1713
1755	owner = op->owner;	1714	if (!owner) // MUST not happen, remove when true TODO
1756	if (op->duration == 0 || owner == NULL)
1757	{	1715	{
		1716	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1758	op->destroy ();	1717	op->destroy ();
1759	return;	1718	return;
1760	}	1719	}
1761		1720
		1721	if (!op->duration || !owner->is_on_map ())
		1722	{
		1723	op->drop_and_destroy ();
		1724	return;
		1725	}
		1726
1762	op->duration--;	1727	op->duration--;
1763		1728
1764	basedir = op->direction;	1729	int basedir = op->direction;
1765	if (basedir == 0)	1730	if (!basedir)
1766	{	1731	{
1767	/* spray in all directions! 8) */	1732	/* spray in all directions! 8) */
1768	basedir = rndm (1, 8);	1733	op->facing = (op->facing + op->state) & 7;
		1734	basedir = op->facing + 1;
1769	}	1735	}
1770		1736
1771	#if 0	1737	#if 0
1772	// this is bogus: it causes wrong places to be checked below	1738	// this is bogus: it causes wrong places to be checked below
1773	// (a wall 2 cells away will block the effect...) and	1739	// (a wall 2 cells away will block the effect...) and
…		…
1834	{	1800	{
1835	/* Bullet spells have a bunch more customization that needs to be done */	1801	/* Bullet spells have a bunch more customization that needs to be done */
1836	if (op->spell->subtype == SP_BULLET)	1802	if (op->spell->subtype == SP_BULLET)
1837	fire_bullet (owner, op, basedir, op->spell);	1803	fire_bullet (owner, op, basedir, op->spell);
1838	else if (op->spell->subtype == SP_MAGIC_MISSILE)	1804	else if (op->spell->subtype == SP_MAGIC_MISSILE)
1839	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);	1805	fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1840	}	1806	}
1841	}	1807	}
1842
1843
1844
1845		1808
1846	/* fire_swarm:	1809	/* fire_swarm:
1847	* The following routine creates a swarm of objects. It actually	1810	* The following routine creates a swarm of objects. It actually
1848	* sets up a specific swarm object, which then fires off all	1811	* sets up a specific swarm object, which then fires off all
1849	* the parts of the swarm.	1812	* the parts of the swarm.
…		…
1852	* caster: the caster (owner, wand, rod, scroll)	1815	* caster: the caster (owner, wand, rod, scroll)
1853	* dir: the direction everything will be fired in	1816	* dir: the direction everything will be fired in
1854	* spell - the spell that is this spell.	1817	* spell - the spell that is this spell.
1855	* n: the number to be fired.	1818	* n: the number to be fired.
1856	*/	1819	*/
1857
1858	int	1820	int
1859	fire_swarm (object *op, object *caster, object *spell, int dir)	1821	fire_swarm (object *op, object *caster, object *spell, int dir)
1860	{	1822	{
1861	object *tmp;
1862	int i;
1863
1864	if (!spell->other_arch)	1823	if (!spell->other_arch)
1865	return 0;	1824	return 0;
1866		1825
1867	tmp = get_archetype (SWARM_SPELL);	1826	object *tmp = archetype::get (SWARM_SPELL);
1868	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */	1827
1869	set_spell_skill (op, caster, spell, tmp);	1828	set_spell_skill (op, caster, spell, tmp);
1870
1871	tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */	1829	tmp->level = casting_level (caster, spell); /* needed later, to get level dep. right. */
1872	tmp->spell = arch_to_object (spell->other_arch);	1830	tmp->spell = spell->other_arch->instance ();
1873
1874	tmp->attacktype = tmp->spell->attacktype;	1831	tmp->attacktype = tmp->spell->attacktype;
1875		1832
1876	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)	1833	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1877	if (!tailor_god_spell (tmp, op))	1834	if (!tailor_god_spell (tmp, op))
1878	return 1;	1835	return 1;
1879		1836
1880	tmp->duration = SP_level_duration_adjust (caster, spell);	1837	tmp->duration = SP_level_duration_adjust (caster, spell);
1881	for (i = 0; i < spell->duration; i++)	1838	for (int i = 0; i < spell->duration; i++)
1882	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1839	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1883		1840
		1841	tmp->invisible = 1;
		1842	tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1884	tmp->direction = dir;	1843	tmp->direction = dir;
1885	tmp->invisible = 1;	1844	tmp->facing = rndm (1, 8); // initial firing direction
		1845	tmp->state = rndm (4) * 2 + 1; // direction increment
1886		1846
1887	tmp->insert_at (op, op);	1847	op->insert (tmp);
		1848
1888	return 1;	1849	return 1;
1889	}	1850	}
1890
1891		1851
1892	/* See the spells documentation file for why this is its own	1852	/* See the spells documentation file for why this is its own
1893	* function.	1853	* function.
1894	*/	1854	*/
1895	int	1855	int
…		…
1900	int dam, mflags;	1860	int dam, mflags;
1901	maptile *m;	1861	maptile *m;
1902		1862
1903	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1863	dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1904		1864
1905	if (!dir)	1865	if (dir)
1906	{
1907	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1908	return 0;
1909	}	1866	{
1910
1911	x = op->x + freearr_x[dir];	1867	x = op->x + freearr_x[dir];
1912	y = op->y + freearr_y[dir];	1868	y = op->y + freearr_y[dir];
1913	m = op->map;	1869	m = op->map;
1914		1870
1915	mflags = get_map_flags (m, &m, x, y, &x, &y);	1871	mflags = get_map_flags (m, &m, x, y, &x, &y);
1916		1872
1917	if (mflags & P_OUT_OF_MAP)	1873	if (mflags & P_OUT_OF_MAP)
1918	{	1874	{
1919	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1875	op->failmsg ("Nothing is there.");
1920	return 0;	1876	return 0;
1921	}	1877	}
1922		1878
1923	if (mflags & P_IS_ALIVE && spell->attacktype)	1879	if (mflags & P_IS_ALIVE && spell->attacktype)
1924	{	1880	{
1925	for (target = GET_MAP_OB (m, x, y); target; target = target->above)	1881	for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1926	if (QUERY_FLAG (target, FLAG_MONSTER))	1882	if (target->flag [FLAG_MONSTER])
1927	{	1883	{
1928	/* oky doky. got a target monster. Lets make a blinding attack */	1884	/* oky doky. got a target monster. Lets make a blinding attack */
1929	if (target->head)	1885	if (target->head)
1930	target = target->head;	1886	target = target->head;
		1887
1931	(void) hit_player (target, dam, op, spell->attacktype, 1);	1888	hit_player (target, dam, op, spell->attacktype, 1);
1932	return 1; /* one success only! */	1889	return 1; /* one success only! */
		1890	}
1933	}	1891	}
1934	}
1935		1892
1936	/* no live target, perhaps a wall is in the way? */	1893	/* no live target, perhaps a wall is in the way? */
1937	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))	1894	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
1938	{	1895	{
1939	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1896	op->failmsg ("Something is in the way.");
1940	return 0;	1897	return 0;
		1898	}
1941	}	1899	}
1942		1900
1943	/* ok, looks groovy to just insert a new light on the map */	1901	/* ok, looks groovy to just insert a new light on the map */
1944	tmp = arch_to_object (spell->other_arch);	1902	tmp = spell->other_arch->instance ();
1945	if (!tmp)	1903	if (!tmp)
1946	{	1904	{
1947	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1905	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1948	return 0;	1906	return 0;
1949	}	1907	}
		1908
1950	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1909	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
		1910
1951	if (tmp->glow_radius)	1911	if (tmp->glow_radius)
1952	{	1912	tmp->set_glow_radius (
1953	tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);	1913	clamp (spell->range + SP_level_range_adjust (caster, spell), 1, MAX_LIGHT_RADIUS)
1954	if (tmp->glow_radius > MAX_LIGHT_RADII)	1914	);
1955	tmp->glow_radius = MAX_LIGHT_RADII;
1956	}
1957		1915
		1916	if (dir)
1958	m->insert (tmp, x, y, op);	1917	m->insert (tmp, x, y, op);
		1918	else
		1919	caster->outer_env_or_self ()->insert (tmp);
		1920
1959	return 1;	1921	return 1;
1960	}	1922	}
1961
1962
1963
1964		1923
1965	/* cast_cause_disease: this spell looks along <dir> from the	1924	/* cast_cause_disease: this spell looks along <dir> from the
1966	* player and infects someone.	1925	* player and infects someone.
1967	* op is the player/monster, caster is the object, dir is the direction	1926	* op is the player/monster, caster is the object, dir is the direction
1968	* to cast, disease_arch is the specific disease, and type is the spell number	1927	* to cast, disease_arch is the specific disease, and type is the spell number
1969	* perhaps this should actually be in disease.c?	1928	* perhaps this should actually be in disease.c?
1970	*/	1929	*/
1971
1972	int	1930	int
1973	cast_cause_disease (object *op, object *caster, object *spell, int dir)	1931	cast_cause_disease (object *op, object *caster, object *spell, int dir)
1974	{	1932	{
1975	sint16 x, y;	1933	sint16 x, y;
1976	int i, mflags, range, dam_mod, dur_mod;	1934	int i, mflags, range, dam_mod, dur_mod;
…		…
1983	/* If casting from a scroll, no direction will be available, so refer to the	1941	/* If casting from a scroll, no direction will be available, so refer to the
1984	* direction the player is pointing.	1942	* direction the player is pointing.
1985	*/	1943	*/
1986	if (!dir)	1944	if (!dir)
1987	dir = op->facing;	1945	dir = op->facing;
		1946
1988	if (!dir)	1947	if (!dir)
1989	return 0; /* won't find anything if casting on ourself, so just return */	1948	return 0; /* won't find anything if casting on ourself, so just return */
1990		1949
1991	/* Calculate these once here */	1950	/* Calculate these once here */
1992	range = spell->range + SP_level_range_adjust (caster, spell);	1951	range = spell->range + SP_level_range_adjust (caster, spell);
…		…
2012	/* Only bother looking on this space if there is something living here */	1971	/* Only bother looking on this space if there is something living here */
2013	if (mflags & P_IS_ALIVE)	1972	if (mflags & P_IS_ALIVE)
2014	{	1973	{
2015	/* search this square for a victim */	1974	/* search this square for a victim */
2016	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)	1975	for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
2017	if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))	1976	if (walk->flag [FLAG_MONSTER] || (walk->type == PLAYER))
2018	{ /* found a victim */	1977	{ /* found a victim */
2019	object *disease = arch_to_object (spell->other_arch);	1978	object *disease = spell->other_arch->instance ();
2020		1979
2021	disease->set_owner (op);	1980	disease->set_owner (op);
2022	set_spell_skill (op, caster, spell, disease);	1981	set_spell_skill (op, caster, spell, disease);
2023	disease->stats.exp = 0;	1982	disease->stats.exp = 0;
2024	disease->level = caster_level (caster, spell);	1983	disease->level = casting_level (caster, spell);
2025		1984
2026	/* do level adjustments */	1985	/* do level adjustments */
2027	if (disease->stats.wc)	1986	if (disease->stats.wc ) disease->stats.wc += dur_mod / 2;
2028	disease->stats.wc += dur_mod / 2;	1987	if (disease->magic > 0) disease->magic += dur_mod / 8;
2029		1988	if (disease->stats.maxhp > 0) disease->stats.maxhp += dur_mod;
2030	if (disease->magic > 0)	1989	if (disease->stats.maxgrace > 0) disease->stats.maxgrace += dur_mod;
2031	disease->magic += dur_mod / 4;
2032
2033	if (disease->stats.maxhp > 0)
2034	disease->stats.maxhp += dur_mod;
2035
2036	if (disease->stats.maxgrace > 0)
2037	disease->stats.maxgrace += dur_mod;
2038
2039	if (disease->stats.dam)
2040	{
2041	if (disease->stats.dam > 0)
2042	disease->stats.dam += dam_mod;
2043	else
2044	disease->stats.dam -= dam_mod;
2045	}
2046		1990
2047	if (disease->last_sp)	1991	if (disease->last_sp)
2048	{	1992	{
2049	disease->last_sp -= 2 * dam_mod;	1993	disease->last_sp -= 2 * dam_mod;
		1994
2050	if (disease->last_sp < 1)	1995	if (disease->last_sp < 1)
2051	disease->last_sp = 1;	1996	disease->last_sp = 1;
2052	}	1997	}
2053		1998
2054	if (disease->stats.maxsp)	1999	if (disease->stats.dam ) disease->stats.dam += copysign (disease->stats.dam , dam_mod);
2055	{	2000	if (disease->stats.maxsp) disease->stats.maxsp += copysign (disease->stats.maxsp, dam_mod);
2056	if (disease->stats.maxsp > 0)	2001	if (disease->stats.ac ) disease->stats.ac += dam_mod;
2057	disease->stats.maxsp += dam_mod;	2002	if (disease->last_eat ) disease->last_eat -= dam_mod;
2058	else	2003	if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2059	disease->stats.maxsp -= dam_mod;	2004	if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2060	}
2061
2062	if (disease->stats.ac)
2063	disease->stats.ac += dam_mod;
2064
2065	if (disease->last_eat)
2066	disease->last_eat -= dam_mod;
2067
2068	if (disease->stats.hp)
2069	disease->stats.hp -= dam_mod;
2070
2071	if (disease->stats.sp)
2072	disease->stats.sp -= dam_mod;
2073		2005
2074	if (infect_object (walk, disease, 1))	2006	if (infect_object (walk, disease, 1))
2075	{	2007	{
2076	new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);	2008	op->statusmsg (format ("You inflict %s on %s!", &disease->name, &walk->name));
2077		2009
2078	disease->destroy (); /* don't need this one anymore */	2010	disease->destroy (); /* don't need this one anymore */
2079	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2011	walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
2080	return 1;	2012	return 1;
2081	}	2013	}
2082		2014
2083	disease->destroy ();	2015	disease->destroy ();
2084	}	2016	}

Diff Legend

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