ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/spell_effect.C
(Generate patch)

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.21 by root, Tue Dec 19 05:41:22 2006 UTC vs.
Revision 1.33 by root, Sun Jan 7 02:39:14 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
3 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
6 7
7 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
37void 38void
38cast_magic_storm (object *op, object *tmp, int lvl) 39cast_magic_storm (object *op, object *tmp, int lvl)
39{ 40{
40 if (!tmp) 41 if (!tmp)
41 return; /* error */ 42 return; /* error */
43
42 tmp->level = op->level; 44 tmp->level = op->level;
43 tmp->x = op->x;
44 tmp->y = op->y;
45 tmp->range += lvl / 5; /* increase the area of destruction */ 45 tmp->range += lvl / 5; /* increase the area of destruction */
46 tmp->duration += lvl / 5; 46 tmp->duration += lvl / 5;
47 47
48 /* Put a cap on duration for this - if the player fails in their 48 /* Put a cap on duration for this - if the player fails in their
49 * apartment, don't want it to go on so long that it kills them 49 * apartment, don't want it to go on so long that it kills them
50 * multiple times. Also, damge already increases with level, 50 * multiple times. Also, damge already increases with level,
51 * so don't really need to increase the duration as much either. 51 * so don't really need to increase the duration as much either.
52 */ 52 */
53 if (tmp->duration >= 40) 53 if (tmp->duration >= 40)
54 tmp->duration = 40; 54 tmp->duration = 40;
55
55 tmp->stats.dam = lvl; /* nasty recoils! */ 56 tmp->stats.dam = lvl; /* nasty recoils! */
56 tmp->stats.maxhp = tmp->count; /* tract single parent */ 57 tmp->stats.maxhp = tmp->count; /* tract single parent */
57 insert_ob_in_map (tmp, op->map, op, 0);
58 58
59 tmp->insert_at (op, op);
59} 60}
60
61 61
62int 62int
63recharge (object *op, object *caster, object *spell_ob) 63recharge (object *op, object *caster, object *spell_ob)
64{ 64{
65 object *wand, *tmp; 65 object *wand, *tmp;
… …
77 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 77 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);
78 esrv_del_item (op->contr, wand->count); 78 esrv_del_item (op->contr, wand->count);
79 wand->destroy (); 79 wand->destroy ();
80 tmp = get_archetype ("fireball"); 80 tmp = get_archetype ("fireball");
81 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 81 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
82
82 if (!tmp->stats.dam) 83 if (!tmp->stats.dam)
83 tmp->stats.dam = 1; 84 tmp->stats.dam = 1;
85
84 tmp->stats.hp = tmp->stats.dam / 2; 86 tmp->stats.hp = tmp->stats.dam / 2;
87
85 if (tmp->stats.hp < 2) 88 if (tmp->stats.hp < 2)
86 tmp->stats.hp = 2; 89 tmp->stats.hp = 2;
87 tmp->x = op->x; 90
88 tmp->y = op->y; 91 tmp->insert_at (op);
89 insert_ob_in_map (tmp, op->map, NULL, 0);
90 return 1; 92 return 1;
91 } 93 }
92 94
93 ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)); 95 ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));
96
94 if (wand->inv && wand->inv->level) 97 if (wand->inv && wand->inv->level)
95 ncharges /= wand->inv->level; 98 ncharges /= wand->inv->level;
96 else 99 else
97 { 100 {
98 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand)); 101 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));
99 return 0; 102 return 0;
100 } 103 }
104
101 if (!ncharges) 105 if (!ncharges)
102 ncharges = 1; 106 ncharges = 1;
103 107
104 wand->stats.food += ncharges; 108 wand->stats.food += ncharges;
105 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 109 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
110
106 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 111 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))
107 { 112 {
108 SET_FLAG (wand, FLAG_ANIMATE); 113 SET_FLAG (wand, FLAG_ANIMATE);
109 wand->speed = wand->arch->clone.speed; 114 wand->set_speed (wand->arch->clone.speed);
110 update_ob_speed (wand);
111 } 115 }
116
112 return 1; 117 return 1;
113} 118}
114 119
115/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows 120/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows
116 * based on whether a crossbow or bow is equiped. If neither, it defaults to 121 * based on whether a crossbow or bow is equiped. If neither, it defaults to
… …
302 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 307 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
303 return 0; 308 return 0;
304 } 309 }
305 if (mflags & P_IS_ALIVE) 310 if (mflags & P_IS_ALIVE)
306 { 311 {
307 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above) 312 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
308 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 313 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
309 { 314 {
310 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 315 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
311 if (tmp->head != NULL) 316 if (tmp->head != NULL)
312 tmp = tmp->head; 317 tmp = tmp->head;
… …
407 update_object (op, UP_OBJ_FACE); 412 update_object (op, UP_OBJ_FACE);
408 413
409 /* Only search the active objects - only these should actually do 414 /* Only search the active objects - only these should actually do
410 * harm to the player. 415 * harm to the player.
411 */ 416 */
412 for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next) 417 for_all_actives (tmp)
413 if (tmp->enemy == op) 418 if (tmp->enemy == op)
414 tmp->enemy = NULL; 419 tmp->enemy = 0;
420
415 return 1; 421 return 1;
416} 422}
417 423
418/* earth to dust spell. Basically destroys earthwalls in the area. 424/* earth to dust spell. Basically destroys earthwalls in the area.
419 */ 425 */
… …
440 446
441 if (mflags & P_OUT_OF_MAP) 447 if (mflags & P_OUT_OF_MAP)
442 continue; 448 continue;
443 449
444 // earth to dust tears down everything that can be teared down 450 // earth to dust tears down everything that can be teared down
445 for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next) 451 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
446 { 452 {
447 next = tmp->above; 453 next = tmp->above;
448 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 454 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
449 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 455 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
450 } 456 }
451 } 457 }
458
452 return 1; 459 return 1;
453} 460}
454
455 461
456void 462void
457execute_word_of_recall (object *op) 463execute_word_of_recall (object *op)
458{ 464{
459 object *wor = op; 465 if (object *pl = op->in_player ())
460 466 {
461 while (op != NULL && op->type != PLAYER) 467 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
462 op = op->env;
463
464 if (op != NULL && op->map)
465 if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST)))
466 new_draw_info (NDI_UNIQUE, 0, op, "You feel something fizzle inside you."); 468 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
467 else 469 else
470 {
471 // remove first so we do not call update_stats
472 op->remove ();
468 enter_exit (op, wor); 473 pl->enter_exit (op);
474 }
475 }
469 476
470 wor->destroy (); 477 op->destroy ();
471} 478}
472 479
473/* Word of recall causes the player to return 'home'. 480/* Word of recall causes the player to return 'home'.
474 * we put a force into the player object, so that there is a 481 * we put a force into the player object, so that there is a
475 * time delay effect. 482 * time delay effect.
… …
494 { 501 {
495 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 502 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
496 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 503 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
497 return 0; 504 return 0;
498 } 505 }
506
499 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 507 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
500 if (time < 1) 508 if (time < 1)
501 time = 1; 509 time = 1;
502 510
503 /* value of speed really doesn't make much difference, as long as it is 511 /* value of speed really doesn't make much difference, as long as it is
504 * positive. Lower value may be useful so that the problem doesn't 512 * positive. Lower value may be useful so that the problem doesn't
505 * do anything really odd if it say a -1000 or something. 513 * do anything really odd if it say a -1000 or something.
506 */ 514 */
507 dummy->speed = 0.002; 515 dummy->set_speed (0.002);
508 update_ob_speed (dummy);
509 dummy->speed_left = -dummy->speed * time; 516 dummy->speed_left = -dummy->speed * time;
510 dummy->type = SPELL_EFFECT; 517 dummy->type = SPELL_EFFECT;
511 dummy->subtype = SP_WORD_OF_RECALL; 518 dummy->subtype = SP_WORD_OF_RECALL;
512 519
513 /* If we could take advantage of enter_player_savebed() here, it would be 520 /* If we could take advantage of enter_player_savebed() here, it would be
514 * nice, but until the map load fails, we can't. 521 * nice, but until the map load fails, we can't.
515 */ 522 */
516 EXIT_PATH (dummy) = op->contr->savebed_map; 523 EXIT_PATH (dummy) = op->contr->savebed_map;
517 EXIT_X (dummy) = op->contr->bed_x; 524 EXIT_X (dummy) = op->contr->bed_x;
518 EXIT_Y (dummy) = op->contr->bed_y; 525 EXIT_Y (dummy) = op->contr->bed_y;
519 526
520 (void) insert_ob_in_ob (dummy, op); 527 op->insert (dummy);
528
521 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 529 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
530
522 return 1; 531 return 1;
523} 532}
524 533
525/* cast_wonder 534/* cast_wonder
526 * wonder is really just a spell that will likely cast another 535 * wonder is really just a spell that will likely cast another
… …
555 } 564 }
556 return cast_spell (op, caster, dir, newspell, NULL); 565 return cast_spell (op, caster, dir, newspell, NULL);
557 } 566 }
558 return 1; 567 return 1;
559} 568}
560
561 569
562int 570int
563perceive_self (object *op) 571perceive_self (object *op)
564{ 572{
565 char *cp = describe_item (op, op), buf[MAX_BUF]; 573 char *cp = describe_item (op, op), buf[MAX_BUF];
… …
634 * Code by Tchize (david.delbecq@usa.net) 642 * Code by Tchize (david.delbecq@usa.net)
635 */ 643 */
636int 644int
637cast_create_town_portal (object *op, object *caster, object *spell, int dir) 645cast_create_town_portal (object *op, object *caster, object *spell, int dir)
638{ 646{
639 object *dummy, *force, *old_force, *tmp; 647 object *dummy, *force, *old_force;
640 archetype *perm_portal; 648 archetype *perm_portal;
641 char portal_name[1024], portal_message[1024]; 649 char portal_name[1024], portal_message[1024];
642 sint16 exitx, exity;
643 maptile *exitmap; 650 maptile *exitmap;
644 int op_level; 651 int op_level;
645
646 652
647 /* Check to see if the map the player is currently on is a per player unique 653 /* Check to see if the map the player is currently on is a per player unique
648 * map. This can be determined in that per player unique maps have the 654 * map. This can be determined in that per player unique maps have the
649 * full pathname listed. 655 * full pathname listed.
650 */ 656 */
… …
718 * If it has the good name, we destruct it. 724 * If it has the good name, we destruct it.
719 * -We destruct the force indicating that portal. 725 * -We destruct the force indicating that portal.
720 */ 726 */
721 while ((old_force = check_inv_recursive (op, dummy))) 727 while ((old_force = check_inv_recursive (op, dummy)))
722 { 728 {
723 exitx = EXIT_X (old_force); 729 exitmap = maptile::find_sync (old_force->race, op->map);
724 exity = EXIT_Y (old_force);
725 LOG (llevDebug, "Trying to kill a portal in %s (%d,%d)\n", &old_force->race, exitx, exity);
726
727 if (!strncmp (old_force->race, settings.localdir, strlen (settings.localdir)))
728 exitmap = ready_map_name (old_force->race, MAP_PLAYER_UNIQUE);
729 else
730 exitmap = ready_map_name (old_force->race, 0);
731 730
732 if (exitmap) 731 if (exitmap)
733 { 732 {
733 exitmap->load_sync ();
734
735 int exitx = EXIT_X (old_force);
736 int exity = EXIT_Y (old_force);
737
734 tmp = present_arch (perm_portal, exitmap, exitx, exity); 738 for (object *tmp = present_arch (perm_portal, exitmap, exitx, exity); tmp; tmp = tmp->above)
735 while (tmp)
736 { 739 {
737 if (tmp->name == old_force->name) 740 if (tmp->name == old_force->name)
738 { 741 {
739 tmp->destroy (); 742 tmp->destroy ();
740 break; 743 break;
741 } 744 }
742
743 tmp = tmp->above;
744 } 745 }
745 } 746 }
746 747
747 old_force->destroy (); 748 old_force->destroy ();
748 LOG (llevDebug, "\n");
749 } 749 }
750 750
751 dummy->destroy (); 751 dummy->destroy ();
752 752
753 /* Creating the portals. 753 /* Creating the portals.
… …
759 * 'force' is the destination of the town portal, which we got 759 * 'force' is the destination of the town portal, which we got
760 * from the players inventory above. 760 * from the players inventory above.
761 */ 761 */
762 762
763 /* Ensure exit map is loaded */ 763 /* Ensure exit map is loaded */
764 if (!strncmp (force->name, settings.localdir, strlen (settings.localdir))) 764 exitmap = maptile::find_sync (force->name);
765 exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
766 else
767 exitmap = ready_map_name (force->name, 0);
768 765
769 /* If we were unable to load (ex. random map deleted), warn player */ 766 /* If we were unable to load (ex. random map deleted), warn player */
770 if (exitmap == NULL) 767 if (!exitmap)
771 { 768 {
772 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?"); 769 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
773 force->destroy (); 770 force->destroy ();
774 return 1; 771 return 1;
775 } 772 }
773
774 exitmap->load_sync ();
776 775
777 op_level = caster_level (caster, spell); 776 op_level = caster_level (caster, spell);
778 if (op_level < 15) 777 if (op_level < 15)
779 snprintf (portal_message, 1024, 778 snprintf (portal_message, 1024,
780 "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n", 779 "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
… …
790 789
791 /* Create a portal in front of player 790 /* Create a portal in front of player
792 * dummy contain the portal and 791 * dummy contain the portal and
793 * force contain the track to kill it later 792 * force contain the track to kill it later
794 */ 793 */
795
796 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name); 794 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
797 dummy = get_archetype (spell->slaying); /*The portal */ 795 dummy = get_archetype (spell->slaying); /*The portal */
798 if (dummy == NULL) 796 if (dummy == NULL)
799 { 797 {
800 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 798 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
… …
812 810
813 /* Now we need to to create a town portal marker inside the player 811 /* Now we need to to create a town portal marker inside the player
814 * object, so on future castings, we can know that he has an active 812 * object, so on future castings, we can know that he has an active
815 * town portal. 813 * town portal.
816 */ 814 */
817 tmp = get_archetype (spell->race); 815 object *tmp = get_archetype (spell->race);
818 if (tmp == NULL) 816
817 if (!tmp)
819 { 818 {
820 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 819 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
821 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name); 820 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
822 return 0; 821 return 0;
823 } 822 }
824 823
825 tmp->race = op->map->path; 824 tmp->race = op->map->path;
826 tmp->name = portal_name; 825 tmp->name = portal_name;
827 EXIT_X (tmp) = dummy->x; 826 EXIT_X (tmp) = dummy->x;
828 EXIT_Y (tmp) = dummy->y; 827 EXIT_Y (tmp) = dummy->y;
829 insert_ob_in_ob (tmp, op); 828 op->insert (tmp);
830 829
831 /* Create a portal in the destination map 830 /* Create a portal in the destination map
832 * dummy contain the portal and 831 * dummy contain the portal and
833 * force the track to kill it later 832 * force the track to kill it later
834 * the 'force' variable still contains the 'reminder' of 833 * the 'force' variable still contains the 'reminder' of
835 * where this portal goes to. 834 * where this portal goes to.
836 */ 835 */
837 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, op->map->path); 836 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &op->map->path);
838 dummy = get_archetype (spell->slaying); /*The portal */ 837 dummy = get_archetype (spell->slaying); /*The portal */
839 if (dummy == NULL) 838 if (dummy == NULL)
840 { 839 {
841 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 840 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
842 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name); 841 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
… …
846 EXIT_PATH (dummy) = op->map->path; 845 EXIT_PATH (dummy) = op->map->path;
847 EXIT_X (dummy) = op->x; 846 EXIT_X (dummy) = op->x;
848 EXIT_Y (dummy) = op->y; 847 EXIT_Y (dummy) = op->y;
849 dummy->name = dummy->name_pl = portal_name; 848 dummy->name = dummy->name_pl = portal_name;
850 dummy->msg = portal_message; 849 dummy->msg = portal_message;
851 dummy->x = EXIT_X (force);
852 dummy->y = EXIT_Y (force);
853 dummy->race = op->name; /*Save the owner of the portal */ 850 dummy->race = op->name; /*Save the owner of the portal */
854 insert_ob_in_map (dummy, exitmap, op, 0); 851 exitmap->insert (dummy, EXIT_X (force), EXIT_Y (force), op);
855 852
856 /* Now we create another town portal marker that 853 /* Now we create another town portal marker that
857 * points back to the one we just made 854 * points back to the one we just made
858 */ 855 */
859 tmp = get_archetype (spell->race); 856 tmp = get_archetype (spell->race);
… …
876 force->destroy (); 873 force->destroy ();
877 874
878 return 1; 875 return 1;
879} 876}
880 877
881
882/* This creates magic walls. Really, it can create most any object, 878/* This creates magic walls. Really, it can create most any object,
883 * within some reason. 879 * within some reason.
884 */ 880 */
885
886int 881int
887magic_wall (object *op, object *caster, int dir, object *spell_ob) 882magic_wall (object *op, object *caster, int dir, object *spell_ob)
888{ 883{
889 object *tmp, *tmp2; 884 object *tmp;
890 int i, posblocked, negblocked, maxrange; 885 int i, posblocked, negblocked, maxrange;
891 sint16 x, y; 886 sint16 x, y;
892 maptile *m; 887 maptile *m;
893 const char *name; 888 const char *name;
894 archetype *at; 889 archetype *at;
… …
902 else 897 else
903 { 898 {
904 x = op->x + freearr_x[dir]; 899 x = op->x + freearr_x[dir];
905 y = op->y + freearr_y[dir]; 900 y = op->y + freearr_y[dir];
906 } 901 }
902
907 m = op->map; 903 m = op->map;
908 904
909 if ((spell_ob->move_block || x != op->x || y != op->y) && 905 if ((spell_ob->move_block || x != op->x || y != op->y) &&
910 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) || 906 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
911 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block))) 907 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
912 { 908 {
913 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 909 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
914 return 0; 910 return 0;
915 } 911 }
912
916 if (spell_ob->other_arch) 913 if (spell_ob->other_arch)
917 {
918 tmp = arch_to_object (spell_ob->other_arch); 914 tmp = arch_to_object (spell_ob->other_arch);
919 }
920 else if (spell_ob->race) 915 else if (spell_ob->race)
921 { 916 {
922 char buf1[MAX_BUF]; 917 char buf1[MAX_BUF];
923 918
924 sprintf (buf1, spell_ob->race, dir); 919 sprintf (buf1, spell_ob->race, dir);
… …
927 { 922 {
928 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 923 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
929 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 924 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
930 return 0; 925 return 0;
931 } 926 }
927
932 tmp = arch_to_object (at); 928 tmp = arch_to_object (at);
933 } 929 }
934 else 930 else
935 { 931 {
936 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 932 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
… …
946 } 942 }
947 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 943 else if (QUERY_FLAG (tmp, FLAG_ALIVE))
948 { 944 {
949 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 945 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
950 tmp->stats.maxhp = tmp->stats.hp; 946 tmp->stats.maxhp = tmp->stats.hp;
951 tmp->set_owner (op);
952 set_spell_skill (op, caster, spell_ob, tmp);
953 } 947 }
948
954 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 949 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP))
955 { 950 {
956 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 951 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
957 SET_FLAG (tmp, FLAG_IS_USED_UP); 952 SET_FLAG (tmp, FLAG_IS_USED_UP);
958 } 953 }
954
959 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 955 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))
960 { 956 {
961 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 957 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
962 tmp->stats.maxhp = tmp->stats.hp; 958 tmp->stats.maxhp = tmp->stats.hp;
963 SET_FLAG (tmp, FLAG_TEAR_DOWN); 959 SET_FLAG (tmp, FLAG_TEAR_DOWN);
964 SET_FLAG (tmp, FLAG_ALIVE); 960 SET_FLAG (tmp, FLAG_ALIVE);
965 } 961 }
966 962
967 /* This can't really hurt - if the object doesn't kill anything, 963 /* This can't really hurt - if the object doesn't kill anything,
968 * these fields just won't be used. 964 * these fields just won't be used. Do not set the owner for
965 * earthwalls, though, so they survive restarts.
969 */ 966 */
967 if (tmp->type != EARTHWALL) //TODO
970 tmp->set_owner (op); 968 tmp->set_owner (op);
969
971 set_spell_skill (op, caster, spell_ob, tmp); 970 set_spell_skill (op, caster, spell_ob, tmp);
972 tmp->x = x;
973 tmp->y = y;
974 tmp->level = caster_level (caster, spell_ob) / 2; 971 tmp->level = caster_level (caster, spell_ob) / 2;
975 972
976 name = tmp->name; 973 name = tmp->name;
977 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL) 974 if (!(tmp = m->insert (tmp, x, y, op)))
978 { 975 {
979 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 976 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
980 return 0; 977 return 0;
981 } 978 }
979
982 /* If this is a spellcasting wall, need to insert the spell object */ 980 /* If this is a spellcasting wall, need to insert the spell object */
983 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 981 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)
984 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 982 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
985 983
986 /* This code causes the wall to extend some distance in 984 /* This code causes the wall to extend some distance in
… …
1004 m = tmp->map; 1002 m = tmp->map;
1005 1003
1006 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 1004 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1007 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked) 1005 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
1008 { 1006 {
1009 tmp2 = tmp->clone (); 1007 object *tmp2 = tmp->clone ();
1010 tmp2->x = x; 1008 m->insert (tmp2, x, y, op);
1011 tmp2->y = y; 1009
1012 insert_ob_in_map (tmp2, m, op, 0);
1013 /* If this is a spellcasting wall, need to insert the spell object */ 1010 /* If this is a spellcasting wall, need to insert the spell object */
1014 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 1011 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
1015 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 1012 tmp2->insert (arch_to_object (tmp2->other_arch));
1016 1013
1017 } 1014 }
1018 else 1015 else
1019 posblocked = 1; 1016 posblocked = 1;
1020 1017
… …
1023 m = tmp->map; 1020 m = tmp->map;
1024 1021
1025 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 1022 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1026 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked) 1023 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1027 { 1024 {
1028 tmp2 = tmp->clone (); 1025 object *tmp2 = tmp->clone ();
1029 tmp2->x = x; 1026 m->insert (tmp2, x, y, op);
1030 tmp2->y = y; 1027
1031 insert_ob_in_map (tmp2, m, op, 0);
1032 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 1028 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
1033 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 1029 tmp2->insert (arch_to_object (tmp2->other_arch));
1034 } 1030 }
1035 else 1031 else
1036 negblocked = 1; 1032 negblocked = 1;
1037 } 1033 }
1038 1034
… …
1087 { 1083 {
1088 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 1084 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1089 op->contr->count = 0; 1085 op->contr->count = 0;
1090 return 0; 1086 return 0;
1091 } 1087 }
1088
1092 op->contr->count = 0; 1089 op->contr->count = 0;
1093 1090
1094 /* Remove code that puts player on random space on maps. IMO, 1091 /* Remove code that puts player on random space on maps. IMO,
1095 * a lot of maps probably have areas the player should not get to, 1092 * a lot of maps probably have areas the player should not get to,
1096 * but may not be marked as NO_MAGIC (as they may be bounded 1093 * but may not be marked as NO_MAGIC (as they may be bounded
… …
1145 return 0; 1142 return 0;
1146 } 1143 }
1147 } 1144 }
1148 1145
1149 /* Actually move the player now */ 1146 /* Actually move the player now */
1150 op->remove (); 1147 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1151 op->x += freearr_x[dir] * dist;
1152 op->y += freearr_y[dir] * dist;
1153 if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1154 return 1; 1148 return 1;
1155 1149
1156 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 1150 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1157 return 1; 1151 return 1;
1158} 1152}
… …
1302}; 1296};
1303 1297
1304int 1298int
1305cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1299cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1306{ 1300{
1307 object *tmp, *tmp2 = NULL;
1308 object *force = NULL; 1301 object *force = NULL;
1309 int i; 1302 int i;
1310 1303
1311 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1304 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1312 if (dir != 0) 1305 object *tmp = dir
1313 {
1314 tmp = find_target_for_friendly_spell (op, dir); 1306 ? find_target_for_friendly_spell (op, dir)
1315 } 1307 : op;
1316 else
1317 {
1318 tmp = op;
1319 }
1320 1308
1321 if (tmp == NULL) 1309 if (!tmp)
1322 return 0; 1310 return 0;
1323 1311
1324 /* If we've already got a force of this type, don't add a new one. */ 1312 /* If we've already got a force of this type, don't add a new one. */
1325 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1313 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1326 { 1314 {
1327 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1315 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1328 { 1316 {
1329 if (tmp2->name == spell_ob->name) 1317 if (tmp2->name == spell_ob->name)
1330 { 1318 {
… …
1432 force->stats.ac = spell_ob->stats.ac; 1420 force->stats.ac = spell_ob->stats.ac;
1433 force->attacktype = spell_ob->attacktype; 1421 force->attacktype = spell_ob->attacktype;
1434 1422
1435 insert_ob_in_ob (force, tmp); 1423 insert_ob_in_ob (force, tmp);
1436 change_abil (tmp, force); /* Mostly to display any messages */ 1424 change_abil (tmp, force); /* Mostly to display any messages */
1437 fix_player (tmp); 1425 tmp->update_stats ();
1438 return 1; 1426 return 1;
1439} 1427}
1440 1428
1441/* This used to be part of cast_change_ability, but it really didn't make 1429/* This used to be part of cast_change_ability, but it really didn't make
1442 * a lot of sense, since most of the values it derives are from the god 1430 * a lot of sense, since most of the values it derives are from the god
… …
1541 force->stats.wc = spell_ob->stats.wc; 1529 force->stats.wc = spell_ob->stats.wc;
1542 force->stats.ac = spell_ob->stats.ac; 1530 force->stats.ac = spell_ob->stats.ac;
1543 1531
1544 change_abil (tmp, force); /* Mostly to display any messages */ 1532 change_abil (tmp, force); /* Mostly to display any messages */
1545 insert_ob_in_ob (force, tmp); 1533 insert_ob_in_ob (force, tmp);
1546 fix_player (tmp); 1534 tmp->update_stats ();
1547 return 1; 1535 return 1;
1548} 1536}
1549 1537
1550 1538
1551 1539
… …
1640 1628
1641 if (small_nuggets) 1629 if (small_nuggets)
1642 { 1630 {
1643 tmp = small->clone (); 1631 tmp = small->clone ();
1644 tmp->nrof = small_nuggets; 1632 tmp->nrof = small_nuggets;
1645 tmp->x = x;
1646 tmp->y = y;
1647 insert_ob_in_map (tmp, m, op, flag); 1633 m->insert (tmp, x, y, op, flag);
1648 } 1634 }
1649 1635
1650 if (large_nuggets) 1636 if (large_nuggets)
1651 { 1637 {
1652 tmp = large->clone (); 1638 tmp = large->clone ();
1653 tmp->nrof = large_nuggets; 1639 tmp->nrof = large_nuggets;
1654 tmp->x = x;
1655 tmp->y = y;
1656 insert_ob_in_map (tmp, m, op, flag); 1640 m->insert (tmp, x, y, op, flag);
1657 } 1641 }
1658} 1642}
1659 1643
1660int 1644int
1661alchemy (object *op, object *caster, object *spell_ob) 1645alchemy (object *op, object *caster, object *spell_ob)
… …
1698 continue; 1682 continue;
1699 1683
1700 small_nuggets = 0; 1684 small_nuggets = 0;
1701 large_nuggets = 0; 1685 large_nuggets = 0;
1702 1686
1703 for (tmp = get_map_ob (mp, nx, ny); tmp != NULL; tmp = next) 1687 for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = next)
1704 { 1688 {
1705 next = tmp->above; 1689 next = tmp->above;
1706 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1690 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1707 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1691 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1708 { 1692 {
… …
1742 large->destroy (); 1726 large->destroy ();
1743 small->destroy (); 1727 small->destroy ();
1744 /* reset this so that if player standing on a big pile of stuff, 1728 /* reset this so that if player standing on a big pile of stuff,
1745 * it is redrawn properly. 1729 * it is redrawn properly.
1746 */ 1730 */
1747 op->contr->socket->look_position = 0; 1731 op->contr->ns->look_position = 0;
1748 return 1; 1732 return 1;
1749} 1733}
1750 1734
1751 1735
1752/* This function removes the cursed/damned status on equipped 1736/* This function removes the cursed/damned status on equipped
… …
1837 * stuff on the floor. Only identify stuff on the floor if the spell 1821 * stuff on the floor. Only identify stuff on the floor if the spell
1838 * was not fully used. 1822 * was not fully used.
1839 */ 1823 */
1840 if (num_ident) 1824 if (num_ident)
1841 { 1825 {
1842 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1826 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1843 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1827 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1844 { 1828 {
1845 identify (tmp); 1829 identify (tmp);
1846 1830
1847 if (op->type == PLAYER) 1831 if (op->type == PLAYER)
… …
1902 * floor. But this is not true for show invisible. 1886 * floor. But this is not true for show invisible.
1903 * Basically, we just go and find the top object and work 1887 * Basically, we just go and find the top object and work
1904 * down - that is easier than working up. 1888 * down - that is easier than working up.
1905 */ 1889 */
1906 1890
1907 for (last = NULL, tmp = get_map_ob (m, nx, ny); tmp; tmp = tmp->above) 1891 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)
1908 last = tmp; 1892 last = tmp;
1909 1893
1910 /* Shouldn't happen, but if there are no objects on a space, this 1894 /* Shouldn't happen, but if there are no objects on a space, this
1911 * would happen. 1895 * would happen.
1912 */ 1896 */
… …
1998 */ 1982 */
1999 if (done_one) 1983 if (done_one)
2000 { 1984 {
2001 object *detect_ob = arch_to_object (spell->other_arch); 1985 object *detect_ob = arch_to_object (spell->other_arch);
2002 1986
2003 detect_ob->x = nx;
2004 detect_ob->y = ny;
2005 /* if this is set, we want to copy the face */ 1987 /* if this is set, we want to copy the face */
2006 if (done_one == 2 && detect) 1988 if (done_one == 2 && detect)
2007 { 1989 {
2008 detect_ob->face = detect->face; 1990 detect_ob->face = detect->face;
2009 detect_ob->animation_id = detect->animation_id; 1991 detect_ob->animation_id = detect->animation_id;
… …
2011 detect_ob->last_anim = 0; 1993 detect_ob->last_anim = 0;
2012 /* by default, the detect_ob is already animated */ 1994 /* by default, the detect_ob is already animated */
2013 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1995 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2014 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1996 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2015 } 1997 }
1998
2016 insert_ob_in_map (detect_ob, m, op, 0); 1999 m->insert (detect_ob, nx, ny, op);
2017 } 2000 }
2018 } /* for processing the surrounding spaces */ 2001 } /* for processing the surrounding spaces */
2019 2002
2020 2003
2021 /* Now process objects in the players inventory if detect curse or magic */ 2004 /* Now process objects in the players inventory if detect curse or magic */
… …
2070 2053
2071 /* Explodes a fireball centered at player */ 2054 /* Explodes a fireball centered at player */
2072 tmp = get_archetype (EXPLODING_FIREBALL); 2055 tmp = get_archetype (EXPLODING_FIREBALL);
2073 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1; 2056 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2074 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2; 2057 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2075 tmp->x = victim->x; 2058
2076 tmp->y = victim->y; 2059 tmp->insert_at (victim);
2077 insert_ob_in_map (tmp, victim->map, NULL, 0);
2078 victim->stats.sp = 2 * victim->stats.maxsp; 2060 victim->stats.sp = 2 * victim->stats.maxsp;
2079 } 2061 }
2080 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 2062 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2081 {
2082 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 2063 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");
2083 }
2084 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 2064 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2085 {
2086 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 2065 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2087 }
2088 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 2066 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2089 { 2067 {
2090 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 2068 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2091 confuse_player (victim, victim, 99); 2069 confuse_player (victim, victim, 99);
2092 } 2070 }
2093 else if (victim->stats.sp >= victim->stats.maxsp * 1.25) 2071 else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2094 {
2095 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices."); 2072 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2096 }
2097} 2073}
2098 2074
2099/* cast_transfer 2075/* cast_transfer
2100 * This spell transfers sp from the player to another person. 2076 * This spell transfers sp from the player to another person.
2101 * We let the target go above their normal maximum SP. 2077 * We let the target go above their normal maximum SP.
… …
2115 2091
2116 mflags = get_map_flags (m, &m, x, y, &x, &y); 2092 mflags = get_map_flags (m, &m, x, y, &x, &y);
2117 2093
2118 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 2094 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
2119 { 2095 {
2120 for (plyr = get_map_ob (m, x, y); plyr != NULL; plyr = plyr->above) 2096 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
2121 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 2097 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2122 break; 2098 break;
2123 } 2099 }
2124 2100
2125 2101
2126 /* If we did not find a player in the specified direction, transfer 2102 /* If we did not find a player in the specified direction, transfer
2127 * to anyone on top of us. This is used for the rune of transference mostly. 2103 * to anyone on top of us. This is used for the rune of transference mostly.
2128 */ 2104 */
2129 if (plyr == NULL) 2105 if (plyr == NULL)
2130 for (plyr = get_map_ob (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 2106 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
2131 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 2107 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2132 break; 2108 break;
2133 2109
2134 if (!plyr) 2110 if (!plyr)
2135 { 2111 {
… …
2190 m = op->map; 2166 m = op->map;
2191 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 2167 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
2192 if (mflags & P_OUT_OF_MAP) 2168 if (mflags & P_OUT_OF_MAP)
2193 return; 2169 return;
2194 2170
2195 for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next) 2171 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
2196 { 2172 {
2197 next = tmp->above; 2173 next = tmp->above;
2198 2174
2199 /* Need to look at the head object - otherwise, if tmp 2175 /* Need to look at the head object - otherwise, if tmp
2200 * points to a monster, we don't have all the necessary 2176 * points to a monster, we don't have all the necessary
… …
2398 * so instead, just set it as equipped (otherwise, we need to update 2374 * so instead, just set it as equipped (otherwise, we need to update
2399 * body_info, skills, etc) 2375 * body_info, skills, etc)
2400 */ 2376 */
2401 SET_FLAG (tmp, FLAG_USE_WEAPON); 2377 SET_FLAG (tmp, FLAG_USE_WEAPON);
2402 SET_FLAG (weapon, FLAG_APPLIED); 2378 SET_FLAG (weapon, FLAG_APPLIED);
2403 fix_player (tmp); 2379 tmp->update_stats ();
2404 2380
2405 /* There used to be 'odd' code that basically seemed to take the absolute 2381 /* There used to be 'odd' code that basically seemed to take the absolute
2406 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2382 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2407 * if you're using a crappy weapon, it shouldn't be as good. 2383 * if you're using a crappy weapon, it shouldn't be as good.
2408 */ 2384 */
… …
2460 if (a > 14) 2436 if (a > 14)
2461 a = 14; 2437 a = 14;
2462 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2438 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2463 2439
2464 /* Determine golem's speed */ 2440 /* Determine golem's speed */
2465 tmp->speed = 0.4 + 0.1 * SP_level_range_adjust (caster, spell); 2441 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2466
2467 if (tmp->speed > 3.33)
2468 tmp->speed = 3.33;
2469 2442
2470 if (!spell->race) 2443 if (!spell->race)
2471 { 2444 {
2472 sprintf (buf, "animated %s", &weapon->name); 2445 sprintf (buf, "animated %s", &weapon->name);
2473 tmp->name = buf; 2446 tmp->name = buf;
… …
2475 tmp->face = weapon->face; 2448 tmp->face = weapon->face;
2476 tmp->animation_id = weapon->animation_id; 2449 tmp->animation_id = weapon->animation_id;
2477 tmp->anim_speed = weapon->anim_speed; 2450 tmp->anim_speed = weapon->anim_speed;
2478 tmp->last_anim = weapon->last_anim; 2451 tmp->last_anim = weapon->last_anim;
2479 tmp->state = weapon->state; 2452 tmp->state = weapon->state;
2480 if (QUERY_FLAG (weapon, FLAG_ANIMATE)) 2453 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2481 {
2482 SET_FLAG (tmp, FLAG_ANIMATE);
2483 }
2484 else
2485 {
2486 CLEAR_FLAG (tmp, FLAG_ANIMATE);
2487 }
2488 update_ob_speed (tmp);
2489 } 2454 }
2490 2455
2491 /* make experience increase in proportion to the strength of the summoned creature. */ 2456 /* make experience increase in proportion to the strength of the summoned creature. */
2492 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2457 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));
2493 2458
2494 tmp->speed_left = -1; 2459 tmp->speed_left = -1;
2495 tmp->x = x;
2496 tmp->y = y;
2497 tmp->direction = dir; 2460 tmp->direction = dir;
2498 insert_ob_in_map (tmp, m, op, 0); 2461
2462 m->insert (tmp, x, y, op);
2499 return 1; 2463 return 1;
2500} 2464}
2501 2465
2502/* cast_daylight() - changes the map darkness level *lower* */ 2466/* cast_daylight() - changes the map darkness level *lower* */
2503 2467
… …
2511 int success; 2475 int success;
2512 2476
2513 if (!op->map) 2477 if (!op->map)
2514 return 0; /* shouldnt happen */ 2478 return 0; /* shouldnt happen */
2515 2479
2516 success = change_map_light (op->map, spell->stats.dam); 2480 success = op->map->change_map_light (spell->stats.dam);
2481
2517 if (!success) 2482 if (!success)
2518 { 2483 {
2519 if (spell->stats.dam < 0) 2484 if (spell->stats.dam < 0)
2520 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2485 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2521 else 2486 else
… …
2598 { 2563 {
2599 aura->destroy (); 2564 aura->destroy ();
2600 return; 2565 return;
2601 } 2566 }
2602 2567
2603 aura->x = env->x;
2604 aura->y = env->y;
2605
2606 /* we need to jump out of the inventory for a bit 2568 /* we need to jump out of the inventory for a bit
2607 * in order to hit the map conveniently. 2569 * in order to hit the map conveniently.
2608 */ 2570 */
2609 insert_ob_in_map (aura, env->map, aura, 0); 2571 aura->insert_at (env, aura);
2610 2572
2611 for (i = 1; i < 9; i++) 2573 for (i = 1; i < 9; i++)
2612 { 2574 {
2613 sint16 nx, ny; 2575 sint16 nx, ny;
2614 2576
… …
2623 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2585 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))
2624 { 2586 {
2625 hit_map (aura, i, aura->attacktype, 0); 2587 hit_map (aura, i, aura->attacktype, 0);
2626 2588
2627 if (aura->other_arch) 2589 if (aura->other_arch)
2628 { 2590 m->insert (arch_to_object (aura->other_arch), nx, ny, aura);
2629 object *new_ob;
2630
2631 new_ob = arch_to_object (aura->other_arch);
2632 new_ob->x = nx;
2633 new_ob->y = ny;
2634 insert_ob_in_map (new_ob, m, aura, 0);
2635 } 2591 }
2636 }
2637 } 2592 }
2593
2638 /* put the aura back in the player's inventory */ 2594 /* put the aura back in the player's inventory */
2639 aura->remove (); 2595 aura->remove ();
2640 insert_ob_in_ob (aura, env); 2596 insert_ob_in_ob (aura, env);
2641} 2597}
2642 2598
… …
2647void 2603void
2648move_peacemaker (object *op) 2604move_peacemaker (object *op)
2649{ 2605{
2650 object *tmp; 2606 object *tmp;
2651 2607
2652 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 2608 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2653 { 2609 {
2654 int atk_lev, def_lev; 2610 int atk_lev, def_lev;
2655 object *victim = tmp; 2611 object *victim = tmp;
2656 2612
2657 if (tmp->head) 2613 if (tmp->head)
… …
2723 2679
2724 snprintf (rune, sizeof (rune), "%s\n", msg); 2680 snprintf (rune, sizeof (rune), "%s\n", msg);
2725 2681
2726 tmp->race = op->name; /*Save the owner of the rune */ 2682 tmp->race = op->name; /*Save the owner of the rune */
2727 tmp->msg = rune; 2683 tmp->msg = rune;
2728 tmp->x = op->x; 2684
2729 tmp->y = op->y; 2685 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2730 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2731 return 1; 2686 return 1;
2732} 2687}

Diff Legend

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