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

Diff Legend

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