ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/spell_util.C

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.8 by root, Tue Aug 29 08:01:38 2006 UTC vs.
Revision 1.24 by root, Wed Dec 20 09:14:22 2006 UTC

1	/*
2	* static char *rcsid_spell_util_c =
3	* "$Id: spell_util.C,v 1.8 2006/08/29 08:01:38 root Exp $";
4	*/
5
6
7	/*	1	/*
8	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
9		3
10	Copyright (C) 2001 Mark Wedel & Crossfire Development Team	4	Copyright (C) 2001 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen	5	Copyright (C) 1992 Frank Tore Johansen
…		…
22		16
23	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26		20
27	The authors can be reached via e-mail at crossfire-devel@real-time.com	21	The authors can be reached via e-mail at <crossfire@schmorp.de>
28	*/	22	*/
29		23
30		24
31	#include <global.h>	25	#include <global.h>
32	#include <spells.h>	26	#include <spells.h>
33	#include <object.h>	27	#include <object.h>
34	#include <errno.h>	28	#include <errno.h>
35	#ifndef __CEXTRACT__	29	#ifndef __CEXTRACT__
36	#include <sproto.h>	30	# include <sproto.h>
37	#endif	31	#endif
38	#include <sounds.h>	32	#include <sounds.h>
39		33
40	extern char *spell_mapping[];	34	extern char *spell_mapping[];
41		35
42	/* This returns a random spell from 'ob'. If skill is set, then	36	/* This returns a random spell from 'ob'. If skill is set, then
43	* the spell must be of this skill, it can be NULL in which case all	37	* the spell must be of this skill, it can be NULL in which case all
44	* matching spells are used.	38	* matching spells are used.
45	*/	39	*/
		40	object *
46	object *find_random_spell_in_ob(object *ob, const char *skill)	41	find_random_spell_in_ob (object *ob, const char *skill)
47	{	42	{
48	int k=0,s;	43	int k = 0, s;
49	object *tmp;	44	object *tmp;
50		45
51	for (tmp=ob->inv; tmp; tmp=tmp->below)	46	for (tmp = ob->inv; tmp; tmp = tmp->below)
52	if (tmp->type == SPELL && (!skill || tmp->skill == skill)) k++;	47	if (tmp->type == SPELL && (!skill || tmp->skill == skill))
		48	k++;
53		49
54	/* No spells, no need to progess further */	50	/* No spells, no need to progess further */
55	if (!k) return NULL;	51	if (!k)
56
57	s = RANDOM() % k;
58
59	for (tmp=ob->inv; tmp; tmp=tmp->below)
60	if (tmp->type == SPELL && (!skill || tmp->skill == skill)) {
61	if (!s) return tmp;
62	else s--;
63	}
64	/* Should never get here, but just in case */
65	return NULL;	52	return NULL;
		53
		54	s = RANDOM () % k;
		55
		56	for (tmp = ob->inv; tmp; tmp = tmp->below)
		57	if (tmp->type == SPELL && (!skill || tmp->skill == skill))
		58	{
		59	if (!s)
		60	return tmp;
		61	else
		62	s--;
		63	}
		64	/* Should never get here, but just in case */
		65	return NULL;
66	}	66	}
67		67
68	/* Relatively simple function that gets used a lot.	68	/* Relatively simple function that gets used a lot.
69	* Basically, it sets up the skill pointer for the spell being	69	* Basically, it sets up the skill pointer for the spell being
70	* cast. If op is really casting the spell, then the skill	70	* cast. If op is really casting the spell, then the skill
71	* is whatever skill the spell requires.	71	* is whatever skill the spell requires.
72	* if instead caster (rod, horn, wand, etc) is casting the skill,	72	* if instead caster (rod, horn, wand, etc) is casting the skill,
73	* then they get exp for the skill that you need to use for	73	* then they get exp for the skill that you need to use for
74	* that object (use magic device).	74	* that object (use magic device).
75	*/	75	*/
		76	void
76	void set_spell_skill(object *op, object *caster, object *spob, object *dest)	77	set_spell_skill (object *op, object *caster, object *spob, object *dest)
77	{	78	{
78	if (dest->skill) FREE_AND_CLEAR_STR(dest->skill);
79	if (caster == op && spob->skill)	79	if (caster == op && spob->skill)
80	dest->skill = add_refcount(spob->skill);	80	dest->skill = spob->skill;
81	else if (caster->skill)	81	else
82	dest->skill = add_refcount(caster->skill);	82	dest->skill = caster->skill;
83	}	83	}
84		84
85	/* init_spells: This should really be called check_spells, as that	85	/* init_spells: This should really be called check_spells, as that
86	* is what it does. It goes through the spells looking for any	86	* is what it does. It goes through the spells looking for any
87	* obvious errors. This was most useful in debugging when re-doing	87	* obvious errors. This was most useful in debugging when re-doing
88	* all the spells to catch simple errors. To use it all the time	88	* all the spells to catch simple errors. To use it all the time
89	* will result in it spitting out messages that aren't really errors.	89	* will result in it spitting out messages that aren't really errors.
90	*/	90	*/
		91	void
91	void init_spells(void) {	92	init_spells (void)
		93	{
92	#ifdef SPELL_DEBUG	94	#ifdef SPELL_DEBUG
93	static int init_spells_done = 0;	95	static int init_spells_done = 0;
94	int i;	96	int i;
95	archetype *at;	97	archetype *at;
96		98
97	if (init_spells_done)	99	if (init_spells_done)
98	return;	100	return;
99	LOG(llevDebug, "Checking spells...\n");	101	LOG (llevDebug, "Checking spells...\n");
100		102
101	for (at=first_archetype; at; at=at->next) {	103	for (at = first_archetype; at; at = at->next)
		104	{
102	if (at->clone.type == SPELL) {	105	if (at->clone.type == SPELL)
		106	{
103	if (at->clone.skill) {	107	if (at->clone.skill)
		108	{
104	for (i=1; i<NUM_SKILLS; i++)	109	for (i = 1; i < NUM_SKILLS; i++)
105	if (!strcmp(skill_names[i], at->clone.skill)) break;	110	if (!strcmp (skill_names[i], at->clone.skill))
		111	break;
106	if (i==NUM_SKILLS) {	112	if (i == NUM_SKILLS)
		113	{
107	LOG(llevError,"Spell %s has improper associated skill %s\n", at->name, at->clone.skill);	114	LOG (llevError, "Spell %s has improper associated skill %s\n", at->name, at->clone.skill);
108	}	115	}
109	}	116	}
110	/* other_arch is already checked for in the loader */	117	/* other_arch is already checked for in the loader */
111	}	118	}
112	}	119	}
113		120
114	i=0;	121	i = 0;
115	while (spell_mapping[i]) {	122	while (spell_mapping[i])
		123	{
116	if (!find_archetype(spell_mapping[i])) {	124	if (!archetype::find (spell_mapping[i]))
		125	{
117	LOG(llevError,"Unable to find spell mapping %s (%i)\n", spell_mapping[i], i);	126	LOG (llevError, "Unable to find spell mapping %s (%i)\n", spell_mapping[i], i);
118	}	127	}
119	i++;	128	i++;
120	}	129	}
121	LOG(llevDebug, "Checking spells completed.\n");	130	LOG (llevDebug, "Checking spells completed.\n");
122	#endif	131	#endif
123	}	132	}
124		133
125	/* Dumps all the spells - now also dumps skill associated with the spell.	134	/* Dumps all the spells - now also dumps skill associated with the spell.
126	* not sure what this would be used for, as the data seems pretty	135	* not sure what this would be used for, as the data seems pretty
127	* minimal, but easy enough to keep around.	136	* minimal, but easy enough to keep around.
128	*/	137	*/
		138	void
129	void dump_spells(void)	139	dump_spells (void)
130	{	140	{
131	archetype *at;	141	archetype *at;
132		142
133	for (at=first_archetype; at; at=at->next) {	143	for (at = first_archetype; at; at = at->next)
		144	{
134	if (at->clone.type == SPELL) {	145	if (at->clone.type == SPELL)
		146	{
135	fprintf(stderr, "%s:%s:%s:%s:%d\n", at->clone.name?at->clone.name:"null",	147	fprintf (stderr, "%s:%s:%s:%s:%d\n", &at->clone.name,
136	at->name, at->clone.other_arch?at->clone.other_arch->name:"null",	148	&at->name, at->clone.other_arch ? &at->clone.other_arch->name : "<nil>", &at->clone.skill, at->clone.level);
137	at->clone.skill?at->clone.skill:"null", at->clone.level);
138	}	149	}
139	}	150	}
140	}	151	}
141		152
142	/* pretty basic function - basically just takes	153	/* pretty basic function - basically just takes
143	* an object, sets the x,y, and calls insert_ob_in_map	154	* an object, sets the x,y, and calls insert_ob_in_map
144	*/	155	*/
145		156
		157	void
146	void spell_effect (object *spob, int x, int y, mapstruct *map,	158	spell_effect (object *spob, int x, int y, maptile *map, object *originator)
147	object *originator)
148	{	159	{
149		160
150	if (spob->other_arch != NULL) {	161	if (spob->other_arch != NULL)
		162	{
151	object *effect = arch_to_object(spob->other_arch);	163	object *effect = arch_to_object (spob->other_arch);
152		164
153	effect->x = x;	165	effect->x = x;
154	effect->y = y;	166	effect->y = y;
155		167
156	insert_ob_in_map(effect, map, originator,0);	168	insert_ob_in_map (effect, map, originator, 0);
157	}	169	}
158	}	170	}
159		171
160	/*	172	/*
161	* This function takes a caster and spell and presents the	173	* This function takes a caster and spell and presents the
…		…
165	*	177	*
166	* caster is person casting hte spell.	178	* caster is person casting hte spell.
167	* spell is the spell object.	179	* spell is the spell object.
168	* Returns modified level.	180	* Returns modified level.
169	*/	181	*/
		182	int
170	int min_casting_level(object *caster, object *spell)	183	min_casting_level (object *caster, object *spell)
171	{	184	{
172	int new_level;	185	int new_level;
173		186
174	if (caster->path_denied & spell->path_attuned) {	187	if (caster->path_denied & spell->path_attuned)
175	/* This case is not a bug, just the fact that this function is
176	* usually called BEFORE checking for path_deny. -AV
177	*/
178	#if 0
179	LOG (llevError, "BUG: path_level_mod (arch %s, name %s): casting denied "
180	"spell\n", caster->arch->name, caster->name);
181	#endif
182	return 1;	188	return 1;
183	}	189
184	new_level = spell->level	190	new_level = spell->level
185	+ ((caster->path_repelled & spell->path_attuned) ? +2 : 0)	191	+ ((caster->path_repelled & spell->path_attuned) ? +2 : 0) + ((caster->path_attuned & spell->path_attuned) ? -2 : 0);
186	+ ((caster->path_attuned & spell->path_attuned) ? -2 : 0);	192
187	return (new_level < 1) ? 1 : new_level;	193	return (new_level < 1) ? 1 : new_level;
188	}	194	}
189		195
190		196
191	/* This function returns the effective level the spell	197	/* This function returns the effective level the spell
192	* is being cast at.	198	* is being cast at.
193	* Note that I changed the repelled/attuned bonus to 2 from 5.	199	* Note that I changed the repelled/attuned bonus to 2 from 5.
194	* This is because the new code compares casting_level against	200	* This is because the new code compares casting_level against
195	* min_caster_level, so the difference is effectively 4	201	* min_caster_level, so the difference is effectively 4
196	*/	202	*/
197		203
		204	int
198	int caster_level(object *caster, object *spell)	205	caster_level (object *caster, object *spell)
199	{	206	{
200	int level = caster->level;	207	int level = caster->level;
201		208
202	/* If this is a player, try to find the matching skill */	209	/* If this is a player, try to find the matching skill */
203	if (caster->type == PLAYER && spell->skill) {	210	if (caster->type == PLAYER && spell->skill)
204	int i;
205
206	for (i=0; i < NUM_SKILLS; i++)	211	for (int i = 0; i < NUM_SKILLS; i++)
207	if (caster->contr->last_skill_ob[i] &&	212	if (caster->contr->last_skill_ob[i] && caster->contr->last_skill_ob[i]->skill == spell->skill)
208	caster->contr->last_skill_ob[i]->skill == spell->skill) {	213	{
209	level = caster->contr->last_skill_ob[i]->level;	214	level = caster->contr->last_skill_ob[i]->level;
210	break;	215	break;
211	}	216	}
212	}
213		217
214	/* if a rod is fired by a player, take the use_magic_item skill in consideration. */	218	/* if a rod is fired by a player, take the use_magic_item skill in consideration. */
215	if (caster->type == ROD && caster->env && caster->env->type == PLAYER)	219	if (caster->type == ROD && caster->env && caster->env->type == PLAYER)
216	{	220	{
217	object *skill = find_skill_by_number (caster->env, SK_USE_MAGIC_ITEM);	221	object *skill = find_skill_by_number (caster->env, SK_USE_MAGIC_ITEM);
218	int sk_level = skill ? skill->level : 1;	222	int sk_level = skill ? skill->level : 1;
		223
219	level = MIN (level, sk_level + level / 10 + 1);	224	level = MIN (level, sk_level + level / 10 + 1);
220	}
221		225	}
		226
222	/* Got valid caster level. Now adjust for attunement */	227	/* Got valid caster level. Now adjust for attunement */
223	level += ((caster->path_repelled & spell->path_attuned) ? -2 : 0)	228	level += ((caster->path_repelled & spell->path_attuned) ? -2 : 0) + ((caster->path_attuned & spell->path_attuned) ? 2 : 0);
224	+ ((caster->path_attuned & spell->path_attuned) ? 2 : 0);
225		229
226	/* Always make this at least 1. If this is zero, we get divide by zero	230	/* Always make this at least 1. If this is zero, we get divide by zero
227	* errors in various places.	231	* errors in various places.
228	*/	232	*/
229	if (level < 1) level = 1;	233	if (level < 1)
		234	level = 1;
		235
230	return level;	236	return level;
231	}	237	}
232		238
233	/* The following function scales the spellpoint cost of	239	/* The following function scales the spellpoint cost of
234	* a spell by it's increased effectiveness. Some of the	240	* a spell by it's increased effectiveness. Some of the
235	* lower level spells become incredibly vicious at high	241	* lower level spells become incredibly vicious at high
…		…
240	* spell is the spell object.	246	* spell is the spell object.
241	* Note that it is now possible for a spell to cost both grace and	247	* Note that it is now possible for a spell to cost both grace and
242	* mana. In that case, we return which ever value is higher.	248	* mana. In that case, we return which ever value is higher.
243	*/	249	*/
244		250
		251	sint16
245	sint16 SP_level_spellpoint_cost(object *caster, object *spell, int flags)	252	SP_level_spellpoint_cost (object *caster, object *spell, int flags)
246	{	253	{
247	int sp, grace, level = caster_level(caster, spell);	254	int sp, grace, level = caster_level (caster, spell);
248		255
249	if (settings.spellpoint_level_depend == TRUE) {	256	if (settings.spellpoint_level_depend == TRUE)
		257	{
250	if (spell->stats.sp && spell->stats.maxsp) {	258	if (spell->stats.sp && spell->stats.maxsp)
251	sp= (int) (spell->stats.sp *
252	(1.0 + MAX(0,
253	(float)(level-spell->level)/ (float)spell->stats.maxsp)));
254	}	259	{
		260	sp = (int) (spell->stats.sp * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxsp)));
		261	}
		262	else
255	else sp = spell->stats.sp;	263	sp = spell->stats.sp;
256		264
257	sp *= (int) PATH_SP_MULT(caster,spell);	265	sp *= (int) PATH_SP_MULT (caster, spell);
258	if (!sp && spell->stats.sp) sp=1;	266	if (!sp && spell->stats.sp)
		267	sp = 1;
259		268
260	if (spell->stats.grace && spell->stats.maxgrace) {	269	if (spell->stats.grace && spell->stats.maxgrace)
261	grace= (int) (spell->stats.grace *
262	(1.0 + MAX(0,
263	(float)(level-spell->level)/ (float)spell->stats.maxgrace)));
264	}	270	{
		271	grace = (int) (spell->stats.grace * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxgrace)));
		272	}
		273	else
265	else grace = spell->stats.grace;	274	grace = spell->stats.grace;
266		275
267	grace *= (int) PATH_SP_MULT(caster,spell);	276	grace *= (int) PATH_SP_MULT (caster, spell);
268	if (spell->stats.grace && !grace) grace=1;	277	if (spell->stats.grace && !grace)
269	} else {	278	grace = 1;
		279	}
		280	else
		281	{
270	sp = (int) (spell->stats.sp * PATH_SP_MULT(caster,spell));	282	sp = (int) (spell->stats.sp * PATH_SP_MULT (caster, spell));
271	if (spell->stats.sp && !sp) sp=1;	283	if (spell->stats.sp && !sp)
		284	sp = 1;
272	grace = (int) (spell->stats.grace * PATH_SP_MULT(caster,spell));	285	grace = (int) (spell->stats.grace * PATH_SP_MULT (caster, spell));
273	if (spell->stats.grace && !grace) grace=1;	286	if (spell->stats.grace && !grace)
		287	grace = 1;
274	}	288	}
275	if (flags == SPELL_HIGHEST)	289	if (flags == SPELL_HIGHEST)
276	return MAX(sp, grace);	290	return MAX (sp, grace);
277	else if (flags == SPELL_GRACE)	291	else if (flags == SPELL_GRACE)
278	return grace;	292	return grace;
279	else if (flags == SPELL_MANA)	293	else if (flags == SPELL_MANA)
280	return sp;	294	return sp;
281	else {	295	else
		296	{
282	LOG(llevError, "SP_level_spellpoint_cost: Unknown flags passed: %d\n", flags);	297	LOG (llevError, "SP_level_spellpoint_cost: Unknown flags passed: %d\n", flags);
283	return 0;	298	return 0;
284	}	299	}
285	}	300	}
286		301
287		302
288	/* SP_level_dam_adjust: Returns adjusted damage based on the caster.	303	/* SP_level_dam_adjust: Returns adjusted damage based on the caster.
289	* spob is the spell we are adjusting.	304	* spob is the spell we are adjusting.
290	*/	305	*/
		306	int
291	int SP_level_dam_adjust(object *caster, object *spob)	307	SP_level_dam_adjust (object *caster, object *spob)
292	{	308	{
293	int level = caster_level (caster, spob);	309	int level = caster_level (caster, spob);
294	int adj = level - min_casting_level(caster, spob);	310	int adj = level - min_casting_level (caster, spob);
295		311
296	if(adj < 0) adj=0;	312	if (adj < 0)
		313	adj = 0;
297	if (spob->dam_modifier)	314	if (spob->dam_modifier)
298	adj/=spob->dam_modifier;	315	adj /= spob->dam_modifier;
299	else adj=0;	316	else
		317	adj = 0;
300	return adj;	318	return adj;
301	}	319	}
302		320
303	/* Adjust the strength of the spell based on level.	321	/* Adjust the strength of the spell based on level.
304	* This is basically the same as SP_level_dam_adjust above,	322	* This is basically the same as SP_level_dam_adjust above,
305	* but instead looks at the level_modifier value.	323	* but instead looks at the level_modifier value.
306	*/	324	*/
		325	int
307	int SP_level_duration_adjust(object *caster, object *spob)	326	SP_level_duration_adjust (object *caster, object *spob)
308	{	327	{
309	int level = caster_level (caster, spob);	328	int level = caster_level (caster, spob);
310	int adj = level - min_casting_level(caster, spob);	329	int adj = level - min_casting_level (caster, spob);
311		330
312	if(adj < 0) adj=0;	331	if (adj < 0)
		332	adj = 0;
313	if(spob->duration_modifier)	333	if (spob->duration_modifier)
314	adj/=spob->duration_modifier;	334	adj /= spob->duration_modifier;
315	else adj=0;	335	else
		336	adj = 0;
316		337
317	return adj;	338	return adj;
318	}	339	}
319		340
320	/* Adjust the strength of the spell based on level.	341	/* Adjust the strength of the spell based on level.
321	* This is basically the same as SP_level_dam_adjust above,	342	* This is basically the same as SP_level_dam_adjust above,
322	* but instead looks at the level_modifier value.	343	* but instead looks at the level_modifier value.
323	*/	344	*/
		345	int
324	int SP_level_range_adjust(object *caster, object *spob)	346	SP_level_range_adjust (object *caster, object *spob)
325	{	347	{
326	int level = caster_level (caster, spob);	348	int level = caster_level (caster, spob);
327	int adj = level - min_casting_level(caster, spob);	349	int adj = level - min_casting_level (caster, spob);
328		350
329	if(adj < 0) adj=0;	351	if (adj < 0)
		352	adj = 0;
330	if(spob->range_modifier)	353	if (spob->range_modifier)
331	adj/=spob->range_modifier;	354	adj /= spob->range_modifier;
332	else adj=0;	355	else
		356	adj = 0;
333		357
334	return adj;	358	return adj;
335	}	359	}
336		360
337	/* Checks to see if player knows the spell. If the name is the same	361	/* Checks to see if player knows the spell. If the name is the same
338	* as an existing spell, we presume they know it.	362	* as an existing spell, we presume they know it.
339	* returns 1 if they know the spell, 0 if they don't.	363	* returns 1 if they know the spell, 0 if they don't.
340	*/	364	*/
		365	object *
341	object *check_spell_known (object *op, const char *name)	366	check_spell_known (object *op, const char *name)
342	{	367	{
343	object *spop;	368	object *spop;
344		369
345	for (spop=op->inv; spop; spop=spop->below)	370	for (spop = op->inv; spop; spop = spop->below)
346	if (spop->type == SPELL && !strcmp(spop->name, name)) return spop;	371	if (spop->type == SPELL && !strcmp (spop->name, name))
		372	return spop;
347		373
348	return NULL;	374	return NULL;
349	}	375	}
350		376
351		377
352	/*	378	/*
353	* Look at object 'op' and see if they know the spell	379	* Look at object 'op' and see if they know the spell
…		…
356	* returns the matching spell object, or NULL.	382	* returns the matching spell object, or NULL.
357	* If we match multiple spells but don't get an	383	* If we match multiple spells but don't get an
358	* exact match, we also return NULL.	384	* exact match, we also return NULL.
359	*/	385	*/
360		386
		387	object *
361	object *lookup_spell_by_name(object *op,const char *spname) {	388	lookup_spell_by_name (object *op, const char *spname)
		389	{
362	object *spob1=NULL, *spob2=NULL, *spob;	390	object *spob1 = NULL, *spob2 = NULL, *spob;
363	int nummatch=0;	391	int nummatch = 0;
364		392
365	if(spname==NULL) return NULL;	393	if (spname == NULL)
		394	return NULL;
366		395
367	/* Try to find the spell. We store the results in spob1	396	/* Try to find the spell. We store the results in spob1
368	* and spob2 - spob1 is only taking the length of	397	* and spob2 - spob1 is only taking the length of
369	* the past spname, spob2 uses the length of the spell name.	398	* the past spname, spob2 uses the length of the spell name.
370	*/	399	*/
371	for (spob = op->inv; spob; spob=spob->below) {	400	for (spob = op->inv; spob; spob = spob->below)
		401	{
372	if (spob->type == SPELL) {	402	if (spob->type == SPELL)
		403	{
373	if (!strncmp(spob->name, spname, strlen(spname))) {	404	if (!strncmp (spob->name, spname, strlen (spname)))
		405	{
374	nummatch++;	406	nummatch++;
375	spob1 = spob;	407	spob1 = spob;
376	} else if (!strncmp(spob->name, spname, strlen(spob->name))) {
377	/* if spells have ambiguous names, it makes matching
378	* really difficult. (eg, fire and fireball would
379	* fall into this category). It shouldn't be hard to
380	* make sure spell names don't overlap in that fashion.
381	*/
382	if (spob2)
383	LOG(llevError,"Found multiple spells with overlapping base names: %s, %s\n",
384	spob2->name, spob->name);
385	spob2 = spob;
386	}	408	}
		409	else if (!strncmp (spob->name, spname, strlen (spob->name)))
		410	{
		411	/* if spells have ambiguous names, it makes matching
		412	* really difficult. (eg, fire and fireball would
		413	* fall into this category). It shouldn't be hard to
		414	* make sure spell names don't overlap in that fashion.
		415	*/
		416	if (spob2)
		417	LOG (llevError, "Found multiple spells with overlapping base names: %s, %s\n", &spob2->name, &spob->name);
		418	spob2 = spob;
387	}	419	}
		420	}
388	}	421	}
389	/* if we have best match, return it. Otherwise, if we have one match	422	/* if we have best match, return it. Otherwise, if we have one match
390	* on the loser match, return that, otehrwise null	423	* on the loser match, return that, otehrwise null
391	*/	424	*/
		425	if (spob2)
392	if (spob2) return spob2;	426	return spob2;
393	if (spob1 && nummatch == 1) return spob1;	427	if (spob1 && nummatch == 1)
		428	return spob1;
394	return NULL;	429	return NULL;
395	}	430	}
396		431
397	/* reflwall - decides weither the (spell-)object sp_op will	432	/* reflwall - decides weither the (spell-)object sp_op will
398	* be reflected from the given mapsquare. Returns 1 if true.	433	* be reflected from the given mapsquare. Returns 1 if true.
399	* (Note that for living creatures there is a small chance that	434	* (Note that for living creatures there is a small chance that
400	* reflect_spell fails.)	435	* reflect_spell fails.)
401	* Caller should be sure it passes us valid map coordinates	436	* Caller should be sure it passes us valid map coordinates
402	* eg, updated for tiled maps.	437	* eg, updated for tiled maps.
403	*/	438	*/
		439	int
404	int reflwall(mapstruct *m,int x,int y, object *sp_op) {	440	reflwall (maptile *m, int x, int y, object *sp_op)
		441	{
405	object *op;	442	object *op;
406		443
407	if(OUT_OF_REAL_MAP(m,x,y)) return 0;	444	if (OUT_OF_REAL_MAP (m, x, y))
408	for(op=get_map_ob(m,x,y);op!=NULL;op=op->above)
409	if(QUERY_FLAG(op, FLAG_REFL_SPELL) && (!QUERY_FLAG(op, FLAG_ALIVE) ||
410	sp_op->type==LIGHTNING || (rndm(0, 99)) < 90-(sp_op->level/10)))
411	return 1;
412
413	return 0;	445	return 0;
		446	for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above)
		447	if (QUERY_FLAG (op, FLAG_REFL_SPELL)
		448	&& (!QUERY_FLAG (op, FLAG_ALIVE)
		449	|| sp_op->type == LIGHTNING // XXX: elmex: why is LIGHTNING special cased here?
		450	// most spells use subtypes for bolts today...
		451	|| (rndm (0, 99)) < 90 - (sp_op->level / 10)))
		452	return 1;
		453
		454	return 0;
414	}	455	}
415		456
416	/* cast_create_object: creates object new_op in direction dir	457	/* cast_create_object: creates object new_op in direction dir
417	* or if that is blocked, beneath the player (op).	458	* or if that is blocked, beneath the player (op).
418	* we pass 'caster', but don't use it for anything.	459	* we pass 'caster', but don't use it for anything.
419	* This is really just a simple wrapper function .	460	* This is really just a simple wrapper function .
420	* returns the direction that the object was actually placed	461	* returns the direction that the object was actually placed
421	* in.	462	* in.
422	*/	463	*/
		464	int
423	int cast_create_obj(object *op,object *caster,object *new_op, int dir)	465	cast_create_obj (object *op, object *caster, object *new_op, int dir)
424	{	466	{
425	mapstruct *m;	467	maptile *m;
426	sint16 sx, sy;	468	sint16 sx, sy;
427		469
428	if(dir &&	470	if (dir &&
429	((get_map_flags(op->map, &m, op->x+freearr_x[dir],op->y+freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) ||	471	((get_map_flags (op->map, &m, op->x + freearr_x[dir], op->y + freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) ||
430	OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(m, sx, sy)))) {	472	OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))))
		473	{
431	new_draw_info(NDI_UNIQUE, 0,op,"Something is in the way.");	474	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
432	new_draw_info(NDI_UNIQUE, 0,op,"You cast it at your feet.");	475	new_draw_info (NDI_UNIQUE, 0, op, "You cast it at your feet.");
433	dir = 0;	476	dir = 0;
434	}	477	}
435	new_op->x=op->x+freearr_x[dir];	478	new_op->x = op->x + freearr_x[dir];
436	new_op->y=op->y+freearr_y[dir];	479	new_op->y = op->y + freearr_y[dir];
437	if (dir == 0)	480	if (dir == 0)
438	insert_ob_in_map(new_op,op->map,op,INS_BELOW_ORIGINATOR);	481	insert_ob_in_map (new_op, op->map, op, INS_BELOW_ORIGINATOR);
439	else	482	else
440	insert_ob_in_map(new_op,op->map,op,0);	483	insert_ob_in_map (new_op, op->map, op, 0);
441	return dir;	484	return dir;
442	}	485	}
443		486
444	/* Returns true if it is ok to put spell *op on the space/may provided.	487	/* Returns true if it is ok to put spell *op on the space/may provided.
445	* immune_stop is basically the attacktype of the spell (why	488	* immune_stop is basically the attacktype of the spell (why
446	* passed as a different value, not sure of). If immune_stop	489	* passed as a different value, not sure of). If immune_stop
…		…
448	* on the space, the object doesn't get placed. if immune stop	491	* on the space, the object doesn't get placed. if immune stop
449	* does not have AT_MAGIC, then counterwalls do not effect the spell.	492	* does not have AT_MAGIC, then counterwalls do not effect the spell.
450	*	493	*
451	*/	494	*/
452		495
		496	int
453	int ok_to_put_more(mapstruct *m,sint16 x,sint16 y,object *op,int immune_stop) {	497	ok_to_put_more (maptile *m, sint16 x, sint16 y, object *op, int immune_stop)
		498	{
454	object *tmp;	499	object *tmp;
455	int mflags;	500	int mflags;
456	mapstruct *mp;	501	maptile *mp;
457		502
458	mp = m;	503	mp = m;
459	mflags = get_map_flags(m, &mp, x, y, &x, &y);	504	mflags = get_map_flags (m, &mp, x, y, &x, &y);
460		505
461	if (mflags & P_OUT_OF_MAP) return 0;	506	if (mflags & P_OUT_OF_MAP)
		507	return 0;
462		508
463	if (OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(mp, x, y))) return 0;	509	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (mp, x, y)))
		510	return 0;
464		511
465	for(tmp=get_map_ob(mp,x,y);tmp!=NULL;tmp=tmp->above) {	512	for (tmp = GET_MAP_OB (mp, x, y); tmp != NULL; tmp = tmp->above)
		513	{
466	/* If there is a counterspell on the space, and this	514	/* If there is a counterspell on the space, and this
467	* object is using magic, don't progress. I believe we could	515	* object is using magic, don't progress. I believe we could
468	* leave this out and let in progress, and other areas of the code	516	* leave this out and let in progress, and other areas of the code
469	* will then remove it, but that would seem to to use more	517	* will then remove it, but that would seem to to use more
470	* resources, and may not work as well if a player is standing	518	* resources, and may not work as well if a player is standing
471	* on top of a counterwall spell (may hit the player before being	519	* on top of a counterwall spell (may hit the player before being
472	* removed.) On the other hand, it may be more dramatic for the	520	* removed.) On the other hand, it may be more dramatic for the
473	* spell to actually hit the counterwall and be sucked up.	521	* spell to actually hit the counterwall and be sucked up.
474	*/	522	*/
475	if ((tmp->attacktype & AT_COUNTERSPELL) &&	523	if ((tmp->attacktype & AT_COUNTERSPELL) &&
476	(tmp->type != PLAYER) && !QUERY_FLAG(tmp,FLAG_MONSTER) &&	524	(tmp->type != PLAYER) && !QUERY_FLAG (tmp, FLAG_MONSTER) &&
477	(tmp->type != WEAPON) && (tmp->type != BOW) &&	525	(tmp->type != WEAPON) && (tmp->type != BOW) && (tmp->type != ARROW) && (tmp->type != GOLEM) && (immune_stop & AT_MAGIC))
478	(tmp->type != ARROW) && (tmp->type != GOLEM) &&	526	return 0;
479	(immune_stop & AT_MAGIC)) return 0;
480		527
481	/* This is to prevent 'out of control' spells. Basically, this	528	/* This is to prevent 'out of control' spells. Basically, this
482	* limits one spell effect per space per spell. This is definately	529	* limits one spell effect per space per spell. This is definately
483	* needed for performance reasons, and just for playability I believe.	530	* needed for performance reasons, and just for playability I believe.
484	* there are no such things as multispaced spells right now, so	531	* there are no such things as multispaced spells right now, so
485	* we don't need to worry about the head.	532	* we don't need to worry about the head.
486	*/	533	*/
487	if ((tmp->stats.maxhp == op->stats.maxhp) && (tmp->type == op->type) &&	534	if ((tmp->stats.maxhp == op->stats.maxhp) && (tmp->type == op->type) && (tmp->subtype == op->subtype))
488	(tmp->subtype == op->subtype))
489	return 0;	535	return 0;
490		536
491	/*	537	/*
492	* Combine similar spell effects into one spell effect. Needed for	538	* Combine similar spell effects into one spell effect. Needed for
493	* performance reasons with meteor swarm and the like, but also for	539	* performance reasons with meteor swarm and the like, but also for
494	* playability reasons.	540	* playability reasons.
495	*/	541	*/
496	if (tmp->arch == op->arch	542	if (tmp->arch == op->arch
497	&& tmp->type == op->type	543	&& tmp->type == op->type
498	&& tmp->subtype == op->subtype	544	&& tmp->subtype == op->subtype
499	&& tmp->owner == op->owner	545	&& tmp->owner == op->owner && ((tmp->subtype == SP_EXPLOSION) || (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp)))
500	&& ((tmp->subtype == SP_EXPLOSION)
501	|| (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp))
502	) {	546	{
503	tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam);	547	tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam);
504	tmp->range = MAX (tmp->range, op->range);	548	tmp->range = MAX (tmp->range, op->range);
505	tmp->duration = MAX (tmp->duration, op->duration);	549	tmp->duration = MAX (tmp->duration, op->duration);
506	return 0;	550	return 0;
507	}	551	}
508		552
509	/* Perhaps we should also put checks in for no magic and unholy	553	/* Perhaps we should also put checks in for no magic and unholy
510	* ground to prevent it from moving along?	554	* ground to prevent it from moving along?
511	*/	555	*/
512	}	556	}
513	/* If it passes the above tests, it must be OK */	557	/* If it passes the above tests, it must be OK */
514	return 1;	558	return 1;
515	}	559	}
516		560
517	/* fire_arch_from_position: fires an archetype.	561	/* fire_arch_from_position: fires an archetype.
518	* op: person firing the object.	562	* op: person firing the object.
519	* caster: object casting the spell.	563	* caster: object casting the spell.
…		…
522	* dir: direction to fire in.	566	* dir: direction to fire in.
523	* spell: spell that is being fired. It uses other_arch for the archetype	567	* spell: spell that is being fired. It uses other_arch for the archetype
524	* to fire.	568	* to fire.
525	* returns 0 on failure, 1 on success.	569	* returns 0 on failure, 1 on success.
526	*/	570	*/
527		571
		572	int
528	int fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y,	573	fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y, int dir, object *spell)
529	int dir, object *spell)
530	{	574	{
531	object *tmp;	575	object *tmp;
532	int mflags;	576	int mflags;
533	mapstruct *m;	577	maptile *m;
534		578
535	if(spell->other_arch==NULL)	579	if (spell->other_arch == NULL)
		580	return 0;
		581
		582	m = op->map;
		583	mflags = get_map_flags (m, &m, x, y, &x, &y);
		584	if (mflags & P_OUT_OF_MAP)
		585	{
		586	return 0;
		587	}
		588
		589	tmp = arch_to_object (spell->other_arch);
		590
		591	if (tmp == NULL)
		592	return 0;
		593
		594	if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, x, y)))
		595	{
		596	new_draw_info (NDI_UNIQUE, 0, op, "You can't cast the spell on top of a wall!\n");
		597	tmp->destroy ();
		598	return 0;
		599	}
		600
		601	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
		602	tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
		603	/* code in time.c uses food for some things, duration for others */
		604	tmp->stats.food = tmp->duration;
		605	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
		606	tmp->attacktype = spell->attacktype;
		607	tmp->x = x;
		608	tmp->y = y;
		609	tmp->direction = dir;
		610	if (op->owner != NULL)
		611	tmp->set_owner (op);
		612	else
		613	tmp->set_owner (op);
		614	tmp->level = caster_level (caster, spell);
		615	set_spell_skill (op, caster, spell, tmp);
		616
		617	/* needed for AT_HOLYWORD,AT_GODPOWER stuff */
		618	if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
		619	{
		620	if (!tailor_god_spell (tmp, op))
536	return 0;	621	return 0;
537
538	m = op->map;
539	mflags = get_map_flags(m, &m, x, y, &x, &y);
540	if (mflags & P_OUT_OF_MAP) {
541	return 0;
542	}	622	}
543
544	tmp=arch_to_object(spell->other_arch);
545
546	if(tmp==NULL)
547	return 0;
548
549	if (OB_TYPE_MOVE_BLOCK(tmp, GET_MAP_MOVE_BLOCK(m, x, y))) {
550	new_draw_info(NDI_UNIQUE, 0, op, "You can't cast the spell on top of a wall!\n");
551	free_object(tmp);
552	return 0;
553	}
554
555
556
557	tmp->stats.dam=spell->stats.dam+SP_level_dam_adjust(caster,spell);
558	tmp->duration=spell->duration+SP_level_duration_adjust(caster,spell);
559	/* code in time.c uses food for some things, duration for others */
560	tmp->stats.food = tmp->duration;
561	tmp->range=spell->range+SP_level_range_adjust(caster,spell);
562	tmp->attacktype = spell->attacktype;
563	tmp->x=x;
564	tmp->y=y;
565	tmp->direction=dir;
566	if (get_owner (op) != NULL)
567	copy_owner (tmp, op);
568	else
569	set_owner (tmp, op);
570	tmp->level = caster_level (caster, spell);
571	set_spell_skill(op, caster, spell, tmp);
572
573	/* needed for AT_HOLYWORD,AT_GODPOWER stuff */
574	if(tmp->attacktype&AT_HOLYWORD || tmp->attacktype&AT_GODPOWER) {
575	if(!tailor_god_spell(tmp,op)) return 0;
576	}
577	if(QUERY_FLAG(tmp, FLAG_IS_TURNABLE))	623	if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
578	SET_ANIMATION(tmp, dir);	624	SET_ANIMATION (tmp, dir);
579		625
580	if ((tmp = insert_ob_in_map (tmp, m, op,0)) == NULL)	626	if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL)
581	return 1;
582
583	move_spell_effect(tmp);
584
585	return 1;	627	return 1;
		628
		629	move_spell_effect (tmp);
		630
		631	return 1;
586	}	632	}
587		633
588		634
589		635
590	/*****************************************************************************	636	/*****************************************************************************
591	*	637	*
592	* Code related to rods - perhaps better located in another file?	638	* Code related to rods - perhaps better located in another file?
593	*	639	*
594	****************************************************************************/	640	****************************************************************************/
595		641
		642	void
596	void regenerate_rod(object *rod) {	643	regenerate_rod (object *rod)
		644	{
597	if (rod->stats.hp < rod->stats.maxhp) {	645	if (rod->stats.hp < rod->stats.maxhp)
		646	{
598	rod->stats.hp+= 1 + rod->stats.maxhp/10;	647	rod->stats.hp += 1 + rod->stats.maxhp / 10;
599		648
600	if (rod->stats.hp > rod->stats.maxhp)	649	if (rod->stats.hp > rod->stats.maxhp)
601	rod->stats.hp = rod->stats.maxhp;	650	rod->stats.hp = rod->stats.maxhp;
602	}	651	}
603	}	652	}
604		653
605		654
		655	void
606	void drain_rod_charge(object *rod) {	656	drain_rod_charge (object *rod)
		657	{
607	rod->stats.hp -= SP_level_spellpoint_cost(rod, rod->inv, SPELL_HIGHEST);	658	rod->stats.hp -= SP_level_spellpoint_cost (rod, rod->inv, SPELL_HIGHEST);
608	}	659	}
609		660
610		661
611		662
612		663
…		…
615	* op is what is looking for the target (which can be a player),	666	* op is what is looking for the target (which can be a player),
616	* dir is the direction we are looking in. Return object found, or	667	* dir is the direction we are looking in. Return object found, or
617	* NULL if no good object.	668	* NULL if no good object.
618	*/	669	*/
619		670
		671	object *
620	object *find_target_for_friendly_spell(object *op,int dir) {	672	find_target_for_friendly_spell (object *op, int dir)
		673	{
621	object *tmp;	674	object *tmp;
622	mapstruct *m;	675	maptile *m;
623	sint16 x, y;	676	sint16 x, y;
624	int mflags;	677	int mflags;
625		678
626	/* I don't really get this block - if op isn't a player or rune,	679	/* I don't really get this block - if op isn't a player or rune,
627	* we then make the owner of this object the target.	680	* we then make the owner of this object the target.
628	* The owner could very well be no where near op.	681	* The owner could very well be no where near op.
629	*/	682	*/
630	if(op->type!=PLAYER && op->type!=RUNE) {	683	if (op->type != PLAYER && op->type != RUNE)
631	tmp=get_owner(op);	684	{
		685	tmp = op->owner;
632	/* If the owner does not exist, or is not a monster, than apply the spell	686	/* If the owner does not exist, or is not a monster, than apply the spell
633	* to the caster.	687	* to the caster.
634	*/	688	*/
635	if(!tmp || !QUERY_FLAG(tmp,FLAG_MONSTER)) tmp=op;	689	if (!tmp || !QUERY_FLAG (tmp, FLAG_MONSTER))
		690	tmp = op;
		691	}
		692	else
636	}	693	{
637	else {
638	m = op->map;	694	m = op->map;
639	x = op->x+freearr_x[dir];	695	x = op->x + freearr_x[dir];
640	y = op->y+freearr_y[dir];	696	y = op->y + freearr_y[dir];
641		697
642	mflags = get_map_flags(m, &m, x, y, &x, &y);	698	mflags = get_map_flags (m, &m, x, y, &x, &y);
643		699
644	if (mflags & P_OUT_OF_MAP)	700	if (mflags & P_OUT_OF_MAP)
645	tmp=NULL;	701	tmp = NULL;
646	else {	702	else
647	for(tmp=get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above)
648	if(tmp->type==PLAYER)
649	break;
650	}	703	{
651	}	704	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
652	/* didn't find a player there, look in current square for a player */
653	if(tmp==NULL)
654	for(tmp=get_map_ob(op->map,op->x,op->y);tmp!=NULL;tmp=tmp->above)
655	{
656	if(tmp->type==PLAYER)	705	if (tmp->type == PLAYER)
657	break;	706	break;
658	}	707	}
		708	}
		709	/* didn't find a player there, look in current square for a player */
		710	if (tmp == NULL)
		711	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
		712	{
		713	if (tmp->type == PLAYER)
		714	break;
		715	}
659		716
660	return tmp;	717	return tmp;
661	}	718	}
662		719
663		720
664		721
665	/* raytrace:	722	/* raytrace:
…		…
672	* It returns the direction toward the first/closest live object if it finds	729	* It returns the direction toward the first/closest live object if it finds
673	* any, otherwise -1.	730	* any, otherwise -1.
674	* note that exclude can be NULL, in which case all bets are off.	731	* note that exclude can be NULL, in which case all bets are off.
675	*/	732	*/
676		733
		734	int
677	int spell_find_dir(mapstruct *m, int x, int y, object *exclude) {	735	spell_find_dir (maptile *m, int x, int y, object *exclude)
		736	{
678	int i,max=SIZEOFFREE;	737	int i, max = SIZEOFFREE;
679	sint16 nx,ny;	738	sint16 nx, ny;
680	int owner_type=0, mflags;	739	int owner_type = 0, mflags;
681	object *tmp;	740	object *tmp;
682	mapstruct *mp;	741	maptile *mp;
683		742
684	if (exclude && exclude->head)	743	if (exclude && exclude->head)
685	exclude = exclude->head;	744	exclude = exclude->head;
686	if (exclude && exclude->type)	745	if (exclude && exclude->type)
687	owner_type = exclude->type;	746	owner_type = exclude->type;
688		747
689	for(i=rndm(1, 8);i<max;i++) {	748	for (i = rndm (1, 8); i < max; i++)
		749	{
690	nx = x + freearr_x[i];	750	nx = x + freearr_x[i];
691	ny = y + freearr_y[i];	751	ny = y + freearr_y[i];
692	mp = m;	752	mp = m;
693	mflags = get_map_flags(m, &mp, nx, ny, &nx, &ny);	753	mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
694	if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW)) continue;	754	if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW))
		755	continue;
695		756
696	tmp=get_map_ob(mp,nx,ny);	757	tmp = GET_MAP_OB (mp, nx, ny);
697		758
698	while(tmp!=NULL && (((owner_type==PLAYER &&	759	while (tmp != NULL && (((owner_type == PLAYER &&
699	!QUERY_FLAG(tmp,FLAG_MONSTER) && !QUERY_FLAG(tmp,FLAG_GENERATOR)) ||	760	!QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_GENERATOR)) ||
700	(owner_type!=PLAYER && tmp->type!=PLAYER)) ||	761	(owner_type != PLAYER && tmp->type != PLAYER)) || (tmp == exclude || (tmp->head && tmp->head == exclude))))
701	(tmp == exclude || (tmp->head && tmp->head == exclude))))
702	tmp=tmp->above;	762	tmp = tmp->above;
703		763
704	if(tmp!=NULL && can_see_monsterP(m,x,y,i))	764	if (tmp != NULL && can_see_monsterP (m, x, y, i))
705	return freedir[i];	765	return freedir[i];
706	}	766	}
707	return -1; /* flag for "keep going the way you were" */	767	return -1; /* flag for "keep going the way you were" */
708	}	768	}
709		769
710		770
711		771
712	/* put_a_monster: puts a monster named monstername near by	772	/* put_a_monster: puts a monster named monstername near by
713	* op. This creates the treasures for the monsters, and	773	* op. This creates the treasures for the monsters, and
714	* also deals with multipart monsters properly.	774	* also deals with multipart monsters properly.
715	*/	775	*/
716		776
		777	void
717	void put_a_monster(object *op,const char *monstername) {	778	put_a_monster (object *op, const char *monstername)
		779	{
718	object *tmp,*head=NULL,*prev=NULL;	780	object *tmp, *head = NULL, *prev = NULL;
719	archetype *at;	781	archetype *at;
720	int dir;	782	int dir;
721		783
722	/* Handle cases where we are passed a bogus mosntername */	784	/* Handle cases where we are passed a bogus mosntername */
723		785
724	if((at=find_archetype(monstername))==NULL) return;	786	if ((at = archetype::find (monstername)) == NULL)
		787	return;
725		788
726	/* find a free square nearby	789	/* find a free square nearby
727	* first we check the closest square for free squares	790	* first we check the closest square for free squares
728	*/	791	*/
729		792
730	dir=find_first_free_spot(&at->clone,op->map,op->x,op->y);	793	dir = find_first_free_spot (&at->clone, op->map, op->x, op->y);
731	if(dir!=-1) {	794	if (dir != -1)
		795	{
732	/* This is basically grabbed for generate monster. Fixed 971225 to	796	/* This is basically grabbed for generate monster. Fixed 971225 to
733	* insert multipart monsters properly	797	* insert multipart monsters properly
734	*/	798	*/
735	while (at!=NULL) {	799	while (at != NULL)
		800	{
736	tmp=arch_to_object(at);	801	tmp = arch_to_object (at);
737	tmp->x=op->x+freearr_x[dir]+at->clone.x;	802	tmp->x = op->x + freearr_x[dir] + at->clone.x;
738	tmp->y=op->y+freearr_y[dir]+at->clone.y;	803	tmp->y = op->y + freearr_y[dir] + at->clone.y;
739	tmp->map = op->map;	804	tmp->map = op->map;
740	if (head) {	805	if (head)
		806	{
741	tmp->head=head;	807	tmp->head = head;
742	prev->more=tmp;	808	prev->more = tmp;
743	}	809	}
744	if (!head) head=tmp;	810	if (!head)
		811	head = tmp;
745	prev=tmp;	812	prev = tmp;
746	at=at->more;	813	at = at->more;
747	}	814	}
748		815
749	if (head->randomitems)	816	if (head->randomitems)
750	create_treasure(head->randomitems, head, GT_INVISIBLE, op->map->difficulty,0);	817	create_treasure (head->randomitems, head, GT_INVISIBLE, op->map->difficulty, 0);
751		818
752	insert_ob_in_map(head,op->map,op,0);	819	insert_ob_in_map (head, op->map, op, 0);
753		820
754	/* thought it'd be cool to insert a burnout, too.*/	821	/* thought it'd be cool to insert a burnout, too. */
755	tmp=get_archetype("burnout");	822	tmp = get_archetype ("burnout");
756	tmp->map = op->map;	823	tmp->map = op->map;
757	tmp->x=op->x+freearr_x[dir];	824	tmp->x = op->x + freearr_x[dir];
758	tmp->y=op->y+freearr_y[dir];	825	tmp->y = op->y + freearr_y[dir];
759	insert_ob_in_map(tmp,op->map,op,0);	826	insert_ob_in_map (tmp, op->map, op, 0);
760	}	827	}
761	}	828	}
762		829
763	/* peterm: function which summons hostile monsters and	830	/* peterm: function which summons hostile monsters and
764	* places them in nearby squares.	831	* places them in nearby squares.
…		…
772	* use to call this, but best I can tell, that spell/ability was	839	* use to call this, but best I can tell, that spell/ability was
773	* never used. This is however used by various failures on the	840	* never used. This is however used by various failures on the
774	* players part (alchemy, reincarnation, etc)	841	* players part (alchemy, reincarnation, etc)
775	*/	842	*/
776		843
		844	int
777	int summon_hostile_monsters(object *op,int n,const char *monstername){	845	summon_hostile_monsters (object *op, int n, const char *monstername)
		846	{
778	int i;	847	int i;
		848
779	for(i=0;i<n;i++)	849	for (i = 0; i < n; i++)
780	put_a_monster(op,monstername);	850	put_a_monster (op, monstername);
781		851
782	return n;	852	return n;
783	}	853	}
784		854
785		855
786	/* Some local definitions for shuffle-attack */	856	/* Some local definitions for shuffle-attack */
787	struct attacktype_shuffle {	857	struct attacktype_shuffle
		858	{
788	int attacktype;	859	int attacktype;
789	int face;	860	int face;
790	} ATTACKS[22] = {	861	} ATTACKS[22] =
		862	{
		863	{
791	{AT_PHYSICAL,0},	864	AT_PHYSICAL, 0},
		865	{
792	{AT_PHYSICAL,0}, /*face = explosion*/	866	AT_PHYSICAL, 0}, /*face = explosion */
		867	{
793	{AT_PHYSICAL,0},	868	AT_PHYSICAL, 0},
		869	{
794	{AT_MAGIC,1},	870	AT_MAGIC, 1},
		871	{
795	{AT_MAGIC,1}, /* face = last-burnout */	872	AT_MAGIC, 1}, /* face = last-burnout */
		873	{
796	{AT_MAGIC,1},	874	AT_MAGIC, 1},
		875	{
797	{AT_FIRE,2},	876	AT_FIRE, 2},
		877	{
798	{AT_FIRE,2}, /* face = fire.... */	878	AT_FIRE, 2}, /* face = fire.... */
		879	{
799	{AT_FIRE,2},	880	AT_FIRE, 2},
		881	{
800	{AT_ELECTRICITY,3},	882	AT_ELECTRICITY, 3},
		883	{
801	{AT_ELECTRICITY,3}, /* ball_lightning */	884	AT_ELECTRICITY, 3}, /* ball_lightning */
		885	{
802	{AT_ELECTRICITY,3},	886	AT_ELECTRICITY, 3},
803	{AT_COLD,4},	887	{
804	{AT_COLD,4}, /* face=icestorm*/
805	{AT_COLD,4},	888	AT_COLD, 4},
		889	{
		890	AT_COLD, 4}, /* face=icestorm */
		891	{
		892	AT_COLD, 4},
		893	{
806	{AT_CONFUSION,5},	894	AT_CONFUSION, 5},
		895	{
807	{AT_POISON,7},	896	AT_POISON, 7},
		897	{
808	{AT_POISON,7}, /* face = acid sphere. generator */	898	AT_POISON, 7}, /* face = acid sphere. generator */
		899	{
809	{AT_POISON,7}, /* poisoncloud face */	900	AT_POISON, 7}, /* poisoncloud face */
		901	{
810	{AT_SLOW,8},	902	AT_SLOW, 8},
		903	{
811	{AT_PARALYZE,9},	904	AT_PARALYZE, 9},
812	{AT_FEAR,10} };	905	{
		906	AT_FEAR, 10}};
813		907
814		908
815		909
816	/* shuffle_attack: peterm	910	/* shuffle_attack: peterm
817	* This routine shuffles the attack of op to one of the	911	* This routine shuffles the attack of op to one of the
…		…
827	* would be nice.	921	* would be nice.
828	* I also fixed a bug here in that attacktype was |= -	922	* I also fixed a bug here in that attacktype was |= -
829	* to me, that would be that it would quickly get all	923	* to me, that would be that it would quickly get all
830	* attacktypes, which probably wasn't the intent. MSW 2003-06-03	924	* attacktypes, which probably wasn't the intent. MSW 2003-06-03
831	*/	925	*/
		926	void
832	void shuffle_attack(object *op,int change_face)	927	shuffle_attack (object *op, int change_face)
833	{	928	{
834	int i;	929	int i;
		930
835	i=rndm(0, 21);	931	i = rndm (0, 21);
836		932
837	op->attacktype=ATTACKS[i].attacktype|AT_MAGIC;	933	op->attacktype = ATTACKS[i].attacktype | AT_MAGIC;
838		934
839	if(change_face) {	935	if (change_face)
		936	{
840	SET_ANIMATION(op, ATTACKS[i].face);	937	SET_ANIMATION (op, ATTACKS[i].face);
841	}	938	}
842	}	939	}
843		940
844		941
845	/* prayer_failure: This is called when a player fails	942	/* prayer_failure: This is called when a player fails
…		…
847	* op is the player.	944	* op is the player.
848	* failure is basically how much grace they had.	945	* failure is basically how much grace they had.
849	* power is how much grace the spell would normally take to cast.	946	* power is how much grace the spell would normally take to cast.
850	*/	947	*/
851		948
		949	void
852	void prayer_failure(object *op, int failure,int power)	950	prayer_failure (object *op, int failure, int power)
853	{	951	{
854	const char *godname;	952	const char *godname;
855	object *tmp;	953	object *tmp;
856		954
857	if(!strcmp((godname=determine_god(op)),"none")) godname="Your spirit";	955	if (!strcmp ((godname = determine_god (op)), "none"))
		956	godname = "Your spirit";
858		957
859	if(failure<= -20 && failure > -40) /* wonder */	958	if (failure <= -20 && failure > -40) /* wonder */
860	{	959	{
861	new_draw_info_format(NDI_UNIQUE, 0,op,"%s gives a sign to renew your faith.",godname);	960	new_draw_info_format (NDI_UNIQUE, 0, op, "%s gives a sign to renew your faith.", godname);
862	tmp = get_archetype(SPELL_WONDER);	961	tmp = get_archetype (SPELL_WONDER);
863	cast_cone(op,op,0,tmp);	962	cast_cone (op, op, 0, tmp);
864	free_object(tmp);	963	tmp->destroy ();
865	}	964	}
866		965
867	else if (failure <= -40 && failure > -60) /* confusion */	966	else if (failure <= -40 && failure > -60) /* confusion */
868	{	967	{
869	new_draw_info(NDI_UNIQUE, 0,op,"Your diety touches your mind!");	968	new_draw_info (NDI_UNIQUE, 0, op, "Your diety touches your mind!");
870	confuse_player(op,op,99);	969	confuse_player (op, op, 99);
871	}	970	}
872	else if (failure <= -60 && failure> -150) /* paralysis */	971	else if (failure <= -60 && failure > -150) /* paralysis */
873	{	972	{
874	new_draw_info_format(NDI_UNIQUE, 0,op,"%s requires you to pray NOW.",godname);	973	new_draw_info_format (NDI_UNIQUE, 0, op, "%s requires you to pray NOW.", godname);
875	new_draw_info(NDI_UNIQUE, 0,op,"You comply, ignoring all else.");	974	new_draw_info (NDI_UNIQUE, 0, op, "You comply, ignoring all else.");
876	paralyze_player(op,op,99);	975	paralyze_player (op, op, 99);
877	}	976	}
878	else if (failure <= -150) /* blast the immediate area */	977	else if (failure <= -150) /* blast the immediate area */
879	{	978	{
880	tmp = get_archetype(GOD_POWER);	979	tmp = get_archetype (GOD_POWER);
881	new_draw_info_format(NDI_UNIQUE, 0,op,"%s smites you!",godname);	980	new_draw_info_format (NDI_UNIQUE, 0, op, "%s smites you!", godname);
882	cast_magic_storm(op,tmp, power);	981	cast_magic_storm (op, tmp, power);
883	}	982	}
884	}	983	}
885		984
886	/*	985	/*
887	* spell_failure() handles the various effects for differing degrees	986	* spell_failure() handles the various effects for differing degrees
…		…
890	* failure is a random value of how badly you failed.	989	* failure is a random value of how badly you failed.
891	* power is how many spellpoints you'd normally need for the spell.	990	* power is how many spellpoints you'd normally need for the spell.
892	* skill is the skill you'd need to cast the spell.	991	* skill is the skill you'd need to cast the spell.
893	*/	992	*/
894		993
		994	void
895	void spell_failure(object *op, int failure,int power, object *skill)	995	spell_failure (object *op, int failure, int power, object *skill)
896	{	996	{
897	object *tmp;	997	object *tmp;
898		998
899	if (settings.spell_failure_effects == FALSE)	999	if (settings.spell_failure_effects == FALSE)
900	return;	1000	return;
901		1001
902	if (failure<=-20 && failure > -40) /* wonder */	1002	if (failure <= -20 && failure > -40) /* wonder */
903	{	1003	{
904	new_draw_info(NDI_UNIQUE, 0,op,"Your spell causes an unexpected effect.");	1004	new_draw_info (NDI_UNIQUE, 0, op, "Your spell causes an unexpected effect.");
905	tmp = get_archetype(SPELL_WONDER);	1005	tmp = get_archetype (SPELL_WONDER);
906	cast_cone(op,op,0,tmp);	1006	cast_cone (op, op, 0, tmp);
907	free_object(tmp);	1007	tmp->destroy ();
908	}	1008	}
909		1009
910	else if (failure <= -40 && failure > -60) /* confusion */	1010	else if (failure <= -40 && failure > -60) /* confusion */
911	{	1011	{
912	new_draw_info(NDI_UNIQUE, 0,op,"Your magic recoils on you, making you confused!");	1012	new_draw_info (NDI_UNIQUE, 0, op, "Your magic recoils on you, making you confused!");
913	confuse_player(op,op,99);	1013	confuse_player (op, op, 99);
914	}	1014	}
915	else if (failure <= -60 && failure> -80) /* paralysis */	1015	else if (failure <= -60 && failure > -80) /* paralysis */
916	{	1016	{
917	new_draw_info(NDI_UNIQUE, 0,op,"Your magic stuns you!");	1017	new_draw_info (NDI_UNIQUE, 0, op, "Your magic stuns you!");
918	paralyze_player(op,op,99);	1018	paralyze_player (op, op, 99);
919	}	1019	}
920	else if (failure <= -80) /* blast the immediate area */	1020	else if (failure <= -80) /* blast the immediate area */
921	{	1021	{
922	object *tmp;	1022	object *tmp;
		1023
923	/* Safety check to make sure we don't get any mana storms in scorn */	1024	/* Safety check to make sure we don't get any mana storms in scorn */
924	if (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC) {	1025	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC)
		1026	{
925	new_draw_info(NDI_UNIQUE, 0, op, "The magic warps and you are turned inside out!");	1027	new_draw_info (NDI_UNIQUE, 0, op, "The magic warps and you are turned inside out!");
926	hit_player(op,9998,op,AT_INTERNAL,1);	1028	hit_player (op, 9998, op, AT_INTERNAL, 1);
927		1029
		1030	}
928	} else {	1031	else
		1032	{
929	new_draw_info(NDI_UNIQUE, 0,op,"You lose control of the mana! The uncontrolled magic blasts you!");	1033	new_draw_info (NDI_UNIQUE, 0, op, "You lose control of the mana! The uncontrolled magic blasts you!");
930	tmp=get_archetype(LOOSE_MANA);	1034	tmp = get_archetype (LOOSE_MANA);
931	tmp->level=skill->level;	1035	tmp->level = skill->level;
932	tmp->x=op->x;	1036	tmp->x = op->x;
933	tmp->y=op->y;	1037	tmp->y = op->y;
934		1038
935	/* increase the area of destruction a little for more powerful spells */	1039	/* increase the area of destruction a little for more powerful spells */
936	tmp->range+=isqrt(power);	1040	tmp->range += isqrt (power);
937		1041
		1042	if (power > 25)
938	if (power>25) tmp->stats.dam = 25 + isqrt(power);	1043	tmp->stats.dam = 25 + isqrt (power);
		1044	else
939	else tmp->stats.dam=power; /* nasty recoils! */	1045	tmp->stats.dam = power; /* nasty recoils! */
940		1046
941	tmp->stats.maxhp=tmp->count;	1047	tmp->stats.maxhp = tmp->count;
942	insert_ob_in_map(tmp,op->map,NULL,0);	1048	insert_ob_in_map (tmp, op->map, NULL, 0);
943	}	1049	}
944	}	1050	}
945	}	1051	}
946		1052
		1053	int
947	int cast_party_spell(object *op, object *caster,int dir,object *spell_ob, char *stringarg)	1054	cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
948	{	1055	{
949	int success;	1056	int success;
950	player *pl;	1057	player *pl;
951	object *spell;	1058	object *spell;
952		1059
953	if ( !spell_ob->other_arch )	1060	if (!spell_ob->other_arch)
954	{	1061	{
955	LOG( llevError, "cast_party_spell: empty other arch\n" );	1062	LOG (llevError, "cast_party_spell: empty other arch\n");
956	return 0;	1063	return 0;
957	}	1064	}
958	spell = arch_to_object( spell_ob->other_arch );	1065	spell = arch_to_object (spell_ob->other_arch);
959		1066
960	/* Always cast spell on caster */	1067	/* Always cast spell on caster */
961	success = cast_spell( op, caster, dir, spell, stringarg );	1068	success = cast_spell (op, caster, dir, spell, stringarg);
962		1069
963	if ( caster->contr->party == NULL )	1070	if (caster->contr->party == NULL)
964	{	1071	{
965	remove_ob( spell );	1072	spell->remove ();
966	return success;	1073	return success;
967	}	1074	}
968	for( pl=first_player; pl!=NULL; pl=pl->next )	1075	for (pl = first_player; pl != NULL; pl = pl->next)
969	if( ( pl->ob->contr->party == caster->contr->party ) && ( on_same_map( pl->ob, caster ) ) )	1076	if ((pl->ob->contr->party == caster->contr->party) && (on_same_map (pl->ob, caster)))
970	{	1077	{
971	cast_spell( pl->ob, caster, pl->ob->facing, spell, stringarg );	1078	cast_spell (pl->ob, caster, pl->ob->facing, spell, stringarg);
972	}	1079	}
973	remove_ob( spell );	1080	spell->remove ();
974	return success;	1081	return success;
975	}	1082	}
976		1083
977	/* This is where the main dispatch when someone casts a spell.	1084	/* This is where the main dispatch when someone casts a spell.
978	*	1085	*
979	* op is the creature that is owner of the object that is casting the spell -	1086	* op is the creature that is owner of the object that is casting the spell -
980	* eg, the player or monster.	1087	* eg, the player or monster.
…		…
1000	* if it is a player casting the spell (op->type == PLAYER, op == caster),	1107	* if it is a player casting the spell (op->type == PLAYER, op == caster),
1001	* this function will decrease the mana/grace appropriately. For other	1108	* this function will decrease the mana/grace appropriately. For other
1002	* objects, the caller should do what it considers appropriate.	1109	* objects, the caller should do what it considers appropriate.
1003	*/	1110	*/
1004		1111
		1112	int
1005	int cast_spell(object *op, object *caster,int dir,object *spell_ob, char *stringarg) {	1113	cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
1006		1114	{
1007	const char *godname;	1115	const char *godname;
1008	int success=0,mflags, cast_level=0, old_shoottype;	1116	int success = 0, mflags, cast_level = 0, old_shoottype;
1009	object *skill=NULL;	1117	object *skill = NULL;
1010		1118
1011	old_shoottype = op->contr ? op->contr->shoottype : 0;	1119	old_shoottype = op->contr ? op->contr->shoottype : 0;
1012		1120
1013	if (!spell_ob) {	1121	if (!spell_ob)
		1122	{
1014	LOG(llevError,"cast_spell: null spell object passed\n");	1123	LOG (llevError, "cast_spell: null spell object passed\n");
1015	return 0;	1124	return 0;
1016	}	1125	}
1017	if(!strcmp((godname=determine_god(op)),"none")) godname="A random spirit";
1018		1126
		1127	if (!strcmp ((godname = determine_god (op)), "none"))
		1128	godname = "A random spirit";
		1129
1019	/* the caller should set caster to op if appropriate */	1130	/* the caller should set caster to op if appropriate */
1020	if (!caster) {	1131	if (!caster)
		1132	{
1021	LOG(llevError,"cast_spell: null caster object passed\n");	1133	LOG (llevError, "cast_spell: null caster object passed\n");
1022	return 0;	1134	return 0;
1023	}	1135	}
1024		1136
1025	/* if caster is a spell casting object, this normally shouldn't be	1137	/* if caster is a spell casting object, this normally shouldn't be
1026	* an issue, because they don't have any spellpaths set up.	1138	* an issue, because they don't have any spellpaths set up.
1027	*/	1139	*/
1028	if (caster->path_denied & spell_ob->path_attuned) {	1140	if (caster->path_denied & spell_ob->path_attuned && !QUERY_FLAG (caster, FLAG_WIZCAST))
		1141	{
1029	new_draw_info(NDI_UNIQUE, 0,op, "That spell path is denied to you.");	1142	new_draw_info (NDI_UNIQUE, 0, op, "That spell path is denied to you.");
1030	return 0;	1143	return 0;
1031	}	1144	}
1032		1145
1033	/* if it is a player casting the spell, and they are really casting it	1146	/* if it is a player casting the spell, and they are really casting it
1034	* (vs it coming from a wand, scroll, or whatever else), do some	1147	* (vs it coming from a wand, scroll, or whatever else), do some
1035	* checks. We let monsters do special things - eg, they	1148	* checks. We let monsters do special things - eg, they
1036	* don't need the skill, bypass level checks, etc. The monster function	1149	* don't need the skill, bypass level checks, etc. The monster function
1037	* should take care of that.	1150	* should take care of that.
1038	* Remove the wiz check here and move it further down - some spells	1151	* Remove the wiz check here and move it further down - some spells
1039	* need to have the right skill pointer passed, so we need to	1152	* need to have the right skill pointer passed, so we need to
1040	* at least process that code.	1153	* at least process that code.
1041	*/	1154	*/
1042	if (op->type == PLAYER && op == caster) {	1155	if (op->type == PLAYER && op == caster)
		1156	{
1043	cast_level = caster_level(caster, spell_ob);	1157	cast_level = caster_level (caster, spell_ob);
1044	if (spell_ob->skill) {	1158	if (spell_ob->skill)
		1159	{
1045	skill = find_skill_by_name(op, spell_ob->skill);	1160	skill = find_skill_by_name (op, spell_ob->skill);
1046	if (!skill) {	1161	if (!skill)
		1162	{
1047	new_draw_info_format(NDI_UNIQUE, 0,op,"You need the skill %s to cast %s.",	1163	new_draw_info_format (NDI_UNIQUE, 0, op, "You need the skill %s to cast %s.", &spell_ob->skill, &spell_ob->name);
1048	spell_ob->skill, spell_ob->name);
1049	return 0;	1164	return 0;
1050	}	1165	}
1051	if (min_casting_level(op, spell_ob) > cast_level && !QUERY_FLAG(op, FLAG_WIZ)) {	1166	if (min_casting_level (op, spell_ob) > cast_level && !QUERY_FLAG (op, FLAG_WIZ))
		1167	{
1052	new_draw_info(NDI_UNIQUE, 0,op, "You lack enough skill to cast that spell.");	1168	new_draw_info (NDI_UNIQUE, 0, op, "You lack enough skill to cast that spell.");
1053	return 0;	1169	return 0;
1054	}	1170	}
1055	}	1171	}
1056	/* If the caster is the wiz, they don't ever fail, and don't have	1172	/* If the caster is the wiz, they don't ever fail, and don't have
1057	* to have sufficient grace/mana.	1173	* to have sufficient grace/mana.
1058	*/	1174	*/
1059	if (!QUERY_FLAG(op, FLAG_WIZ)) {	1175	if (!QUERY_FLAG (op, FLAG_WIZ))
		1176	{
1060	if (SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA) &&	1177	if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) &&
1061	SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA) > op->stats.sp) {	1178	SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp)
		1179	{
1062	new_draw_info(NDI_UNIQUE, 0,op,"You don't have enough mana.");	1180	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough mana.");
1063	return 0;	1181	return 0;
1064	}	1182	}
1065	if (SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) &&	1183	if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) &&
1066	SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) > op->stats.grace) {	1184	SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) > op->stats.grace)
		1185	{
1067	if(random_roll(0, op->stats.Wis-1, op, PREFER_HIGH) + op->stats.grace -	1186	if (random_roll (0, op->stats.Wis - 1, op, PREFER_HIGH) + op->stats.grace -
1068	10*SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE)/op->stats.maxgrace >0) {	1187	10 * SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) / op->stats.maxgrace > 0)
1069	new_draw_info_format(NDI_UNIQUE, 0,op,	1188	{
1070	"%s grants your prayer, though you are unworthy.",godname);	1189	new_draw_info_format (NDI_UNIQUE, 0, op, "%s grants your prayer, though you are unworthy.", godname);
1071	}	1190	}
1072	else {	1191	else
1073	prayer_failure(op,op->stats.grace,	1192	{
1074	SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) - op->stats.grace);	1193	prayer_failure (op, op->stats.grace, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) - op->stats.grace);
1075	new_draw_info_format(NDI_UNIQUE, 0,op,"%s ignores your prayer.",godname);	1194	new_draw_info_format (NDI_UNIQUE, 0, op, "%s ignores your prayer.", godname);
1076	return 0;	1195	return 0;
1077	}	1196	}
1078	}	1197	}
1079		1198
1080	/* player/monster is trying to cast the spell. might fumble it */	1199	/* player/monster is trying to cast the spell. might fumble it */
1081	if (spell_ob->stats.grace && random_roll(0, 99, op, PREFER_HIGH) <	1200	if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) <
1082	(spell_ob->level/(float)MAX(1,op->level) *cleric_chance[op->stats.Wis])) {	1201	(spell_ob->level / (float) MAX (1, op->level) * cleric_chance[op->stats.Wis]))
		1202	{
1083	play_sound_player_only(op->contr, SOUND_FUMBLE_SPELL,0,0);	1203	play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0);
1084	new_draw_info(NDI_UNIQUE, 0,op,"You fumble the spell.");	1204	new_draw_info (NDI_UNIQUE, 0, op, "You fumble the spell.");
1085	if (settings.casting_time == TRUE) {	1205	if (settings.casting_time == TRUE)
		1206	{
1086	op->casting_time = -1;	1207	op->casting_time = -1;
1087	}	1208	}
1088	op->stats.grace -= random_roll(1, SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE), op, PREFER_LOW);	1209	op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);
1089	return 0;	1210	return 0;
		1211	}
1090	} else if (spell_ob->stats.sp) {	1212	else if (spell_ob->stats.sp)
1091	int failure = random_roll(0, 199, op, PREFER_HIGH) -	1213	{
1092	op->contr->encumbrance +op->level - spell_ob->level +35;	1214	int failure = random_roll (0, 199, op, PREFER_HIGH) - op->contr->encumbrance + op->level - spell_ob->level + 35;
1093		1215
1094	if( failure < 0) {	1216	if (failure < 0)
		1217	{
1095	new_draw_info(NDI_UNIQUE, 0,op,"You bungle the spell because you have too much heavy equipment in use.");	1218	new_draw_info (NDI_UNIQUE, 0, op, "You bungle the spell because you have too much heavy equipment in use.");
1096	if (settings.spell_failure_effects == TRUE)	1219	if (settings.spell_failure_effects == TRUE)
1097	spell_failure(op,failure,
1098	SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA),	1220	spell_failure (op, failure, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), skill);
1099	skill);
1100	op->contr->shoottype = (rangetype) old_shoottype;	1221	op->contr->shoottype = (rangetype) old_shoottype;
1101	op->stats.sp -= random_roll(0, SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA), op, PREFER_LOW);	1222	op->stats.sp -= random_roll (0, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), op, PREFER_LOW);
1102	return 0;	1223	return 0;
1103	}	1224	}
1104	}	1225	}
1105	}	1226	}
1106	}	1227	}
1107		1228
1108	mflags = get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL);	1229	mflags = get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL);
1109		1230
1110	/* See if we can cast a spell here. If the caster and op are	1231	/* See if we can cast a spell here. If the caster and op are
1111	* not alive, then this would mean that the mapmaker put the	1232	* not alive, then this would mean that the mapmaker put the
1112	* objects on the space - presume that they know what they are	1233	* objects on the space - presume that they know what they are
1113	* doing.	1234	* doing.
1114	*/	1235	*/
		1236
		1237	if ((mflags & P_SAFE) && !QUERY_FLAG (op, FLAG_WIZCAST)) // There is _ABSOLUTELY_ no magic allowed here (except wizards :-)!
		1238	{
		1239	new_draw_info (NDI_UNIQUE, 0, op, "This ground is sacred! The gods prevent any magical effects done by you here!.");
		1240	return 0;
		1241	}
		1242
1115	if (spell_ob->type == SPELL	1243	if ((spell_ob->type == SPELL)
1116	&& (mflags & P_SAFE || caster->type != POTION) // elmex: prevent potions from casting on safe maps	1244	&& (caster->type != POTION)
1117	&& !QUERY_FLAG(op, FLAG_WIZCAST)	1245	&& !QUERY_FLAG (op, FLAG_WIZCAST)
1118	&& (QUERY_FLAG(caster, FLAG_ALIVE)	1246	&& (QUERY_FLAG (caster, FLAG_ALIVE)
1119	|| QUERY_FLAG(op, FLAG_ALIVE))	1247	|| QUERY_FLAG (op, FLAG_ALIVE))
1120	&& (((mflags & P_NO_MAGIC) && spell_ob->stats.sp)	1248	&& (((mflags & P_NO_MAGIC) && spell_ob->stats.sp) || ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))
1121	|| ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))
1122	{	1249	{
1123	if (op->type!=PLAYER)	1250	if (op->type != PLAYER)
1124	return 0;	1251	return 0;
1125		1252
1126	if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)	1253	if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)
1127	new_draw_info_format(NDI_UNIQUE, 0,op,"This ground is unholy! %s ignores you.",godname);	1254	new_draw_info_format (NDI_UNIQUE, 0, op, "This ground is unholy! %s ignores you.", godname);
1128	else if (mflags & P_SAFE)
1129	new_draw_info(NDI_UNIQUE, 0,op,
1130	"This ground is sacred! The gods prevent any magical effects done by you here!.");
1131	else	1255	else
1132	switch(op->contr->shoottype)	1256	switch (op->contr->shoottype)
1133	{	1257	{
1134	case range_magic:	1258	case range_magic:
1135	new_draw_info(NDI_UNIQUE, 0,op,"Something blocks your spellcasting.");	1259	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your spellcasting.");
1136	break;	1260	break;
1137	case range_misc:	1261	case range_misc:
1138	new_draw_info(NDI_UNIQUE, 0,op,"Something blocks the magic of your item.");	1262	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of your item.");
1139	break;	1263	break;
1140	case range_golem:	1264	case range_golem:
1141	new_draw_info(NDI_UNIQUE, 0,op,"Something blocks the magic of your scroll.");	1265	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of your scroll.");
1142	break;	1266	break;
1143	default:	1267	default:
1144	break;	1268	break;
		1269	}
		1270	return 0;
		1271	}
		1272
		1273	if (caster == op && settings.casting_time == TRUE && spell_ob->type == SPELL)
		1274	{
		1275	if (op->casting_time == -1)
		1276	{ /* begin the casting */
		1277	op->casting_time = (sint16) (spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob));
		1278	op->spell = spell_ob;
		1279	/* put the stringarg into the object struct so that when the
		1280	* spell is actually cast, it knows about the stringarg.
		1281	* necessary for the invoke command spells.
		1282	*/
		1283	if (stringarg)
		1284	{
		1285	op->spellarg = strdup (stringarg);
1145	}	1286	}
1146	return 0;	1287	else
1147	}
1148
1149	if (caster == op && settings.casting_time == TRUE && spell_ob->type == SPELL) {
1150	if (op->casting_time==-1) { /* begin the casting */
1151	op->casting_time = (sint16) (spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob));
1152	op->spell = spell_ob;
1153	/* put the stringarg into the object struct so that when the
1154	* spell is actually cast, it knows about the stringarg.
1155	* necessary for the invoke command spells.
1156	*/
1157	if(stringarg) {
1158	op->spellarg = strdup_local(stringarg);
1159	}
1160	else op->spellarg=NULL;	1288	op->spellarg = NULL;
1161	return 0;	1289	return 0;
1162	}	1290	}
1163	else if (op->casting_time != 0) {	1291	else if (op->casting_time != 0)
		1292	{
1164	if (op->type == PLAYER )	1293	if (op->type == PLAYER)
1165	new_draw_info(NDI_UNIQUE, 0,op,"You are casting!");	1294	new_draw_info (NDI_UNIQUE, 0, op, "You are casting!");
1166	return 0;	1295	return 0;
1167	} else { /* casting_time == 0 */	1296	}
		1297	else
		1298	{ /* casting_time == 0 */
1168	op->casting_time = -1;	1299	op->casting_time = -1;
1169	spell_ob = op->spell;	1300	spell_ob = op->spell;
1170	stringarg = op->spellarg;	1301	stringarg = op->spellarg;
1171	}	1302	}
1172	} else {	1303	}
		1304	else
		1305	{
1173	/* Take into account how long it takes to cast the spell.	1306	/* Take into account how long it takes to cast the spell.
1174	* if the player is casting it, then we use the time in	1307	* if the player is casting it, then we use the time in
1175	* the spell object. If it is a spell object, have it	1308	* the spell object. If it is a spell object, have it
1176	* take two ticks. Things that cast spells on the players	1309	* take two ticks. Things that cast spells on the players
1177	* behalf (eg, altars, and whatever else) shouldn't cost	1310	* behalf (eg, altars, and whatever else) shouldn't cost
1178	* the player any time.	1311	* the player any time.
1179	* Ignore casting time for firewalls	1312	* Ignore casting time for firewalls
1180	*/	1313	*/
1181	if (caster == op && caster->type != FIREWALL) {	1314	if (caster == op && caster->type != FIREWALL)
		1315	{
1182	op->speed_left -= spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed);	1316	op->speed_left -= spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);
1183	/* Other portions of the code may also decrement the speed of the player, so	1317	/* Other portions of the code may also decrement the speed of the player, so
1184	* put a lower limit so that the player isn't stuck here too long	1318	* put a lower limit so that the player isn't stuck here too long
1185	*/	1319	*/
1186	if ((spell_ob->casting_time > 0) &&
1187	op->speed_left < -spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed))	1320	if ((spell_ob->casting_time > 0) && op->speed_left < -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed))
1188	op->speed_left = -spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed);	1321	op->speed_left = -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);
1189	} else if (caster->type == WAND || caster->type == HORN ||	1322	}
1190	caster->type == ROD || caster->type == POTION ||	1323	else if (caster->type == WAND || caster->type == HORN || caster->type == ROD || caster->type == POTION || caster->type == SCROLL)
1191	caster->type == SCROLL) {	1324	{
1192	op->speed_left -= 2 * FABS(op->speed);	1325	op->speed_left -= 2 * FABS (op->speed);
1193	}	1326	}
1194	}	1327	}
1195		1328
1196	if (op->type == PLAYER && op == caster) {	1329	if (op->type == PLAYER && op == caster)
		1330	{
1197	op->stats.grace -= SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE);	1331	op->stats.grace -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE);
1198	op->stats.sp -= SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA);	1332	op->stats.sp -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA);
1199	}	1333	}
1200		1334
1201	/* We want to try to find the skill to properly credit exp.	1335	/* We want to try to find the skill to properly credit exp.
1202	* for spell casting objects, the exp goes to the skill the casting	1336	* for spell casting objects, the exp goes to the skill the casting
1203	* object requires.	1337	* object requires.
1204	*/	1338	*/
1205	if (op != caster && !skill && caster->skill) {	1339	if (op != caster && !skill && caster->skill)
		1340	{
1206	skill = find_skill_by_name(op, caster->skill);	1341	skill = find_skill_by_name (op, caster->skill);
1207	if (!skill) {	1342	if (!skill)
		1343	{
1208	new_draw_info_format(NDI_UNIQUE, 0,op,"You lack the skill %s to use the %s",	1344	new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the skill %s to use the %s", &caster->skill, query_name (caster));
1209	caster->skill, query_name(caster));
1210	return 0;	1345	return 0;
1211	}	1346	}
1212	change_skill(op, skill, 0); /* needed for proper exp credit */	1347	change_skill (op, skill, 0); /* needed for proper exp credit */
1213	}	1348	}
1214		1349
1215	switch(spell_ob->subtype) {	1350	switch (spell_ob->subtype)
		1351	{
1216	/* The order of case statements is same as the order they show up	1352	/* The order of case statements is same as the order they show up
1217	* in in spells.h.	1353	* in in spells.h.
1218	*/	1354	*/
1219	case SP_RAISE_DEAD:	1355	case SP_RAISE_DEAD:
1220	success = cast_raise_dead_spell(op,caster, spell_ob, dir,stringarg);	1356	success = cast_raise_dead_spell (op, caster, spell_ob, dir, stringarg);
1221	break;	1357	break;
1222		1358
1223	case SP_RUNE:	1359	case SP_RUNE:
1224	success = write_rune(op,caster, spell_ob, dir,stringarg);	1360	success = write_rune (op, caster, spell_ob, dir, stringarg);
1225	break;	1361	break;
1226		1362
1227	case SP_MAKE_MARK:	1363	case SP_MAKE_MARK:
1228	success = write_mark(op, spell_ob, stringarg);	1364	success = write_mark (op, spell_ob, stringarg);
1229	break;	1365	break;
1230		1366
1231	case SP_BOLT:	1367	case SP_BOLT:
1232	success = fire_bolt(op,caster,dir,spell_ob,skill);	1368	success = fire_bolt (op, caster, dir, spell_ob, skill);
1233	break;	1369	break;
1234		1370
1235	case SP_BULLET:	1371	case SP_BULLET:
1236	success = fire_bullet(op, caster, dir, spell_ob);	1372	success = fire_bullet (op, caster, dir, spell_ob);
1237	break;	1373	break;
1238		1374
1239	case SP_CONE:	1375	case SP_CONE:
1240	success = cast_cone(op, caster, dir, spell_ob);	1376	success = cast_cone (op, caster, dir, spell_ob);
1241	break;	1377	break;
1242		1378
1243	case SP_BOMB:	1379	case SP_BOMB:
1244	success = create_bomb(op,caster,dir, spell_ob);	1380	success = create_bomb (op, caster, dir, spell_ob);
1245	break;	1381	break;
1246		1382
1247	case SP_WONDER:	1383	case SP_WONDER:
1248	success = cast_wonder(op,caster, dir,spell_ob);	1384	success = cast_wonder (op, caster, dir, spell_ob);
1249	break;	1385	break;
1250		1386
1251	case SP_SMITE:	1387	case SP_SMITE:
1252	success = cast_smite_spell(op,caster, dir,spell_ob);	1388	success = cast_smite_spell (op, caster, dir, spell_ob);
1253	break;	1389	break;
1254		1390
1255	case SP_MAGIC_MISSILE:	1391	case SP_MAGIC_MISSILE:
1256	success = fire_arch_from_position(op, caster, op->x + freearr_x[dir],	1392	success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1257	op->y + freearr_y[dir], dir, spell_ob);
1258	break;	1393	break;
1259		1394
1260	case SP_SUMMON_GOLEM:	1395	case SP_SUMMON_GOLEM:
1261	success = summon_golem(op, caster, dir, spell_ob);	1396	success = summon_golem (op, caster, dir, spell_ob);
1262	old_shoottype = range_golem;	1397	old_shoottype = range_golem;
1263	break;	1398	break;
1264		1399
1265	case SP_DIMENSION_DOOR:	1400	case SP_DIMENSION_DOOR:
1266	/* dimension door needs the actual caster, because that is what is	1401	/* dimension door needs the actual caster, because that is what is
1267	* moved.	1402	* moved.
1268	*/	1403	*/
1269	success = dimension_door(op,caster, spell_ob, dir);	1404	success = dimension_door (op, caster, spell_ob, dir);
1270	break;	1405	break;
1271		1406
1272	case SP_MAGIC_MAPPING:	1407	case SP_MAGIC_MAPPING:
1273	if(op->type==PLAYER) {	1408	if (op->type == PLAYER)
		1409	{
1274	spell_effect(spell_ob, op->x, op->y, op->map, op);	1410	spell_effect (spell_ob, op->x, op->y, op->map, op);
1275	draw_magic_map(op);	1411	draw_magic_map (op);
1276	success=1;	1412	success = 1;
1277	}	1413	}
		1414	else
1278	else success=0;	1415	success = 0;
1279	break;	1416	break;
1280		1417
1281	case SP_MAGIC_WALL:	1418	case SP_MAGIC_WALL:
1282	success = magic_wall(op,caster,dir,spell_ob);	1419	success = magic_wall (op, caster, dir, spell_ob);
1283	break;	1420	break;
1284		1421
1285	case SP_DESTRUCTION:	1422	case SP_DESTRUCTION:
1286	success = cast_destruction(op,caster,spell_ob);	1423	success = cast_destruction (op, caster, spell_ob);
1287	break;	1424	break;
1288		1425
1289	case SP_PERCEIVE_SELF:	1426	case SP_PERCEIVE_SELF:
1290	success = perceive_self(op);	1427	success = perceive_self (op);
1291	break;	1428	break;
1292		1429
1293	case SP_WORD_OF_RECALL:	1430	case SP_WORD_OF_RECALL:
1294	success = cast_word_of_recall(op,caster,spell_ob);	1431	success = cast_word_of_recall (op, caster, spell_ob);
1295	break;	1432	break;
1296		1433
1297	case SP_INVISIBLE:	1434	case SP_INVISIBLE:
1298	success = cast_invisible(op,caster,spell_ob);	1435	success = cast_invisible (op, caster, spell_ob);
1299	break;	1436	break;
1300		1437
1301	case SP_PROBE:	1438	case SP_PROBE:
1302	success = probe(op,caster, spell_ob, dir);	1439	success = probe (op, caster, spell_ob, dir);
1303	break;	1440	break;
1304		1441
1305	case SP_HEALING:	1442	case SP_HEALING:
1306	success = cast_heal(op,caster, spell_ob, dir);	1443	success = cast_heal (op, caster, spell_ob, dir);
1307	break;	1444	break;
1308		1445
1309	case SP_CREATE_FOOD:	1446	case SP_CREATE_FOOD:
1310	success = cast_create_food(op,caster,spell_ob, dir,stringarg);	1447	success = cast_create_food (op, caster, spell_ob, dir, stringarg);
1311	break;	1448	break;
1312		1449
1313	case SP_EARTH_TO_DUST:	1450	case SP_EARTH_TO_DUST:
1314	success = cast_earth_to_dust(op,caster,spell_ob);	1451	success = cast_earth_to_dust (op, caster, spell_ob);
1315	break;	1452	break;
1316		1453
1317	case SP_CHANGE_ABILITY:	1454	case SP_CHANGE_ABILITY:
1318	success = cast_change_ability(op,caster,spell_ob, dir, 0);	1455	success = cast_change_ability (op, caster, spell_ob, dir, 0);
1319	break;	1456	break;
1320		1457
1321	case SP_BLESS:	1458	case SP_BLESS:
1322	success = cast_bless(op,caster,spell_ob, dir);	1459	success = cast_bless (op, caster, spell_ob, dir);
1323	break;	1460	break;
1324		1461
1325	case SP_CURSE:	1462	case SP_CURSE:
1326	success = cast_curse(op,caster,spell_ob, dir);	1463	success = cast_curse (op, caster, spell_ob, dir);
1327	break;	1464	break;
1328		1465
1329	case SP_SUMMON_MONSTER:	1466	case SP_SUMMON_MONSTER:
1330	success = summon_object(op,caster,spell_ob, dir,stringarg);	1467	success = summon_object (op, caster, spell_ob, dir, stringarg);
1331	break;	1468	break;
1332		1469
1333	case SP_CHARGING:	1470	case SP_CHARGING:
1334	success = recharge(op, caster, spell_ob);	1471	success = recharge (op, caster, spell_ob);
1335	break;	1472	break;
1336		1473
1337	case SP_POLYMORPH:	1474	case SP_POLYMORPH:
1338	#ifdef NO_POLYMORPH	1475	#ifdef NO_POLYMORPH
1339	/* Not great, but at least provide feedback so if players do have	1476	/* Not great, but at least provide feedback so if players do have
1340	* polymorph (ie, find it as a preset item or left over from before	1477	* polymorph (ie, find it as a preset item or left over from before
1341	* it was disabled), they get some feedback.	1478	* it was disabled), they get some feedback.
1342	*/	1479	*/
1343	new_draw_info(NDI_UNIQUE, 0,op,"The spell fizzles");	1480	new_draw_info (NDI_UNIQUE, 0, op, "The spell fizzles");
		1481	success = 0;
		1482	#else
		1483	success = cast_polymorph (op, caster, spell_ob, dir);
		1484	#endif
		1485	break;
		1486
		1487	case SP_ALCHEMY:
		1488	success = alchemy (op, caster, spell_ob);
		1489	break;
		1490
		1491	case SP_REMOVE_CURSE:
		1492	success = remove_curse (op, caster, spell_ob);
		1493	break;
		1494
		1495	case SP_IDENTIFY:
		1496	success = cast_identify (op, caster, spell_ob);
		1497	break;
		1498
		1499	case SP_DETECTION:
		1500	success = cast_detection (op, caster, spell_ob, skill);
		1501	break;
		1502
		1503	case SP_MOOD_CHANGE:
		1504	success = mood_change (op, caster, spell_ob);
		1505	break;
		1506
		1507	case SP_MOVING_BALL:
		1508	if (spell_ob->path_repelled && (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled)
		1509	{
		1510	new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the proper attunement to cast %s", &spell_ob->name);
1344	success = 0;	1511	success = 0;
1345	#else	1512	}
1346	success = cast_polymorph(op,caster,spell_ob, dir);	1513	else
1347	#endif	1514	success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1348	break;	1515	break;
1349		1516
1350	case SP_ALCHEMY:
1351	success = alchemy(op, caster, spell_ob);
1352	break;
1353
1354	case SP_REMOVE_CURSE:
1355	success = remove_curse(op, caster, spell_ob);
1356	break;
1357
1358	case SP_IDENTIFY:
1359	success = cast_identify(op, caster, spell_ob);
1360	break;
1361
1362	case SP_DETECTION:
1363	success = cast_detection(op, caster, spell_ob, skill);
1364	break;
1365
1366	case SP_MOOD_CHANGE:
1367	success = mood_change(op, caster, spell_ob);
1368	break;
1369
1370	case SP_MOVING_BALL:
1371	if (spell_ob->path_repelled &&
1372	(spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled) {
1373	new_draw_info_format(NDI_UNIQUE, 0, op,
1374	"You lack the proper attunement to cast %s", spell_ob->name);
1375	success = 0;
1376	} else
1377	success = fire_arch_from_position(op,caster,
1378	op->x + freearr_x[dir], op->y + freearr_y[dir],
1379	dir, spell_ob);
1380	break;
1381
1382	case SP_SWARM:	1517	case SP_SWARM:
1383	success = fire_swarm(op, caster, spell_ob, dir);	1518	success = fire_swarm (op, caster, spell_ob, dir);
1384	break;	1519	break;
1385		1520
1386	case SP_CHANGE_MANA:	1521	case SP_CHANGE_MANA:
1387	success = cast_transfer(op,caster, spell_ob, dir);	1522	success = cast_transfer (op, caster, spell_ob, dir);
1388	break;	1523	break;
1389		1524
1390	case SP_DISPEL_RUNE:	1525	case SP_DISPEL_RUNE:
1391	/* in rune.c */	1526	/* in rune.c */
1392	success = dispel_rune(op,caster, spell_ob, skill, dir);	1527	success = dispel_rune (op, caster, spell_ob, skill, dir);
1393	break;	1528	break;
1394		1529
1395	case SP_CREATE_MISSILE:	1530	case SP_CREATE_MISSILE:
1396	success = cast_create_missile(op,caster,spell_ob, dir,stringarg);	1531	success = cast_create_missile (op, caster, spell_ob, dir, stringarg);
1397	break;	1532	break;
1398		1533
1399	case SP_CONSECRATE:	1534	case SP_CONSECRATE:
1400	success = cast_consecrate(op, caster, spell_ob);	1535	success = cast_consecrate (op, caster, spell_ob);
1401	break;	1536	break;
1402		1537
1403	case SP_ANIMATE_WEAPON:	1538	case SP_ANIMATE_WEAPON:
1404	success = animate_weapon(op, caster, spell_ob, dir);	1539	success = animate_weapon (op, caster, spell_ob, dir);
1405	old_shoottype = range_golem;	1540	old_shoottype = range_golem;
1406	break;	1541	break;
1407		1542
1408	case SP_LIGHT:	1543	case SP_LIGHT:
1409	success = cast_light(op, caster, spell_ob, dir);	1544	success = cast_light (op, caster, spell_ob, dir);
1410	break;	1545	break;
1411		1546
1412	case SP_CHANGE_MAP_LIGHT:	1547	case SP_CHANGE_MAP_LIGHT:
1413	success = cast_change_map_lightlevel(op, caster, spell_ob);	1548	success = cast_change_map_lightlevel (op, caster, spell_ob);
1414	break;	1549	break;
1415		1550
1416	case SP_FAERY_FIRE:	1551	case SP_FAERY_FIRE:
1417	success = cast_destruction(op,caster,spell_ob);	1552	success = cast_destruction (op, caster, spell_ob);
1418	break;	1553	break;
1419		1554
1420	case SP_CAUSE_DISEASE:	1555	case SP_CAUSE_DISEASE:
1421	success = cast_cause_disease(op, caster, spell_ob, dir);	1556	success = cast_cause_disease (op, caster, spell_ob, dir);
1422	break;	1557	break;
1423		1558
1424	case SP_AURA:	1559	case SP_AURA:
1425	success = create_aura(op, caster, spell_ob);	1560	success = create_aura (op, caster, spell_ob);
1426	break;	1561	break;
1427		1562
1428	case SP_TOWN_PORTAL:	1563	case SP_TOWN_PORTAL:
1429	success= cast_create_town_portal (op,caster,spell_ob, dir);	1564	success = cast_create_town_portal (op, caster, spell_ob, dir);
1430	break;	1565	break;
1431		1566
1432	case SP_PARTY_SPELL:	1567	case SP_PARTY_SPELL:
1433	success = cast_party_spell (op, caster, dir, spell_ob, stringarg);	1568	success = cast_party_spell (op, caster, dir, spell_ob, stringarg);
1434	break;	1569	break;
1435		1570
1436	default:	1571	default:
1437	if (!INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg)))	1572	if (!INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg)))
1438	LOG (llevError,"cast_spell: Unhandled spell subtype %d\n",	1573	LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);
1439	spell_ob->subtype);
1440
1441
1442	}	1574	}
1443		1575
1444	/* FIXME - we need some better sound suppport */	1576	/* FIXME - we need some better sound suppport */
1445	// yes, for example, augment map info with the spell effect	1577	// yes, for example, augment map info with the spell effect
1446	// so clients can calculate the sounds themselves	1578	// so clients can calculate the sounds themselves
1447	//play_sound_map(op->map, op->x, op->y, SOUND_CAST_SPELL_0 + spell_ob->subtype);	1579	//play_sound_map(op->map, op->x, op->y, SOUND_CAST_SPELL_0 + spell_ob->subtype);
1448		1580
1449	/* free the spell arg */	1581	/* free the spell arg */
1450	if(settings.casting_time == TRUE && stringarg) {	1582	if (settings.casting_time == TRUE && stringarg)
		1583	{
1451	free(stringarg);	1584	free (stringarg);
1452	stringarg=NULL;	1585	stringarg = NULL;
1453	}	1586	}
1454	/* perhaps a bit of a hack, but if using a wand, it has to change the skill	1587	/* perhaps a bit of a hack, but if using a wand, it has to change the skill
1455	* to something like use_magic_item, but you really want to be able to fire	1588	* to something like use_magic_item, but you really want to be able to fire
1456	* it again.	1589	* it again.
1457	*/	1590	*/
		1591	if (op->contr)
1458	if (op->contr) op->contr->shoottype = (rangetype) old_shoottype;	1592	op->contr->shoottype = (rangetype) old_shoottype;
1459		1593
1460	return success;	1594	return success;
1461	}	1595	}
1462		1596
1463		1597
1464	/* This is called from time.c/process_object(). That function	1598	/* This is called from time.c/process_object(). That function
1465	* calls this for any SPELL_EFFECT type objects. This function	1599	* calls this for any SPELL_EFFECT type objects. This function
1466	* then dispatches them to the appropriate specific routines.	1600	* then dispatches them to the appropriate specific routines.
1467	*/	1601	*/
		1602	void
1468	void move_spell_effect(object *op) {	1603	move_spell_effect (object *op)
1469		1604	{
1470	switch (op->subtype) {	1605	switch (op->subtype)
		1606	{
1471	case SP_BOLT:	1607	case SP_BOLT:
1472	move_bolt(op);	1608	move_bolt (op);
1473	break;	1609	break;
1474		1610
1475	case SP_BULLET:	1611	case SP_BULLET:
1476	move_bullet(op);	1612	move_bullet (op);
1477	break;	1613	break;
1478		1614
1479	case SP_EXPLOSION:	1615	case SP_EXPLOSION:
1480	explosion(op);	1616	explosion (op);
1481	break;	1617	break;
1482		1618
1483	case SP_CONE:	1619	case SP_CONE:
1484	move_cone(op);	1620	move_cone (op);
1485	break;	1621	break;
1486		1622
1487	case SP_BOMB:	1623	case SP_BOMB:
1488	animate_bomb(op);	1624	animate_bomb (op);
1489	break;	1625	break;
1490		1626
1491	case SP_MAGIC_MISSILE:	1627	case SP_MAGIC_MISSILE:
1492	move_missile(op);	1628	move_missile (op);
1493	break;	1629	break;
1494		1630
1495	case SP_WORD_OF_RECALL:	1631	case SP_WORD_OF_RECALL:
1496	execute_word_of_recall(op);	1632	execute_word_of_recall (op);
1497	break;	1633	break;
1498		1634
1499	case SP_MOVING_BALL:	1635	case SP_MOVING_BALL:
1500	move_ball_spell(op);	1636	move_ball_spell (op);
1501	break;	1637	break;
1502		1638
1503	case SP_SWARM:	1639	case SP_SWARM:
1504	move_swarm_spell(op);	1640	move_swarm_spell (op);
1505	break;	1641	break;
1506		1642
1507	case SP_AURA:	1643	case SP_AURA:
1508	move_aura(op);	1644	move_aura (op);
1509	break;	1645	break;
1510
1511	}	1646	}
1512	}	1647	}
1513		1648
1514	/* this checks to see if something special should happen if	1649	/* this checks to see if something special should happen if
1515	* something runs into the object.	1650	* something runs into the object.
1516	*/	1651	*/
		1652	void
1517	void check_spell_effect(object *op) {	1653	check_spell_effect (object *op)
1518		1654	{
1519	switch (op->subtype) {	1655	switch (op->subtype)
		1656	{
1520	case SP_BOLT:	1657	case SP_BOLT:
1521	move_bolt(op);	1658	move_bolt (op);
1522	return;	1659	return;
1523		1660
1524	case SP_BULLET:	1661	case SP_BULLET:
1525	check_bullet(op);	1662	check_bullet (op);
1526	return;	1663	return;
1527	}	1664	}
1528
1529	}	1665	}
1530		1666
1531	/* This is called by move_apply. Basically, if someone	1667	/* This is called by move_apply. Basically, if someone
1532	* moves onto a spell effect and the walk_on or fly_on flags	1668	* moves onto a spell effect and the walk_on or fly_on flags
1533	* are set, this is called. This should only be called for	1669	* are set, this is called. This should only be called for
1534	* objects of the appropraite type.	1670	* objects of the appropraite type.
1535	*/	1671	*/
		1672	void
1536	void apply_spell_effect(object *spell, object *victim)	1673	apply_spell_effect (object *spell, object *victim)
1537	{	1674	{
1538	switch (spell->subtype) {	1675	switch (spell->subtype)
		1676	{
1539	case SP_CONE:	1677	case SP_CONE:
1540	if (QUERY_FLAG(victim, FLAG_ALIVE) && spell->speed && spell->attacktype)	1678	if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->speed && spell->attacktype)
1541	hit_player(victim, spell->stats.dam, spell, spell->attacktype, 0);	1679	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0);
1542	break;	1680	break;
1543		1681
1544	case SP_MAGIC_MISSILE:	1682	case SP_MAGIC_MISSILE:
1545	if (QUERY_FLAG (victim, FLAG_ALIVE)) {	1683	if (QUERY_FLAG (victim, FLAG_ALIVE))
1546	tag_t spell_tag = spell->count;	1684	{
1547	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);	1685	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1548	if ( ! was_destroyed (spell, spell_tag)) {	1686
1549	remove_ob (spell);	1687	if (!spell->destroyed ())
1550	free_object (spell);	1688	spell->destroy ();
1551	}
1552	}	1689	}
1553	break;	1690	break;
1554		1691
1555	case SP_MOVING_BALL:	1692	case SP_MOVING_BALL:
1556	if (QUERY_FLAG (victim, FLAG_ALIVE))	1693	if (QUERY_FLAG (victim, FLAG_ALIVE))
1557	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);	1694	hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1558	else if (victim->material || victim->materialname)	1695	else if (victim->material || victim->materialname)
1559	save_throw_object (victim, spell->attacktype, spell);	1696	save_throw_object (victim, spell->attacktype, spell);
1560	break;	1697	break;
1561	}	1698	}
1562	}	1699	}

Diff Legend

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