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

Diff Legend

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