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.10 by root, Sun Sep 10 23:24:12 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.10 2006/09/10 23:24:12 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 }
183
190 hit_map (op, 0, op->attacktype, 1); 184 hit_map (op, 0, op->attacktype, 1);
191 185
192 if (!op->direction) 186 if (!op->direction)
193 return; 187 return;
194 188
… …
326 tmp->map = op->map; 320 tmp->map = op->map;
327 321
328 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);
329 if (mflags & P_OUT_OF_MAP) 323 if (mflags & P_OUT_OF_MAP)
330 { 324 {
331 free_object (tmp); 325 tmp->destroy (0);
332 return 0; 326 return 0;
333 } 327 }
334 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)))
335 { 329 {
336 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 330 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
337 { 331 {
338 free_object (tmp); 332 tmp->destroy (0);
339 return 0; 333 return 0;
340 } 334 }
341 tmp->x = op->x; 335 tmp->x = op->x;
342 tmp->y = op->y; 336 tmp->y = op->y;
343 tmp->direction = absdir (tmp->direction + 4); 337 tmp->direction = absdir (tmp->direction + 4);
… …
362 */ 356 */
363void 357void
364explosion (object *op) 358explosion (object *op)
365{ 359{
366 object *tmp; 360 object *tmp;
367 mapstruct *m = op->map; 361 maptile *m = op->map;
368 int i; 362 int i;
369 363
370 if (--(op->duration) < 0) 364 if (--(op->duration) < 0)
371 { 365 {
372 remove_ob (op); 366 op->remove ();
373 free_object (op); 367 op->destroy (0);
374 return; 368 return;
375 } 369 }
376 hit_map (op, 0, op->attacktype, 0); 370 hit_map (op, 0, op->attacktype, 0);
377 371
378 if (op->range > 0) 372 if (op->range > 0)
… …
408 * explode. 402 * explode.
409 */ 403 */
410void 404void
411explode_bullet (object *op) 405explode_bullet (object *op)
412{ 406{
413 tag_t op_tag = op->count;
414 object *tmp, *owner; 407 object *tmp, *owner;
415 408
416 if (op->other_arch == NULL) 409 if (op->other_arch == NULL)
417 { 410 {
418 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 411 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
419 remove_ob (op); 412 op->remove ();
420 free_object (op); 413 op->destroy (0);
421 return; 414 return;
422 } 415 }
423 416
424 if (op->env) 417 if (op->env)
425 { 418 {
… …
427 420
428 env = object_get_env_recursive (op); 421 env = object_get_env_recursive (op);
429 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))
430 { 423 {
431 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 424 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
432 remove_ob (op); 425 op->remove ();
433 free_object (op); 426 op->destroy (0);
434 return; 427 return;
435 } 428 }
436 remove_ob (op); 429 op->remove ();
437 op->x = env->x; 430 op->x = env->x;
438 op->y = env->y; 431 op->y = env->y;
439 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);
440 } 433 }
441 else if (out_of_map (op->map, op->x, op->y)) 434 else if (out_of_map (op->map, op->x, op->y))
442 { 435 {
443 LOG (llevError, "BUG: explode_bullet(): op out of map\n"); 436 LOG (llevError, "BUG: explode_bullet(): op out of map\n");
444 remove_ob (op); 437 op->remove ();
445 free_object (op); 438 op->destroy (0);
446 return; 439 return;
447 } 440 }
448 441
449 // 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
450 // 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
451 // bad at the moment that might happen from this. 444 // bad at the moment that might happen from this.
452 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)
453 { 446 {
454 remove_ob (op); 447 op->remove ();
455 free_object (op); 448 op->destroy (0);
456 return; 449 return;
457 } 450 }
458 451
459 if (op->attacktype) 452 if (op->attacktype)
460 { 453 {
461 hit_map (op, 0, op->attacktype, 1); 454 hit_map (op, 0, op->attacktype, 1);
462 if (was_destroyed (op, op_tag)) 455 if (op->destroyed ())
463 return; 456 return;
464 } 457 }
465 458
466 /* other_arch contains what this explodes into */ 459 /* other_arch contains what this explodes into */
467 tmp = arch_to_object (op->other_arch); 460 tmp = arch_to_object (op->other_arch);
… …
471 464
472 owner = get_owner (op); 465 owner = get_owner (op);
473 466
474 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))
475 { 468 {
476 remove_ob (op); 469 op->remove ();
477 free_object (op); 470 op->destroy (0);
478 return; 471 return;
479 } 472 }
480 473
481 tmp->x = op->x; 474 tmp->x = op->x;
482 tmp->y = op->y; 475 tmp->y = op->y;
… …
510 /* Prevent recursion */ 503 /* Prevent recursion */
511 op->move_on = 0; 504 op->move_on = 0;
512 505
513 insert_ob_in_map (tmp, op->map, op, 0); 506 insert_ob_in_map (tmp, op->map, op, 0);
514 /* remove the firebullet */ 507 /* remove the firebullet */
515 if (!was_destroyed (op, op_tag)) 508 if (!op->destroyed ())
516 { 509 {
517 remove_ob (op); 510 op->remove ();
518 free_object (op); 511 op->destroy (0);
519 } 512 }
520} 513}
521 514
522 515
523 516
… …
526 */ 519 */
527 520
528void 521void
529check_bullet (object *op) 522check_bullet (object *op)
530{ 523{
531 tag_t op_tag = op->count, tmp_tag;
532 object *tmp; 524 object *tmp;
533 int dam, mflags; 525 int dam, mflags;
534 mapstruct *m; 526 maptile *m;
535 sint16 sx, sy; 527 sint16 sx, sy;
536 528
537 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);
538 530
539 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)))
… …
552 544
553 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)
554 { 546 {
555 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 547 if (QUERY_FLAG (tmp, FLAG_ALIVE))
556 { 548 {
557 tmp_tag = tmp->count;
558 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 549 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
559 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)
560 { 551 {
561 if (!QUERY_FLAG (op, FLAG_REMOVED)) 552 if (!QUERY_FLAG (op, FLAG_REMOVED))
562 { 553 {
563 remove_ob (op); 554 op->remove ();
564 free_object (op); 555 op->destroy (0);
565 return; 556 return;
566 } 557 }
567 } 558 }
568 } 559 }
569 } 560 }
… …
579void 570void
580move_bullet (object *op) 571move_bullet (object *op)
581{ 572{
582 sint16 new_x, new_y; 573 sint16 new_x, new_y;
583 int mflags; 574 int mflags;
584 mapstruct *m; 575 maptile *m;
585 576
586#if 0 577#if 0
587 /* We need a better general purpose way to do this */ 578 /* We need a better general purpose way to do this */
588 579
589 /* peterm: added to make comet leave a trail of burnouts 580 /* peterm: added to make comet leave a trail of burnouts
590 it's an unadulterated hack, but the effect is cool. */ 581 it's an unadulterated hack, but the effect is cool. */
591 if (op->stats.sp == SP_METEOR) 582 if (op->stats.sp == SP_METEOR)
592 { 583 {
593 replace_insert_ob_in_map ("fire_trail", op); 584 replace_insert_ob_in_map ("fire_trail", op);
594 if (was_destroyed (op, op_tag)) 585 if (op->destroyed ())
595 return; 586 return;
596 } /* end addition. */ 587 } /* end addition. */
597#endif 588#endif
598 589
599 /* Reached the end of its life - remove it */ 590 /* Reached the end of its life - remove it */
… …
603 { 594 {
604 explode_bullet (op); 595 explode_bullet (op);
605 } 596 }
606 else 597 else
607 { 598 {
608 remove_ob (op); 599 op->remove ();
609 free_object (op); 600 op->destroy (0);
610 } 601 }
611 return; 602 return;
612 } 603 }
613 604
614 new_x = op->x + DIRX (op); 605 new_x = op->x + DIRX (op);
… …
616 m = op->map; 607 m = op->map;
617 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);
618 609
619 if (mflags & P_OUT_OF_MAP) 610 if (mflags & P_OUT_OF_MAP)
620 { 611 {
621 remove_ob (op); 612 op->remove ();
622 free_object (op); 613 op->destroy (0);
623 return; 614 return;
624 } 615 }
625 616
626 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)))
627 { 618 {
… …
629 { 620 {
630 explode_bullet (op); 621 explode_bullet (op);
631 } 622 }
632 else 623 else
633 { 624 {
634 remove_ob (op); 625 op->remove ();
635 free_object (op); 626 op->destroy (0);
636 } 627 }
637 return; 628 return;
638 } 629 }
639 630
640 remove_ob (op); 631 op->remove ();
641 op->x = new_x; 632 op->x = new_x;
642 op->y = new_y; 633 op->y = new_y;
643 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL) 634 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL)
644 return; 635 return;
645 636
… …
704 tmp->map = op->map; 695 tmp->map = op->map;
705 696
706 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);
707 if (mflags & P_OUT_OF_MAP) 698 if (mflags & P_OUT_OF_MAP)
708 { 699 {
709 free_object (tmp); 700 tmp->destroy (0);
710 return 0; 701 return 0;
711 } 702 }
712 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)))
713 { 704 {
714 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 705 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
715 { 706 {
716 free_object (tmp); 707 tmp->destroy (0);
717 return 0; 708 return 0;
718 } 709 }
719 tmp->x = op->x; 710 tmp->x = op->x;
720 tmp->y = op->y; 711 tmp->y = op->y;
721 tmp->direction = absdir (tmp->direction + 4); 712 tmp->direction = absdir (tmp->direction + 4);
… …
762 753
763void 754void
764move_cone (object *op) 755move_cone (object *op)
765{ 756{
766 int i; 757 int i;
767 tag_t tag;
768 758
769 /* 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 */
770 if (!op->map) 760 if (!op->map)
771 { 761 {
772 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");
… …
787 * when their cone dies when they die. 777 * when their cone dies when they die.
788 */ 778 */
789 /* If no owner left, the spell dies out. */ 779 /* If no owner left, the spell dies out. */
790 if (get_owner (op) == NULL) 780 if (get_owner (op) == NULL)
791 { 781 {
792 remove_ob (op); 782 op->remove ();
793 free_object (op); 783 op->destroy (0);
794 return; 784 return;
795 } 785 }
796#endif 786#endif
797 787
798 tag = op->count;
799 hit_map (op, 0, op->attacktype, 0); 788 hit_map (op, 0, op->attacktype, 0);
800 789
801 /* Check to see if we should push anything. 790 /* Check to see if we should push anything.
802 * Spell objects with weight push whatever they encounter to some 791 * Spell objects with weight push whatever they encounter to some
803 * degree. 792 * degree.
804 */ 793 */
805 if (op->weight) 794 if (op->weight)
806 check_spell_knockback (op); 795 check_spell_knockback (op);
807 796
808 if (was_destroyed (op, tag)) 797 if (op->destroyed ())
809 return; 798 return;
810 799
811 if ((op->duration--) < 0) 800 if ((op->duration--) < 0)
812 { 801 {
813 remove_ob (op); 802 op->remove ();
814 free_object (op); 803 op->destroy (0);
815 return; 804 return;
816 } 805 }
817 /* Object has hit maximum range, so don't have it move 806 /* Object has hit maximum range, so don't have it move
818 * any further. When the duration above expires, 807 * any further. When the duration above expires,
819 * then the object will get removed. 808 * then the object will get removed.
… …
858int 847int
859cast_cone (object *op, object *caster, int dir, object *spell) 848cast_cone (object *op, object *caster, int dir, object *spell)
860{ 849{
861 object *tmp; 850 object *tmp;
862 int i, success = 0, range_min = -1, range_max = 1; 851 int i, success = 0, range_min = -1, range_max = 1;
863 mapstruct *m; 852 maptile *m;
864 sint16 sx, sy; 853 sint16 sx, sy;
865 MoveType movetype; 854 MoveType movetype;
866 855
867 if (!spell->other_arch) 856 if (!spell->other_arch)
868 return 0; 857 return 0;
… …
1023 return; 1012 return;
1024 1013
1025 if (env->type == PLAYER) 1014 if (env->type == PLAYER)
1026 esrv_del_item (env->contr, op->count); 1015 esrv_del_item (env->contr, op->count);
1027 1016
1028 remove_ob (op); 1017 op->remove ();
1029 op->x = env->x; 1018 op->x = env->x;
1030 op->y = env->y; 1019 op->y = env->y;
1031 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)
1032 return; 1021 return;
1033 } 1022 }
… …
1035 // 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
1036 // 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
1037 // as bombs can be carried. 1026 // as bombs can be carried.
1038 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)
1039 { 1028 {
1040 remove_ob (op); 1029 op->remove ();
1041 free_object (op); 1030 op->destroy (0);
1042 return; 1031 return;
1043 } 1032 }
1044 1033
1045 /* This copies a lot of the code from the fire bullet, 1034 /* This copies a lot of the code from the fire bullet,
1046 * but using the cast_bullet isn't really feasible, 1035 * but using the cast_bullet isn't really feasible,
1047 * so just set up the appropriate values. 1036 * so just set up the appropriate values.
1048 */ 1037 */
1049 at = find_archetype (SPLINT); 1038 at = archetype::find (SPLINT);
1050 if (at) 1039 if (at)
1051 { 1040 {
1052 for (i = 1; i < 9; i++) 1041 for (i = 1; i < 9; i++)
1053 { 1042 {
1054 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]))
… …
1081{ 1070{
1082 1071
1083 object *tmp; 1072 object *tmp;
1084 int mflags; 1073 int mflags;
1085 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];
1086 mapstruct *m; 1075 maptile *m;
1087 1076
1088 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy); 1077 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
1089 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))
1090 { 1079 {
1091 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.");
… …
1127get_pointed_target (object *op, int dir, int range, int type) 1116get_pointed_target (object *op, int dir, int range, int type)
1128{ 1117{
1129 object *target; 1118 object *target;
1130 sint16 x, y; 1119 sint16 x, y;
1131 int dist, mflags; 1120 int dist, mflags;
1132 mapstruct *mp; 1121 maptile *mp;
1133 1122
1134 if (dir == 0) 1123 if (dir == 0)
1135 return NULL; 1124 return NULL;
1136 1125
1137 for (dist = 1; dist < range; dist++) 1126 for (dist = 1; dist < range; dist++)
… …
1240 } 1229 }
1241 else 1230 else
1242 { 1231 {
1243 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));
1244 target->stats.hp = target->stats.maxhp * 2; 1233 target->stats.hp = target->stats.maxhp * 2;
1245 free_object (effect); 1234 effect->destroy (0);
1246 return 0; 1235 return 0;
1247 } 1236 }
1248 } 1237 }
1249 } 1238 }
1250 else 1239 else
… …
1277move_missile (object *op) 1266move_missile (object *op)
1278{ 1267{
1279 int i, mflags; 1268 int i, mflags;
1280 object *owner; 1269 object *owner;
1281 sint16 new_x, new_y; 1270 sint16 new_x, new_y;
1282 mapstruct *m; 1271 maptile *m;
1283 1272
1284 if (op->range-- <= 0) 1273 if (op->range-- <= 0)
1285 { 1274 {
1286 remove_ob (op); 1275 op->remove ();
1287 free_object (op); 1276 op->destroy (0);
1288 return; 1277 return;
1289 } 1278 }
1290 1279
1291 owner = get_owner (op); 1280 owner = get_owner (op);
1292#if 0 1281#if 0
1293 /* 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
1294 * monster that are then killed would continue to survive 1283 * monster that are then killed would continue to survive
1295 */ 1284 */
1296 if (owner == NULL) 1285 if (owner == NULL)
1297 { 1286 {
1298 remove_ob (op); 1287 op->remove ();
1299 free_object (op); 1288 op->destroy (0);
1300 return; 1289 return;
1301 } 1290 }
1302#endif 1291#endif
1303 1292
1304 new_x = op->x + DIRX (op); 1293 new_x = op->x + DIRX (op);
… …
1306 1295
1307 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);
1308 1297
1309 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))))
1310 { 1299 {
1311 tag_t tag = op->count;
1312
1313 hit_map (op, op->direction, AT_MAGIC, 1); 1300 hit_map (op, op->direction, AT_MAGIC, 1);
1314 /* Basically, missile only hits one thing then goes away. 1301 /* Basically, missile only hits one thing then goes away.
1315 * 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.
1316 */ 1303 */
1317 if (!was_destroyed (op, tag)) 1304 if (!op->destroyed ())
1318 { 1305 op->destroy (0);
1319 remove_ob (op); 1306
1320 free_object (op);
1321 }
1322 return; 1307 return;
1323 } 1308 }
1324 1309
1325 remove_ob (op); 1310 op->remove ();
1311
1326 if (!op->direction || (mflags & P_OUT_OF_MAP)) 1312 if (!op->direction || (mflags & P_OUT_OF_MAP))
1327 { 1313 {
1328 free_object (op); 1314 op->destroy (0);
1329 return; 1315 return;
1330 } 1316 }
1317
1331 op->x = new_x; 1318 op->x = new_x;
1332 op->y = new_y; 1319 op->y = new_y;
1333 op->map = m; 1320 op->map = m;
1334 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));
1335 if (i > 0 && i != op->direction) 1322 if (i > 0 && i != op->direction)
1336 { 1323 {
1337 op->direction = i; 1324 op->direction = i;
1338 SET_ANIMATION (op, op->direction); 1325 SET_ANIMATION (op, op->direction);
1339 } 1326 }
1327
1340 insert_ob_in_map (op, op->map, op, 0); 1328 insert_ob_in_map (op, op->map, op, 0);
1341} 1329}
1342 1330
1343/**************************************************************************** 1331/****************************************************************************
1344 * Destruction 1332 * Destruction
… …
1390int 1378int
1391cast_destruction (object *op, object *caster, object *spell_ob) 1379cast_destruction (object *op, object *caster, object *spell_ob)
1392{ 1380{
1393 int i, j, range, mflags, friendly = 0, dam, dur; 1381 int i, j, range, mflags, friendly = 0, dam, dur;
1394 sint16 sx, sy; 1382 sint16 sx, sy;
1395 mapstruct *m; 1383 maptile *m;
1396 object *tmp; 1384 object *tmp;
1397 const char *skill; 1385 const char *skill;
1398 1386
1399 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 1387 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1400 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);
… …
1582mood_change (object *op, object *caster, object *spell) 1570mood_change (object *op, object *caster, object *spell)
1583{ 1571{
1584 object *tmp, *god, *head; 1572 object *tmp, *god, *head;
1585 int done_one, range, mflags, level, at, best_at; 1573 int done_one, range, mflags, level, at, best_at;
1586 sint16 x, y, nx, ny; 1574 sint16 x, y, nx, ny;
1587 mapstruct *m; 1575 maptile *m;
1588 const char *race; 1576 const char *race;
1589 1577
1590 /* 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
1591 * doing it over and over again. 1579 * doing it over and over again.
1592 */ 1580 */
… …
1756move_ball_spell (object *op) 1744move_ball_spell (object *op)
1757{ 1745{
1758 int i, j, dam_save, dir, mflags; 1746 int i, j, dam_save, dir, mflags;
1759 sint16 nx, ny, hx, hy; 1747 sint16 nx, ny, hx, hy;
1760 object *owner; 1748 object *owner;
1761 mapstruct *m; 1749 maptile *m;
1762 1750
1763 owner = get_owner (op); 1751 owner = get_owner (op);
1764 1752
1765 /* 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,
1766 * 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
… …
1797 nx = op->x; 1785 nx = op->x;
1798 ny = op->y; 1786 ny = op->y;
1799 m = op->map; 1787 m = op->map;
1800 } 1788 }
1801 1789
1802 remove_ob (op); 1790 op->remove ();
1803 op->y = ny; 1791 op->y = ny;
1804 op->x = nx; 1792 op->x = nx;
1805 insert_ob_in_map (op, m, op, 0); 1793 insert_ob_in_map (op, m, op, 0);
1806 1794
1807 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
… …
1878#if 0 1866#if 0
1879 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 };
1880 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 };
1881 sint16 target_x, target_y, origin_x, origin_y; 1869 sint16 target_x, target_y, origin_x, origin_y;
1882 int adjustdir; 1870 int adjustdir;
1883 mapstruct *m; 1871 maptile *m;
1884#endif 1872#endif
1885 int basedir; 1873 int basedir;
1886 object *owner; 1874 object *owner;
1887 1875
1888 owner = get_owner (op); 1876 owner = get_owner (op);
1889 if (op->duration == 0 || owner == NULL) 1877 if (op->duration == 0 || owner == NULL)
1890 { 1878 {
1891 remove_ob (op); 1879 op->remove ();
1892 free_object (op); 1880 op->destroy (0);
1893 return; 1881 return;
1894 } 1882 }
1895 op->duration--; 1883 op->duration--;
1896 1884
1897 basedir = op->direction; 1885 basedir = op->direction;
… …
2031cast_light (object *op, object *caster, object *spell, int dir) 2019cast_light (object *op, object *caster, object *spell, int dir)
2032{ 2020{
2033 object *target = NULL, *tmp = NULL; 2021 object *target = NULL, *tmp = NULL;
2034 sint16 x, y; 2022 sint16 x, y;
2035 int dam, mflags; 2023 int dam, mflags;
2036 mapstruct *m; 2024 maptile *m;
2037 2025
2038 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2026 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2039 2027
2040 if (!dir) 2028 if (!dir)
2041 { 2029 {
… …
2109cast_cause_disease (object *op, object *caster, object *spell, int dir) 2097cast_cause_disease (object *op, object *caster, object *spell, int dir)
2110{ 2098{
2111 sint16 x, y; 2099 sint16 x, y;
2112 int i, mflags, range, dam_mod, dur_mod; 2100 int i, mflags, range, dam_mod, dur_mod;
2113 object *walk; 2101 object *walk;
2114 mapstruct *m; 2102 maptile *m;
2115 2103
2116 x = op->x; 2104 x = op->x;
2117 y = op->y; 2105 y = op->y;
2118 2106
2119 /* 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
… …
2211 { 2199 {
2212 object *flash; /* visual effect for inflicting disease */ 2200 object *flash; /* visual effect for inflicting disease */
2213 2201
2214 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);
2215 2203
2216 free_object (disease); /* don't need this one anymore */ 2204 disease->destroy (0); /* don't need this one anymore */
2217 flash = get_archetype (ARCH_DETECT_MAGIC); 2205 flash = get_archetype (ARCH_DETECT_MAGIC);
2218 flash->x = x; 2206 flash->x = x;
2219 flash->y = y; 2207 flash->y = y;
2220 flash->map = walk->map; 2208 flash->map = walk->map;
2221 insert_ob_in_map (flash, walk->map, op, 0); 2209 insert_ob_in_map (flash, walk->map, op, 0);
2222 return 1; 2210 return 1;
2223 } 2211 }
2224 free_object (disease); 2212 disease->destroy (0);
2225 } 2213 }
2226 } /* if living creature */ 2214 } /* if living creature */
2227 } /* for range of spaces */ 2215 } /* for range of spaces */
2228 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!"); 2216 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
2229 return 1; 2217 return 1;

Diff Legend

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