ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/spell_util.C
Revision: 1.90
Committed: Thu Jan 1 11:41:17 2009 UTC (15 years, 5 months ago) by root
Content type: text/plain
Branch: MAIN
CVS Tags: rel-2_75
Changes since 1.89: +2 -3 lines
Log Message:
*** empty log message ***

File Contents

# User Rev Content
1 elmex 1.1 /*
2 root 1.63 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 pippijn 1.34 *
4 root 1.72 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 root 1.49 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6     * Copyright (©) 1992,2007 Frank Tore Johansen
7 pippijn 1.34 *
8 root 1.63 * Deliantra is free software: you can redistribute it and/or modify
9 root 1.54 * it under the terms of the GNU General Public License as published by
10     * the Free Software Foundation, either version 3 of the License, or
11     * (at your option) any later version.
12 pippijn 1.34 *
13 root 1.54 * This program is distributed in the hope that it will be useful,
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16     * GNU General Public License for more details.
17 pippijn 1.34 *
18 root 1.54 * You should have received a copy of the GNU General Public License
19     * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 root 1.49 *
21 root 1.63 * The authors can be reached via e-mail to <support@deliantra.net>
22 pippijn 1.34 */
23 elmex 1.1
24     #include <global.h>
25     #include <spells.h>
26     #include <object.h>
27     #include <errno.h>
28 root 1.28 #include <sproto.h>
29 elmex 1.1 #include <sounds.h>
30    
31     extern char *spell_mapping[];
32    
33     /* This returns a random spell from 'ob'. If skill is set, then
34     * the spell must be of this skill, it can be NULL in which case all
35     * matching spells are used.
36     */
37 root 1.11 object *
38 root 1.90 find_random_spell_in_ob (object *ob, shstr_cmp skill)
39 elmex 1.1 {
40 root 1.11 int k = 0, s;
41 elmex 1.1
42 root 1.79 for (object *tmp = ob->inv; tmp; tmp = tmp->below)
43 root 1.11 if (tmp->type == SPELL && (!skill || tmp->skill == skill))
44     k++;
45 elmex 1.1
46 root 1.11 /* No spells, no need to progess further */
47     if (!k)
48     return NULL;
49 elmex 1.1
50 root 1.87 s = rndm (k);
51 elmex 1.1
52 root 1.79 for (object *tmp = ob->inv; tmp; tmp = tmp->below)
53 root 1.11 if (tmp->type == SPELL && (!skill || tmp->skill == skill))
54 root 1.79 if (!s)
55     return tmp;
56     else
57     s--;
58    
59 root 1.11 /* Should never get here, but just in case */
60 root 1.79 return 0;
61 elmex 1.1 }
62    
63     /* Relatively simple function that gets used a lot.
64     * Basically, it sets up the skill pointer for the spell being
65     * cast. If op is really casting the spell, then the skill
66     * is whatever skill the spell requires.
67     * if instead caster (rod, horn, wand, etc) is casting the skill,
68     * then they get exp for the skill that you need to use for
69     * that object (use magic device).
70     */
71 root 1.11 void
72     set_spell_skill (object *op, object *caster, object *spob, object *dest)
73 elmex 1.1 {
74 root 1.10 if (caster == op && spob->skill)
75     dest->skill = spob->skill;
76     else
77     dest->skill = caster->skill;
78 elmex 1.1 }
79    
80     /* pretty basic function - basically just takes
81     * an object, sets the x,y, and calls insert_ob_in_map
82     */
83 root 1.11 void
84 root 1.17 spell_effect (object *spob, int x, int y, maptile *map, object *originator)
85 elmex 1.1 {
86 root 1.29 if (spob->other_arch)
87     map->insert (arch_to_object (spob->other_arch), x, y, originator);
88 elmex 1.1 }
89    
90 root 1.80 static int
91     attuned_bonus (object *caster, object *spell, int level)
92     {
93     // compute the attuned/repelled bonus
94     // attuned only increases up to 2 times the original level (i.e. bonus <= level) */
95     // repell has no such quarrels
96     return (caster->path_attuned & spell->path_attuned ? min (level, +ATTUNE_REPELL) : 0)
97     + (caster->path_repelled & spell->path_attuned ? -ATTUNE_REPELL : 0);
98     }
99    
100 elmex 1.1 /* This function returns the effective level the spell
101     * is being cast at.
102     */
103 root 1.11 int
104 root 1.79 casting_level (object *caster, object *spell)
105 elmex 1.1 {
106 root 1.11 int level = caster->level;
107    
108     /* if a rod is fired by a player, take the use_magic_item skill in consideration. */
109     if (caster->type == ROD && caster->env && caster->env->type == PLAYER)
110     {
111     object *skill = find_skill_by_number (caster->env, SK_USE_MAGIC_ITEM);
112     int sk_level = skill ? skill->level : 1;
113    
114 root 1.66 level = min (level, sk_level + level / 10 + 1);
115 elmex 1.1 }
116 root 1.79 else if (caster->type == PLAYER) /* If this is a player, try to find the matching skill */
117     if (object *skill = caster->contr->find_skill (spell->skill))
118     level = skill->level;
119    
120 root 1.80 int bonus = attuned_bonus (caster, spell, level);
121    
122     level += bonus;
123    
124 root 1.79 // now scale the effective level from the startinglevel..100 range to 1..100
125     if (level < 100)
126     level = lerp (level, (int)spell->level, 100, 1, 100);
127 elmex 1.1
128 root 1.11 /* Always make this at least 1. If this is zero, we get divide by zero
129     * errors in various places.
130     */
131 root 1.38 return max (level, 1);
132 elmex 1.1 }
133    
134     /* The following function scales the spellpoint cost of
135     * a spell by it's increased effectiveness. Some of the
136     * lower level spells become incredibly vicious at high
137     * levels. Very cheap mass destruction. This function is
138     * intended to keep the sp cost related to the effectiveness.
139     * op is the player/monster
140     * caster is what is casting the spell, can be op.
141     * spell is the spell object.
142     * Note that it is now possible for a spell to cost both grace and
143     * mana. In that case, we return which ever value is higher.
144     */
145 root 1.11 sint16
146     SP_level_spellpoint_cost (object *caster, object *spell, int flags)
147 elmex 1.1 {
148 root 1.79 int sp, grace, level = casting_level (caster, spell);
149 elmex 1.1
150 root 1.11 if (settings.spellpoint_level_depend == TRUE)
151     {
152     if (spell->stats.sp && spell->stats.maxsp)
153     {
154     sp = (int) (spell->stats.sp * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxsp)));
155 root 1.8 }
156 root 1.11 else
157     sp = spell->stats.sp;
158 root 1.8
159 root 1.11 sp *= (int) PATH_SP_MULT (caster, spell);
160     if (!sp && spell->stats.sp)
161     sp = 1;
162 root 1.8
163 root 1.11 if (spell->stats.grace && spell->stats.maxgrace)
164     {
165     grace = (int) (spell->stats.grace * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxgrace)));
166 root 1.8 }
167 root 1.11 else
168     grace = spell->stats.grace;
169 elmex 1.1
170 root 1.11 grace *= (int) PATH_SP_MULT (caster, spell);
171     if (spell->stats.grace && !grace)
172     grace = 1;
173     }
174     else
175     {
176     sp = (int) (spell->stats.sp * PATH_SP_MULT (caster, spell));
177     if (spell->stats.sp && !sp)
178     sp = 1;
179 root 1.65
180 root 1.11 grace = (int) (spell->stats.grace * PATH_SP_MULT (caster, spell));
181     if (spell->stats.grace && !grace)
182     grace = 1;
183     }
184 root 1.62
185 root 1.11 if (flags == SPELL_HIGHEST)
186     return MAX (sp, grace);
187     else if (flags == SPELL_GRACE)
188     return grace;
189     else if (flags == SPELL_MANA)
190     return sp;
191     else
192     {
193     LOG (llevError, "SP_level_spellpoint_cost: Unknown flags passed: %d\n", flags);
194     return 0;
195 elmex 1.1 }
196     }
197    
198 root 1.77 /*
199     * Return the effective casting level of the spell.
200 root 1.79 * To make spells independent of their starting level, this function
201     * scales the range spellstartlevel .. 100 into the range 1..100
202 root 1.77 */
203     static int
204     SP_casting_level (object *caster, object *spell)
205     {
206 root 1.79 return casting_level (caster, spell);
207 root 1.77 }
208    
209 elmex 1.1 /* SP_level_dam_adjust: Returns adjusted damage based on the caster.
210     * spob is the spell we are adjusting.
211     */
212 root 1.11 int
213     SP_level_dam_adjust (object *caster, object *spob)
214 elmex 1.1 {
215 root 1.62 if (!spob->dam_modifier)
216     return 0;
217    
218 root 1.77 return SP_casting_level (caster, spob) / spob->dam_modifier;
219 elmex 1.1 }
220    
221     /* Adjust the strength of the spell based on level.
222     * This is basically the same as SP_level_dam_adjust above,
223     * but instead looks at the level_modifier value.
224     */
225 root 1.11 int
226     SP_level_duration_adjust (object *caster, object *spob)
227 elmex 1.1 {
228 root 1.62 if (!spob->duration_modifier)
229     return 0;
230    
231 root 1.77 return SP_casting_level (caster, spob) / spob->duration_modifier;
232 elmex 1.1 }
233    
234     /* Adjust the strength of the spell based on level.
235     * This is basically the same as SP_level_dam_adjust above,
236     * but instead looks at the level_modifier value.
237     */
238 root 1.11 int
239     SP_level_range_adjust (object *caster, object *spob)
240 elmex 1.1 {
241 root 1.62 if (!spob->range_modifier)
242     return 0;
243    
244 root 1.77 return SP_casting_level (caster, spob) / spob->range_modifier;
245 elmex 1.1 }
246    
247     /* Checks to see if player knows the spell. If the name is the same
248     * as an existing spell, we presume they know it.
249     * returns 1 if they know the spell, 0 if they don't.
250     */
251 root 1.11 object *
252 root 1.90 check_spell_known (object *op, shstr_cmp name)
253 elmex 1.1 {
254 root 1.11 object *spop;
255 elmex 1.1
256 root 1.11 for (spop = op->inv; spop; spop = spop->below)
257 root 1.71 if (spop->type == SPELL && spop->name == name)
258 root 1.11 return spop;
259 elmex 1.1
260 root 1.71 return 0;
261 elmex 1.1 }
262    
263     /*
264     * Look at object 'op' and see if they know the spell
265     * spname. This is pretty close to check_spell_known
266     * above, but it uses a looser matching mechanism.
267     * returns the matching spell object, or NULL.
268     * If we match multiple spells but don't get an
269     * exact match, we also return NULL.
270     */
271 root 1.11 object *
272     lookup_spell_by_name (object *op, const char *spname)
273     {
274 root 1.89 object *spob1 = 0, *spob2 = 0;
275 root 1.11 int nummatch = 0;
276    
277 root 1.89 if (!spname)
278     return 0;
279 root 1.11
280     /* Try to find the spell. We store the results in spob1
281     * and spob2 - spob1 is only taking the length of
282     * the past spname, spob2 uses the length of the spell name.
283     */
284 root 1.89 for (object *spob = op->inv; spob; spob = spob->below)
285 root 1.11 {
286     if (spob->type == SPELL)
287     {
288 root 1.89 // TODO: WTF?
289 root 1.11 if (!strncmp (spob->name, spname, strlen (spname)))
290     {
291     nummatch++;
292     spob1 = spob;
293     }
294     else if (!strncmp (spob->name, spname, strlen (spob->name)))
295     {
296     /* if spells have ambiguous names, it makes matching
297     * really difficult. (eg, fire and fireball would
298     * fall into this category). It shouldn't be hard to
299     * make sure spell names don't overlap in that fashion.
300     */
301     if (spob2)
302     LOG (llevError, "Found multiple spells with overlapping base names: %s, %s\n", &spob2->name, &spob->name);
303 root 1.89
304 root 1.11 spob2 = spob;
305 root 1.8 }
306     }
307 elmex 1.1 }
308 root 1.11 /* if we have best match, return it. Otherwise, if we have one match
309     * on the loser match, return that, otehrwise null
310     */
311     if (spob2)
312     return spob2;
313 root 1.89
314 root 1.11 if (spob1 && nummatch == 1)
315     return spob1;
316 root 1.89
317 root 1.11 return NULL;
318 elmex 1.1 }
319    
320     /* reflwall - decides weither the (spell-)object sp_op will
321     * be reflected from the given mapsquare. Returns 1 if true.
322     * (Note that for living creatures there is a small chance that
323     * reflect_spell fails.)
324     * Caller should be sure it passes us valid map coordinates
325     * eg, updated for tiled maps.
326     */
327 root 1.11 int
328 root 1.17 reflwall (maptile *m, int x, int y, object *sp_op)
329 root 1.11 {
330     if (OUT_OF_REAL_MAP (m, x, y))
331     return 0;
332 root 1.79
333     for (object *op = GET_MAP_OB (m, x, y); op; op = op->above)
334 elmex 1.23 if (QUERY_FLAG (op, FLAG_REFL_SPELL)
335     && (!QUERY_FLAG (op, FLAG_ALIVE)
336     || (rndm (0, 99)) < 90 - (sp_op->level / 10)))
337 root 1.11 return 1;
338 elmex 1.1
339 root 1.11 return 0;
340 elmex 1.1 }
341    
342     /* cast_create_object: creates object new_op in direction dir
343     * or if that is blocked, beneath the player (op).
344     * we pass 'caster', but don't use it for anything.
345     * This is really just a simple wrapper function .
346     * returns the direction that the object was actually placed
347     * in.
348     */
349 root 1.11 int
350     cast_create_obj (object *op, object *caster, object *new_op, int dir)
351 elmex 1.1 {
352 root 1.17 maptile *m;
353 root 1.11 sint16 sx, sy;
354 elmex 1.1
355 root 1.11 if (dir &&
356     ((get_map_flags (op->map, &m, op->x + freearr_x[dir], op->y + freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) ||
357     OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))))
358     {
359     new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
360     new_draw_info (NDI_UNIQUE, 0, op, "You cast it at your feet.");
361     dir = 0;
362     }
363 root 1.29
364 elmex 1.56 SET_FLAG (new_op, FLAG_IDENTIFIED);
365 root 1.29 op->map->insert (new_op,
366     op->x + freearr_x[dir], op->y + freearr_y[dir],
367     op,
368     dir ? 0 : INS_BELOW_ORIGINATOR);
369    
370 root 1.11 return dir;
371 elmex 1.1 }
372    
373     /* Returns true if it is ok to put spell *op on the space/may provided.
374     * immune_stop is basically the attacktype of the spell (why
375     * passed as a different value, not sure of). If immune_stop
376     * has the AT_MAGIC bit set, and there is a counterwall
377     * on the space, the object doesn't get placed. if immune stop
378     * does not have AT_MAGIC, then counterwalls do not effect the spell.
379     *
380     */
381 root 1.11 int
382 root 1.17 ok_to_put_more (maptile *m, sint16 x, sint16 y, object *op, int immune_stop)
383 root 1.11 {
384 root 1.32 if (!xy_normalise (m, x, y))
385     return 0;
386 root 1.11
387 root 1.32 mapspace &ms = m->at (x, y);
388 root 1.75 ms.update ();
389 root 1.11
390 root 1.32 if (OB_TYPE_MOVE_BLOCK (op, ms.move_block))
391 root 1.11 return 0;
392    
393 root 1.32 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
394 root 1.11 {
395     /* If there is a counterspell on the space, and this
396     * object is using magic, don't progress. I believe we could
397     * leave this out and let in progress, and other areas of the code
398     * will then remove it, but that would seem to to use more
399     * resources, and may not work as well if a player is standing
400     * on top of a counterwall spell (may hit the player before being
401     * removed.) On the other hand, it may be more dramatic for the
402     * spell to actually hit the counterwall and be sucked up.
403     */
404 elmex 1.40 if ((tmp->attacktype & AT_COUNTERSPELL)
405     && !QUERY_FLAG (tmp, FLAG_MONSTER)
406     && (tmp->type != PLAYER)
407     && (tmp->type != WEAPON)
408     && (tmp->type != BOW)
409     && (tmp->type != ARROW)
410     && (tmp->type != GOLEM)
411     && !QUERY_FLAG (tmp, FLAG_IS_FLOOR) // XXX:
412     // we special case floor here because there
413     // are sometimes spell effect floors
414     // which are used to inflict damage
415     // (and those shouldn't go away from
416     // sanctuary) see also: permanent lava
417     && (immune_stop & AT_MAGIC))
418 root 1.11 return 0;
419    
420     /* This is to prevent 'out of control' spells. Basically, this
421     * limits one spell effect per space per spell. This is definately
422     * needed for performance reasons, and just for playability I believe.
423     * there are no such things as multispaced spells right now, so
424     * we don't need to worry about the head.
425     */
426     if ((tmp->stats.maxhp == op->stats.maxhp) && (tmp->type == op->type) && (tmp->subtype == op->subtype))
427     return 0;
428    
429     /*
430     * Combine similar spell effects into one spell effect. Needed for
431     * performance reasons with meteor swarm and the like, but also for
432     * playability reasons.
433     */
434 root 1.69 if (tmp->arch == op->arch /* no harm if not comparing by name here */
435 root 1.11 && tmp->type == op->type
436     && tmp->subtype == op->subtype
437 root 1.33 && tmp->owner == op->owner
438     && ((tmp->subtype == SP_EXPLOSION) || (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp)))
439 root 1.11 {
440     tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam);
441     tmp->range = MAX (tmp->range, op->range);
442     tmp->duration = MAX (tmp->duration, op->duration);
443     return 0;
444 elmex 1.1 }
445    
446 root 1.11 /* Perhaps we should also put checks in for no magic and unholy
447     * ground to prevent it from moving along?
448     */
449 elmex 1.1 }
450 root 1.32
451 root 1.11 /* If it passes the above tests, it must be OK */
452     return 1;
453 elmex 1.1 }
454    
455     /* fire_arch_from_position: fires an archetype.
456     * op: person firing the object.
457     * caster: object casting the spell.
458     * x, y: where to fire the spell (note, it then uses op->map for the map
459     * for these coordinates, which is probably a really bad idea.
460     * dir: direction to fire in.
461     * spell: spell that is being fired. It uses other_arch for the archetype
462     * to fire.
463     * returns 0 on failure, 1 on success.
464     */
465 root 1.11 int
466     fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y, int dir, object *spell)
467     {
468 root 1.73 if (!spell->other_arch)
469     return 0;
470    
471     object *tmp = spell->other_arch->instance ();
472 elmex 1.1
473 root 1.73 if (!tmp)
474 root 1.11 return 0;
475 elmex 1.1
476 root 1.11 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
477     tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
478     /* code in time.c uses food for some things, duration for others */
479     tmp->stats.food = tmp->duration;
480     tmp->range = spell->range + SP_level_range_adjust (caster, spell);
481     tmp->attacktype = spell->attacktype;
482     tmp->direction = dir;
483 root 1.73 tmp->set_owner (op);
484 root 1.79 tmp->level = casting_level (caster, spell);
485 root 1.11 set_spell_skill (op, caster, spell, tmp);
486    
487     /* needed for AT_HOLYWORD,AT_GODPOWER stuff */
488     if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
489 root 1.73 if (!tailor_god_spell (tmp, op))
490     return 0;
491    
492 root 1.11 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
493     SET_ANIMATION (tmp, dir);
494 elmex 1.1
495 root 1.73 if ((tmp = op->map->insert (tmp, x, y, op)))
496 root 1.29 move_spell_effect (tmp);
497 elmex 1.1
498 root 1.11 return 1;
499 elmex 1.1 }
500    
501     /*****************************************************************************
502     *
503     * Code related to rods - perhaps better located in another file?
504     *
505     ****************************************************************************/
506 root 1.11 void
507     regenerate_rod (object *rod)
508     {
509     if (rod->stats.hp < rod->stats.maxhp)
510 root 1.44 rod->stats.hp = min (rod->stats.maxhp, rod->stats.hp + 1 + rod->stats.maxhp / 10);
511 elmex 1.1 }
512    
513 root 1.11 void
514     drain_rod_charge (object *rod)
515     {
516     rod->stats.hp -= SP_level_spellpoint_cost (rod, rod->inv, SPELL_HIGHEST);
517 elmex 1.1 }
518    
519     /* this function is commonly used to find a friendly target for
520     * spells such as heal or protection or armour
521     * op is what is looking for the target (which can be a player),
522     * dir is the direction we are looking in. Return object found, or
523     * NULL if no good object.
524     */
525 root 1.11 object *
526     find_target_for_friendly_spell (object *op, int dir)
527     {
528     object *tmp;
529    
530     /* I don't really get this block - if op isn't a player or rune,
531     * we then make the owner of this object the target.
532     * The owner could very well be no where near op.
533     */
534     if (op->type != PLAYER && op->type != RUNE)
535     {
536 root 1.21 tmp = op->owner;
537 root 1.11 /* If the owner does not exist, or is not a monster, than apply the spell
538     * to the caster.
539     */
540     if (!tmp || !QUERY_FLAG (tmp, FLAG_MONSTER))
541     tmp = op;
542 elmex 1.1 }
543 root 1.11 else
544     {
545 root 1.37 maptile *m = op->map;
546     sint16 x = op->x + freearr_x[dir];
547     sint16 y = op->y + freearr_y[dir];
548    
549     tmp = xy_normalise (m, x, y)
550     ? m->at (x, y).player ()
551     : 0;
552 root 1.11 }
553 root 1.26
554 root 1.11 /* didn't find a player there, look in current square for a player */
555 root 1.26 if (!tmp)
556     tmp = op->ms ().player ();
557 elmex 1.1
558 root 1.11 return tmp;
559 elmex 1.1 }
560    
561     /* raytrace:
562     * spell_find_dir(map, x, y, exclude) will search first the center square
563     * then some close squares in the given map at the given coordinates for
564     * live objects.
565     * It will not consider the object given as exclude (= caster) among possible
566     * live objects. If the caster is a player, the spell will go after
567     * monsters/generators only. If not, the spell will hunt players only.
568     * It returns the direction toward the first/closest live object if it finds
569     * any, otherwise -1.
570     * note that exclude can be NULL, in which case all bets are off.
571     */
572 root 1.11 int
573 root 1.17 spell_find_dir (maptile *m, int x, int y, object *exclude)
574 root 1.11 {
575     int i, max = SIZEOFFREE;
576     sint16 nx, ny;
577     int owner_type = 0, mflags;
578     object *tmp;
579 root 1.17 maptile *mp;
580 root 1.11
581     if (exclude && exclude->head)
582     exclude = exclude->head;
583     if (exclude && exclude->type)
584     owner_type = exclude->type;
585    
586     for (i = rndm (1, 8); i < max; i++)
587     {
588     nx = x + freearr_x[i];
589     ny = y + freearr_y[i];
590     mp = m;
591     mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
592     if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW))
593     continue;
594    
595 root 1.24 tmp = GET_MAP_OB (mp, nx, ny);
596 root 1.11
597     while (tmp != NULL && (((owner_type == PLAYER &&
598     !QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_GENERATOR)) ||
599     (owner_type != PLAYER && tmp->type != PLAYER)) || (tmp == exclude || (tmp->head && tmp->head == exclude))))
600     tmp = tmp->above;
601 elmex 1.1
602 root 1.11 if (tmp != NULL && can_see_monsterP (m, x, y, i))
603     return freedir[i];
604 elmex 1.1 }
605 root 1.11 return -1; /* flag for "keep going the way you were" */
606 elmex 1.1 }
607    
608     /* put_a_monster: puts a monster named monstername near by
609     * op. This creates the treasures for the monsters, and
610     * also deals with multipart monsters properly.
611     */
612 root 1.11 void
613     put_a_monster (object *op, const char *monstername)
614     {
615     object *tmp, *head = NULL, *prev = NULL;
616     archetype *at;
617     int dir;
618    
619     /* Handle cases where we are passed a bogus mosntername */
620    
621 root 1.14 if ((at = archetype::find (monstername)) == NULL)
622 root 1.11 return;
623    
624     /* find a free square nearby
625     * first we check the closest square for free squares
626     */
627    
628 root 1.51 dir = find_first_free_spot (at, op->map, op->x, op->y);
629 root 1.11 if (dir != -1)
630     {
631     /* This is basically grabbed for generate monster. Fixed 971225 to
632     * insert multipart monsters properly
633     */
634 root 1.52 //TODO: use expand_tail + ...
635 root 1.11 while (at != NULL)
636     {
637     tmp = arch_to_object (at);
638 root 1.51 tmp->x = op->x + freearr_x[dir] + at->x;
639     tmp->y = op->y + freearr_y[dir] + at->y;
640 root 1.11 tmp->map = op->map;
641     if (head)
642     {
643     tmp->head = head;
644     prev->more = tmp;
645 root 1.8 }
646 root 1.52
647 root 1.11 if (!head)
648     head = tmp;
649 root 1.52
650 root 1.11 prev = tmp;
651 root 1.52
652     at = (archetype *)at->more;
653 root 1.8 }
654    
655 root 1.11 if (head->randomitems)
656     create_treasure (head->randomitems, head, GT_INVISIBLE, op->map->difficulty, 0);
657 root 1.8
658 root 1.11 insert_ob_in_map (head, op->map, op, 0);
659 root 1.8
660 root 1.11 /* thought it'd be cool to insert a burnout, too. */
661 root 1.70 op->map->insert (archetype::get (shstr_burnout), op->x + freearr_x[dir], op->y + freearr_y[dir], op);
662 elmex 1.1 }
663     }
664    
665     /* peterm: function which summons hostile monsters and
666     * places them in nearby squares.
667     * op is the summoner.
668     * n is the number of monsters.
669     * monstername is the name of the monster.
670     * returns the number of monsters, which is basically n.
671     * it should really see how many it successfully replaced and
672     * return that instead.
673     * Note that this is not used by any spells (summon evil monsters
674     * use to call this, but best I can tell, that spell/ability was
675     * never used. This is however used by various failures on the
676     * players part (alchemy, reincarnation, etc)
677     */
678    
679 root 1.11 int
680     summon_hostile_monsters (object *op, int n, const char *monstername)
681     {
682     int i;
683    
684     for (i = 0; i < n; i++)
685     put_a_monster (op, monstername);
686 elmex 1.1
687 root 1.11 return n;
688 elmex 1.1 }
689    
690    
691     /* Some local definitions for shuffle-attack */
692 root 1.11 struct attacktype_shuffle
693     {
694     int attacktype;
695     int face;
696     } ATTACKS[22] =
697     {
698 root 1.41 { AT_PHYSICAL, 0},
699     { AT_PHYSICAL, 0}, /*face = explosion */
700     { AT_PHYSICAL, 0},
701     { AT_MAGIC, 1},
702     { AT_MAGIC, 1}, /* face = last-burnout */
703     { AT_MAGIC, 1},
704     { AT_FIRE, 2},
705     { AT_FIRE, 2}, /* face = fire.... */
706     { AT_FIRE, 2},
707     { AT_ELECTRICITY, 3},
708     { AT_ELECTRICITY, 3}, /* ball_lightning */
709     { AT_ELECTRICITY, 3},
710     { AT_COLD, 4},
711     { AT_COLD, 4}, /* face=icestorm */
712     { AT_COLD, 4},
713     { AT_CONFUSION, 5},
714     { AT_POISON, 7},
715     { AT_POISON, 7}, /* face = acid sphere. generator */
716     { AT_POISON, 7}, /* poisoncloud face */
717     { AT_SLOW, 8},
718     { AT_PARALYZE, 9},
719     { AT_FEAR, 10},
720     };
721 elmex 1.1
722     /* shuffle_attack: peterm
723     * This routine shuffles the attack of op to one of the
724     * ones in the list. It does this at random. It also
725     * chooses a face appropriate to the attack that is
726     * being committed by that square at the moment.
727     * right now it's being used by color spray and create pool of
728     * chaos.
729     * This could really be a better implementation - the
730     * faces and attacktypes above are hardcoded, which is never
731     * good. The faces refer to faces in the animation sequence.
732     * Not sure how to do better - but not having it hardcoded
733     * would be nice.
734     * I also fixed a bug here in that attacktype was |= -
735     * to me, that would be that it would quickly get all
736     * attacktypes, which probably wasn't the intent. MSW 2003-06-03
737     */
738 root 1.11 void
739     shuffle_attack (object *op, int change_face)
740 elmex 1.1 {
741 root 1.11 int i;
742 elmex 1.1
743 root 1.11 i = rndm (0, 21);
744 elmex 1.1
745 root 1.11 op->attacktype = ATTACKS[i].attacktype | AT_MAGIC;
746    
747     if (change_face)
748     {
749     SET_ANIMATION (op, ATTACKS[i].face);
750 elmex 1.1 }
751     }
752    
753     /* prayer_failure: This is called when a player fails
754     * at casting a prayer.
755     * op is the player.
756     * failure is basically how much grace they had.
757     * power is how much grace the spell would normally take to cast.
758     */
759 root 1.11 void
760     prayer_failure (object *op, int failure, int power)
761     {
762     const char *godname;
763     object *tmp;
764 elmex 1.1
765 root 1.11 if (!strcmp ((godname = determine_god (op)), "none"))
766     godname = "Your spirit";
767 elmex 1.1
768 root 1.11 if (failure <= -20 && failure > -40) /* wonder */
769 elmex 1.1 {
770 root 1.11 new_draw_info_format (NDI_UNIQUE, 0, op, "%s gives a sign to renew your faith.", godname);
771     tmp = get_archetype (SPELL_WONDER);
772     cast_cone (op, op, 0, tmp);
773 root 1.82 tmp->destroy ();
774 elmex 1.1 }
775    
776 root 1.11 else if (failure <= -40 && failure > -60) /* confusion */
777 elmex 1.1 {
778 root 1.11 new_draw_info (NDI_UNIQUE, 0, op, "Your diety touches your mind!");
779     confuse_player (op, op, 99);
780 elmex 1.1 }
781 root 1.11 else if (failure <= -60 && failure > -150) /* paralysis */
782 elmex 1.1 {
783 root 1.11 new_draw_info_format (NDI_UNIQUE, 0, op, "%s requires you to pray NOW.", godname);
784     new_draw_info (NDI_UNIQUE, 0, op, "You comply, ignoring all else.");
785     paralyze_player (op, op, 99);
786 elmex 1.1 }
787 root 1.11 else if (failure <= -150) /* blast the immediate area */
788     {
789     tmp = get_archetype (GOD_POWER);
790     new_draw_info_format (NDI_UNIQUE, 0, op, "%s smites you!", godname);
791     cast_magic_storm (op, tmp, power);
792 elmex 1.1 }
793     }
794    
795     /*
796     * spell_failure() handles the various effects for differing degrees
797     * of failure badness.
798     * op is the player that failed.
799     * failure is a random value of how badly you failed.
800     * power is how many spellpoints you'd normally need for the spell.
801     * skill is the skill you'd need to cast the spell.
802     */
803    
804 root 1.11 void
805     spell_failure (object *op, int failure, int power, object *skill)
806     {
807     object *tmp;
808 elmex 1.1
809 root 1.11 if (settings.spell_failure_effects == FALSE)
810     return;
811 elmex 1.1
812 root 1.11 if (failure <= -20 && failure > -40) /* wonder */
813 elmex 1.1 {
814 root 1.11 new_draw_info (NDI_UNIQUE, 0, op, "Your spell causes an unexpected effect.");
815     tmp = get_archetype (SPELL_WONDER);
816     cast_cone (op, op, 0, tmp);
817 root 1.82 tmp->destroy ();
818 elmex 1.1 }
819    
820 root 1.11 else if (failure <= -40 && failure > -60) /* confusion */
821 elmex 1.1 {
822 root 1.11 new_draw_info (NDI_UNIQUE, 0, op, "Your magic recoils on you, making you confused!");
823     confuse_player (op, op, 99);
824 elmex 1.1 }
825 root 1.11 else if (failure <= -60 && failure > -80) /* paralysis */
826 elmex 1.1 {
827 root 1.11 new_draw_info (NDI_UNIQUE, 0, op, "Your magic stuns you!");
828     paralyze_player (op, op, 99);
829 elmex 1.1 }
830 root 1.11 else if (failure <= -80) /* blast the immediate area */
831     {
832     object *tmp;
833 root 1.8
834 root 1.11 /* Safety check to make sure we don't get any mana storms in scorn */
835     if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC)
836     {
837     new_draw_info (NDI_UNIQUE, 0, op, "The magic warps and you are turned inside out!");
838     hit_player (op, 9998, op, AT_INTERNAL, 1);
839 root 1.8
840 root 1.11 }
841     else
842     {
843     new_draw_info (NDI_UNIQUE, 0, op, "You lose control of the mana! The uncontrolled magic blasts you!");
844     tmp = get_archetype (LOOSE_MANA);
845     tmp->level = skill->level;
846    
847     /* increase the area of destruction a little for more powerful spells */
848     tmp->range += isqrt (power);
849    
850     if (power > 25)
851     tmp->stats.dam = 25 + isqrt (power);
852     else
853     tmp->stats.dam = power; /* nasty recoils! */
854 root 1.8
855 root 1.11 tmp->stats.maxhp = tmp->count;
856 root 1.29
857     tmp->insert_at (op);
858 root 1.8 }
859 elmex 1.1 }
860     }
861    
862 root 1.11 int
863     cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
864     {
865     int success;
866     object *spell;
867    
868     if (!spell_ob->other_arch)
869 elmex 1.1 {
870 root 1.11 LOG (llevError, "cast_party_spell: empty other arch\n");
871     return 0;
872     }
873 root 1.57
874 root 1.11 spell = arch_to_object (spell_ob->other_arch);
875 elmex 1.1
876 root 1.11 /* Always cast spell on caster */
877     success = cast_spell (op, caster, dir, spell, stringarg);
878 elmex 1.1
879 root 1.11 if (caster->contr->party == NULL)
880     {
881 root 1.19 spell->remove ();
882 root 1.11 return success;
883 elmex 1.1 }
884 root 1.57
885 root 1.27 for_all_players (pl)
886 root 1.11 if ((pl->ob->contr->party == caster->contr->party) && (on_same_map (pl->ob, caster)))
887 root 1.57 cast_spell (pl->ob, caster, pl->ob->facing, spell, stringarg);
888    
889 root 1.19 spell->remove ();
890 root 1.11 return success;
891     }
892 elmex 1.1
893     /* This is where the main dispatch when someone casts a spell.
894     *
895     * op is the creature that is owner of the object that is casting the spell -
896     * eg, the player or monster.
897     * caster is the actual object (wand, potion) casting the spell. can be
898     * same as op.
899     * dir is the direction to cast in. Note in some cases, if the spell
900     * is self only, dir really doesn't make a difference.
901     * spell_ob is the spell object that is being cast. From that,
902     * we can determine what to do.
903     * stringarg is any options that are being used. It can be NULL. Almost
904     * certainly, only players will set it. It is basically used as optional
905     * parameters to a spell (eg, item to create, information for marking runes,
906     * etc.
907     * returns 1 on successful cast, or 0 on error. These values should really
908     * be swapped, so that 0 is successful, and non zero is failure, with a code
909     * of what it failed.
910     *
911     * Note that this function is really a dispatch routine that calls other
912     * functions - it just blindly returns what ever value those functions
913     * return. So if your writing a new function that is called from this,
914     * it shoudl also return 1 on success, 0 on failure.
915     *
916     * if it is a player casting the spell (op->type == PLAYER, op == caster),
917     * this function will decrease the mana/grace appropriately. For other
918     * objects, the caller should do what it considers appropriate.
919     */
920 root 1.11 int
921     cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
922     {
923     const char *godname;
924 root 1.86 int success = 0;
925 root 1.11 object *skill = NULL;
926 elmex 1.1
927 root 1.11 if (!spell_ob)
928     {
929     LOG (llevError, "cast_spell: null spell object passed\n");
930     return 0;
931 elmex 1.1 }
932 root 1.13
933 root 1.11 if (!strcmp ((godname = determine_god (op)), "none"))
934     godname = "A random spirit";
935 elmex 1.1
936 root 1.11 /* the caller should set caster to op if appropriate */
937     if (!caster)
938     {
939     LOG (llevError, "cast_spell: null caster object passed\n");
940     return 0;
941 elmex 1.1 }
942    
943 root 1.11 /* if caster is a spell casting object, this normally shouldn't be
944     * an issue, because they don't have any spellpaths set up.
945     */
946 root 1.18 if (caster->path_denied & spell_ob->path_attuned && !QUERY_FLAG (caster, FLAG_WIZCAST))
947 root 1.11 {
948     new_draw_info (NDI_UNIQUE, 0, op, "That spell path is denied to you.");
949     return 0;
950 elmex 1.1 }
951    
952 root 1.11 /* if it is a player casting the spell, and they are really casting it
953     * (vs it coming from a wand, scroll, or whatever else), do some
954     * checks. We let monsters do special things - eg, they
955     * don't need the skill, bypass level checks, etc. The monster function
956     * should take care of that.
957     * Remove the wiz check here and move it further down - some spells
958     * need to have the right skill pointer passed, so we need to
959     * at least process that code.
960     */
961     if (op->type == PLAYER && op == caster)
962     {
963     if (spell_ob->skill)
964     {
965     skill = find_skill_by_name (op, spell_ob->skill);
966 root 1.45
967 root 1.11 if (!skill)
968     {
969 root 1.68 op->failmsg (format ("You need the skill %s to cast %s! "
970     "H<You either need to learn the skill via a skill scroll "
971     "or you need to wear a talisman or holy symbol.>",
972     &spell_ob->skill, &spell_ob->name));
973 root 1.79 return 0;
974     }
975    
976     const char *msg = "";
977    
978     int caster_level = skill->level;
979    
980     if (op->path_attuned & spell_ob->path_attuned)
981     {
982 root 1.86 caster_level += min (caster_level, ATTUNE_REPELL);
983 root 1.79 msg = " (attuned)";
984     }
985    
986     if (op->path_repelled & spell_ob->path_attuned)
987     {
988 root 1.84 caster_level -= ATTUNE_REPELL; // negative is ok
989 root 1.79 msg = " (repelled)";
990 root 1.8 }
991 root 1.45
992 root 1.80 if (spell_ob->level > caster_level)
993 root 1.11 {
994 root 1.68 op->failmsg (format ("You lack enough skill to cast that spell! "
995 root 1.79 "H<Your effective cast level is %d%s, but level %d is required.>",
996 root 1.80 caster_level, msg, spell_ob->level));
997 root 1.79 if (!op->is_wiz ())
998     return 0;
999 root 1.8 }
1000     }
1001 root 1.45
1002 root 1.11 /* If the caster is the wiz, they don't ever fail, and don't have
1003     * to have sufficient grace/mana.
1004     */
1005 root 1.88 if (!QUERY_FLAG (op, FLAG_WIZCAST))
1006 root 1.11 {
1007     if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) &&
1008     SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp)
1009     {
1010 root 1.60 op->failmsg ("You don't have enough mana!");
1011 root 1.11 return 0;
1012 root 1.8 }
1013 root 1.30
1014 root 1.11 if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) &&
1015     SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) > op->stats.grace)
1016     {
1017     if (random_roll (0, op->stats.Wis - 1, op, PREFER_HIGH) + op->stats.grace -
1018     10 * SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) / op->stats.maxgrace > 0)
1019 root 1.60 op->statusmsg (format ("%s grants your prayer, though you are unworthy.", godname));
1020 root 1.11 else
1021     {
1022     prayer_failure (op, op->stats.grace, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) - op->stats.grace);
1023 root 1.60 op->failmsg (format ("%s ignores your prayer.", godname));
1024 root 1.11 return 0;
1025 root 1.8 }
1026     }
1027    
1028 root 1.11 /* player/monster is trying to cast the spell. might fumble it */
1029     if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) <
1030     (spell_ob->level / (float) MAX (1, op->level) * cleric_chance[op->stats.Wis]))
1031     {
1032 root 1.55 op->contr->play_sound (sound_find ("fumble_spell"));
1033 root 1.60 op->failmsg ("You fumble the prayer.");
1034 root 1.35
1035 root 1.11 op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);
1036     return 0;
1037     }
1038     else if (spell_ob->stats.sp)
1039     {
1040     int failure = random_roll (0, 199, op, PREFER_HIGH) - op->contr->encumbrance + op->level - spell_ob->level + 35;
1041    
1042     if (failure < 0)
1043     {
1044 root 1.60 op->failmsg ("You bungle the spell because you have too much heavy equipment in use.");
1045 root 1.11 if (settings.spell_failure_effects == TRUE)
1046     spell_failure (op, failure, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), skill);
1047 root 1.42
1048 root 1.11 op->stats.sp -= random_roll (0, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), op, PREFER_LOW);
1049     return 0;
1050 root 1.8 }
1051     }
1052     }
1053 elmex 1.1 }
1054    
1055 root 1.60 int mflags = op->ms ().flags ();
1056 root 1.11
1057     /* See if we can cast a spell here. If the caster and op are
1058     * not alive, then this would mean that the mapmaker put the
1059     * objects on the space - presume that they know what they are
1060     * doing.
1061     */
1062 elmex 1.9
1063 root 1.11 if ((mflags & P_SAFE) && !QUERY_FLAG (op, FLAG_WIZCAST)) // There is _ABSOLUTELY_ no magic allowed here (except wizards :-)!
1064     {
1065 root 1.58 op->failmsg ("This ground is sacred! The gods prevent any magical effects done by you here!");
1066 root 1.11 return 0;
1067     }
1068    
1069     if ((spell_ob->type == SPELL)
1070     && (caster->type != POTION)
1071     && !QUERY_FLAG (op, FLAG_WIZCAST)
1072     && (QUERY_FLAG (caster, FLAG_ALIVE)
1073     || QUERY_FLAG (op, FLAG_ALIVE))
1074     && (((mflags & P_NO_MAGIC) && spell_ob->stats.sp) || ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))
1075     {
1076     if (op->type != PLAYER)
1077 elmex 1.9 return 0;
1078    
1079 root 1.11 if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)
1080 root 1.58 op->failmsg (format ("This ground is unholy! %s ignores you.", godname));
1081 root 1.43 else if (object *item = op->contr->ranged_ob)
1082     {
1083     if (item->type == SPELL)
1084 root 1.60 op->failmsg ("Something blocks your spellcasting.");
1085 root 1.43 else if (item->type == SCROLL)
1086 root 1.60 op->failmsg ("Something blocks the magic of your scroll.");
1087 root 1.43 else
1088 root 1.60 op->failmsg ("Something blocks the magic of your item.");
1089 root 1.43 }
1090 root 1.11 else
1091 root 1.60 op->failmsg ("Something blocks the spell!");
1092 root 1.42
1093 root 1.11 return 0;
1094     }
1095 elmex 1.1
1096 root 1.46 /* Take into account how long it takes to cast the spell.
1097     * if the player is casting it, then we use the time in
1098     * the spell object. If it is a spell object, have it
1099     * take two ticks. Things that cast spells on the players
1100     * behalf (eg, altars, and whatever else) shouldn't cost
1101     * the player any time.
1102     * Ignore casting time for firewalls
1103     */
1104     if (caster == op && caster->type != FIREWALL)
1105 root 1.11 {
1106 root 1.46 op->speed_left -= spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);
1107     /* Other portions of the code may also decrement the speed of the player, so
1108     * put a lower limit so that the player isn't stuck here too long
1109 root 1.11 */
1110 root 1.46 if ((spell_ob->casting_time > 0) && op->speed_left < -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed))
1111     op->speed_left = -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);
1112 elmex 1.1 }
1113 root 1.46 else if (caster->type == WAND || caster->type == HORN || caster->type == ROD || caster->type == POTION || caster->type == SCROLL)
1114     op->speed_left -= 2 * FABS (op->speed);
1115 elmex 1.1
1116 root 1.11 if (op->type == PLAYER && op == caster)
1117     {
1118     op->stats.grace -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE);
1119     op->stats.sp -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA);
1120 elmex 1.1 }
1121    
1122 root 1.11 /* We want to try to find the skill to properly credit exp.
1123     * for spell casting objects, the exp goes to the skill the casting
1124     * object requires.
1125     */
1126     if (op != caster && !skill && caster->skill)
1127     {
1128     skill = find_skill_by_name (op, caster->skill);
1129     if (!skill)
1130     {
1131 root 1.60 op->failmsg (format ("You lack the skill %s to use the %s!", &caster->skill, query_name (caster)));
1132 root 1.11 return 0;
1133 root 1.8 }
1134 root 1.45
1135 root 1.47 op->change_skill (skill); /* needed for proper exp credit */
1136 elmex 1.1 }
1137    
1138 root 1.48 if (INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg)))
1139     return RESULT_INT (0);
1140    
1141 root 1.11 switch (spell_ob->subtype)
1142     {
1143 root 1.45 /* The order of case statements is same as the order they show up
1144     * in in spells.h.
1145     */
1146 root 1.12 case SP_RAISE_DEAD:
1147     success = cast_raise_dead_spell (op, caster, spell_ob, dir, stringarg);
1148     break;
1149    
1150     case SP_RUNE:
1151     success = write_rune (op, caster, spell_ob, dir, stringarg);
1152     break;
1153    
1154     case SP_MAKE_MARK:
1155     success = write_mark (op, spell_ob, stringarg);
1156     break;
1157    
1158     case SP_BOLT:
1159     success = fire_bolt (op, caster, dir, spell_ob, skill);
1160     break;
1161    
1162     case SP_BULLET:
1163     success = fire_bullet (op, caster, dir, spell_ob);
1164     break;
1165    
1166     case SP_CONE:
1167     success = cast_cone (op, caster, dir, spell_ob);
1168     break;
1169    
1170     case SP_BOMB:
1171     success = create_bomb (op, caster, dir, spell_ob);
1172     break;
1173    
1174     case SP_WONDER:
1175     success = cast_wonder (op, caster, dir, spell_ob);
1176     break;
1177    
1178     case SP_SMITE:
1179     success = cast_smite_spell (op, caster, dir, spell_ob);
1180     break;
1181    
1182     case SP_MAGIC_MISSILE:
1183 root 1.73 success = fire_arch_from_position (op, caster, op->x, op->y, dir, spell_ob);
1184 root 1.12 break;
1185    
1186     case SP_SUMMON_GOLEM:
1187     success = summon_golem (op, caster, dir, spell_ob);
1188     break;
1189    
1190     case SP_DIMENSION_DOOR:
1191     /* dimension door needs the actual caster, because that is what is
1192     * moved.
1193     */
1194     success = dimension_door (op, caster, spell_ob, dir);
1195     break;
1196 root 1.8
1197 root 1.12 case SP_MAGIC_MAPPING:
1198     if (op->type == PLAYER)
1199     {
1200     spell_effect (spell_ob, op->x, op->y, op->map, op);
1201     draw_magic_map (op);
1202     success = 1;
1203     }
1204     else
1205     success = 0;
1206     break;
1207 elmex 1.1
1208 root 1.12 case SP_MAGIC_WALL:
1209     success = magic_wall (op, caster, dir, spell_ob);
1210     break;
1211 root 1.8
1212 root 1.12 case SP_DESTRUCTION:
1213     success = cast_destruction (op, caster, spell_ob);
1214     break;
1215 root 1.8
1216 root 1.12 case SP_PERCEIVE_SELF:
1217     success = perceive_self (op);
1218     break;
1219 root 1.8
1220 root 1.12 case SP_WORD_OF_RECALL:
1221     success = cast_word_of_recall (op, caster, spell_ob);
1222     break;
1223 root 1.8
1224 root 1.12 case SP_INVISIBLE:
1225     success = cast_invisible (op, caster, spell_ob);
1226     break;
1227 root 1.8
1228 root 1.12 case SP_PROBE:
1229     success = probe (op, caster, spell_ob, dir);
1230     break;
1231 root 1.8
1232 root 1.12 case SP_HEALING:
1233     success = cast_heal (op, caster, spell_ob, dir);
1234     break;
1235 root 1.8
1236 root 1.12 case SP_CREATE_FOOD:
1237     success = cast_create_food (op, caster, spell_ob, dir, stringarg);
1238     break;
1239 root 1.8
1240 root 1.12 case SP_EARTH_TO_DUST:
1241     success = cast_earth_to_dust (op, caster, spell_ob);
1242     break;
1243 root 1.8
1244 root 1.12 case SP_CHANGE_ABILITY:
1245     success = cast_change_ability (op, caster, spell_ob, dir, 0);
1246     break;
1247 root 1.8
1248 root 1.12 case SP_BLESS:
1249     success = cast_bless (op, caster, spell_ob, dir);
1250     break;
1251 root 1.8
1252 root 1.12 case SP_CURSE:
1253     success = cast_curse (op, caster, spell_ob, dir);
1254     break;
1255 root 1.8
1256 root 1.12 case SP_SUMMON_MONSTER:
1257     success = summon_object (op, caster, spell_ob, dir, stringarg);
1258     break;
1259 root 1.8
1260 root 1.12 case SP_CHARGING:
1261     success = recharge (op, caster, spell_ob);
1262     break;
1263 root 1.8
1264 root 1.12 case SP_POLYMORPH:
1265 elmex 1.1 #ifdef NO_POLYMORPH
1266 root 1.12 /* Not great, but at least provide feedback so if players do have
1267     * polymorph (ie, find it as a preset item or left over from before
1268     * it was disabled), they get some feedback.
1269     */
1270 root 1.60 op->failmsg ("The spell fizzles!");
1271 root 1.12 success = 0;
1272 elmex 1.1 #else
1273 root 1.12 success = cast_polymorph (op, caster, spell_ob, dir);
1274 elmex 1.1 #endif
1275 root 1.12 break;
1276 root 1.8
1277 root 1.12 case SP_ALCHEMY:
1278     success = alchemy (op, caster, spell_ob);
1279     break;
1280    
1281     case SP_REMOVE_CURSE:
1282     success = remove_curse (op, caster, spell_ob);
1283     break;
1284    
1285     case SP_IDENTIFY:
1286     success = cast_identify (op, caster, spell_ob);
1287     break;
1288    
1289     case SP_DETECTION:
1290     success = cast_detection (op, caster, spell_ob, skill);
1291     break;
1292    
1293     case SP_MOOD_CHANGE:
1294     success = mood_change (op, caster, spell_ob);
1295     break;
1296 elmex 1.1
1297 root 1.12 case SP_MOVING_BALL:
1298     if (spell_ob->path_repelled && (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled)
1299     {
1300 root 1.60 op->failmsg (format ("You lack the proper attunement to cast %s!", &spell_ob->name));
1301 root 1.12 success = 0;
1302     }
1303     else
1304 root 1.73 success = fire_arch_from_position (op, caster, op->x, op->y, dir, spell_ob);
1305 root 1.12 break;
1306 elmex 1.1
1307 root 1.12 case SP_SWARM:
1308     success = fire_swarm (op, caster, spell_ob, dir);
1309     break;
1310    
1311     case SP_CHANGE_MANA:
1312     success = cast_transfer (op, caster, spell_ob, dir);
1313     break;
1314    
1315     case SP_DISPEL_RUNE:
1316     /* in rune.c */
1317     success = dispel_rune (op, caster, spell_ob, skill, dir);
1318     break;
1319    
1320     case SP_CREATE_MISSILE:
1321     success = cast_create_missile (op, caster, spell_ob, dir, stringarg);
1322     break;
1323    
1324     case SP_CONSECRATE:
1325     success = cast_consecrate (op, caster, spell_ob);
1326     break;
1327    
1328     case SP_ANIMATE_WEAPON:
1329     success = animate_weapon (op, caster, spell_ob, dir);
1330     break;
1331    
1332     case SP_LIGHT:
1333     success = cast_light (op, caster, spell_ob, dir);
1334     break;
1335    
1336     case SP_CHANGE_MAP_LIGHT:
1337     success = cast_change_map_lightlevel (op, caster, spell_ob);
1338     break;
1339    
1340     case SP_FAERY_FIRE:
1341     success = cast_destruction (op, caster, spell_ob);
1342     break;
1343    
1344     case SP_CAUSE_DISEASE:
1345     success = cast_cause_disease (op, caster, spell_ob, dir);
1346     break;
1347    
1348     case SP_AURA:
1349     success = create_aura (op, caster, spell_ob);
1350     break;
1351    
1352     case SP_PARTY_SPELL:
1353     success = cast_party_spell (op, caster, dir, spell_ob, stringarg);
1354     break;
1355    
1356     default:
1357 root 1.48 LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);
1358 elmex 1.1 }
1359    
1360 root 1.61 op->play_sound (
1361     success
1362     ? spell_ob->sound
1363     ? spell_ob->sound
1364     : sound_find ("spell_success")
1365     : sound_find ("fumble_spell")
1366     );
1367 elmex 1.1
1368 root 1.11 return success;
1369 elmex 1.1 }
1370    
1371 root 1.60 /* This is called from time.c/process_object(). That function
1372     * calls this for any SPELL_EFFECT type objects. This function
1373 elmex 1.1 * then dispatches them to the appropriate specific routines.
1374     */
1375 root 1.11 void
1376     move_spell_effect (object *op)
1377     {
1378     switch (op->subtype)
1379     {
1380 root 1.12 case SP_BOLT:
1381     move_bolt (op);
1382     break;
1383    
1384     case SP_BULLET:
1385     move_bullet (op);
1386     break;
1387    
1388     case SP_EXPLOSION:
1389     explosion (op);
1390     break;
1391    
1392     case SP_CONE:
1393     move_cone (op);
1394     break;
1395    
1396     case SP_BOMB:
1397     animate_bomb (op);
1398     break;
1399    
1400     case SP_MAGIC_MISSILE:
1401     move_missile (op);
1402     break;
1403    
1404     case SP_WORD_OF_RECALL:
1405     execute_word_of_recall (op);
1406     break;
1407    
1408     case SP_MOVING_BALL:
1409     move_ball_spell (op);
1410     break;
1411    
1412     case SP_SWARM:
1413     move_swarm_spell (op);
1414     break;
1415    
1416     case SP_AURA:
1417     move_aura (op);
1418     break;
1419 elmex 1.1 }
1420     }
1421    
1422     /* this checks to see if something special should happen if
1423     * something runs into the object.
1424     */
1425 root 1.11 void
1426     check_spell_effect (object *op)
1427     {
1428     switch (op->subtype)
1429     {
1430 root 1.12 case SP_BOLT:
1431     move_bolt (op);
1432     return;
1433    
1434     case SP_BULLET:
1435     check_bullet (op);
1436     return;
1437 elmex 1.1 }
1438     }
1439    
1440 root 1.76 /* This is called by move_apply. Basically, if someone
1441 elmex 1.1 * moves onto a spell effect and the walk_on or fly_on flags
1442 root 1.76 * are set, this is called. This should only be called for
1443     * objects of the appropriate type.
1444 elmex 1.1 */
1445 root 1.11 void
1446     apply_spell_effect (object *spell, object *victim)
1447 elmex 1.1 {
1448 root 1.11 switch (spell->subtype)
1449     {
1450 root 1.12 case SP_CONE:
1451     if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->speed && spell->attacktype)
1452     hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0);
1453     break;
1454 root 1.8
1455 root 1.12 case SP_MAGIC_MISSILE:
1456     if (QUERY_FLAG (victim, FLAG_ALIVE))
1457     {
1458 root 1.16 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1459 root 1.82 spell->destroy ();
1460 root 1.12 }
1461     break;
1462 root 1.8
1463 root 1.12 case SP_MOVING_BALL:
1464     if (QUERY_FLAG (victim, FLAG_ALIVE))
1465     hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1466 root 1.36 else if (victim->materialname)
1467 root 1.12 save_throw_object (victim, spell->attacktype, spell);
1468 root 1.81
1469 root 1.12 break;
1470 elmex 1.1 }
1471     }
1472 root 1.60