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.14 by root, Thu Sep 14 23:13:49 2006 UTC vs.
Revision 1.20 by root, Mon Dec 18 02:35:01 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++;
… …
310 308
311 tmp->direction = dir; 309 tmp->direction = dir;
312 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE)) 310 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
313 SET_ANIMATION (tmp, dir); 311 SET_ANIMATION (tmp, dir);
314 312
315 set_owner (tmp, op); 313 tmp->set_owner (op);
316 set_spell_skill (op, caster, spob, tmp); 314 set_spell_skill (op, caster, spob, tmp);
317 315
318 tmp->x = op->x + DIRX (tmp); 316 tmp->x = op->x + DIRX (tmp);
319 tmp->y = op->y + DIRY (tmp); 317 tmp->y = op->y + DIRY (tmp);
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;
… …
407 object *tmp, *owner; 408 object *tmp, *owner;
408 409
409 if (op->other_arch == NULL) 410 if (op->other_arch == NULL)
410 { 411 {
411 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 412 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
412 remove_ob (op); 413 op->destroy ();
413 free_object (op);
414 return; 414 return;
415 } 415 }
416 416
417 if (op->env) 417 if (op->env)
418 { 418 {
… …
420 420
421 env = object_get_env_recursive (op); 421 env = object_get_env_recursive (op);
422 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))
423 { 423 {
424 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 424 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
425 remove_ob (op); 425 op->destroy ();
426 free_object (op);
427 return; 426 return;
428 } 427 }
428
429 remove_ob (op); 429 op->remove ();
430 op->x = env->x; 430 op->x = env->x;
431 op->y = env->y; 431 op->y = env->y;
432 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);
433 } 433 }
434 else if (out_of_map (op->map, op->x, op->y)) 434 else if (out_of_map (op->map, op->x, op->y))
435 { 435 {
436 LOG (llevError, "BUG: explode_bullet(): op out of map\n"); 436 LOG (llevError, "BUG: explode_bullet(): op out of map\n");
437 remove_ob (op); 437 op->destroy ();
438 free_object (op);
439 return; 438 return;
440 } 439 }
441 440
442 // 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
443 // 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
444 // bad at the moment that might happen from this. 443 // bad at the moment that might happen from this.
445 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)
446 { 445 {
447 remove_ob (op); 446 op->destroy ();
448 free_object (op);
449 return; 447 return;
450 } 448 }
451 449
452 if (op->attacktype) 450 if (op->attacktype)
453 { 451 {
… …
457 } 455 }
458 456
459 /* other_arch contains what this explodes into */ 457 /* other_arch contains what this explodes into */
460 tmp = arch_to_object (op->other_arch); 458 tmp = arch_to_object (op->other_arch);
461 459
462 copy_owner (tmp, op); 460 tmp->set_owner (op);
463 tmp->skill = op->skill; 461 tmp->skill = op->skill;
464 462
465 owner = get_owner (op); 463 owner = op->owner;
466 464
467 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))
468 { 466 {
469 remove_ob (op); 467 op->destroy ();
470 free_object (op);
471 return; 468 return;
472 } 469 }
473 470
474 tmp->x = op->x; 471 tmp->x = op->x;
475 tmp->y = op->y; 472 tmp->y = op->y;
… …
505 502
506 insert_ob_in_map (tmp, op->map, op, 0); 503 insert_ob_in_map (tmp, op->map, op, 0);
507 /* remove the firebullet */ 504 /* remove the firebullet */
508 if (!op->destroyed ()) 505 if (!op->destroyed ())
509 { 506 {
510 remove_ob (op); 507 op->destroy ();
511 free_object (op);
512 } 508 }
513} 509}
514 510
515 511
516 512
… …
521void 517void
522check_bullet (object *op) 518check_bullet (object *op)
523{ 519{
524 object *tmp; 520 object *tmp;
525 int dam, mflags; 521 int dam, mflags;
526 mapstruct *m; 522 maptile *m;
527 sint16 sx, sy; 523 sint16 sx, sy;
528 524
529 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);
530 526
531 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)))
… …
549 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 545 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
550 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 546 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
551 { 547 {
552 if (!QUERY_FLAG (op, FLAG_REMOVED)) 548 if (!QUERY_FLAG (op, FLAG_REMOVED))
553 { 549 {
554 remove_ob (op); 550 op->destroy ();
555 free_object (op);
556 return; 551 return;
557 } 552 }
558 } 553 }
559 } 554 }
560 } 555 }
… …
570void 565void
571move_bullet (object *op) 566move_bullet (object *op)
572{ 567{
573 sint16 new_x, new_y; 568 sint16 new_x, new_y;
574 int mflags; 569 int mflags;
575 mapstruct *m; 570 maptile *m;
576 571
577#if 0 572#if 0
578 /* We need a better general purpose way to do this */ 573 /* We need a better general purpose way to do this */
579 574
580 /* peterm: added to make comet leave a trail of burnouts 575 /* peterm: added to make comet leave a trail of burnouts
… …
589 584
590 /* Reached the end of its life - remove it */ 585 /* Reached the end of its life - remove it */
591 if (--op->range <= 0) 586 if (--op->range <= 0)
592 { 587 {
593 if (op->other_arch) 588 if (op->other_arch)
594 {
595 explode_bullet (op); 589 explode_bullet (op);
596 }
597 else 590 else
598 { 591 op->destroy ();
599 remove_ob (op); 592
600 free_object (op);
601 }
602 return; 593 return;
603 } 594 }
604 595
605 new_x = op->x + DIRX (op); 596 new_x = op->x + DIRX (op);
606 new_y = op->y + DIRY (op); 597 new_y = op->y + DIRY (op);
607 m = op->map; 598 m = op->map;
608 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);
609 600
610 if (mflags & P_OUT_OF_MAP) 601 if (mflags & P_OUT_OF_MAP)
611 { 602 {
612 remove_ob (op); 603 op->destroy ();
613 free_object (op);
614 return; 604 return;
615 } 605 }
616 606
617 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)))
618 { 608 {
619 if (op->other_arch) 609 if (op->other_arch)
620 {
621 explode_bullet (op); 610 explode_bullet (op);
622 }
623 else 611 else
624 { 612 op->destroy ();
625 remove_ob (op); 613
626 free_object (op);
627 }
628 return; 614 return;
629 } 615 }
630 616
631 remove_ob (op); 617 op->remove ();
632 op->x = new_x; 618 op->x = new_x;
633 op->y = new_y; 619 op->y = new_y;
634 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL) 620 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL)
635 return; 621 return;
636 622
… …
685 671
686 tmp->direction = dir; 672 tmp->direction = dir;
687 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE)) 673 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
688 SET_ANIMATION (tmp, dir); 674 SET_ANIMATION (tmp, dir);
689 675
690 set_owner (tmp, op); 676 tmp->set_owner (op);
691 set_spell_skill (op, caster, spob, tmp); 677 set_spell_skill (op, caster, spob, tmp);
692 678
693 tmp->x = op->x + freearr_x[dir]; 679 tmp->x = op->x + freearr_x[dir];
694 tmp->y = op->y + freearr_y[dir]; 680 tmp->y = op->y + freearr_y[dir];
695 tmp->map = op->map; 681 tmp->map = op->map;
696 682
697 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);
698 if (mflags & P_OUT_OF_MAP) 684 if (mflags & P_OUT_OF_MAP)
699 { 685 {
700 free_object (tmp); 686 tmp->destroy ();
701 return 0; 687 return 0;
702 } 688 }
689
703 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)))
704 { 691 {
705 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 692 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
706 { 693 {
707 free_object (tmp); 694 tmp->destroy ();
708 return 0; 695 return 0;
709 } 696 }
697
710 tmp->x = op->x; 698 tmp->x = op->x;
711 tmp->y = op->y; 699 tmp->y = op->y;
712 tmp->direction = absdir (tmp->direction + 4); 700 tmp->direction = absdir (tmp->direction + 4);
713 tmp->map = op->map; 701 tmp->map = op->map;
714 } 702 }
703
715 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)
716 {
717 check_bullet (tmp); 705 check_bullet (tmp);
718 } 706
719 return 1; 707 return 1;
720} 708}
721 709
722 710
723 711
… …
736 object *new_ob = arch_to_object (op->other_arch); 724 object *new_ob = arch_to_object (op->other_arch);
737 725
738 new_ob->x = op->x; 726 new_ob->x = op->x;
739 new_ob->y = op->y; 727 new_ob->y = op->y;
740 new_ob->level = op->level; 728 new_ob->level = op->level;
741 set_owner (new_ob, op->owner); 729 new_ob->set_owner (op->owner);
742 730
743 /* preserve skill ownership */ 731 /* preserve skill ownership */
744 if (op->skill && op->skill != new_ob->skill) 732 if (op->skill && op->skill != new_ob->skill)
745 { 733 {
746 new_ob->skill = op->skill; 734 new_ob->skill = op->skill;
… …
775#if 0 763#if 0
776 /* Disable this - enabling it makes monsters easier, as 764 /* Disable this - enabling it makes monsters easier, as
777 * when their cone dies when they die. 765 * when their cone dies when they die.
778 */ 766 */
779 /* If no owner left, the spell dies out. */ 767 /* If no owner left, the spell dies out. */
780 if (get_owner (op) == NULL) 768 if (op->owner == NULL)
781 { 769 {
782 remove_ob (op); 770 op->destroy ();
783 free_object (op);
784 return; 771 return;
785 } 772 }
786#endif 773#endif
787 774
788 hit_map (op, 0, op->attacktype, 0); 775 hit_map (op, 0, op->attacktype, 0);
… …
797 if (op->destroyed ()) 784 if (op->destroyed ())
798 return; 785 return;
799 786
800 if ((op->duration--) < 0) 787 if ((op->duration--) < 0)
801 { 788 {
802 remove_ob (op); 789 op->destroy ();
803 free_object (op);
804 return; 790 return;
805 } 791 }
806 /* Object has hit maximum range, so don't have it move 792 /* Object has hit maximum range, so don't have it move
807 * any further. When the duration above expires, 793 * any further. When the duration above expires,
808 * then the object will get removed. 794 * then the object will get removed.
… …
817 { 803 {
818 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)];
819 805
820 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))
821 { 807 {
822 object *tmp = get_object (); 808 object *tmp = op->clone ();
823 809
824 copy_object (op, tmp);
825 tmp->x = x; 810 tmp->x = x;
826 tmp->y = y; 811 tmp->y = y;
827 812
828 tmp->duration = op->duration + 1; 813 tmp->duration = op->duration + 1;
829 814
… …
847int 832int
848cast_cone (object *op, object *caster, int dir, object *spell) 833cast_cone (object *op, object *caster, int dir, object *spell)
849{ 834{
850 object *tmp; 835 object *tmp;
851 int i, success = 0, range_min = -1, range_max = 1; 836 int i, success = 0, range_min = -1, range_max = 1;
852 mapstruct *m; 837 maptile *m;
853 sint16 sx, sy; 838 sint16 sx, sy;
854 MoveType movetype; 839 MoveType movetype;
855 840
856 if (!spell->other_arch) 841 if (!spell->other_arch)
857 return 0; 842 return 0;
… …
913 if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype) 898 if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
914 continue; 899 continue;
915 900
916 success = 1; 901 success = 1;
917 tmp = arch_to_object (spell->other_arch); 902 tmp = arch_to_object (spell->other_arch);
918 set_owner (tmp, op); 903 tmp->set_owner (op);
919 set_spell_skill (op, caster, spell, tmp); 904 set_spell_skill (op, caster, spell, tmp);
920 tmp->level = caster_level (caster, spell); 905 tmp->level = caster_level (caster, spell);
921 tmp->x = sx; 906 tmp->x = sx;
922 tmp->y = sy; 907 tmp->y = sy;
923 tmp->attacktype = spell->attacktype; 908 tmp->attacktype = spell->attacktype;
… …
1012 return; 997 return;
1013 998
1014 if (env->type == PLAYER) 999 if (env->type == PLAYER)
1015 esrv_del_item (env->contr, op->count); 1000 esrv_del_item (env->contr, op->count);
1016 1001
1017 remove_ob (op); 1002 op->remove ();
1018 op->x = env->x; 1003 op->x = env->x;
1019 op->y = env->y; 1004 op->y = env->y;
1020 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)
1021 return; 1006 return;
1022 } 1007 }
… …
1024 // 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
1025 // 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
1026 // as bombs can be carried. 1011 // as bombs can be carried.
1027 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)
1028 { 1013 {
1029 remove_ob (op); 1014 op->destroy ();
1030 free_object (op);
1031 return; 1015 return;
1032 } 1016 }
1033 1017
1034 /* This copies a lot of the code from the fire bullet, 1018 /* This copies a lot of the code from the fire bullet,
1035 * but using the cast_bullet isn't really feasible, 1019 * but using the cast_bullet isn't really feasible,
… …
1046 tmp->direction = i; 1030 tmp->direction = i;
1047 tmp->range = op->range; 1031 tmp->range = op->range;
1048 tmp->stats.dam = op->stats.dam; 1032 tmp->stats.dam = op->stats.dam;
1049 tmp->duration = op->duration; 1033 tmp->duration = op->duration;
1050 tmp->attacktype = op->attacktype; 1034 tmp->attacktype = op->attacktype;
1051 copy_owner (tmp, op); 1035 tmp->set_owner (op);
1052 if (op->skill && op->skill != tmp->skill) 1036 if (op->skill && op->skill != tmp->skill)
1053 { 1037 {
1054 tmp->skill = op->skill; 1038 tmp->skill = op->skill;
1055 } 1039 }
1056 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE)) 1040 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
… …
1070{ 1054{
1071 1055
1072 object *tmp; 1056 object *tmp;
1073 int mflags; 1057 int mflags;
1074 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];
1075 mapstruct *m; 1059 maptile *m;
1076 1060
1077 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy); 1061 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy);
1078 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))
1079 { 1063 {
1080 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.");
… …
1086 tmp->range = spell->range + SP_level_range_adjust (caster, spell); 1070 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1087 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1071 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1088 tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell); 1072 tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
1089 tmp->attacktype = spell->attacktype; 1073 tmp->attacktype = spell->attacktype;
1090 1074
1091 set_owner (tmp, op); 1075 tmp->set_owner (op);
1092 set_spell_skill (op, caster, spell, tmp); 1076 set_spell_skill (op, caster, spell, tmp);
1093 tmp->x = dx; 1077 tmp->x = dx;
1094 tmp->y = dy; 1078 tmp->y = dy;
1095 insert_ob_in_map (tmp, m, op, 0); 1079 insert_ob_in_map (tmp, m, op, 0);
1096 return 1; 1080 return 1;
… …
1116get_pointed_target (object *op, int dir, int range, int type) 1100get_pointed_target (object *op, int dir, int range, int type)
1117{ 1101{
1118 object *target; 1102 object *target;
1119 sint16 x, y; 1103 sint16 x, y;
1120 int dist, mflags; 1104 int dist, mflags;
1121 mapstruct *mp; 1105 maptile *mp;
1122 1106
1123 if (dir == 0) 1107 if (dir == 0)
1124 return NULL; 1108 return NULL;
1125 1109
1126 for (dist = 1; dist < range; dist++) 1110 for (dist = 1; dist < range; dist++)
… …
1216 if (effect->attacktype & AT_DEATH) 1200 if (effect->attacktype & AT_DEATH)
1217 { 1201 {
1218 effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1202 effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1219 1203
1220 /* casting death spells at undead isn't a good thing */ 1204 /* casting death spells at undead isn't a good thing */
1221 if QUERY_FLAG
1222 (target, FLAG_UNDEAD) 1205 if (QUERY_FLAG (target, FLAG_UNDEAD))
1223 { 1206 {
1224 if (random_roll (0, 2, op, PREFER_LOW)) 1207 if (random_roll (0, 2, op, PREFER_LOW))
1225 { 1208 {
1226 new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!"); 1209 new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1227 effect->x = op->x; 1210 effect->x = op->x;
… …
1229 } 1212 }
1230 else 1213 else
1231 { 1214 {
1232 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target)); 1215 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s looks stronger!", query_name (target));
1233 target->stats.hp = target->stats.maxhp * 2; 1216 target->stats.hp = target->stats.maxhp * 2;
1234 free_object (effect); 1217 effect->destroy ();
1235 return 0; 1218 return 0;
1236 } 1219 }
1237 } 1220 }
1238 } 1221 }
1239 else 1222 else
1240 { 1223 {
1241 /* how much woe to inflict :) */ 1224 /* how much woe to inflict :) */
1242 effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1225 effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1243 } 1226 }
1244 1227
1245 set_owner (effect, op); 1228 effect->set_owner (op);
1246 set_spell_skill (op, caster, spell, effect); 1229 set_spell_skill (op, caster, spell, effect);
1247 1230
1248 /* ok, tell it where to be, and insert! */ 1231 /* ok, tell it where to be, and insert! */
1249 effect->x = target->x; 1232 effect->x = target->x;
1250 effect->y = target->y; 1233 effect->y = target->y;
… …
1266move_missile (object *op) 1249move_missile (object *op)
1267{ 1250{
1268 int i, mflags; 1251 int i, mflags;
1269 object *owner; 1252 object *owner;
1270 sint16 new_x, new_y; 1253 sint16 new_x, new_y;
1271 mapstruct *m; 1254 maptile *m;
1272 1255
1273 if (op->range-- <= 0) 1256 if (op->range-- <= 0)
1274 { 1257 {
1275 remove_ob (op); 1258 op->destroy ();
1276 free_object (op);
1277 return; 1259 return;
1278 } 1260 }
1279 1261
1280 owner = get_owner (op); 1262 owner = op->owner;
1281#if 0 1263#if 0
1282 /* It'd make things nastier if this wasn't here - spells cast by 1264 /* It'd make things nastier if this wasn't here - spells cast by
1283 * monster that are then killed would continue to survive 1265 * monster that are then killed would continue to survive
1284 */ 1266 */
1285 if (owner == NULL) 1267 if (owner == NULL)
1286 { 1268 {
1287 remove_ob (op); 1269 op->destroy ();
1288 free_object (op);
1289 return; 1270 return;
1290 } 1271 }
1291#endif 1272#endif
1292 1273
1293 new_x = op->x + DIRX (op); 1274 new_x = op->x + DIRX (op);
… …
1300 hit_map (op, op->direction, AT_MAGIC, 1); 1281 hit_map (op, op->direction, AT_MAGIC, 1);
1301 /* Basically, missile only hits one thing then goes away. 1282 /* Basically, missile only hits one thing then goes away.
1302 * we need to remove it if someone hasn't already done so. 1283 * we need to remove it if someone hasn't already done so.
1303 */ 1284 */
1304 if (!op->destroyed ()) 1285 if (!op->destroyed ())
1305 free_object (op); 1286 op->destroy ();
1306 1287
1307 return; 1288 return;
1308 } 1289 }
1309 1290
1310 remove_ob (op); 1291 op->remove ();
1311 1292
1312 if (!op->direction || (mflags & P_OUT_OF_MAP)) 1293 if (!op->direction || (mflags & P_OUT_OF_MAP))
1313 { 1294 {
1314 free_object (op); 1295 op->destroy ();
1315 return; 1296 return;
1316 } 1297 }
1317 1298
1318 op->x = new_x; 1299 op->x = new_x;
1319 op->y = new_y; 1300 op->y = new_y;
1320 op->map = m; 1301 op->map = m;
1321 i = spell_find_dir (op->map, op->x, op->y, get_owner (op)); 1302 i = spell_find_dir (op->map, op->x, op->y, op->owner);
1322 if (i > 0 && i != op->direction) 1303 if (i > 0 && i != op->direction)
1323 { 1304 {
1324 op->direction = i; 1305 op->direction = i;
1325 SET_ANIMATION (op, op->direction); 1306 SET_ANIMATION (op, op->direction);
1326 } 1307 }
… …
1378int 1359int
1379cast_destruction (object *op, object *caster, object *spell_ob) 1360cast_destruction (object *op, object *caster, object *spell_ob)
1380{ 1361{
1381 int i, j, range, mflags, friendly = 0, dam, dur; 1362 int i, j, range, mflags, friendly = 0, dam, dur;
1382 sint16 sx, sy; 1363 sint16 sx, sy;
1383 mapstruct *m; 1364 maptile *m;
1384 object *tmp; 1365 object *tmp;
1385 const char *skill; 1366 const char *skill;
1386 1367
1387 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 1368 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1388 dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 1369 dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
… …
1570mood_change (object *op, object *caster, object *spell) 1551mood_change (object *op, object *caster, object *spell)
1571{ 1552{
1572 object *tmp, *god, *head; 1553 object *tmp, *god, *head;
1573 int done_one, range, mflags, level, at, best_at; 1554 int done_one, range, mflags, level, at, best_at;
1574 sint16 x, y, nx, ny; 1555 sint16 x, y, nx, ny;
1575 mapstruct *m; 1556 maptile *m;
1576 const char *race; 1557 const char *race;
1577 1558
1578 /* We precompute some values here so that we don't have to keep 1559 /* We precompute some values here so that we don't have to keep
1579 * doing it over and over again. 1560 * doing it over and over again.
1580 */ 1561 */
… …
1708 SET_FLAG (head, FLAG_FRIENDLY); 1689 SET_FLAG (head, FLAG_FRIENDLY);
1709 /* Prevent uncontolled outbreaks of self replicating monsters. 1690 /* Prevent uncontolled outbreaks of self replicating monsters.
1710 Typical use case is charm, go somwhere, use aggravation to make hostile. 1691 Typical use case is charm, go somwhere, use aggravation to make hostile.
1711 This could lead to fun stuff like mice outbreak in bigworld and server crawl. */ 1692 This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1712 CLEAR_FLAG (head, FLAG_GENERATOR); 1693 CLEAR_FLAG (head, FLAG_GENERATOR);
1713 set_owner (head, op); 1694 head->set_owner (op);
1714 set_spell_skill (op, caster, spell, head); 1695 set_spell_skill (op, caster, spell, head);
1715 add_friendly_object (head); 1696 add_friendly_object (head);
1716 head->attack_movement = PETMOVE; 1697 head->attack_movement = PETMOVE;
1717 done_one = 1; 1698 done_one = 1;
1718 change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL); 1699 change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
… …
1744move_ball_spell (object *op) 1725move_ball_spell (object *op)
1745{ 1726{
1746 int i, j, dam_save, dir, mflags; 1727 int i, j, dam_save, dir, mflags;
1747 sint16 nx, ny, hx, hy; 1728 sint16 nx, ny, hx, hy;
1748 object *owner; 1729 object *owner;
1749 mapstruct *m; 1730 maptile *m;
1750 1731
1751 owner = get_owner (op); 1732 owner = op->owner;
1752 1733
1753 /* the following logic makes sure that the ball doesn't move into a wall, 1734 /* the following logic makes sure that the ball doesn't move into a wall,
1754 * and makes sure that it will move along a wall to try and get at it's 1735 * and makes sure that it will move along a wall to try and get at it's
1755 * victim. The block immediately below more or less chooses a random 1736 * victim. The block immediately below more or less chooses a random
1756 * offset to move the ball, eg, keep it mostly on course, with some 1737 * offset to move the ball, eg, keep it mostly on course, with some
… …
1785 nx = op->x; 1766 nx = op->x;
1786 ny = op->y; 1767 ny = op->y;
1787 m = op->map; 1768 m = op->map;
1788 } 1769 }
1789 1770
1790 remove_ob (op); 1771 op->remove ();
1791 op->y = ny; 1772 op->y = ny;
1792 op->x = nx; 1773 op->x = nx;
1793 insert_ob_in_map (op, m, op, 0); 1774 insert_ob_in_map (op, m, op, 0);
1794 1775
1795 dam_save = op->stats.dam; /* save the original dam: we do halfdam on 1776 dam_save = op->stats.dam; /* save the original dam: we do halfdam on
… …
1835 } 1816 }
1836 1817
1837 /* restore to the center location and damage */ 1818 /* restore to the center location and damage */
1838 op->stats.dam = dam_save; 1819 op->stats.dam = dam_save;
1839 1820
1840 i = spell_find_dir (op->map, op->x, op->y, get_owner (op)); 1821 i = spell_find_dir (op->map, op->x, op->y, op->owner);
1841 1822
1842 if (i >= 0) 1823 if (i >= 0)
1843 { /* we have a preferred direction! */ 1824 { /* we have a preferred direction! */
1844 /* pick another direction if the preferred dir is blocked. */ 1825 /* pick another direction if the preferred dir is blocked. */
1845 if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP || 1826 if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP ||
… …
1866#if 0 1847#if 0
1867 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 }; 1848 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1868 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 }; 1849 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1869 sint16 target_x, target_y, origin_x, origin_y; 1850 sint16 target_x, target_y, origin_x, origin_y;
1870 int adjustdir; 1851 int adjustdir;
1871 mapstruct *m; 1852 maptile *m;
1872#endif 1853#endif
1873 int basedir; 1854 int basedir;
1874 object *owner; 1855 object *owner;
1875 1856
1876 owner = get_owner (op); 1857 owner = op->owner;
1877 if (op->duration == 0 || owner == NULL) 1858 if (op->duration == 0 || owner == NULL)
1878 { 1859 {
1879 remove_ob (op); 1860 op->destroy ();
1880 free_object (op);
1881 return; 1861 return;
1882 } 1862 }
1863
1883 op->duration--; 1864 op->duration--;
1884 1865
1885 basedir = op->direction; 1866 basedir = op->direction;
1886 if (basedir == 0) 1867 if (basedir == 0)
1887 { 1868 {
… …
1986 return 0; 1967 return 0;
1987 1968
1988 tmp = get_archetype (SWARM_SPELL); 1969 tmp = get_archetype (SWARM_SPELL);
1989 tmp->x = op->x; 1970 tmp->x = op->x;
1990 tmp->y = op->y; 1971 tmp->y = op->y;
1991 set_owner (tmp, op); /* needed so that if swarm elements kill, caster gets xp. */ 1972 tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
1992 set_spell_skill (op, caster, spell, tmp); 1973 set_spell_skill (op, caster, spell, tmp);
1993 1974
1994 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */ 1975 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */
1995 tmp->spell = arch_to_object (spell->other_arch); 1976 tmp->spell = arch_to_object (spell->other_arch);
1996 1977
… …
2019cast_light (object *op, object *caster, object *spell, int dir) 2000cast_light (object *op, object *caster, object *spell, int dir)
2020{ 2001{
2021 object *target = NULL, *tmp = NULL; 2002 object *target = NULL, *tmp = NULL;
2022 sint16 x, y; 2003 sint16 x, y;
2023 int dam, mflags; 2004 int dam, mflags;
2024 mapstruct *m; 2005 maptile *m;
2025 2006
2026 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2007 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2027 2008
2028 if (!dir) 2009 if (!dir)
2029 { 2010 {
… …
2097cast_cause_disease (object *op, object *caster, object *spell, int dir) 2078cast_cause_disease (object *op, object *caster, object *spell, int dir)
2098{ 2079{
2099 sint16 x, y; 2080 sint16 x, y;
2100 int i, mflags, range, dam_mod, dur_mod; 2081 int i, mflags, range, dam_mod, dur_mod;
2101 object *walk; 2082 object *walk;
2102 mapstruct *m; 2083 maptile *m;
2103 2084
2104 x = op->x; 2085 x = op->x;
2105 y = op->y; 2086 y = op->y;
2106 2087
2107 /* If casting from a scroll, no direction will be available, so refer to the 2088 /* If casting from a scroll, no direction will be available, so refer to the
… …
2140 for (walk = get_map_ob (m, x, y); walk; walk = walk->above) 2121 for (walk = get_map_ob (m, x, y); walk; walk = walk->above)
2141 if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER)) 2122 if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
2142 { /* found a victim */ 2123 { /* found a victim */
2143 object *disease = arch_to_object (spell->other_arch); 2124 object *disease = arch_to_object (spell->other_arch);
2144 2125
2145 set_owner (disease, op); 2126 disease->set_owner (op);
2146 set_spell_skill (op, caster, spell, disease); 2127 set_spell_skill (op, caster, spell, disease);
2147 disease->stats.exp = 0; 2128 disease->stats.exp = 0;
2148 disease->level = caster_level (caster, spell); 2129 disease->level = caster_level (caster, spell);
2149 2130
2150 /* do level adjustments */ 2131 /* do level adjustments */
… …
2199 { 2180 {
2200 object *flash; /* visual effect for inflicting disease */ 2181 object *flash; /* visual effect for inflicting disease */
2201 2182
2202 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name); 2183 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2203 2184
2204 free_object (disease); /* don't need this one anymore */ 2185 disease->destroy (); /* don't need this one anymore */
2205 flash = get_archetype (ARCH_DETECT_MAGIC); 2186 flash = get_archetype (ARCH_DETECT_MAGIC);
2206 flash->x = x; 2187 flash->x = x;
2207 flash->y = y; 2188 flash->y = y;
2208 flash->map = walk->map; 2189 flash->map = walk->map;
2209 insert_ob_in_map (flash, walk->map, op, 0); 2190 insert_ob_in_map (flash, walk->map, op, 0);
2210 return 1; 2191 return 1;
2211 } 2192 }
2212 free_object (disease); 2193
2194 disease->destroy ();
2213 } 2195 }
2214 } /* if living creature */ 2196 } /* if living creature */
2215 } /* for range of spaces */ 2197 } /* for range of spaces */
2216 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!"); 2198 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
2217 return 1; 2199 return 1;

Diff Legend

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