[ViewVC] Diff of: cvs/deliantra/server/server/spell

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.73 by root, Sun Dec 28 06:59:27 2008 UTC vs.
Revision 1.114 by root, Wed Nov 16 23:42:03 2016 UTC

…		…
1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 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	* Deliantra 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 <support@deliantra.net>	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
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	void	42	static void
42	check_spell_knockback (object *op)	43	check_spell_knockback (object *op)
43	{	44	{
44	int weight_move;	45	int weight_move;
45	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 /
46		47
…		…
58	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)	59	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
59	{	60	{
60	int num_sections = 1;	61	int num_sections = 1;
61		62
62	/* don't move DM */	63	/* don't move DM */
63	if (QUERY_FLAG (tmp, FLAG_WIZ))	64	if (tmp->flag [FLAG_WIZ])
64	return;	65	return;
65		66
66	/* don't move parts of objects */	67	/* don't move parts of objects */
67	if (tmp->head)	68	if (tmp->head)
68	continue;	69	continue;
69		70
70	/* don't move floors or immobile objects */	71	/* don't move floors or immobile objects */
71	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]))
72	continue;	73	continue;
73		74
74	/* count the object's sections */	75	/* count the object's sections */
75	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)	76	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
76	num_sections++;	77	num_sections++;
…		…
92	* also be safe for objects.	93	* also be safe for objects.
93	* This does return if successful or not, but	94	* This does return if successful or not, but
94	* I don't see us doing anything useful with that information	95	* I don't see us doing anything useful with that information
95	* right now.	96	* right now.
96	*/	97	*/
97	move_object (tmp, absdir (op->stats.sp));	98	tmp->move (absdir (op->stats.sp));
98	}	99	}
99		100
100	}	101	}
101	}	102	}
102		103
…		…
107	***************************************************************************/	108	***************************************************************************/
108		109
109	/* Causes op to fork. op is the original bolt, tmp	110	/* Causes op to fork. op is the original bolt, tmp
110	* is the first piece of the fork.	111	* is the first piece of the fork.
111	*/	112	*/
112	void	113	static void
113	forklightning (object op, object tmp)	114	forklightning (object op, object tmp)
114	{	115	{
115	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 */
116	int t_dir; /* stores temporary dir calculation */	117	int t_dir; /* stores temporary dir calculation */
117	maptile *m;	118	maptile *m;
…		…
193	* 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
194	* will be useful.	195	* will be useful.
195	*/	196	*/
196	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)))
197	{	198	{
198	if (!QUERY_FLAG (op, FLAG_REFLECTING))	199	if (!op->flag [FLAG_REFLECTING])
199	return;	200	return;
200		201
201	/* Since walls don't run diagonal, if the bolt is in	202	/* Since walls don't run diagonal, if the bolt is in
202	* one of 4 main directions, it just reflects back in the	203	* one of 4 main directions, it just reflects back in the
203	* opposite direction. However, if the bolt is travelling	204	* opposite direction. However, if the bolt is travelling
…		…
276	int mflags;	277	int mflags;
277		278
278	if (!spob->other_arch)	279	if (!spob->other_arch)
279	return 0;	280	return 0;
280		281
281	tmp = arch_to_object (spob->other_arch);	282	tmp = spob->other_arch->instance ();
282	if (tmp == NULL)	283	if (tmp == NULL)
283	return 0;	284	return 0;
284		285
285	/* peterm: level dependency for bolts */	286	/* peterm: level dependency for bolts */
286	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->duration = spob->duration + SP_level_duration_adjust (caster, spob);	294	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
294	tmp->stats.Dex = spob->stats.Dex;	295	tmp->stats.Dex = spob->stats.Dex;
295	tmp->stats.Con = spob->stats.Con;	296	tmp->stats.Con = spob->stats.Con;
296		297
297	tmp->direction = dir;	298	tmp->direction = dir;
298	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	299	if (tmp->flag [FLAG_IS_TURNABLE])
299	SET_ANIMATION (tmp, dir);	300	SET_ANIMATION (tmp, dir);
300		301
301	tmp->set_owner (op);	302	tmp->set_owner (op);
302	set_spell_skill (op, caster, spob, tmp);	303	set_spell_skill (op, caster, spob, tmp);
303		304
…		…
315		316
316	tmp->map = newmap;	317	tmp->map = newmap;
317		318
318	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)))
319	{	320	{
320	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	321	if (!tmp->flag [FLAG_REFLECTING])
321	{	322	{
322	tmp->drop_and_destroy ();	323	tmp->drop_and_destroy ();
323	return 0;	324	return 0;
324	}	325	}
325		326
…		…
388		389
389	/* Causes an object to explode, eg, a firebullet,	390	/* Causes an object to explode, eg, a firebullet,
390	* poison cloud ball, etc. op is the object to	391	* poison cloud ball, etc. op is the object to
391	* explode.	392	* explode.
392	*/	393	*/
393	void	394	static void
394	explode_bullet (object *op)	395	explode_bullet (object *op)
395	{	396	{
396	object tmp, owner;	397	object tmp, owner;
397		398
398	if (!op->other_arch)	399	if (!op->other_arch)
…		…
438	if (op->destroyed ())	439	if (op->destroyed ())
439	return;	440	return;
440	}	441	}
441		442
442	/* other_arch contains what this explodes into */	443	/* other_arch contains what this explodes into */
443	tmp = arch_to_object (op->other_arch);	444	tmp = op->other_arch->instance ();
444		445
445	tmp->set_owner (op);	446	tmp->set_owner (op);
446	tmp->skill = op->skill;	447	tmp->skill = op->skill;
447		448
448	owner = op->owner;	449	owner = op->owner;
…		…
520	if (!(mflags & P_IS_ALIVE))	521	if (!(mflags & P_IS_ALIVE))
521	return;	522	return;
522		523
523	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	524	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
524	{	525	{
525	if (QUERY_FLAG (tmp, FLAG_ALIVE))	526	if (tmp->flag [FLAG_ALIVE])
526	{	527	{
527	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	528	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
528		529
529	// TODO: can't understand the following if's	530	// TODO: can't understand the following if's
530	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)	531	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)
531	{	532	{
532	if (!QUERY_FLAG (op, FLAG_REMOVED))	533	if (!op->flag [FLAG_REMOVED])
533	{	534	{
534	op->destroy ();	535	op->destroy ();
535	return;	536	return;
536	}	537	}
537	}	538	}
…		…
545	* fired arches (eg, bolts).	546	* fired arches (eg, bolts).
546	*/	547	*/
547	void	548	void
548	move_bullet (object *op)	549	move_bullet (object *op)
549	{	550	{
550	sint16 new_x, new_y;
551	int mflags;
552	maptile *m;
553
554	#if 0	551	#if 0
555	/* We need a better general purpose way to do this */	552	/* We need a better general purpose way to do this */
556		553
557	/* peterm: added to make comet leave a trail of burnouts	554	/* peterm: added to make comet leave a trail of burnouts
558	it's an unadulterated hack, but the effect is cool. */	555	it's an unadulterated hack, but the effect is cool. */
…		…
573	op->destroy ();	570	op->destroy ();
574		571
575	return;	572	return;
576	}	573	}
577		574
578	new_x = op->x + DIRX (op);	575	mapxy pos (op);
579	new_y = op->y + DIRY (op);	576	pos.move (op->direction);
580	m = op->map;
581	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
582		577
583	if (mflags & P_OUT_OF_MAP)	578	if (!pos.normalise ())
584	{	579	{
585	op->destroy ();	580	op->destroy ();
586	return;	581	return;
587	}	582	}
588		583
589	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))
590	{	589	{
591	if (op->other_arch)	590	if (op->other_arch)
592	explode_bullet (op);	591	explode_bullet (op);
593	else	592	else
594	op->destroy ();	593	op->destroy ();
595		594
596	return;	595	return;
597	}	596	}
598		597
599	if (!(op = m->insert (op, new_x, new_y, op)))	598	if (!(op = pos.insert (op, op)))
600	return;	599	return;
601		600
602	if (reflwall (op->map, op->x, op->y, op))	601	if (reflwall (op->map, op->x, op->y, op))
603	{	602	{
604	op->direction = absdir (op->direction + 4);	603	op->direction = absdir (op->direction + 4);
…		…
641	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);	640	tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
642	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);	641	tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
643	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);
644		643
645	tmp->direction = dir;	644	tmp->direction = dir;
646	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	645	if (tmp->flag [FLAG_IS_TURNABLE])
647	SET_ANIMATION (tmp, dir);	646	SET_ANIMATION (tmp, dir);
648		647
649	tmp->set_owner (op);	648	tmp->set_owner (op);
650	set_spell_skill (op, caster, spob, tmp);	649	set_spell_skill (op, caster, spob, tmp);
651		650
…		…
661	return 0;	660	return 0;
662	}	661	}
663		662
664	tmp->map = newmap;	663	tmp->map = newmap;
665		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
666	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)))
667	{	679	{
668	if (!QUERY_FLAG (tmp, FLAG_REFLECTING))	680	if (!tmp->flag [FLAG_REFLECTING])
669	{	681	{
670	tmp->destroy ();	682	tmp->destroy ();
671	return 0;	683	return 0;
672	}	684	}
673		685
…		…
688	* CONE RELATED FUNCTIONS	700	* CONE RELATED FUNCTIONS
689	*	701	*
690	*****************************************************************************/	702	*****************************************************************************/
691		703
692	/* 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" */
693	void	705	static void
694	cone_drop (object *op)	706	cone_drop (object *op)
695	{	707	{
696	object *new_ob = arch_to_object (op->other_arch);	708	object *new_ob = op->other_arch->instance ();
697		709
698	new_ob->level = op->level;	710	new_ob->level = op->level;
699	new_ob->set_owner (op->owner);	711	new_ob->set_owner (op->owner);
700		712
701	/* preserve skill ownership */	713	/* preserve skill ownership */
…		…
717	op->set_speed (0);	729	op->set_speed (0);
718	return;	730	return;
719	}	731	}
720		732
721	/* lava saves it's life, but not yours :) */	733	/* lava saves it's life, but not yours :) */
722	if (QUERY_FLAG (op, FLAG_LIFESAVE))	734	if (op->flag [FLAG_LIFESAVE])
723	{	735	{
724	hit_map (op, 0, op->attacktype, 0);	736	hit_map (op, 0, op->attacktype, 0);
725	return;	737	return;
726	}	738	}
727		739
…		…
808	MoveType movetype;	820	MoveType movetype;
809		821
810	if (!spell->other_arch)	822	if (!spell->other_arch)
811	return 0;	823	return 0;
812		824
813	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)
814	{	826	{
815	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!");
816	return 0;	828	return 0;
817	}	829	}
818		830
819	if (!dir)	831	if (!dir)
820	{	832	{
…		…
828	*/	840	*/
829	movetype = spell->other_arch->move_type;	841	movetype = spell->other_arch->move_type;
830		842
831	for (i = range_min; i <= range_max; i++)	843	for (i = range_min; i <= range_max; i++)
832	{	844	{
833	sint16 x, y, d;	845	sint16 x, y;
834		846
835	/* We can't use absdir here, because it never returns	847	/* We can't use absdir here, because it never returns
836	* 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
837	* 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
838	* to hit that person.	850	* to hit that person.
839	*/	851	*/
840	d = dir + i;	852	int d = dir ? absdir (dir + i) : i;
841	while (d < 0)
842	d += 8;
843	while (d > 8)
844	d -= 8;
845		853
846	/* 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.
847	* In that case, we have to see - if dir is specified,	855	* In that case, we have to see - if dir is specified,
848	* turn this into direction 8. If dir is not specified (all	856	* turn this into direction 8. If dir is not specified (all
849	* direction) skip - otherwise, one line would do more damage	857	* direction) skip - otherwise, one line would do more damage
…		…
866		874
867	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)	875	if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
868	continue;	876	continue;
869		877
870	success = 1;	878	success = 1;
871	tmp = arch_to_object (spell->other_arch);	879	tmp = spell->other_arch->instance ();
872	tmp->set_owner (op);	880	tmp->set_owner (op);
873	set_spell_skill (op, caster, spell, tmp);	881	set_spell_skill (op, caster, spell, tmp);
874	tmp->level = casting_level (caster, spell);	882	tmp->level = casting_level (caster, spell);
875	tmp->attacktype = spell->attacktype;	883	tmp->attacktype = spell->attacktype;
876		884
…		…
951		959
952	object *env = op->outer_env ();	960	object *env = op->outer_env ();
953		961
954	if (op->env)	962	if (op->env)
955	{	963	{
956	if (env->map == NULL)	964	if (!env->map)
957	return;	965	return;
958		966
959	if (!(op = op->insert_at (env, op)))	967	if (!(op = op->insert_at (env, op)))
960	return;	968	return;
961	}	969	}
962		970
963	// 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
964	// 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
965	// as bombs can be carried.	973	// as bombs can be carried.
966	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	974	if (op->ms ().flags () & P_SAFE)
967	{	975	{
968	op->destroy ();	976	op->destroy ();
969	return;	977	return;
970	}	978	}
971		979
…		…
978	for (int i = 1; i < 9; i++)	986	for (int i = 1; i < 9; i++)
979	{	987	{
980	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]))
981	continue;	989	continue;
982		990
983	object *tmp = arch_to_object (at);	991	object *tmp = at->instance ();
984	tmp->direction = i;	992	tmp->direction = i;
985	tmp->range = op->range;	993	tmp->range = op->range;
986	tmp->stats.dam = op->stats.dam;	994	tmp->stats.dam = op->stats.dam;
987	tmp->duration = op->duration;	995	tmp->duration = op->duration;
988	tmp->attacktype = op->attacktype;	996	tmp->attacktype = op->attacktype;
989	tmp->set_owner (op);	997	tmp->set_owner (op);
990	if (op->skill && op->skill != tmp->skill)	998	if (op->skill && op->skill != tmp->skill)
991	tmp->skill = op->skill;	999	tmp->skill = op->skill;
992		1000
993	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	1001	if (tmp->flag [FLAG_IS_TURNABLE])
994	SET_ANIMATION (tmp, i);	1002	SET_ANIMATION (tmp, i);
995		1003
996	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);
997	move_bullet (tmp);	1005	move_bullet (tmp);
998	}	1006	}
…		…
1017	// to fix create bomb traps in doors, which cast with dir=0).	1025	// to fix create bomb traps in doors, which cast with dir=0).
1018	if (dir)	1026	if (dir)
1019	{	1027	{
1020	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))
1021	{	1029	{
1022	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1030	op->failmsg ("There is something in the way.");
1023	return 0;	1031	return 0;
1024	}	1032	}
1025	}	1033	}
1026		1034
1027	tmp = arch_to_object (spell->other_arch);	1035	tmp = spell->other_arch->instance ();
1028		1036
1029	/* level dependencies for bomb */	1037	/* level dependencies for bomb */
1030	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1038	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1031	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);
1032	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);	1040	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
1052	* dir is the direction to look in.	1060	* dir is the direction to look in.
1053	* range is how far out to look.	1061	* range is how far out to look.
1054	* 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.
1055	* this info is used for blocked magic/unholy spaces.	1063	* this info is used for blocked magic/unholy spaces.
1056	*/	1064	*/
1057	object *	1065	static object *
1058	get_pointed_target (object *op, int dir, int range, int type)	1066	get_pointed_target (object *op, int dir, int range, int type)
1059	{	1067	{
1060	object *target;	1068	object *target;
1061	sint16 x, y;	1069	sint16 x, y;
1062	int dist, mflags;	1070	int dist, mflags;
…		…
1081	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)	1089	if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1082	return NULL;	1090	return NULL;
1083		1091
1084	if (mflags & P_IS_ALIVE)	1092	if (mflags & P_IS_ALIVE)
1085	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)
1086	if (QUERY_FLAG (target, FLAG_MONSTER))	1094	if (target->flag [FLAG_MONSTER])
1087	return target;	1095	return target;
1088	}	1096	}
1089		1097
1090	return NULL;	1098	return NULL;
1091	}	1099	}
1092		1100
1093	/* cast_smite_arch() - the priest points to a creature and causes	1101	/* cast_smite_spell() - the priest points to a creature and causes
1094	* a 'godly curse' to decend.	1102	* a 'godly curse' to decend.
1095	* usual params -	1103	* usual params -
1096	* op = player	1104	* op = player
1097	* caster = object casting the spell.	1105	* caster = object casting the spell.
1098	* dir = direction being cast	1106	* dir = direction being cast
…		…
1101	int	1109	int
1102	cast_smite_spell (object op, object caster, int dir, object *spell)	1110	cast_smite_spell (object op, object caster, int dir, object *spell)
1103	{	1111	{
1104	object effect, target;	1112	object effect, target;
1105	object *god = find_god (determine_god (op));	1113	object *god = find_god (determine_god (op));
1106	int range;
1107		1114
1108	range = spell->range + SP_level_range_adjust (caster, spell);
1109	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);
1110		1116
1111	/* Bunch of conditions for casting this spell. Note that only	1117	/* Bunch of conditions for casting this spell. Note that only
1112	* require a god if this is a cleric spell (requires grace).	1118	* require a god if this is a cleric spell (requires grace).
1113	* 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
…		…
1115	* interesting spell.	1121	* interesting spell.
1116	* 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
1117	* can't be friendly to your god.	1123	* can't be friendly to your god.
1118	*/	1124	*/
1119		1125
1120	if (!target \|\| QUERY_FLAG (target, FLAG_REFL_SPELL)	1126	if (!target
		1127	\|\| target->flag [FLAG_REFL_SPELL]
1121	\|\| (!god && spell->stats.grace)	1128	\|\| (!god && spell->stats.grace)
1122	\|\| (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)))
1123	{	1131	{
1124	new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");	1132	op->failmsg ("Your request is unheeded.");
1125	return 0;	1133	return 0;
1126	}	1134	}
1127		1135
1128	if (spell->other_arch)	1136	if (spell->other_arch)
1129	effect = arch_to_object (spell->other_arch);	1137	effect = spell->other_arch->instance ();
1130	else	1138	else
1131	return 0;	1139	return 0;
1132		1140
1133	/* tailor the effect by priest level and worshipped God */	1141	/* tailor the effect by priest level and worshipped God */
1134	effect->level = casting_level (caster, spell);	1142	effect->level = casting_level (caster, spell);
1135	effect->attacktype = spell->attacktype;	1143	effect->attacktype = spell->attacktype;
1136	if (effect->attacktype & (AT_HOLYWORD \| AT_GODPOWER))	1144	if (effect->attacktype & (AT_HOLYWORD \| AT_GODPOWER))
1137	{	1145	{
1138	if (tailor_god_spell (effect, op))	1146	if (tailor_god_spell (effect, op))
1139	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));
1140	else	1148	else
1141	{	1149	{
1142	new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");	1150	op->failmsg ("Your request is ignored.");
1143	return 0;	1151	return 0;
1144	}	1152	}
1145	}	1153	}
1146		1154
1147	/* size of the area of destruction */	1155	/* size of the area of destruction */
…		…
1151	if (effect->attacktype & AT_DEATH)	1159	if (effect->attacktype & AT_DEATH)
1152	{	1160	{
1153	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1161	effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1154		1162
1155	/* casting death spells at undead isn't a good thing */	1163	/* casting death spells at undead isn't a good thing */
1156	if (QUERY_FLAG (target, FLAG_UNDEAD))	1164	if (target->flag [FLAG_UNDEAD])
1157	{	1165	{
1158	if (random_roll (0, 2, op, PREFER_LOW))	1166	if (random_roll (0, 2, op, PREFER_LOW))
1159	{	1167	{
1160	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");	1168	new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1161	effect->x = op->x;	1169	effect->x = op->x;
…		…
1247	* 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
1248	* object. if time is 0, the object glows permanently. To truely	1256	* object. if time is 0, the object glows permanently. To truely
1249	* make this work for non-living objects, we would have to	1257	* make this work for non-living objects, we would have to
1250	* give them the capability to have an inventory. b.t.	1258	* give them the capability to have an inventory. b.t.
1251	*/	1259	*/
1252	int	1260	static int
1253	make_object_glow (object *op, int radius, int time)	1261	make_object_glow (object *op, int radius, int time)
1254	{	1262	{
1255	/* some things are unaffected... */	1263	/* some things are unaffected... */
1256	if (op->path_denied & PATH_LIGHT)	1264	if (op->path_denied & PATH_LIGHT)
1257	return 0;	1265	return 0;
1258		1266
1259	object *tmp = get_archetype (FORCE_NAME);	1267	object *tmp = archetype::get (FORCE_NAME);
1260	tmp->speed = 0.01;	1268	tmp->set_speed (0.01);
1261	tmp->stats.food = time;	1269	tmp->stats.food = time;
1262	SET_FLAG (tmp, FLAG_IS_USED_UP);	1270	tmp->set_flag (FLAG_IS_USED_UP);
1263	tmp->glow_radius = min (MAX_LIGHT_RADIUS, radius);	1271	tmp->set_glow_radius (min (MAX_LIGHT_RADIUS, radius));
1264	tmp = insert_ob_in_ob (tmp, op);	1272	tmp = insert_ob_in_ob (tmp, op);
1265		1273
1266	if (tmp->glow_radius > op->glow_radius)	1274	if (tmp->glow_radius > op->glow_radius)
1267	op->glow_radius = tmp->glow_radius;	1275	op->set_glow_radius (tmp->glow_radius);
1268		1276
1269	return 1;	1277	return 1;
1270	}	1278	}
1271		1279
1272	int	1280	int
1273	cast_destruction (object op, object caster, object *spell_ob)	1281	cast_destruction (object op, object caster, object *spell_ob)
1274	{	1282	{
1275	int i, j, range, mflags, friendly = 0, dam, dur;
1276	sint16 sx, sy;
1277	maptile *m;
1278	object *tmp;
1279	const char *skill;
1280
1281	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	1283	int range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1282	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);
1283	dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	1285	int dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1284	if (QUERY_FLAG (op, FLAG_FRIENDLY) \|\| op->type == PLAYER)
1285	friendly = 1;
1286		1286
1287	/* destruction doesn't use another spell object, so we need	1287	bool friendly = op->flag [FLAG_FRIENDLY] \|\| op->is_player ();
1288	* update op's skill pointer so that exp is properly awarded.
1289	* We do some shortcuts here - since this is just temporary
1290	* and we'll reset the values back, we don't need to go through
1291	* the full share string/free_string route.
1292	*/
1293	skill = op->skill;
1294	if (caster == op)
1295	op->skill = spell_ob->skill;
1296	else if (caster->skill)
1297	op->skill = caster->skill;
1298	else
1299	op->skill = NULL;
1300		1288
1301	op->change_skill (find_skill_by_name (op, op->skill));	1289	dynbuf buf;
1302		1290	unordered_mapwalk (buf, op, -range, -range, range, range)
1303	for (i = -range; i <= range; i++)
1304	{	1291	{
1305	for (j = -range; j <= range; j++)	1292	mapspace &ms = m->at (nx, ny);
1306	{
1307	m = op->map;
1308	sx = op->x + i;
1309	sy = op->y + j;
1310		1293
1311	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1312	if (mflags & P_OUT_OF_MAP)
1313	continue;
1314
1315	if (mflags & P_IS_ALIVE)	1294	if (ms.flags () & P_IS_ALIVE)
		1295	for (object next, tmp = ms.bot; tmp; tmp = next)
1316	{	1296	{
1317	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)	1297	next = tmp->above;
1318	if (QUERY_FLAG (tmp, FLAG_ALIVE) \|\| tmp->type == PLAYER)
1319	break;
1320		1298
1321	if (tmp)	1299	if (tmp->flag [FLAG_ALIVE] \|\| tmp->is_player ())
1322	{	1300	{
1323	if (tmp->head)
1324	tmp = tmp->head;	1301	tmp = tmp->head_ ();
1325		1302
1326	if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) \|\|	1303	if ((friendly && !tmp->flag [FLAG_FRIENDLY] && !tmp->is_player ())
1327	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) \|\| tmp->type == PLAYER)))	1304	\|\| (!friendly && (tmp->flag [FLAG_FRIENDLY] \|\| tmp->is_player ())))
1328	{	1305	{
1329	if (spell_ob->subtype == SP_DESTRUCTION)	1306	if (spell_ob->subtype == SP_DESTRUCTION)
1330	{	1307	{
1331	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1308	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1332		1309
1333	if (spell_ob->other_arch)	1310	if (spell_ob->other_arch)
1334	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1311	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1335	}	1312	}
1336	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)
1337	{	1314	{
1338	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)	1315	if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1339	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1316	m->insert (spell_ob->other_arch->instance (), nx, ny, op);
1340	}	1317	}
1341	}	1318	}
1342	}	1319	}
1343	}	1320	}
1344	}
1345	}	1321	}
1346		1322
1347	op->skill = skill;
1348	return 1;	1323	return 1;
1349	}	1324	}
1350		1325
1351	/***************************************************************************	1326	/***************************************************************************
1352	*	1327	*
1353	* CURSE	1328	* CURSE
1354	*	1329	*
1355	***************************************************************************/	1330	***************************************************************************/
1356
1357	int	1331	int
1358	cast_curse (object op, object caster, object *spell_ob, int dir)	1332	cast_curse (object op, object caster, object *spell_ob, int dir)
1359	{	1333	{
1360	object *god = find_god (determine_god (op));	1334	object *god = find_god (determine_god (op));
1361	object tmp, force;	1335	object tmp, force;
1362		1336
1363	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);
1364	if (!tmp)	1338	if (!tmp)
1365	{	1339	{
1366	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.");
1367	return 0;	1341	return 0;
1368	}	1342	}
1369		1343
1370	tmp = tmp->head_ ();	1344	tmp = tmp->head_ ();
1371		1345
…		…
1386	}	1360	}
1387	}	1361	}
1388		1362
1389	if (!force)	1363	if (!force)
1390	{	1364	{
1391	force = get_archetype (FORCE_NAME);	1365	force = archetype::get (FORCE_NAME);
1392	force->subtype = FORCE_CHANGE_ABILITY;	1366	force->subtype = FORCE_CHANGE_ABILITY;
1393		1367
1394	if (spell_ob->race)	1368	if (spell_ob->race)
1395	force->name = spell_ob->race;	1369	force->name = spell_ob->race;
1396	else	1370	else
…		…
1414		1388
1415	return 1;	1389	return 1;
1416	}	1390	}
1417		1391
1418	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;
1419	force->speed = 1.f;
1420	force->speed_left = -1.f;	1393	force->speed_left = -1.f;
1421	SET_FLAG (force, FLAG_APPLIED);	1394	force->set_speed (1.f);
		1395	force->set_flag (FLAG_APPLIED);
1422		1396
1423	if (god)	1397	if (god)
1424	{	1398	{
1425	if (spell_ob->last_grace)	1399	if (spell_ob->last_grace)
1426	force->path_repelled = god->path_repelled;	1400	force->path_repelled = god->path_repelled;
…		…
1439	force->stats.wc = spell_ob->stats.wc;	1413	force->stats.wc = spell_ob->stats.wc;
1440		1414
1441	change_abil (tmp, force); /* Mostly to display any messages */	1415	change_abil (tmp, force); /* Mostly to display any messages */
1442	insert_ob_in_ob (force, tmp);	1416	insert_ob_in_ob (force, tmp);
1443	tmp->update_stats ();	1417	tmp->update_stats ();
		1418
1444	return 1;	1419	return 1;
1445
1446	}	1420	}
1447		1421
1448	/**********************************************************************	1422	/**********************************************************************
1449	* mood change	1423	* mood change
1450	* 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
…		…
1456	*/	1430	*/
1457	int	1431	int
1458	mood_change (object op, object caster, object *spell)	1432	mood_change (object op, object caster, object *spell)
1459	{	1433	{
1460	object tmp, god, *head;	1434	object tmp, god, *head;
1461	int done_one, range, mflags, level, at, best_at;	1435	int done_one, range, level, at, best_at;
1462	sint16 x, y, nx, ny;
1463	maptile *m;
1464	const char *race;	1436	const char *race;
1465		1437
1466	/* 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
1467	* doing it over and over again.	1439	* doing it over and over again.
1468	*/	1440	*/
…		…
1474	* 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
1475	* won't ever match anything.	1447	* won't ever match anything.
1476	*/	1448	*/
1477	if (!spell->race)	1449	if (!spell->race)
1478	race = NULL;	1450	race = NULL;
1479	else if (god && !strcmp (spell->race, "GOD_SLAYING"))	1451	else if (god && spell->race == shstr_GOD_SLAYING)
1480	race = god->slaying;	1452	race = god->slaying;
1481	else if (god && !strcmp (spell->race, "GOD_FRIEND"))	1453	else if (god && spell->race == shstr_GOD_FRIEND)
1482	race = god->race;	1454	race = god->race;
1483	else	1455	else
1484	race = spell->race;	1456	race = spell->race;
1485		1457
1486	for (x = op->x - range; x <= op->x + range; x++)	1458	dynbuf buf;
1487	for (y = op->y - range; y <= op->y + range; y++)	1459	unordered_mapwalk (buf, op, -range, -range, range, range)
1488	{	1460	{
1489	done_one = 0;	1461	mapspace &ms = m->at (nx, ny);
1490	m = op->map;
1491	nx = x;
1492	ny = y;
1493	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1494	if (mflags & P_OUT_OF_MAP)
1495	continue;
1496		1462
1497	/* 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 */
1498	if (!(mflags & P_IS_ALIVE))	1464	if (!(ms.flags () & P_IS_ALIVE))
1499	continue;	1465	continue;
1500		1466
1501	// players can only affect spaces that they can actually see	1467	// players can only affect spaces that they can actually see
1502	if (caster	1468	if (caster
1503	&& caster->contr	1469	&& caster->contr
1504	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)	1470	&& caster->contr->darkness_at (m, nx, ny) == LOS_BLOCKED)
1505	continue;	1471	continue;
1506		1472
1507	for (tmp = GET_MAP_TOP (m, nx, ny); tmp; tmp = tmp->below)	1473	for (tmp = ms.top; tmp; tmp = tmp->below)
1508	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1474	if (tmp->flag [FLAG_MONSTER])
1509	break;	1475	break;
1510		1476
1511	/* There can be living objects that are not monsters */	1477	/* There can be living objects that are not monsters */
1512	if (!tmp \|\| tmp->type == PLAYER)	1478	if (!tmp)
1513	continue;	1479	continue;
1514		1480
1515	/* Only the head has meaningful data, so resolve to that */	1481	/* Only the head has meaningful data, so resolve to that */
1516	if (tmp->head)
1517	head = tmp->head;	1482	head = tmp->head_ ();
1518	else
1519	head = tmp;
1520		1483
1521	/* 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 */
1522	if (race && head->race && !strstr (race, head->race))	1485	if (race && head->race && !strstr (race, head->race))
1523	continue;	1486	continue;
1524		1487
1525	if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))	1488	if (head->flag [FLAG_UNDEAD] && !spell->flag [FLAG_UNDEAD])
1526	continue;	1489	continue;
1527		1490
1528	/* Now do a bunch of stuff related to saving throws */	1491	/* Now do a bunch of stuff related to saving throws */
1529	best_at = -1;	1492	best_at = -1;
1530	if (spell->attacktype)	1493	if (spell->attacktype)
1531	{	1494	{
1532	for (at = 0; at < NROFATTACKS; at++)	1495	for (at = 0; at < NROFATTACKS; at++)
1533	if (spell->attacktype & (1 << at))	1496	if (spell->attacktype & (1 << at))
1534	if (best_at == -1 \|\| head->resist[at] > head->resist[best_at])	1497	if (best_at == -1 \|\| head->resist[at] > head->resist[best_at])
1535	best_at = at;	1498	best_at = at;
1536		1499
1537	if (best_at == -1)	1500	if (best_at == -1)
1538	at = 0;	1501	at = 0;
1539	else	1502	else
1540	{	1503	{
1541	if (head->resist[best_at] == 100)	1504	if (head->resist[best_at] == 100)
1542	continue;	1505	continue;
1543	else	1506	else
1544	at = head->resist[best_at] / 5;	1507	at = head->resist[best_at] / 5;
1545	}	1508	}
		1509
1546	at -= level / 5;	1510	at -= level / 5;
1547	if (did_make_save (head, head->level, at))	1511	if (did_make_save (head, head->level, at))
1548	continue;	1512	continue;
1549	}	1513	}
1550	else /* spell->attacktype */	1514	else /* spell->attacktype */
1551	{	1515	{
1552	/*	1516	/*
1553	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:
1554	* if spell level < monster level, no go	1518	* if spell level < monster level, no go
1555	* 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 ) )
1556		1520
1557	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.
1558		1522
1559	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
1560	charm a level 125 monster...	1524	charm a level 125 monster...
1561		1525
1562	Ryo, august 14th	1526	Ryo, august 14th
1563	*/	1527	*/
1564	if (head->level > level)	1528	if (head->level > level)
1565	continue;	1529	continue;
1566		1530
1567	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))))
1568	/* Failed, no effect */	1532	/* Failed, no effect */
1569	continue;	1533	continue;
1570	}	1534	}
1571		1535
1572	/* Done with saving throw. Now start affecting the monster */	1536	/* Done with saving throw. Now start affecting the monster */
		1537	done_one = 0;
1573		1538
1574	/* aggravation */	1539	/* aggravation */
1575	if (QUERY_FLAG (spell, FLAG_MONSTER))	1540	if (spell->flag [FLAG_MONSTER])
1576	{	1541	{
1577	CLEAR_FLAG (head, FLAG_SLEEP);	1542	head->clr_flag (FLAG_SLEEP);
1578	remove_friendly_object (head);	1543	remove_friendly_object (head);
1579	done_one = 1;	1544	done_one = 1;
1580	head->enemy = op;	1545	head->enemy = op;
1581	}	1546	}
1582		1547
1583	/* calm monsters */	1548	/* calm monsters */
1584	if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))	1549	if (spell->flag [FLAG_UNAGGRESSIVE] && !head->flag [FLAG_UNAGGRESSIVE])
1585	{	1550	{
1586	SET_FLAG (head, FLAG_UNAGGRESSIVE);	1551	head->set_flag (FLAG_UNAGGRESSIVE);
1587	head->enemy = NULL;	1552	head->enemy = NULL;
1588	done_one = 1;	1553	done_one = 1;
1589	}	1554	}
1590		1555
1591	/* berserk monsters */	1556	/* berserk monsters */
1592	if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))	1557	if (spell->flag [FLAG_BERSERK] && !head->flag [FLAG_BERSERK])
1593	{	1558	{
1594	SET_FLAG (head, FLAG_BERSERK);	1559	head->set_flag (FLAG_BERSERK);
1595	done_one = 1;	1560	done_one = 1;
1596	}	1561	}
1597		1562
1598	/* charm */	1563	/* charm */
1599	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1564	if (spell->flag [FLAG_NO_ATTACK] && !head->flag [FLAG_FRIENDLY])
1600	{	1565	{
1601	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));	1566	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
1602		1567
1603	/* Prevent uncontrolled outbreaks of self replicating monsters.	1568	/* Prevent uncontrolled outbreaks of self replicating monsters.
1604	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.
1605	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. */
1606	CLEAR_FLAG (head, FLAG_GENERATOR);	1571	head->clr_flag (FLAG_GENERATOR);
1607	head->set_owner (op);	1572	head->set_owner (op);
1608	set_spell_skill (op, caster, spell, head);	1573	set_spell_skill (op, caster, spell, head);
1609	add_friendly_object (head);	1574	add_friendly_object (head);
1610	head->attack_movement = PETMOVE;	1575	head->attack_movement = PETMOVE;
1611	done_one = 1;	1576	done_one = 1;
1612	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);
1613	head->stats.exp = 0;	1578	head->stats.exp = 0;
1614	}	1579	}
1615		1580
1616	/* If a monster was effected, put an effect in */	1581	/* If a monster was effected, put an effect in */
1617	if (done_one && spell->other_arch)	1582	if (done_one && spell->other_arch)
1618	m->insert (arch_to_object (spell->other_arch), nx, ny, op);	1583	m->insert (spell->other_arch->instance (), nx, ny, op);
1619	} /* for y */	1584	}
1620		1585
1621	return 1;	1586	return 1;
1622	}	1587	}
1623		1588
1624	/* 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
…		…
1706	hit_map (op, j, op->attacktype, 1);	1671	hit_map (op, j, op->attacktype, 1);
1707	}	1672	}
1708		1673
1709	/* insert the other arch */	1674	/* insert the other arch */
1710	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))))
1711	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1676	m->insert (op->other_arch->instance (), hx, hy, op);
1712	}	1677	}
1713		1678
1714	/* restore to the center location and damage */	1679	/* restore to the center location and damage */
1715	op->stats.dam = dam_save;	1680	op->stats.dam = dam_save;
1716		1681
…		…
1905		1870
1906	mflags = get_map_flags (m, &m, x, y, &x, &y);	1871	mflags = get_map_flags (m, &m, x, y, &x, &y);
1907		1872
1908	if (mflags & P_OUT_OF_MAP)	1873	if (mflags & P_OUT_OF_MAP)
1909	{	1874	{
1910	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");	1875	op->failmsg ("Nothing is there.");
1911	return 0;	1876	return 0;
1912	}	1877	}
1913		1878
1914	if (mflags & P_IS_ALIVE && spell->attacktype)	1879	if (mflags & P_IS_ALIVE && spell->attacktype)
1915	{	1880	{
1916	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)
1917	if (QUERY_FLAG (target, FLAG_MONSTER))	1882	if (target->flag [FLAG_MONSTER])
1918	{	1883	{
1919	/* oky doky. got a target monster. Lets make a blinding attack */	1884	/* oky doky. got a target monster. Lets make a blinding attack */
1920	if (target->head)	1885	if (target->head)
1921	target = target->head;	1886	target = target->head;
1922		1887
…		…
1926	}	1891	}
1927		1892
1928	/* no live target, perhaps a wall is in the way? */	1893	/* no live target, perhaps a wall is in the way? */
1929	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)))
1930	{	1895	{
1931	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1896	op->failmsg ("Something is in the way.");
1932	return 0;	1897	return 0;
1933	}	1898	}
1934	}	1899	}
1935		1900
1936	/* 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 */
1937	tmp = arch_to_object (spell->other_arch);	1902	tmp = spell->other_arch->instance ();
1938	if (!tmp)	1903	if (!tmp)
1939	{	1904	{
1940	LOG (llevError, "Error: spell arch for cast_light() missing.\n");	1905	LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1941	return 0;	1906	return 0;
1942	}	1907	}
1943		1908
1944	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);	1909	tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
1945		1910
1946	if (tmp->glow_radius)	1911	if (tmp->glow_radius)
1947	tmp->glow_radius = min (MAX_LIGHT_RADIUS, spell->range + SP_level_range_adjust (caster, spell));	1912	tmp->set_glow_radius (
		1913	clamp (spell->range + SP_level_range_adjust (caster, spell), 1, MAX_LIGHT_RADIUS)
		1914	);
1948		1915
1949	if (dir)	1916	if (dir)
1950	m->insert (tmp, x, y, op);	1917	m->insert (tmp, x, y, op);
1951	else	1918	else
1952	caster->outer_env ()->insert (tmp);	1919	caster->outer_env_or_self ()->insert (tmp);
1953		1920
1954	return 1;	1921	return 1;
1955	}	1922	}
1956		1923
1957	/* cast_cause_disease: this spell looks along <dir> from the	1924	/* cast_cause_disease: this spell looks along <dir> from the
…		…
2004	/* 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 */
2005	if (mflags & P_IS_ALIVE)	1972	if (mflags & P_IS_ALIVE)
2006	{	1973	{
2007	/* search this square for a victim */	1974	/* search this square for a victim */
2008	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)
2009	if (QUERY_FLAG (walk, FLAG_MONSTER) \|\| (walk->type == PLAYER))	1976	if (walk->flag [FLAG_MONSTER] \|\| (walk->type == PLAYER))
2010	{ /* found a victim */	1977	{ /* found a victim */
2011	object *disease = arch_to_object (spell->other_arch);	1978	object *disease = spell->other_arch->instance ();
2012		1979
2013	disease->set_owner (op);	1980	disease->set_owner (op);
2014	set_spell_skill (op, caster, spell, disease);	1981	set_spell_skill (op, caster, spell, disease);
2015	disease->stats.exp = 0;	1982	disease->stats.exp = 0;
2016	disease->level = casting_level (caster, spell);	1983	disease->level = casting_level (caster, spell);
2017		1984
2018	/* do level adjustments */	1985	/* do level adjustments */
2019	if (disease->stats.wc)	1986	if (disease->stats.wc ) disease->stats.wc += dur_mod / 2;
2020	disease->stats.wc += dur_mod / 2;	1987	if (disease->magic > 0) disease->magic += dur_mod / 8;
2021		1988	if (disease->stats.maxhp > 0) disease->stats.maxhp += dur_mod;
2022	if (disease->magic > 0)	1989	if (disease->stats.maxgrace > 0) disease->stats.maxgrace += dur_mod;
2023	disease->magic += dur_mod / 8;
2024
2025	if (disease->stats.maxhp > 0)
2026	disease->stats.maxhp += dur_mod;
2027
2028	if (disease->stats.maxgrace > 0)
2029	disease->stats.maxgrace += dur_mod;
2030
2031	if (disease->stats.dam)
2032	{
2033	if (disease->stats.dam > 0)
2034	disease->stats.dam += dam_mod;
2035	else
2036	disease->stats.dam -= dam_mod;
2037	}
2038		1990
2039	if (disease->last_sp)	1991	if (disease->last_sp)
2040	{	1992	{
2041	disease->last_sp -= 2 * dam_mod;	1993	disease->last_sp -= 2 * dam_mod;
		1994
2042	if (disease->last_sp < 1)	1995	if (disease->last_sp < 1)
2043	disease->last_sp = 1;	1996	disease->last_sp = 1;
2044	}	1997	}
2045		1998
2046	if (disease->stats.maxsp)	1999	if (disease->stats.dam ) disease->stats.dam += copysignl (disease->stats.dam , dam_mod);
2047	{	2000	if (disease->stats.maxsp) disease->stats.maxsp += copysignl (disease->stats.maxsp, dam_mod);
2048	if (disease->stats.maxsp > 0)	2001	if (disease->stats.ac ) disease->stats.ac += dam_mod;
2049	disease->stats.maxsp += dam_mod;	2002	if (disease->last_eat ) disease->last_eat -= dam_mod;
2050	else	2003	if (disease->stats.hp ) disease->stats.hp -= dam_mod;
2051	disease->stats.maxsp -= dam_mod;	2004	if (disease->stats.sp ) disease->stats.sp -= dam_mod;
2052	}
2053
2054	if (disease->stats.ac)
2055	disease->stats.ac += dam_mod;
2056
2057	if (disease->last_eat)
2058	disease->last_eat -= dam_mod;
2059
2060	if (disease->stats.hp)
2061	disease->stats.hp -= dam_mod;
2062
2063	if (disease->stats.sp)
2064	disease->stats.sp -= dam_mod;
2065		2005
2066	if (infect_object (walk, disease, 1))	2006	if (infect_object (walk, disease, 1))
2067	{	2007	{
2068	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));
2069		2009
2070	disease->destroy (); /* don't need this one anymore */	2010	disease->destroy (); /* don't need this one anymore */
2071	walk->map->insert (get_archetype ("detect_magic"), x, y, op);	2011	walk->map->insert (archetype::get (shstr_detect_magic), x, y, op);
2072	return 1;	2012	return 1;
2073	}	2013	}
2074		2014
2075	disease->destroy ();	2015	disease->destroy ();
2076	}	2016	}

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.73 by root, Sun Dec 28 06:59:27 2008 UTC vs. Revision 1.114 by root, Wed Nov 16 23:42:03 2016 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.73 by root, Sun Dec 28 06:59:27 2008 UTC vs.
Revision 1.114 by root, Wed Nov 16 23:42:03 2016 UTC