1 | /* |
1 | /* |
2 | * static char *rcsid_object_c = |
2 | * static char *rcsid_object_c = |
3 | * "$Id: object.C,v 1.16 2006/09/04 16:46:32 root Exp $"; |
3 | * "$Id: object.C,v 1.22 2006/09/10 00:51:23 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}; |
56 | int freedir[SIZEOFFREE]= { |
56 | int 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. */ |
62 | static int compare_ob_value_lists_one(const object * wants, const object * has) { |
61 | static 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 | |
|
|
634 | object *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 | |
|
|
836 | static std::vector<object *> mortals; |
|
|
837 | |
|
|
838 | void 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 | |
|
|
846 | object::object () |
|
|
847 | { |
|
|
848 | SET_FLAG (this, FLAG_REMOVED); |
|
|
849 | |
|
|
850 | expmul = 1.0; |
|
|
851 | face = blank_face; |
|
|
852 | attacked_by_count = -1; |
|
|
853 | } |
|
|
854 | |
|
|
855 | object::~object () |
|
|
856 | { |
|
|
857 | free_key_values (this); |
|
|
858 | } |
|
|
859 | |
|
|
860 | void |
|
|
861 | object::link () |
|
|
862 | { |
|
|
863 | count = ++ob_count; |
|
|
864 | |
|
|
865 | prev = 0; |
|
|
866 | next = objects; |
|
|
867 | |
|
|
868 | if (objects) |
|
|
869 | objects->prev = this; |
|
|
870 | |
|
|
871 | objects = this; |
|
|
872 | } |
|
|
873 | |
|
|
874 | void |
|
|
875 | object::unlink () |
|
|
876 | { |
|
|
877 | count = 0; |
|
|
878 | |
|
|
879 | /* Remove this object from the list of used objects */ |
|
|
880 | if (prev) prev->next = next; |
|
|
881 | if (next) next->prev = prev; |
|
|
882 | if (this == objects) objects = next; |
|
|
883 | } |
|
|
884 | |
|
|
885 | object *object::create () |
|
|
886 | { |
|
|
887 | object *op = new object; |
|
|
888 | op->link (); |
|
|
889 | return op; |
|
|
890 | } |
862 | |
891 | |
863 | /* |
892 | /* |
864 | * free_object() frees everything allocated by an object, removes |
893 | * free_object() frees everything allocated by an object, removes |
865 | * it from the list of used objects, and puts it on the list of |
894 | * 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. |
895 | * free objects. The IS_FREED() flag is set in the object. |
… | |
… | |
868 | * this function to succeed. |
897 | * this function to succeed. |
869 | * |
898 | * |
870 | * If free_inventory is set, free inventory as well. Else drop items in |
899 | * If free_inventory is set, free inventory as well. Else drop items in |
871 | * inventory to the ground. |
900 | * inventory to the ground. |
872 | */ |
901 | */ |
873 | |
|
|
874 | void |
902 | void |
875 | free_object (object * ob) |
903 | object::free (bool free_inventory) |
876 | { |
904 | { |
877 | free_object2 (ob, 0); |
|
|
878 | } |
|
|
879 | |
|
|
880 | void |
|
|
881 | free_object2 (object * ob, int free_inventory) |
|
|
882 | { |
|
|
883 | object *tmp, *op; |
|
|
884 | |
|
|
885 | if (!QUERY_FLAG (ob, FLAG_REMOVED)) |
905 | if (!QUERY_FLAG (this, FLAG_REMOVED)) |
886 | { |
906 | { |
887 | LOG (llevDebug, "Free object called with non removed object\n"); |
907 | LOG (llevDebug, "Free object called with non removed object\n"); |
888 | dump_object (ob); |
908 | dump_object (this); |
889 | #ifdef MANY_CORES |
909 | #ifdef MANY_CORES |
890 | abort (); |
910 | abort (); |
891 | #endif |
911 | #endif |
892 | } |
912 | } |
893 | |
913 | |
894 | if (QUERY_FLAG (ob, FLAG_FRIENDLY)) |
914 | if (QUERY_FLAG (this, FLAG_FRIENDLY)) |
895 | { |
915 | { |
896 | LOG (llevMonster, "Warning: tried to free friendly object.\n"); |
916 | LOG (llevMonster, "Warning: tried to free friendly object.\n"); |
897 | remove_friendly_object (ob); |
917 | remove_friendly_object (this); |
898 | } |
918 | } |
899 | |
919 | |
900 | if (QUERY_FLAG (ob, FLAG_FREED)) |
920 | if (QUERY_FLAG (this, FLAG_FREED)) |
901 | { |
921 | { |
902 | dump_object (ob); |
922 | dump_object (this); |
903 | LOG (llevError, "Trying to free freed object.\n%s\n", errmsg); |
923 | LOG (llevError, "Trying to free freed object.\n%s\n", errmsg); |
904 | return; |
924 | return; |
905 | } |
925 | } |
906 | |
926 | |
907 | if (ob->more != NULL) |
927 | if (more) |
908 | { |
928 | { |
909 | free_object2 (ob->more, free_inventory); |
929 | more->free (free_inventory); |
910 | ob->more = NULL; |
930 | more = 0; |
911 | } |
931 | } |
912 | |
932 | |
913 | if (ob->inv) |
933 | if (inv) |
914 | { |
934 | { |
915 | /* Only if the space blocks everything do we not process - |
935 | /* Only if the space blocks everything do we not process - |
916 | * if some form of movemnt is allowed, let objects |
936 | * if some form of movement is allowed, let objects |
917 | * drop on that space. |
937 | * drop on that space. |
918 | */ |
938 | */ |
919 | if (free_inventory || ob->map == NULL |
939 | if (free_inventory || !map |
920 | || ob->map->in_memory != MAP_IN_MEMORY |
940 | || map->in_memory != MAP_IN_MEMORY |
921 | || (GET_MAP_MOVE_BLOCK (ob->map, ob->x, ob->y) == MOVE_ALL)) |
941 | || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)) |
922 | { |
942 | { |
923 | op = ob->inv; |
943 | object *op = inv; |
924 | |
944 | |
925 | while (op != NULL) |
945 | while (op) |
926 | { |
946 | { |
927 | tmp = op->below; |
947 | object *tmp = op->below; |
928 | remove_ob (op); |
948 | remove_ob (op); |
929 | free_object2 (op, free_inventory); |
949 | op->free (free_inventory); |
930 | op = tmp; |
950 | op = tmp; |
931 | } |
951 | } |
932 | } |
952 | } |
933 | else |
953 | else |
934 | { /* Put objects in inventory onto this space */ |
954 | { /* Put objects in inventory onto this space */ |
935 | op = ob->inv; |
955 | object *op = inv; |
936 | |
956 | |
937 | while (op != NULL) |
957 | while (op) |
938 | { |
958 | { |
939 | tmp = op->below; |
959 | object *tmp = op->below; |
940 | remove_ob (op); |
960 | remove_ob (op); |
941 | |
961 | |
942 | if (QUERY_FLAG (op, FLAG_STARTEQUIP) |
962 | if (QUERY_FLAG (op, FLAG_STARTEQUIP) |
943 | || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE |
963 | || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE |
944 | || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) |
964 | || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) |
945 | free_object (op); |
965 | free_object (op); |
946 | else |
966 | else |
947 | { |
967 | { |
948 | op->x = ob->x; |
968 | op->x = x; |
949 | op->y = ob->y; |
969 | op->y = y; |
950 | insert_ob_in_map (op, ob->map, NULL, 0); /* Insert in same map as the envir */ |
970 | insert_ob_in_map (op, map, 0, 0); /* Insert in same map as the envir */ |
951 | } |
971 | } |
952 | |
972 | |
953 | op = tmp; |
973 | op = tmp; |
954 | } |
974 | } |
955 | } |
975 | } |
956 | } |
976 | } |
957 | |
977 | |
958 | /* Remove object from the active list */ |
978 | /* Remove object from the active list */ |
959 | ob->speed = 0; |
979 | speed = 0; |
960 | update_ob_speed (ob); |
980 | update_ob_speed (this); |
961 | |
981 | |
|
|
982 | unlink (); |
|
|
983 | |
962 | SET_FLAG (ob, FLAG_FREED); |
984 | SET_FLAG (this, FLAG_FREED); |
963 | ob->count = 0; |
|
|
964 | |
985 | |
965 | /* Remove this object from the list of used objects */ |
986 | mortals.push_back (this); |
966 | if (ob->prev == NULL) |
|
|
967 | { |
|
|
968 | objects = ob->next; |
|
|
969 | |
|
|
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); |
|
|
982 | |
|
|
983 | /* Now link it with the free_objects list: */ |
|
|
984 | ob->prev = 0; |
|
|
985 | ob->next = 0; |
|
|
986 | |
|
|
987 | delete ob; |
|
|
988 | } |
987 | } |
989 | |
988 | |
990 | /* |
989 | /* |
991 | * sub_weight() recursively (outwards) subtracts a number from the |
990 | * sub_weight() recursively (outwards) subtracts a number from the |
992 | * weight of an object (and what is carried by it's environment(s)). |
991 | * weight of an object (and what is carried by it's environment(s)). |