ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/spell_attack.C
(Generate patch)

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.41 by root, Sat Jun 9 21:16:12 2007 UTC vs.
Revision 1.65 by root, Mon Sep 29 10:20:49 2008 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software; you can redistribute it and/or modify it 8 * Deliantra is free software: you can redistribute it and/or modify
9 * under the terms of the GNU General Public License as published by the Free 9 * it under the terms of the GNU General Public License as published by
10 * Software Foundation; either version 2 of the License, or (at your option) 10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, but 13 * This program is distributed in the hope that it will be useful,
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License along 18 * You should have received a copy of the GNU General Public License
19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * 20 *
22 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 22 */
24 23
25/* This file contains all the spell attack code. Grouping this code 24/* This file contains all the spell attack code. Grouping this code
26 * together should hopefully make it easier to find the relevent bits 25 * together should hopefully make it easier to find the relevent bits
27 * of code 26 * of code
… …
37/* this function checks to see if a spell pushes objects as well 36/* this function checks to see if a spell pushes objects as well
38 * as flies over and damages them (only used for cones for now) 37 * as flies over and damages them (only used for cones for now)
39 * but moved here so it could be applied to bolts too 38 * but moved here so it could be applied to bolts too
40 * op is the spell object. 39 * op is the spell object.
41 */ 40 */
42
43void 41void
44check_spell_knockback (object *op) 42check_spell_knockback (object *op)
45{ 43{
46 object *tmp, *tmp2; /* object on the map */
47 int weight_move; 44 int weight_move;
48 int frictionmod = 2; /*poor man's physics - multipy targets weight by this amount */ 45 int frictionmod = 2; /*poor man's physics - multipy targets weight by this amount */
49 46
50 if (!op->weight) 47 if (!op->weight)
51 { /*shouldn't happen but if cone object has no weight drop out */ 48 { /*shouldn't happen but if cone object has no weight drop out */
… …
56 { 53 {
57 weight_move = op->weight + (op->weight * op->level) / 3; 54 weight_move = op->weight + (op->weight * op->level) / 3;
58 /*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */ 55 /*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */
59 } 56 }
60 57
61 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 58 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
62 { 59 {
63 int num_sections = 1; 60 int num_sections = 1;
64 61
65 /* don't move DM */ 62 /* don't move DM */
66 if (QUERY_FLAG (tmp, FLAG_WIZ)) 63 if (QUERY_FLAG (tmp, FLAG_WIZ))
… …
73 /* don't move floors or immobile objects */ 70 /* don't move floors or immobile objects */
74 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK))) 71 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))
75 continue; 72 continue;
76 73
77 /* count the object's sections */ 74 /* count the object's sections */
78 for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more) 75 for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
79 num_sections++; 76 num_sections++;
80 77
81 /* I'm not sure if it makes sense to divide by num_sections - bigger 78 /* I'm not sure if it makes sense to divide by num_sections - bigger
82 * objects should be harder to move, and we are moving the entire 79 * objects should be harder to move, and we are moving the entire
83 * object, not just the head, so the total weight should be relevant. 80 * object, not just the head, so the total weight should be relevant.
… …
107 * 104 *
108 * BOLT CODE 105 * BOLT CODE
109 * 106 *
110 ***************************************************************************/ 107 ***************************************************************************/
111 108
112/* Causes op to fork. op is the original bolt, tmp 109/* Causes op to fork. op is the original bolt, tmp
113 * is the first piece of the fork. 110 * is the first piece of the fork.
114 */ 111 */
115
116void 112void
117forklightning (object *op, object *tmp) 113forklightning (object *op, object *tmp)
118{ 114{
119 int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */ 115 int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
120 int t_dir; /* stores temporary dir calculation */ 116 int t_dir; /* stores temporary dir calculation */
… …
152 new_bolt->duration++; 148 new_bolt->duration++;
153 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */ 149 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
154 new_bolt->stats.dam++; 150 new_bolt->stats.dam++;
155 tmp->stats.dam /= 2; /* reduce father bolt damage */ 151 tmp->stats.dam /= 2; /* reduce father bolt damage */
156 tmp->stats.dam++; 152 tmp->stats.dam++;
153
157 if ((new_bolt = m->insert (new_bolt, sx, sy, op))) 154 if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
158 update_turn_face (new_bolt); 155 update_turn_face (new_bolt);
159} 156}
160 157
161/* move_bolt: moves bolt 'op'. Basically, it just advances a space, 158/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
162 * and checks for various things that may stop it. 159 * and checks for various things that may stop it.
163 */ 160 */
164
165void 161void
166move_bolt (object *op) 162move_bolt (object *op)
167{ 163{
168 int mflags; 164 int mflags;
169 sint16 x, y; 165 sint16 x, y;
170 maptile *m; 166 maptile *m;
171 167
172 if (--op->duration < 0) 168 if (--op->duration < 0)
173 { 169 {
170 op->destroy_inv (true); // be explicit about dropping
174 op->destroy (); 171 op->destroy (true);
175 return; 172 return;
176 } 173 }
177 174
178 hit_map (op, 0, op->attacktype, 1); 175 hit_map (op, 0, op->attacktype, 1);
179 176
… …
252 tmp->duration++; 249 tmp->duration++;
253 250
254 /* New forking code. Possibly create forks of this object 251 /* New forking code. Possibly create forks of this object
255 * going off in other directions. 252 * going off in other directions.
256 */ 253 */
257 if (rndm (0, 99) < tmp->stats.Dex) 254 if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
258 { /* stats.Dex % of forking */ 255 forklightning (op, tmp); /* stats.Dex % of forking */
259 forklightning (op, tmp);
260 }
261 256
262 /* In this way, the object left behind sticks on the space, but 257 /* In this way, the object left behind sticks on the space, but
263 * doesn't create any bolts that continue to move onward. 258 * doesn't create any bolts that continue to move onward.
264 */ 259 */
265 op->range = 0; 260 op->range = 0;
… …
289 return 0; 284 return 0;
290 285
291 /* peterm: level dependency for bolts */ 286 /* peterm: level dependency for bolts */
292 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 287 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
293 tmp->attacktype = spob->attacktype; 288 tmp->attacktype = spob->attacktype;
289
294 if (spob->slaying) 290 if (spob->slaying)
295 tmp->slaying = spob->slaying; 291 tmp->slaying = spob->slaying;
292
296 tmp->range = spob->range + SP_level_range_adjust (caster, spob); 293 tmp->range = spob->range + SP_level_range_adjust (caster, spob);
297 tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob); 294 tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
298 tmp->stats.Dex = spob->stats.Dex; 295 tmp->stats.Dex = spob->stats.Dex;
299 tmp->stats.Con = spob->stats.Con; 296 tmp->stats.Con = spob->stats.Con;
300 297
… …
311 308
312 maptile *newmap; 309 maptile *newmap;
313 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y); 310 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
314 if (mflags & P_OUT_OF_MAP) 311 if (mflags & P_OUT_OF_MAP)
315 { 312 {
313 tmp->destroy_inv (true); // be explicit about dropping
316 tmp->destroy (); 314 tmp->destroy (true);
317 return 0; 315 return 0;
318 } 316 }
319 317
320 tmp->map = newmap; 318 tmp->map = newmap;
321 319
322 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 320 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
323 { 321 {
324 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 322 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
325 { 323 {
324 tmp->destroy_inv (true); // be explicit about dropping
326 tmp->destroy (); 325 tmp->destroy (true);
327 return 0; 326 return 0;
328 } 327 }
329 328
330 tmp->x = op->x; 329 tmp->x = op->x;
331 tmp->y = op->y; 330 tmp->y = op->y;
… …
344 * BULLET/BALL CODE 343 * BULLET/BALL CODE
345 * 344 *
346 ***************************************************************************/ 345 ***************************************************************************/
347 346
348/* expands an explosion. op is a piece of the 347/* expands an explosion. op is a piece of the
349 * explosion - this expans it in the different directions. 348 * explosion - this expands it in the different directions.
350 * At least that is what I think this does. 349 * At least that is what I think this does.
351 */ 350 */
352void 351void
353explosion (object *op) 352explosion (object *op)
354{ 353{
355 maptile *m = op->map; 354 maptile *m = op->map;
356 int i; 355 int i;
357 356
358 if (--op->duration < 0) 357 if (--op->duration < 0)
359 { 358 {
360 op->destroy (); 359 op->destroy (true);
361 return; 360 return;
362 } 361 }
363 362
364 hit_map (op, 0, op->attacktype, 0); 363 hit_map (op, 0, op->attacktype, 0);
365 364
… …
397void 396void
398explode_bullet (object *op) 397explode_bullet (object *op)
399{ 398{
400 object *tmp, *owner; 399 object *tmp, *owner;
401 400
402 if (op->other_arch == NULL) 401 if (!op->other_arch)
403 { 402 {
404 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 403 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
405 op->destroy (); 404 op->destroy (true);
406 return; 405 return;
407 } 406 }
408 407
409 if (op->env) 408 if (op->env)
410 { 409 {
411 object *env = object_get_env_recursive (op); 410 object *env = op->outer_env ();
411
412 if (env->map == NULL || out_of_map (env->map, env->x, env->y)) 412 if (!env->map || out_of_map (env->map, env->x, env->y))
413 { 413 {
414 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 414 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
415 op->destroy (); 415 op->destroy (true);
416 return; 416 return;
417 } 417 }
418 418
419 op->insert_at (env, op, INS_NO_MERGE | INS_NO_WALK_ON); 419 op->insert_at (env, op, INS_NO_MERGE | INS_NO_WALK_ON);
420 } 420 }
421 else if (out_of_map (op->map, op->x, op->y)) 421 else if (out_of_map (op->map, op->x, op->y))
422 { 422 {
423 LOG (llevError, "BUG: explode_bullet(): op out of map\n"); 423 LOG (llevError, "BUG: explode_bullet(): op out of map\n");
424 op->destroy (); 424 op->destroy (true);
425 return; 425 return;
426 } 426 }
427 427
428 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps 428 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps
429 // NOTE: If this breaks something important: remove this. I can't think of anything 429 // NOTE: If this breaks something important: remove this. I can't think of anything
430 // bad at the moment that might happen from this. 430 // bad at the moment that might happen from this.
431 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE) 431 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
432 { 432 {
433 op->destroy (); 433 op->destroy (true);
434 return; 434 return;
435 } 435 }
436 436
437 if (op->attacktype) 437 if (op->attacktype)
438 { 438 {
439 hit_map (op, 0, op->attacktype, 1); 439 hit_map (op, 0, op->attacktype, 1);
440
440 if (op->destroyed ()) 441 if (op->destroyed ())
441 return; 442 return;
442 } 443 }
443 444
444 /* other_arch contains what this explodes into */ 445 /* other_arch contains what this explodes into */
… …
447 tmp->set_owner (op); 448 tmp->set_owner (op);
448 tmp->skill = op->skill; 449 tmp->skill = op->skill;
449 450
450 owner = op->owner; 451 owner = op->owner;
451 452
452 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner)) 453 if ((tmp->attacktype & AT_HOLYWORD
454 || tmp->attacktype & AT_GODPOWER)
455 && owner
456 && !tailor_god_spell (tmp, owner))
453 { 457 {
454 op->destroy (); 458 op->destroy (true);
455 return; 459 return;
456 } 460 }
457 461
458 /* special for bombs - it actually has sane values for these */ 462 /* special for bombs - it actually has sane values for these */
459 if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB) 463 if (op->type == SPELL_EFFECT && op->subtype == SP_BOMB)
… …
484 488
485 /* Prevent recursion */ 489 /* Prevent recursion */
486 op->move_on = 0; 490 op->move_on = 0;
487 491
488 tmp->insert_at (op, op); 492 tmp->insert_at (op, op);
493 tmp->play_sound (tmp->sound);
494
489 /* remove the firebullet */ 495 /* remove the firebullet */
490 op->destroy (); 496 op->destroy (true);
491} 497}
492 498
493/* checks to see what op should do, given the space it is on 499/* checks to see what op should do, given the space it is on
494 * (eg, explode, damage player, etc) 500 * (eg, explode, damage player, etc)
495 */ 501 */
… …
520 for (tmp = op->ms ().bot; tmp; tmp = tmp->above) 526 for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
521 { 527 {
522 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 528 if (QUERY_FLAG (tmp, FLAG_ALIVE))
523 { 529 {
524 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 530 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
531
532 // TODO: can't understand the following if's
525 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 533 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
526 { 534 {
527 if (!QUERY_FLAG (op, FLAG_REMOVED)) 535 if (!QUERY_FLAG (op, FLAG_REMOVED))
528 { 536 {
529 op->destroy (); 537 op->destroy (true);
530 return; 538 return;
531 } 539 }
532 } 540 }
533 } 541 }
534 } 542 }
… …
563 if (--op->range <= 0) 571 if (--op->range <= 0)
564 { 572 {
565 if (op->other_arch) 573 if (op->other_arch)
566 explode_bullet (op); 574 explode_bullet (op);
567 else 575 else
568 op->destroy (); 576 op->destroy (true);
569 577
570 return; 578 return;
571 } 579 }
572 580
573 new_x = op->x + DIRX (op); 581 new_x = op->x + DIRX (op);
… …
575 m = op->map; 583 m = op->map;
576 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y); 584 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
577 585
578 if (mflags & P_OUT_OF_MAP) 586 if (mflags & P_OUT_OF_MAP)
579 { 587 {
580 op->destroy (); 588 op->destroy (true);
581 return; 589 return;
582 } 590 }
583 591
584 if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))) 592 if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))
585 { 593 {
586 if (op->other_arch) 594 if (op->other_arch)
587 explode_bullet (op); 595 explode_bullet (op);
588 else 596 else
589 op->destroy (); 597 op->destroy (true);
590 598
591 return; 599 return;
592 } 600 }
593 601
594 if (!(op = m->insert (op, new_x, new_y, op))) 602 if (!(op = m->insert (op, new_x, new_y, op)))
… …
618 int mflags; 626 int mflags;
619 627
620 if (!spob->other_arch) 628 if (!spob->other_arch)
621 return 0; 629 return 0;
622 630
623 tmp = arch_to_object (spob->other_arch); 631 tmp = spob->other_arch->instance ();
624 if (tmp == NULL) 632 if (!tmp)
625 return 0; 633 return 0;
626 634
627 /* peterm: level dependency for bolts */ 635 /* peterm: level dependency for bolts */
628 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 636 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
629 tmp->attacktype = spob->attacktype; 637 tmp->attacktype = spob->attacktype;
630 if (spob->slaying) 638 if (spob->slaying)
631 tmp->slaying = spob->slaying; 639 tmp->slaying = spob->slaying;
632 640
… …
642 SET_ANIMATION (tmp, dir); 650 SET_ANIMATION (tmp, dir);
643 651
644 tmp->set_owner (op); 652 tmp->set_owner (op);
645 set_spell_skill (op, caster, spob, tmp); 653 set_spell_skill (op, caster, spob, tmp);
646 654
647 tmp->x = op->x + freearr_x[dir]; 655 tmp->x = op->x + freearr_x[dir];
648 tmp->y = op->y + freearr_y[dir]; 656 tmp->y = op->y + freearr_y[dir];
649 tmp->map = op->map; 657 tmp->map = op->map;
650 658
651 maptile *newmap; 659 maptile *newmap;
652 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y); 660 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
653 if (mflags & P_OUT_OF_MAP) 661 if (mflags & P_OUT_OF_MAP)
654 { 662 {
655 tmp->destroy (); 663 tmp->destroy (true);
656 return 0; 664 return 0;
657 } 665 }
658 666
659 tmp->map = newmap; 667 tmp->map = newmap;
660 668
661 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 669 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
662 { 670 {
663 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 671 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
664 { 672 {
665 tmp->destroy (); 673 tmp->destroy (true);
666 return 0; 674 return 0;
667 } 675 }
668 676
669 tmp->x = op->x; 677 tmp->x = op->x;
670 tmp->y = op->y; 678 tmp->y = op->y;
… …
703/* move_cone: causes cone object 'op' to move a space/hit creatures */ 711/* move_cone: causes cone object 'op' to move a space/hit creatures */
704 712
705void 713void
706move_cone (object *op) 714move_cone (object *op)
707{ 715{
708 int i;
709
710 /* if no map then hit_map will crash so just ignore object */ 716 /* if no map then hit_map will crash so just ignore object */
711 if (!op->map) 717 if (!op->map)
712 { 718 {
713 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown"); 719 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
714 op->set_speed (0); 720 op->set_speed (0);
… …
727 * when their cone dies when they die. 733 * when their cone dies when they die.
728 */ 734 */
729 /* If no owner left, the spell dies out. */ 735 /* If no owner left, the spell dies out. */
730 if (op->owner == NULL) 736 if (op->owner == NULL)
731 { 737 {
732 op->destroy (); 738 op->destroy (true);
733 return; 739 return;
734 } 740 }
735#endif 741#endif
736 742
737 hit_map (op, 0, op->attacktype, 0); 743 hit_map (op, 0, op->attacktype, 0);
… …
744 check_spell_knockback (op); 750 check_spell_knockback (op);
745 751
746 if (op->destroyed ()) 752 if (op->destroyed ())
747 return; 753 return;
748 754
749 if ((op->duration--) < 0) 755 if (op->duration-- < 0)
750 { 756 {
751 op->destroy (); 757 op->destroy (true);
752 return; 758 return;
753 } 759 }
754 /* Object has hit maximum range, so don't have it move 760 /* Object has hit maximum range, so don't have it move
755 * any further. When the duration above expires, 761 * any further. When the duration above expires,
756 * then the object will get removed. 762 * then the object will get removed.
… …
759 { 765 {
760 op->range = 0; /* just so it doesn't wrap */ 766 op->range = 0; /* just so it doesn't wrap */
761 return; 767 return;
762 } 768 }
763 769
764 for (i = -1; i < 2; i++) 770 for (int i = -1; i <= 1; i++)
765 { 771 {
766 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)]; 772 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
767 773
768 if (ok_to_put_more (op->map, x, y, op, op->attacktype)) 774 if (ok_to_put_more (op->map, x, y, op, op->attacktype))
769 { 775 {
… …
861 867
862 success = 1; 868 success = 1;
863 tmp = arch_to_object (spell->other_arch); 869 tmp = arch_to_object (spell->other_arch);
864 tmp->set_owner (op); 870 tmp->set_owner (op);
865 set_spell_skill (op, caster, spell, tmp); 871 set_spell_skill (op, caster, spell, tmp);
866 tmp->level = caster_level (caster, spell); 872 tmp->level = casting_level (caster, spell);
867 tmp->attacktype = spell->attacktype; 873 tmp->attacktype = spell->attacktype;
868 874
869 /* holy word stuff */ 875 /* holy word stuff */
870 if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER)) 876 if ((tmp->attacktype & AT_HOLYWORD) || (tmp->attacktype & AT_GODPOWER))
871 if (!tailor_god_spell (tmp, op)) 877 if (!tailor_god_spell (tmp, op))
… …
936 * op is the original bomb object. 942 * op is the original bomb object.
937 */ 943 */
938void 944void
939animate_bomb (object *op) 945animate_bomb (object *op)
940{ 946{
941 int i;
942 object *env, *tmp;
943
944 if (op->state != NUM_ANIMATIONS (op) - 1) 947 if (op->state != NUM_ANIMATIONS (op) - 1)
945 return; 948 return;
946 949
947 env = object_get_env_recursive (op); 950 object *env = op->outer_env ();
948 951
949 if (op->env) 952 if (op->env)
950 { 953 {
951 if (env->map == NULL) 954 if (env->map == NULL)
952 return; 955 return;
953
954 if (env->type == PLAYER)
955 esrv_del_item (env->contr, op->count);
956 956
957 if (!(op = op->insert_at (env, op))) 957 if (!(op = op->insert_at (env, op)))
958 return; 958 return;
959 } 959 }
960 960
961 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding 961 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
962 // on a safe map. I don't like this special casing, but it seems to be neccessary 962 // on a safe map. I don't like this special casing, but it seems to be neccessary
963 // as bombs can be carried. 963 // as bombs can be carried.
964 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE) 964 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
965 { 965 {
966 op->destroy (); 966 op->destroy (true);
967 return; 967 return;
968 } 968 }
969 969
970 /* This copies a lot of the code from the fire bullet, 970 /* This copies a lot of the code from the fire bullet,
971 * but using the cast_bullet isn't really feasible, 971 * but using the cast_bullet isn't really feasible,
972 * so just set up the appropriate values. 972 * so just set up the appropriate values.
973 */ 973 */
974 if (archetype *at = archetype::find (SPLINT)) 974 if (archetype *at = archetype::find (SPLINT))
975 { 975 {
976 for (i = 1; i < 9; i++) 976 for (int i = 1; i < 9; i++)
977 { 977 {
978 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i])) 978 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
979 continue; 979 continue;
980 980
981 tmp = arch_to_object (at); 981 object *tmp = arch_to_object (at);
982 tmp->direction = i; 982 tmp->direction = i;
983 tmp->range = op->range; 983 tmp->range = op->range;
984 tmp->stats.dam = op->stats.dam; 984 tmp->stats.dam = op->stats.dam;
985 tmp->duration = op->duration; 985 tmp->duration = op->duration;
986 tmp->attacktype = op->attacktype; 986 tmp->attacktype = op->attacktype;
… …
1000} 1000}
1001 1001
1002int 1002int
1003create_bomb (object *op, object *caster, int dir, object *spell) 1003create_bomb (object *op, object *caster, int dir, object *spell)
1004{ 1004{
1005
1006 object *tmp; 1005 object *tmp;
1007 int mflags; 1006 int mflags;
1008 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir]; 1007 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1009 maptile *m; 1008 maptile *m;
1010 1009
… …
1012 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK)) 1011 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1013 { 1012 {
1014 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1013 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1015 return 0; 1014 return 0;
1016 } 1015 }
1016
1017 tmp = arch_to_object (spell->other_arch); 1017 tmp = arch_to_object (spell->other_arch);
1018 1018
1019 /* level dependencies for bomb */ 1019 /* level dependencies for bomb */
1020 tmp->range = spell->range + SP_level_range_adjust (caster, spell); 1020 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1021 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1021 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
… …
1086 * op = player 1086 * op = player
1087 * caster = object casting the spell. 1087 * caster = object casting the spell.
1088 * dir = direction being cast 1088 * dir = direction being cast
1089 * spell = spell object 1089 * spell = spell object
1090 */ 1090 */
1091
1092int 1091int
1093cast_smite_spell (object *op, object *caster, int dir, object *spell) 1092cast_smite_spell (object *op, object *caster, int dir, object *spell)
1094{ 1093{
1095 object *effect, *target; 1094 object *effect, *target;
1096 object *god = find_god (determine_god (op)); 1095 object *god = find_god (determine_god (op));
… …
1120 effect = arch_to_object (spell->other_arch); 1119 effect = arch_to_object (spell->other_arch);
1121 else 1120 else
1122 return 0; 1121 return 0;
1123 1122
1124 /* tailor the effect by priest level and worshipped God */ 1123 /* tailor the effect by priest level and worshipped God */
1125 effect->level = caster_level (caster, spell); 1124 effect->level = casting_level (caster, spell);
1126 effect->attacktype = spell->attacktype; 1125 effect->attacktype = spell->attacktype;
1127 if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER)) 1126 if (effect->attacktype & (AT_HOLYWORD | AT_GODPOWER))
1128 { 1127 {
1129 if (tailor_god_spell (effect, op)) 1128 if (tailor_god_spell (effect, op))
1130 new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op)); 1129 new_draw_info_format (NDI_UNIQUE, 0, op, "%s answers your call!", determine_god (op));
… …
1154 } 1153 }
1155 else 1154 else
1156 { 1155 {
1157 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target)); 1156 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1158 target->stats.hp = target->stats.maxhp * 2; 1157 target->stats.hp = target->stats.maxhp * 2;
1159 effect->destroy (); 1158 effect->destroy (true);
1160 return 0; 1159 return 0;
1161 } 1160 }
1162 } 1161 }
1163 } 1162 }
1164 else 1163 else
… …
1173 /* ok, tell it where to be, and insert! */ 1172 /* ok, tell it where to be, and insert! */
1174 effect->insert_at (target, op); 1173 effect->insert_at (target, op);
1175 1174
1176 return 1; 1175 return 1;
1177} 1176}
1178
1179 1177
1180/**************************************************************************** 1178/****************************************************************************
1181 * 1179 *
1182 * MAGIC MISSILE code. 1180 * MAGIC MISSILE code.
1183 * note that the fire_bullet is used to fire the missile. The 1181 * note that the fire_bullet is used to fire the missile. The
… …
1186 1184
1187/* op is a missile that needs to be moved */ 1185/* op is a missile that needs to be moved */
1188void 1186void
1189move_missile (object *op) 1187move_missile (object *op)
1190{ 1188{
1191 int i, mflags;
1192 object *owner;
1193 sint16 new_x, new_y;
1194 maptile *m;
1195
1196 if (op->range-- <= 0) 1189 if (op->range-- <= 0)
1197 { 1190 {
1191 op->destroy_inv (true); // be explicit about dropping
1198 op->destroy (); 1192 op->destroy (true);
1199 return; 1193 return;
1200 }
1201
1202 owner = op->owner;
1203#if 0
1204 /* It'd make things nastier if this wasn't here - spells cast by
1205 * monster that are then killed would continue to survive
1206 */
1207 if (owner == NULL)
1208 { 1194 }
1195
1196 mapxy pos (op);
1197 pos.move (op->direction);
1198
1199 if (!pos.normalise ())
1200 {
1209 op->destroy (); 1201 op->destroy (true);
1210 return; 1202 return;
1211 } 1203 }
1212#endif
1213 1204
1214 new_x = op->x + DIRX (op); 1205 mapspace &ms = pos.ms ();
1215 new_y = op->y + DIRY (op);
1216 1206
1217 mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y); 1207 if (ms.flags () & P_IS_ALIVE || ms.blocks (op))
1218
1219 if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1220 { 1208 {
1221 hit_map (op, op->direction, AT_MAGIC, 1); 1209 hit_map (op, op->direction, AT_MAGIC, 1);
1222 /* Basically, missile only hits one thing then goes away. 1210 /* Basically, missile only hits one thing then goes away.
1223 * we need to remove it if someone hasn't already done so. 1211 * we need to remove it if someone hasn't already done so.
1224 */ 1212 */
1225 if (!op->destroyed ())
1226 op->destroy ();
1227
1228 return;
1229 }
1230
1231 op->remove ();
1232
1233 if (!op->direction || (mflags & P_OUT_OF_MAP))
1234 {
1235 op->destroy (); 1213 op->destroy (true);
1236 return; 1214 return;
1215 }
1216
1217 if (!op->direction)
1237 } 1218 {
1219 op->destroy (true);
1220 return;
1221 }
1238 1222
1239 i = spell_find_dir (m, new_x, new_y, op->owner); 1223 int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1240 if (i > 0 && i != op->direction) 1224 if (i > 0 && i != op->direction)
1241 { 1225 {
1242 op->direction = i; 1226 op->direction = i;
1243 SET_ANIMATION (op, op->direction); 1227 SET_ANIMATION (op, op->direction);
1244 } 1228 }
1245 1229
1246 m->insert (op, new_x, new_y, op); 1230 pos.insert (op, op);
1247} 1231}
1248 1232
1249/**************************************************************************** 1233/****************************************************************************
1250 * Destruction 1234 * Destruction
1251 ****************************************************************************/ 1235 ****************************************************************************/
… …
1254 * we do this by creating a force and inserting it in the 1238 * we do this by creating a force and inserting it in the
1255 * object. if time is 0, the object glows permanently. To truely 1239 * object. if time is 0, the object glows permanently. To truely
1256 * make this work for non-living objects, we would have to 1240 * make this work for non-living objects, we would have to
1257 * give them the capability to have an inventory. b.t. 1241 * give them the capability to have an inventory. b.t.
1258 */ 1242 */
1259
1260int 1243int
1261make_object_glow (object *op, int radius, int time) 1244make_object_glow (object *op, int radius, int time)
1262{ 1245{
1263 object *tmp;
1264
1265 /* some things are unaffected... */ 1246 /* some things are unaffected... */
1266 if (op->path_denied & PATH_LIGHT) 1247 if (op->path_denied & PATH_LIGHT)
1267 return 0; 1248 return 0;
1268 1249
1269 tmp = get_archetype (FORCE_NAME); 1250 object *tmp = get_archetype (FORCE_NAME);
1270 tmp->speed = 0.01; 1251 tmp->speed = 0.01;
1271 tmp->stats.food = time; 1252 tmp->stats.food = time;
1272 SET_FLAG (tmp, FLAG_IS_USED_UP); 1253 SET_FLAG (tmp, FLAG_IS_USED_UP);
1273 tmp->glow_radius = radius; 1254 tmp->glow_radius = radius;
1274 if (tmp->glow_radius > MAX_LIGHT_RADII) 1255 if (tmp->glow_radius > MAX_LIGHT_RADII)
1275 tmp->glow_radius = MAX_LIGHT_RADII; 1256 tmp->glow_radius = MAX_LIGHT_RADII;
1276 1257
1277 tmp->x = op->x;
1278 tmp->y = op->y;
1279 if (tmp->speed < MIN_ACTIVE_SPEED)
1280 tmp->speed = MIN_ACTIVE_SPEED; /* safety */
1281 tmp = insert_ob_in_ob (tmp, op); 1258 tmp = insert_ob_in_ob (tmp, op);
1259
1282 if (tmp->glow_radius > op->glow_radius) 1260 if (tmp->glow_radius > op->glow_radius)
1283 op->glow_radius = tmp->glow_radius; 1261 op->glow_radius = tmp->glow_radius;
1284 1262
1285 if (!tmp->env || op != tmp->env)
1286 {
1287 LOG (llevError, "make_object_glow() failed to insert glowing force in %s\n", &op->name);
1288 return 0;
1289 }
1290 return 1; 1263 return 1;
1291} 1264}
1292 1265
1293int 1266int
1294cast_destruction (object *op, object *caster, object *spell_ob) 1267cast_destruction (object *op, object *caster, object *spell_ob)
… …
1319 else 1292 else
1320 op->skill = NULL; 1293 op->skill = NULL;
1321 1294
1322 op->change_skill (find_skill_by_name (op, op->skill)); 1295 op->change_skill (find_skill_by_name (op, op->skill));
1323 1296
1324 for (i = -range; i < range; i++) 1297 for (i = -range; i <= range; i++)
1325 { 1298 {
1326 for (j = -range; j < range; j++) 1299 for (j = -range; j <= range; j++)
1327 { 1300 {
1328 m = op->map; 1301 m = op->map;
1329 sx = op->x + i; 1302 sx = op->x + i;
1330 sy = op->y + j; 1303 sy = op->y + j;
1331 1304
… …
1348 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER))) 1321 (!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) || tmp->type == PLAYER)))
1349 { 1322 {
1350 if (spell_ob->subtype == SP_DESTRUCTION) 1323 if (spell_ob->subtype == SP_DESTRUCTION)
1351 { 1324 {
1352 hit_player (tmp, dam, op, spell_ob->attacktype, 0); 1325 hit_player (tmp, dam, op, spell_ob->attacktype, 0);
1326
1353 if (spell_ob->other_arch) 1327 if (spell_ob->other_arch)
1354 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op); 1328 m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1355 } 1329 }
1356 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100) 1330 else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1357 { 1331 {
… …
1385 { 1359 {
1386 new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse."); 1360 new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");
1387 return 0; 1361 return 0;
1388 } 1362 }
1389 1363
1364 tmp = tmp->head_ ();
1365
1390 /* If we've already got a force of this type, don't add a new one. */ 1366 /* If we've already got a force of this type, don't add a new one. */
1391 for (force = tmp->inv; force != NULL; force = force->below) 1367 for (force = tmp->inv; force; force = force->below)
1392 { 1368 {
1393 if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY) 1369 if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
1394 { 1370 {
1395 if (force->name == spell_ob->name) 1371 if (force->name == spell_ob->name)
1396 { 1372 {
… …
1402 return 0; 1378 return 0;
1403 } 1379 }
1404 } 1380 }
1405 } 1381 }
1406 1382
1407 if (force == NULL) 1383 if (!force)
1408 { 1384 {
1409 force = get_archetype (FORCE_NAME); 1385 force = get_archetype (FORCE_NAME);
1410 force->subtype = FORCE_CHANGE_ABILITY; 1386 force->subtype = FORCE_CHANGE_ABILITY;
1387
1411 if (spell_ob->race) 1388 if (spell_ob->race)
1412 force->name = spell_ob->race; 1389 force->name = spell_ob->race;
1413 else 1390 else
1414 force->name = spell_ob->name; 1391 force->name = spell_ob->name;
1415 1392
… …
1425 { 1402 {
1426 force->duration = duration; 1403 force->duration = duration;
1427 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1404 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1428 } 1405 }
1429 else 1406 else
1430 {
1431 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1407 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1432 } 1408
1433 return 1; 1409 return 1;
1434 } 1410 }
1411
1435 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1412 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1436 force->speed = 1.f; 1413 force->speed = 1.f;
1437 force->speed_left = -1.f; 1414 force->speed_left = -1.f;
1438 SET_FLAG (force, FLAG_APPLIED); 1415 SET_FLAG (force, FLAG_APPLIED);
1439 1416
… …
1482 1459
1483 /* We precompute some values here so that we don't have to keep 1460 /* We precompute some values here so that we don't have to keep
1484 * doing it over and over again. 1461 * doing it over and over again.
1485 */ 1462 */
1486 god = find_god (determine_god (op)); 1463 god = find_god (determine_god (op));
1487 level = caster_level (caster, spell); 1464 level = casting_level (caster, spell);
1488 range = spell->range + SP_level_range_adjust (caster, spell); 1465 range = spell->range + SP_level_range_adjust (caster, spell);
1489 1466
1490 /* On the bright side, no monster should ever have a race of GOD_... 1467 /* On the bright side, no monster should ever have a race of GOD_...
1491 * so even if the player doesn't worship a god, if race=GOD_.., it 1468 * so even if the player doesn't worship a god, if race=GOD_.., it
1492 * won't ever match anything. 1469 * won't ever match anything.
… …
1612 } 1589 }
1613 1590
1614 /* charm */ 1591 /* charm */
1615 if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY)) 1592 if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
1616 { 1593 {
1594 INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
1595
1617 /* Prevent uncontolled outbreaks of self replicating monsters. 1596 /* Prevent uncontrolled outbreaks of self replicating monsters.
1618 Typical use case is charm, go somwhere, use aggravation to make hostile. 1597 Typical use case is charm, go somwhere, use aggravation to make hostile.
1619 This could lead to fun stuff like mice outbreak in bigworld and server crawl. */ 1598 This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1620 CLEAR_FLAG (head, FLAG_GENERATOR); 1599 CLEAR_FLAG (head, FLAG_GENERATOR);
1621 head->set_owner (op); 1600 head->set_owner (op);
1622 set_spell_skill (op, caster, spell, head); 1601 set_spell_skill (op, caster, spell, head);
… …
1640 * about. was called move_ball_lightning, but since more than the ball 1619 * about. was called move_ball_lightning, but since more than the ball
1641 * lightning spell used it, that seemed misnamed. 1620 * lightning spell used it, that seemed misnamed.
1642 * op is the spell effect. 1621 * op is the spell effect.
1643 * note that duration is handled by process_object() in time.c 1622 * note that duration is handled by process_object() in time.c
1644 */ 1623 */
1645
1646void 1624void
1647move_ball_spell (object *op) 1625move_ball_spell (object *op)
1648{ 1626{
1649 int i, j, dam_save, dir, mflags; 1627 int i, j, dam_save, dir, mflags;
1650 sint16 nx, ny, hx, hy; 1628 sint16 nx, ny, hx, hy;
… …
1716 1694
1717 if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op))) 1695 if ((mflags & P_IS_ALIVE) && (!owner || owner->x != hx || owner->y != hy || !on_same_map (owner, op)))
1718 { 1696 {
1719 if (j) 1697 if (j)
1720 op->stats.dam = dam_save / 2; 1698 op->stats.dam = dam_save / 2;
1699
1721 hit_map (op, j, op->attacktype, 1); 1700 hit_map (op, j, op->attacktype, 1);
1722
1723 } 1701 }
1724 1702
1725 /* insert the other arch */ 1703 /* insert the other arch */
1726 if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy)))) 1704 if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1727 m->insert (arch_to_object (op->other_arch), hx, hy, op); 1705 m->insert (arch_to_object (op->other_arch), hx, hy, op);
… …
1741 1719
1742 op->direction = i; 1720 op->direction = i;
1743 } 1721 }
1744} 1722}
1745 1723
1746
1747/* move_swarm_spell: peterm 1724/* move_swarm_spell: peterm
1748 * This is an implementation of the swarm spell. It was written for 1725 * This is an implementation of the swarm spell. It was written for
1749 * meteor swarm, but it could be used for any swarm. A swarm spell 1726 * meteor swarm, but it could be used for any swarm. A swarm spell
1750 * is a special type of object that casts swarms of other types 1727 * is a special type of object that casts swarms of other types
1751 * of spells. Which spell it casts is flexible. It fires the spells 1728 * of spells. Which spell it casts is flexible. It fires the spells
1752 * from a set of squares surrounding the caster, in a given direction. 1729 * from a set of squares surrounding the caster, in a given direction.
1753 */ 1730 */
1754
1755void 1731void
1756move_swarm_spell (object *op) 1732move_swarm_spell (object *op)
1757{ 1733{
1758#if 0 1734#if 0
1759 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 }; 1735 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1760 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 }; 1736 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1761 sint16 target_x, target_y, origin_x, origin_y; 1737 sint16 target_x, target_y, origin_x, origin_y;
1762 int adjustdir; 1738 int adjustdir;
1763 maptile *m; 1739 maptile *m;
1764#endif 1740#endif
1765 int basedir;
1766 object *owner; 1741 object *owner = op->env;
1767 1742
1768 owner = op->owner; 1743 if (!owner) // MUST not happen, remove when true TODO
1769 if (op->duration == 0 || owner == NULL)
1770 { 1744 {
1745 LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1771 op->destroy (); 1746 op->destroy (true);
1747 return;
1748 }
1749
1750 if (!op->duration || !owner->is_on_map ())
1751 {
1752 op->destroy_inv (true); // be explicit about dropping
1753 op->destroy (true);
1772 return; 1754 return;
1773 } 1755 }
1774 1756
1775 op->duration--; 1757 op->duration--;
1776 1758
1777 basedir = op->direction; 1759 int basedir = op->direction;
1778 if (basedir == 0) 1760 if (!basedir)
1779 { 1761 {
1780 /* spray in all directions! 8) */ 1762 /* spray in all directions! 8) */
1781 basedir = rndm (1, 8); 1763 op->facing = (op->facing + op->state) & 7;
1764 basedir = op->facing + 1;
1782 } 1765 }
1783 1766
1784#if 0 1767#if 0
1785 // this is bogus: it causes wrong places to be checked below 1768 // this is bogus: it causes wrong places to be checked below
1786 // (a wall 2 cells away will block the effect...) and 1769 // (a wall 2 cells away will block the effect...) and
… …
1847 { 1830 {
1848 /* Bullet spells have a bunch more customization that needs to be done */ 1831 /* Bullet spells have a bunch more customization that needs to be done */
1849 if (op->spell->subtype == SP_BULLET) 1832 if (op->spell->subtype == SP_BULLET)
1850 fire_bullet (owner, op, basedir, op->spell); 1833 fire_bullet (owner, op, basedir, op->spell);
1851 else if (op->spell->subtype == SP_MAGIC_MISSILE) 1834 else if (op->spell->subtype == SP_MAGIC_MISSILE)
1852 fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell); 1835 fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1853 } 1836 }
1854} 1837}
1855
1856
1857
1858 1838
1859/* fire_swarm: 1839/* fire_swarm:
1860 * The following routine creates a swarm of objects. It actually 1840 * The following routine creates a swarm of objects. It actually
1861 * sets up a specific swarm object, which then fires off all 1841 * sets up a specific swarm object, which then fires off all
1862 * the parts of the swarm. 1842 * the parts of the swarm.
… …
1865 * caster: the caster (owner, wand, rod, scroll) 1845 * caster: the caster (owner, wand, rod, scroll)
1866 * dir: the direction everything will be fired in 1846 * dir: the direction everything will be fired in
1867 * spell - the spell that is this spell. 1847 * spell - the spell that is this spell.
1868 * n: the number to be fired. 1848 * n: the number to be fired.
1869 */ 1849 */
1870
1871int 1850int
1872fire_swarm (object *op, object *caster, object *spell, int dir) 1851fire_swarm (object *op, object *caster, object *spell, int dir)
1873{ 1852{
1874 object *tmp;
1875 int i;
1876
1877 if (!spell->other_arch) 1853 if (!spell->other_arch)
1878 return 0; 1854 return 0;
1879 1855
1880 tmp = get_archetype (SWARM_SPELL); 1856 object *tmp = archetype::get (SWARM_SPELL);
1881 tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */ 1857
1882 set_spell_skill (op, caster, spell, tmp); 1858 set_spell_skill (op, caster, spell, tmp);
1883
1884 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */ 1859 tmp->level = casting_level (caster, spell); /* needed later, to get level dep. right. */
1885 tmp->spell = arch_to_object (spell->other_arch); 1860 tmp->spell = spell->other_arch->instance ();
1886
1887 tmp->attacktype = tmp->spell->attacktype; 1861 tmp->attacktype = tmp->spell->attacktype;
1888 1862
1889 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) 1863 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1890 if (!tailor_god_spell (tmp, op)) 1864 if (!tailor_god_spell (tmp, op))
1891 return 1; 1865 return 1;
1892 1866
1893 tmp->duration = SP_level_duration_adjust (caster, spell); 1867 tmp->duration = SP_level_duration_adjust (caster, spell);
1894 for (i = 0; i < spell->duration; i++) 1868 for (int i = 0; i < spell->duration; i++)
1895 tmp->duration += die_roll (1, 3, op, PREFER_HIGH); 1869 tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1896 1870
1871 tmp->invisible = 1;
1872 tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1897 tmp->direction = dir; 1873 tmp->direction = dir;
1898 tmp->invisible = 1; 1874 tmp->facing = rndm (1, 8); // initial firing direction
1875 tmp->state = rndm (4) * 2 + 1; // direction increment
1899 1876
1900 tmp->insert_at (op, op); 1877 op->insert (tmp);
1878
1901 return 1; 1879 return 1;
1902} 1880}
1903
1904 1881
1905/* See the spells documentation file for why this is its own 1882/* See the spells documentation file for why this is its own
1906 * function. 1883 * function.
1907 */ 1884 */
1908int 1885int
… …
1939 if (QUERY_FLAG (target, FLAG_MONSTER)) 1916 if (QUERY_FLAG (target, FLAG_MONSTER))
1940 { 1917 {
1941 /* oky doky. got a target monster. Lets make a blinding attack */ 1918 /* oky doky. got a target monster. Lets make a blinding attack */
1942 if (target->head) 1919 if (target->head)
1943 target = target->head; 1920 target = target->head;
1921
1944 (void) hit_player (target, dam, op, spell->attacktype, 1); 1922 hit_player (target, dam, op, spell->attacktype, 1);
1945 return 1; /* one success only! */ 1923 return 1; /* one success only! */
1946 } 1924 }
1947 } 1925 }
1948 1926
1949 /* no live target, perhaps a wall is in the way? */ 1927 /* no live target, perhaps a wall is in the way? */
… …
1969 } 1947 }
1970 1948
1971 m->insert (tmp, x, y, op); 1949 m->insert (tmp, x, y, op);
1972 return 1; 1950 return 1;
1973} 1951}
1974
1975
1976
1977 1952
1978/* cast_cause_disease: this spell looks along <dir> from the 1953/* cast_cause_disease: this spell looks along <dir> from the
1979 * player and infects someone. 1954 * player and infects someone.
1980 * op is the player/monster, caster is the object, dir is the direction 1955 * op is the player/monster, caster is the object, dir is the direction
1981 * to cast, disease_arch is the specific disease, and type is the spell number 1956 * to cast, disease_arch is the specific disease, and type is the spell number
1982 * perhaps this should actually be in disease.c? 1957 * perhaps this should actually be in disease.c?
1983 */ 1958 */
1984
1985int 1959int
1986cast_cause_disease (object *op, object *caster, object *spell, int dir) 1960cast_cause_disease (object *op, object *caster, object *spell, int dir)
1987{ 1961{
1988 sint16 x, y; 1962 sint16 x, y;
1989 int i, mflags, range, dam_mod, dur_mod; 1963 int i, mflags, range, dam_mod, dur_mod;
… …
1996 /* If casting from a scroll, no direction will be available, so refer to the 1970 /* If casting from a scroll, no direction will be available, so refer to the
1997 * direction the player is pointing. 1971 * direction the player is pointing.
1998 */ 1972 */
1999 if (!dir) 1973 if (!dir)
2000 dir = op->facing; 1974 dir = op->facing;
1975
2001 if (!dir) 1976 if (!dir)
2002 return 0; /* won't find anything if casting on ourself, so just return */ 1977 return 0; /* won't find anything if casting on ourself, so just return */
2003 1978
2004 /* Calculate these once here */ 1979 /* Calculate these once here */
2005 range = spell->range + SP_level_range_adjust (caster, spell); 1980 range = spell->range + SP_level_range_adjust (caster, spell);
… …
2032 object *disease = arch_to_object (spell->other_arch); 2007 object *disease = arch_to_object (spell->other_arch);
2033 2008
2034 disease->set_owner (op); 2009 disease->set_owner (op);
2035 set_spell_skill (op, caster, spell, disease); 2010 set_spell_skill (op, caster, spell, disease);
2036 disease->stats.exp = 0; 2011 disease->stats.exp = 0;
2037 disease->level = caster_level (caster, spell); 2012 disease->level = casting_level (caster, spell);
2038 2013
2039 /* do level adjustments */ 2014 /* do level adjustments */
2040 if (disease->stats.wc) 2015 if (disease->stats.wc)
2041 disease->stats.wc += dur_mod / 2; 2016 disease->stats.wc += dur_mod / 2;
2042 2017
2043 if (disease->magic > 0) 2018 if (disease->magic > 0)
2044 disease->magic += dur_mod / 4; 2019 disease->magic += dur_mod / 8;
2045 2020
2046 if (disease->stats.maxhp > 0) 2021 if (disease->stats.maxhp > 0)
2047 disease->stats.maxhp += dur_mod; 2022 disease->stats.maxhp += dur_mod;
2048 2023
2049 if (disease->stats.maxgrace > 0) 2024 if (disease->stats.maxgrace > 0)
… …
2086 2061
2087 if (infect_object (walk, disease, 1)) 2062 if (infect_object (walk, disease, 1))
2088 { 2063 {
2089 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name); 2064 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2090 2065
2091 disease->destroy (); /* don't need this one anymore */ 2066 disease->destroy (true); /* don't need this one anymore */
2092 walk->map->insert (get_archetype ("detect_magic"), x, y, op); 2067 walk->map->insert (get_archetype ("detect_magic"), x, y, op);
2093 return 1; 2068 return 1;
2094 } 2069 }
2095 2070
2096 disease->destroy (); 2071 disease->destroy (true);
2097 } 2072 }
2098 } /* if living creature */ 2073 } /* if living creature */
2099 } /* for range of spaces */ 2074 } /* for range of spaces */
2100 2075
2101 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!"); 2076 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");

Diff Legend

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