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

Comparing deliantra/server/server/plugins.C (file contents):
Revision 1.18 by pippijn, Sat Dec 9 17:28:37 2006 UTC vs.
Revision 1.42 by root, Mon Feb 5 01:47:23 2007 UTC

… …
43static const hook_entry plug_hooks[NR_OF_HOOKS] = { 43static const hook_entry plug_hooks[NR_OF_HOOKS] = {
44 {cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"}, 44 {cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"},
45 {cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"}, 45 {cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"},
46 {cfapi_system_check_path, 4, "cfapi_system_check_path"}, 46 {cfapi_system_check_path, 4, "cfapi_system_check_path"},
47 {NULL, 5, "cfapi_system_re_cmp"}, 47 {NULL, 5, "cfapi_system_re_cmp"},
48 {cfapi_system_strdup_local, 6, "cfapi_system_strdup_local"}, 48 {cfapi_system_strdup, 6, "cfapi_system_strdup"},
49 {cfapi_system_directory, 7, "cfapi_system_directory"}, 49 {cfapi_system_directory, 7, "cfapi_system_directory"},
50 {cfapi_system_find_animation, 8, "cfapi_system_find_animation"}, 50 {cfapi_system_find_animation, 8, "cfapi_system_find_animation"},
51 {cfapi_object_clean_object, 9, "cfapi_object_clean_object"}, 51 {cfapi_object_clean_object, 9, "cfapi_object_clean_object"},
52 {cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"}, 52 {cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"},
53 {cfapi_object_get_key, 11, "cfapi_object_get_key"}, 53 {cfapi_object_get_key, 11, "cfapi_object_get_key"},
… …
121 121
122/* NEW PLUGIN STUFF STARTS HERE */ 122/* NEW PLUGIN STUFF STARTS HERE */
123 123
124/*****************************************************************************/ 124/*****************************************************************************/
125 125
126#ifdef WIN32
127static const char *
128plugins_dlerror (void)
129{
130 static char buf[256];
131 DWORD err;
132 char *p;
133
134 err = GetLastError ();
135 if (FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, sizeof (buf), NULL) == 0)
136 snprintf (buf, sizeof (buf), "error %lu", err);
137 p = strchr (buf, '\0');
138 while (p > buf && (p[-1] == '\r' || p[-1] == '\n'))
139 p--;
140 *p = '\0';
141 return buf;
142}
143#endif /* WIN32 */
144
145/** 126/**
146 * Notify clients about a changed object. 127 * Notify clients about a changed object.
147 * 128 *
148 * @param op the object that has changed 129 * @param op the object that has changed
149 */ 130 */
150static void 131static void
151send_changed_object (object *op) 132send_changed_object (object *op)
152{ 133{
153 object *tmp; 134 object *tmp;
154 player *pl;
155 135
156 if (op->env != NULL) 136 if (op->env)
157 { 137 {
158 tmp = is_player_inv (op->env); 138 tmp = op->in_player ();
139
159 if (!tmp) 140 if (!tmp)
160 { 141 {
161 for (pl = first_player; pl; pl = pl->next) 142 for_all_players (pl)
162 if (pl->ob->container == op->env) 143 if (pl->ob->container == op->env)
144 {
145 tmp = pl->ob;
163 break; 146 break;
164 if (pl) 147 }
165 tmp = pl->ob;
166 else
167 tmp = NULL;
168 } 148 }
149
169 if (tmp) 150 if (tmp)
170 esrv_send_item (tmp, op); 151 esrv_send_item (tmp, op);
171 } 152 }
172 else 153 else
173 { 154 {
… …
185 */ 166 */
186static void 167static void
187send_removed_object (object *op) 168send_removed_object (object *op)
188{ 169{
189 object *tmp; 170 object *tmp;
190 player *pl;
191 171
192 if (op->env == NULL) 172 if (op->env == NULL)
193 { 173 {
194 /* no action necessary: remove_ob() notifies the client */ 174 /* no action necessary: remove_ob() notifies the client */
195 return; 175 return;
196 } 176 }
197 177
198 tmp = is_player_inv (op->env); 178 tmp = op->in_player ();
199 if (!tmp) 179 if (!tmp)
200 { 180 {
201 for (pl = first_player; pl; pl = pl->next) 181 for_all_players (pl)
202 if (pl->ob->container == op->env) 182 if (pl->ob->container == op->env)
183 {
184 tmp = pl->ob;
203 break; 185 break;
204 if (pl) 186 }
205 tmp = pl->ob;
206 else
207 tmp = NULL;
208 } 187 }
188
209 if (tmp) 189 if (tmp)
210 esrv_del_item (tmp->contr, op->count); 190 esrv_del_item (tmp->contr, op->count);
211} 191}
212 192
213extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr); 193extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr);
… …
501 *type = CFAPI_INT; 481 *type = CFAPI_INT;
502 return &rv; 482 return &rv;
503} 483}
504 484
505void * 485void *
506cfapi_system_strdup_local (int *type, ...) 486cfapi_system_strdup (int *type, ...)
507{ 487{
508 va_list args; 488 va_list args;
509 char *txt; 489 char *txt;
510 490
511 va_start (args, type); 491 va_start (args, type);
512 txt = va_arg (args, char *); 492 txt = va_arg (args, char *);
513 493
514 va_end (args); 494 va_end (args);
515 *type = CFAPI_STRING; 495 *type = CFAPI_STRING;
516 return strdup_local (txt); 496 return strdup (txt);
517} 497}
518 498
519void * 499void *
520cfapi_system_register_global_event (int *type, ...) 500cfapi_system_register_global_event (int *type, ...)
521{ 501{
… …
629/* MAP RELATED HOOKS */ 609/* MAP RELATED HOOKS */
630 610
631void * 611void *
632cfapi_map_get_map (int *type, ...) 612cfapi_map_get_map (int *type, ...)
633{ 613{
634 va_list args; 614 abort ();
635 maptile *rv;
636 int ctype;
637 int x, y;
638 sint16 nx, ny;
639 char *name;
640 maptile *m;
641
642 va_start (args, type);
643
644 ctype = va_arg (args, int);
645
646 switch (ctype)
647 {
648 case 0:
649 x = va_arg (args, int);
650 y = va_arg (args, int);
651
652 rv = get_empty_map (x, y);
653 break;
654
655 case 1:
656 name = va_arg (args, char *);
657 x = va_arg (args, int);
658
659 rv = ready_map_name (name, x);
660 break;
661
662 case 2:
663 m = va_arg (args, maptile *);
664 nx = va_arg (args, int);
665 ny = va_arg (args, int);
666
667 rv = get_map_from_coord (m, &nx, &ny);
668 break;
669
670 case 3:
671 rv = first_map;
672 break;
673
674 default:
675 *type = CFAPI_NONE;
676 va_end (args);
677 return NULL;
678 break;
679 }
680 va_end (args);
681 *type = CFAPI_PMAP;
682 return rv;
683} 615}
684 616
685void * 617void *
686cfapi_map_has_been_loaded (int *type, ...) 618cfapi_map_has_been_loaded (int *type, ...)
687{ 619{
688 va_list args; 620 abort ();
689 maptile *map;
690 char *string;
691
692 va_start (args, type);
693 string = va_arg (args, char *);
694
695 map = has_been_loaded (string);
696 va_end (args);
697 *type = CFAPI_PMAP;
698 return map;
699} 621}
700 622
701void * 623void *
702cfapi_map_create_path (int *type, ...) 624cfapi_map_create_path (int *type, ...)
703{ 625{
704 va_list args; 626 abort ();
705 int ctype;
706 const char *str;
707 char *rv;
708
709 va_start (args, type);
710
711 ctype = va_arg (args, int);
712 str = va_arg (args, char *);
713
714 *type = CFAPI_STRING;
715
716 switch (ctype)
717 {
718 case 0:
719 rv = (char *) create_pathname (str);
720 break;
721
722 case 1:
723 rv = (char *) create_overlay_pathname (str);
724 break;
725
726 /*case 2:
727 rv = create_items_path(str);
728 break; */
729
730 default:
731 rv = NULL;
732 *type = CFAPI_NONE;
733 break;
734 }
735 va_end (args);
736 return rv;
737} 627}
738 628
739void * 629void *
740cfapi_map_get_map_property (int *type, ...) 630cfapi_map_get_map_property (int *type, ...)
741{ 631{
742 va_list args; 632 abort ();
743 int x, y;
744 sint16 nx, ny;
745 maptile *map;
746 maptile *newmap;
747 static int rv;
748 int property;
749 char *buf;
750
751 va_start (args, type);
752
753 property = va_arg (args, int);
754
755 switch (property)
756 {
757 case CFAPI_MAP_PROP_FLAGS:
758 map = va_arg (args, maptile *);
759 newmap = va_arg (args, maptile *);
760 x = va_arg (args, int);
761 y = va_arg (args, int);
762 nx = va_arg (args, int);
763 ny = va_arg (args, int);
764
765 rv = get_map_flags (map, &newmap, x, y, &nx, &ny);
766 va_end (args);
767 *type = CFAPI_INT;
768 return &rv;
769 break;
770
771 case CFAPI_MAP_PROP_DIFFICULTY:
772 map = va_arg (args, maptile *);
773
774 rv = calculate_difficulty (map);
775 va_end (args);
776 *type = CFAPI_INT;
777 return &rv;
778 break;
779
780 case CFAPI_MAP_PROP_PATH:
781 map = va_arg (args, maptile *);
782
783 buf = map->path;
784 *type = CFAPI_STRING;
785 va_end (args);
786 return buf;
787 break;
788
789 case CFAPI_MAP_PROP_TMPNAME:
790 map = va_arg (args, maptile *);
791
792 buf = map->tmpname;
793 *type = CFAPI_STRING;
794 va_end (args);
795 return buf;
796 break;
797
798 case CFAPI_MAP_PROP_NAME:
799 map = va_arg (args, maptile *);
800
801 buf = map->name;
802 *type = CFAPI_STRING;
803 va_end (args);
804 return buf;
805 break;
806
807 case CFAPI_MAP_PROP_RESET_TIME:
808 map = va_arg (args, maptile *);
809
810 rv = map->reset_time;
811 *type = CFAPI_INT;
812 va_end (args);
813 return &rv;
814 break;
815
816 case CFAPI_MAP_PROP_RESET_TIMEOUT:
817 map = va_arg (args, maptile *);
818
819 rv = map->reset_timeout;
820 *type = CFAPI_INT;
821 va_end (args);
822 return &rv;
823 break;
824
825 case CFAPI_MAP_PROP_PLAYERS:
826 map = va_arg (args, maptile *);
827
828 rv = map->players;
829 *type = CFAPI_INT;
830 va_end (args);
831 return &rv;
832 break;
833
834 case CFAPI_MAP_PROP_DARKNESS:
835 map = va_arg (args, maptile *);
836
837 rv = map->darkness;
838 *type = CFAPI_INT;
839 va_end (args);
840 return &rv;
841 break;
842
843 case CFAPI_MAP_PROP_WIDTH:
844 map = va_arg (args, maptile *);
845
846 rv = map->width;
847 *type = CFAPI_INT;
848 va_end (args);
849 return &rv;
850 break;
851
852 case CFAPI_MAP_PROP_HEIGHT:
853 map = va_arg (args, maptile *);
854
855 rv = map->height;
856 *type = CFAPI_INT;
857 va_end (args);
858 return &rv;
859 break;
860
861 case CFAPI_MAP_PROP_ENTER_X:
862 map = va_arg (args, maptile *);
863
864 rv = map->enter_x;
865 *type = CFAPI_INT;
866 va_end (args);
867 return &rv;
868 break;
869
870 case CFAPI_MAP_PROP_ENTER_Y:
871 map = va_arg (args, maptile *);
872
873 rv = map->enter_y;
874 *type = CFAPI_INT;
875 va_end (args);
876 return &rv;
877 break;
878
879 case CFAPI_MAP_PROP_TEMPERATURE:
880 map = va_arg (args, maptile *);
881
882 rv = map->temp;
883 *type = CFAPI_INT;
884 va_end (args);
885 return &rv;
886 break;
887
888 case CFAPI_MAP_PROP_PRESSURE:
889 map = va_arg (args, maptile *);
890
891 rv = map->pressure;
892 *type = CFAPI_INT;
893 va_end (args);
894 return &rv;
895 break;
896
897 case CFAPI_MAP_PROP_HUMIDITY:
898 map = va_arg (args, maptile *);
899
900 rv = map->humid;
901 *type = CFAPI_INT;
902 va_end (args);
903 return &rv;
904 break;
905
906 case CFAPI_MAP_PROP_WINDSPEED:
907 map = va_arg (args, maptile *);
908
909 rv = map->windspeed;
910 *type = CFAPI_INT;
911 va_end (args);
912 return &rv;
913 break;
914
915 case CFAPI_MAP_PROP_WINDDIR:
916 map = va_arg (args, maptile *);
917
918 rv = map->winddir;
919 *type = CFAPI_INT;
920 va_end (args);
921 return &rv;
922 break;
923
924 case CFAPI_MAP_PROP_SKY:
925 map = va_arg (args, maptile *);
926
927 rv = map->sky;
928 *type = CFAPI_INT;
929 va_end (args);
930 return &rv;
931 break;
932
933 case CFAPI_MAP_PROP_WPARTX:
934 map = va_arg (args, maptile *);
935
936 rv = map->wpartx;
937 *type = CFAPI_INT;
938 va_end (args);
939 return &rv;
940 break;
941
942 case CFAPI_MAP_PROP_WPARTY:
943 map = va_arg (args, maptile *);
944
945 rv = map->wparty;
946 *type = CFAPI_INT;
947 va_end (args);
948 return &rv;
949 break;
950
951 case CFAPI_MAP_PROP_MESSAGE:
952 map = va_arg (args, maptile *);
953
954 buf = map->msg;
955 *type = CFAPI_STRING;
956 va_end (args);
957 return buf;
958 break;
959
960 case CFAPI_MAP_PROP_NEXT:
961 map = va_arg (args, maptile *);
962
963 *type = CFAPI_PMAP;
964 va_end (args);
965 return map->next;
966 break;
967
968 case CFAPI_MAP_PROP_REGION:
969 map = va_arg (args, maptile *);
970
971 *type = CFAPI_PREGION;
972 va_end (args);
973 return get_region_by_map (map);
974 break;
975
976 default:
977 *type = CFAPI_NONE;
978 va_end (args);
979 return NULL;
980 break;
981 }
982} 633}
983 634
984void * 635void *
985cfapi_map_set_map_property (int *type, ...) 636cfapi_map_set_map_property (int *type, ...)
986{ 637{
987 va_list args; 638 abort ();
988 static int rv;
989 maptile *map;
990 int val;
991 int property;
992
993 va_start (args, type);
994
995 property = va_arg (args, int);
996
997 switch (property)
998 {
999 case CFAPI_MAP_PROP_LIGHT:
1000 map = va_arg (args, maptile *);
1001 val = va_arg (args, int);
1002
1003 rv = change_map_light (map, val);
1004 *type = CFAPI_INT;
1005 va_end (args);
1006 return &rv;
1007 break;
1008
1009 case CFAPI_MAP_PROP_RESET_TIME:
1010 map = va_arg (args, maptile *);
1011
1012 *type = CFAPI_NONE;
1013 va_end (args);
1014 return NULL;
1015 break;
1016
1017 default:
1018 *type = CFAPI_NONE;
1019 va_end (args);
1020 return NULL;
1021 break;
1022 }
1023} 639}
640
1024void * 641void *
1025cfapi_map_out_of_map (int *type, ...) 642cfapi_map_out_of_map (int *type, ...)
1026{ 643{
644 abort ();
645}
646
647void *
648cfapi_map_update_position (int *type, ...)
649{
1027 va_list args; 650 va_list args;
1028 static int rv;
1029 maptile *map; 651 maptile *map;
1030 int x, y; 652 int x, y;
1031 653
1032 va_start (args, type); 654 va_start (args, type);
655
1033 map = va_arg (args, maptile *); 656 map = va_arg (args, maptile *);
1034 x = va_arg (args, int); 657 x = va_arg (args, int);
1035 y = va_arg (args, int); 658 y = va_arg (args, int);
1036 659
1037 rv = out_of_map (map, x, y); 660 map->at (x, y).flags_ &= ~P_UPTODATE;
661
1038 va_end (args); 662 va_end (args);
1039 *type = CFAPI_INT; 663 *type = CFAPI_NONE;
1040 return &rv; 664 return NULL;
1041} 665}
1042 666
1043void * 667void *
1044cfapi_map_update_position (int *type, ...) 668cfapi_map_delete_map (int *type, ...)
669{
670 abort ();
671}
672
673void *
674cfapi_map_message (int *type, ...)
675{
676 va_list args;
677 maptile *map;
678 char *string;
679 int color;
680
681 va_start (args, type);
682 map = va_arg (args, maptile *);
683 string = va_arg (args, char *);
684 color = va_arg (args, int);
685
686 va_end (args);
687
688 new_info_map (color, map, string);
689 *type = CFAPI_NONE;
690 return NULL;
691}
692
693void *
694cfapi_map_get_object_at (int *type, ...)
1045{ 695{
1046 va_list args; 696 va_list args;
1047 maptile *map; 697 maptile *map;
1048 int x, y; 698 int x, y;
699 object *rv;
1049 700
1050 va_start (args, type); 701 va_start (args, type);
1051
1052 map = va_arg (args, maptile *); 702 map = va_arg (args, maptile *);
1053 x = va_arg (args, int); 703 x = va_arg (args, int);
1054 y = va_arg (args, int); 704 y = va_arg (args, int);
1055 705
1056 update_position (map, x, y);
1057 va_end (args); 706 va_end (args);
1058 *type = CFAPI_NONE;
1059 return NULL;
1060}
1061 707
1062void * 708 rv = GET_MAP_OB (map, x, y);
1063cfapi_map_delete_map (int *type, ...)
1064{
1065 va_list args;
1066 maptile *map;
1067
1068 va_start (args, type);
1069
1070 map = va_arg (args, maptile *);
1071
1072 delete_map (map);
1073
1074 va_end (args);
1075 *type = CFAPI_NONE;
1076 return NULL;
1077}
1078
1079void *
1080cfapi_map_message (int *type, ...)
1081{
1082 va_list args;
1083 maptile *map;
1084 char *string;
1085 int color;
1086
1087 va_start (args, type);
1088 map = va_arg (args, maptile *);
1089 string = va_arg (args, char *);
1090 color = va_arg (args, int);
1091
1092 va_end (args);
1093
1094 new_info_map (color, map, string);
1095 *type = CFAPI_NONE;
1096 return NULL;
1097}
1098
1099void *
1100cfapi_map_get_object_at (int *type, ...)
1101{
1102 va_list args;
1103 maptile *map;
1104 int x, y;
1105 object *rv;
1106
1107 va_start (args, type);
1108 map = va_arg (args, maptile *);
1109 x = va_arg (args, int);
1110 y = va_arg (args, int);
1111
1112 va_end (args);
1113
1114 rv = get_map_ob (map, x, y);
1115 *type = CFAPI_POBJECT; 709 *type = CFAPI_POBJECT;
1116 return rv; 710 return rv;
1117} 711}
1118 712
1119void * 713void *
… …
1245} 839}
1246 840
1247void * 841void *
1248cfapi_object_get_property (int *type, ...) 842cfapi_object_get_property (int *type, ...)
1249{ 843{
1250 va_list args; 844 abort ();
1251 int property;
1252 object *op;
1253 void *rv;
1254 static int ri;
1255
1256 va_start (args, type);
1257
1258 op = va_arg (args, object *);
1259 property = va_arg (args, int);
1260
1261 rv = NULL;
1262 if (op != NULL)
1263 {
1264 switch (property)
1265 {
1266 case CFAPI_OBJECT_PROP_OB_ABOVE:
1267 rv = op->above;
1268 *type = CFAPI_POBJECT;
1269 break;
1270
1271 case CFAPI_OBJECT_PROP_OB_BELOW:
1272 rv = op->below;
1273 *type = CFAPI_POBJECT;
1274 break;
1275
1276 case CFAPI_OBJECT_PROP_NEXT_ACTIVE_OB:
1277 rv = op->active_next;
1278 *type = CFAPI_POBJECT;
1279 break;
1280
1281 case CFAPI_OBJECT_PROP_PREV_ACTIVE_OB:
1282 rv = op->active_prev;
1283 *type = CFAPI_POBJECT;
1284 break;
1285
1286 case CFAPI_OBJECT_PROP_INVENTORY:
1287 rv = op->inv;
1288 *type = CFAPI_POBJECT;
1289 break;
1290
1291 case CFAPI_OBJECT_PROP_ENVIRONMENT:
1292 rv = op->env;
1293 *type = CFAPI_POBJECT;
1294 break;
1295
1296 case CFAPI_OBJECT_PROP_HEAD:
1297 rv = op->head;
1298 *type = CFAPI_POBJECT;
1299 break;
1300
1301 case CFAPI_OBJECT_PROP_CONTAINER:
1302 rv = op->container;
1303 *type = CFAPI_POBJECT;
1304 break;
1305
1306 case CFAPI_OBJECT_PROP_MAP:
1307 rv = op->map;
1308 *type = CFAPI_PMAP;
1309 break;
1310
1311 case CFAPI_OBJECT_PROP_COUNT:
1312 ri = op->count;
1313 rv = &ri;
1314 *type = CFAPI_INT;
1315 break;
1316
1317 case CFAPI_OBJECT_PROP_REFCOUNT:
1318 abort ();
1319 break;
1320
1321 case CFAPI_OBJECT_PROP_NAME:
1322 rv = query_name (op);
1323 *type = CFAPI_STRING;
1324 break;
1325
1326 case CFAPI_OBJECT_PROP_NAME_PLURAL:
1327 rv = (char *) &op->name_pl;
1328 *type = CFAPI_STRING;
1329 break;
1330
1331 case CFAPI_OBJECT_PROP_TITLE:
1332 rv = (char *) &op->title;
1333 *type = CFAPI_STRING;
1334 break;
1335
1336 case CFAPI_OBJECT_PROP_RACE:
1337 rv = (char *) &op->race;
1338 *type = CFAPI_STRING;
1339 break;
1340
1341 case CFAPI_OBJECT_PROP_SLAYING:
1342 rv = (char *) &op->slaying;
1343 *type = CFAPI_STRING;
1344 break;
1345
1346 case CFAPI_OBJECT_PROP_SKILL:
1347 rv = (char *) &op->skill;
1348 *type = CFAPI_STRING;
1349 break;
1350
1351 case CFAPI_OBJECT_PROP_MESSAGE:
1352 rv = (char *) &op->msg;
1353 if (rv == NULL)
1354 rv = (void *) "";
1355 *type = CFAPI_STRING;
1356 break;
1357
1358 case CFAPI_OBJECT_PROP_LORE:
1359 rv = (char *) &op->lore;
1360 *type = CFAPI_STRING;
1361 break;
1362
1363 case CFAPI_OBJECT_PROP_X:
1364 ri = op->x;
1365 rv = &ri;
1366 *type = CFAPI_INT;
1367 break;
1368
1369 case CFAPI_OBJECT_PROP_Y:
1370 ri = op->y;
1371 rv = &ri;
1372 *type = CFAPI_INT;
1373 break;
1374
1375 case CFAPI_OBJECT_PROP_SPEED:
1376 rv = &op->speed;
1377 *type = CFAPI_DOUBLE;
1378 break;
1379
1380 case CFAPI_OBJECT_PROP_SPEED_LEFT:
1381 rv = &op->speed_left;
1382 *type = CFAPI_DOUBLE;
1383 break;
1384
1385 case CFAPI_OBJECT_PROP_NROF:
1386 ri = op->nrof;
1387 rv = &ri;
1388 *type = CFAPI_INT;
1389 break;
1390
1391 case CFAPI_OBJECT_PROP_DIRECTION:
1392 ri = op->direction;
1393 rv = &ri;
1394 *type = CFAPI_INT;
1395 break;
1396
1397 case CFAPI_OBJECT_PROP_FACING:
1398 ri = op->facing;
1399 rv = &ri;
1400 *type = CFAPI_INT;
1401 break;
1402
1403 case CFAPI_OBJECT_PROP_TYPE:
1404 ri = op->type;
1405 rv = &ri;
1406 *type = CFAPI_INT;
1407 break;
1408
1409 case CFAPI_OBJECT_PROP_SUBTYPE:
1410 ri = op->subtype;
1411 rv = &ri;
1412 *type = CFAPI_INT;
1413 break;
1414
1415 case CFAPI_OBJECT_PROP_CLIENT_TYPE:
1416 ri = op->client_type;
1417 rv = &ri;
1418 *type = CFAPI_INT;
1419 break;
1420
1421 case CFAPI_OBJECT_PROP_RESIST:
1422 {
1423 int idx;
1424 idx = va_arg (args, int);
1425
1426 ri = op->resist[idx];
1427 rv = &ri;
1428 }
1429 *type = CFAPI_INT;
1430 break;
1431
1432 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
1433 ri = op->attacktype;
1434 rv = &ri;
1435 *type = CFAPI_INT;
1436 break;
1437
1438 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
1439 ri = op->path_attuned;
1440 rv = &ri;
1441 *type = CFAPI_INT;
1442 break;
1443
1444 case CFAPI_OBJECT_PROP_PATH_REPELLED:
1445 ri = op->path_repelled;
1446 rv = &ri;
1447 *type = CFAPI_INT;
1448 break;
1449
1450 case CFAPI_OBJECT_PROP_PATH_DENIED:
1451 ri = op->path_denied;
1452 rv = &ri;
1453 *type = CFAPI_INT;
1454 break;
1455
1456 case CFAPI_OBJECT_PROP_MATERIAL:
1457 ri = op->material;
1458 rv = &ri;
1459 *type = CFAPI_INT;
1460 break;
1461
1462 case CFAPI_OBJECT_PROP_MAGIC:
1463 ri = op->magic;
1464 rv = &ri;
1465 *type = CFAPI_INT;
1466 break;
1467
1468 case CFAPI_OBJECT_PROP_VALUE:
1469 ri = op->value;
1470 rv = &ri;
1471 *type = CFAPI_INT;
1472 break;
1473
1474 case CFAPI_OBJECT_PROP_LEVEL:
1475 ri = op->level;
1476 rv = &ri;
1477 *type = CFAPI_INT;
1478 break;
1479
1480 case CFAPI_OBJECT_PROP_LAST_HEAL:
1481 ri = op->last_heal;
1482 rv = &ri;
1483 *type = CFAPI_INT;
1484 break;
1485
1486 case CFAPI_OBJECT_PROP_LAST_SP:
1487 ri = op->last_sp;
1488 rv = &ri;
1489 *type = CFAPI_INT;
1490 break;
1491
1492 case CFAPI_OBJECT_PROP_LAST_GRACE:
1493 ri = op->last_grace;
1494 rv = &ri;
1495 *type = CFAPI_INT;
1496 break;
1497
1498 case CFAPI_OBJECT_PROP_LAST_EAT:
1499 ri = op->last_eat;
1500 rv = &ri;
1501 *type = CFAPI_INT;
1502 break;
1503
1504 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
1505 ri = op->invisible;
1506 rv = &ri;
1507 *type = CFAPI_INT;
1508 break;
1509
1510 case CFAPI_OBJECT_PROP_PICK_UP:
1511 ri = op->pick_up;
1512 rv = &ri;
1513 *type = CFAPI_INT;
1514 break;
1515
1516 case CFAPI_OBJECT_PROP_ITEM_POWER:
1517 ri = op->item_power;
1518 rv = &ri;
1519 *type = CFAPI_INT;
1520 break;
1521
1522 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
1523 ri = op->gen_sp_armour;
1524 rv = &ri;
1525 *type = CFAPI_INT;
1526 break;
1527
1528 case CFAPI_OBJECT_PROP_WEIGHT:
1529 ri = op->weight;
1530 rv = &ri;
1531 *type = CFAPI_INT;
1532 break;
1533
1534 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
1535 ri = op->weight_limit;
1536 rv = &ri;
1537 *type = CFAPI_INT;
1538 break;
1539
1540 case CFAPI_OBJECT_PROP_CARRYING:
1541 ri = op->carrying;
1542 rv = &ri;
1543 *type = CFAPI_INT;
1544 break;
1545
1546 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
1547 ri = op->glow_radius;
1548 rv = &ri;
1549 *type = CFAPI_INT;
1550 break;
1551
1552 case CFAPI_OBJECT_PROP_PERM_EXP:
1553 rv = &op->perm_exp;
1554 *type = CFAPI_LONG;
1555 break;
1556
1557 case CFAPI_OBJECT_PROP_CURRENT_WEAPON:
1558 rv = op->current_weapon;
1559 *type = CFAPI_POBJECT;
1560 break;
1561
1562 case CFAPI_OBJECT_PROP_ENEMY:
1563 rv = op->enemy;
1564 *type = CFAPI_POBJECT;
1565 break;
1566
1567 case CFAPI_OBJECT_PROP_ATTACKED_BY:
1568 rv = op->attacked_by;
1569 *type = CFAPI_POBJECT;
1570 break;
1571
1572 case CFAPI_OBJECT_PROP_RUN_AWAY:
1573 ri = op->run_away;
1574 rv = &ri;
1575 *type = CFAPI_INT;
1576 break;
1577
1578 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
1579 rv = op->chosen_skill;
1580 *type = CFAPI_POBJECT;
1581 break;
1582
1583 case CFAPI_OBJECT_PROP_HIDDEN:
1584 ri = op->hide;
1585 rv = &ri;
1586 *type = CFAPI_INT;
1587 break;
1588
1589 case CFAPI_OBJECT_PROP_MOVE_STATUS:
1590 ri = op->move_status;
1591 rv = &ri;
1592 *type = CFAPI_INT;
1593 break;
1594
1595 case CFAPI_OBJECT_PROP_MOVE_TYPE:
1596 ri = op->attack_movement;
1597 rv = &ri;
1598 *type = CFAPI_INT;
1599 break;
1600
1601 case CFAPI_OBJECT_PROP_SPELL_ITEM:
1602 rv = op->spellitem;
1603 *type = CFAPI_POBJECT;
1604 break;
1605
1606 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
1607 rv = &op->expmul;
1608 *type = CFAPI_DOUBLE;
1609 break;
1610
1611 case CFAPI_OBJECT_PROP_ARCHETYPE:
1612 rv = op->arch;
1613 *type = CFAPI_PARCH;
1614 break;
1615
1616 case CFAPI_OBJECT_PROP_OTHER_ARCH:
1617 rv = op->other_arch;
1618 *type = CFAPI_PARCH;
1619 break;
1620
1621 case CFAPI_OBJECT_PROP_ANIM_SPEED:
1622 ri = op->anim_speed;
1623 rv = &ri;
1624 *type = CFAPI_INT;
1625 break;
1626
1627 case CFAPI_OBJECT_PROP_FRIENDLY:
1628 ri = is_friendly (op);
1629 rv = &ri;
1630 *type = CFAPI_INT;
1631 break;
1632
1633 case CFAPI_OBJECT_PROP_BASE_NAME:
1634 {
1635 int i;
1636 i = va_arg (args, int);
1637
1638 rv = (char *) query_base_name (op, i);
1639 *type = CFAPI_STRING;
1640 }
1641 break;
1642
1643 case CFAPI_OBJECT_PROP_MAGICAL:
1644 ri = is_magical (op);
1645 rv = &ri;
1646 *type = CFAPI_INT;
1647 break;
1648
1649 case CFAPI_OBJECT_PROP_LUCK:
1650 ri = op->stats.luck;
1651 rv = &ri;
1652 *type = CFAPI_INT;
1653 break;
1654
1655 case CFAPI_OBJECT_PROP_EXP:
1656 rv = &op->stats.exp;
1657 *type = CFAPI_LONG;
1658 break;
1659
1660 case CFAPI_OBJECT_PROP_OWNER:
1661 rv = get_owner (op);
1662 *type = CFAPI_POBJECT;
1663 break;
1664
1665 case CFAPI_OBJECT_PROP_PRESENT:
1666 {
1667 int stype;
1668
1669 rv = 0;
1670 stype = va_arg (args, int);
1671
1672 switch (stype)
1673 {
1674
1675 unsigned char ptype;
1676 char *buf;
1677 archetype *at;
1678
1679 case 0: /* present_in_ob */
1680 ptype = (unsigned char) (va_arg (args, int));
1681
1682 rv = present_in_ob (ptype, op);
1683 break;
1684
1685 case 1: /* present_in_ob_by_name */
1686 ptype = (unsigned char) (va_arg (args, int));
1687 buf = va_arg (args, char *);
1688
1689 rv = present_in_ob_by_name (ptype, buf, op);
1690 break;
1691
1692 case 2: /* present_arch_in_ob */
1693 at = va_arg (args, archetype *);
1694
1695 rv = present_arch_in_ob (at, op);
1696 break;
1697 }
1698 }
1699 *type = CFAPI_POBJECT;
1700 break;
1701
1702 case CFAPI_OBJECT_PROP_CHEATER:
1703 ri = (QUERY_FLAG (op, FLAG_WAS_WIZ));
1704 rv = &ri;
1705 *type = CFAPI_INT;
1706 break;
1707
1708 case CFAPI_OBJECT_PROP_MERGEABLE:
1709 {
1710 object *op2;
1711 op2 = va_arg (args, object *);
1712
1713 ri = CAN_MERGE (op, op2);
1714 rv = &ri;
1715 }
1716 *type = CFAPI_INT;
1717 break;
1718
1719 case CFAPI_OBJECT_PROP_PICKABLE:
1720 {
1721 object *op2;
1722
1723 rv = 0;
1724 op2 = va_arg (args, object *);
1725
1726 ri = can_pick (op2, op);
1727 rv = &ri;
1728 }
1729 *type = CFAPI_INT;
1730 break;
1731
1732 case CFAPI_OBJECT_PROP_FLAGS:
1733 {
1734 int fl;
1735
1736 ri = 0;
1737 fl = va_arg (args, int);
1738
1739 ri = QUERY_FLAG (op, fl);
1740 rv = &ri;
1741 }
1742 *type = CFAPI_INT;
1743 break;
1744
1745 case CFAPI_OBJECT_PROP_STR:
1746 ri = op->stats.Str;
1747 rv = &ri;
1748 *type = CFAPI_INT;
1749 break;
1750
1751 case CFAPI_OBJECT_PROP_DEX:
1752 ri = op->stats.Dex;
1753 rv = &ri;
1754 *type = CFAPI_INT;
1755 break;
1756
1757 case CFAPI_OBJECT_PROP_CON:
1758 ri = op->stats.Con;
1759 rv = &ri;
1760 *type = CFAPI_INT;
1761 break;
1762
1763 case CFAPI_OBJECT_PROP_WIS:
1764 ri = op->stats.Wis;
1765 rv = &ri;
1766 *type = CFAPI_INT;
1767 break;
1768
1769 case CFAPI_OBJECT_PROP_INT:
1770 ri = op->stats.Int;
1771 rv = &ri;
1772 *type = CFAPI_INT;
1773 break;
1774
1775 case CFAPI_OBJECT_PROP_POW:
1776 ri = op->stats.Pow;
1777 rv = &ri;
1778 *type = CFAPI_INT;
1779 break;
1780
1781 case CFAPI_OBJECT_PROP_CHA:
1782 ri = op->stats.Cha;
1783 rv = &ri;
1784 *type = CFAPI_INT;
1785 break;
1786
1787 case CFAPI_OBJECT_PROP_WC:
1788 ri = op->stats.wc;
1789 rv = &ri;
1790 *type = CFAPI_INT;
1791 break;
1792
1793 case CFAPI_OBJECT_PROP_AC:
1794 ri = op->stats.ac;
1795 rv = &ri;
1796 *type = CFAPI_INT;
1797 break;
1798
1799 case CFAPI_OBJECT_PROP_HP:
1800 ri = op->stats.hp;
1801 rv = &ri;
1802 *type = CFAPI_INT;
1803 break;
1804
1805 case CFAPI_OBJECT_PROP_SP:
1806 ri = op->stats.sp;
1807 rv = &ri;
1808 *type = CFAPI_INT;
1809 break;
1810
1811 case CFAPI_OBJECT_PROP_GP:
1812 ri = op->stats.grace;
1813 rv = &ri;
1814 *type = CFAPI_INT;
1815 break;
1816
1817 case CFAPI_OBJECT_PROP_FP:
1818 ri = op->stats.food;
1819 rv = &ri;
1820 *type = CFAPI_INT;
1821 break;
1822
1823 case CFAPI_OBJECT_PROP_MAXHP:
1824 ri = op->stats.maxhp;
1825 rv = &ri;
1826 *type = CFAPI_INT;
1827 break;
1828
1829 case CFAPI_OBJECT_PROP_MAXSP:
1830 ri = op->stats.maxsp;
1831 rv = &ri;
1832 *type = CFAPI_INT;
1833 break;
1834
1835 case CFAPI_OBJECT_PROP_MAXGP:
1836 ri = op->stats.maxgrace;
1837 rv = &ri;
1838 *type = CFAPI_INT;
1839 break;
1840
1841 case CFAPI_OBJECT_PROP_DAM:
1842 ri = op->stats.dam;
1843 rv = &ri;
1844 *type = CFAPI_INT;
1845 break;
1846
1847 case CFAPI_OBJECT_PROP_GOD:
1848 rv = (char *) determine_god (op);
1849 *type = CFAPI_STRING;
1850 break;
1851
1852 case CFAPI_OBJECT_PROP_ARCH_NAME:
1853 rv = (char *) &op->arch->name;
1854 *type = CFAPI_STRING;
1855 break;
1856
1857 case CFAPI_OBJECT_PROP_INVISIBLE:
1858 ri = op->invisible;
1859 rv = &ri;
1860 *type = CFAPI_INT;
1861 break;
1862
1863 case CFAPI_OBJECT_PROP_FACE:
1864 ri = op->animation_id;
1865 rv = &ri;
1866 *type = CFAPI_INT;
1867 break;
1868
1869 case CFAPI_PLAYER_PROP_IP:
1870 rv = op->contr->socket.host;
1871 *type = CFAPI_STRING;
1872 break;
1873
1874 case CFAPI_PLAYER_PROP_MARKED_ITEM:
1875 rv = find_marked_object (op);
1876 *type = CFAPI_POBJECT;
1877 break;
1878
1879 case CFAPI_PLAYER_PROP_PARTY:
1880 rv = (op->contr ? op->contr->party : NULL);
1881 *type = CFAPI_PPARTY;
1882 break;
1883 default:
1884 *type = CFAPI_NONE;
1885 break;
1886 }
1887 }
1888 va_end (args);
1889 return rv;
1890} 845}
1891 846
1892void * 847void *
1893cfapi_object_set_property (int *type, ...) 848cfapi_object_set_property (int *type, ...)
1894{ 849{
1895 va_list args; 850 abort ();
1896 int iarg;
1897 long larg;
1898 char *sarg;
1899 double darg;
1900 object *oparg;
1901 object *op;
1902 int property;
1903 void *rv;
1904 partylist *partyarg;
1905
1906 va_start (args, type);
1907
1908 op = va_arg (args, object *);
1909 property = va_arg (args, int);
1910
1911 rv = NULL;
1912
1913 if (op != NULL && (!op->arch || (op != &op->arch->clone)))
1914 {
1915 switch (property)
1916 {
1917 case CFAPI_OBJECT_PROP_NAME:
1918 sarg = va_arg (args, char *);
1919
1920#define FREE_AND_COPY(a,b) (a) = (b) // TODO: remove, but plugins.C is considered zombie code
1921 FREE_AND_COPY (op->name, sarg);
1922 send_changed_object (op);
1923 break;
1924
1925 case CFAPI_OBJECT_PROP_NAME_PLURAL:
1926 sarg = va_arg (args, char *);
1927
1928 FREE_AND_COPY (op->name_pl, sarg);
1929 send_changed_object (op);
1930 break;
1931
1932 case CFAPI_OBJECT_PROP_TITLE:
1933 sarg = va_arg (args, char *);
1934
1935 FREE_AND_COPY (op->title, sarg);
1936 break;
1937
1938 case CFAPI_OBJECT_PROP_RACE:
1939 sarg = va_arg (args, char *);
1940
1941 FREE_AND_COPY (op->race, sarg);
1942 break;
1943
1944 case CFAPI_OBJECT_PROP_SLAYING:
1945 sarg = va_arg (args, char *);
1946
1947 FREE_AND_COPY (op->slaying, sarg);
1948 break;
1949
1950 case CFAPI_OBJECT_PROP_SKILL:
1951 sarg = va_arg (args, char *);
1952
1953 FREE_AND_COPY (op->skill, sarg);
1954 break;
1955
1956 case CFAPI_OBJECT_PROP_MESSAGE:
1957 sarg = va_arg (args, char *);
1958
1959 FREE_AND_COPY (op->msg, sarg);
1960 break;
1961
1962 case CFAPI_OBJECT_PROP_LORE:
1963 sarg = va_arg (args, char *);
1964
1965 FREE_AND_COPY (op->lore, sarg);
1966 break;
1967
1968 case CFAPI_OBJECT_PROP_SPEED:
1969 darg = va_arg (args, double);
1970
1971 op->speed = darg;
1972 break;
1973
1974 case CFAPI_OBJECT_PROP_SPEED_LEFT:
1975 darg = va_arg (args, double);
1976
1977 op->speed_left = darg;
1978 break;
1979
1980 case CFAPI_OBJECT_PROP_NROF:
1981 iarg = va_arg (args, int);
1982
1983 if (iarg < 0)
1984 iarg = 0;
1985 if (op->nrof > (uint32) iarg)
1986 decrease_ob_nr (op, op->nrof - iarg);
1987 else if (op->nrof < (uint32) iarg)
1988 {
1989 object *tmp;
1990 player *pl;
1991
1992 op->nrof = iarg;
1993 if (op->env != NULL)
1994 {
1995 tmp = is_player_inv (op->env);
1996 if (!tmp)
1997 {
1998 for (pl = first_player; pl; pl = pl->next)
1999 if (pl->ob->container == op->env)
2000 break;
2001 if (pl)
2002 tmp = pl->ob;
2003 else
2004 tmp = NULL;
2005 }
2006 else
2007 {
2008 sum_weight (tmp);
2009 fix_player (tmp);
2010 }
2011 if (tmp)
2012 esrv_send_item (tmp, op);
2013 }
2014 else
2015 {
2016 object *above = op->above;
2017
2018 for (tmp = above; tmp != NULL; tmp = tmp->above)
2019 if (tmp->type == PLAYER)
2020 esrv_send_item (tmp, op);
2021 }
2022 }
2023 break;
2024
2025 case CFAPI_OBJECT_PROP_DIRECTION:
2026 iarg = va_arg (args, int);
2027
2028 op->direction = iarg;
2029 break;
2030
2031 case CFAPI_OBJECT_PROP_FACING:
2032 iarg = va_arg (args, int);
2033
2034 op->facing = iarg;
2035 break;
2036
2037 case CFAPI_OBJECT_PROP_RESIST:
2038 {
2039 int iargbis = va_arg (args, int);
2040 iarg = va_arg (args, int);
2041
2042 op->resist[iargbis] = iarg;
2043 }
2044 break;
2045
2046 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
2047 iarg = va_arg (args, int);
2048
2049 op->attacktype = iarg;
2050 break;
2051
2052 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
2053 iarg = va_arg (args, int);
2054
2055 op->path_attuned = iarg;
2056 break;
2057
2058 case CFAPI_OBJECT_PROP_PATH_REPELLED:
2059 iarg = va_arg (args, int);
2060
2061 op->path_repelled = iarg;
2062 break;
2063
2064 case CFAPI_OBJECT_PROP_PATH_DENIED:
2065 iarg = va_arg (args, int);
2066
2067 op->path_denied = iarg;
2068 break;
2069
2070 case CFAPI_OBJECT_PROP_MATERIAL:
2071 iarg = va_arg (args, int);
2072
2073 op->material = iarg;
2074 break;
2075
2076 case CFAPI_OBJECT_PROP_MATERIAL_NAME:
2077 break;
2078
2079 case CFAPI_OBJECT_PROP_MAGIC:
2080 iarg = va_arg (args, int);
2081
2082 op->magic = iarg;
2083 break;
2084
2085 case CFAPI_OBJECT_PROP_VALUE:
2086 iarg = va_arg (args, int);
2087
2088 op->value = iarg;
2089 break;
2090
2091 case CFAPI_OBJECT_PROP_LEVEL:
2092 iarg = va_arg (args, int);
2093
2094 op->level = iarg;
2095 break;
2096
2097 case CFAPI_OBJECT_PROP_LAST_HEAL:
2098 iarg = va_arg (args, int);
2099
2100 op->last_heal = iarg;
2101 break;
2102
2103 case CFAPI_OBJECT_PROP_LAST_SP:
2104 iarg = va_arg (args, int);
2105
2106 op->last_sp = iarg;
2107 break;
2108
2109 case CFAPI_OBJECT_PROP_LAST_GRACE:
2110 iarg = va_arg (args, int);
2111
2112 op->last_grace = iarg;
2113 break;
2114
2115 case CFAPI_OBJECT_PROP_LAST_EAT:
2116 iarg = va_arg (args, int);
2117
2118 op->last_eat = iarg;
2119 break;
2120
2121 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
2122 iarg = va_arg (args, int);
2123
2124 op->invisible = iarg;
2125 break;
2126
2127 case CFAPI_OBJECT_PROP_PICK_UP:
2128 iarg = va_arg (args, int);
2129
2130 op->pick_up = iarg;
2131 break;
2132
2133 case CFAPI_OBJECT_PROP_ITEM_POWER:
2134 iarg = va_arg (args, int);
2135
2136 op->item_power = iarg;
2137 break;
2138
2139 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
2140 iarg = va_arg (args, int);
2141
2142 op->gen_sp_armour = iarg;
2143 break;
2144
2145 case CFAPI_OBJECT_PROP_WEIGHT:
2146 iarg = va_arg (args, int);
2147
2148 if (op->weight != iarg)
2149 {
2150 object *tmp;
2151 player *pl;
2152
2153 op->weight = iarg;
2154 if (op->env != NULL)
2155 {
2156 tmp = is_player_inv (op->env);
2157 if (!tmp)
2158 {
2159 for (pl = first_player; pl; pl = pl->next)
2160 if (pl->ob->container == op->env)
2161 break;
2162 if (pl)
2163 tmp = pl->ob;
2164 else
2165 tmp = NULL;
2166 }
2167 else
2168 {
2169 sum_weight (tmp);
2170 fix_player (tmp);
2171 }
2172 if (tmp)
2173 esrv_send_item (tmp, op);
2174 }
2175 else
2176 {
2177 object *above = op->above;
2178
2179 for (tmp = above; tmp != NULL; tmp = tmp->above)
2180 if (tmp->type == PLAYER)
2181 esrv_send_item (tmp, op);
2182 }
2183 }
2184 break;
2185
2186 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
2187 iarg = va_arg (args, int);
2188
2189 op->weight_limit = iarg;
2190 break;
2191
2192 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
2193 iarg = va_arg (args, int);
2194
2195 op->glow_radius = iarg;
2196 break;
2197
2198 case CFAPI_OBJECT_PROP_PERM_EXP:
2199 larg = va_arg (args, long);
2200
2201 op->perm_exp = larg;
2202 break;
2203
2204 case CFAPI_OBJECT_PROP_ENEMY:
2205 oparg = va_arg (args, object *);
2206
2207 op->enemy = oparg;
2208 break;
2209
2210 case CFAPI_OBJECT_PROP_RUN_AWAY:
2211 iarg = va_arg (args, int);
2212
2213 op->run_away = iarg;
2214 break;
2215
2216 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
2217 oparg = va_arg (args, object *);
2218
2219 op->chosen_skill = oparg;
2220 break;
2221
2222 case CFAPI_OBJECT_PROP_HIDDEN:
2223 iarg = va_arg (args, int);
2224
2225 op->hide = iarg;
2226 break;
2227
2228 case CFAPI_OBJECT_PROP_MOVE_STATUS:
2229 iarg = va_arg (args, int);
2230
2231 op->move_status = iarg;
2232 break;
2233
2234 case CFAPI_OBJECT_PROP_MOVE_TYPE:
2235 iarg = va_arg (args, int);
2236
2237 op->attack_movement = iarg;
2238 break;
2239
2240 case CFAPI_OBJECT_PROP_SPELL_ITEM:
2241 oparg = va_arg (args, object *);
2242
2243 op->spellitem = oparg;
2244 break;
2245
2246 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
2247 darg = va_arg (args, double);
2248
2249 op->expmul = darg;
2250 break;
2251
2252 case CFAPI_OBJECT_PROP_CUSTOM_NAME:
2253 sarg = va_arg (args, char *);
2254
2255 FREE_AND_COPY (op->custom_name, sarg);
2256 send_changed_object (op);
2257 break;
2258
2259 case CFAPI_OBJECT_PROP_ANIM_SPEED:
2260 iarg = va_arg (args, int);
2261
2262 op->anim_speed = iarg;
2263 break;
2264
2265 case CFAPI_OBJECT_PROP_FRIENDLY:
2266 iarg = va_arg (args, int);
2267
2268 if (iarg == 1 && is_friendly (op) == 0)
2269 add_friendly_object (op);
2270 else if (iarg == 0 && is_friendly (op) == 1)
2271 remove_friendly_object (op);
2272 break;
2273
2274 case CFAPI_OBJECT_PROP_LUCK:
2275 iarg = va_arg (args, int);
2276
2277 op->stats.luck = iarg;
2278 break;
2279
2280 case CFAPI_OBJECT_PROP_EXP:
2281 {
2282 char *skillname;
2283
2284 larg = va_arg (args, long);
2285 skillname = va_arg (args, char *);
2286 iarg = va_arg (args, int);
2287
2288 change_exp (op, larg, skillname, iarg);
2289 }
2290 break;
2291
2292 case CFAPI_OBJECT_PROP_OWNER:
2293 oparg = va_arg (args, object *);
2294
2295 set_owner (op, oparg);
2296 break;
2297
2298 case CFAPI_OBJECT_PROP_CHEATER:
2299 set_cheat (op);
2300 break;
2301
2302 case CFAPI_OBJECT_PROP_FLAGS:
2303 {
2304 int iargbis;
2305 iarg = va_arg (args, int);
2306 iargbis = va_arg (args, int);
2307
2308 if (iargbis == 1)
2309 SET_FLAG (op, iarg);
2310 else
2311 CLEAR_FLAG (op, iarg);
2312 }
2313 break;
2314
2315 case CFAPI_OBJECT_PROP_STR:
2316 iarg = va_arg (args, int);
2317
2318 op->stats.Str = iarg;
2319 break;
2320
2321 case CFAPI_OBJECT_PROP_DEX:
2322 iarg = va_arg (args, int);
2323
2324 op->stats.Dex = iarg;
2325 break;
2326
2327 case CFAPI_OBJECT_PROP_CON:
2328 iarg = va_arg (args, int);
2329
2330 op->stats.Con = iarg;
2331 break;
2332
2333 case CFAPI_OBJECT_PROP_WIS:
2334 iarg = va_arg (args, int);
2335
2336 op->stats.Wis = iarg;
2337 break;
2338
2339 case CFAPI_OBJECT_PROP_INT:
2340 iarg = va_arg (args, int);
2341
2342 op->stats.Int = iarg;
2343 break;
2344
2345 case CFAPI_OBJECT_PROP_POW:
2346 iarg = va_arg (args, int);
2347
2348 op->stats.Pow = iarg;
2349 break;
2350
2351 case CFAPI_OBJECT_PROP_CHA:
2352 iarg = va_arg (args, int);
2353
2354 op->stats.Cha = iarg;
2355 break;
2356
2357 case CFAPI_OBJECT_PROP_WC:
2358 iarg = va_arg (args, int);
2359
2360 op->stats.wc = iarg;
2361 break;
2362
2363 case CFAPI_OBJECT_PROP_AC:
2364 iarg = va_arg (args, int);
2365
2366 op->stats.ac = iarg;
2367 break;
2368
2369 case CFAPI_OBJECT_PROP_HP:
2370 iarg = va_arg (args, int);
2371
2372 op->stats.hp = iarg;
2373 break;
2374
2375 case CFAPI_OBJECT_PROP_SP:
2376 iarg = va_arg (args, int);
2377
2378 op->stats.sp = iarg;
2379 break;
2380
2381 case CFAPI_OBJECT_PROP_GP:
2382 iarg = va_arg (args, int);
2383
2384 op->stats.grace = iarg;
2385 break;
2386
2387 case CFAPI_OBJECT_PROP_FP:
2388 iarg = va_arg (args, int);
2389
2390 op->stats.food = iarg;
2391 break;
2392
2393 case CFAPI_OBJECT_PROP_MAXHP:
2394 iarg = va_arg (args, int);
2395
2396 op->stats.maxhp = iarg;
2397 break;
2398
2399 case CFAPI_OBJECT_PROP_MAXSP:
2400 iarg = va_arg (args, int);
2401
2402 op->stats.maxsp = iarg;
2403 break;
2404
2405 case CFAPI_OBJECT_PROP_MAXGP:
2406 iarg = va_arg (args, int);
2407
2408 op->stats.maxgrace = iarg;
2409 break;
2410
2411 case CFAPI_OBJECT_PROP_DAM:
2412 iarg = va_arg (args, int);
2413
2414 op->stats.dam = iarg;
2415 break;
2416
2417 case CFAPI_OBJECT_PROP_FACE:
2418 iarg = va_arg (args, int);
2419
2420 op->animation_id = iarg;
2421 update_object (op, UP_OBJ_FACE);
2422 break;
2423
2424 case CFAPI_OBJECT_ANIMATION:
2425 iarg = va_arg (args, int);
2426
2427 if (iarg != -1)
2428 {
2429 SET_ANIMATION (op, iarg);
2430 }
2431 update_object (op, UP_OBJ_FACE);
2432 break;
2433
2434 case CFAPI_PLAYER_PROP_MARKED_ITEM:
2435 if (op->contr)
2436 {
2437 oparg = va_arg (args, object *);
2438
2439 op->contr->mark = oparg;
2440 }
2441 break;
2442
2443 case CFAPI_PLAYER_PROP_PARTY:
2444 if (op->contr)
2445 {
2446 partyarg = va_arg (args, partylist *);
2447
2448 op->contr->party = partyarg;
2449 }
2450 break;
2451
2452 default:
2453 *type = CFAPI_NONE;
2454 break;
2455 }
2456 }
2457 va_end (args);
2458
2459 *type = CFAPI_NONE;
2460 return NULL;
2461} 851}
2462 852
2463void * 853void *
2464cfapi_object_apply_below (int *type, ...) 854cfapi_object_apply_below (int *type, ...)
2465{ 855{
… …
2535} 925}
2536 926
2537void * 927void *
2538cfapi_object_drain (int *type, ...) 928cfapi_object_drain (int *type, ...)
2539{ 929{
2540 va_list args; 930 abort ();
2541
2542 object *op;
2543 int ds;
2544
2545 va_start (args, type);
2546
2547 op = va_arg (args, object *);
2548 ds = va_arg (args, int);
2549
2550 va_end (args);
2551
2552 drain_specific_stat (op, ds);
2553
2554 *type = CFAPI_NONE;
2555 return NULL;
2556} 931}
2557 932
2558void * 933void *
2559cfapi_object_fix (int *type, ...) 934cfapi_object_fix (int *type, ...)
2560{ 935{
… …
2565 940
2566 op = va_arg (args, object *); 941 op = va_arg (args, object *);
2567 942
2568 va_end (args); 943 va_end (args);
2569 944
2570 fix_player (op); 945 op->update_stats ();
2571 946
2572 *type = CFAPI_NONE; 947 *type = CFAPI_NONE;
2573 return NULL; 948 return NULL;
2574} 949}
2575 950
… …
2623 op = va_arg (args, object *); 998 op = va_arg (args, object *);
2624 999
2625 va_end (args); 1000 va_end (args);
2626 1001
2627 send_removed_object (op); 1002 send_removed_object (op);
2628 remove_ob (op); 1003 op->remove ();
2629 *type = CFAPI_NONE; 1004 *type = CFAPI_NONE;
2630 return NULL; 1005 return NULL;
2631} 1006}
2632 1007
2633void * 1008void *
… …
2640 1015
2641 op = va_arg (args, object *); 1016 op = va_arg (args, object *);
2642 1017
2643 va_end (args); 1018 va_end (args);
2644 1019
2645 free_object (op); 1020 op->destroy ();
2646 1021
2647 *type = CFAPI_NONE; 1022 *type = CFAPI_NONE;
2648 return NULL; 1023 return NULL;
2649} 1024}
2650 1025
… …
2667 *type = CFAPI_POBJECT; 1042 *type = CFAPI_POBJECT;
2668 return object_create_clone (op); 1043 return object_create_clone (op);
2669 } 1044 }
2670 else 1045 else
2671 { 1046 {
2672 object *tmp; 1047 object *tmp = op->clone ();
2673
2674 tmp = get_object ();
2675 copy_object (op, tmp);
2676 *type = CFAPI_POBJECT; 1048 *type = CFAPI_POBJECT;
2677 return tmp; 1049 return tmp;
2678 } 1050 }
2679} 1051}
2680void * 1052void *
… …
2716 break; 1088 break;
2717 1089
2718 case 3: 1090 case 3:
2719 op = va_arg (args, object *); 1091 op = va_arg (args, object *);
2720 1092
2721 rv = is_player_inv (op); 1093 rv = op->in_player ();
2722 break; 1094 break;
2723 1095
2724 default: 1096 default:
2725 rv = NULL; 1097 rv = NULL;
2726 *type = CFAPI_NONE; 1098 *type = CFAPI_NONE;
… …
2744 *type = CFAPI_POBJECT; 1116 *type = CFAPI_POBJECT;
2745 switch (ival) 1117 switch (ival)
2746 { 1118 {
2747 case 0: 1119 case 0:
2748 va_end (args); 1120 va_end (args);
2749 return get_object (); 1121 return object::create ();
2750 break; 1122 break;
2751 1123
2752 case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */ 1124 case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */
2753 { 1125 {
2754 char *sval; 1126 char *sval;
… …
2757 1129
2758 op = get_archetype_by_object_name (sval); 1130 op = get_archetype_by_object_name (sval);
2759 1131
2760 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) 1132 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
2761 { 1133 {
2762 free_object (op); 1134 op->destroy ();
2763 /* Try with archetype names... */ 1135 /* Try with archetype names... */
2764 op = get_archetype (sval); 1136 op = get_archetype (sval);
2765 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) 1137 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
2766 { 1138 {
2767 free_object (op); 1139 op->destroy ();
2768 *type = CFAPI_NONE; 1140 *type = CFAPI_NONE;
2769 va_end (args); 1141 va_end (args);
2770 return NULL; 1142 return NULL;
2771 } 1143 }
2772 } 1144 }
… …
2922} 1294}
2923 1295
2924void * 1296void *
2925cfapi_object_clear (int *type, ...) 1297cfapi_object_clear (int *type, ...)
2926{ 1298{
2927 va_list args; 1299 abort ();
2928 object *op;
2929
2930 va_start (args, type);
2931
2932 op = va_arg (args, object *);
2933
2934 va_end (args);
2935
2936 clear_object (op);
2937 *type = CFAPI_NONE;
2938 return NULL;
2939} 1300}
2940 1301
2941void * 1302void *
2942cfapi_object_reset (int *type, ...) 1303cfapi_object_reset (int *type, ...)
2943{ 1304{
… …
2976} 1337}
2977 1338
2978void * 1339void *
2979cfapi_object_clean_object (int *type, ...) 1340cfapi_object_clean_object (int *type, ...)
2980{ 1341{
2981 va_list args; 1342 abort ();
2982 object *op;
2983
2984 va_start (args, type);
2985 op = va_arg (args, object *);
2986
2987 clean_object (op);
2988 va_end (args);
2989 *type = CFAPI_NONE;
2990 return NULL;
2991} 1343}
2992 1344
2993void * 1345void *
2994cfapi_object_on_same_map (int *type, ...) 1346cfapi_object_on_same_map (int *type, ...)
2995{ 1347{
… …
3241 x = map->enter_x; 1593 x = map->enter_x;
3242 y = map->enter_y; 1594 y = map->enter_y;
3243 } 1595 }
3244 1596
3245/* 1597/*
3246 originator = get_object(); 1598 originator = object::create();
3247 EXIT_PATH(originator) = add_string(map->path); 1599 EXIT_PATH(originator) = map->path;
3248 EXIT_X(originator) = x; 1600 EXIT_X(originator) = x;
3249 EXIT_Y(originator) = y; 1601 EXIT_Y(originator) = y;
3250 printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/ 1602 printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/
3251 /*enter_exit(op, originator); */ 1603 /*enter_exit(op, originator); */
3252 insert_ob_in_map_at (op, map, NULL, 0, x, y); 1604 insert_ob_in_map_at (op, map, NULL, 0, x, y);
3253 /*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name); 1605 /*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name);
3254 free_object(originator); 1606 originator->destroy ();
3255 */ 1607 */
3256 *type = CFAPI_INT; 1608 *type = CFAPI_INT;
3257 return &rv; 1609 return &rv;
3258 break; 1610 break;
3259 1611
… …
3332 drop (author, op); 1684 drop (author, op);
3333 1685
3334 if (author->type == PLAYER) 1686 if (author->type == PLAYER)
3335 { 1687 {
3336 author->contr->count = 0; 1688 author->contr->count = 0;
3337 author->contr->socket.update_look = 1; 1689 author->contr->ns->floorbox_update ();
3338 } 1690 }
3339 1691
3340 *type = CFAPI_NONE; 1692 *type = CFAPI_NONE;
3341 return NULL; 1693 return NULL;
3342} 1694}
… …
3373 1725
3374/* PLAYER SUBCLASS */ 1726/* PLAYER SUBCLASS */
3375void * 1727void *
3376cfapi_player_find (int *type, ...) 1728cfapi_player_find (int *type, ...)
3377{ 1729{
3378 va_list args; 1730 abort ();
3379 void *rv;
3380 char *sval;
3381
3382 va_start (args, type);
3383
3384 sval = va_arg (args, char *);
3385
3386 va_end (args);
3387
3388 rv = find_player (sval);
3389
3390 *type = CFAPI_PPLAYER;
3391 return rv;
3392} 1731}
3393 1732
3394void * 1733void *
3395cfapi_player_message (int *type, ...) 1734cfapi_player_message (int *type, ...)
3396{ 1735{
… …
3448 result = 1; 1787 result = 1;
3449 return &result; 1788 return &result;
3450 } 1789 }
3451 1790
3452 send_removed_object (who); 1791 send_removed_object (who);
3453 remove_ob (who); 1792 who->remove ();
3454 1793
3455 for (tmp = who; tmp != NULL; tmp = tmp->more) 1794 for (tmp = who; tmp != NULL; tmp = tmp->more)
3456 tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x), 1795 tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x),
3457 tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y); 1796 tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);
3458 1797
… …
3543 1882
3544/* Party-related functions */ 1883/* Party-related functions */
3545void * 1884void *
3546cfapi_party_get_property (int *type, ...) 1885cfapi_party_get_property (int *type, ...)
3547{ 1886{
3548 partylist *party; 1887 abort ();
3549 int prop;
3550 va_list args;
3551 void *rv;
3552 object *obarg;
3553 player *pl;
3554
3555 va_start (args, type);
3556 party = va_arg (args, partylist *);
3557 prop = va_arg (args, int);
3558
3559 switch (prop)
3560 {
3561 case CFAPI_PARTY_PROP_NAME:
3562 *type = CFAPI_STRING;
3563 rv = (void *) party->partyname;
3564 break;
3565
3566 case CFAPI_PARTY_PROP_NEXT:
3567 *type = CFAPI_PPARTY;
3568 rv = (party ? party->next : get_firstparty ());
3569 break;
3570
3571 case CFAPI_PARTY_PROP_PASSWORD:
3572 *type = CFAPI_STRING;
3573 rv = (void *) party->passwd;
3574 break;
3575
3576 case CFAPI_PARTY_PROP_PLAYER:
3577 *type = CFAPI_PPLAYER;
3578 obarg = va_arg (args, object *);
3579
3580 pl = (obarg ? obarg->contr : first_player);
3581 rv = NULL;
3582 for (; pl != NULL; pl = pl->next)
3583 if (pl->ob->contr->party == party)
3584 {
3585 rv = (void *) pl;
3586 break;
3587 }
3588 break;
3589
3590 default:
3591 *type = CFAPI_NONE;
3592 rv = NULL;
3593 break;
3594 }
3595 va_end (args);
3596 return rv;
3597} 1888}
3598 1889
3599/* Regions-related functions */ 1890/* Regions-related functions */
3600void * 1891void *
3601cfapi_region_get_property (int *type, ...) 1892cfapi_region_get_property (int *type, ...)
3602{ 1893{
3603 region *reg; 1894 abort ();
3604 int prop;
3605 va_list args;
3606 void *rv;
3607
3608 va_start (args, type);
3609 reg = va_arg (args, region *);
3610 prop = va_arg (args, int);
3611
3612 switch (prop)
3613 {
3614 case CFAPI_REGION_PROP_NAME:
3615 *type = CFAPI_STRING;
3616 rv = (void *) reg->name;
3617 break;
3618
3619 case CFAPI_REGION_PROP_NEXT:
3620 *type = CFAPI_PREGION;
3621 rv = (reg ? reg->next : first_region);
3622 break;
3623
3624 case CFAPI_REGION_PROP_PARENT:
3625 *type = CFAPI_PREGION;
3626 rv = (void *) reg->parent;
3627 break;
3628
3629 case CFAPI_REGION_PROP_LONGNAME:
3630 *type = CFAPI_STRING;
3631 rv = (void *) reg->longname;
3632 break;
3633
3634 case CFAPI_REGION_PROP_MESSAGE:
3635 *type = CFAPI_STRING;
3636 rv = (void *) reg->msg;
3637 break;
3638
3639 default:
3640 *type = CFAPI_NONE;
3641 rv = NULL;
3642 break;
3643 }
3644 va_end (args);
3645 return rv;
3646} 1895}
3647 1896
3648/*****************************************************************************/ 1897/*****************************************************************************/
3649 1898
3650/* NEW PLUGIN STUFF ENDS HERE */ 1899/* NEW PLUGIN STUFF ENDS HERE */
… …
3680 return NULL; 1929 return NULL;
3681} 1930}
3682 1931
3683/*****************************************************************************/ 1932/*****************************************************************************/
3684 1933
3685/* Plugins initialization. Browses the plugins directory and call */ 1934/* Plugins initialisation. Browses the plugins directory and call */
3686 1935
3687/* initOnePlugin for each file found. */ 1936/* initOnePlugin for each file found. */
3688 1937
3689/* Returns 0 if at least one plugin was successfully loaded, -1 if not */ 1938/* Returns 0 if at least one plugin was successfully loaded, -1 if not */
3690 1939
… …
3697 size_t l; 1946 size_t l;
3698 char buf[MAX_BUF]; 1947 char buf[MAX_BUF];
3699 char buf2[MAX_BUF]; 1948 char buf2[MAX_BUF];
3700 int result; 1949 int result;
3701 1950
3702 LOG (llevInfo, "Initializing plugins\n"); 1951 LOG (llevInfo, "Initialising plugins\n");
3703 strcpy (buf, LIBDIR); 1952 strcpy (buf, LIBDIR);
3704 strcat (buf, "/plugins/"); 1953 strcat (buf, "/plugins/");
3705 LOG (llevInfo, "Plugins directory is %s\n", buf); 1954 LOG (llevInfo, "Plugins directory is %s\n", buf);
3706 1955
3707 plugins_init_perl (); 1956 plugins_init_perl ();

Diff Legend

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