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.18 by root, Wed Dec 13 00:42:04 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
… …
147 140
148 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)))
149 return; 142 return;
150 143
151 /* OK, we made a fork */ 144 /* OK, we made a fork */
152 new_bolt = get_object (); 145 new_bolt = tmp->clone ();
153 copy_object (tmp, new_bolt);
154 146
155 /* reduce chances of subsequent forking */ 147 /* reduce chances of subsequent forking */
156 new_bolt->stats.Dex -= 10; 148 new_bolt->stats.Dex -= 10;
157 tmp->stats.Dex -= 10; /* less forks from main bolt too */ 149 tmp->stats.Dex -= 10; /* less forks from main bolt too */
158 new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */ 150 new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */
… …
177move_bolt (object *op) 169move_bolt (object *op)
178{ 170{
179 object *tmp; 171 object *tmp;
180 int mflags; 172 int mflags;
181 sint16 x, y; 173 sint16 x, y;
182 mapstruct *m; 174 maptile *m;
183 175
184 if (--(op->duration) < 0) 176 if (--(op->duration) < 0)
185 { 177 {
186 remove_ob (op); 178 op->destroy ();
187 free_object (op);
188 return; 179 return;
189 } 180 }
181
190 hit_map (op, 0, op->attacktype, 1); 182 hit_map (op, 0, op->attacktype, 1);
191 183
192 if (!op->direction) 184 if (!op->direction)
193 return; 185 return;
194 186
… …
256 update_turn_face (op); /* A bolt *must* be IS_TURNABLE */ 248 update_turn_face (op); /* A bolt *must* be IS_TURNABLE */
257 return; 249 return;
258 } 250 }
259 else 251 else
260 { /* Create a copy of this object and put it ahead */ 252 { /* Create a copy of this object and put it ahead */
261 tmp = get_object (); 253 tmp = op->clone ();
262 copy_object (op, tmp); 254
263 tmp->speed_left = -0.1; 255 tmp->speed_left = -0.1;
264 tmp->x += DIRX (tmp), tmp->y += DIRY (tmp); 256 tmp->x += DIRX (tmp), tmp->y += DIRY (tmp);
265 tmp = insert_ob_in_map (tmp, op->map, op, 0); 257 tmp = insert_ob_in_map (tmp, op->map, op, 0);
266 /* 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 */
267 tmp->duration++; 259 tmp->duration++;
… …
326 tmp->map = op->map; 318 tmp->map = op->map;
327 319
328 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);
329 if (mflags & P_OUT_OF_MAP) 321 if (mflags & P_OUT_OF_MAP)
330 { 322 {
331 free_object (tmp); 323 tmp->destroy ();
332 return 0; 324 return 0;
333 } 325 }
326
334 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)))
335 { 328 {
336 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 329 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
337 { 330 {
338 free_object (tmp); 331 tmp->destroy ();
339 return 0; 332 return 0;
340 } 333 }
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);
344 tmp->map = op->map; 338 tmp->map = op->map;
345 } 339 }
340
346 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)
347 move_bolt (tmp); 342 move_bolt (tmp);
343
348 return 1; 344 return 1;
349} 345}
350 346
351 347
352 348
… …
362 */ 358 */
363void 359void
364explosion (object *op) 360explosion (object *op)
365{ 361{
366 object *tmp; 362 object *tmp;
367 mapstruct *m = op->map; 363 maptile *m = op->map;
368 int i; 364 int i;
369 365
370 if (--(op->duration) < 0) 366 if (--(op->duration) < 0)
371 { 367 {
372 remove_ob (op); 368 op->destroy ();
373 free_object (op);
374 return; 369 return;
375 } 370 }
371
376 hit_map (op, 0, op->attacktype, 0); 372 hit_map (op, 0, op->attacktype, 0);
377 373
378 if (op->range > 0) 374 if (op->range > 0)
379 { 375 {
380 for (i = 1; i < 9; i++) 376 for (i = 1; i < 9; i++)
… …
386 /* ok_to_put_more already does things like checks for walls, 382 /* ok_to_put_more already does things like checks for walls,
387 * out of map, etc. 383 * out of map, etc.
388 */ 384 */
389 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))
390 { 386 {
391 tmp = get_object (); 387 tmp = op->clone ();
392 copy_object (op, tmp);
393 tmp->state = 0; 388 tmp->state = 0;
394 tmp->speed_left = -0.21; 389 tmp->speed_left = -0.21;
395 tmp->range--; 390 tmp->range--;
396 tmp->value = 0; 391 tmp->value = 0;
397 tmp->x = dx; 392 tmp->x = dx;
… …
408 * explode. 403 * explode.
409 */ 404 */
410void 405void
411explode_bullet (object *op) 406explode_bullet (object *op)
412{ 407{
413 tag_t op_tag = op->count;
414 object *tmp, *owner; 408 object *tmp, *owner;
415 409
416 if (op->other_arch == NULL) 410 if (op->other_arch == NULL)
417 { 411 {
418 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 412 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
419 remove_ob (op); 413 op->destroy ();
420 free_object (op);
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->destroy ();
433 free_object (op);
434 return; 426 return;
435 } 427 }
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->destroy ();
445 free_object (op);
446 return; 438 return;
447 } 439 }
448 440
449 // 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
450 // 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
451 // bad at the moment that might happen from this. 443 // 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) 444 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
453 { 445 {
454 remove_ob (op); 446 op->destroy ();
455 free_object (op);
456 return; 447 return;
457 } 448 }
458 449
459 if (op->attacktype) 450 if (op->attacktype)
460 { 451 {
461 hit_map (op, 0, op->attacktype, 1); 452 hit_map (op, 0, op->attacktype, 1);
462 if (was_destroyed (op, op_tag)) 453 if (op->destroyed ())
463 return; 454 return;
464 } 455 }
465 456
466 /* other_arch contains what this explodes into */ 457 /* other_arch contains what this explodes into */
467 tmp = arch_to_object (op->other_arch); 458 tmp = arch_to_object (op->other_arch);
… …
471 462
472 owner = get_owner (op); 463 owner = get_owner (op);
473 464
474 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))
475 { 466 {
476 remove_ob (op); 467 op->destroy ();
477 free_object (op);
478 return; 468 return;
479 } 469 }
480 470
481 tmp->x = op->x; 471 tmp->x = op->x;
482 tmp->y = op->y; 472 tmp->y = op->y;
… …
510 /* Prevent recursion */ 500 /* Prevent recursion */
511 op->move_on = 0; 501 op->move_on = 0;
512 502
513 insert_ob_in_map (tmp, op->map, op, 0); 503 insert_ob_in_map (tmp, op->map, op, 0);
514 /* remove the firebullet */ 504 /* remove the firebullet */
515 if (!was_destroyed (op, op_tag)) 505 if (!op->destroyed ())
516 { 506 {
517 remove_ob (op); 507 op->destroy ();
518 free_object (op);
519 } 508 }
520} 509}
521 510
522 511
523 512
… …
526 */ 515 */
527 516
528void 517void
529check_bullet (object *op) 518check_bullet (object *op)
530{ 519{
531 tag_t op_tag = op->count, tmp_tag;
532 object *tmp; 520 object *tmp;
533 int dam, mflags; 521 int dam, mflags;
534 mapstruct *m; 522 maptile *m;
535 sint16 sx, sy; 523 sint16 sx, sy;
536 524
537 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);
538 526
539 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)))
… …
552 540
553 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)
554 { 542 {
555 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 543 if (QUERY_FLAG (tmp, FLAG_ALIVE))
556 { 544 {
557 tmp_tag = tmp->count;
558 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 545 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) 546 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
560 { 547 {
561 if (!QUERY_FLAG (op, FLAG_REMOVED)) 548 if (!QUERY_FLAG (op, FLAG_REMOVED))
562 { 549 {
563 remove_ob (op); 550 op->destroy ();
564 free_object (op);
565 return; 551 return;
566 } 552 }
567 } 553 }
568 } 554 }
569 } 555 }
… …
579void 565void
580move_bullet (object *op) 566move_bullet (object *op)
581{ 567{
582 sint16 new_x, new_y; 568 sint16 new_x, new_y;
583 int mflags; 569 int mflags;
584 mapstruct *m; 570 maptile *m;
585 571
586#if 0 572#if 0
587 /* We need a better general purpose way to do this */ 573 /* We need a better general purpose way to do this */
588 574
589 /* peterm: added to make comet leave a trail of burnouts 575 /* peterm: added to make comet leave a trail of burnouts
590 it's an unadulterated hack, but the effect is cool. */ 576 it's an unadulterated hack, but the effect is cool. */
591 if (op->stats.sp == SP_METEOR) 577 if (op->stats.sp == SP_METEOR)
592 { 578 {
593 replace_insert_ob_in_map ("fire_trail", op); 579 replace_insert_ob_in_map ("fire_trail", op);
594 if (was_destroyed (op, op_tag)) 580 if (op->destroyed ())
595 return; 581 return;
596 } /* end addition. */ 582 } /* end addition. */
597#endif 583#endif
598 584
599 /* Reached the end of its life - remove it */ 585 /* Reached the end of its life - remove it */
600 if (--op->range <= 0) 586 if (--op->range <= 0)
601 { 587 {
602 if (op->other_arch) 588 if (op->other_arch)
603 {
604 explode_bullet (op); 589 explode_bullet (op);
605 }
606 else 590 else
607 { 591 op->destroy ();
608 remove_ob (op); 592
609 free_object (op);
610 }
611 return; 593 return;
612 } 594 }
613 595
614 new_x = op->x + DIRX (op); 596 new_x = op->x + DIRX (op);
615 new_y = op->y + DIRY (op); 597 new_y = op->y + DIRY (op);
616 m = op->map; 598 m = op->map;
617 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);
618 600
619 if (mflags & P_OUT_OF_MAP) 601 if (mflags & P_OUT_OF_MAP)
620 { 602 {
621 remove_ob (op); 603 op->destroy ();
622 free_object (op);
623 return; 604 return;
624 } 605 }
625 606
626 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)))
627 { 608 {
628 if (op->other_arch) 609 if (op->other_arch)
629 {
630 explode_bullet (op); 610 explode_bullet (op);
631 }
632 else 611 else
633 { 612 op->destroy ();
634 remove_ob (op); 613
635 free_object (op);
636 }
637 return; 614 return;
638 } 615 }
639 616
640 remove_ob (op); 617 op->remove ();
641 op->x = new_x; 618 op->x = new_x;
642 op->y = new_y; 619 op->y = new_y;
643 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL) 620 if ((op = insert_ob_in_map (op, m, op, 0)) == NULL)
644 return; 621 return;
645 622
… …
704 tmp->map = op->map; 681 tmp->map = op->map;
705 682
706 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);
707 if (mflags & P_OUT_OF_MAP) 684 if (mflags & P_OUT_OF_MAP)
708 { 685 {
709 free_object (tmp); 686 tmp->destroy ();
710 return 0; 687 return 0;
711 } 688 }
689
712 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)))
713 { 691 {
714 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 692 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
715 { 693 {
716 free_object (tmp); 694 tmp->destroy ();
717 return 0; 695 return 0;
718 } 696 }
697
719 tmp->x = op->x; 698 tmp->x = op->x;
720 tmp->y = op->y; 699 tmp->y = op->y;
721 tmp->direction = absdir (tmp->direction + 4); 700 tmp->direction = absdir (tmp->direction + 4);
722 tmp->map = op->map; 701 tmp->map = op->map;
723 } 702 }
703
724 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)
725 {
726 check_bullet (tmp); 705 check_bullet (tmp);
727 } 706
728 return 1; 707 return 1;
729} 708}
730 709
731 710
732 711
… …
762 741
763void 742void
764move_cone (object *op) 743move_cone (object *op)
765{ 744{
766 int i; 745 int i;
767 tag_t tag;
768 746
769 /* 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 */
770 if (!op->map) 748 if (!op->map)
771 { 749 {
772 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");
… …
787 * when their cone dies when they die. 765 * when their cone dies when they die.
788 */ 766 */
789 /* If no owner left, the spell dies out. */ 767 /* If no owner left, the spell dies out. */
790 if (get_owner (op) == NULL) 768 if (get_owner (op) == NULL)
791 { 769 {
792 remove_ob (op); 770 op->destroy ();
793 free_object (op);
794 return; 771 return;
795 } 772 }
796#endif 773#endif
797 774
798 tag = op->count;
799 hit_map (op, 0, op->attacktype, 0); 775 hit_map (op, 0, op->attacktype, 0);
800 776
801 /* Check to see if we should push anything. 777 /* Check to see if we should push anything.
802 * Spell objects with weight push whatever they encounter to some 778 * Spell objects with weight push whatever they encounter to some
803 * degree. 779 * degree.
804 */ 780 */
805 if (op->weight) 781 if (op->weight)
806 check_spell_knockback (op); 782 check_spell_knockback (op);
807 783
808 if (was_destroyed (op, tag)) 784 if (op->destroyed ())
809 return; 785 return;
810 786
811 if ((op->duration--) < 0) 787 if ((op->duration--) < 0)
812 { 788 {
813 remove_ob (op); 789 op->destroy ();
814 free_object (op);
815 return; 790 return;
816 } 791 }
817 /* Object has hit maximum range, so don't have it move 792 /* Object has hit maximum range, so don't have it move
818 * any further. When the duration above expires, 793 * any further. When the duration above expires,
819 * then the object will get removed. 794 * then the object will get removed.
… …
828 { 803 {
829 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)];
830 805
831 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))
832 { 807 {
833 object *tmp = get_object (); 808 object *tmp = op->clone ();
834 809
835 copy_object (op, tmp);
836 tmp->x = x; 810 tmp->x = x;
837 tmp->y = y; 811 tmp->y = y;
838 812
839 tmp->duration = op->duration + 1; 813 tmp->duration = op->duration + 1;
840 814
… …
858int 832int
859cast_cone (object *op, object *caster, int dir, object *spell) 833cast_cone (object *op, object *caster, int dir, object *spell)
860{ 834{
861 object *tmp; 835 object *tmp;
862 int i, success = 0, range_min = -1, range_max = 1; 836 int i, success = 0, range_min = -1, range_max = 1;
863 mapstruct *m; 837 maptile *m;
864 sint16 sx, sy; 838 sint16 sx, sy;
865 MoveType movetype; 839 MoveType movetype;
866 840
867 if (!spell->other_arch) 841 if (!spell->other_arch)
868 return 0; 842 return 0;
… …
1023 return; 997 return;
1024 998
1025 if (env->type == PLAYER) 999 if (env->type == PLAYER)
1026 esrv_del_item (env->contr, op->count); 1000 esrv_del_item (env->contr, op->count);
1027 1001
1028 remove_ob (op); 1002 op->remove ();
1029 op->x = env->x; 1003 op->x = env->x;
1030 op->y = env->y; 1004 op->y = env->y;
1031 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)
1032 return; 1006 return;
1033 } 1007 }
… …
1035 // 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
1036 // 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
1037 // as bombs can be carried. 1011 // as bombs can be carried.
1038 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)
1039 { 1013 {
1040 remove_ob (op); 1014 op->destroy ();
1041 free_object (op);
1042 return; 1015 return;
1043 } 1016 }
1044 1017
1045 /* This copies a lot of the code from the fire bullet, 1018 /* This copies a lot of the code from the fire bullet,
1046 * but using the cast_bullet isn't really feasible, 1019 * but using the cast_bullet isn't really feasible,
1047 * so just set up the appropriate values. 1020 * so just set up the appropriate values.
1048 */ 1021 */
1049 at = find_archetype (SPLINT); 1022 at = archetype::find (SPLINT);
1050 if (at) 1023 if (at)
1051 { 1024 {
1052 for (i = 1; i < 9; i++) 1025 for (i = 1; i < 9; i++)
1053 { 1026 {
1054 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i])) 1027 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
… …
1081{ 1054{
1082 1055
1083 object *tmp; 1056 object *tmp;
1084 int mflags; 1057 int mflags;
1085 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];
1086 mapstruct *m; 1059 maptile *m;
1087 1060
1088 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy); 1061 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)) 1062 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1090 { 1063 {
1091 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.");
… …
1127get_pointed_target (object *op, int dir, int range, int type) 1100get_pointed_target (object *op, int dir, int range, int type)
1128{ 1101{
1129 object *target; 1102 object *target;
1130 sint16 x, y; 1103 sint16 x, y;
1131 int dist, mflags; 1104 int dist, mflags;
1132 mapstruct *mp; 1105 maptile *mp;
1133 1106
1134 if (dir == 0) 1107 if (dir == 0)
1135 return NULL; 1108 return NULL;
1136 1109
1137 for (dist = 1; dist < range; dist++) 1110 for (dist = 1; dist < range; dist++)
… …
1240 } 1213 }
1241 else 1214 else
1242 { 1215 {
1243 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));
1244 target->stats.hp = target->stats.maxhp * 2; 1217 target->stats.hp = target->stats.maxhp * 2;
1245 free_object (effect); 1218 effect->destroy ();
1246 return 0; 1219 return 0;
1247 } 1220 }
1248 } 1221 }
1249 } 1222 }
1250 else 1223 else
… …
1277move_missile (object *op) 1250move_missile (object *op)
1278{ 1251{
1279 int i, mflags; 1252 int i, mflags;
1280 object *owner; 1253 object *owner;
1281 sint16 new_x, new_y; 1254 sint16 new_x, new_y;
1282 mapstruct *m; 1255 maptile *m;
1283 1256
1284 if (op->range-- <= 0) 1257 if (op->range-- <= 0)
1285 { 1258 {
1286 remove_ob (op); 1259 op->destroy ();
1287 free_object (op);
1288 return; 1260 return;
1289 } 1261 }
1290 1262
1291 owner = get_owner (op); 1263 owner = get_owner (op);
1292#if 0 1264#if 0
1293 /* 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
1294 * monster that are then killed would continue to survive 1266 * monster that are then killed would continue to survive
1295 */ 1267 */
1296 if (owner == NULL) 1268 if (owner == NULL)
1297 { 1269 {
1298 remove_ob (op); 1270 op->destroy ();
1299 free_object (op);
1300 return; 1271 return;
1301 } 1272 }
1302#endif 1273#endif
1303 1274
1304 new_x = op->x + DIRX (op); 1275 new_x = op->x + DIRX (op);
… …
1306 1277
1307 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);
1308 1279
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)))) 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))))
1310 { 1281 {
1311 tag_t tag = op->count;
1312
1313 hit_map (op, op->direction, AT_MAGIC, 1); 1282 hit_map (op, op->direction, AT_MAGIC, 1);
1314 /* Basically, missile only hits one thing then goes away. 1283 /* Basically, missile only hits one thing then goes away.
1315 * 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.
1316 */ 1285 */
1317 if (!was_destroyed (op, tag)) 1286 if (!op->destroyed ())
1318 { 1287 op->destroy ();
1319 remove_ob (op); 1288
1320 free_object (op);
1321 }
1322 return; 1289 return;
1323 } 1290 }
1324 1291
1325 remove_ob (op); 1292 op->remove ();
1293
1326 if (!op->direction || (mflags & P_OUT_OF_MAP)) 1294 if (!op->direction || (mflags & P_OUT_OF_MAP))
1327 { 1295 {
1328 free_object (op); 1296 op->destroy ();
1329 return; 1297 return;
1330 } 1298 }
1299
1331 op->x = new_x; 1300 op->x = new_x;
1332 op->y = new_y; 1301 op->y = new_y;
1333 op->map = m; 1302 op->map = m;
1334 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));
1335 if (i > 0 && i != op->direction) 1304 if (i > 0 && i != op->direction)
1336 { 1305 {
1337 op->direction = i; 1306 op->direction = i;
1338 SET_ANIMATION (op, op->direction); 1307 SET_ANIMATION (op, op->direction);
1339 } 1308 }
1309
1340 insert_ob_in_map (op, op->map, op, 0); 1310 insert_ob_in_map (op, op->map, op, 0);
1341} 1311}
1342 1312
1343/**************************************************************************** 1313/****************************************************************************
1344 * Destruction 1314 * Destruction
… …
1390int 1360int
1391cast_destruction (object *op, object *caster, object *spell_ob) 1361cast_destruction (object *op, object *caster, object *spell_ob)
1392{ 1362{
1393 int i, j, range, mflags, friendly = 0, dam, dur; 1363 int i, j, range, mflags, friendly = 0, dam, dur;
1394 sint16 sx, sy; 1364 sint16 sx, sy;
1395 mapstruct *m; 1365 maptile *m;
1396 object *tmp; 1366 object *tmp;
1397 const char *skill; 1367 const char *skill;
1398 1368
1399 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 1369 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
1400 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);
… …
1582mood_change (object *op, object *caster, object *spell) 1552mood_change (object *op, object *caster, object *spell)
1583{ 1553{
1584 object *tmp, *god, *head; 1554 object *tmp, *god, *head;
1585 int done_one, range, mflags, level, at, best_at; 1555 int done_one, range, mflags, level, at, best_at;
1586 sint16 x, y, nx, ny; 1556 sint16 x, y, nx, ny;
1587 mapstruct *m; 1557 maptile *m;
1588 const char *race; 1558 const char *race;
1589 1559
1590 /* 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
1591 * doing it over and over again. 1561 * doing it over and over again.
1592 */ 1562 */
… …
1756move_ball_spell (object *op) 1726move_ball_spell (object *op)
1757{ 1727{
1758 int i, j, dam_save, dir, mflags; 1728 int i, j, dam_save, dir, mflags;
1759 sint16 nx, ny, hx, hy; 1729 sint16 nx, ny, hx, hy;
1760 object *owner; 1730 object *owner;
1761 mapstruct *m; 1731 maptile *m;
1762 1732
1763 owner = get_owner (op); 1733 owner = get_owner (op);
1764 1734
1765 /* 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,
1766 * 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
… …
1797 nx = op->x; 1767 nx = op->x;
1798 ny = op->y; 1768 ny = op->y;
1799 m = op->map; 1769 m = op->map;
1800 } 1770 }
1801 1771
1802 remove_ob (op); 1772 op->remove ();
1803 op->y = ny; 1773 op->y = ny;
1804 op->x = nx; 1774 op->x = nx;
1805 insert_ob_in_map (op, m, op, 0); 1775 insert_ob_in_map (op, m, op, 0);
1806 1776
1807 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
… …
1878#if 0 1848#if 0
1879 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 };
1880 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 };
1881 sint16 target_x, target_y, origin_x, origin_y; 1851 sint16 target_x, target_y, origin_x, origin_y;
1882 int adjustdir; 1852 int adjustdir;
1883 mapstruct *m; 1853 maptile *m;
1884#endif 1854#endif
1885 int basedir; 1855 int basedir;
1886 object *owner; 1856 object *owner;
1887 1857
1888 owner = get_owner (op); 1858 owner = get_owner (op);
1889 if (op->duration == 0 || owner == NULL) 1859 if (op->duration == 0 || owner == NULL)
1890 { 1860 {
1891 remove_ob (op); 1861 op->destroy ();
1892 free_object (op);
1893 return; 1862 return;
1894 } 1863 }
1864
1895 op->duration--; 1865 op->duration--;
1896 1866
1897 basedir = op->direction; 1867 basedir = op->direction;
1898 if (basedir == 0) 1868 if (basedir == 0)
1899 { 1869 {
… …
2031cast_light (object *op, object *caster, object *spell, int dir) 2001cast_light (object *op, object *caster, object *spell, int dir)
2032{ 2002{
2033 object *target = NULL, *tmp = NULL; 2003 object *target = NULL, *tmp = NULL;
2034 sint16 x, y; 2004 sint16 x, y;
2035 int dam, mflags; 2005 int dam, mflags;
2036 mapstruct *m; 2006 maptile *m;
2037 2007
2038 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2008 dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2039 2009
2040 if (!dir) 2010 if (!dir)
2041 { 2011 {
… …
2109cast_cause_disease (object *op, object *caster, object *spell, int dir) 2079cast_cause_disease (object *op, object *caster, object *spell, int dir)
2110{ 2080{
2111 sint16 x, y; 2081 sint16 x, y;
2112 int i, mflags, range, dam_mod, dur_mod; 2082 int i, mflags, range, dam_mod, dur_mod;
2113 object *walk; 2083 object *walk;
2114 mapstruct *m; 2084 maptile *m;
2115 2085
2116 x = op->x; 2086 x = op->x;
2117 y = op->y; 2087 y = op->y;
2118 2088
2119 /* 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
… …
2211 { 2181 {
2212 object *flash; /* visual effect for inflicting disease */ 2182 object *flash; /* visual effect for inflicting disease */
2213 2183
2214 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);
2215 2185
2216 free_object (disease); /* don't need this one anymore */ 2186 disease->destroy (); /* don't need this one anymore */
2217 flash = get_archetype (ARCH_DETECT_MAGIC); 2187 flash = get_archetype (ARCH_DETECT_MAGIC);
2218 flash->x = x; 2188 flash->x = x;
2219 flash->y = y; 2189 flash->y = y;
2220 flash->map = walk->map; 2190 flash->map = walk->map;
2221 insert_ob_in_map (flash, walk->map, op, 0); 2191 insert_ob_in_map (flash, walk->map, op, 0);
2222 return 1; 2192 return 1;
2223 } 2193 }
2224 free_object (disease); 2194
2195 disease->destroy ();
2225 } 2196 }
2226 } /* if living creature */ 2197 } /* if living creature */
2227 } /* for range of spaces */ 2198 } /* for range of spaces */
2228 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!"); 2199 new_draw_info (NDI_UNIQUE, 0, op, "No one caught anything!");
2229 return 1; 2200 return 1;

Diff Legend

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