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.13 by root, Thu Sep 14 22:34:05 2006 UTC vs.
Revision 1.18 by root, Wed Dec 13 00:42:04 2006 UTC

… …
117void 117void
118forklightning (object *op, object *tmp) 118forklightning (object *op, object *tmp)
119{ 119{
120 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 */
121 int t_dir; /* stores temporary dir calculation */ 121 int t_dir; /* stores temporary dir calculation */
122 mapstruct *m; 122 maptile *m;
123 sint16 sx, sy; 123 sint16 sx, sy;
124 object *new_bolt; 124 object *new_bolt;
125 125
126 /* pick a fork direction. tmp->stats.Con is the left bias 126 /* pick a fork direction. tmp->stats.Con is the left bias
127 * i.e., the chance in 100 of forking LEFT 127 * i.e., the chance in 100 of forking LEFT
… …
140 140
141 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy))) 141 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, sx, sy)))
142 return; 142 return;
143 143
144 /* OK, we made a fork */ 144 /* OK, we made a fork */
145 new_bolt = get_object (); 145 new_bolt = tmp->clone ();
146 copy_object (tmp, new_bolt);
147 146
148 /* reduce chances of subsequent forking */ 147 /* reduce chances of subsequent forking */
149 new_bolt->stats.Dex -= 10; 148 new_bolt->stats.Dex -= 10;
150 tmp->stats.Dex -= 10; /* less forks from main bolt too */ 149 tmp->stats.Dex -= 10; /* less forks from main bolt too */
151 new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */ 150 new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */
… …
170move_bolt (object *op) 169move_bolt (object *op)
171{ 170{
172 object *tmp; 171 object *tmp;
173 int mflags; 172 int mflags;
174 sint16 x, y; 173 sint16 x, y;
175 mapstruct *m; 174 maptile *m;
176 175
177 if (--(op->duration) < 0) 176 if (--(op->duration) < 0)
178 { 177 {
179 remove_ob (op); 178 op->destroy ();
180 free_object (op);
181 return; 179 return;
182 } 180 }
183 181
184 hit_map (op, 0, op->attacktype, 1); 182 hit_map (op, 0, op->attacktype, 1);
185 183
… …
250 update_turn_face (op); /* A bolt *must* be IS_TURNABLE */ 248 update_turn_face (op); /* A bolt *must* be IS_TURNABLE */
251 return; 249 return;
252 } 250 }
253 else 251 else
254 { /* Create a copy of this object and put it ahead */ 252 { /* Create a copy of this object and put it ahead */
255 tmp = get_object (); 253 tmp = op->clone ();
256 copy_object (op, tmp); 254
257 tmp->speed_left = -0.1; 255 tmp->speed_left = -0.1;
258 tmp->x += DIRX (tmp), tmp->y += DIRY (tmp); 256 tmp->x += DIRX (tmp), tmp->y += DIRY (tmp);
259 tmp = insert_ob_in_map (tmp, op->map, op, 0); 257 tmp = insert_ob_in_map (tmp, op->map, op, 0);
260 /* To make up for the decrease at the top of the function */ 258 /* To make up for the decrease at the top of the function */
261 tmp->duration++; 259 tmp->duration++;
… …
320 tmp->map = op->map; 318 tmp->map = op->map;
321 319
322 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y); 320 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y);
323 if (mflags & P_OUT_OF_MAP) 321 if (mflags & P_OUT_OF_MAP)
324 { 322 {
325 free_object (tmp); 323 tmp->destroy ();
326 return 0; 324 return 0;
327 } 325 }
326
328 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 327 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
329 { 328 {
330 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 329 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
331 { 330 {
332 free_object (tmp); 331 tmp->destroy ();
333 return 0; 332 return 0;
334 } 333 }
334
335 tmp->x = op->x; 335 tmp->x = op->x;
336 tmp->y = op->y; 336 tmp->y = op->y;
337 tmp->direction = absdir (tmp->direction + 4); 337 tmp->direction = absdir (tmp->direction + 4);
338 tmp->map = op->map; 338 tmp->map = op->map;
339 } 339 }
340
340 if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL) 341 if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL)
341 move_bolt (tmp); 342 move_bolt (tmp);
343
342 return 1; 344 return 1;
343} 345}
344 346
345 347
346 348
… …
356 */ 358 */
357void 359void
358explosion (object *op) 360explosion (object *op)
359{ 361{
360 object *tmp; 362 object *tmp;
361 mapstruct *m = op->map; 363 maptile *m = op->map;
362 int i; 364 int i;
363 365
364 if (--(op->duration) < 0) 366 if (--(op->duration) < 0)
365 { 367 {
366 remove_ob (op); 368 op->destroy ();
367 free_object (op);
368 return; 369 return;
369 } 370 }
371
370 hit_map (op, 0, op->attacktype, 0); 372 hit_map (op, 0, op->attacktype, 0);
371 373
372 if (op->range > 0) 374 if (op->range > 0)
373 { 375 {
374 for (i = 1; i < 9; i++) 376 for (i = 1; i < 9; i++)
… …
380 /* ok_to_put_more already does things like checks for walls, 382 /* ok_to_put_more already does things like checks for walls,
381 * out of map, etc. 383 * out of map, etc.
382 */ 384 */
383 if (ok_to_put_more (op->map, dx, dy, op, op->attacktype)) 385 if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
384 { 386 {
385 tmp = get_object (); 387 tmp = op->clone ();
386 copy_object (op, tmp);
387 tmp->state = 0; 388 tmp->state = 0;
388 tmp->speed_left = -0.21; 389 tmp->speed_left = -0.21;
389 tmp->range--; 390 tmp->range--;
390 tmp->value = 0; 391 tmp->value = 0;
391 tmp->x = dx; 392 tmp->x = dx;
… …
402 * explode. 403 * explode.
403 */ 404 */
404void 405void
405explode_bullet (object *op) 406explode_bullet (object *op)
406{ 407{
407 tag_t op_tag = op->count;
408 object *tmp, *owner; 408 object *tmp, *owner;
409 409
410 if (op->other_arch == NULL) 410 if (op->other_arch == NULL)
411 { 411 {
412 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 412 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
413 remove_ob (op); 413 op->destroy ();
414 free_object (op);
415 return; 414 return;
416 } 415 }
417 416
418 if (op->env) 417 if (op->env)
419 { 418 {
… …
421 420
422 env = object_get_env_recursive (op); 421 env = object_get_env_recursive (op);
423 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))
424 { 423 {
425 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 424 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
426 remove_ob (op); 425 op->destroy ();
427 free_object (op);
428 return; 426 return;
429 } 427 }
428
430 remove_ob (op); 429 op->remove ();
431 op->x = env->x; 430 op->x = env->x;
432 op->y = env->y; 431 op->y = env->y;
433 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);
434 } 433 }
435 else if (out_of_map (op->map, op->x, op->y)) 434 else if (out_of_map (op->map, op->x, op->y))
436 { 435 {
437 LOG (llevError, "BUG: explode_bullet(): op out of map\n"); 436 LOG (llevError, "BUG: explode_bullet(): op out of map\n");
438 remove_ob (op); 437 op->destroy ();
439 free_object (op);
440 return; 438 return;
441 } 439 }
442 440
443 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps 441 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps
444 // NOTE: If this breaks something important: remove this. I can't think of anything 442 // NOTE: If this breaks something important: remove this. I can't think of anything
445 // bad at the moment that might happen from this. 443 // bad at the moment that might happen from this.
446 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE) 444 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
447 { 445 {
448 remove_ob (op); 446 op->destroy ();
449 free_object (op);
450 return; 447 return;
451 } 448 }
452 449
453 if (op->attacktype) 450 if (op->attacktype)
454 { 451 {
455 hit_map (op, 0, op->attacktype, 1); 452 hit_map (op, 0, op->attacktype, 1);
456 if (was_destroyed (op, op_tag)) 453 if (op->destroyed ())
457 return; 454 return;
458 } 455 }
459 456
460 /* other_arch contains what this explodes into */ 457 /* other_arch contains what this explodes into */
461 tmp = arch_to_object (op->other_arch); 458 tmp = arch_to_object (op->other_arch);
… …
465 462
466 owner = get_owner (op); 463 owner = get_owner (op);
467 464
468 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner)) 465 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))
469 { 466 {
470 remove_ob (op); 467 op->destroy ();
471 free_object (op);
472 return; 468 return;
473 } 469 }
474 470
475 tmp->x = op->x; 471 tmp->x = op->x;
476 tmp->y = op->y; 472 tmp->y = op->y;
… …
504 /* Prevent recursion */ 500 /* Prevent recursion */
505 op->move_on = 0; 501 op->move_on = 0;
506 502
507 insert_ob_in_map (tmp, op->map, op, 0); 503 insert_ob_in_map (tmp, op->map, op, 0);
508 /* remove the firebullet */ 504 /* remove the firebullet */
509 if (!was_destroyed (op, op_tag)) 505 if (!op->destroyed ())
510 { 506 {
511 remove_ob (op); 507 op->destroy ();
512 free_object (op);
513 } 508 }
514} 509}
515 510
516 511
517 512
… …
520 */ 515 */
521 516
522void 517void
523check_bullet (object *op) 518check_bullet (object *op)
524{ 519{
525 tag_t op_tag = op->count, tmp_tag;
526 object *tmp; 520 object *tmp;
527 int dam, mflags; 521 int dam, mflags;
528 mapstruct *m; 522 maptile *m;
529 sint16 sx, sy; 523 sint16 sx, sy;
530 524
531 mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy); 525 mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy);
532 526
533 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 527 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
… …
546 540
547 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 541 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
548 { 542 {
549 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 543 if (QUERY_FLAG (tmp, FLAG_ALIVE))
550 { 544 {
551 tmp_tag = tmp->count;
552 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 545 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
553 if (was_destroyed (op, op_tag) || !was_destroyed (tmp, tmp_tag) || (op->stats.dam -= dam) < 0) 546 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
554 { 547 {
555 if (!QUERY_FLAG (op, FLAG_REMOVED)) 548 if (!QUERY_FLAG (op, FLAG_REMOVED))
556 { 549 {
557 remove_ob (op); 550 op->destroy ();
558 free_object (op);
559 return; 551 return;
560 } 552 }
561 } 553 }
562 } 554 }
563 } 555 }
… …
573void 565void
574move_bullet (object *op) 566move_bullet (object *op)
575{ 567{
576 sint16 new_x, new_y; 568 sint16 new_x, new_y;
577 int mflags; 569 int mflags;
578 mapstruct *m; 570 maptile *m;
579 571
580#if 0 572#if 0
581 /* We need a better general purpose way to do this */ 573 /* We need a better general purpose way to do this */
582 574
583 /* peterm: added to make comet leave a trail of burnouts 575 /* peterm: added to make comet leave a trail of burnouts
584 it's an unadulterated hack, but the effect is cool. */ 576 it's an unadulterated hack, but the effect is cool. */
585 if (op->stats.sp == SP_METEOR) 577 if (op->stats.sp == SP_METEOR)
586 { 578 {
587 replace_insert_ob_in_map ("fire_trail", op); 579 replace_insert_ob_in_map ("fire_trail", op);
588 if (was_destroyed (op, op_tag)) 580 if (op->destroyed ())
589 return; 581 return;
590 } /* end addition. */ 582 } /* end addition. */
591#endif 583#endif
592 584
593 /* Reached the end of its life - remove it */ 585 /* Reached the end of its life - remove it */
594 if (--op->range <= 0) 586 if (--op->range <= 0)
595 { 587 {
596 if (op->other_arch) 588 if (op->other_arch)
597 {
598 explode_bullet (op); 589 explode_bullet (op);
599 }
600 else 590 else
601 { 591 op->destroy ();
602 remove_ob (op); 592
603 free_object (op);
604 }
605 return; 593 return;
606 } 594 }
607 595
608 new_x = op->x + DIRX (op); 596 new_x = op->x + DIRX (op);
609 new_y = op->y + DIRY (op); 597 new_y = op->y + DIRY (op);
610 m = op->map; 598 m = op->map;
611 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y); 599 mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
612 600
613 if (mflags & P_OUT_OF_MAP) 601 if (mflags & P_OUT_OF_MAP)
614 { 602 {
615 remove_ob (op); 603 op->destroy ();
616 free_object (op);
617 return; 604 return;
618 } 605 }
619 606
620 if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))) 607 if (!op->direction || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))
621 { 608 {
622 if (op->other_arch) 609 if (op->other_arch)
623 {
624 explode_bullet (op); 610 explode_bullet (op);
625 }
626 else 611 else
627 { 612 op->destroy ();
628 remove_ob (op); 613
629 free_object (op);
630 }
631 return; 614 return;
632 } 615 }
633 616
634 remove_ob (op); 617 op->remove ();
635 op->x = new_x; 618 op->x = new_x;
636 op->y = new_y; 619 op->y = new_y;
637 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL) 620 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL)
638 return; 621 return;
639 622
… …
698 tmp->map = op->map; 681 tmp->map = op->map;
699 682
700 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y); 683 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y);
701 if (mflags & P_OUT_OF_MAP) 684 if (mflags & P_OUT_OF_MAP)
702 { 685 {
703 free_object (tmp); 686 tmp->destroy ();
704 return 0; 687 return 0;
705 } 688 }
689
706 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 690 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
707 { 691 {
708 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 692 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
709 { 693 {
710 free_object (tmp); 694 tmp->destroy ();
711 return 0; 695 return 0;
712 } 696 }
697
713 tmp->x = op->x; 698 tmp->x = op->x;
714 tmp->y = op->y; 699 tmp->y = op->y;
715 tmp->direction = absdir (tmp->direction + 4); 700 tmp->direction = absdir (tmp->direction + 4);
716 tmp->map = op->map; 701 tmp->map = op->map;
717 } 702 }
703
718 if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL) 704 if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL)
719 {
720 check_bullet (tmp); 705 check_bullet (tmp);
721 } 706
722 return 1; 707 return 1;
723} 708}
724 709
725 710
726 711
… …
756 741
757void 742void
758move_cone (object *op) 743move_cone (object *op)
759{ 744{
760 int i; 745 int i;
761 tag_t tag;
762 746
763 /* if no map then hit_map will crash so just ignore object */ 747 /* if no map then hit_map will crash so just ignore object */
764 if (!op->map) 748 if (!op->map)
765 { 749 {
766 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown"); 750 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
… …
781 * when their cone dies when they die. 765 * when their cone dies when they die.
782 */ 766 */
783 /* If no owner left, the spell dies out. */ 767 /* If no owner left, the spell dies out. */
784 if (get_owner (op) == NULL) 768 if (get_owner (op) == NULL)
785 { 769 {
786 remove_ob (op); 770 op->destroy ();
787 free_object (op);
788 return; 771 return;
789 } 772 }
790#endif 773#endif
791 774
792 tag = op->count;
793 hit_map (op, 0, op->attacktype, 0); 775 hit_map (op, 0, op->attacktype, 0);
794 776
795 /* Check to see if we should push anything. 777 /* Check to see if we should push anything.
796 * Spell objects with weight push whatever they encounter to some 778 * Spell objects with weight push whatever they encounter to some
797 * degree. 779 * degree.
798 */ 780 */
799 if (op->weight) 781 if (op->weight)
800 check_spell_knockback (op); 782 check_spell_knockback (op);
801 783
802 if (was_destroyed (op, tag)) 784 if (op->destroyed ())
803 return; 785 return;
804 786
805 if ((op->duration--) < 0) 787 if ((op->duration--) < 0)
806 { 788 {
807 remove_ob (op); 789 op->destroy ();
808 free_object (op);
809 return; 790 return;
810 } 791 }
811 /* Object has hit maximum range, so don't have it move 792 /* Object has hit maximum range, so don't have it move
812 * any further. When the duration above expires, 793 * any further. When the duration above expires,
813 * then the object will get removed. 794 * then the object will get removed.
… …
822 { 803 {
823 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)]; 804 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
824 805
825 if (ok_to_put_more (op->map, x, y, op, op->attacktype)) 806 if (ok_to_put_more (op->map, x, y, op, op->attacktype))
826 { 807 {
827 object *tmp = get_object (); 808 object *tmp = op->clone ();
828 809
829 copy_object (op, tmp);
830 tmp->x = x; 810 tmp->x = x;
831 tmp->y = y; 811 tmp->y = y;
832 812
833 tmp->duration = op->duration + 1; 813 tmp->duration = op->duration + 1;
834 814
… …
852int 832int
853cast_cone (object *op, object *caster, int dir, object *spell) 833cast_cone (object *op, object *caster, int dir, object *spell)
854{ 834{
855 object *tmp; 835 object *tmp;
856 int i, success = 0, range_min = -1, range_max = 1; 836 int i, success = 0, range_min = -1, range_max = 1;
857 mapstruct *m; 837 maptile *m;
858 sint16 sx, sy; 838 sint16 sx, sy;
859 MoveType movetype; 839 MoveType movetype;
860 840
861 if (!spell->other_arch) 841 if (!spell->other_arch)
862 return 0; 842 return 0;
… …
1017 return; 997 return;
1018 998
1019 if (env->type == PLAYER) 999 if (env->type == PLAYER)
1020 esrv_del_item (env->contr, op->count); 1000 esrv_del_item (env->contr, op->count);
1021 1001
1022 remove_ob (op); 1002 op->remove ();
1023 op->x = env->x; 1003 op->x = env->x;
1024 op->y = env->y; 1004 op->y = env->y;
1025 if ((op = insert_ob_in_map (op, env->map, op, 0)) == NULL) 1005 if ((op = insert_ob_in_map (op, env->map, op, 0)) == NULL)
1026 return; 1006 return;
1027 } 1007 }
… …
1029 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding 1009 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding
1030 // on a safe map. I don't like this special casing, but it seems to be neccessary 1010 // on a safe map. I don't like this special casing, but it seems to be neccessary
1031 // as bombs can be carried. 1011 // as bombs can be carried.
1032 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE) 1012 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
1033 { 1013 {
1034 remove_ob (op); 1014 op->destroy ();
1035 free_object (op);
1036 return; 1015 return;
1037 } 1016 }
1038 1017
1039 /* This copies a lot of the code from the fire bullet, 1018 /* This copies a lot of the code from the fire bullet,
1040 * but using the cast_bullet isn't really feasible, 1019 * but using the cast_bullet isn't really feasible,
… …
1075{ 1054{
1076 1055
1077 object *tmp; 1056 object *tmp;
1078 int mflags; 1057 int mflags;
1079 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir]; 1058 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1080 mapstruct *m; 1059 maptile *m;
1081 1060
1082 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy); 1061 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
1083 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK)) 1062 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1084 { 1063 {
1085 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1064 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
… …
1121get_pointed_target (object *op, int dir, int range, int type) 1100get_pointed_target (object *op, int dir, int range, int type)
1122{ 1101{
1123 object *target; 1102 object *target;
1124 sint16 x, y; 1103 sint16 x, y;
1125 int dist, mflags; 1104 int dist, mflags;
1126 mapstruct *mp; 1105 maptile *mp;
1127 1106
1128 if (dir == 0) 1107 if (dir == 0)
1129 return NULL; 1108 return NULL;
1130 1109
1131 for (dist = 1; dist < range; dist++) 1110 for (dist = 1; dist < range; dist++)
… …
1234 } 1213 }
1235 else 1214 else
1236 { 1215 {
1237 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target)); 1216 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1238 target->stats.hp = target->stats.maxhp * 2; 1217 target->stats.hp = target->stats.maxhp * 2;
1239 free_object (effect); 1218 effect->destroy ();
1240 return 0; 1219 return 0;
1241 } 1220 }
1242 } 1221 }
1243 } 1222 }
1244 else 1223 else
… …
1271move_missile (object *op) 1250move_missile (object *op)
1272{ 1251{
1273 int i, mflags; 1252 int i, mflags;
1274 object *owner; 1253 object *owner;
1275 sint16 new_x, new_y; 1254 sint16 new_x, new_y;
1276 mapstruct *m; 1255 maptile *m;
1277 1256
1278 if (op->range-- <= 0) 1257 if (op->range-- <= 0)
1279 { 1258 {
1280 remove_ob (op); 1259 op->destroy ();
1281 free_object (op);
1282 return; 1260 return;
1283 } 1261 }
1284 1262
1285 owner = get_owner (op); 1263 owner = get_owner (op);
1286#if 0 1264#if 0
1287 /* It'd make things nastier if this wasn't here - spells cast by 1265 /* It'd make things nastier if this wasn't here - spells cast by
1288 * monster that are then killed would continue to survive 1266 * monster that are then killed would continue to survive
1289 */ 1267 */
1290 if (owner == NULL) 1268 if (owner == NULL)
1291 { 1269 {
1292 remove_ob (op); 1270 op->destroy ();
1293 free_object (op);
1294 return; 1271 return;
1295 } 1272 }
1296#endif 1273#endif
1297 1274
1298 new_x = op->x + DIRX (op); 1275 new_x = op->x + DIRX (op);
… …
1300 1277
1301 mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y); 1278 mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);
1302 1279
1303 if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))) 1280 if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1304 { 1281 {
1305 tag_t tag = op->count;
1306
1307 hit_map (op, op->direction, AT_MAGIC, 1); 1282 hit_map (op, op->direction, AT_MAGIC, 1);
1308 /* Basically, missile only hits one thing then goes away. 1283 /* Basically, missile only hits one thing then goes away.
1309 * we need to remove it if someone hasn't already done so. 1284 * we need to remove it if someone hasn't already done so.
1310 */ 1285 */
1311 if (!was_destroyed (op, tag)) 1286 if (!op->destroyed ())
1312 { 1287 op->destroy ();
1313 remove_ob (op); 1288
1314 free_object (op);
1315 }
1316 return; 1289 return;
1317 } 1290 }
1318 1291
1319 remove_ob (op); 1292 op->remove ();
1293
1320 if (!op->direction || (mflags & P_OUT_OF_MAP)) 1294 if (!op->direction || (mflags & P_OUT_OF_MAP))
1321 { 1295 {
1322 free_object (op); 1296 op->destroy ();
1323 return; 1297 return;
1324 } 1298 }
1299
1325 op->x = new_x; 1300 op->x = new_x;
1326 op->y = new_y; 1301 op->y = new_y;
1327 op->map = m; 1302 op->map = m;
1328 i = spell_find_dir (op->map, op->x, op->y, get_owner (op)); 1303 i = spell_find_dir (op->map, op->x, op->y, get_owner (op));
1329 if (i > 0 && i != op->direction) 1304 if (i > 0 && i != op->direction)
1330 { 1305 {
1331 op->direction = i; 1306 op->direction = i;
1332 SET_ANIMATION (op, op->direction); 1307 SET_ANIMATION (op, op->direction);
1333 } 1308 }
1309
1334 insert_ob_in_map (op, op->map, op, 0); 1310 insert_ob_in_map (op, op->map, op, 0);
1335} 1311}
1336 1312
1337/**************************************************************************** 1313/****************************************************************************
1338 * Destruction 1314 * Destruction
… …
1384int 1360int
1385cast_destruction (object *op, object *caster, object *spell_ob) 1361cast_destruction (object *op, object *caster, object *spell_ob)
1386{ 1362{
1387 int i, j, range, mflags, friendly = 0, dam, dur; 1363 int i, j, range, mflags, friendly = 0, dam, dur;
1388 sint16 sx, sy; 1364 sint16 sx, sy;
1389 mapstruct *m; 1365 maptile *m;
1390 object *tmp; 1366 object *tmp;
1391 const char *skill; 1367 const char *skill;
1392 1368
1393 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 1369 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1394 dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 1370 dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
… …
1576mood_change (object *op, object *caster, object *spell) 1552mood_change (object *op, object *caster, object *spell)
1577{ 1553{
1578 object *tmp, *god, *head; 1554 object *tmp, *god, *head;
1579 int done_one, range, mflags, level, at, best_at; 1555 int done_one, range, mflags, level, at, best_at;
1580 sint16 x, y, nx, ny; 1556 sint16 x, y, nx, ny;
1581 mapstruct *m; 1557 maptile *m;
1582 const char *race; 1558 const char *race;
1583 1559
1584 /* We precompute some values here so that we don't have to keep 1560 /* We precompute some values here so that we don't have to keep
1585 * doing it over and over again. 1561 * doing it over and over again.
1586 */ 1562 */
… …
1750move_ball_spell (object *op) 1726move_ball_spell (object *op)
1751{ 1727{
1752 int i, j, dam_save, dir, mflags; 1728 int i, j, dam_save, dir, mflags;
1753 sint16 nx, ny, hx, hy; 1729 sint16 nx, ny, hx, hy;
1754 object *owner; 1730 object *owner;
1755 mapstruct *m; 1731 maptile *m;
1756 1732
1757 owner = get_owner (op); 1733 owner = get_owner (op);
1758 1734
1759 /* the following logic makes sure that the ball doesn't move into a wall, 1735 /* the following logic makes sure that the ball doesn't move into a wall,
1760 * and makes sure that it will move along a wall to try and get at it's 1736 * and makes sure that it will move along a wall to try and get at it's
… …
1791 nx = op->x; 1767 nx = op->x;
1792 ny = op->y; 1768 ny = op->y;
1793 m = op->map; 1769 m = op->map;
1794 } 1770 }
1795 1771
1796 remove_ob (op); 1772 op->remove ();
1797 op->y = ny; 1773 op->y = ny;
1798 op->x = nx; 1774 op->x = nx;
1799 insert_ob_in_map (op, m, op, 0); 1775 insert_ob_in_map (op, m, op, 0);
1800 1776
1801 dam_save = op->stats.dam; /* save the original dam: we do halfdam on 1777 dam_save = op->stats.dam; /* save the original dam: we do halfdam on
… …
1872#if 0 1848#if 0
1873 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 }; 1849 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1874 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 }; 1850 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1875 sint16 target_x, target_y, origin_x, origin_y; 1851 sint16 target_x, target_y, origin_x, origin_y;
1876 int adjustdir; 1852 int adjustdir;
1877 mapstruct *m; 1853 maptile *m;
1878#endif 1854#endif
1879 int basedir; 1855 int basedir;
1880 object *owner; 1856 object *owner;
1881 1857
1882 owner = get_owner (op); 1858 owner = get_owner (op);
1883 if (op->duration == 0 || owner == NULL) 1859 if (op->duration == 0 || owner == NULL)
1884 { 1860 {
1885 remove_ob (op); 1861 op->destroy ();
1886 free_object (op);
1887 return; 1862 return;
1888 } 1863 }
1864
1889 op->duration--; 1865 op->duration--;
1890 1866
1891 basedir = op->direction; 1867 basedir = op->direction;
1892 if (basedir == 0) 1868 if (basedir == 0)
1893 { 1869 {
… …
2025cast_light (object *op, object *caster, object *spell, int dir) 2001cast_light (object *op, object *caster, object *spell, int dir)
2026{ 2002{
2027 object *target = NULL, *tmp = NULL; 2003 object *target = NULL, *tmp = NULL;
2028 sint16 x, y; 2004 sint16 x, y;
2029 int dam, mflags; 2005 int dam, mflags;
2030 mapstruct *m; 2006 maptile *m;
2031 2007
2032 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2008 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2033 2009
2034 if (!dir) 2010 if (!dir)
2035 { 2011 {
… …
2103cast_cause_disease (object *op, object *caster, object *spell, int dir) 2079cast_cause_disease (object *op, object *caster, object *spell, int dir)
2104{ 2080{
2105 sint16 x, y; 2081 sint16 x, y;
2106 int i, mflags, range, dam_mod, dur_mod; 2082 int i, mflags, range, dam_mod, dur_mod;
2107 object *walk; 2083 object *walk;
2108 mapstruct *m; 2084 maptile *m;
2109 2085
2110 x = op->x; 2086 x = op->x;
2111 y = op->y; 2087 y = op->y;
2112 2088
2113 /* If casting from a scroll, no direction will be available, so refer to the 2089 /* If casting from a scroll, no direction will be available, so refer to the
… …
2205 { 2181 {
2206 object *flash; /* visual effect for inflicting disease */ 2182 object *flash; /* visual effect for inflicting disease */
2207 2183
2208 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name); 2184 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2209 2185
2210 free_object (disease); /* don't need this one anymore */ 2186 disease->destroy (); /* don't need this one anymore */
2211 flash = get_archetype (ARCH_DETECT_MAGIC); 2187 flash = get_archetype (ARCH_DETECT_MAGIC);
2212 flash->x = x; 2188 flash->x = x;
2213 flash->y = y; 2189 flash->y = y;
2214 flash->map = walk->map; 2190 flash->map = walk->map;
2215 insert_ob_in_map (flash, walk->map, op, 0); 2191 insert_ob_in_map (flash, walk->map, op, 0);
2216 return 1; 2192 return 1;
2217 } 2193 }
2218 free_object (disease); 2194
2195 disease->destroy ();
2219 } 2196 }
2220 } /* if living creature */ 2197 } /* if living creature */
2221 } /* for range of spaces */ 2198 } /* for range of spaces */
2222 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!"); 2199 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
2223 return 1; 2200 return 1;

Diff Legend

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