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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.88 by root, Tue Dec 26 09:37:00 2006 UTC vs.
Revision 1.95 by root, Wed Dec 27 05:42:08 2006 UTC

778 778
779 prev = 0; 779 prev = 0;
780 next = 0; 780 next = 0;
781} 781}
782 782
783object *object::create ()
784{
785 object *op = new object;
786 op->link ();
787 return op;
788}
789
790void
791object::do_destroy ()
792{
793 attachable::do_destroy ();
794
795 if (flag [FLAG_IS_LINKED])
796 remove_button_link (this);
797
798 if (flag [FLAG_FRIENDLY])
799 remove_friendly_object (this);
800
801 if (!flag [FLAG_REMOVED])
802 remove ();
803
804 if (flag [FLAG_FREED])
805 return;
806
807 flag [FLAG_FREED] = 1;
808
809 while (inv)
810 inv->destroy ();
811
812 set_speed (0);
813 unlink ();
814
815 // hack to ensure that freed objects still have a valid map
816 {
817 static maptile *freed_map; // freed objects are moved here to avoid crashes
818
819 if (!freed_map)
820 {
821 freed_map = new maptile;
822
823 freed_map->name = "/internal/freed_objects_map";
824 freed_map->width = 3;
825 freed_map->height = 3;
826
827 freed_map->allocate ();
828 }
829
830 map = freed_map;
831 x = 1;
832 y = 1;
833 }
834
835 head = 0;
836
837 if (more)
838 {
839 more->destroy ();
840 more = 0;
841 }
842
843 // clear those pointers that likely might have circular references to us
844 owner = 0;
845 enemy = 0;
846 attacked_by = 0;
847
848 // only relevant for players(?), but make sure of it anyways
849 contr = 0;
850}
851
852/* 783/*
853 * Remove and free all objects in the inventory of the given object. 784 * Remove and free all objects in the inventory of the given object.
854 * object.c ? 785 * object.c ?
855 */ 786 */
856void 787void
857object::destroy_inv (bool drop_to_ground) 788object::destroy_inv (bool drop_to_ground)
858{ 789{
790 // need to check first, because the checks below might segfault
791 // as we might be on an invalid mapspace and crossfire code
792 // is too buggy to ensure that the inventory is empty.
793 // corollary: if you create arrows etc. with stuff in tis inventory,
794 // cf will crash below with off-map x and y
795 if (!inv)
796 return;
797
859 /* Only if the space blocks everything do we not process - 798 /* Only if the space blocks everything do we not process -
860 * if some form of movement is allowed, let objects 799 * if some form of movement is allowed, let objects
861 * drop on that space. 800 * drop on that space.
862 */ 801 */
863 if (!drop_to_ground || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL) 802 if (!drop_to_ground
803 || !map
804 || map->in_memory != MAP_IN_MEMORY
805 || ms ().move_block == MOVE_ALL)
864 { 806 {
865 while (inv) 807 while (inv)
808 {
809 inv->destroy_inv (drop_to_ground);
866 inv->destroy (); 810 inv->destroy ();
811 }
867 } 812 }
868 else 813 else
869 { /* Put objects in inventory onto this space */ 814 { /* Put objects in inventory onto this space */
870 while (inv) 815 while (inv)
871 { 816 {
876 || op->type == RUNE 821 || op->type == RUNE
877 || op->type == TRAP 822 || op->type == TRAP
878 || op->flag [FLAG_IS_A_TEMPLATE]) 823 || op->flag [FLAG_IS_A_TEMPLATE])
879 op->destroy (); 824 op->destroy ();
880 else 825 else
881 { 826 map->insert (op, x, y);
882 op->remove ();
883 op->x = x;
884 op->y = y;
885 insert_ob_in_map (op, map, 0, 0); /* Insert in same map as the envir */
886 }
887 } 827 }
888 } 828 }
829}
830
831object *object::create ()
832{
833 object *op = new object;
834 op->link ();
835 return op;
836}
837
838void
839object::do_destroy ()
840{
841 if (flag [FLAG_IS_LINKED])
842 remove_button_link (this);
843
844 if (flag [FLAG_FRIENDLY])
845 remove_friendly_object (this);
846
847 if (!flag [FLAG_REMOVED])
848 remove ();
849
850 if (flag [FLAG_FREED])
851 return;
852
853 set_speed (0);
854
855 flag [FLAG_FREED] = 1;
856
857 attachable::do_destroy ();
858
859 destroy_inv (true);
860 unlink ();
861
862 // hack to ensure that freed objects still have a valid map
863 {
864 static maptile *freed_map; // freed objects are moved here to avoid crashes
865
866 if (!freed_map)
867 {
868 freed_map = new maptile;
869
870 freed_map->name = "/internal/freed_objects_map";
871 freed_map->width = 3;
872 freed_map->height = 3;
873
874 freed_map->allocate ();
875 }
876
877 map = freed_map;
878 x = 1;
879 y = 1;
880 }
881
882 head = 0;
883
884 if (more)
885 {
886 more->destroy ();
887 more = 0;
888 }
889
890 // clear those pointers that likely might have circular references to us
891 owner = 0;
892 enemy = 0;
893 attacked_by = 0;
894
895 // only relevant for players(?), but make sure of it anyways
896 contr = 0;
889} 897}
890 898
891void 899void
892object::destroy (bool destroy_inventory) 900object::destroy (bool destroy_inventory)
893{ 901{
894 if (destroyed ()) 902 if (destroyed ())
895 return; 903 return;
896 904
897 if (destroy_inventory) 905 if (destroy_inventory)
898 destroy_inv (true); 906 destroy_inv (false);
899 907
900 attachable::destroy (); 908 attachable::destroy ();
901} 909}
902 910
903/* 911/*
1016 if (map->in_memory == MAP_SAVING) 1024 if (map->in_memory == MAP_SAVING)
1017 return; 1025 return;
1018 1026
1019 int check_walk_off = !flag [FLAG_NO_APPLY]; 1027 int check_walk_off = !flag [FLAG_NO_APPLY];
1020 1028
1021 for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above) 1029 for (tmp = map->at (x, y).bot; tmp; tmp = tmp->above)
1022 { 1030 {
1023 /* No point updating the players look faces if he is the object 1031 /* No point updating the players look faces if he is the object
1024 * being removed. 1032 * being removed.
1025 */ 1033 */
1026 1034
1112 * job preparing multi-part monsters 1120 * job preparing multi-part monsters
1113 */ 1121 */
1114object * 1122object *
1115insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) 1123insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1116{ 1124{
1117 object *tmp;
1118
1119 if (op->head)
1120 op = op->head;
1121
1122 for (tmp = op; tmp; tmp = tmp->more) 1125 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1123 { 1126 {
1124 tmp->x = x + tmp->arch->clone.x; 1127 tmp->x = x + tmp->arch->clone.x;
1125 tmp->y = y + tmp->arch->clone.y; 1128 tmp->y = y + tmp->arch->clone.y;
1126 } 1129 }
1127 1130
1441 tmp1->x = op->x; 1444 tmp1->x = op->x;
1442 tmp1->y = op->y; 1445 tmp1->y = op->y;
1443 insert_ob_in_map (tmp1, op->map, op, 0); 1446 insert_ob_in_map (tmp1, op->map, op, 0);
1444} 1447}
1445 1448
1449object *
1450object::insert_at (object *where, object *originator, int flags)
1451{
1452 where->map->insert (this, where->x, where->y, originator, flags);
1453}
1454
1446/* 1455/*
1447 * get_split_ob(ob,nr) splits up ob into two parts. The part which 1456 * get_split_ob(ob,nr) splits up ob into two parts. The part which
1448 * is returned contains nr objects, and the remaining parts contains 1457 * is returned contains nr objects, and the remaining parts contains
1449 * the rest (or is removed and freed if that number is 0). 1458 * the rest (or is removed and freed if that number is 0).
1450 * On failure, NULL is returned, and the reason put into the 1459 * On failure, NULL is returned, and the reason put into the
1451 * global static errmsg array. 1460 * global static errmsg array.
1452 */ 1461 */
1453
1454object * 1462object *
1455get_split_ob (object *orig_ob, uint32 nr) 1463get_split_ob (object *orig_ob, uint32 nr)
1456{ 1464{
1457 object *newob; 1465 object *newob;
1458 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0); 1466 int is_removed = (QUERY_FLAG (orig_ob, FLAG_REMOVED) != 0);
1722 * 1730 *
1723 * MSW 2001-07-08: Check all objects on space, not just those below 1731 * MSW 2001-07-08: Check all objects on space, not just those below
1724 * object being inserted. insert_ob_in_map may not put new objects 1732 * object being inserted. insert_ob_in_map may not put new objects
1725 * on top. 1733 * on top.
1726 */ 1734 */
1727
1728int 1735int
1729check_move_on (object *op, object *originator) 1736check_move_on (object *op, object *originator)
1730{ 1737{
1731 object *tmp; 1738 object *tmp;
1732 maptile *m = op->map; 1739 maptile *m = op->map;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines