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.23 by root, Mon Dec 25 11:25:50 2006 UTC

… …
57 { 57 {
58 weight_move = op->weight + (op->weight * op->level) / 3; 58 weight_move = op->weight + (op->weight * op->level) / 3;
59 /*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */ 59 /*LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); */
60 } 60 }
61 61
62 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 62 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
63 { 63 {
64 int num_sections = 1; 64 int num_sections = 1;
65 65
66 /* don't move DM */ 66 /* don't move DM */
67 if (QUERY_FLAG (tmp, FLAG_WIZ)) 67 if (QUERY_FLAG (tmp, FLAG_WIZ))
… …
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++;
… …
282 * we remove the magic flag - that can be derived from 280 * we remove the magic flag - that can be derived from
283 * spob->attacktype. 281 * spob->attacktype.
284 * This function sets up the appropriate owner and skill 282 * This function sets up the appropriate owner and skill
285 * pointers. 283 * pointers.
286 */ 284 */
287
288int 285int
289fire_bolt (object *op, object *caster, int dir, object *spob, object *skill) 286fire_bolt (object *op, object *caster, int dir, object *spob, object *skill)
290{ 287{
291 object *tmp = NULL; 288 object *tmp = NULL;
292 int mflags; 289 int mflags;
… …
310 307
311 tmp->direction = dir; 308 tmp->direction = dir;
312 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE)) 309 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
313 SET_ANIMATION (tmp, dir); 310 SET_ANIMATION (tmp, dir);
314 311
315 set_owner (tmp, op); 312 tmp->set_owner (op);
316 set_spell_skill (op, caster, spob, tmp); 313 set_spell_skill (op, caster, spob, tmp);
317 314
318 tmp->x = op->x + DIRX (tmp); 315 tmp->x = op->x + DIRX (tmp);
319 tmp->y = op->y + DIRY (tmp); 316 tmp->y = op->y + DIRY (tmp);
320 tmp->map = op->map; 317 tmp->map = op->map;
321 318
319 maptile *newmap;
322 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y); 320 mflags = get_map_flags (tmp->map, &newmap, 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
327 tmp->map = newmap;
328
328 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 329 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
329 { 330 {
330 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 331 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
331 { 332 {
332 free_object (tmp); 333 tmp->destroy ();
333 return 0; 334 return 0;
334 } 335 }
336
335 tmp->x = op->x; 337 tmp->x = op->x;
336 tmp->y = op->y; 338 tmp->y = op->y;
337 tmp->direction = absdir (tmp->direction + 4); 339 tmp->direction = absdir (tmp->direction + 4);
338 tmp->map = op->map; 340 tmp->map = op->map;
339 } 341 }
342
340 if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL) 343 if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL)
341 move_bolt (tmp); 344 move_bolt (tmp);
345
342 return 1; 346 return 1;
343} 347}
344 348
345 349
346 350
… …
356 */ 360 */
357void 361void
358explosion (object *op) 362explosion (object *op)
359{ 363{
360 object *tmp; 364 object *tmp;
361 mapstruct *m = op->map; 365 maptile *m = op->map;
362 int i; 366 int i;
363 367
364 if (--(op->duration) < 0) 368 if (--(op->duration) < 0)
365 { 369 {
366 remove_ob (op); 370 op->destroy ();
367 free_object (op);
368 return; 371 return;
369 } 372 }
373
370 hit_map (op, 0, op->attacktype, 0); 374 hit_map (op, 0, op->attacktype, 0);
371 375
372 if (op->range > 0) 376 if (op->range > 0)
373 { 377 {
374 for (i = 1; i < 9; i++) 378 for (i = 1; i < 9; i++)
… …
380 /* ok_to_put_more already does things like checks for walls, 384 /* ok_to_put_more already does things like checks for walls,
381 * out of map, etc. 385 * out of map, etc.
382 */ 386 */
383 if (ok_to_put_more (op->map, dx, dy, op, op->attacktype)) 387 if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
384 { 388 {
385 tmp = get_object (); 389 tmp = op->clone ();
386 copy_object (op, tmp);
387 tmp->state = 0; 390 tmp->state = 0;
388 tmp->speed_left = -0.21; 391 tmp->speed_left = -0.21;
389 tmp->range--; 392 tmp->range--;
390 tmp->value = 0; 393 tmp->value = 0;
391 tmp->x = dx; 394 tmp->x = dx;
… …
402 * explode. 405 * explode.
403 */ 406 */
404void 407void
405explode_bullet (object *op) 408explode_bullet (object *op)
406{ 409{
407 tag_t op_tag = op->count;
408 object *tmp, *owner; 410 object *tmp, *owner;
409 411
410 if (op->other_arch == NULL) 412 if (op->other_arch == NULL)
411 { 413 {
412 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n"); 414 LOG (llevError, "BUG: explode_bullet(): op without other_arch\n");
413 remove_ob (op); 415 op->destroy ();
414 free_object (op);
415 return; 416 return;
416 } 417 }
417 418
418 if (op->env) 419 if (op->env)
419 { 420 {
… …
421 422
422 env = object_get_env_recursive (op); 423 env = object_get_env_recursive (op);
423 if (env->map == NULL || out_of_map (env->map, env->x, env->y)) 424 if (env->map == NULL || out_of_map (env->map, env->x, env->y))
424 { 425 {
425 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 426 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
426 remove_ob (op); 427 op->destroy ();
427 free_object (op);
428 return; 428 return;
429 } 429 }
430
430 remove_ob (op); 431 op->remove ();
431 op->x = env->x; 432 op->x = env->x;
432 op->y = env->y; 433 op->y = env->y;
433 insert_ob_in_map (op, env->map, op, INS_NO_MERGE | INS_NO_WALK_ON); 434 insert_ob_in_map (op, env->map, op, INS_NO_MERGE | INS_NO_WALK_ON);
434 } 435 }
435 else if (out_of_map (op->map, op->x, op->y)) 436 else if (out_of_map (op->map, op->x, op->y))
436 { 437 {
437 LOG (llevError, "BUG: explode_bullet(): op out of map\n"); 438 LOG (llevError, "BUG: explode_bullet(): op out of map\n");
438 remove_ob (op); 439 op->destroy ();
439 free_object (op);
440 return; 440 return;
441 } 441 }
442 442
443 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent explosions of any kind on safe maps 443 // 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 444 // NOTE: If this breaks something important: remove this. I can't think of anything
445 // bad at the moment that might happen from this. 445 // 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) 446 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
447 { 447 {
448 remove_ob (op); 448 op->destroy ();
449 free_object (op);
450 return; 449 return;
451 } 450 }
452 451
453 if (op->attacktype) 452 if (op->attacktype)
454 { 453 {
455 hit_map (op, 0, op->attacktype, 1); 454 hit_map (op, 0, op->attacktype, 1);
456 if (was_destroyed (op, op_tag)) 455 if (op->destroyed ())
457 return; 456 return;
458 } 457 }
459 458
460 /* other_arch contains what this explodes into */ 459 /* other_arch contains what this explodes into */
461 tmp = arch_to_object (op->other_arch); 460 tmp = arch_to_object (op->other_arch);
462 461
463 copy_owner (tmp, op); 462 tmp->set_owner (op);
464 tmp->skill = op->skill; 463 tmp->skill = op->skill;
465 464
466 owner = get_owner (op); 465 owner = op->owner;
467 466
468 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner)) 467 if ((tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) && owner && !tailor_god_spell (tmp, owner))
469 { 468 {
470 remove_ob (op); 469 op->destroy ();
471 free_object (op);
472 return; 470 return;
473 } 471 }
474 472
475 tmp->x = op->x; 473 tmp->x = op->x;
476 tmp->y = op->y; 474 tmp->y = op->y;
… …
504 /* Prevent recursion */ 502 /* Prevent recursion */
505 op->move_on = 0; 503 op->move_on = 0;
506 504
507 insert_ob_in_map (tmp, op->map, op, 0); 505 insert_ob_in_map (tmp, op->map, op, 0);
508 /* remove the firebullet */ 506 /* remove the firebullet */
509 if (!was_destroyed (op, op_tag)) 507 if (!op->destroyed ())
510 { 508 {
511 remove_ob (op); 509 op->destroy ();
512 free_object (op);
513 } 510 }
514} 511}
515 512
516 513
517 514
… …
520 */ 517 */
521 518
522void 519void
523check_bullet (object *op) 520check_bullet (object *op)
524{ 521{
525 tag_t op_tag = op->count, tmp_tag;
526 object *tmp; 522 object *tmp;
527 int dam, mflags; 523 int dam, mflags;
528 mapstruct *m; 524 maptile *m;
529 sint16 sx, sy; 525 sint16 sx, sy;
530 526
531 mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy); 527 mflags = get_map_flags (op->map, &m, op->x, op->y, &sx, &sy);
532 528
533 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 529 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
… …
542 538
543 /* If nothing alive on this space, no reason to do anything further */ 539 /* If nothing alive on this space, no reason to do anything further */
544 if (!(mflags & P_IS_ALIVE)) 540 if (!(mflags & P_IS_ALIVE))
545 return; 541 return;
546 542
547 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 543 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
548 { 544 {
549 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 545 if (QUERY_FLAG (tmp, FLAG_ALIVE))
550 { 546 {
551 tmp_tag = tmp->count;
552 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 547 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) 548 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
554 { 549 {
555 if (!QUERY_FLAG (op, FLAG_REMOVED)) 550 if (!QUERY_FLAG (op, FLAG_REMOVED))
556 { 551 {
557 remove_ob (op); 552 op->destroy ();
558 free_object (op);
559 return; 553 return;
560 } 554 }
561 } 555 }
562 } 556 }
563 } 557 }
564} 558}
565
566 559
567/* Basically, we move 'op' one square, and if it hits something, 560/* Basically, we move 'op' one square, and if it hits something,
568 * call check_bullet. 561 * call check_bullet.
569 * This function is only applicable to bullets, but not to all 562 * This function is only applicable to bullets, but not to all
570 * fired arches (eg, bolts). 563 * fired arches (eg, bolts).
571 */ 564 */
572
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
… …
641 { 624 {
642 op->direction = absdir (op->direction + 4); 625 op->direction = absdir (op->direction + 4);
643 update_turn_face (op); 626 update_turn_face (op);
644 } 627 }
645 else 628 else
646 {
647 check_bullet (op); 629 check_bullet (op);
648 }
649} 630}
650 631
651 632
652 633
653 634
… …
688 669
689 tmp->direction = dir; 670 tmp->direction = dir;
690 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE)) 671 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
691 SET_ANIMATION (tmp, dir); 672 SET_ANIMATION (tmp, dir);
692 673
693 set_owner (tmp, op); 674 tmp->set_owner (op);
694 set_spell_skill (op, caster, spob, tmp); 675 set_spell_skill (op, caster, spob, tmp);
695 676
696 tmp->x = op->x + freearr_x[dir]; 677 tmp->x = op->x + freearr_x[dir];
697 tmp->y = op->y + freearr_y[dir]; 678 tmp->y = op->y + freearr_y[dir];
698 tmp->map = op->map; 679 tmp->map = op->map;
699 680
681 maptile *newmap;
700 mflags = get_map_flags (tmp->map, &tmp->map, tmp->x, tmp->y, &tmp->x, &tmp->y); 682 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
701 if (mflags & P_OUT_OF_MAP) 683 if (mflags & P_OUT_OF_MAP)
702 { 684 {
703 free_object (tmp); 685 tmp->destroy ();
704 return 0; 686 return 0;
705 } 687 }
688
689 tmp->map = newmap;
690
706 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y))) 691 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (tmp->map, tmp->x, tmp->y)))
707 { 692 {
708 if (!QUERY_FLAG (tmp, FLAG_REFLECTING)) 693 if (!QUERY_FLAG (tmp, FLAG_REFLECTING))
709 { 694 {
710 free_object (tmp); 695 tmp->destroy ();
711 return 0; 696 return 0;
712 } 697 }
698
713 tmp->x = op->x; 699 tmp->x = op->x;
714 tmp->y = op->y; 700 tmp->y = op->y;
715 tmp->direction = absdir (tmp->direction + 4); 701 tmp->direction = absdir (tmp->direction + 4);
716 tmp->map = op->map; 702 tmp->map = op->map;
717 } 703 }
704
718 if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)) != NULL) 705 if ((tmp = insert_ob_in_map (tmp, tmp->map, op, 0)))
719 {
720 check_bullet (tmp); 706 check_bullet (tmp);
721 } 707
722 return 1; 708 return 1;
723} 709}
724 710
725 711
726 712
… …
739 object *new_ob = arch_to_object (op->other_arch); 725 object *new_ob = arch_to_object (op->other_arch);
740 726
741 new_ob->x = op->x; 727 new_ob->x = op->x;
742 new_ob->y = op->y; 728 new_ob->y = op->y;
743 new_ob->level = op->level; 729 new_ob->level = op->level;
744 set_owner (new_ob, op->owner); 730 new_ob->set_owner (op->owner);
745 731
746 /* preserve skill ownership */ 732 /* preserve skill ownership */
747 if (op->skill && op->skill != new_ob->skill) 733 if (op->skill && op->skill != new_ob->skill)
748 { 734 {
749 new_ob->skill = op->skill; 735 new_ob->skill = op->skill;
… …
756 742
757void 743void
758move_cone (object *op) 744move_cone (object *op)
759{ 745{
760 int i; 746 int i;
761 tag_t tag;
762 747
763 /* if no map then hit_map will crash so just ignore object */ 748 /* if no map then hit_map will crash so just ignore object */
764 if (!op->map) 749 if (!op->map)
765 { 750 {
766 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown"); 751 LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
… …
779#if 0 764#if 0
780 /* Disable this - enabling it makes monsters easier, as 765 /* Disable this - enabling it makes monsters easier, as
781 * when their cone dies when they die. 766 * when their cone dies when they die.
782 */ 767 */
783 /* If no owner left, the spell dies out. */ 768 /* If no owner left, the spell dies out. */
784 if (get_owner (op) == NULL) 769 if (op->owner == NULL)
785 { 770 {
786 remove_ob (op); 771 op->destroy ();
787 free_object (op);
788 return; 772 return;
789 } 773 }
790#endif 774#endif
791 775
792 tag = op->count;
793 hit_map (op, 0, op->attacktype, 0); 776 hit_map (op, 0, op->attacktype, 0);
794 777
795 /* Check to see if we should push anything. 778 /* Check to see if we should push anything.
796 * Spell objects with weight push whatever they encounter to some 779 * Spell objects with weight push whatever they encounter to some
797 * degree. 780 * degree.
798 */ 781 */
799 if (op->weight) 782 if (op->weight)
800 check_spell_knockback (op); 783 check_spell_knockback (op);
801 784
802 if (was_destroyed (op, tag)) 785 if (op->destroyed ())
803 return; 786 return;
804 787
805 if ((op->duration--) < 0) 788 if ((op->duration--) < 0)
806 { 789 {
807 remove_ob (op); 790 op->destroy ();
808 free_object (op);
809 return; 791 return;
810 } 792 }
811 /* Object has hit maximum range, so don't have it move 793 /* Object has hit maximum range, so don't have it move
812 * any further. When the duration above expires, 794 * any further. When the duration above expires,
813 * then the object will get removed. 795 * then the object will get removed.
… …
822 { 804 {
823 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)]; 805 sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
824 806
825 if (ok_to_put_more (op->map, x, y, op, op->attacktype)) 807 if (ok_to_put_more (op->map, x, y, op, op->attacktype))
826 { 808 {
827 object *tmp = get_object (); 809 object *tmp = op->clone ();
828 810
829 copy_object (op, tmp);
830 tmp->x = x; 811 tmp->x = x;
831 tmp->y = y; 812 tmp->y = y;
832 813
833 tmp->duration = op->duration + 1; 814 tmp->duration = op->duration + 1;
834 815
… …
852int 833int
853cast_cone (object *op, object *caster, int dir, object *spell) 834cast_cone (object *op, object *caster, int dir, object *spell)
854{ 835{
855 object *tmp; 836 object *tmp;
856 int i, success = 0, range_min = -1, range_max = 1; 837 int i, success = 0, range_min = -1, range_max = 1;
857 mapstruct *m; 838 maptile *m;
858 sint16 sx, sy; 839 sint16 sx, sy;
859 MoveType movetype; 840 MoveType movetype;
860 841
861 if (!spell->other_arch) 842 if (!spell->other_arch)
862 return 0; 843 return 0;
… …
918 if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype) 899 if ((movetype & GET_MAP_MOVE_BLOCK (m, sx, sy)) == movetype)
919 continue; 900 continue;
920 901
921 success = 1; 902 success = 1;
922 tmp = arch_to_object (spell->other_arch); 903 tmp = arch_to_object (spell->other_arch);
923 set_owner (tmp, op); 904 tmp->set_owner (op);
924 set_spell_skill (op, caster, spell, tmp); 905 set_spell_skill (op, caster, spell, tmp);
925 tmp->level = caster_level (caster, spell); 906 tmp->level = caster_level (caster, spell);
926 tmp->x = sx; 907 tmp->x = sx;
927 tmp->y = sy; 908 tmp->y = sy;
928 tmp->attacktype = spell->attacktype; 909 tmp->attacktype = spell->attacktype;
… …
1017 return; 998 return;
1018 999
1019 if (env->type == PLAYER) 1000 if (env->type == PLAYER)
1020 esrv_del_item (env->contr, op->count); 1001 esrv_del_item (env->contr, op->count);
1021 1002
1022 remove_ob (op); 1003 op->remove ();
1023 op->x = env->x; 1004 op->x = env->x;
1024 op->y = env->y; 1005 op->y = env->y;
1025 if ((op = insert_ob_in_map (op, env->map, op, 0)) == NULL) 1006 if ((op = insert_ob_in_map (op, env->map, op, 0)) == NULL)
1026 return; 1007 return;
1027 } 1008 }
… …
1029 // elmex Tue Aug 15 17:46:51 CEST 2006: Prevent bomb from exploding 1010 // 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 1011 // on a safe map. I don't like this special casing, but it seems to be neccessary
1031 // as bombs can be carried. 1012 // as bombs can be carried.
1032 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE) 1013 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
1033 { 1014 {
1034 remove_ob (op); 1015 op->destroy ();
1035 free_object (op);
1036 return; 1016 return;
1037 } 1017 }
1038 1018
1039 /* This copies a lot of the code from the fire bullet, 1019 /* This copies a lot of the code from the fire bullet,
1040 * but using the cast_bullet isn't really feasible, 1020 * but using the cast_bullet isn't really feasible,
… …
1051 tmp->direction = i; 1031 tmp->direction = i;
1052 tmp->range = op->range; 1032 tmp->range = op->range;
1053 tmp->stats.dam = op->stats.dam; 1033 tmp->stats.dam = op->stats.dam;
1054 tmp->duration = op->duration; 1034 tmp->duration = op->duration;
1055 tmp->attacktype = op->attacktype; 1035 tmp->attacktype = op->attacktype;
1056 copy_owner (tmp, op); 1036 tmp->set_owner (op);
1057 if (op->skill && op->skill != tmp->skill) 1037 if (op->skill && op->skill != tmp->skill)
1058 { 1038 {
1059 tmp->skill = op->skill; 1039 tmp->skill = op->skill;
1060 } 1040 }
1061 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE)) 1041 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
… …
1075{ 1055{
1076 1056
1077 object *tmp; 1057 object *tmp;
1078 int mflags; 1058 int mflags;
1079 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir]; 1059 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1080 mapstruct *m; 1060 maptile *m;
1081 1061
1082 mflags = get_map_flags (op->map, &m, dx, dy, &dx, &dy); 1062 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)) 1063 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1084 { 1064 {
1085 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1065 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
… …
1091 tmp->range = spell->range + SP_level_range_adjust (caster, spell); 1071 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1092 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1072 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1093 tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell); 1073 tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
1094 tmp->attacktype = spell->attacktype; 1074 tmp->attacktype = spell->attacktype;
1095 1075
1096 set_owner (tmp, op); 1076 tmp->set_owner (op);
1097 set_spell_skill (op, caster, spell, tmp); 1077 set_spell_skill (op, caster, spell, tmp);
1098 tmp->x = dx; 1078 tmp->x = dx;
1099 tmp->y = dy; 1079 tmp->y = dy;
1100 insert_ob_in_map (tmp, m, op, 0); 1080 insert_ob_in_map (tmp, m, op, 0);
1101 return 1; 1081 return 1;
… …
1121get_pointed_target (object *op, int dir, int range, int type) 1101get_pointed_target (object *op, int dir, int range, int type)
1122{ 1102{
1123 object *target; 1103 object *target;
1124 sint16 x, y; 1104 sint16 x, y;
1125 int dist, mflags; 1105 int dist, mflags;
1126 mapstruct *mp; 1106 maptile *mp;
1127 1107
1128 if (dir == 0) 1108 if (dir == 0)
1129 return NULL; 1109 return NULL;
1130 1110
1131 for (dist = 1; dist < range; dist++) 1111 for (dist = 1; dist < range; dist++)
… …
1144 if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW) 1124 if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1145 return NULL; 1125 return NULL;
1146 1126
1147 if (mflags & P_IS_ALIVE) 1127 if (mflags & P_IS_ALIVE)
1148 { 1128 {
1149 for (target = get_map_ob (mp, x, y); target; target = target->above) 1129 for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1150 { 1130 {
1151 if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER)) 1131 if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER))
1152 { 1132 {
1153 return target; 1133 return target;
1154 } 1134 }
… …
1221 if (effect->attacktype & AT_DEATH) 1201 if (effect->attacktype & AT_DEATH)
1222 { 1202 {
1223 effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1203 effect->level = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1224 1204
1225 /* casting death spells at undead isn't a good thing */ 1205 /* casting death spells at undead isn't a good thing */
1226 if QUERY_FLAG
1227 (target, FLAG_UNDEAD) 1206 if (QUERY_FLAG (target, FLAG_UNDEAD))
1228 { 1207 {
1229 if (random_roll (0, 2, op, PREFER_LOW)) 1208 if (random_roll (0, 2, op, PREFER_LOW))
1230 { 1209 {
1231 new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!"); 1210 new_draw_info (NDI_UNIQUE, 0, op, "Idiot! Your spell boomerangs!");
1232 effect->x = op->x; 1211 effect->x = op->x;
… …
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
1245 { 1224 {
1246 /* how much woe to inflict :) */ 1225 /* how much woe to inflict :) */
1247 effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1226 effect->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1248 } 1227 }
1249 1228
1250 set_owner (effect, op); 1229 effect->set_owner (op);
1251 set_spell_skill (op, caster, spell, effect); 1230 set_spell_skill (op, caster, spell, effect);
1252 1231
1253 /* ok, tell it where to be, and insert! */ 1232 /* ok, tell it where to be, and insert! */
1254 effect->x = target->x; 1233 effect->x = target->x;
1255 effect->y = target->y; 1234 effect->y = target->y;
… …
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 = op->owner;
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, op->owner);
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);
… …
1422 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 1398 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1423 if (mflags & P_OUT_OF_MAP) 1399 if (mflags & P_OUT_OF_MAP)
1424 continue; 1400 continue;
1425 if (mflags & P_IS_ALIVE) 1401 if (mflags & P_IS_ALIVE)
1426 { 1402 {
1427 for (tmp = get_map_ob (m, sx, sy); tmp; tmp = tmp->above) 1403 for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
1428 { 1404 {
1429 if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER) 1405 if (QUERY_FLAG (tmp, FLAG_ALIVE) || tmp->type == PLAYER)
1430 break; 1406 break;
1431 } 1407 }
1432 if (tmp) 1408 if (tmp)
… …
1555 force->stats.ac = spell_ob->stats.ac; 1531 force->stats.ac = spell_ob->stats.ac;
1556 force->stats.wc = spell_ob->stats.wc; 1532 force->stats.wc = spell_ob->stats.wc;
1557 1533
1558 change_abil (tmp, force); /* Mostly to display any messages */ 1534 change_abil (tmp, force); /* Mostly to display any messages */
1559 insert_ob_in_ob (force, tmp); 1535 insert_ob_in_ob (force, tmp);
1560 fix_player (tmp); 1536 tmp->update_stats ();
1561 return 1; 1537 return 1;
1562 1538
1563} 1539}
1564 1540
1565 1541
… …
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 */
… …
1616 1592
1617 /* If there is nothing living on this space, no need to go further */ 1593 /* If there is nothing living on this space, no need to go further */
1618 if (!(mflags & P_IS_ALIVE)) 1594 if (!(mflags & P_IS_ALIVE))
1619 continue; 1595 continue;
1620 1596
1621 for (tmp = get_map_ob (m, nx, ny); tmp; tmp = tmp->above) 1597 for (tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)
1622 if (QUERY_FLAG (tmp, FLAG_MONSTER)) 1598 if (QUERY_FLAG (tmp, FLAG_MONSTER))
1623 break; 1599 break;
1624 1600
1625 /* There can be living objects that are not monsters */ 1601 /* There can be living objects that are not monsters */
1626 if (!tmp || tmp->type == PLAYER) 1602 if (!tmp || tmp->type == PLAYER)
… …
1714 SET_FLAG (head, FLAG_FRIENDLY); 1690 SET_FLAG (head, FLAG_FRIENDLY);
1715 /* Prevent uncontolled outbreaks of self replicating monsters. 1691 /* Prevent uncontolled outbreaks of self replicating monsters.
1716 Typical use case is charm, go somwhere, use aggravation to make hostile. 1692 Typical use case is charm, go somwhere, use aggravation to make hostile.
1717 This could lead to fun stuff like mice outbreak in bigworld and server crawl. */ 1693 This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1718 CLEAR_FLAG (head, FLAG_GENERATOR); 1694 CLEAR_FLAG (head, FLAG_GENERATOR);
1719 set_owner (head, op); 1695 head->set_owner (op);
1720 set_spell_skill (op, caster, spell, head); 1696 set_spell_skill (op, caster, spell, head);
1721 add_friendly_object (head); 1697 add_friendly_object (head);
1722 head->attack_movement = PETMOVE; 1698 head->attack_movement = PETMOVE;
1723 done_one = 1; 1699 done_one = 1;
1724 change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL); 1700 change_exp (op, head->stats.exp / 2, head->skill, SK_EXP_ADD_SKILL);
… …
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 = op->owner;
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
1761 * victim. The block immediately below more or less chooses a random 1737 * victim. The block immediately below more or less chooses a random
1762 * offset to move the ball, eg, keep it mostly on course, with some 1738 * offset to move the ball, eg, keep it mostly on course, with some
… …
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
… …
1841 } 1817 }
1842 1818
1843 /* restore to the center location and damage */ 1819 /* restore to the center location and damage */
1844 op->stats.dam = dam_save; 1820 op->stats.dam = dam_save;
1845 1821
1846 i = spell_find_dir (op->map, op->x, op->y, get_owner (op)); 1822 i = spell_find_dir (op->map, op->x, op->y, op->owner);
1847 1823
1848 if (i >= 0) 1824 if (i >= 0)
1849 { /* we have a preferred direction! */ 1825 { /* we have a preferred direction! */
1850 /* pick another direction if the preferred dir is blocked. */ 1826 /* pick another direction if the preferred dir is blocked. */
1851 if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP || 1827 if (get_map_flags (op->map, &m, nx + freearr_x[i], ny + freearr_y[i], &hx, &hy) & P_OUT_OF_MAP ||
… …
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 = op->owner;
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 {
… …
1992 return 0; 1968 return 0;
1993 1969
1994 tmp = get_archetype (SWARM_SPELL); 1970 tmp = get_archetype (SWARM_SPELL);
1995 tmp->x = op->x; 1971 tmp->x = op->x;
1996 tmp->y = op->y; 1972 tmp->y = op->y;
1997 set_owner (tmp, op); /* needed so that if swarm elements kill, caster gets xp. */ 1973 tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
1998 set_spell_skill (op, caster, spell, tmp); 1974 set_spell_skill (op, caster, spell, tmp);
1999 1975
2000 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */ 1976 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */
2001 tmp->spell = arch_to_object (spell->other_arch); 1977 tmp->spell = arch_to_object (spell->other_arch);
2002 1978
… …
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 {
… …
2049 return 0; 2025 return 0;
2050 } 2026 }
2051 2027
2052 if (mflags & P_IS_ALIVE && spell->attacktype) 2028 if (mflags & P_IS_ALIVE && spell->attacktype)
2053 { 2029 {
2054 for (target = get_map_ob (m, x, y); target; target = target->above) 2030 for (target = GET_MAP_OB (m, x, y); target; target = target->above)
2055 if (QUERY_FLAG (target, FLAG_MONSTER)) 2031 if (QUERY_FLAG (target, FLAG_MONSTER))
2056 { 2032 {
2057 /* oky doky. got a target monster. Lets make a blinding attack */ 2033 /* oky doky. got a target monster. Lets make a blinding attack */
2058 if (target->head) 2034 if (target->head)
2059 target = target->head; 2035 target = target->head;
… …
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
… …
2141 2117
2142 /* Only bother looking on this space if there is something living here */ 2118 /* Only bother looking on this space if there is something living here */
2143 if (mflags & P_IS_ALIVE) 2119 if (mflags & P_IS_ALIVE)
2144 { 2120 {
2145 /* search this square for a victim */ 2121 /* search this square for a victim */
2146 for (walk = get_map_ob (m, x, y); walk; walk = walk->above) 2122 for (walk = GET_MAP_OB (m, x, y); walk; walk = walk->above)
2147 if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER)) 2123 if (QUERY_FLAG (walk, FLAG_MONSTER) || (walk->type == PLAYER))
2148 { /* found a victim */ 2124 { /* found a victim */
2149 object *disease = arch_to_object (spell->other_arch); 2125 object *disease = arch_to_object (spell->other_arch);
2150 2126
2151 set_owner (disease, op); 2127 disease->set_owner (op);
2152 set_spell_skill (op, caster, spell, disease); 2128 set_spell_skill (op, caster, spell, disease);
2153 disease->stats.exp = 0; 2129 disease->stats.exp = 0;
2154 disease->level = caster_level (caster, spell); 2130 disease->level = caster_level (caster, spell);
2155 2131
2156 /* do level adjustments */ 2132 /* do level adjustments */
… …
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