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.17 by root, Mon Sep 4 17:27:13 2006 UTC vs.
Revision 1.21 by root, Sat Sep 9 21:48:28 2006 UTC

1/* 1/*
2 * static char *rcsid_object_c = 2 * static char *rcsid_object_c =
3 * "$Id: object.C,v 1.17 2006/09/04 17:27:13 root Exp $"; 3 * "$Id: object.C,v 1.21 2006/09/09 21:48:28 root Exp $";
4 */ 4 */
5 5
6/* 6/*
7 CrossFire, A Multiplayer game for X-windows 7 CrossFire, A Multiplayer game for X-windows
8 8
… …
54 {0,9,10,13,14,17,18,21,22,25,26,27,30,31,32,33,36,37,39,39,42,43,44,45, 54 {0,9,10,13,14,17,18,21,22,25,26,27,30,31,32,33,36,37,39,39,42,43,44,45,
55 48,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49}; 55 48,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49};
56int freedir[SIZEOFFREE]= { 56int freedir[SIZEOFFREE]= {
57 0,1,2,3,4,5,6,7,8,1,2,2,2,3,4,4,4,5,6,6,6,7,8,8,8, 57 0,1,2,3,4,5,6,7,8,1,2,2,2,3,4,4,4,5,6,6,6,7,8,8,8,
58 1,2,2,2,2,2,3,4,4,4,4,4,5,6,6,6,6,6,7,8,8,8,8,8}; 58 1,2,2,2,2,2,3,4,4,4,4,4,5,6,6,6,6,6,7,8,8,8,8,8};
59
60 59
61/* Returns TRUE if every key_values in wants has a partner with the same value in has. */ 60/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
62static int compare_ob_value_lists_one(const object * wants, const object * has) { 61static int compare_ob_value_lists_one(const object * wants, const object * has) {
63 key_value * wants_field; 62 key_value * wants_field;
64 63
… …
624 623
625 update_ob_speed (op); 624 update_ob_speed (op);
626} 625}
627 626
628/* 627/*
629 * get_object() grabs an object from the list of unused objects, makes
630 * sure it is initialised, and returns it.
631 * If there are no free objects, expand_objects() is called to get more.
632 */
633
634object *get_object ()
635{
636 object *op = new object;
637
638 op->count = ++ob_count;
639
640 op->active_next = 0;
641 op->active_prev = 0;
642
643 op->next = objects;
644 op->prev = 0;
645
646 if (objects)
647 objects->prev = op;
648
649 objects = op;
650
651 SET_FLAG (op, FLAG_REMOVED);
652
653 op->expmul = 1.0;
654 op->face = blank_face;
655 op->attacked_by_count = -1;
656
657 return op;
658}
659
660/*
661 * If an object with the IS_TURNABLE() flag needs to be turned due 628 * If an object with the IS_TURNABLE() flag needs to be turned due
662 * to the closest player being on the other side, this function can 629 * to the closest player being on the other side, this function can
663 * be called to update the face variable, _and_ how it looks on the map. 630 * be called to update the face variable, _and_ how it looks on the map.
664 */ 631 */
665 632
… …
826 update_now=1; 793 update_now=1;
827 794
828 if (QUERY_FLAG(op, FLAG_ALIVE) && !(flags & P_IS_ALIVE)) 795 if (QUERY_FLAG(op, FLAG_ALIVE) && !(flags & P_IS_ALIVE))
829 update_now=1; 796 update_now=1;
830 797
798 if (op->type == SAFE_GROUND && !(flags & P_SAFE))
799 update_now=1;
800
831 if ((move_on | op->move_on) != move_on) update_now=1; 801 if ((move_on | op->move_on) != move_on) update_now=1;
802
832 if ((move_off | op->move_off) != move_off) update_now=1; 803 if ((move_off | op->move_off) != move_off) update_now=1;
804
833 /* This isn't perfect, but I don't expect a lot of objects to 805 /* This isn't perfect, but I don't expect a lot of objects to
834 * to have move_allow right now. 806 * to have move_allow right now.
835 */ 807 */
836 if (((move_block | op->move_block) & ~op->move_allow) != move_block) 808 if (((move_block | op->move_block) & ~op->move_allow) != move_block)
837 update_now=1; 809 update_now=1;
810
838 if ((move_slow | op->move_slow) != move_slow) update_now=1; 811 if ((move_slow | op->move_slow) != move_slow)
812 update_now=1;
839 } 813 }
840 /* if the object is being removed, we can't make intelligent 814 /* if the object is being removed, we can't make intelligent
841 * decisions, because remove_ob can't really pass the object 815 * decisions, because remove_ob can't really pass the object
842 * that is being removed. 816 * that is being removed.
843 */ 817 */
… …
857 831
858 if(op->more!=NULL) 832 if(op->more!=NULL)
859 update_object(op->more, action); 833 update_object(op->more, action);
860} 834}
861 835
836static std::vector<object *> mortals;
837
838void object::free_mortals ()
839{
840 for (std::vector<object *>::iterator i = mortals.begin (); i != mortals.end (); ++i)
841 delete *i;
842
843 mortals.clear ();
844}
845
846object::object ()
847{
848 count = ++ob_count;
849
850 prev = 0;
851 next = objects;
852
853 if (objects)
854 objects->prev = this;
855
856 objects = this;
857
858 SET_FLAG (this, FLAG_REMOVED);
859
860 expmul = 1.0;
861 face = blank_face;
862 attacked_by_count = -1;
863}
864
865object::~object ()
866{
867}
868
869object *object::create ()
870{
871 return new object;
872}
862 873
863/* 874/*
864 * free_object() frees everything allocated by an object, removes 875 * free_object() frees everything allocated by an object, removes
865 * it from the list of used objects, and puts it on the list of 876 * it from the list of used objects, and puts it on the list of
866 * free objects. The IS_FREED() flag is set in the object. 877 * free objects. The IS_FREED() flag is set in the object.
… …
868 * this function to succeed. 879 * this function to succeed.
869 * 880 *
870 * If free_inventory is set, free inventory as well. Else drop items in 881 * If free_inventory is set, free inventory as well. Else drop items in
871 * inventory to the ground. 882 * inventory to the ground.
872 */ 883 */
873
874void 884void
875free_object (object * ob) 885object::free (bool free_inventory)
876{ 886{
877 free_object2 (ob, 0);
878}
879
880void
881free_object2 (object * ob, int free_inventory)
882{
883 object *tmp, *op;
884
885 if (!QUERY_FLAG (ob, FLAG_REMOVED)) 887 if (!QUERY_FLAG (this, FLAG_REMOVED))
886 { 888 {
887 LOG (llevDebug, "Free object called with non removed object\n"); 889 LOG (llevDebug, "Free object called with non removed object\n");
888 dump_object (ob); 890 dump_object (this);
889#ifdef MANY_CORES 891#ifdef MANY_CORES
890 abort (); 892 abort ();
891#endif 893#endif
892 } 894 }
893 895
894 if (QUERY_FLAG (ob, FLAG_FRIENDLY)) 896 if (QUERY_FLAG (this, FLAG_FRIENDLY))
895 { 897 {
896 LOG (llevMonster, "Warning: tried to free friendly object.\n"); 898 LOG (llevMonster, "Warning: tried to free friendly object.\n");
897 remove_friendly_object (ob); 899 remove_friendly_object (this);
898 } 900 }
899 901
900 if (QUERY_FLAG (ob, FLAG_FREED)) 902 if (QUERY_FLAG (this, FLAG_FREED))
901 { 903 {
902 dump_object (ob); 904 dump_object (this);
903 LOG (llevError, "Trying to free freed object.\n%s\n", errmsg); 905 LOG (llevError, "Trying to free freed object.\n%s\n", errmsg);
904 return; 906 return;
905 } 907 }
906 908
907 if (ob->more != NULL) 909 if (more)
908 { 910 {
909 free_object2 (ob->more, free_inventory); 911 more->free (free_inventory);
910 ob->more = NULL; 912 more = 0;
911 } 913 }
912 914
913 if (ob->inv) 915 if (inv)
914 { 916 {
915 /* Only if the space blocks everything do we not process - 917 /* Only if the space blocks everything do we not process -
916 * if some form of movement is allowed, let objects 918 * if some form of movement is allowed, let objects
917 * drop on that space. 919 * drop on that space.
918 */ 920 */
919 if (free_inventory || ob->map == NULL 921 if (free_inventory || !map
920 || ob->map->in_memory != MAP_IN_MEMORY 922 || map->in_memory != MAP_IN_MEMORY
921 || (GET_MAP_MOVE_BLOCK (ob->map, ob->x, ob->y) == MOVE_ALL)) 923 || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL))
922 { 924 {
923 op = ob->inv; 925 object *op = inv;
924 926
925 while (op != NULL) 927 while (op)
926 { 928 {
927 tmp = op->below; 929 object *tmp = op->below;
928 remove_ob (op); 930 remove_ob (op);
929 free_object2 (op, free_inventory); 931 op->free (free_inventory);
930 op = tmp; 932 op = tmp;
931 } 933 }
932 } 934 }
933 else 935 else
934 { /* Put objects in inventory onto this space */ 936 { /* Put objects in inventory onto this space */
935 op = ob->inv; 937 object *op = inv;
936 938
937 while (op != NULL) 939 while (op)
938 { 940 {
939 tmp = op->below; 941 object *tmp = op->below;
940 remove_ob (op); 942 remove_ob (op);
941 943
942 if (QUERY_FLAG (op, FLAG_STARTEQUIP) 944 if (QUERY_FLAG (op, FLAG_STARTEQUIP)
943 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE 945 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE
944 || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 946 || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
945 free_object (op); 947 free_object (op);
946 else 948 else
947 { 949 {
948 op->x = ob->x; 950 op->x = x;
949 op->y = ob->y; 951 op->y = y;
950 insert_ob_in_map (op, ob->map, NULL, 0); /* Insert in same map as the envir */ 952 insert_ob_in_map (op, map, 0, 0); /* Insert in same map as the envir */
951 } 953 }
952 954
953 op = tmp; 955 op = tmp;
954 } 956 }
955 } 957 }
956 } 958 }
957 959
958 /* Remove object from the active list */ 960 /* Remove object from the active list */
959 ob->speed = 0; 961 speed = 0;
960 update_ob_speed (ob); 962 update_ob_speed (this);
961 963
962 SET_FLAG (ob, FLAG_FREED); 964 SET_FLAG (this, FLAG_FREED);
965
966 mortalise ();
967}
968
969void
970object::mortalise ()
971{
963 ob->count = 0; 972 count = 0;
964 973
965 /* Remove this object from the list of used objects */ 974 /* Remove this object from the list of used objects */
966 if (ob->prev == NULL) 975 if (prev) prev->next = next;
967 { 976 if (next) next->prev = prev;
968 objects = ob->next; 977 if (this == objects) objects = next;
969 978
970 if (objects != NULL)
971 objects->prev = NULL;
972 }
973 else
974 {
975 ob->prev->next = ob->next;
976
977 if (ob->next != NULL)
978 ob->next->prev = ob->prev;
979 }
980
981 free_key_values (ob); 979 free_key_values (this);
982 980
983 /* Now link it with the free_objects list: */ 981 mortals.push_back (this);
984 ob->prev = 0;
985 ob->next = 0;
986
987 delete ob;
988} 982}
989 983
990/* 984/*
991 * sub_weight() recursively (outwards) subtracts a number from the 985 * sub_weight() recursively (outwards) subtracts a number from the
992 * weight of an object (and what is carried by it's environment(s)). 986 * weight of an object (and what is carried by it's environment(s)).

Diff Legend

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