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.11 by root, Mon Sep 11 20:26:41 2006 UTC vs.
Revision 1.16 by root, Tue Dec 12 20:53:03 2006 UTC

1
2/*
3 * static char *rcsid_spell_attack_c =
4 * "$Id: spell_attack.C,v 1.11 2006/09/11 20:26:41 root Exp $";
5 */
6
7
8/* 1/*
9 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
10 3
11 Copyright (C) 2002-2003 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002-2003 Mark Wedel & Crossfire Development Team
12 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
23 16
24 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 20
28 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
29*/ 22*/
30 23
31/* This file contains all the spell attack code. Grouping this code 24/* This file contains all the spell attack code. Grouping this code
32 * together should hopefully make it easier to find the relevent bits 25 * together should hopefully make it easier to find the relevent bits
33 * of code 26 * of code
… …
124void 117void
125forklightning (object *op, object *tmp) 118forklightning (object *op, object *tmp)
126{ 119{
127 int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */ 120 int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
128 int t_dir; /* stores temporary dir calculation */ 121 int t_dir; /* stores temporary dir calculation */
129 mapstruct *m; 122 maptile *m;
130 sint16 sx, sy; 123 sint16 sx, sy;
131 object *new_bolt; 124 object *new_bolt;
132 125
133 /* pick a fork direction. tmp->stats.Con is the left bias 126 /* pick a fork direction. tmp->stats.Con is the left bias
134 * i.e., the chance in 100 of forking LEFT 127 * i.e., the chance in 100 of forking LEFT
… …
177move_bolt (object *op) 170move_bolt (object *op)
178{ 171{
179 object *tmp; 172 object *tmp;
180 int mflags; 173 int mflags;
181 sint16 x, y; 174 sint16 x, y;
182 mapstruct *m; 175 maptile *m;
183 176
184 if (--(op->duration) < 0) 177 if (--(op->duration) < 0)
185 { 178 {
186 remove_ob (op); 179 op->remove ();
187 free_object (op); 180 op->destroy (0);
188 return; 181 return;
189 } 182 }
190 183
191 hit_map (op, 0, op->attacktype, 1); 184 hit_map (op, 0, op->attacktype, 1);
192 185
… …
327 tmp->map = op->map; 320 tmp->map = op->map;
328 321
329 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y); 322 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y);
330 if (mflags & P_OUT_OF_MAP) 323 if (mflags & P_OUT_OF_MAP)
331 { 324 {
332 free_object (tmp); 325 tmp->destroy (0);
333 return 0; 326 return 0;
334 } 327 }
335 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 328 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
336 { 329 {
337 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 330 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
338 { 331 {
339 free_object (tmp); 332 tmp->destroy (0);
340 return 0; 333 return 0;
341 } 334 }
342 tmp->x = op->x; 335 tmp->x = op->x;
343 tmp->y = op->y; 336 tmp->y = op->y;
344 tmp->direction = absdir (tmp->direction + 4); 337 tmp->direction = absdir (tmp->direction + 4);
… …
363 */ 356 */
364void 357void
365explosion (object *op) 358explosion (object *op)
366{ 359{
367 object *tmp; 360 object *tmp;
368 mapstruct *m = op->map; 361 maptile *m = op->map;
369 int i; 362 int i;
370 363
371 if (--(op->duration) < 0) 364 if (--(op->duration) < 0)
372 { 365 {
373 remove_ob (op); 366 op->remove ();
374 free_object (op); 367 op->destroy (0);
375 return; 368 return;
376 } 369 }
377 hit_map (op, 0, op->attacktype, 0); 370 hit_map (op, 0, op->attacktype, 0);
378 371
379 if (op->range > 0) 372 if (op->range > 0)
… …
409 * explode. 402 * explode.
410 */ 403 */
411void 404void
412explode_bullet (object *op) 405explode_bullet (object *op)
413{ 406{
414 tag_t op_tag = op->count;
415 object *tmp, *owner; 407 object *tmp, *owner;
416 408
417 if (op->other_arch == NULL) 409 if (op->other_arch == NULL)
418 { 410 {
419 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 411 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
420 remove_ob (op); 412 op->remove ();
421 free_object (op); 413 op->destroy (0);
422 return; 414 return;
423 } 415 }
424 416
425 if (op->env) 417 if (op->env)
426 { 418 {
… …
428 420
429 env = object_get_env_recursive (op); 421 env = object_get_env_recursive (op);
430 if (env->map == NULL || out_of_map (env->map, env->x, env->y)) 422 if (env->map == NULL || out_of_map (env->map, env->x, env->y))
431 { 423 {
432 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 424 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
433 remove_ob (op); 425 op->remove ();
434 free_object (op); 426 op->destroy (0);
435 return; 427 return;
436 } 428 }
437 remove_ob (op); 429 op->remove ();
438 op->x = env->x; 430 op->x = env->x;
439 op->y = env->y; 431 op->y = env->y;
440 insert_ob_in_map (op, env->map, op, INS_NO_MERGE | INS_NO_WALK_ON); 432 insert_ob_in_map (op, env->map, op, INS_NO_MERGE | INS_NO_WALK_ON);
441 } 433 }
442 else if (out_of_map (op->map, op->x, op->y)) 434 else if (out_of_map (op->map, op->x, op->y))
443 { 435 {
444 LOG (llevError, "BUG: explode_bullet(): op out of map\n"); 436 LOG (llevError, "BUG: explode_bullet(): op out of map\n");
445 remove_ob (op); 437 op->remove ();
446 free_object (op); 438 op->destroy (0);
447 return; 439 return;
448 } 440 }
449 441
450 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps 442 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps
451 // NOTE: If this breaks something important: remove this. I can't think of anything 443 // NOTE: If this breaks something important: remove this. I can't think of anything
452 // bad at the moment that might happen from this. 444 // bad at the moment that might happen from this.
453 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE) 445 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
454 { 446 {
455 remove_ob (op); 447 op->remove ();
456 free_object (op); 448 op->destroy (0);
457 return; 449 return;
458 } 450 }
459 451
460 if (op->attacktype) 452 if (op->attacktype)
461 { 453 {
462 hit_map (op, 0, op->attacktype, 1); 454 hit_map (op, 0, op->attacktype, 1);
463 if (was_destroyed (op, op_tag)) 455 if (op->destroyed ())
464 return; 456 return;
465 } 457 }
466 458
467 /* other_arch contains what this explodes into */ 459 /* other_arch contains what this explodes into */
468 tmp = arch_to_object (op->other_arch); 460 tmp = arch_to_object (op->other_arch);
… …
472 464
473 owner = get_owner (op); 465 owner = get_owner (op);
474 466
475 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner)) 467 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))
476 { 468 {
477 remove_ob (op); 469 op->remove ();
478 free_object (op); 470 op->destroy (0);
479 return; 471 return;
480 } 472 }
481 473
482 tmp->x = op->x; 474 tmp->x = op->x;
483 tmp->y = op->y; 475 tmp->y = op->y;
… …
511 /* Prevent recursion */ 503 /* Prevent recursion */
512 op->move_on = 0; 504 op->move_on = 0;
513 505
514 insert_ob_in_map (tmp, op->map, op, 0); 506 insert_ob_in_map (tmp, op->map, op, 0);
515 /* remove the firebullet */ 507 /* remove the firebullet */
516 if (!was_destroyed (op, op_tag)) 508 if (!op->destroyed ())
517 { 509 {
518 remove_ob (op); 510 op->remove ();
519 free_object (op); 511 op->destroy (0);
520 } 512 }
521} 513}
522 514
523 515
524 516
… …
527 */ 519 */
528 520
529void 521void
530check_bullet (object *op) 522check_bullet (object *op)
531{ 523{
532 tag_t op_tag = op->count, tmp_tag;
533 object *tmp; 524 object *tmp;
534 int dam, mflags; 525 int dam, mflags;
535 mapstruct *m; 526 maptile *m;
536 sint16 sx, sy; 527 sint16 sx, sy;
537 528
538 mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy); 529 mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy);
539 530
540 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 531 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
… …
553 544
554 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 545 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
555 { 546 {
556 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 547 if (QUERY_FLAG (tmp, FLAG_ALIVE))
557 { 548 {
558 tmp_tag = tmp->count;
559 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 549 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
560 if (was_destroyed (op, op_tag) || !was_destroyed (tmp, tmp_tag) || (op->stats.dam -= dam) < 0) 550 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
561 { 551 {
562 if (!QUERY_FLAG (op, FLAG_REMOVED)) 552 if (!QUERY_FLAG (op, FLAG_REMOVED))
563 { 553 {
564 remove_ob (op); 554 op->remove ();
565 free_object (op); 555 op->destroy (0);
566 return; 556 return;
567 } 557 }
568 } 558 }
569 } 559 }
570 } 560 }
… …
580void 570void
581move_bullet (object *op) 571move_bullet (object *op)
582{ 572{
583 sint16 new_x, new_y; 573 sint16 new_x, new_y;
584 int mflags; 574 int mflags;
585 mapstruct *m; 575 maptile *m;
586 576
587#if 0 577#if 0
588 /* We need a better general purpose way to do this */ 578 /* We need a better general purpose way to do this */
589 579
590 /* peterm: added to make comet leave a trail of burnouts 580 /* peterm: added to make comet leave a trail of burnouts
591 it's an unadulterated hack, but the effect is cool. */ 581 it's an unadulterated hack, but the effect is cool. */
592 if (op->stats.sp == SP_METEOR) 582 if (op->stats.sp == SP_METEOR)
593 { 583 {
594 replace_insert_ob_in_map ("fire_trail", op); 584 replace_insert_ob_in_map ("fire_trail", op);
595 if (was_destroyed (op, op_tag)) 585 if (op->destroyed ())
596 return; 586 return;
597 } /* end addition. */ 587 } /* end addition. */
598#endif 588#endif
599 589
600 /* Reached the end of its life - remove it */ 590 /* Reached the end of its life - remove it */
… …
604 { 594 {
605 explode_bullet (op); 595 explode_bullet (op);
606 } 596 }
607 else 597 else
608 { 598 {
609 remove_ob (op); 599 op->remove ();
610 free_object (op); 600 op->destroy (0);
611 } 601 }
612 return; 602 return;
613 } 603 }
614 604
615 new_x = op->x + DIRX (op); 605 new_x = op->x + DIRX (op);
… …
617 m = op->map; 607 m = op->map;
618 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y); 608 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
619 609
620 if (mflags & P_OUT_OF_MAP) 610 if (mflags & P_OUT_OF_MAP)
621 { 611 {
622 remove_ob (op); 612 op->remove ();
623 free_object (op); 613 op->destroy (0);
624 return; 614 return;
625 } 615 }
626 616
627 if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))) 617 if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))
628 { 618 {
… …
630 { 620 {
631 explode_bullet (op); 621 explode_bullet (op);
632 } 622 }
633 else 623 else
634 { 624 {
635 remove_ob (op); 625 op->remove ();
636 free_object (op); 626 op->destroy (0);
637 } 627 }
638 return; 628 return;
639 } 629 }
640 630
641 remove_ob (op); 631 op->remove ();
642 op->x = new_x; 632 op->x = new_x;
643 op->y = new_y; 633 op->y = new_y;
644 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL) 634 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL)
645 return; 635 return;
646 636
… …
705 tmp->map = op->map; 695 tmp->map = op->map;
706 696
707 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y); 697 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y);
708 if (mflags & P_OUT_OF_MAP) 698 if (mflags & P_OUT_OF_MAP)
709 { 699 {
710 free_object (tmp); 700 tmp->destroy (0);
711 return 0; 701 return 0;
712 } 702 }
713 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 703 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
714 { 704 {
715 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 705 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
716 { 706 {
717 free_object (tmp); 707 tmp->destroy (0);
718 return 0; 708 return 0;
719 } 709 }
720 tmp->x = op->x; 710 tmp->x = op->x;
721 tmp->y = op->y; 711 tmp->y = op->y;
722 tmp->direction = absdir (tmp->direction + 4); 712 tmp->direction = absdir (tmp->direction + 4);
… …
763 753
764void 754void
765move_cone (object *op) 755move_cone (object *op)
766{ 756{
767 int i; 757 int i;
768 tag_t tag;
769 758
770 /* if no map then hit_map will crash so just ignore object */ 759 /* if no map then hit_map will crash so just ignore object */
771 if (!op->map) 760 if (!op->map)
772 { 761 {
773 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown"); 762 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
… …
788 * when their cone dies when they die. 777 * when their cone dies when they die.
789 */ 778 */
790 /* If no owner left, the spell dies out. */ 779 /* If no owner left, the spell dies out. */
791 if (get_owner (op) == NULL) 780 if (get_owner (op) == NULL)
792 { 781 {
793 remove_ob (op); 782 op->remove ();
794 free_object (op); 783 op->destroy (0);
795 return; 784 return;
796 } 785 }
797#endif 786#endif
798 787
799 tag = op->count;
800 hit_map (op, 0, op->attacktype, 0); 788 hit_map (op, 0, op->attacktype, 0);
801 789
802 /* Check to see if we should push anything. 790 /* Check to see if we should push anything.
803 * Spell objects with weight push whatever they encounter to some 791 * Spell objects with weight push whatever they encounter to some
804 * degree. 792 * degree.
805 */ 793 */
806 if (op->weight) 794 if (op->weight)
807 check_spell_knockback (op); 795 check_spell_knockback (op);
808 796
809 if (was_destroyed (op, tag)) 797 if (op->destroyed ())
810 return; 798 return;
811 799
812 if ((op->duration--) < 0) 800 if ((op->duration--) < 0)
813 { 801 {
814 remove_ob (op); 802 op->remove ();
815 free_object (op); 803 op->destroy (0);
816 return; 804 return;
817 } 805 }
818 /* Object has hit maximum range, so don't have it move 806 /* Object has hit maximum range, so don't have it move
819 * any further. When the duration above expires, 807 * any further. When the duration above expires,
820 * then the object will get removed. 808 * then the object will get removed.
… …
859int 847int
860cast_cone (object *op, object *caster, int dir, object *spell) 848cast_cone (object *op, object *caster, int dir, object *spell)
861{ 849{
862 object *tmp; 850 object *tmp;
863 int i, success = 0, range_min = -1, range_max = 1; 851 int i, success = 0, range_min = -1, range_max = 1;
864 mapstruct *m; 852 maptile *m;
865 sint16 sx, sy; 853 sint16 sx, sy;
866 MoveType movetype; 854 MoveType movetype;
867 855
868 if (!spell->other_arch) 856 if (!spell->other_arch)
869 return 0; 857 return 0;
… …
1024 return; 1012 return;
1025 1013
1026 if (env->type == PLAYER) 1014 if (env->type == PLAYER)
1027 esrv_del_item (env->contr, op->count); 1015 esrv_del_item (env->contr, op->count);
1028 1016
1029 remove_ob (op); 1017 op->remove ();
1030 op->x = env->x; 1018 op->x = env->x;
1031 op->y = env->y; 1019 op->y = env->y;
1032 if ((op = insert_ob_in_map (op, env->map, op, 0)) == NULL) 1020 if ((op = insert_ob_in_map (op, env->map, op, 0)) == NULL)
1033 return; 1021 return;
1034 } 1022 }
… …
1036 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding 1024 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
1037 // on a safe map. I don't like this special casing, but it seems to be neccessary 1025 // on a safe map. I don't like this special casing, but it seems to be neccessary
1038 // as bombs can be carried. 1026 // as bombs can be carried.
1039 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE) 1027 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
1040 { 1028 {
1041 remove_ob (op); 1029 op->remove ();
1042 free_object (op); 1030 op->destroy (0);
1043 return; 1031 return;
1044 } 1032 }
1045 1033
1046 /* This copies a lot of the code from the fire bullet, 1034 /* This copies a lot of the code from the fire bullet,
1047 * but using the cast_bullet isn't really feasible, 1035 * but using the cast_bullet isn't really feasible,
1048 * so just set up the appropriate values. 1036 * so just set up the appropriate values.
1049 */ 1037 */
1050 at = find_archetype (SPLINT); 1038 at = archetype::find (SPLINT);
1051 if (at) 1039 if (at)
1052 { 1040 {
1053 for (i = 1; i < 9; i++) 1041 for (i = 1; i < 9; i++)
1054 { 1042 {
1055 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i])) 1043 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
… …
1082{ 1070{
1083 1071
1084 object *tmp; 1072 object *tmp;
1085 int mflags; 1073 int mflags;
1086 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir]; 1074 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1087 mapstruct *m; 1075 maptile *m;
1088 1076
1089 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy); 1077 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
1090 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK)) 1078 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1091 { 1079 {
1092 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1080 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
… …
1128get_pointed_target (object *op, int dir, int range, int type) 1116get_pointed_target (object *op, int dir, int range, int type)
1129{ 1117{
1130 object *target; 1118 object *target;
1131 sint16 x, y; 1119 sint16 x, y;
1132 int dist, mflags; 1120 int dist, mflags;
1133 mapstruct *mp; 1121 maptile *mp;
1134 1122
1135 if (dir == 0) 1123 if (dir == 0)
1136 return NULL; 1124 return NULL;
1137 1125
1138 for (dist = 1; dist < range; dist++) 1126 for (dist = 1; dist < range; dist++)
… …
1241 } 1229 }
1242 else 1230 else
1243 { 1231 {
1244 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target)); 1232 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1245 target->stats.hp = target->stats.maxhp * 2; 1233 target->stats.hp = target->stats.maxhp * 2;
1246 free_object (effect); 1234 effect->destroy (0);
1247 return 0; 1235 return 0;
1248 } 1236 }
1249 } 1237 }
1250 } 1238 }
1251 else 1239 else
… …
1278move_missile (object *op) 1266move_missile (object *op)
1279{ 1267{
1280 int i, mflags; 1268 int i, mflags;
1281 object *owner; 1269 object *owner;
1282 sint16 new_x, new_y; 1270 sint16 new_x, new_y;
1283 mapstruct *m; 1271 maptile *m;
1284 1272
1285 if (op->range-- <= 0) 1273 if (op->range-- <= 0)
1286 { 1274 {
1287 remove_ob (op); 1275 op->remove ();
1288 free_object (op); 1276 op->destroy (0);
1289 return; 1277 return;
1290 } 1278 }
1291 1279
1292 owner = get_owner (op); 1280 owner = get_owner (op);
1293#if 0 1281#if 0
1294 /* It'd make things nastier if this wasn't here - spells cast by 1282 /* It'd make things nastier if this wasn't here - spells cast by
1295 * monster that are then killed would continue to survive 1283 * monster that are then killed would continue to survive
1296 */ 1284 */
1297 if (owner == NULL) 1285 if (owner == NULL)
1298 { 1286 {
1299 remove_ob (op); 1287 op->remove ();
1300 free_object (op); 1288 op->destroy (0);
1301 return; 1289 return;
1302 } 1290 }
1303#endif 1291#endif
1304 1292
1305 new_x = op->x + DIRX (op); 1293 new_x = op->x + DIRX (op);
… …
1307 1295
1308 mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y); 1296 mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1309 1297
1310 if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))) 1298 if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1311 { 1299 {
1312 tag_t tag = op->count;
1313
1314 hit_map (op, op->direction, AT_MAGIC, 1); 1300 hit_map (op, op->direction, AT_MAGIC, 1);
1315 /* Basically, missile only hits one thing then goes away. 1301 /* Basically, missile only hits one thing then goes away.
1316 * we need to remove it if someone hasn't already done so. 1302 * we need to remove it if someone hasn't already done so.
1317 */ 1303 */
1318 if (!was_destroyed (op, tag)) 1304 if (!op->destroyed ())
1319 { 1305 op->destroy (0);
1320 remove_ob (op); 1306
1321 free_object (op);
1322 }
1323 return; 1307 return;
1324 } 1308 }
1325 1309
1326 remove_ob (op); 1310 op->remove ();
1311
1327 if (!op->direction || (mflags & P_OUT_OF_MAP)) 1312 if (!op->direction || (mflags & P_OUT_OF_MAP))
1328 { 1313 {
1329 free_object (op); 1314 op->destroy (0);
1330 return; 1315 return;
1331 } 1316 }
1317
1332 op->x = new_x; 1318 op->x = new_x;
1333 op->y = new_y; 1319 op->y = new_y;
1334 op->map = m; 1320 op->map = m;
1335 i = spell_find_dir (op->map, op->x, op->y, get_owner (op)); 1321 i = spell_find_dir (op->map, op->x, op->y, get_owner (op));
1336 if (i > 0 && i != op->direction) 1322 if (i > 0 && i != op->direction)
1337 { 1323 {
1338 op->direction = i; 1324 op->direction = i;
1339 SET_ANIMATION (op, op->direction); 1325 SET_ANIMATION (op, op->direction);
1340 } 1326 }
1327
1341 insert_ob_in_map (op, op->map, op, 0); 1328 insert_ob_in_map (op, op->map, op, 0);
1342} 1329}
1343 1330
1344/**************************************************************************** 1331/****************************************************************************
1345 * Destruction 1332 * Destruction
… …
1391int 1378int
1392cast_destruction (object *op, object *caster, object *spell_ob) 1379cast_destruction (object *op, object *caster, object *spell_ob)
1393{ 1380{
1394 int i, j, range, mflags, friendly = 0, dam, dur; 1381 int i, j, range, mflags, friendly = 0, dam, dur;
1395 sint16 sx, sy; 1382 sint16 sx, sy;
1396 mapstruct *m; 1383 maptile *m;
1397 object *tmp; 1384 object *tmp;
1398 const char *skill; 1385 const char *skill;
1399 1386
1400 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 1387 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1401 dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 1388 dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
… …
1583mood_change (object *op, object *caster, object *spell) 1570mood_change (object *op, object *caster, object *spell)
1584{ 1571{
1585 object *tmp, *god, *head; 1572 object *tmp, *god, *head;
1586 int done_one, range, mflags, level, at, best_at; 1573 int done_one, range, mflags, level, at, best_at;
1587 sint16 x, y, nx, ny; 1574 sint16 x, y, nx, ny;
1588 mapstruct *m; 1575 maptile *m;
1589 const char *race; 1576 const char *race;
1590 1577
1591 /* We precompute some values here so that we don't have to keep 1578 /* We precompute some values here so that we don't have to keep
1592 * doing it over and over again. 1579 * doing it over and over again.
1593 */ 1580 */
… …
1757move_ball_spell (object *op) 1744move_ball_spell (object *op)
1758{ 1745{
1759 int i, j, dam_save, dir, mflags; 1746 int i, j, dam_save, dir, mflags;
1760 sint16 nx, ny, hx, hy; 1747 sint16 nx, ny, hx, hy;
1761 object *owner; 1748 object *owner;
1762 mapstruct *m; 1749 maptile *m;
1763 1750
1764 owner = get_owner (op); 1751 owner = get_owner (op);
1765 1752
1766 /* the following logic makes sure that the ball doesn't move into a wall, 1753 /* the following logic makes sure that the ball doesn't move into a wall,
1767 * and makes sure that it will move along a wall to try and get at it's 1754 * and makes sure that it will move along a wall to try and get at it's
… …
1798 nx = op->x; 1785 nx = op->x;
1799 ny = op->y; 1786 ny = op->y;
1800 m = op->map; 1787 m = op->map;
1801 } 1788 }
1802 1789
1803 remove_ob (op); 1790 op->remove ();
1804 op->y = ny; 1791 op->y = ny;
1805 op->x = nx; 1792 op->x = nx;
1806 insert_ob_in_map (op, m, op, 0); 1793 insert_ob_in_map (op, m, op, 0);
1807 1794
1808 dam_save = op->stats.dam; /* save the original dam: we do halfdam on 1795 dam_save = op->stats.dam; /* save the original dam: we do halfdam on
… …
1879#if 0 1866#if 0
1880 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 }; 1867 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1881 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 }; 1868 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1882 sint16 target_x, target_y, origin_x, origin_y; 1869 sint16 target_x, target_y, origin_x, origin_y;
1883 int adjustdir; 1870 int adjustdir;
1884 mapstruct *m; 1871 maptile *m;
1885#endif 1872#endif
1886 int basedir; 1873 int basedir;
1887 object *owner; 1874 object *owner;
1888 1875
1889 owner = get_owner (op); 1876 owner = get_owner (op);
1890 if (op->duration == 0 || owner == NULL) 1877 if (op->duration == 0 || owner == NULL)
1891 { 1878 {
1892 remove_ob (op); 1879 op->remove ();
1893 free_object (op); 1880 op->destroy (0);
1894 return; 1881 return;
1895 } 1882 }
1896 op->duration--; 1883 op->duration--;
1897 1884
1898 basedir = op->direction; 1885 basedir = op->direction;
… …
2032cast_light (object *op, object *caster, object *spell, int dir) 2019cast_light (object *op, object *caster, object *spell, int dir)
2033{ 2020{
2034 object *target = NULL, *tmp = NULL; 2021 object *target = NULL, *tmp = NULL;
2035 sint16 x, y; 2022 sint16 x, y;
2036 int dam, mflags; 2023 int dam, mflags;
2037 mapstruct *m; 2024 maptile *m;
2038 2025
2039 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2026 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2040 2027
2041 if (!dir) 2028 if (!dir)
2042 { 2029 {
… …
2110cast_cause_disease (object *op, object *caster, object *spell, int dir) 2097cast_cause_disease (object *op, object *caster, object *spell, int dir)
2111{ 2098{
2112 sint16 x, y; 2099 sint16 x, y;
2113 int i, mflags, range, dam_mod, dur_mod; 2100 int i, mflags, range, dam_mod, dur_mod;
2114 object *walk; 2101 object *walk;
2115 mapstruct *m; 2102 maptile *m;
2116 2103
2117 x = op->x; 2104 x = op->x;
2118 y = op->y; 2105 y = op->y;
2119 2106
2120 /* If casting from a scroll, no direction will be available, so refer to the 2107 /* If casting from a scroll, no direction will be available, so refer to the
… …
2212 { 2199 {
2213 object *flash; /* visual effect for inflicting disease */ 2200 object *flash; /* visual effect for inflicting disease */
2214 2201
2215 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name); 2202 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2216 2203
2217 free_object (disease); /* don't need this one anymore */ 2204 disease->destroy (0); /* don't need this one anymore */
2218 flash = get_archetype (ARCH_DETECT_MAGIC); 2205 flash = get_archetype (ARCH_DETECT_MAGIC);
2219 flash->x = x; 2206 flash->x = x;
2220 flash->y = y; 2207 flash->y = y;
2221 flash->map = walk->map; 2208 flash->map = walk->map;
2222 insert_ob_in_map (flash, walk->map, op, 0); 2209 insert_ob_in_map (flash, walk->map, op, 0);
2223 return 1; 2210 return 1;
2224 } 2211 }
2225 free_object (disease); 2212 disease->destroy (0);
2226 } 2213 }
2227 } /* if living creature */ 2214 } /* if living creature */
2228 } /* for range of spaces */ 2215 } /* for range of spaces */
2229 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!"); 2216 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
2230 return 1; 2217 return 1;

Diff Legend

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