ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/spell_attack.C
Revision: 1.25
Committed: Tue Dec 26 20:04:09 2006 UTC (17 years, 5 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.24: +63 -134 lines
Log Message:
- added maptile->insert and object->insert_at methods that might
  make code using it clearer.
- replaced some insert_ob_in_map calls.

File Contents

# User Rev Content
1 elmex 1.1 /*
2     CrossFire, A Multiplayer game for X-windows
3    
4     Copyright (C) 2002-2003 Mark Wedel & Crossfire Development Team
5     Copyright (C) 1992 Frank Tore Johansen
6    
7     This program is free software; you can redistribute it and/or modify
8     it under the terms of the GNU General Public License as published by
9     the Free Software Foundation; either version 2 of the License, or
10     (at your option) any later version.
11    
12     This program is distributed in the hope that it will be useful,
13     but WITHOUT ANY WARRANTY; without even the implied warranty of
14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     GNU General Public License for more details.
16    
17     You should have received a copy of the GNU General Public License
18     along with this program; if not, write to the Free Software
19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20    
21 root 1.13 The authors can be reached via e-mail at <crossfire@schmorp.de>
22 elmex 1.1 */
23    
24     /* This file contains all the spell attack code. Grouping this code
25     * together should hopefully make it easier to find the relevent bits
26     * of code
27     */
28    
29     #include <global.h>
30     #include <object.h>
31     #include <living.h>
32 root 1.24 #include <sproto.h>
33 elmex 1.1 #include <spells.h>
34     #include <sounds.h>
35    
36     /* this function checks to see if a spell pushes objects as well
37     * as flies over and damages them (only used for cones for now)
38     * but moved here so it could be applied to bolts too
39     * op is the spell object.
40     */
41    
42 root 1.9 void
43     check_spell_knockback (object *op)
44     {
45     object *tmp, *tmp2; /* object on the map */
46     int weight_move;
47     int frictionmod = 2; /*poor man's physics - multipy targets weight by this amount */
48    
49     if (!op->weight)
50     { /*shouldn't happen but if cone object has no weight drop out */
51     /*LOG (llevDebug, "DEBUG: arch weighs nothing\n"); */
52     return;
53     }
54     else
55     {
56     weight_move = op->weight + (op->weight * op->level) / 3;
57     /*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */
58     }
59    
60 root 1.21 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
61 root 1.9 {
62     int num_sections = 1;
63    
64     /* don't move DM */
65     if (QUERY_FLAG (tmp, FLAG_WIZ))
66     return;
67    
68     /* don't move parts of objects */
69     if (tmp->head)
70     continue;
71    
72     /* don't move floors or immobile objects */
73     if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))
74     continue;
75    
76     /* count the object's sections */
77     for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more)
78     num_sections++;
79    
80     /* I'm not sure if it makes sense to divide by num_sections - bigger
81     * objects should be harder to move, and we are moving the entire
82     * object, not just the head, so the total weight should be relevant.
83     */
84    
85     /* surface area? -tm */
86    
87     if (tmp->move_type & MOVE_FLYING)
88     frictionmod = 1; /* flying objects loose the friction modifier */
89    
90     if (rndm (0, weight_move - 1) > ((tmp->weight / num_sections) * frictionmod))
91     { /* move it. */
92     /* move_object is really for monsters, but looking at
93     * the move_object function, it appears that it should
94     * also be safe for objects.
95     * This does return if successful or not, but
96     * I don't see us doing anything useful with that information
97     * right now.
98     */
99     move_object (tmp, absdir (op->stats.sp));
100 root 1.6 }
101 elmex 1.1
102     }
103     }
104    
105     /***************************************************************************
106     *
107     * BOLT CODE
108     *
109     ***************************************************************************/
110    
111     /* Causes op to fork. op is the original bolt, tmp
112     * is the first piece of the fork.
113     */
114    
115 root 1.9 void
116     forklightning (object *op, object *tmp)
117     {
118     int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
119     int t_dir; /* stores temporary dir calculation */
120 root 1.15 maptile *m;
121 root 1.9 sint16 sx, sy;
122     object *new_bolt;
123    
124     /* pick a fork direction. tmp->stats.Con is the left bias
125     * i.e., the chance in 100 of forking LEFT
126     * Should start out at 50, down to 25 for one already going left
127     * down to 0 for one going 90 degrees left off original path
128     */
129    
130     if (rndm (0, 99) < tmp->stats.Con) /* fork left */
131     new_dir = -1;
132    
133     /* check the new dir for a wall and in the map */
134     t_dir = absdir (tmp->direction + new_dir);
135    
136     if (get_map_flags (tmp->map, &m, tmp->x + freearr_x[t_dir], tmp->y + freearr_y[t_dir], &sx, &sy) & P_OUT_OF_MAP)
137     return;
138    
139     if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy)))
140     return;
141    
142     /* OK, we made a fork */
143 root 1.18 new_bolt = tmp->clone ();
144 root 1.9
145     /* reduce chances of subsequent forking */
146     new_bolt->stats.Dex -= 10;
147     tmp->stats.Dex -= 10; /* less forks from main bolt too */
148     new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */
149     new_bolt->speed_left = -0.1;
150     new_bolt->direction = t_dir;
151     new_bolt->duration++;
152     new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
153     new_bolt->stats.dam++;
154     tmp->stats.dam /= 2; /* reduce father bolt damage */
155     tmp->stats.dam++;
156 root 1.25 if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
157     update_turn_face (new_bolt);
158 elmex 1.1 }
159    
160     /* move_bolt: moves bolt 'op'. Basically, it just advances a space,
161     * and checks for various things that may stop it.
162     */
163    
164 root 1.9 void
165     move_bolt (object *op)
166     {
167     object *tmp;
168     int mflags;
169     sint16 x, y;
170 root 1.15 maptile *m;
171 root 1.9
172 root 1.25 if (--op->duration < 0)
173 root 1.9 {
174 root 1.17 op->destroy ();
175 root 1.9 return;
176     }
177 root 1.11
178 root 1.9 hit_map (op, 0, op->attacktype, 1);
179    
180     if (!op->direction)
181     return;
182    
183     if (--op->range < 0)
184 root 1.25 op->range = 0;
185 root 1.9 else
186     {
187     x = op->x + DIRX (op);
188     y = op->y + DIRY (op);
189     m = op->map;
190     mflags = get_map_flags (m, &m, x, y, &x, &y);
191    
192     if (mflags & P_OUT_OF_MAP)
193     return;
194    
195     /* We are about to run into something - we may bounce */
196     /* Calling reflwall is pretty costly, as it has to look at all the objects
197     * on the space. So only call reflwall if we think the data it returns
198     * will be useful.
199     */
200     if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)) || ((mflags & P_IS_ALIVE) && reflwall (m, x, y, op)))
201     {
202     if (!QUERY_FLAG (op, FLAG_REFLECTING))
203     return;
204 root 1.6
205 root 1.9 /* Since walls don't run diagonal, if the bolt is in
206     * one of 4 main directions, it just reflects back in the
207     * opposite direction. However, if the bolt is travelling
208     * on the diagonal, it is trickier - eg, a bolt travelling
209     * northwest bounces different if it hits a north/south
210     * wall (bounces to northeast) vs an east/west (bounces
211     * to the southwest.
212     */
213     if (op->direction & 1)
214     op->direction = absdir (op->direction + 4);
215     else
216     {
217     int left, right;
218     int mflags;
219 root 1.6
220 root 1.9 /* Need to check for P_OUT_OF_MAP: if the bolt is tavelling
221     * over a corner in a tiled map, it is possible that
222     * op->direction is within an adjacent map but either
223     * op->direction-1 or op->direction+1 does not exist.
224     */
225     mflags = get_map_flags (op->map, &m, op->x + freearr_x[absdir (op->direction - 1)],
226     op->y + freearr_y[absdir (op->direction - 1)], &x, &y);
227    
228     left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));
229    
230     mflags = get_map_flags (op->map, &m, op->x + freearr_x[absdir (op->direction + 1)],
231     op->y + freearr_y[absdir (op->direction + 1)], &x, &y);
232     right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y));
233    
234     if (left == right)
235     op->direction = absdir (op->direction + 4);
236     else if (left)
237     op->direction = absdir (op->direction + 2);
238     else if (right)
239     op->direction = absdir (op->direction - 2);
240 root 1.6 }
241 root 1.25
242 root 1.9 update_turn_face (op); /* A bolt *must* be IS_TURNABLE */
243     return;
244 root 1.6 }
245 root 1.9 else
246     { /* Create a copy of this object and put it ahead */
247 root 1.25 object *tmp = op->clone ();
248 root 1.18
249 root 1.25 m->insert (tmp, x, y, op);
250 root 1.9 tmp->speed_left = -0.1;
251     /* To make up for the decrease at the top of the function */
252     tmp->duration++;
253    
254     /* New forking code. Possibly create forks of this object
255     * going off in other directions.
256     */
257     if (rndm (0, 99) < tmp->stats.Dex)
258     { /* stats.Dex % of forking */
259     forklightning (op, tmp);
260 root 1.6 }
261 root 1.25
262 root 1.9 /* In this way, the object left behind sticks on the space, but
263     * doesn't create any bolts that continue to move onward.
264     */
265     op->range = 0;
266     } /* copy object and move it along */
267     } /* if move bolt along */
268 elmex 1.1 }
269    
270     /* fire_bolt
271     * object op (cast from caster) files a bolt in dir.
272     * spob is the spell object for the bolt.
273     * we remove the magic flag - that can be derived from
274     * spob->attacktype.
275     * This function sets up the appropriate owner and skill
276     * pointers.
277     */
278 root 1.9 int
279     fire_bolt (object *op, object *caster, int dir, object *spob, object *skill)
280     {
281     object *tmp = NULL;
282     int mflags;
283 elmex 1.1
284 root 1.9 if (!spob->other_arch)
285     return 0;
286 elmex 1.1
287 root 1.9 tmp = arch_to_object (spob->other_arch);
288     if (tmp == NULL)
289     return 0;
290    
291     /* peterm: level dependency for bolts */
292     tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
293     tmp->attacktype = spob->attacktype;
294     if (spob->slaying)
295     tmp->slaying = spob->slaying;
296     tmp->range = spob->range + SP_level_range_adjust (caster, spob);
297     tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
298     tmp->stats.Dex = spob->stats.Dex;
299     tmp->stats.Con = spob->stats.Con;
300    
301     tmp->direction = dir;
302     if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
303     SET_ANIMATION (tmp, dir);
304    
305 root 1.19 tmp->set_owner (op);
306 root 1.9 set_spell_skill (op, caster, spob, tmp);
307    
308     tmp->x = op->x + DIRX (tmp);
309     tmp->y = op->y + DIRY (tmp);
310     tmp->map = op->map;
311 elmex 1.1
312 root 1.23 maptile *newmap;
313     mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
314 root 1.9 if (mflags & P_OUT_OF_MAP)
315     {
316 root 1.17 tmp->destroy ();
317 root 1.9 return 0;
318 elmex 1.1 }
319 root 1.17
320 root 1.23 tmp->map = newmap;
321    
322 root 1.9 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
323     {
324     if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
325     {
326 root 1.17 tmp->destroy ();
327 root 1.9 return 0;
328     }
329 root 1.17
330 root 1.9 tmp->x = op->x;
331     tmp->y = op->y;
332     tmp->direction = absdir (tmp->direction + 4);
333     tmp->map = op->map;
334 elmex 1.1 }
335 root 1.17
336 root 1.25 if ((tmp = tmp->insert_at (tmp, op)))
337 elmex 1.1 move_bolt (tmp);
338 root 1.17
339 root 1.9 return 1;
340 elmex 1.1 }
341    
342    
343    
344     /***************************************************************************
345     *
346     * BULLET/BALL CODE
347     *
348     ***************************************************************************/
349    
350     /* expands an explosion. op is a piece of the
351     * explosion - this expans it in the different directions.
352     * At least that is what I think this does.
353     */
354 root 1.9 void
355     explosion (object *op)
356     {
357 root 1.15 maptile *m = op->map;
358 root 1.9 int i;
359    
360 root 1.25 if (--op->duration < 0)
361 root 1.9 {
362 root 1.17 op->destroy ();
363 root 1.9 return;
364 elmex 1.1 }
365 root 1.17
366 root 1.9 hit_map (op, 0, op->attacktype, 0);
367 elmex 1.1
368 root 1.9 if (op->range > 0)
369     {
370     for (i = 1; i < 9; i++)
371     {
372     sint16 dx, dy;
373    
374     dx = op->x + freearr_x[i];
375     dy = op->y + freearr_y[i];
376 root 1.25
377 root 1.9 /* ok_to_put_more already does things like checks for walls,
378     * out of map, etc.
379     */
380     if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
381     {
382 root 1.25 object *tmp = op->clone ();
383    
384 root 1.9 tmp->state = 0;
385     tmp->speed_left = -0.21;
386     tmp->range--;
387     tmp->value = 0;
388 root 1.25
389     m->insert (tmp, dx, dy, op);
390 root 1.6 }
391     }
392 elmex 1.1 }
393     }
394    
395    
396     /* Causes an object to explode, eg, a firebullet,
397     * poison cloud ball, etc. op is the object to
398     * explode.
399     */
400 root 1.9 void
401     explode_bullet (object *op)
402 elmex 1.1 {
403 root 1.9 object *tmp, *owner;
404 elmex 1.1
405 root 1.9 if (op->other_arch == NULL)
406     {
407     LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
408 root 1.17 op->destroy ();
409 root 1.9 return;
410 elmex 1.1 }
411    
412 root 1.9 if (op->env)
413     {
414 root 1.25 object *env = object_get_env_recursive (op);
415 root 1.9 if (env->map == NULL || out_of_map (env->map, env->x, env->y))
416     {
417     LOG (llevError, "BUG: explode_bullet(): env out of map\n");
418 root 1.17 op->destroy ();
419 root 1.9 return;
420     }
421 root 1.17
422 root 1.25 op->insert_at (env, op, INS_NO_MERGE | INS_NO_WALK_ON);
423 root 1.9 }
424     else if (out_of_map (op->map, op->x, op->y))
425     {
426     LOG (llevError, "BUG: explode_bullet(): op out of map\n");
427 root 1.17 op->destroy ();
428 root 1.9 return;
429     }
430    
431     // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps
432     // NOTE: If this breaks something important: remove this. I can't think of anything
433     // bad at the moment that might happen from this.
434     if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
435     {
436 root 1.17 op->destroy ();
437 root 1.9 return;
438 elmex 1.1 }
439    
440 root 1.9 if (op->attacktype)
441     {
442     hit_map (op, 0, op->attacktype, 1);
443 root 1.14 if (op->destroyed ())
444 elmex 1.2 return;
445 elmex 1.1 }
446    
447 root 1.9 /* other_arch contains what this explodes into */
448     tmp = arch_to_object (op->other_arch);
449 elmex 1.1
450 root 1.19 tmp->set_owner (op);
451 root 1.9 tmp->skill = op->skill;
452 elmex 1.1
453 root 1.19 owner = op->owner;
454 root 1.10
455 root 1.9 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))
456     {
457 root 1.17 op->destroy ();
458 root 1.9 return;
459 elmex 1.1 }
460 root 1.10
461 root 1.9 /* special for bombs - it actually has sane values for these */
462     if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)
463     {
464     tmp->attacktype = op->attacktype;
465     tmp->range = op->range;
466     tmp->stats.dam = op->stats.dam;
467     tmp->duration = op->duration;
468     }
469     else
470     {
471     if (op->attacktype & AT_MAGIC)
472     tmp->attacktype |= AT_MAGIC;
473 root 1.25
474 root 1.9 /* Spell doc describes what is going on here */
475     tmp->stats.dam = op->dam_modifier;
476     tmp->range = op->stats.maxhp;
477     tmp->duration = op->stats.hp;
478     /* Used for spell tracking - just need a unique val for this spell -
479     * the count of the parent should work fine.
480     */
481     tmp->stats.maxhp = op->count;
482     }
483    
484     /* Set direction of cone explosion */
485     if (tmp->type == SPELL_EFFECT && tmp->subtype == SP_CONE)
486     tmp->stats.sp = op->direction;
487    
488     /* Prevent recursion */
489     op->move_on = 0;
490    
491 root 1.25 tmp->insert_at (op, op);
492 root 1.9 /* remove the firebullet */
493 root 1.25 op->destroy ();
494 elmex 1.1 }
495    
496     /* checks to see what op should do, given the space it is on
497     * (eg, explode, damage player, etc)
498     */
499 root 1.9 void
500     check_bullet (object *op)
501 elmex 1.1 {
502 root 1.9 object *tmp;
503     int dam, mflags;
504 root 1.15 maptile *m;
505 root 1.9 sint16 sx, sy;
506 elmex 1.1
507 root 1.9 mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy);
508 elmex 1.1
509 root 1.9 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
510     return;
511 elmex 1.1
512 root 1.9 if (op->other_arch)
513     {
514     /* explode object will also remove op */
515     explode_bullet (op);
516     return;
517 elmex 1.1 }
518    
519 root 1.9 /* If nothing alive on this space, no reason to do anything further */
520     if (!(mflags & P_IS_ALIVE))
521     return;
522 elmex 1.1
523 root 1.21 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
524 elmex 1.1 {
525 root 1.9 if (QUERY_FLAG (tmp, FLAG_ALIVE))
526     {
527     dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
528 root 1.14 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
529 elmex 1.1 {
530 root 1.9 if (!QUERY_FLAG (op, FLAG_REMOVED))
531     {
532 root 1.17 op->destroy ();
533 root 1.9 return;
534 root 1.6 }
535 elmex 1.1 }
536     }
537     }
538     }
539    
540     /* Basically, we move 'op' one square, and if it hits something,
541     * call check_bullet.
542     * This function is only applicable to bullets, but not to all
543     * fired arches (eg, bolts).
544     */
545 root 1.9 void
546     move_bullet (object *op)
547 elmex 1.1 {
548 root 1.9 sint16 new_x, new_y;
549     int mflags;
550 root 1.15 maptile *m;
551 elmex 1.1
552     #if 0
553 root 1.9 /* We need a better general purpose way to do this */
554 elmex 1.1
555 root 1.9 /* peterm: added to make comet leave a trail of burnouts
556     it's an unadulterated hack, but the effect is cool. */
557     if (op->stats.sp == SP_METEOR)
558     {
559     replace_insert_ob_in_map ("fire_trail", op);
560 root 1.14 if (op->destroyed ())
561 elmex 1.1 return;
562 root 1.9 } /* end addition. */
563 elmex 1.1 #endif
564    
565 root 1.9 /* Reached the end of its life - remove it */
566     if (--op->range <= 0)
567     {
568     if (op->other_arch)
569 root 1.17 explode_bullet (op);
570 root 1.9 else
571 root 1.17 op->destroy ();
572    
573 root 1.9 return;
574 elmex 1.1 }
575    
576 root 1.9 new_x = op->x + DIRX (op);
577     new_y = op->y + DIRY (op);
578     m = op->map;
579     mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
580    
581     if (mflags & P_OUT_OF_MAP)
582     {
583 root 1.17 op->destroy ();
584 root 1.9 return;
585 elmex 1.1 }
586    
587 root 1.9 if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))
588     {
589     if (op->other_arch)
590 root 1.17 explode_bullet (op);
591 root 1.9 else
592 root 1.17 op->destroy ();
593    
594 root 1.9 return;
595 elmex 1.1 }
596    
597 root 1.25 if (!(op = m->insert (op, new_x, new_y, op)))
598 root 1.9 return;
599 elmex 1.1
600 root 1.9 if (reflwall (op->map, op->x, op->y, op))
601     {
602     op->direction = absdir (op->direction + 4);
603     update_turn_face (op);
604     }
605     else
606 root 1.23 check_bullet (op);
607 elmex 1.1 }
608    
609    
610    
611    
612     /* fire_bullet
613     * object op (cast from caster) files a bolt in dir.
614     * spob is the spell object for the bolt.
615     * we remove the magic flag - that can be derived from
616     * spob->attacktype.
617     * This function sets up the appropriate owner and skill
618     * pointers.
619     */
620    
621 root 1.9 int
622     fire_bullet (object *op, object *caster, int dir, object *spob)
623     {
624     object *tmp = NULL;
625     int mflags;
626 elmex 1.1
627 root 1.9 if (!spob->other_arch)
628     return 0;
629 elmex 1.1
630 root 1.9 tmp = arch_to_object (spob->other_arch);
631     if (tmp == NULL)
632     return 0;
633    
634     /* peterm: level dependency for bolts */
635     tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
636     tmp->attacktype = spob->attacktype;
637     if (spob->slaying)
638     tmp->slaying = spob->slaying;
639    
640     tmp->range = 50;
641    
642     /* Need to store duration/range for the ball to use */
643     tmp->stats.hp = spob->duration + SP_level_duration_adjust (caster, spob);
644     tmp->stats.maxhp = spob->range + SP_level_range_adjust (caster, spob);
645     tmp->dam_modifier = spob->stats.food + SP_level_dam_adjust (caster, spob);
646    
647     tmp->direction = dir;
648     if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
649     SET_ANIMATION (tmp, dir);
650    
651 root 1.19 tmp->set_owner (op);
652 root 1.9 set_spell_skill (op, caster, spob, tmp);
653    
654     tmp->x = op->x + freearr_x[dir];
655     tmp->y = op->y + freearr_y[dir];
656     tmp->map = op->map;
657 elmex 1.1
658 root 1.23 maptile *newmap;
659     mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
660 root 1.9 if (mflags & P_OUT_OF_MAP)
661     {
662 root 1.17 tmp->destroy ();
663 root 1.9 return 0;
664 elmex 1.1 }
665 root 1.17
666 root 1.23 tmp->map = newmap;
667    
668 root 1.9 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
669     {
670     if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
671     {
672 root 1.17 tmp->destroy ();
673 root 1.9 return 0;
674     }
675 root 1.17
676 root 1.9 tmp->x = op->x;
677     tmp->y = op->y;
678     tmp->direction = absdir (tmp->direction + 4);
679     tmp->map = op->map;
680 elmex 1.1 }
681 root 1.17
682 root 1.25 if ((tmp = tmp->insert_at (tmp, op)))
683 root 1.17 check_bullet (tmp);
684    
685 root 1.9 return 1;
686 elmex 1.1 }
687    
688    
689    
690    
691     /*****************************************************************************
692     *
693     * CONE RELATED FUNCTIONS
694     *
695     *****************************************************************************/
696    
697    
698     /* drops an object based on what is in the cone's "other_arch" */
699 root 1.9 void
700     cone_drop (object *op)
701     {
702     object *new_ob = arch_to_object (op->other_arch);
703 elmex 1.1
704 root 1.9 new_ob->level = op->level;
705 root 1.19 new_ob->set_owner (op->owner);
706 root 1.9
707     /* preserve skill ownership */
708     if (op->skill && op->skill != new_ob->skill)
709 root 1.25 new_ob->skill = op->skill;
710 root 1.9
711 root 1.25 new_ob->insert_at (op, op);
712 elmex 1.1 }
713    
714     /* move_cone: causes cone object 'op' to move a space/hit creatures */
715    
716 root 1.9 void
717     move_cone (object *op)
718     {
719     int i;
720    
721     /* if no map then hit_map will crash so just ignore object */
722     if (!op->map)
723     {
724     LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
725 root 1.24 op->set_speed (0);
726 root 1.9 return;
727 elmex 1.1 }
728    
729 root 1.9 /* lava saves it's life, but not yours :) */
730     if (QUERY_FLAG (op, FLAG_LIFESAVE))
731     {
732     hit_map (op, 0, op->attacktype, 0);
733     return;
734 elmex 1.1 }
735    
736     #if 0
737 root 1.9 /* Disable this - enabling it makes monsters easier, as
738     * when their cone dies when they die.
739     */
740     /* If no owner left, the spell dies out. */
741 root 1.19 if (op->owner == NULL)
742 root 1.9 {
743 root 1.17 op->destroy ();
744 root 1.9 return;
745 elmex 1.1 }
746     #endif
747    
748 root 1.9 hit_map (op, 0, op->attacktype, 0);
749 elmex 1.1
750 root 1.9 /* Check to see if we should push anything.
751     * Spell objects with weight push whatever they encounter to some
752     * degree.
753     */
754     if (op->weight)
755     check_spell_knockback (op);
756 elmex 1.1
757 root 1.14 if (op->destroyed ())
758 root 1.9 return;
759 elmex 1.1
760 root 1.9 if ((op->duration--) < 0)
761     {
762 root 1.17 op->destroy ();
763 root 1.9 return;
764     }
765     /* Object has hit maximum range, so don't have it move
766     * any further. When the duration above expires,
767     * then the object will get removed.
768     */
769     if (--op->range < 0)
770     {
771     op->range = 0; /* just so it doesn't wrap */
772     return;
773 elmex 1.1 }
774    
775 root 1.9 for (i = -1; i < 2; i++)
776     {
777     sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
778    
779     if (ok_to_put_more (op->map, x, y, op, op->attacktype))
780     {
781 root 1.18 object *tmp = op->clone ();
782 root 1.9
783     tmp->duration = op->duration + 1;
784    
785     /* Use for spell tracking - see ok_to_put_more() */
786     tmp->stats.maxhp = op->stats.maxhp;
787 root 1.25
788     op->map->insert (tmp, x, y, op);
789    
790 root 1.9 if (tmp->other_arch)
791     cone_drop (tmp);
792 root 1.6 }
793 elmex 1.1 }
794     }
795    
796     /* cast_cone: casts a cone spell.
797     * op: person firing the object.
798     * caster: object casting the spell.
799     * dir: direction to fire in.
800     * spell: spell that is being fired. It uses other_arch for the archetype
801     * to fire.
802     * returns 0 on failure, 1 on success.
803     */
804 root 1.9 int
805     cast_cone (object *op, object *caster, int dir, object *spell)
806 elmex 1.1 {
807 root 1.9 object *tmp;
808     int i, success = 0, range_min = -1, range_max = 1;
809 root 1.15 maptile *m;
810 root 1.9 sint16 sx, sy;
811     MoveType movetype;
812    
813     if (!spell->other_arch)
814     return 0;
815    
816     if (op->type == PLAYER && QUERY_FLAG (op, FLAG_UNDEAD) && op->attacktype & AT_TURN_UNDEAD)
817     {
818     new_draw_info (NDI_UNIQUE, 0, op, "Your undead nature prevents you from turning undead!");
819     return 0;
820     }
821    
822     if (!dir)
823     {
824     range_min = 0;
825     range_max = 8;
826 elmex 1.1 }
827    
828 root 1.9 /* Need to know what the movetype of the object we are about
829     * to create is, so we can know if the space we are about to
830     * insert it into is blocked.
831     */
832     movetype = spell->other_arch->clone.move_type;
833 root 1.6
834 root 1.9 for (i = range_min; i <= range_max; i++)
835     {
836     sint16 x, y, d;
837 elmex 1.1
838 root 1.9 /* We can't use absdir here, because it never returns
839     * 0. If this is a rune, we want to hit the person on top
840     * of the trap (d==0). If it is not a rune, then we don't want
841     * to hit that person.
842     */
843     d = dir + i;
844     while (d < 0)
845     d += 8;
846     while (d > 8)
847     d -= 8;
848    
849     /* If it's not a rune, we don't want to blast the caster.
850     * In that case, we have to see - if dir is specified,
851     * turn this into direction 8. If dir is not specified (all
852     * direction) skip - otherwise, one line would do more damage
853     * becase 0 direction will go through 9 directions - necessary
854     * for the rune code.
855     */
856     if (caster->type != RUNE && d == 0)
857     {
858     if (dir != 0)
859     d = 8;
860     else
861 root 1.6 continue;
862 root 1.9 }
863 elmex 1.1
864 root 1.9 x = op->x + freearr_x[d];
865     y = op->y + freearr_y[d];
866 root 1.6
867 root 1.9 if (get_map_flags (op->map, &m, x, y, &sx, &sy) & P_OUT_OF_MAP)
868     continue;
869 root 1.6
870 root 1.9 if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
871     continue;
872 root 1.6
873 root 1.9 success = 1;
874     tmp = arch_to_object (spell->other_arch);
875 root 1.19 tmp->set_owner (op);
876 root 1.9 set_spell_skill (op, caster, spell, tmp);
877     tmp->level = caster_level (caster, spell);
878     tmp->attacktype = spell->attacktype;
879    
880     /* holy word stuff */
881     if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
882 root 1.10 if (!tailor_god_spell (tmp, op))
883     return 0;
884 root 1.6
885 root 1.9 if (dir)
886     tmp->stats.sp = dir;
887     else
888     tmp->stats.sp = i;
889    
890     tmp->range = spell->range + SP_level_range_adjust (caster, spell);
891    
892     /* If casting it in all directions, it doesn't go as far */
893     if (dir == 0)
894     {
895     tmp->range /= 4;
896     if (tmp->range < 2 && spell->range >= 2)
897     tmp->range = 2;
898     }
899 root 1.10
900 root 1.9 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
901     tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
902    
903     /* Special bonus for fear attacks */
904     if (tmp->attacktype & AT_FEAR)
905     {
906     if (caster->type == PLAYER)
907     tmp->duration += fear_bonus[caster->stats.Cha];
908     else
909     tmp->duration += caster->level / 3;
910     }
911 root 1.10
912 root 1.9 if (tmp->attacktype & (AT_HOLYWORD | AT_TURN_UNDEAD))
913     {
914     if (caster->type == PLAYER)
915     tmp->duration += turn_bonus[caster->stats.Wis] / 5;
916     else
917     tmp->duration += caster->level / 3;
918 root 1.6 }
919    
920 root 1.9 if (!(tmp->move_type & MOVE_FLY_LOW))
921     LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n", &spell->other_arch->name);
922    
923     if (!tmp->move_on && tmp->stats.dam)
924 root 1.25 LOG (llevDebug, "cast_cone(): arch %s doesn't have move_on set\n", &spell->other_arch->name);
925 root 1.10
926 root 1.25 m->insert (tmp, sx, sy, op);
927 root 1.9
928     /* This is used for tracking spells so that one effect doesn't hit
929     * a single space too many times.
930     */
931     tmp->stats.maxhp = tmp->count;
932 root 1.6
933 root 1.9 if (tmp->other_arch)
934     cone_drop (tmp);
935 elmex 1.1 }
936 root 1.10
937 root 1.9 return success;
938 elmex 1.1 }
939    
940     /****************************************************************************
941     *
942     * BOMB related code
943     *
944     ****************************************************************************/
945    
946    
947     /* This handles an exploding bomb.
948     * op is the original bomb object.
949     */
950 root 1.9 void
951     animate_bomb (object *op)
952     {
953     int i;
954     object *env, *tmp;
955 elmex 1.1
956 root 1.9 if (op->state != NUM_ANIMATIONS (op) - 1)
957     return;
958 elmex 1.1
959 root 1.9 env = object_get_env_recursive (op);
960 elmex 1.1
961 root 1.9 if (op->env)
962     {
963     if (env->map == NULL)
964     return;
965 elmex 1.1
966 root 1.9 if (env->type == PLAYER)
967     esrv_del_item (env->contr, op->count);
968 elmex 1.1
969 root 1.25 if (!(op = op->insert_at (env, op)))
970 root 1.9 return;
971 elmex 1.1 }
972    
973 root 1.9 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
974     // on a safe map. I don't like this special casing, but it seems to be neccessary
975     // as bombs can be carried.
976     if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
977     {
978 root 1.17 op->destroy ();
979 root 1.9 return;
980     }
981 elmex 1.3
982 root 1.9 /* This copies a lot of the code from the fire bullet,
983     * but using the cast_bullet isn't really feasible,
984     * so just set up the appropriate values.
985     */
986 root 1.25 if (archetype *at = archetype::find (SPLINT))
987 root 1.9 {
988     for (i = 1; i < 9; i++)
989     {
990     if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
991     continue;
992 root 1.25
993 root 1.9 tmp = arch_to_object (at);
994     tmp->direction = i;
995     tmp->range = op->range;
996     tmp->stats.dam = op->stats.dam;
997     tmp->duration = op->duration;
998     tmp->attacktype = op->attacktype;
999 root 1.19 tmp->set_owner (op);
1000 root 1.9 if (op->skill && op->skill != tmp->skill)
1001 root 1.25 tmp->skill = op->skill;
1002    
1003 root 1.9 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
1004     SET_ANIMATION (tmp, i);
1005 root 1.25
1006     op->map->insert (tmp, op->x + freearr_x[i], op->y + freearr_x[i], op);
1007 root 1.9 move_bullet (tmp);
1008 root 1.6 }
1009 elmex 1.1 }
1010    
1011 root 1.9 explode_bullet (op);
1012 elmex 1.1 }
1013    
1014 root 1.9 int
1015     create_bomb (object *op, object *caster, int dir, object *spell)
1016     {
1017 elmex 1.1
1018 root 1.9 object *tmp;
1019     int mflags;
1020     sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1021 root 1.15 maptile *m;
1022 elmex 1.1
1023 root 1.9 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
1024     if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1025     {
1026     new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1027     return 0;
1028 elmex 1.1 }
1029 root 1.9 tmp = arch_to_object (spell->other_arch);
1030 elmex 1.1
1031 root 1.9 /* level dependencies for bomb */
1032     tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1033     tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1034     tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
1035     tmp->attacktype = spell->attacktype;
1036    
1037 root 1.19 tmp->set_owner (op);
1038 root 1.9 set_spell_skill (op, caster, spell, tmp);
1039 root 1.25
1040     m->insert (tmp, dx, dy, op);
1041 root 1.9 return 1;
1042 elmex 1.1 }
1043    
1044     /****************************************************************************
1045     *
1046     * smite related spell code.
1047     *
1048     ****************************************************************************/
1049    
1050     /* get_pointed_target() - this is used by finger of death
1051     * and the 'smite' spells. Returns the pointer to the first
1052     * monster in the direction which is pointed to by op. b.t.
1053     * op is the caster - really only used for the source location.
1054     * dir is the direction to look in.
1055     * range is how far out to look.
1056     * type is the type of spell - either SPELL_MANA or SPELL_GRACE.
1057     * this info is used for blocked magic/unholy spaces.
1058     */
1059 root 1.9
1060     object *
1061     get_pointed_target (object *op, int dir, int range, int type)
1062     {
1063     object *target;
1064     sint16 x, y;
1065     int dist, mflags;
1066 root 1.15 maptile *mp;
1067 root 1.9
1068     if (dir == 0)
1069     return NULL;
1070    
1071     for (dist = 1; dist < range; dist++)
1072     {
1073     x = op->x + freearr_x[dir] * dist;
1074     y = op->y + freearr_y[dir] * dist;
1075     mp = op->map;
1076     mflags = get_map_flags (op->map, &mp, x, y, &x, &y);
1077    
1078     if (mflags & P_OUT_OF_MAP)
1079     return NULL;
1080     if ((type & SPELL_MANA) && (mflags & P_NO_MAGIC))
1081     return NULL;
1082     if ((type & SPELL_GRACE) && (mflags & P_NO_CLERIC))
1083     return NULL;
1084     if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1085     return NULL;
1086    
1087     if (mflags & P_IS_ALIVE)
1088     {
1089 root 1.21 for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1090 root 1.9 {
1091     if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER))
1092     {
1093     return target;
1094 root 1.6 }
1095     }
1096     }
1097 elmex 1.1 }
1098 root 1.9 return NULL;
1099 elmex 1.1 }
1100    
1101    
1102     /* cast_smite_arch() - the priest points to a creature and causes
1103     * a 'godly curse' to decend.
1104     * usual params -
1105     * op = player
1106     * caster = object casting the spell.
1107     * dir = direction being cast
1108     * spell = spell object
1109     */
1110    
1111 root 1.9 int
1112     cast_smite_spell (object *op, object *caster, int dir, object *spell)
1113     {
1114     object *effect, *target;
1115     object *god = find_god (determine_god (op));
1116     int range;
1117    
1118     range = spell->range + SP_level_range_adjust (caster, spell);
1119     target = get_pointed_target (op, dir, 50, spell->stats.grace ? SPELL_GRACE : SPELL_MANA);
1120    
1121     /* Bunch of conditions for casting this spell. Note that only
1122     * require a god if this is a cleric spell (requires grace).
1123     * This makes this spell much more general purpose - it can be used
1124     * by wizards also, which is good, because I think this is a very
1125     * interesting spell.
1126     * if it is a cleric spell, you need a god, and the creature
1127     * can't be friendly to your god.
1128     */
1129    
1130     if (!target || QUERY_FLAG (target, FLAG_REFL_SPELL)
1131     || (!god && spell->stats.grace)
1132     || (target->title && god && !strcmp (target->title, god->name)) || (target->race && god && strstr (target->race, god->race)))
1133     {
1134     new_draw_info (NDI_UNIQUE, 0, op, "Your request is unheeded.");
1135     return 0;
1136     }
1137    
1138     if (spell->other_arch)
1139     effect = arch_to_object (spell->other_arch);
1140     else
1141     return 0;
1142    
1143     /* tailor the effect by priest level and worshipped God */
1144     effect->level = caster_level (caster, spell);
1145     effect->attacktype = spell->attacktype;
1146     if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1147     {
1148     if (tailor_god_spell (effect, op))
1149     new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));
1150     else
1151     {
1152     new_draw_info (NDI_UNIQUE, 0, op, "Your request is ignored.");
1153     return 0;
1154     }
1155 elmex 1.1 }
1156    
1157 root 1.9 /* size of the area of destruction */
1158     effect->range = spell->range + SP_level_range_adjust (caster, spell);
1159     effect->duration = spell->duration + SP_level_range_adjust (caster, spell);
1160    
1161     if (effect->attacktype & AT_DEATH)
1162     {
1163     effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1164 elmex 1.1
1165 root 1.9 /* casting death spells at undead isn't a good thing */
1166 root 1.20 if (QUERY_FLAG (target, FLAG_UNDEAD))
1167 root 1.9 {
1168     if (random_roll (0, 2, op, PREFER_LOW))
1169     {
1170     new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1171     effect->x = op->x;
1172     effect->y = op->y;
1173     }
1174     else
1175     {
1176     new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1177     target->stats.hp = target->stats.maxhp * 2;
1178 root 1.17 effect->destroy ();
1179 root 1.9 return 0;
1180 root 1.6 }
1181     }
1182 elmex 1.1 }
1183 root 1.9 else
1184     {
1185     /* how much woe to inflict :) */
1186     effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1187     }
1188    
1189 root 1.19 effect->set_owner (op);
1190 root 1.9 set_spell_skill (op, caster, spell, effect);
1191    
1192     /* ok, tell it where to be, and insert! */
1193 root 1.25 effect->insert_at (target, op);
1194 elmex 1.1
1195 root 1.9 return 1;
1196 elmex 1.1 }
1197    
1198    
1199     /****************************************************************************
1200     *
1201     * MAGIC MISSILE code.
1202     * note that the fire_bullet is used to fire the missile. The
1203     * code here is just to move the missile.
1204     ****************************************************************************/
1205    
1206     /* op is a missile that needs to be moved */
1207 root 1.9 void
1208     move_missile (object *op)
1209     {
1210     int i, mflags;
1211     object *owner;
1212     sint16 new_x, new_y;
1213 root 1.15 maptile *m;
1214 root 1.9
1215     if (op->range-- <= 0)
1216     {
1217 root 1.17 op->destroy ();
1218 root 1.9 return;
1219 elmex 1.1 }
1220    
1221 root 1.19 owner = op->owner;
1222 elmex 1.1 #if 0
1223 root 1.9 /* It'd make things nastier if this wasn't here - spells cast by
1224     * monster that are then killed would continue to survive
1225     */
1226     if (owner == NULL)
1227     {
1228 root 1.17 op->destroy ();
1229 root 1.9 return;
1230 elmex 1.1 }
1231     #endif
1232    
1233 root 1.9 new_x = op->x + DIRX (op);
1234     new_y = op->y + DIRY (op);
1235    
1236     mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1237 elmex 1.1
1238 root 1.9 if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1239     {
1240     hit_map (op, op->direction, AT_MAGIC, 1);
1241     /* Basically, missile only hits one thing then goes away.
1242     * we need to remove it if someone hasn't already done so.
1243     */
1244 root 1.14 if (!op->destroyed ())
1245 root 1.17 op->destroy ();
1246 root 1.14
1247 root 1.9 return;
1248 elmex 1.1 }
1249    
1250 root 1.16 op->remove ();
1251 root 1.14
1252 root 1.9 if (!op->direction || (mflags & P_OUT_OF_MAP))
1253     {
1254 root 1.17 op->destroy ();
1255 root 1.9 return;
1256 elmex 1.1 }
1257 root 1.14
1258 root 1.25 i = spell_find_dir (m, new_x, new_y, op->owner);
1259 root 1.9 if (i > 0 && i != op->direction)
1260     {
1261     op->direction = i;
1262     SET_ANIMATION (op, op->direction);
1263 elmex 1.1 }
1264 root 1.14
1265 root 1.25 m->insert (op, new_x, new_y, op);
1266 elmex 1.1 }
1267    
1268     /****************************************************************************
1269     * Destruction
1270     ****************************************************************************/
1271 root 1.9
1272 elmex 1.1 /* make_object_glow() - currently only makes living objects glow.
1273     * we do this by creating a force and inserting it in the
1274     * object. if time is 0, the object glows permanently. To truely
1275     * make this work for non-living objects, we would have to
1276     * give them the capability to have an inventory. b.t.
1277     */
1278    
1279 root 1.9 int
1280     make_object_glow (object *op, int radius, int time)
1281     {
1282     object *tmp;
1283    
1284     /* some things are unaffected... */
1285     if (op->path_denied & PATH_LIGHT)
1286     return 0;
1287    
1288     tmp = get_archetype (FORCE_NAME);
1289     tmp->speed = 0.01;
1290     tmp->stats.food = time;
1291     SET_FLAG (tmp, FLAG_IS_USED_UP);
1292     tmp->glow_radius = radius;
1293     if (tmp->glow_radius > MAX_LIGHT_RADII)
1294     tmp->glow_radius = MAX_LIGHT_RADII;
1295    
1296     tmp->x = op->x;
1297     tmp->y = op->y;
1298     if (tmp->speed < MIN_ACTIVE_SPEED)
1299     tmp->speed = MIN_ACTIVE_SPEED; /* safety */
1300     tmp = insert_ob_in_ob (tmp, op);
1301     if (tmp->glow_radius > op->glow_radius)
1302     op->glow_radius = tmp->glow_radius;
1303    
1304     if (!tmp->env || op != tmp->env)
1305     {
1306     LOG (llevError, "make_object_glow() failed to insert glowing force in %s\n", &op->name);
1307     return 0;
1308     }
1309     return 1;
1310     }
1311    
1312 elmex 1.1
1313    
1314    
1315 root 1.9 int
1316     cast_destruction (object *op, object *caster, object *spell_ob)
1317     {
1318     int i, j, range, mflags, friendly = 0, dam, dur;
1319     sint16 sx, sy;
1320 root 1.15 maptile *m;
1321 root 1.9 object *tmp;
1322     const char *skill;
1323    
1324     range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1325     dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
1326     dur = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1327     if (QUERY_FLAG (op, FLAG_FRIENDLY) || op->type == PLAYER)
1328     friendly = 1;
1329    
1330     /* destruction doesn't use another spell object, so we need
1331     * update op's skill pointer so that exp is properly awarded.
1332     * We do some shortcuts here - since this is just temporary
1333     * and we'll reset the values back, we don't need to go through
1334     * the full share string/free_string route.
1335     */
1336     skill = op->skill;
1337     if (caster == op)
1338     op->skill = spell_ob->skill;
1339     else if (caster->skill)
1340     op->skill = caster->skill;
1341     else
1342     op->skill = NULL;
1343 elmex 1.1
1344 root 1.9 change_skill (op, find_skill_by_name (op, op->skill), 1);
1345 elmex 1.1
1346 root 1.9 for (i = -range; i < range; i++)
1347     {
1348     for (j = -range; j < range; j++)
1349     {
1350     m = op->map;
1351     sx = op->x + i;
1352     sy = op->y + j;
1353 root 1.25
1354 root 1.9 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1355     if (mflags & P_OUT_OF_MAP)
1356     continue;
1357 root 1.25
1358 root 1.9 if (mflags & P_IS_ALIVE)
1359     {
1360 root 1.21 for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
1361 root 1.25 if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1362     break;
1363    
1364 root 1.9 if (tmp)
1365     {
1366     if (tmp->head)
1367     tmp = tmp->head;
1368    
1369     if ((friendly && !QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->type != PLAYER) ||
1370     (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
1371     {
1372     if (spell_ob->subtype == SP_DESTRUCTION)
1373     {
1374     hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1375     if (spell_ob->other_arch)
1376 root 1.25 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1377 root 1.6 }
1378 root 1.9 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1379     {
1380     if (make_object_glow (tmp, 1, dur) && spell_ob->other_arch)
1381 root 1.25 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1382 root 1.6 }
1383     }
1384     }
1385     }
1386     }
1387 elmex 1.1 }
1388 root 1.25
1389 root 1.9 op->skill = skill;
1390     return 1;
1391 elmex 1.1 }
1392    
1393     /***************************************************************************
1394     *
1395     * CURSE
1396     *
1397     ***************************************************************************/
1398    
1399 root 1.9 int
1400     cast_curse (object *op, object *caster, object *spell_ob, int dir)
1401     {
1402     object *god = find_god (determine_god (op));
1403     object *tmp, *force;
1404    
1405     tmp = get_pointed_target (op, (dir == 0) ? op->direction : dir, spell_ob->range, SPELL_GRACE);
1406     if (!tmp)
1407     {
1408     new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");
1409     return 0;
1410 elmex 1.1 }
1411    
1412 root 1.9 /* If we've already got a force of this type, don't add a new one. */
1413     for (force = tmp->inv; force != NULL; force = force->below)
1414     {
1415     if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
1416     {
1417     if (force->name == spell_ob->name)
1418     {
1419     break;
1420 root 1.6 }
1421 root 1.9 else if (spell_ob->race && spell_ob->race == force->name)
1422     {
1423     new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &force->name_pl);
1424     return 0;
1425 root 1.6 }
1426     }
1427 elmex 1.1 }
1428    
1429 root 1.9 if (force == NULL)
1430     {
1431     force = get_archetype (FORCE_NAME);
1432     force->subtype = FORCE_CHANGE_ABILITY;
1433     if (spell_ob->race)
1434     force->name = spell_ob->race;
1435     else
1436     force->name = spell_ob->name;
1437 root 1.7
1438 root 1.9 force->name_pl = spell_ob->name;
1439 elmex 1.1
1440 root 1.9 }
1441     else
1442     {
1443     int duration;
1444    
1445     duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1446     if (duration > force->duration)
1447     {
1448     force->duration = duration;
1449     new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1450     }
1451     else
1452     {
1453     new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1454     }
1455     return 1;
1456     }
1457     force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1458     force->speed = 1.0;
1459     force->speed_left = -1.0;
1460     SET_FLAG (force, FLAG_APPLIED);
1461 elmex 1.1
1462 root 1.9 if (god)
1463     {
1464     if (spell_ob->last_grace)
1465     force->path_repelled = god->path_repelled;
1466     if (spell_ob->last_grace)
1467     force->path_denied = god->path_denied;
1468     new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are a victim of %s's curse!", &god->name);
1469     }
1470     else
1471     new_draw_info (NDI_UNIQUE, 0, op, "Your curse seems empty.");
1472    
1473    
1474     if (tmp != op && op->type == PLAYER)
1475     new_draw_info_format (NDI_UNIQUE, 0, op, "You curse %s!", &tmp->name);
1476    
1477     force->stats.ac = spell_ob->stats.ac;
1478     force->stats.wc = spell_ob->stats.wc;
1479    
1480     change_abil (tmp, force); /* Mostly to display any messages */
1481     insert_ob_in_ob (force, tmp);
1482 root 1.22 tmp->update_stats ();
1483 root 1.9 return 1;
1484 elmex 1.1
1485     }
1486    
1487    
1488     /**********************************************************************
1489     * mood change
1490     * Arguably, this may or may not be an attack spell. But since it
1491     * effects monsters, it seems best to put it into this file
1492     ***********************************************************************/
1493    
1494     /* This covers the various spells that change the moods of monsters -
1495     * makes them angry, peacful, friendly, etc.
1496     */
1497 root 1.9 int
1498     mood_change (object *op, object *caster, object *spell)
1499     {
1500     object *tmp, *god, *head;
1501     int done_one, range, mflags, level, at, best_at;
1502     sint16 x, y, nx, ny;
1503 root 1.15 maptile *m;
1504 root 1.9 const char *race;
1505    
1506     /* We precompute some values here so that we don't have to keep
1507     * doing it over and over again.
1508     */
1509     god = find_god (determine_god (op));
1510     level = caster_level (caster, spell);
1511     range = spell->range + SP_level_range_adjust (caster, spell);
1512    
1513     /* On the bright side, no monster should ever have a race of GOD_...
1514     * so even if the player doesn't worship a god, if race=GOD_.., it
1515     * won't ever match anything.
1516     */
1517     if (!spell->race)
1518     race = NULL;
1519     else if (god && !strcmp (spell->race, "GOD_SLAYING"))
1520     race = god->slaying;
1521     else if (god && !strcmp (spell->race, "GOD_FRIEND"))
1522     race = god->race;
1523     else
1524     race = spell->race;
1525 elmex 1.1
1526    
1527 root 1.9 for (x = op->x - range; x <= op->x + range; x++)
1528     for (y = op->y - range; y <= op->y + range; y++)
1529     {
1530 elmex 1.1
1531 root 1.9 done_one = 0;
1532     m = op->map;
1533     nx = x;
1534     ny = y;
1535     mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1536     if (mflags & P_OUT_OF_MAP)
1537     continue;
1538    
1539     /* If there is nothing living on this space, no need to go further */
1540     if (!(mflags & P_IS_ALIVE))
1541     continue;
1542 elmex 1.1
1543 root 1.21 for (tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)
1544 root 1.9 if (QUERY_FLAG (tmp, FLAG_MONSTER))
1545     break;
1546 root 1.6
1547 root 1.9 /* There can be living objects that are not monsters */
1548     if (!tmp || tmp->type == PLAYER)
1549     continue;
1550    
1551     /* Only the head has meaningful data, so resolve to that */
1552     if (tmp->head)
1553     head = tmp->head;
1554     else
1555     head = tmp;
1556 root 1.6
1557 root 1.9 /* Make sure the race is OK. Likewise, only effect undead if spell specifically allows it */
1558     if (race && head->race && !strstr (race, head->race))
1559     continue;
1560     if (QUERY_FLAG (head, FLAG_UNDEAD) && !QUERY_FLAG (spell, FLAG_UNDEAD))
1561     continue;
1562    
1563     /* Now do a bunch of stuff related to saving throws */
1564     best_at = -1;
1565     if (spell->attacktype)
1566     {
1567     for (at = 0; at < NROFATTACKS; at++)
1568     if (spell->attacktype & (1 << at))
1569     if (best_at == -1 || head->resist[at] > head->resist[best_at])
1570     best_at = at;
1571 elmex 1.1
1572 root 1.9 if (best_at == -1)
1573     at = 0;
1574     else
1575     {
1576     if (head->resist[best_at] == 100)
1577     continue;
1578     else
1579     at = head->resist[best_at] / 5;
1580     }
1581     at -= level / 5;
1582     if (did_make_save (head, head->level, at))
1583     continue;
1584     }
1585     else /* spell->attacktype */
1586     /*
1587     Spell has no attacktype (charm & such), so we'll have a specific saving:
1588     * if spell level < monster level, no go
1589     * else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1590    
1591     The chance will then be in the range [20-70] percent, not too bad.
1592    
1593     This is required to fix the 'charm monster' abuse, where a player level 1 can
1594     charm a level 125 monster...
1595    
1596     Ryo, august 14th
1597     */
1598     {
1599     if (head->level > level)
1600     continue;
1601     if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))
1602     /* Failed, no effect */
1603     continue;
1604     }
1605    
1606     /* Done with saving throw. Now start effecting the monster */
1607    
1608     /* aggravation */
1609     if (QUERY_FLAG (spell, FLAG_MONSTER))
1610     {
1611     CLEAR_FLAG (head, FLAG_SLEEP);
1612     if (QUERY_FLAG (head, FLAG_FRIENDLY))
1613     remove_friendly_object (head);
1614    
1615     done_one = 1;
1616     head->enemy = op;
1617     }
1618    
1619     /* calm monsters */
1620     if (QUERY_FLAG (spell, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (head, FLAG_UNAGGRESSIVE))
1621     {
1622     SET_FLAG (head, FLAG_UNAGGRESSIVE);
1623     head->enemy = NULL;
1624     done_one = 1;
1625     }
1626    
1627     /* berserk monsters */
1628     if (QUERY_FLAG (spell, FLAG_BERSERK) && !QUERY_FLAG (head, FLAG_BERSERK))
1629     {
1630     SET_FLAG (head, FLAG_BERSERK);
1631     done_one = 1;
1632     }
1633     /* charm */
1634     if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
1635     {
1636     SET_FLAG (head, FLAG_FRIENDLY);
1637     /* Prevent uncontolled outbreaks of self replicating monsters.
1638     Typical use case is charm, go somwhere, use aggravation to make hostile.
1639     This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1640     CLEAR_FLAG (head, FLAG_GENERATOR);
1641 root 1.19 head->set_owner (op);
1642 root 1.9 set_spell_skill (op, caster, spell, head);
1643     add_friendly_object (head);
1644     head->attack_movement = PETMOVE;
1645     done_one = 1;
1646     change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
1647     head->stats.exp = 0;
1648     }
1649    
1650     /* If a monster was effected, put an effect in */
1651     if (done_one && spell->other_arch)
1652 root 1.25 m->insert (arch_to_object (spell->other_arch), nx, ny, op);
1653 root 1.9 } /* for y */
1654 elmex 1.1
1655 root 1.9 return 1;
1656 elmex 1.1 }
1657    
1658    
1659     /* Move_ball_spell: This handles ball type spells that just sort of wander
1660     * about. was called move_ball_lightning, but since more than the ball
1661     * lightning spell used it, that seemed misnamed.
1662     * op is the spell effect.
1663     * note that duration is handled by process_object() in time.c
1664     */
1665    
1666 root 1.9 void
1667     move_ball_spell (object *op)
1668     {
1669     int i, j, dam_save, dir, mflags;
1670     sint16 nx, ny, hx, hy;
1671     object *owner;
1672 root 1.15 maptile *m;
1673 root 1.9
1674 root 1.19 owner = op->owner;
1675 root 1.9
1676     /* the following logic makes sure that the ball doesn't move into a wall,
1677     * and makes sure that it will move along a wall to try and get at it's
1678     * victim. The block immediately below more or less chooses a random
1679     * offset to move the ball, eg, keep it mostly on course, with some
1680     * deviations.
1681     */
1682    
1683     dir = 0;
1684     if (!(rndm (0, 3)))
1685     j = rndm (0, 1);
1686     else
1687     j = 0;
1688    
1689     for (i = 1; i < 9; i++)
1690     {
1691     /* i bit 0: alters sign of offset
1692     * other bits (i / 2): absolute value of offset
1693     */
1694    
1695     int offset = ((i ^ j) & 1) ? (i / 2) : -(i / 2);
1696     int tmpdir = absdir (op->direction + offset);
1697    
1698     nx = op->x + freearr_x[tmpdir];
1699     ny = op->y + freearr_y[tmpdir];
1700     if (!(get_map_flags (op->map, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, nx, ny))))
1701     {
1702     dir = tmpdir;
1703     break;
1704 root 1.6 }
1705 elmex 1.1 }
1706 root 1.9 if (dir == 0)
1707     {
1708     nx = op->x;
1709     ny = op->y;
1710     m = op->map;
1711     }
1712    
1713 root 1.25 m->insert (op, nx, ny, op);
1714 root 1.9
1715     dam_save = op->stats.dam; /* save the original dam: we do halfdam on
1716     surrounding squares */
1717    
1718     /* loop over current square and neighbors to hit.
1719     * if this has an other_arch field, we insert that in
1720     * the surround spaces.
1721     */
1722     for (j = 0; j < 9; j++)
1723     {
1724     object *new_ob;
1725 elmex 1.1
1726 root 1.9 hx = nx + freearr_x[j];
1727     hy = ny + freearr_y[j];
1728 elmex 1.1
1729 root 1.9 m = op->map;
1730     mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
1731 elmex 1.1
1732 root 1.9 if (mflags & P_OUT_OF_MAP)
1733     continue;
1734 elmex 1.1
1735 root 1.9 /* first, don't ever, ever hit the owner. Don't hit out
1736     * of the map either.
1737     */
1738 elmex 1.1
1739 root 1.9 if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
1740     {
1741     if (j)
1742     op->stats.dam = dam_save / 2;
1743     hit_map (op, j, op->attacktype, 1);
1744 elmex 1.1
1745 root 1.6 }
1746 elmex 1.1
1747 root 1.9 /* insert the other arch */
1748     if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1749 root 1.25 m->insert (arch_to_object (op->other_arch), hx, hy, op);
1750 elmex 1.1 }
1751    
1752 root 1.9 /* restore to the center location and damage */
1753     op->stats.dam = dam_save;
1754 elmex 1.1
1755 root 1.19 i = spell_find_dir (op->map, op->x, op->y, op->owner);
1756 elmex 1.1
1757 root 1.9 if (i >= 0)
1758     { /* we have a preferred direction! */
1759     /* pick another direction if the preferred dir is blocked. */
1760     if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP ||
1761     OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))
1762 root 1.25 i = absdir (i + rndm (0, 2) - 1); /* -1, 0, +1 */
1763    
1764 root 1.9 op->direction = i;
1765 elmex 1.1 }
1766     }
1767    
1768    
1769     /* move_swarm_spell: peterm
1770     * This is an implementation of the swarm spell. It was written for
1771     * meteor swarm, but it could be used for any swarm. A swarm spell
1772     * is a special type of object that casts swarms of other types
1773     * of spells. Which spell it casts is flexible. It fires the spells
1774     * from a set of squares surrounding the caster, in a given direction.
1775     */
1776    
1777 root 1.9 void
1778     move_swarm_spell (object *op)
1779 elmex 1.1 {
1780 pippijn 1.8 #if 0
1781 root 1.9 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1782     static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1783     sint16 target_x, target_y, origin_x, origin_y;
1784     int adjustdir;
1785 root 1.15 maptile *m;
1786 pippijn 1.8 #endif
1787 root 1.9 int basedir;
1788     object *owner;
1789 elmex 1.1
1790 root 1.19 owner = op->owner;
1791 root 1.9 if (op->duration == 0 || owner == NULL)
1792     {
1793 root 1.17 op->destroy ();
1794 root 1.9 return;
1795 elmex 1.1 }
1796 root 1.17
1797 root 1.9 op->duration--;
1798 elmex 1.1
1799 root 1.9 basedir = op->direction;
1800     if (basedir == 0)
1801     {
1802     /* spray in all directions! 8) */
1803     basedir = rndm (1, 8);
1804 elmex 1.1 }
1805    
1806     #if 0
1807 root 1.9 // this is bogus: it causes wrong places to be checked below
1808     // (a wall 2 cells away will block the effect...) and
1809     // doesn't work for SP_BULLET anyhow, so again tests the wrong
1810     // space.
1811     // should be fixed later, but correctness before featurs...
1812     // (schmorp)
1813    
1814     /* new offset calculation to make swarm element distribution
1815     * more uniform
1816     */
1817     if (op->duration)
1818     {
1819     if (basedir & 1)
1820     {
1821     adjustdir = cardinal_adjust[rndm (0, 8)];
1822     }
1823     else
1824     {
1825     adjustdir = diagonal_adjust[rndm (0, 9)];
1826     }
1827     }
1828     else
1829     {
1830     adjustdir = 0; /* fire the last one from forward. */
1831     }
1832    
1833     target_x = op->x + freearr_x[absdir (basedir + adjustdir)];
1834     target_y = op->y + freearr_y[absdir (basedir + adjustdir)];
1835    
1836     /* back up one space so we can hit point-blank targets, but this
1837     * necessitates extra out_of_map check below
1838     */
1839     origin_x = target_x - freearr_x[basedir];
1840     origin_y = target_y - freearr_y[basedir];
1841    
1842    
1843     /* spell pointer is set up for the spell this casts. Since this
1844     * should just be a pointer to the spell in some inventory,
1845     * it is unlikely to disappear by the time we need it. However,
1846     * do some sanity checking anyways.
1847     */
1848    
1849     if (op->spell && op->spell->type == SPELL &&
1850     !(get_map_flags (op->map, &m, target_x, target_y, &target_x, &target_y) & P_OUT_OF_MAP) &&
1851     !(OB_TYPE_MOVE_BLOCK (op->spell, GET_MAP_MOVE_BLOCK (m, target_x, target_y))))
1852     {
1853    
1854     /* Bullet spells have a bunch more customization that needs to be done */
1855     if (op->spell->subtype == SP_BULLET)
1856     fire_bullet (owner, op, basedir, op->spell);
1857     else if (op->spell->subtype == SP_MAGIC_MISSILE)
1858     fire_arch_from_position (owner, op, origin_x, origin_y, basedir, op->spell);
1859 elmex 1.1 }
1860     #endif
1861    
1862 root 1.9 /* spell pointer is set up for the spell this casts. Since this
1863     * should just be a pointer to the spell in some inventory,
1864     * it is unlikely to disappear by the time we need it. However,
1865     * do some sanity checking anyways.
1866     */
1867    
1868     if (op->spell && op->spell->type == SPELL)
1869     {
1870     /* Bullet spells have a bunch more customization that needs to be done */
1871     if (op->spell->subtype == SP_BULLET)
1872     fire_bullet (owner, op, basedir, op->spell);
1873     else if (op->spell->subtype == SP_MAGIC_MISSILE)
1874     fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);
1875     }
1876 elmex 1.1 }
1877    
1878    
1879    
1880    
1881     /* fire_swarm:
1882     * The following routine creates a swarm of objects. It actually
1883     * sets up a specific swarm object, which then fires off all
1884     * the parts of the swarm.
1885     *
1886     * op: the owner
1887     * caster: the caster (owner, wand, rod, scroll)
1888     * dir: the direction everything will be fired in
1889     * spell - the spell that is this spell.
1890     * n: the number to be fired.
1891     */
1892    
1893 root 1.9 int
1894     fire_swarm (object *op, object *caster, object *spell, int dir)
1895 elmex 1.1 {
1896 root 1.9 object *tmp;
1897     int i;
1898 elmex 1.1
1899 root 1.9 if (!spell->other_arch)
1900     return 0;
1901 elmex 1.1
1902 root 1.9 tmp = get_archetype (SWARM_SPELL);
1903 root 1.19 tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
1904 root 1.9 set_spell_skill (op, caster, spell, tmp);
1905 elmex 1.1
1906 root 1.9 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */
1907     tmp->spell = arch_to_object (spell->other_arch);
1908 elmex 1.1
1909 root 1.9 tmp->attacktype = tmp->spell->attacktype;
1910 elmex 1.1
1911 root 1.9 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1912 root 1.25 if (!tailor_god_spell (tmp, op))
1913     return 1;
1914    
1915 root 1.9 tmp->duration = SP_level_duration_adjust (caster, spell);
1916     for (i = 0; i < spell->duration; i++)
1917     tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1918    
1919     tmp->direction = dir;
1920     tmp->invisible = 1;
1921 root 1.25
1922     tmp->insert_at (op, op);
1923 root 1.9 return 1;
1924 elmex 1.1 }
1925    
1926    
1927     /* See the spells documentation file for why this is its own
1928     * function.
1929     */
1930 root 1.9 int
1931     cast_light (object *op, object *caster, object *spell, int dir)
1932     {
1933     object *target = NULL, *tmp = NULL;
1934     sint16 x, y;
1935     int dam, mflags;
1936 root 1.15 maptile *m;
1937 elmex 1.1
1938 root 1.9 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1939 elmex 1.1
1940 root 1.9 if (!dir)
1941     {
1942     new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
1943     return 0;
1944 elmex 1.1 }
1945    
1946 root 1.9 x = op->x + freearr_x[dir];
1947     y = op->y + freearr_y[dir];
1948     m = op->map;
1949 elmex 1.1
1950 root 1.9 mflags = get_map_flags (m, &m, x, y, &x, &y);
1951 elmex 1.1
1952 root 1.9 if (mflags & P_OUT_OF_MAP)
1953     {
1954     new_draw_info (NDI_UNIQUE, 0, op, "Nothing is there.");
1955     return 0;
1956 elmex 1.1 }
1957    
1958 root 1.9 if (mflags & P_IS_ALIVE && spell->attacktype)
1959     {
1960 root 1.21 for (target = GET_MAP_OB (m, x, y); target; target = target->above)
1961 root 1.9 if (QUERY_FLAG (target, FLAG_MONSTER))
1962     {
1963     /* oky doky. got a target monster. Lets make a blinding attack */
1964     if (target->head)
1965     target = target->head;
1966     (void) hit_player (target, dam, op, spell->attacktype, 1);
1967     return 1; /* one success only! */
1968     }
1969 elmex 1.1 }
1970    
1971 root 1.9 /* no live target, perhaps a wall is in the way? */
1972     if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
1973     {
1974     new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1975     return 0;
1976 elmex 1.1 }
1977    
1978 root 1.9 /* ok, looks groovy to just insert a new light on the map */
1979     tmp = arch_to_object (spell->other_arch);
1980     if (!tmp)
1981     {
1982     LOG (llevError, "Error: spell arch for cast_light() missing.\n");
1983     return 0;
1984     }
1985     tmp->stats.food = spell->duration + SP_level_duration_adjust (caster, spell);
1986     if (tmp->glow_radius)
1987     {
1988     tmp->glow_radius = spell->range + SP_level_range_adjust (caster, spell);
1989     if (tmp->glow_radius > MAX_LIGHT_RADII)
1990     tmp->glow_radius = MAX_LIGHT_RADII;
1991 elmex 1.1 }
1992 root 1.25
1993     m->insert (tmp, x, y, op);
1994 root 1.9 return 1;
1995 elmex 1.1 }
1996    
1997    
1998    
1999    
2000     /* cast_cause_disease: this spell looks along <dir> from the
2001     * player and infects someone.
2002     * op is the player/monster, caster is the object, dir is the direction
2003     * to cast, disease_arch is the specific disease, and type is the spell number
2004     * perhaps this should actually be in disease.c?
2005     */
2006    
2007 root 1.9 int
2008     cast_cause_disease (object *op, object *caster, object *spell, int dir)
2009     {
2010     sint16 x, y;
2011     int i, mflags, range, dam_mod, dur_mod;
2012     object *walk;
2013 root 1.15 maptile *m;
2014 root 1.9
2015     x = op->x;
2016     y = op->y;
2017    
2018     /* If casting from a scroll, no direction will be available, so refer to the
2019     * direction the player is pointing.
2020     */
2021     if (!dir)
2022     dir = op->facing;
2023     if (!dir)
2024     return 0; /* won't find anything if casting on ourself, so just return */
2025    
2026     /* Calculate these once here */
2027     range = spell->range + SP_level_range_adjust (caster, spell);
2028     dam_mod = SP_level_dam_adjust (caster, spell);
2029     dur_mod = SP_level_duration_adjust (caster, spell);
2030    
2031     /* search in a line for a victim */
2032     for (i = 1; i < range; i++)
2033     {
2034     x = op->x + i * freearr_x[dir];
2035     y = op->y + i * freearr_y[dir];
2036     m = op->map;
2037    
2038     mflags = get_map_flags (m, &m, x, y, &x, &y);
2039    
2040     if (mflags & P_OUT_OF_MAP)
2041     return 0;
2042    
2043     /* don't go through walls - presume diseases are airborne */
2044     if (GET_MAP_MOVE_BLOCK (m, x, y) & MOVE_FLY_LOW)
2045     return 0;
2046    
2047     /* Only bother looking on this space if there is something living here */
2048     if (mflags & P_IS_ALIVE)
2049     {
2050     /* search this square for a victim */
2051 root 1.21 for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
2052 root 1.9 if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
2053     { /* found a victim */
2054     object *disease = arch_to_object (spell->other_arch);
2055    
2056 root 1.19 disease->set_owner (op);
2057 root 1.9 set_spell_skill (op, caster, spell, disease);
2058     disease->stats.exp = 0;
2059     disease->level = caster_level (caster, spell);
2060    
2061     /* do level adjustments */
2062     if (disease->stats.wc)
2063     disease->stats.wc += dur_mod / 2;
2064    
2065     if (disease->magic > 0)
2066     disease->magic += dur_mod / 4;
2067    
2068     if (disease->stats.maxhp > 0)
2069     disease->stats.maxhp += dur_mod;
2070    
2071     if (disease->stats.maxgrace > 0)
2072     disease->stats.maxgrace += dur_mod;
2073    
2074     if (disease->stats.dam)
2075     {
2076     if (disease->stats.dam > 0)
2077     disease->stats.dam += dam_mod;
2078     else
2079     disease->stats.dam -= dam_mod;
2080     }
2081 root 1.6
2082 root 1.9 if (disease->last_sp)
2083     {
2084     disease->last_sp -= 2 * dam_mod;
2085     if (disease->last_sp < 1)
2086     disease->last_sp = 1;
2087     }
2088 root 1.6
2089 root 1.9 if (disease->stats.maxsp)
2090     {
2091     if (disease->stats.maxsp > 0)
2092     disease->stats.maxsp += dam_mod;
2093     else
2094     disease->stats.maxsp -= dam_mod;
2095     }
2096 root 1.6
2097 root 1.9 if (disease->stats.ac)
2098     disease->stats.ac += dam_mod;
2099 root 1.6
2100 root 1.9 if (disease->last_eat)
2101     disease->last_eat -= dam_mod;
2102 root 1.6
2103 root 1.9 if (disease->stats.hp)
2104     disease->stats.hp -= dam_mod;
2105 root 1.6
2106 root 1.9 if (disease->stats.sp)
2107     disease->stats.sp -= dam_mod;
2108    
2109     if (infect_object (walk, disease, 1))
2110     {
2111     object *flash; /* visual effect for inflicting disease */
2112    
2113     new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2114    
2115 root 1.17 disease->destroy (); /* don't need this one anymore */
2116 root 1.25 walk->map->insert (get_archetype (ARCH_DETECT_MAGIC), x, y, op);
2117 root 1.9 return 1;
2118 root 1.6 }
2119 root 1.17
2120     disease->destroy ();
2121 root 1.9 }
2122     } /* if living creature */
2123     } /* for range of spaces */
2124 root 1.25
2125 root 1.9 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
2126     return 1;
2127 elmex 1.1 }