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

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.101 by root, Fri Nov 6 13:03:34 2009 UTC vs.
Revision 1.126 by root, Wed Nov 21 12:12:03 2012 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,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001 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 it under	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the	9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* 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 Affero GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* and the GNU General Public License along with this program. If not, see	19	* and the GNU General Public License along with this program. If not, see
20	* <http://www.gnu.org/licenses/>.	20	* <http://www.gnu.org/licenses/>.
21	*	21	*
22	* 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>
23	*/	23	*/
24		24
25	#include <global.h>	25	#include <global.h>
26	#include <spells.h>	26	#include <spells.h>
83	*/	83	*/
84	void	84	void
85	spell_effect (object spob, int x, int y, maptile map, object *originator)	85	spell_effect (object spob, int x, int y, maptile map, object *originator)
86	{	86	{
87	if (spob->other_arch)	87	if (spob->other_arch)
88	map->insert (arch_to_object (spob->other_arch), x, y, originator);	88	map->insert (spob->other_arch->instance (), x, y, originator);
89	}	89	}
90		90
91	static int	91	static int
92	attuned_bonus (object caster, object spell, int level)	92	attuned_bonus (object caster, object spell, int level)
93	{	93	{
…		…
149	int sp, grace, level = casting_level (caster, spell);	149	int sp, grace, level = casting_level (caster, spell);
150		150
151	if (settings.spellpoint_level_depend == TRUE)	151	if (settings.spellpoint_level_depend == TRUE)
152	{	152	{
153	if (spell->stats.sp && spell->stats.maxsp)	153	if (spell->stats.sp && spell->stats.maxsp)
154	{
155	sp = (int) (spell->stats.sp * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxsp)));	154	sp = spell->stats.sp * (1.f + max (0.f, float (level - spell->level) / spell->stats.maxsp));
156	}
157	else	155	else
158	sp = spell->stats.sp;	156	sp = spell->stats.sp;
159		157
160	sp *= (int) PATH_SP_MULT (caster, spell);	158	sp *= (int) PATH_SP_MULT (caster, spell);
161	if (!sp && spell->stats.sp)	159	if (!sp && spell->stats.sp)
162	sp = 1;	160	sp = 1;
163		161
164	if (spell->stats.grace && spell->stats.maxgrace)	162	if (spell->stats.grace && spell->stats.maxgrace)
165	{
166	grace = (int) (spell->stats.grace * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxgrace)));	163	grace = spell->stats.grace * (1.f + max (0.f, float (level - spell->level) / spell->stats.maxgrace));
167	}
168	else	164	else
169	grace = spell->stats.grace;	165	grace = spell->stats.grace;
170		166
171	grace *= (int) PATH_SP_MULT (caster, spell);	167	grace *= PATH_SP_MULT (caster, spell);
172	if (spell->stats.grace && !grace)	168	if (spell->stats.grace && !grace)
173	grace = 1;	169	grace = 1;
174	}	170	}
175	else	171	else
176	{	172	{
…		…
182	if (spell->stats.grace && !grace)	178	if (spell->stats.grace && !grace)
183	grace = 1;	179	grace = 1;
184	}	180	}
185		181
186	if (flags == SPELL_HIGHEST)	182	if (flags == SPELL_HIGHEST)
187	return MAX (sp, grace);	183	return max (sp, grace);
188	else if (flags == SPELL_GRACE)	184	else if (flags == SPELL_GRACE)
189	return grace;	185	return grace;
190	else if (flags == SPELL_MANA)	186	else if (flags == SPELL_MANA)
191	return sp;	187	return sp;
192	else	188	else
…		…
259	return spop;	255	return spop;
260		256
261	return 0;	257	return 0;
262	}	258	}
263		259
264	/*	260	/*
265	* Look at object 'op' and see if they know the spell	261	* Look at object 'op' and see if they know the spell
266	* spname. This is pretty close to check_spell_known	262	* spname. This is pretty close to check_spell_known
267	* above, but it uses a looser matching mechanism.	263	* above, but it uses a looser matching mechanism.
268	* returns the matching spell object, or NULL.	264	* returns the matching spell object, or NULL.
269	* If we match multiple spells but don't get an	265	* If we match multiple spells but don't get an
270	* exact match, we also return NULL.	266	* exact match, we also return NULL.
271	*/	267	*/
272	object *	268	object *
273	lookup_spell_by_name (object op, const char spname)	269	object::find_spell (shstr_cmp name) const
274	{	270	{
275	object spob1 = 0, spob2 = 0;
276	int nummatch = 0;
277
278	if (!spname)
279	return 0;
280
281	/* Try to find the spell. We store the results in spob1
282	* and spob2 - spob1 is only taking the length of
283	* the past spname, spob2 uses the length of the spell name.
284	*/
285	for (object *spob = op->inv; spob; spob = spob->below)	271	for (object *spob = inv; spob; spob = spob->below)
286	{	272	if (spob->name == name && spob->type == SPELL)
287	if (spob->type == SPELL)
288	{
289	// TODO: WTF?
290	if (!strncmp (spob->name, spname, strlen (spname)))
291	{
292	nummatch++;
293	spob1 = spob;
294	}
295	else if (!strncmp (spob->name, spname, strlen (spob->name)))
296	{
297	/* if spells have ambiguous names, it makes matching
298	* really difficult. (eg, fire and fireball would
299	* fall into this category). It shouldn't be hard to
300	* make sure spell names don't overlap in that fashion.
301	*/
302	if (spob2)
303	LOG (llevError, "Found multiple spells with overlapping base names: %s, %s\n", &spob2->name, &spob->name);
304
305	spob2 = spob;
306	}
307	}
308	}
309	/* if we have best match, return it. Otherwise, if we have one match
310	* on the loser match, return that, otehrwise null
311	*/
312	if (spob2)
313	return spob2;	273	return spob;
314		274
315	if (spob1 && nummatch == 1)
316	return spob1;
317
318	return NULL;	275	return 0;
319	}	276	}
320		277
321	/* reflwall - decides weither the (spell-)object sp_op will	278	/* reflwall - decides weither the (spell-)object sp_op will
322	* be reflected from the given mapsquare. Returns 1 if true.	279	* be reflected from the given mapsquare. Returns 1 if true.
323	* (Note that for living creatures there is a small chance that	280	* (Note that for living creatures there is a small chance that
…		…
330	{	287	{
331	if (OUT_OF_REAL_MAP (m, x, y))	288	if (OUT_OF_REAL_MAP (m, x, y))
332	return 0;	289	return 0;
333		290
334	for (object *op = GET_MAP_OB (m, x, y); op; op = op->above)	291	for (object *op = GET_MAP_OB (m, x, y); op; op = op->above)
335	if (QUERY_FLAG (op, FLAG_REFL_SPELL)	292	if (op->flag [FLAG_REFL_SPELL]
336	&& (!QUERY_FLAG (op, FLAG_ALIVE)	293	&& (!op->flag [FLAG_ALIVE]
337	\|\| (rndm (0, 99)) < 90 - (sp_op->level / 10)))	294	\|\| (rndm (0, 99)) < 90 - (sp_op->level / 10)))
338	return 1;	295	return 1;
339		296
340	return 0;	297	return 0;
341	}	298	}
342		299
343	/* cast_create_object: creates object new_op in direction dir	300	/* cast_create_object: creates object new_op in direction dir
344	* or if that is blocked, beneath the player (op).	301	* or if that is blocked, beneath the player (op).
345	* we pass 'caster', but don't use it for anything.	302	* we pass 'caster', but don't use it for anything.
346	* This is really just a simple wrapper function .	303	* This is really just a simple wrapper function .
347	* returns the direction that the object was actually placed	304	* returns true to indicate whether the operation was successful.
348	* in.	305	* destroys the object is unsuccessful.
349	*/	306	*/
350	int	307	bool
351	cast_create_obj (object op, object caster, object *new_op, int dir)	308	cast_create_obj (object op, object caster, object *new_op, int dir)
352	{	309	{
353	maptile *m;	310	mapxy pos (op);
354	sint16 sx, sy;	311	pos.move (dir);
355		312
356	if (dir &&	313	if (!pos.normalise ()
357	((get_map_flags (op->map, &m, op->x + freearr_x[dir], op->y + freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) \|\|	314	\|\| pos->blocks (op) // perversely enough, we check if the palyer can reach that space
358	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))))	315	\|\| !new_op->can_drop_at (pos.m, pos.x, pos.y)
359	{	316	)
360	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
361	new_draw_info (NDI_UNIQUE, 0, op, "You cast it at your feet.");
362	dir = 0;
363	}	317	{
		318	op->failmsg ("Your spell fizzles! H<Something is in the way.>");
		319	new_op->destroy ();
		320	return 0;
		321	}
364		322
365	SET_FLAG (new_op, FLAG_IDENTIFIED);	323	new_op->set_flag (FLAG_IDENTIFIED);
366	op->map->insert (new_op,
367	op->x + freearr_x[dir], op->y + freearr_y[dir],
368	op,
369	dir ? 0 : INS_BELOW_ORIGINATOR);
370		324
		325	pos.insert (new_op, op, dir ? 0 : INS_BELOW_ORIGINATOR);
		326
371	return dir;	327	return 1;
372	}	328	}
373		329
374	static bool	330	static bool
375	mergable_owner (object o1, object o2)	331	mergable_owner (object o1, object o2)
376	{	332	{
…		…
408	if (OB_TYPE_MOVE_BLOCK (op, ms.move_block))	364	if (OB_TYPE_MOVE_BLOCK (op, ms.move_block))
409	return 0;	365	return 0;
410		366
411	int max_effects = 5; // max. number of similar spells per mapspace	367	int max_effects = 5; // max. number of similar spells per mapspace
412		368
413	for (object *tmp = ms.bot; tmp; tmp = tmp->above)	369	for (object *tmp = ms.top; tmp; tmp = tmp->below)
414	{	370	{
415	/* If there is a counterspell on the space, and this	371	/* If there is a counterspell on the space, and this
416	* object is using magic, don't progress. I believe we could	372	* object is using magic, don't progress. I believe we could
417	* leave this out and let in progress, and other areas of the code	373	* leave this out and let in progress, and other areas of the code
418	* will then remove it, but that would seem to to use more	374	* will then remove it, but that would seem to to use more
…		…
420	* on top of a counterwall spell (may hit the player before being	376	* on top of a counterwall spell (may hit the player before being
421	* removed.) On the other hand, it may be more dramatic for the	377	* removed.) On the other hand, it may be more dramatic for the
422	* spell to actually hit the counterwall and be sucked up.	378	* spell to actually hit the counterwall and be sucked up.
423	*/	379	*/
424	if ((tmp->attacktype & AT_COUNTERSPELL)	380	if ((tmp->attacktype & AT_COUNTERSPELL)
425	&& !QUERY_FLAG (tmp, FLAG_MONSTER)	381	&& !tmp->flag [FLAG_MONSTER]
426	&& (tmp->type != PLAYER)	382	&& (tmp->type != PLAYER)
427	&& (tmp->type != WEAPON)	383	&& (tmp->type != WEAPON)
428	&& (tmp->type != BOW)	384	&& (tmp->type != BOW)
429	&& (tmp->type != ARROW)	385	&& (tmp->type != ARROW)
430	&& (tmp->type != GOLEM)	386	&& (tmp->type != GOLEM)
431	&& !QUERY_FLAG (tmp, FLAG_IS_FLOOR) // XXX:	387	&& !tmp->flag [FLAG_IS_FLOOR] // XXX:
432	// we special case floor here because there	388	// we special case floor here because there
433	// are sometimes spell effect floors	389	// are sometimes spell effect floors
434	// which are used to inflict damage	390	// which are used to inflict damage
435	// (and those shouldn't go away from	391	// (and those shouldn't go away from
436	// sanctuary) see also: permanent lava	392	// sanctuary) see also: permanent lava
…		…
518	/* needed for AT_HOLYWORD,AT_GODPOWER stuff */	474	/* needed for AT_HOLYWORD,AT_GODPOWER stuff */
519	if (tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER)	475	if (tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER)
520	if (!tailor_god_spell (tmp, op))	476	if (!tailor_god_spell (tmp, op))
521	return 0;	477	return 0;
522		478
523	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))	479	if (tmp->flag [FLAG_IS_TURNABLE])
524	SET_ANIMATION (tmp, dir);	480	SET_ANIMATION (tmp, dir);
525		481
526	if ((tmp = op->map->insert (tmp, x, y, op)))	482	if ((tmp = op->map->insert (tmp, x, y, op)))
527	move_spell_effect (tmp);	483	move_spell_effect (tmp);
528		484
…		…
536	****************************************************************************/	492	****************************************************************************/
537	void	493	void
538	regenerate_rod (object *rod)	494	regenerate_rod (object *rod)
539	{	495	{
540	if (rod->stats.hp < rod->stats.maxhp)	496	if (rod->stats.hp < rod->stats.maxhp)
541	rod->stats.hp = min (rod->stats.maxhp, rod->stats.hp + 1 + rod->stats.maxhp / 10);	497	rod->stats.hp = min (rod->stats.maxhp, rod->stats.hp + 1 + rod->stats.maxhp / 20);
542	}	498	}
543		499
544	void	500	void
545	drain_rod_charge (object *rod)	501	drain_rod_charge (object *rod)
546	{	502	{
…		…
566	{	522	{
567	tmp = op->owner;	523	tmp = op->owner;
568	/* If the owner does not exist, or is not a monster, than apply the spell	524	/* If the owner does not exist, or is not a monster, than apply the spell
569	* to the caster.	525	* to the caster.
570	*/	526	*/
571	if (!tmp \|\| !QUERY_FLAG (tmp, FLAG_MONSTER))	527	if (!tmp \|\| !tmp->flag [FLAG_MONSTER])
572	tmp = op;	528	tmp = op;
573	}	529	}
574	else	530	else
575	{	531	{
576	maptile *m = op->map;	532	maptile *m = op->map;
…		…
624	continue;	580	continue;
625		581
626	tmp = GET_MAP_OB (mp, nx, ny);	582	tmp = GET_MAP_OB (mp, nx, ny);
627		583
628	while (tmp != NULL && (((owner_type == PLAYER &&	584	while (tmp != NULL && (((owner_type == PLAYER &&
629	!QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_GENERATOR)) \|\|	585	!tmp->flag [FLAG_MONSTER] && !tmp->flag [FLAG_GENERATOR]) \|\|
630	(owner_type != PLAYER && tmp->type != PLAYER)) \|\| (tmp == exclude \|\| (tmp->head && tmp->head == exclude))))	586	(owner_type != PLAYER && tmp->type != PLAYER)) \|\| (tmp == exclude \|\| (tmp->head && tmp->head == exclude))))
631	tmp = tmp->above;	587	tmp = tmp->above;
632		588
633	if (tmp != NULL && can_see_monsterP (m, x, y, i))	589	if (tmp != NULL && can_see_monsterP (m, x, y, i))
634	return freedir[i];	590	return freedir[i];
…		…
663	* insert multipart monsters properly	619	* insert multipart monsters properly
664	*/	620	*/
665	//TODO: use expand_tail + ...	621	//TODO: use expand_tail + ...
666	while (at != NULL)	622	while (at != NULL)
667	{	623	{
668	tmp = arch_to_object (at);	624	tmp = at->instance ();
669	tmp->x = op->x + freearr_x[dir] + at->x;	625	tmp->x = op->x + freearr_x[dir] + at->x;
670	tmp->y = op->y + freearr_y[dir] + at->y;	626	tmp->y = op->y + freearr_y[dir] + at->y;
671	tmp->map = op->map;	627	tmp->map = op->map;
672	if (head)	628	if (head)
673	{	629	{
…		…
784	* at casting a prayer.	740	* at casting a prayer.
785	* op is the player.	741	* op is the player.
786	* failure is basically how much grace they had.	742	* failure is basically how much grace they had.
787	* power is how much grace the spell would normally take to cast.	743	* power is how much grace the spell would normally take to cast.
788	*/	744	*/
		745
		746	#define HINT_GRACE " H<Make sure you always have enough grace points for your prayers.>"
		747
789	static void	748	static void
790	prayer_failure (object *op, int failure, int power)	749	prayer_failure (object *op, int failure, int power)
791	{	750	{
792	const char *godname;	751	const char *godname;
793	object *tmp;	752	object *tmp;
…		…
795	if (!strcmp ((godname = determine_god (op)), "none"))	754	if (!strcmp ((godname = determine_god (op)), "none"))
796	godname = "Your spirit";	755	godname = "Your spirit";
797		756
798	if (failure <= -20 && failure > -40) /* wonder */	757	if (failure <= -20 && failure > -40) /* wonder */
799	{	758	{
800	new_draw_info_format (NDI_UNIQUE, 0, op, "%s gives a sign to renew your faith.", godname);	759	op->failmsgf ("%s gives a sign to renew your faith." HINT_GRACE, godname);
801	tmp = get_archetype (SPELL_WONDER);	760	tmp = archetype::get (SPELL_WONDER);
802	cast_cone (op, op, 0, tmp);	761	cast_cone (op, op, 0, tmp);
803	tmp->destroy ();	762	tmp->destroy ();
804	}	763	}
805		764
806	else if (failure <= -40 && failure > -60) /* confusion */	765	else if (failure <= -40 && failure > -60) /* confusion */
807	{	766	{
808	new_draw_info (NDI_UNIQUE, 0, op, "Your diety touches your mind!");	767	op->failmsg ("Your diety touches your mind!" HINT_GRACE);
809	confuse_player (op, op, 99);	768	confuse_player (op, op, 99);
810	}	769	}
811	else if (failure <= -60 && failure > -150) /* paralysis */	770	else if (failure <= -60 && failure > -150) /* paralysis */
812	{	771	{
813	new_draw_info_format (NDI_UNIQUE, 0, op, "%s requires you to pray NOW.", godname);	772	op->failmsgf ("%s requires you to pray NOW. "
814	new_draw_info (NDI_UNIQUE, 0, op, "You comply, ignoring all else.");	773	"You comply, ignoring all else." HINT_GRACE,
		774	godname);
815	paralyze_player (op, op, 99);	775	paralyze_player (op, op, 99);
816	}	776	}
817	else if (failure <= -150) /* blast the immediate area */	777	else if (failure <= -150) /* blast the immediate area */
818	{	778	{
819	tmp = get_archetype (GOD_POWER);	779	tmp = archetype::get (GOD_POWER);
820	new_draw_info_format (NDI_UNIQUE, 0, op, "%s smites you!", godname);	780	op->failmsgf ("%s smites you!" HINT_GRACE, godname);
821	cast_magic_storm (op, tmp, power);	781	cast_magic_storm (op, tmp, power);
822	}	782	}
823	}	783	}
824		784
825	/*	785	/*
826	* spell_failure() handles the various effects for differing degrees	786	* spell_failure() handles the various effects for differing degrees
827	* of failure badness.	787	* of failure badness.
828	* op is the player that failed.	788	* op is the player that failed.
829	* failure is a random value of how badly you failed.	789	* failure is a random value of how badly you failed.
830	* power is how many spellpoints you'd normally need for the spell.	790	* power is how many spellpoints you'd normally need for the spell.
831	* skill is the skill you'd need to cast the spell.	791	* skill is the skill you'd need to cast the spell.
832	*/	792	*/
833
834	void	793	void
835	spell_failure (object op, int failure, int power, object skill)	794	spell_failure (object op, int failure, int power, object skill)
836	{	795	{
837	object *tmp;	796	object *tmp;
838		797
839	if (settings.spell_failure_effects == FALSE)	798	if (settings.spell_failure_effects == FALSE)
840	return;	799	return;
841		800
842	if (failure <= -20 && failure > -40) /* wonder */	801	if (failure <= -20 && failure > -40) /* wonder */
843	{	802	{
844	new_draw_info (NDI_UNIQUE, 0, op, "Your spell causes an unexpected effect.");	803	op->failmsg ("Your spell causes an unexpected effect.");
845	tmp = get_archetype (SPELL_WONDER);	804	tmp = archetype::get (SPELL_WONDER);
846	cast_cone (op, op, 0, tmp);	805	cast_cone (op, op, 0, tmp);
847	tmp->destroy ();	806	tmp->destroy ();
848	}	807	}
849		808
850	else if (failure <= -40 && failure > -60) /* confusion */	809	else if (failure <= -40 && failure > -60) /* confusion */
851	{	810	{
852	new_draw_info (NDI_UNIQUE, 0, op, "Your magic recoils on you, making you confused!");	811	op->failmsg ("Your magic recoils on you, making you confused!");
853	confuse_player (op, op, 99);	812	confuse_player (op, op, 99);
854	}	813	}
855	else if (failure <= -60 && failure > -80) /* paralysis */	814	else if (failure <= -60 && failure > -80) /* paralysis */
856	{	815	{
857	new_draw_info (NDI_UNIQUE, 0, op, "Your magic stuns you!");	816	op->failmsg ("Your magic stuns you!");
858	paralyze_player (op, op, 99);	817	paralyze_player (op, op, 99);
859	}	818	}
860	else if (failure <= -80) /* blast the immediate area */	819	else if (failure <= -80) /* blast the immediate area */
861	{	820	{
862	object *tmp;	821	object *tmp;
863		822
864	/* Safety check to make sure we don't get any mana storms in scorn */	823	/* Safety check to make sure we don't get any mana storms in scorn */
865	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC)	824	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC)
866	{	825	{
867	new_draw_info (NDI_UNIQUE, 0, op, "The magic warps and you are turned inside out!");	826	op->failmsg ("The magic warps and you are turned inside out!");
868	hit_player (op, 9998, op, AT_INTERNAL, 1);	827	hit_player (op, 9998, op, AT_INTERNAL, 1);
869		828
870	}	829	}
871	else	830	else
872	{	831	{
873	new_draw_info (NDI_UNIQUE, 0, op, "You lose control of the mana! The uncontrolled magic blasts you!");	832	op->failmsg ("You lose control of the mana! The uncontrolled magic blasts you!");
874	tmp = get_archetype (LOOSE_MANA);	833	tmp = archetype::get (LOOSE_MANA);
875	tmp->level = skill->level;	834	tmp->level = skill->level;
876		835
877	/* increase the area of destruction a little for more powerful spells */	836	/* increase the area of destruction a little for more powerful spells */
878	tmp->range += isqrt (power);	837	tmp->range += isqrt (power);
879		838
…		…
896	{	855	{
897	LOG (llevError, "cast_party_spell: empty other arch\n");	856	LOG (llevError, "cast_party_spell: empty other arch\n");
898	return 0;	857	return 0;
899	}	858	}
900		859
901	object *spell = arch_to_object (spell_ob->other_arch);	860	object *spell = spell_ob->other_arch->instance ();
902		861
903	/* Always cast spell on caster */	862	/* Always cast spell on caster */
904	int success = cast_spell (op, caster, dir, spell, spellparam);	863	int success = cast_spell (op, caster, dir, spell, spellparam);
905		864
906	if (!op->contr \|\| !op->contr->party)	865	if (!op->contr \|\| !op->contr->party)
…		…
949	int	908	int
950	cast_spell (object op, object caster, int dir, object spell_ob, char spellparam)	909	cast_spell (object op, object caster, int dir, object spell_ob, char spellparam)
951	{	910	{
952	const char *godname;	911	const char *godname;
953	int success = 0;	912	int success = 0;
954	object *skill = NULL;	913
		914	// make sure spells always take a while, so a) we don't flood the
		915	// user with messages and b) too many failures can be harmful (smiting).
		916	op->speed_left -= 4 * op->speed; // ~0.5s on failure
955		917
956	if (!spell_ob)	918	if (!spell_ob)
957	{	919	{
958	LOG (llevError, "cast_spell: null spell object passed\n");	920	LOG (llevError, "cast_spell: null spell object passed\n");
959	return 0;	921	return 0;
…		…
970	}	932	}
971		933
972	/* if caster is a spell casting object, this normally shouldn't be	934	/* if caster is a spell casting object, this normally shouldn't be
973	* an issue, because they don't have any spellpaths set up.	935	* an issue, because they don't have any spellpaths set up.
974	*/	936	*/
975	if (caster->path_denied & spell_ob->path_attuned && !QUERY_FLAG (caster, FLAG_WIZCAST))	937	if (caster->path_denied & spell_ob->path_attuned && !caster->flag [FLAG_WIZCAST])
976	{	938	{
977	new_draw_info (NDI_UNIQUE, 0, op, "That spell path is denied to you.");	939	op->failmsg ("That spell path is denied to you.");
978	return 0;	940	return 0;
979	}	941	}
		942
		943	object *skill = 0;
980		944
981	/* if it is a player casting the spell, and they are really casting it	945	/* if it is a player casting the spell, and they are really casting it
982	* (vs it coming from a wand, scroll, or whatever else), do some	946	* (vs it coming from a wand, scroll, or whatever else), do some
983	* checks. We let monsters do special things - eg, they	947	* checks. We let monsters do special things - eg, they
984	* don't need the skill, bypass level checks, etc. The monster function	948	* don't need the SKILL, BYpass level checks, etc. The monster function
985	* should take care of that.	949	* should take care of that.
986	* Remove the wiz check here and move it further down - some spells	950	* Remove the wiz check here and move it further down - some spells
987	* need to have the right skill pointer passed, so we need to	951	* need to have the right skill pointer passed, so we need to
988	* at least process that code.	952	* at least process that code.
989	*/	953	*/
…		…
993	{	957	{
994	skill = find_skill_by_name (op, spell_ob->skill);	958	skill = find_skill_by_name (op, spell_ob->skill);
995		959
996	if (!skill)	960	if (!skill)
997	{	961	{
998	op->failmsg (format ("You need the skill %s to cast %s! "	962	op->failmsgf ("You need the %s skill to cast %s! "
999	"H<You either need to learn the skill via a skill scroll "	963	"H<You either need to learn the skill via a skill scroll "
1000	"or you need to wear a talisman or holy symbol.>",	964	"or you need to wear a talisman, holy symbol or another skill tool.>",
1001	&spell_ob->skill, &spell_ob->name));	965	&spell_ob->skill, &spell_ob->name);
1002	return 0;	966	return 0;
1003	}	967	}
1004		968
1005	const char *msg = "";	969	const char *msg = "";
1006		970
1007	int caster_level = skill->level;	971	int caster_level = skill->level;
…		…
1018	msg = " (repelled)";	982	msg = " (repelled)";
1019	}	983	}
1020		984
1021	if (spell_ob->level > caster_level)	985	if (spell_ob->level > caster_level)
1022	{	986	{
1023	op->failmsg (format ("You lack enough skill to cast that spell! "	987	op->failmsgf ("You lack enough skill to cast that spell! "
1024	"H<Your effective cast level is %d%s, but level %d is required.>",	988	"H<Your effective cast level is %d%s, but level %d is required.>",
1025	caster_level, msg, spell_ob->level));	989	caster_level, msg, spell_ob->level);
1026	if (!op->is_wiz ())	990	if (!op->is_wiz ())
1027	return 0;	991	return 0;
1028	}	992	}
1029	}	993	}
1030		994
1031	/* If the caster is the wiz, they don't ever fail, and don't have	995	/* If the caster is the wiz, they don't ever fail, and don't have
1032	* to have sufficient grace/mana.	996	* to have sufficient grace/mana.
1033	*/	997	*/
1034	if (!QUERY_FLAG (op, FLAG_WIZCAST))	998	if (!op->flag [FLAG_WIZCAST])
1035	{	999	{
1036	if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) &&	1000	if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) &&
1037	SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp)	1001	SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp)
1038	{	1002	{
1039	op->failmsg ("You don't have enough mana!");	1003	op->failmsg ("You don't have enough mana!");
…		…
1047	10 * SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) / op->stats.maxgrace > 0)	1011	10 * SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) / op->stats.maxgrace > 0)
1048	op->statusmsg (format ("%s grants your prayer, though you are unworthy.", godname));	1012	op->statusmsg (format ("%s grants your prayer, though you are unworthy.", godname));
1049	else	1013	else
1050	{	1014	{
1051	prayer_failure (op, op->stats.grace, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) - op->stats.grace);	1015	prayer_failure (op, op->stats.grace, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) - op->stats.grace);
1052	op->failmsg (format ("%s ignores your prayer.", godname));	1016	op->failmsgf ("%s ignores your prayer.", godname);
1053	return 0;	1017	return 0;
1054	}	1018	}
1055	}	1019	}
1056		1020
1057	/* player/monster is trying to cast the spell. might fumble it */	1021	/* player/monster is trying to cast the spell. might fumble it */
1058	if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) <	1022	if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) <
1059	(spell_ob->level / (float) MAX (1, op->level) * cleric_chance[op->stats.Wis]))	1023	(spell_ob->level / (float) max (1, op->level) * cleric_chance[op->stats.Wis]))
1060	{	1024	{
1061	op->contr->play_sound (sound_find ("fumble_spell"));	1025	op->contr->play_sound (sound_find ("fumble_spell"));
1062	op->failmsg ("You fumble the prayer.");	1026	op->failmsg ("You fumble the prayer.");
1063		1027
1064	op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);	1028	op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);
…		…
1087	* not alive, then this would mean that the mapmaker put the	1051	* not alive, then this would mean that the mapmaker put the
1088	* objects on the space - presume that they know what they are	1052	* objects on the space - presume that they know what they are
1089	* doing.	1053	* doing.
1090	*/	1054	*/
1091		1055
1092	if ((mflags & P_SAFE) && !QUERY_FLAG (op, FLAG_WIZCAST)) // There is _ABSOLUTELY_ no magic allowed here (except wizards :-)!	1056	if ((mflags & P_SAFE) && !op->flag [FLAG_WIZCAST]) // There is _ABSOLUTELY_ no magic allowed here (except wizards :-)!
1093	{	1057	{
		1058	op->speed_left -= 2 * op->speed; // freeze for two ticks, so we don't flood
1094	op->failmsg ("This ground is sacred! The gods prevent any magical effects done by you here!");	1059	op->failmsg ("This ground is sacred! The gods prevent any magical effects done by you here!");
1095	return 0;	1060	return 0;
1096	}	1061	}
1097		1062
1098	if ((spell_ob->type == SPELL)	1063	if ((spell_ob->type == SPELL)
1099	&& (caster->type != POTION)	1064	&& (caster->type != POTION)
1100	&& !QUERY_FLAG (op, FLAG_WIZCAST)	1065	&& !op->flag [FLAG_WIZCAST]
1101	&& (QUERY_FLAG (caster, FLAG_ALIVE)	1066	&& (caster->flag [FLAG_ALIVE]
1102	\|\| QUERY_FLAG (op, FLAG_ALIVE))	1067	\|\| op->flag [FLAG_ALIVE])
1103	&& (((mflags & P_NO_MAGIC) && spell_ob->stats.sp) \|\| ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))	1068	&& (((mflags & P_NO_MAGIC) && spell_ob->stats.sp) \|\| ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))
1104	{	1069	{
1105	if (op->type != PLAYER)	1070	if (op->type != PLAYER)
1106	return 0;	1071	return 0;
1107		1072
1108	if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)	1073	if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)
1109	op->failmsg (format ("This ground is unholy! %s ignores you.", godname));	1074	op->failmsgf ("This ground is unholy! %s ignores you.", godname);
1110	else if (object *item = op->contr->ranged_ob)	1075	else if (object *item = op->contr->ranged_ob)
1111	{	1076	{
1112	if (item->type == SPELL)	1077	if (item->type == SPELL)
1113	op->failmsg ("Something blocks your spellcasting.");	1078	op->failmsg ("Something blocks your spellcasting.");
1114	else if (item->type == SCROLL)	1079	else if (item->type == SCROLL)
…		…
1120	op->failmsg ("Something blocks the spell!");	1085	op->failmsg ("Something blocks the spell!");
1121		1086
1122	return 0;	1087	return 0;
1123	}	1088	}
1124		1089
		1090	// undo the flood protection from earlier
		1091	op->speed_left += 4 * op->speed; // ~0.5s on failure
		1092
1125	/* Take into account how long it takes to cast the spell.	1093	/* Take into account how long it takes to cast the spell.
1126	* if the player is casting it, then we use the time in	1094	* if the player is casting it, then we use the time in
1127	* the spell object. If it is a spell object, have it	1095	* the spell object. If it is a spell object, have it
1128	* take two ticks. Things that cast spells on the players	1096	* take two ticks. Things that cast spells on the players
1129	* behalf (eg, altars, and whatever else) shouldn't cost	1097	* behalf (eg, altars, and whatever else) shouldn't cost
1130	* the player any time.	1098	* the player any time.
1131	* Ignore casting time for firewalls	1099	* Ignore casting time for firewalls
1132	*/	1100	*/
1133	if (caster == op && caster->type != FIREWALL)	1101	if (caster == op && caster->type != FIREWALL)
1134	{	1102	{
1135	op->speed_left -= spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);	1103	op->speed_left -= spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * op->speed;
1136	/* Other portions of the code may also decrement the speed of the player, so	1104	/* Other portions of the code may also decrement the speed of the player, so
1137	* put a lower limit so that the player isn't stuck here too long	1105	* put a lower limit so that the player isn't stuck here too long
1138	*/	1106	*/
1139	if ((spell_ob->casting_time > 0) && op->speed_left < -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed))	1107	if ((spell_ob->casting_time > 0) && op->speed_left < -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * op->speed)
1140	op->speed_left = -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);	1108	op->speed_left = -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * op->speed;
1141	}	1109	}
1142	else if (caster->type == WAND \|\| caster->type == HORN \|\| caster->type == ROD \|\| caster->type == POTION \|\| caster->type == SCROLL)	1110	else if (caster->type == WAND \|\| caster->type == HORN \|\| caster->type == ROD \|\| caster->type == POTION \|\| caster->type == SCROLL)
1143	op->speed_left -= 2 * FABS (op->speed);	1111	op->speed_left -= 2 * op->speed;
1144		1112
1145	if (op->type == PLAYER && op == caster)	1113	if (op->type == PLAYER && op == caster)
1146	{	1114	{
1147	op->stats.grace -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE);	1115	op->stats.grace -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE);
1148	op->stats.sp -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA);	1116	op->stats.sp -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA);
…		…
1153	* object requires.	1121	* object requires.
1154	*/	1122	*/
1155	if (op != caster && !skill && caster->skill)	1123	if (op != caster && !skill && caster->skill)
1156	{	1124	{
1157	skill = find_skill_by_name (op, caster->skill);	1125	skill = find_skill_by_name (op, caster->skill);
		1126
1158	if (!skill)	1127	if (!skill)
1159	{	1128	{
1160	op->failmsg (format ("You lack the skill %s to use the %s!", &caster->skill, query_name (caster)));	1129	op->failmsgf ("You lack the %s skill, which is required to use the %s!", &caster->skill, query_name (caster));
1161	return 0;	1130	return 0;
1162	}	1131	}
1163
1164	op->change_skill (skill); /* needed for proper exp credit */
1165	}	1132	}
1166		1133
1167	if (INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (spellparam)))	1134	if (INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (spellparam)))
1168	return RESULT_INT (0);	1135	return RESULT_INT (0);
		1136
		1137	// temporaroly replace chosen_skill by skill, we assume skill could be applied,
		1138	// at least temporarily, which might not be true due to slot restrictions, but hey
		1139	// invoke requires it basically.
		1140
		1141	object *chosen_skill = op->chosen_skill;
		1142	op->chosen_skill = skill;
1169		1143
1170	switch (spell_ob->subtype)	1144	switch (spell_ob->subtype)
1171	{	1145	{
1172	/* The order of case statements is same as the order they show up	1146	/* The order of case statements is same as the order they show up
1173	* in spells.h.	1147	* in spells.h.
…		…
1324	break;	1298	break;
1325		1299
1326	case SP_MOVING_BALL:	1300	case SP_MOVING_BALL:
1327	if (spell_ob->path_repelled && (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled)	1301	if (spell_ob->path_repelled && (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled)
1328	{	1302	{
1329	op->failmsg (format ("You lack the proper attunement to cast %s!", &spell_ob->name));	1303	op->failmsgf ("You lack the proper attunement to cast %s!", &spell_ob->name);
1330	success = 0;	1304	success = 0;
1331	}	1305	}
1332	else	1306	else
1333	success = fire_arch_from_position (op, caster, op->x, op->y, dir, spell_ob);	1307	success = fire_arch_from_position (op, caster, op->x, op->y, dir, spell_ob);
1334	break;	1308	break;
…		…
1383	break;	1357	break;
1384		1358
1385	default:	1359	default:
1386	LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);	1360	LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);
1387	}	1361	}
		1362
		1363	// restore chosen_skill
		1364	op->chosen_skill = chosen_skill;
1388		1365
1389	op->play_sound (	1366	op->play_sound (
1390	success	1367	success
1391	? spell_ob->sound	1368	? spell_ob->sound
1392	? spell_ob->sound	1369	? spell_ob->sound
…		…
1446	move_aura (op);	1423	move_aura (op);
1447	break;	1424	break;
1448	}	1425	}
1449	}	1426	}
1450		1427
1451	/* this checks to see if something special should happen if
1452	* something runs into the object.
1453	*/
1454	static void
1455	check_spell_effect (object *op)
1456	{
1457	switch (op->subtype)
1458	{
1459	case SP_BOLT:
1460	move_bolt (op);
1461	return;
1462
1463	case SP_BULLET:
1464	check_bullet (op);
1465	return;
1466	}
1467	}
1468
1469	/* This is called by move_apply. Basically, if someone	1428	/* This is called by move_apply. Basically, if someone
1470	* moves onto a spell effect and the walk_on or fly_on flags	1429	* moves onto a spell effect and the walk_on or fly_on flags
1471	* are set, this is called. This should only be called for	1430	* are set, this is called. This should only be called for
1472	* objects of the appropriate type.	1431	* objects of the appropriate type.
1473	*/	1432	*/
…		…
1475	apply_spell_effect (object spell, object victim)	1434	apply_spell_effect (object spell, object victim)
1476	{	1435	{
1477	switch (spell->subtype)	1436	switch (spell->subtype)
1478	{	1437	{
1479	case SP_CONE:	1438	case SP_CONE:
1480	if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->speed && spell->attacktype)	1439	if (victim->flag [FLAG_ALIVE] && spell->has_active_speed () && spell->attacktype)
1481	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0);	1440	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0);
1482	break;	1441	break;
1483		1442
1484	case SP_MAGIC_MISSILE:	1443	case SP_MAGIC_MISSILE:
1485	if (QUERY_FLAG (victim, FLAG_ALIVE))	1444	if (victim->flag [FLAG_ALIVE])
1486	{	1445	{
1487	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);	1446	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1488	spell->destroy ();	1447	spell->destroy ();
1489	}	1448	}
1490	break;	1449	break;
1491		1450
1492	case SP_MOVING_BALL:	1451	case SP_MOVING_BALL:
1493	if (QUERY_FLAG (victim, FLAG_ALIVE))	1452	if (victim->flag [FLAG_ALIVE])
1494	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);	1453	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1495	else if (victim->materialname)	1454	else if (victim->material != MATERIAL_NULL)
1496	save_throw_object (victim, spell->attacktype, spell);	1455	save_throw_object (victim, spell->attacktype, spell);
1497		1456
1498	break;	1457	break;
1499	}	1458	}
1500	}	1459	}
…		…
1504	* the victim with a specific maximum level.	1463	* the victim with a specific maximum level.
1505	*/	1464	*/
1506	void	1465	void
1507	create_exploding_ball_at (object *victim, int level)	1466	create_exploding_ball_at (object *victim, int level)
1508	{	1467	{
1509	object *ball = get_archetype (EXPLODING_FIREBALL);	1468	object *ball = archetype::get (EXPLODING_FIREBALL);
1510	ball->dam_modifier = random_roll (1, level, victim, PREFER_LOW) / 5 + 1;	1469	ball->dam_modifier = random_roll (1, level, victim, PREFER_LOW) / 5 + 1;
1511	ball->stats.maxhp = random_roll (1, level, victim, PREFER_LOW) / 10 + 2;	1470	ball->stats.maxhp = random_roll (1, level, victim, PREFER_LOW) / 10 + 2;
1512	ball->insert_at (victim);	1471	ball->insert_at (victim);
1513	}	1472	}

Diff Legend

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

Comparing deliantra/server/server/spell_util.C (file contents): Revision 1.101 by root, Fri Nov 6 13:03:34 2009 UTC vs. Revision 1.126 by root, Wed Nov 21 12:12:03 2012 UTC

Diff Legend

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.101 by root, Fri Nov 6 13:03:34 2009 UTC vs.
Revision 1.126 by root, Wed Nov 21 12:12:03 2012 UTC