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.16 by root, Sat Sep 16 22:24:13 2006 UTC vs.
Revision 1.42 by root, Mon Feb 5 01:47:23 2007 UTC

… …
42 42
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 {cfapi_system_re_cmp, 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{
… …
575 *type = CFAPI_INT; 555 *type = CFAPI_INT;
576 return &rv; 556 return &rv;
577} 557}
578 558
579void * 559void *
580cfapi_system_re_cmp (int *type, ...)
581{
582 va_list args;
583 char *rv;
584 const char *str;
585 const char *regexp;
586
587 va_start (args, type);
588
589 str = va_arg (args, char *);
590 regexp = va_arg (args, char *);
591
592 rv = (char *) re_cmp (str, regexp);
593
594 va_end (args);
595 *type = CFAPI_STRING;
596 return rv;
597}
598
599void *
600cfapi_system_directory (int *type, ...) 560cfapi_system_directory (int *type, ...)
601{ 561{
602 va_list args; 562 va_list args;
603 int dirtype; 563 int dirtype;
604 564
… …
649/* MAP RELATED HOOKS */ 609/* MAP RELATED HOOKS */
650 610
651void * 611void *
652cfapi_map_get_map (int *type, ...) 612cfapi_map_get_map (int *type, ...)
653{ 613{
654 va_list args; 614 abort ();
655 maptile *rv;
656 int ctype;
657 int x, y;
658 sint16 nx, ny;
659 char *name;
660 maptile *m;
661
662 va_start (args, type);
663
664 ctype = va_arg (args, int);
665
666 switch (ctype)
667 {
668 case 0:
669 x = va_arg (args, int);
670 y = va_arg (args, int);
671
672 rv = get_empty_map (x, y);
673 break;
674
675 case 1:
676 name = va_arg (args, char *);
677 x = va_arg (args, int);
678
679 rv = ready_map_name (name, x);
680 break;
681
682 case 2:
683 m = va_arg (args, maptile *);
684 nx = va_arg (args, int);
685 ny = va_arg (args, int);
686
687 rv = get_map_from_coord (m, &nx, &ny);
688 break;
689
690 case 3:
691 rv = first_map;
692 break;
693
694 default:
695 *type = CFAPI_NONE;
696 va_end (args);
697 return NULL;
698 break;
699 }
700 va_end (args);
701 *type = CFAPI_PMAP;
702 return rv;
703} 615}
704 616
705void * 617void *
706cfapi_map_has_been_loaded (int *type, ...) 618cfapi_map_has_been_loaded (int *type, ...)
707{ 619{
708 va_list args; 620 abort ();
709 maptile *map;
710 char *string;
711
712 va_start (args, type);
713 string = va_arg (args, char *);
714
715 map = has_been_loaded (string);
716 va_end (args);
717 *type = CFAPI_PMAP;
718 return map;
719} 621}
720 622
721void * 623void *
722cfapi_map_create_path (int *type, ...) 624cfapi_map_create_path (int *type, ...)
723{ 625{
724 va_list args; 626 abort ();
725 int ctype;
726 const char *str;
727 char *rv;
728
729 va_start (args, type);
730
731 ctype = va_arg (args, int);
732 str = va_arg (args, char *);
733
734 *type = CFAPI_STRING;
735
736 switch (ctype)
737 {
738 case 0:
739 rv = (char *) create_pathname (str);
740 break;
741
742 case 1:
743 rv = (char *) create_overlay_pathname (str);
744 break;
745
746 /*case 2:
747 rv = create_items_path(str);
748 break; */
749
750 default:
751 rv = NULL;
752 *type = CFAPI_NONE;
753 break;
754 }
755 va_end (args);
756 return rv;
757} 627}
758 628
759void * 629void *
760cfapi_map_get_map_property (int *type, ...) 630cfapi_map_get_map_property (int *type, ...)
761{ 631{
762 va_list args; 632 abort ();
763 int x, y;
764 sint16 nx, ny;
765 maptile *map;
766 maptile *newmap;
767 static int rv;
768 int property;
769 char *buf;
770
771 va_start (args, type);
772
773 property = va_arg (args, int);
774
775 switch (property)
776 {
777 case CFAPI_MAP_PROP_FLAGS:
778 map = va_arg (args, maptile *);
779 newmap = va_arg (args, maptile *);
780 x = va_arg (args, int);
781 y = va_arg (args, int);
782 nx = va_arg (args, int);
783 ny = va_arg (args, int);
784
785 rv = get_map_flags (map, &newmap, x, y, &nx, &ny);
786 va_end (args);
787 *type = CFAPI_INT;
788 return &rv;
789 break;
790
791 case CFAPI_MAP_PROP_DIFFICULTY:
792 map = va_arg (args, maptile *);
793
794 rv = calculate_difficulty (map);
795 va_end (args);
796 *type = CFAPI_INT;
797 return &rv;
798 break;
799
800 case CFAPI_MAP_PROP_PATH:
801 map = va_arg (args, maptile *);
802
803 buf = map->path;
804 *type = CFAPI_STRING;
805 va_end (args);
806 return buf;
807 break;
808
809 case CFAPI_MAP_PROP_TMPNAME:
810 map = va_arg (args, maptile *);
811
812 buf = map->tmpname;
813 *type = CFAPI_STRING;
814 va_end (args);
815 return buf;
816 break;
817
818 case CFAPI_MAP_PROP_NAME:
819 map = va_arg (args, maptile *);
820
821 buf = map->name;
822 *type = CFAPI_STRING;
823 va_end (args);
824 return buf;
825 break;
826
827 case CFAPI_MAP_PROP_RESET_TIME:
828 map = va_arg (args, maptile *);
829
830 rv = map->reset_time;
831 *type = CFAPI_INT;
832 va_end (args);
833 return &rv;
834 break;
835
836 case CFAPI_MAP_PROP_RESET_TIMEOUT:
837 map = va_arg (args, maptile *);
838
839 rv = map->reset_timeout;
840 *type = CFAPI_INT;
841 va_end (args);
842 return &rv;
843 break;
844
845 case CFAPI_MAP_PROP_PLAYERS:
846 map = va_arg (args, maptile *);
847
848 rv = map->players;
849 *type = CFAPI_INT;
850 va_end (args);
851 return &rv;
852 break;
853
854 case CFAPI_MAP_PROP_DARKNESS:
855 map = va_arg (args, maptile *);
856
857 rv = map->darkness;
858 *type = CFAPI_INT;
859 va_end (args);
860 return &rv;
861 break;
862
863 case CFAPI_MAP_PROP_WIDTH:
864 map = va_arg (args, maptile *);
865
866 rv = map->width;
867 *type = CFAPI_INT;
868 va_end (args);
869 return &rv;
870 break;
871
872 case CFAPI_MAP_PROP_HEIGHT:
873 map = va_arg (args, maptile *);
874
875 rv = map->height;
876 *type = CFAPI_INT;
877 va_end (args);
878 return &rv;
879 break;
880
881 case CFAPI_MAP_PROP_ENTER_X:
882 map = va_arg (args, maptile *);
883
884 rv = map->enter_x;
885 *type = CFAPI_INT;
886 va_end (args);
887 return &rv;
888 break;
889
890 case CFAPI_MAP_PROP_ENTER_Y:
891 map = va_arg (args, maptile *);
892
893 rv = map->enter_y;
894 *type = CFAPI_INT;
895 va_end (args);
896 return &rv;
897 break;
898
899 case CFAPI_MAP_PROP_TEMPERATURE:
900 map = va_arg (args, maptile *);
901
902 rv = map->temp;
903 *type = CFAPI_INT;
904 va_end (args);
905 return &rv;
906 break;
907
908 case CFAPI_MAP_PROP_PRESSURE:
909 map = va_arg (args, maptile *);
910
911 rv = map->pressure;
912 *type = CFAPI_INT;
913 va_end (args);
914 return &rv;
915 break;
916
917 case CFAPI_MAP_PROP_HUMIDITY:
918 map = va_arg (args, maptile *);
919
920 rv = map->humid;
921 *type = CFAPI_INT;
922 va_end (args);
923 return &rv;
924 break;
925
926 case CFAPI_MAP_PROP_WINDSPEED:
927 map = va_arg (args, maptile *);
928
929 rv = map->windspeed;
930 *type = CFAPI_INT;
931 va_end (args);
932 return &rv;
933 break;
934
935 case CFAPI_MAP_PROP_WINDDIR:
936 map = va_arg (args, maptile *);
937
938 rv = map->winddir;
939 *type = CFAPI_INT;
940 va_end (args);
941 return &rv;
942 break;
943
944 case CFAPI_MAP_PROP_SKY:
945 map = va_arg (args, maptile *);
946
947 rv = map->sky;
948 *type = CFAPI_INT;
949 va_end (args);
950 return &rv;
951 break;
952
953 case CFAPI_MAP_PROP_WPARTX:
954 map = va_arg (args, maptile *);
955
956 rv = map->wpartx;
957 *type = CFAPI_INT;
958 va_end (args);
959 return &rv;
960 break;
961
962 case CFAPI_MAP_PROP_WPARTY:
963 map = va_arg (args, maptile *);
964
965 rv = map->wparty;
966 *type = CFAPI_INT;
967 va_end (args);
968 return &rv;
969 break;
970
971 case CFAPI_MAP_PROP_MESSAGE:
972 map = va_arg (args, maptile *);
973
974 buf = map->msg;
975 *type = CFAPI_STRING;
976 va_end (args);
977 return buf;
978 break;
979
980 case CFAPI_MAP_PROP_NEXT:
981 map = va_arg (args, maptile *);
982
983 *type = CFAPI_PMAP;
984 va_end (args);
985 return map->next;
986 break;
987
988 case CFAPI_MAP_PROP_REGION:
989 map = va_arg (args, maptile *);
990
991 *type = CFAPI_PREGION;
992 va_end (args);
993 return get_region_by_map (map);
994 break;
995
996 default:
997 *type = CFAPI_NONE;
998 va_end (args);
999 return NULL;
1000 break;
1001 }
1002} 633}
1003 634
1004void * 635void *
1005cfapi_map_set_map_property (int *type, ...) 636cfapi_map_set_map_property (int *type, ...)
1006{ 637{
1007 va_list args; 638 abort ();
1008 static int rv;
1009 maptile *map;
1010 int val;
1011 int property;
1012
1013 va_start (args, type);
1014
1015 property = va_arg (args, int);
1016
1017 switch (property)
1018 {
1019 case CFAPI_MAP_PROP_LIGHT:
1020 map = va_arg (args, maptile *);
1021 val = va_arg (args, int);
1022
1023 rv = change_map_light (map, val);
1024 *type = CFAPI_INT;
1025 va_end (args);
1026 return &rv;
1027 break;
1028
1029 case CFAPI_MAP_PROP_RESET_TIME:
1030 map = va_arg (args, maptile *);
1031
1032 *type = CFAPI_NONE;
1033 va_end (args);
1034 return NULL;
1035 break;
1036
1037 default:
1038 *type = CFAPI_NONE;
1039 va_end (args);
1040 return NULL;
1041 break;
1042 }
1043} 639}
640
1044void * 641void *
1045cfapi_map_out_of_map (int *type, ...) 642cfapi_map_out_of_map (int *type, ...)
1046{ 643{
644 abort ();
645}
646
647void *
648cfapi_map_update_position (int *type, ...)
649{
1047 va_list args; 650 va_list args;
1048 static int rv;
1049 maptile *map; 651 maptile *map;
1050 int x, y; 652 int x, y;
1051 653
1052 va_start (args, type); 654 va_start (args, type);
655
1053 map = va_arg (args, maptile *); 656 map = va_arg (args, maptile *);
1054 x = va_arg (args, int); 657 x = va_arg (args, int);
1055 y = va_arg (args, int); 658 y = va_arg (args, int);
1056 659
1057 rv = out_of_map (map, x, y); 660 map->at (x, y).flags_ &= ~P_UPTODATE;
661
1058 va_end (args); 662 va_end (args);
1059 *type = CFAPI_INT; 663 *type = CFAPI_NONE;
1060 return &rv; 664 return NULL;
1061} 665}
1062 666
1063void * 667void *
1064cfapi_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, ...)
1065{ 695{
1066 va_list args; 696 va_list args;
1067 maptile *map; 697 maptile *map;
1068 int x, y; 698 int x, y;
699 object *rv;
1069 700
1070 va_start (args, type); 701 va_start (args, type);
1071
1072 map = va_arg (args, maptile *); 702 map = va_arg (args, maptile *);
1073 x = va_arg (args, int); 703 x = va_arg (args, int);
1074 y = va_arg (args, int); 704 y = va_arg (args, int);
1075 705
1076 update_position (map, x, y);
1077 va_end (args); 706 va_end (args);
1078 *type = CFAPI_NONE;
1079 return NULL;
1080}
1081 707
1082void * 708 rv = GET_MAP_OB (map, x, y);
1083cfapi_map_delete_map (int *type, ...)
1084{
1085 va_list args;
1086 maptile *map;
1087
1088 va_start (args, type);
1089
1090 map = va_arg (args, maptile *);
1091
1092 delete_map (map);
1093
1094 va_end (args);
1095 *type = CFAPI_NONE;
1096 return NULL;
1097}
1098
1099void *
1100cfapi_map_message (int *type, ...)
1101{
1102 va_list args;
1103 maptile *map;
1104 char *string;
1105 int color;
1106
1107 va_start (args, type);
1108 map = va_arg (args, maptile *);
1109 string = va_arg (args, char *);
1110 color = va_arg (args, int);
1111
1112 va_end (args);
1113
1114 new_info_map (color, map, string);
1115 *type = CFAPI_NONE;
1116 return NULL;
1117}
1118
1119void *
1120cfapi_map_get_object_at (int *type, ...)
1121{
1122 va_list args;
1123 maptile *map;
1124 int x, y;
1125 object *rv;
1126
1127 va_start (args, type);
1128 map = va_arg (args, maptile *);
1129 x = va_arg (args, int);
1130 y = va_arg (args, int);
1131
1132 va_end (args);
1133
1134 rv = get_map_ob (map, x, y);
1135 *type = CFAPI_POBJECT; 709 *type = CFAPI_POBJECT;
1136 return rv; 710 return rv;
1137} 711}
1138 712
1139void * 713void *
… …
1265} 839}
1266 840
1267void * 841void *
1268cfapi_object_get_property (int *type, ...) 842cfapi_object_get_property (int *type, ...)
1269{ 843{
1270 va_list args; 844 abort ();
1271 int property;
1272 object *op;
1273 void *rv;
1274 static int ri;
1275
1276 va_start (args, type);
1277
1278 op = va_arg (args, object *);
1279 property = va_arg (args, int);
1280
1281 rv = NULL;
1282 if (op != NULL)
1283 {
1284 switch (property)
1285 {
1286 case CFAPI_OBJECT_PROP_OB_ABOVE:
1287 rv = op->above;
1288 *type = CFAPI_POBJECT;
1289 break;
1290
1291 case CFAPI_OBJECT_PROP_OB_BELOW:
1292 rv = op->below;
1293 *type = CFAPI_POBJECT;
1294 break;
1295
1296 case CFAPI_OBJECT_PROP_NEXT_ACTIVE_OB:
1297 rv = op->active_next;
1298 *type = CFAPI_POBJECT;
1299 break;
1300
1301 case CFAPI_OBJECT_PROP_PREV_ACTIVE_OB:
1302 rv = op->active_prev;
1303 *type = CFAPI_POBJECT;
1304 break;
1305
1306 case CFAPI_OBJECT_PROP_INVENTORY:
1307 rv = op->inv;
1308 *type = CFAPI_POBJECT;
1309 break;
1310
1311 case CFAPI_OBJECT_PROP_ENVIRONMENT:
1312 rv = op->env;
1313 *type = CFAPI_POBJECT;
1314 break;
1315
1316 case CFAPI_OBJECT_PROP_HEAD:
1317 rv = op->head;
1318 *type = CFAPI_POBJECT;
1319 break;
1320
1321 case CFAPI_OBJECT_PROP_CONTAINER:
1322 rv = op->container;
1323 *type = CFAPI_POBJECT;
1324 break;
1325
1326 case CFAPI_OBJECT_PROP_MAP:
1327 rv = op->map;
1328 *type = CFAPI_PMAP;
1329 break;
1330
1331 case CFAPI_OBJECT_PROP_COUNT:
1332 ri = op->count;
1333 rv = &ri;
1334 *type = CFAPI_INT;
1335 break;
1336
1337 case CFAPI_OBJECT_PROP_REFCOUNT:
1338 abort ();
1339 break;
1340
1341 case CFAPI_OBJECT_PROP_NAME:
1342 rv = query_name (op);
1343 *type = CFAPI_STRING;
1344 break;
1345
1346 case CFAPI_OBJECT_PROP_NAME_PLURAL:
1347 rv = (char *) &op->name_pl;
1348 *type = CFAPI_STRING;
1349 break;
1350
1351 case CFAPI_OBJECT_PROP_TITLE:
1352 rv = (char *) &op->title;
1353 *type = CFAPI_STRING;
1354 break;
1355
1356 case CFAPI_OBJECT_PROP_RACE:
1357 rv = (char *) &op->race;
1358 *type = CFAPI_STRING;
1359 break;
1360
1361 case CFAPI_OBJECT_PROP_SLAYING:
1362 rv = (char *) &op->slaying;
1363 *type = CFAPI_STRING;
1364 break;
1365
1366 case CFAPI_OBJECT_PROP_SKILL:
1367 rv = (char *) &op->skill;
1368 *type = CFAPI_STRING;
1369 break;
1370
1371 case CFAPI_OBJECT_PROP_MESSAGE:
1372 rv = (char *) &op->msg;
1373 if (rv == NULL)
1374 rv = (void *) "";
1375 *type = CFAPI_STRING;
1376 break;
1377
1378 case CFAPI_OBJECT_PROP_LORE:
1379 rv = (char *) &op->lore;
1380 *type = CFAPI_STRING;
1381 break;
1382
1383 case CFAPI_OBJECT_PROP_X:
1384 ri = op->x;
1385 rv = &ri;
1386 *type = CFAPI_INT;
1387 break;
1388
1389 case CFAPI_OBJECT_PROP_Y:
1390 ri = op->y;
1391 rv = &ri;
1392 *type = CFAPI_INT;
1393 break;
1394
1395 case CFAPI_OBJECT_PROP_SPEED:
1396 rv = &op->speed;
1397 *type = CFAPI_DOUBLE;
1398 break;
1399
1400 case CFAPI_OBJECT_PROP_SPEED_LEFT:
1401 rv = &op->speed_left;
1402 *type = CFAPI_DOUBLE;
1403 break;
1404
1405 case CFAPI_OBJECT_PROP_NROF:
1406 ri = op->nrof;
1407 rv = &ri;
1408 *type = CFAPI_INT;
1409 break;
1410
1411 case CFAPI_OBJECT_PROP_DIRECTION:
1412 ri = op->direction;
1413 rv = &ri;
1414 *type = CFAPI_INT;
1415 break;
1416
1417 case CFAPI_OBJECT_PROP_FACING:
1418 ri = op->facing;
1419 rv = &ri;
1420 *type = CFAPI_INT;
1421 break;
1422
1423 case CFAPI_OBJECT_PROP_TYPE:
1424 ri = op->type;
1425 rv = &ri;
1426 *type = CFAPI_INT;
1427 break;
1428
1429 case CFAPI_OBJECT_PROP_SUBTYPE:
1430 ri = op->subtype;
1431 rv = &ri;
1432 *type = CFAPI_INT;
1433 break;
1434
1435 case CFAPI_OBJECT_PROP_CLIENT_TYPE:
1436 ri = op->client_type;
1437 rv = &ri;
1438 *type = CFAPI_INT;
1439 break;
1440
1441 case CFAPI_OBJECT_PROP_RESIST:
1442 {
1443 int idx;
1444 idx = va_arg (args, int);
1445
1446 ri = op->resist[idx];
1447 rv = &ri;
1448 }
1449 *type = CFAPI_INT;
1450 break;
1451
1452 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
1453 ri = op->attacktype;
1454 rv = &ri;
1455 *type = CFAPI_INT;
1456 break;
1457
1458 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
1459 ri = op->path_attuned;
1460 rv = &ri;
1461 *type = CFAPI_INT;
1462 break;
1463
1464 case CFAPI_OBJECT_PROP_PATH_REPELLED:
1465 ri = op->path_repelled;
1466 rv = &ri;
1467 *type = CFAPI_INT;
1468 break;
1469
1470 case CFAPI_OBJECT_PROP_PATH_DENIED:
1471 ri = op->path_denied;
1472 rv = &ri;
1473 *type = CFAPI_INT;
1474 break;
1475
1476 case CFAPI_OBJECT_PROP_MATERIAL:
1477 ri = op->material;
1478 rv = &ri;
1479 *type = CFAPI_INT;
1480 break;
1481
1482 case CFAPI_OBJECT_PROP_MAGIC:
1483 ri = op->magic;
1484 rv = &ri;
1485 *type = CFAPI_INT;
1486 break;
1487
1488 case CFAPI_OBJECT_PROP_VALUE:
1489 ri = op->value;
1490 rv = &ri;
1491 *type = CFAPI_INT;
1492 break;
1493
1494 case CFAPI_OBJECT_PROP_LEVEL:
1495 ri = op->level;
1496 rv = &ri;
1497 *type = CFAPI_INT;
1498 break;
1499
1500 case CFAPI_OBJECT_PROP_LAST_HEAL:
1501 ri = op->last_heal;
1502 rv = &ri;
1503 *type = CFAPI_INT;
1504 break;
1505
1506 case CFAPI_OBJECT_PROP_LAST_SP:
1507 ri = op->last_sp;
1508 rv = &ri;
1509 *type = CFAPI_INT;
1510 break;
1511
1512 case CFAPI_OBJECT_PROP_LAST_GRACE:
1513 ri = op->last_grace;
1514 rv = &ri;
1515 *type = CFAPI_INT;
1516 break;
1517
1518 case CFAPI_OBJECT_PROP_LAST_EAT:
1519 ri = op->last_eat;
1520 rv = &ri;
1521 *type = CFAPI_INT;
1522 break;
1523
1524 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
1525 ri = op->invisible;
1526 rv = &ri;
1527 *type = CFAPI_INT;
1528 break;
1529
1530 case CFAPI_OBJECT_PROP_PICK_UP:
1531 ri = op->pick_up;
1532 rv = &ri;
1533 *type = CFAPI_INT;
1534 break;
1535
1536 case CFAPI_OBJECT_PROP_ITEM_POWER:
1537 ri = op->item_power;
1538 rv = &ri;
1539 *type = CFAPI_INT;
1540 break;
1541
1542 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
1543 ri = op->gen_sp_armour;
1544 rv = &ri;
1545 *type = CFAPI_INT;
1546 break;
1547
1548 case CFAPI_OBJECT_PROP_WEIGHT:
1549 ri = op->weight;
1550 rv = &ri;
1551 *type = CFAPI_INT;
1552 break;
1553
1554 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
1555 ri = op->weight_limit;
1556 rv = &ri;
1557 *type = CFAPI_INT;
1558 break;
1559
1560 case CFAPI_OBJECT_PROP_CARRYING:
1561 ri = op->carrying;
1562 rv = &ri;
1563 *type = CFAPI_INT;
1564 break;
1565
1566 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
1567 ri = op->glow_radius;
1568 rv = &ri;
1569 *type = CFAPI_INT;
1570 break;
1571
1572 case CFAPI_OBJECT_PROP_PERM_EXP:
1573 rv = &op->perm_exp;
1574 *type = CFAPI_LONG;
1575 break;
1576
1577 case CFAPI_OBJECT_PROP_CURRENT_WEAPON:
1578 rv = op->current_weapon;
1579 *type = CFAPI_POBJECT;
1580 break;
1581
1582 case CFAPI_OBJECT_PROP_ENEMY:
1583 rv = op->enemy;
1584 *type = CFAPI_POBJECT;
1585 break;
1586
1587 case CFAPI_OBJECT_PROP_ATTACKED_BY:
1588 rv = op->attacked_by;
1589 *type = CFAPI_POBJECT;
1590 break;
1591
1592 case CFAPI_OBJECT_PROP_RUN_AWAY:
1593 ri = op->run_away;
1594 rv = &ri;
1595 *type = CFAPI_INT;
1596 break;
1597
1598 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
1599 rv = op->chosen_skill;
1600 *type = CFAPI_POBJECT;
1601 break;
1602
1603 case CFAPI_OBJECT_PROP_HIDDEN:
1604 ri = op->hide;
1605 rv = &ri;
1606 *type = CFAPI_INT;
1607 break;
1608
1609 case CFAPI_OBJECT_PROP_MOVE_STATUS:
1610 ri = op->move_status;
1611 rv = &ri;
1612 *type = CFAPI_INT;
1613 break;
1614
1615 case CFAPI_OBJECT_PROP_MOVE_TYPE:
1616 ri = op->attack_movement;
1617 rv = &ri;
1618 *type = CFAPI_INT;
1619 break;
1620
1621 case CFAPI_OBJECT_PROP_SPELL_ITEM:
1622 rv = op->spellitem;
1623 *type = CFAPI_POBJECT;
1624 break;
1625
1626 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
1627 rv = &op->expmul;
1628 *type = CFAPI_DOUBLE;
1629 break;
1630
1631 case CFAPI_OBJECT_PROP_ARCHETYPE:
1632 rv = op->arch;
1633 *type = CFAPI_PARCH;
1634 break;
1635
1636 case CFAPI_OBJECT_PROP_OTHER_ARCH:
1637 rv = op->other_arch;
1638 *type = CFAPI_PARCH;
1639 break;
1640
1641 case CFAPI_OBJECT_PROP_ANIM_SPEED:
1642 ri = op->anim_speed;
1643 rv = &ri;
1644 *type = CFAPI_INT;
1645 break;
1646
1647 case CFAPI_OBJECT_PROP_FRIENDLY:
1648 ri = is_friendly (op);
1649 rv = &ri;
1650 *type = CFAPI_INT;
1651 break;
1652
1653 case CFAPI_OBJECT_PROP_BASE_NAME:
1654 {
1655 int i;
1656 i = va_arg (args, int);
1657
1658 rv = (char *) query_base_name (op, i);
1659 *type = CFAPI_STRING;
1660 }
1661 break;
1662
1663 case CFAPI_OBJECT_PROP_MAGICAL:
1664 ri = is_magical (op);
1665 rv = &ri;
1666 *type = CFAPI_INT;
1667 break;
1668
1669 case CFAPI_OBJECT_PROP_LUCK:
1670 ri = op->stats.luck;
1671 rv = &ri;
1672 *type = CFAPI_INT;
1673 break;
1674
1675 case CFAPI_OBJECT_PROP_EXP:
1676 rv = &op->stats.exp;
1677 *type = CFAPI_LONG;
1678 break;
1679
1680 case CFAPI_OBJECT_PROP_OWNER:
1681 rv = get_owner (op);
1682 *type = CFAPI_POBJECT;
1683 break;
1684
1685 case CFAPI_OBJECT_PROP_PRESENT:
1686 {
1687 int stype;
1688
1689 rv = 0;
1690 stype = va_arg (args, int);
1691
1692 switch (stype)
1693 {
1694
1695 unsigned char ptype;
1696 char *buf;
1697 archetype *at;
1698
1699 case 0: /* present_in_ob */
1700 ptype = (unsigned char) (va_arg (args, int));
1701
1702 rv = present_in_ob (ptype, op);
1703 break;
1704
1705 case 1: /* present_in_ob_by_name */
1706 ptype = (unsigned char) (va_arg (args, int));
1707 buf = va_arg (args, char *);
1708
1709 rv = present_in_ob_by_name (ptype, buf, op);
1710 break;
1711
1712 case 2: /* present_arch_in_ob */
1713 at = va_arg (args, archetype *);
1714
1715 rv = present_arch_in_ob (at, op);
1716 break;
1717 }
1718 }
1719 *type = CFAPI_POBJECT;
1720 break;
1721
1722 case CFAPI_OBJECT_PROP_CHEATER:
1723 ri = (QUERY_FLAG (op, FLAG_WAS_WIZ));
1724 rv = &ri;
1725 *type = CFAPI_INT;
1726 break;
1727
1728 case CFAPI_OBJECT_PROP_MERGEABLE:
1729 {
1730 object *op2;
1731 op2 = va_arg (args, object *);
1732
1733 ri = CAN_MERGE (op, op2);
1734 rv = &ri;
1735 }
1736 *type = CFAPI_INT;
1737 break;
1738
1739 case CFAPI_OBJECT_PROP_PICKABLE:
1740 {
1741 object *op2;
1742
1743 rv = 0;
1744 op2 = va_arg (args, object *);
1745
1746 ri = can_pick (op2, op);
1747 rv = &ri;
1748 }
1749 *type = CFAPI_INT;
1750 break;
1751
1752 case CFAPI_OBJECT_PROP_FLAGS:
1753 {
1754 int fl;
1755
1756 ri = 0;
1757 fl = va_arg (args, int);
1758
1759 ri = QUERY_FLAG (op, fl);
1760 rv = &ri;
1761 }
1762 *type = CFAPI_INT;
1763 break;
1764
1765 case CFAPI_OBJECT_PROP_STR:
1766 ri = op->stats.Str;
1767 rv = &ri;
1768 *type = CFAPI_INT;
1769 break;
1770
1771 case CFAPI_OBJECT_PROP_DEX:
1772 ri = op->stats.Dex;
1773 rv = &ri;
1774 *type = CFAPI_INT;
1775 break;
1776
1777 case CFAPI_OBJECT_PROP_CON:
1778 ri = op->stats.Con;
1779 rv = &ri;
1780 *type = CFAPI_INT;
1781 break;
1782
1783 case CFAPI_OBJECT_PROP_WIS:
1784 ri = op->stats.Wis;
1785 rv = &ri;
1786 *type = CFAPI_INT;
1787 break;
1788
1789 case CFAPI_OBJECT_PROP_INT:
1790 ri = op->stats.Int;
1791 rv = &ri;
1792 *type = CFAPI_INT;
1793 break;
1794
1795 case CFAPI_OBJECT_PROP_POW:
1796 ri = op->stats.Pow;
1797 rv = &ri;
1798 *type = CFAPI_INT;
1799 break;
1800
1801 case CFAPI_OBJECT_PROP_CHA:
1802 ri = op->stats.Cha;
1803 rv = &ri;
1804 *type = CFAPI_INT;
1805 break;
1806
1807 case CFAPI_OBJECT_PROP_WC:
1808 ri = op->stats.wc;
1809 rv = &ri;
1810 *type = CFAPI_INT;
1811 break;
1812
1813 case CFAPI_OBJECT_PROP_AC:
1814 ri = op->stats.ac;
1815 rv = &ri;
1816 *type = CFAPI_INT;
1817 break;
1818
1819 case CFAPI_OBJECT_PROP_HP:
1820 ri = op->stats.hp;
1821 rv = &ri;
1822 *type = CFAPI_INT;
1823 break;
1824
1825 case CFAPI_OBJECT_PROP_SP:
1826 ri = op->stats.sp;
1827 rv = &ri;
1828 *type = CFAPI_INT;
1829 break;
1830
1831 case CFAPI_OBJECT_PROP_GP:
1832 ri = op->stats.grace;
1833 rv = &ri;
1834 *type = CFAPI_INT;
1835 break;
1836
1837 case CFAPI_OBJECT_PROP_FP:
1838 ri = op->stats.food;
1839 rv = &ri;
1840 *type = CFAPI_INT;
1841 break;
1842
1843 case CFAPI_OBJECT_PROP_MAXHP:
1844 ri = op->stats.maxhp;
1845 rv = &ri;
1846 *type = CFAPI_INT;
1847 break;
1848
1849 case CFAPI_OBJECT_PROP_MAXSP:
1850 ri = op->stats.maxsp;
1851 rv = &ri;
1852 *type = CFAPI_INT;
1853 break;
1854
1855 case CFAPI_OBJECT_PROP_MAXGP:
1856 ri = op->stats.maxgrace;
1857 rv = &ri;
1858 *type = CFAPI_INT;
1859 break;
1860
1861 case CFAPI_OBJECT_PROP_DAM:
1862 ri = op->stats.dam;
1863 rv = &ri;
1864 *type = CFAPI_INT;
1865 break;
1866
1867 case CFAPI_OBJECT_PROP_GOD:
1868 rv = (char *) determine_god (op);
1869 *type = CFAPI_STRING;
1870 break;
1871
1872 case CFAPI_OBJECT_PROP_ARCH_NAME:
1873 rv = (char *) &op->arch->name;
1874 *type = CFAPI_STRING;
1875 break;
1876
1877 case CFAPI_OBJECT_PROP_INVISIBLE:
1878 ri = op->invisible;
1879 rv = &ri;
1880 *type = CFAPI_INT;
1881 break;
1882
1883 case CFAPI_OBJECT_PROP_FACE:
1884 ri = op->animation_id;
1885 rv = &ri;
1886 *type = CFAPI_INT;
1887 break;
1888
1889 case CFAPI_PLAYER_PROP_IP:
1890 rv = op->contr->socket.host;
1891 *type = CFAPI_STRING;
1892 break;
1893
1894 case CFAPI_PLAYER_PROP_MARKED_ITEM:
1895 rv = find_marked_object (op);
1896 *type = CFAPI_POBJECT;
1897 break;
1898
1899 case CFAPI_PLAYER_PROP_PARTY:
1900 rv = (op->contr ? op->contr->party : NULL);
1901 *type = CFAPI_PPARTY;
1902 break;
1903 default:
1904 *type = CFAPI_NONE;
1905 break;
1906 }
1907 }
1908 va_end (args);
1909 return rv;
1910} 845}
1911 846
1912void * 847void *
1913cfapi_object_set_property (int *type, ...) 848cfapi_object_set_property (int *type, ...)
1914{ 849{
1915 va_list args; 850 abort ();
1916 int iarg;
1917 long larg;
1918 char *sarg;
1919 double darg;
1920 object *oparg;
1921 object *op;
1922 int property;
1923 void *rv;
1924 partylist *partyarg;
1925
1926 va_start (args, type);
1927
1928 op = va_arg (args, object *);
1929 property = va_arg (args, int);
1930
1931 rv = NULL;
1932
1933 if (op != NULL && (!op->arch || (op != &op->arch->clone)))
1934 {
1935 switch (property)
1936 {
1937 case CFAPI_OBJECT_PROP_NAME:
1938 sarg = va_arg (args, char *);
1939
1940#define FREE_AND_COPY(a,b) (a) = (b) // TODO: remove, but plugins.C is considered zombie code
1941 FREE_AND_COPY (op->name, sarg);
1942 send_changed_object (op);
1943 break;
1944
1945 case CFAPI_OBJECT_PROP_NAME_PLURAL:
1946 sarg = va_arg (args, char *);
1947
1948 FREE_AND_COPY (op->name_pl, sarg);
1949 send_changed_object (op);
1950 break;
1951
1952 case CFAPI_OBJECT_PROP_TITLE:
1953 sarg = va_arg (args, char *);
1954
1955 FREE_AND_COPY (op->title, sarg);
1956 break;
1957
1958 case CFAPI_OBJECT_PROP_RACE:
1959 sarg = va_arg (args, char *);
1960
1961 FREE_AND_COPY (op->race, sarg);
1962 break;
1963
1964 case CFAPI_OBJECT_PROP_SLAYING:
1965 sarg = va_arg (args, char *);
1966
1967 FREE_AND_COPY (op->slaying, sarg);
1968 break;
1969
1970 case CFAPI_OBJECT_PROP_SKILL:
1971 sarg = va_arg (args, char *);
1972
1973 FREE_AND_COPY (op->skill, sarg);
1974 break;
1975
1976 case CFAPI_OBJECT_PROP_MESSAGE:
1977 sarg = va_arg (args, char *);
1978
1979 FREE_AND_COPY (op->msg, sarg);
1980 break;
1981
1982 case CFAPI_OBJECT_PROP_LORE:
1983 sarg = va_arg (args, char *);
1984
1985 FREE_AND_COPY (op->lore, sarg);
1986 break;
1987
1988 case CFAPI_OBJECT_PROP_SPEED:
1989 darg = va_arg (args, double);
1990
1991 op->speed = darg;
1992 break;
1993
1994 case CFAPI_OBJECT_PROP_SPEED_LEFT:
1995 darg = va_arg (args, double);
1996
1997 op->speed_left = darg;
1998 break;
1999
2000 case CFAPI_OBJECT_PROP_NROF:
2001 iarg = va_arg (args, int);
2002
2003 if (iarg < 0)
2004 iarg = 0;
2005 if (op->nrof > (uint32) iarg)
2006 decrease_ob_nr (op, op->nrof - iarg);
2007 else if (op->nrof < (uint32) iarg)
2008 {
2009 object *tmp;
2010 player *pl;
2011
2012 op->nrof = iarg;
2013 if (op->env != NULL)
2014 {
2015 tmp = is_player_inv (op->env);
2016 if (!tmp)
2017 {
2018 for (pl = first_player; pl; pl = pl->next)
2019 if (pl->ob->container == op->env)
2020 break;
2021 if (pl)
2022 tmp = pl->ob;
2023 else
2024 tmp = NULL;
2025 }
2026 else
2027 {
2028 sum_weight (tmp);
2029 fix_player (tmp);
2030 }
2031 if (tmp)
2032 esrv_send_item (tmp, op);
2033 }
2034 else
2035 {
2036 object *above = op->above;
2037
2038 for (tmp = above; tmp != NULL; tmp = tmp->above)
2039 if (tmp->type == PLAYER)
2040 esrv_send_item (tmp, op);
2041 }
2042 }
2043 break;
2044
2045 case CFAPI_OBJECT_PROP_DIRECTION:
2046 iarg = va_arg (args, int);
2047
2048 op->direction = iarg;
2049 break;
2050
2051 case CFAPI_OBJECT_PROP_FACING:
2052 iarg = va_arg (args, int);
2053
2054 op->facing = iarg;
2055 break;
2056
2057 case CFAPI_OBJECT_PROP_RESIST:
2058 {
2059 int iargbis = va_arg (args, int);
2060 iarg = va_arg (args, int);
2061
2062 op->resist[iargbis] = iarg;
2063 }
2064 break;
2065
2066 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
2067 iarg = va_arg (args, int);
2068
2069 op->attacktype = iarg;
2070 break;
2071
2072 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
2073 iarg = va_arg (args, int);
2074
2075 op->path_attuned = iarg;
2076 break;
2077
2078 case CFAPI_OBJECT_PROP_PATH_REPELLED:
2079 iarg = va_arg (args, int);
2080
2081 op->path_repelled = iarg;
2082 break;
2083
2084 case CFAPI_OBJECT_PROP_PATH_DENIED:
2085 iarg = va_arg (args, int);
2086
2087 op->path_denied = iarg;
2088 break;
2089
2090 case CFAPI_OBJECT_PROP_MATERIAL:
2091 iarg = va_arg (args, int);
2092
2093 op->material = iarg;
2094 break;
2095
2096 case CFAPI_OBJECT_PROP_MATERIAL_NAME:
2097 break;
2098
2099 case CFAPI_OBJECT_PROP_MAGIC:
2100 iarg = va_arg (args, int);
2101
2102 op->magic = iarg;
2103 break;
2104
2105 case CFAPI_OBJECT_PROP_VALUE:
2106 iarg = va_arg (args, int);
2107
2108 op->value = iarg;
2109 break;
2110
2111 case CFAPI_OBJECT_PROP_LEVEL:
2112 iarg = va_arg (args, int);
2113
2114 op->level = iarg;
2115 break;
2116
2117 case CFAPI_OBJECT_PROP_LAST_HEAL:
2118 iarg = va_arg (args, int);
2119
2120 op->last_heal = iarg;
2121 break;
2122
2123 case CFAPI_OBJECT_PROP_LAST_SP:
2124 iarg = va_arg (args, int);
2125
2126 op->last_sp = iarg;
2127 break;
2128
2129 case CFAPI_OBJECT_PROP_LAST_GRACE:
2130 iarg = va_arg (args, int);
2131
2132 op->last_grace = iarg;
2133 break;
2134
2135 case CFAPI_OBJECT_PROP_LAST_EAT:
2136 iarg = va_arg (args, int);
2137
2138 op->last_eat = iarg;
2139 break;
2140
2141 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
2142 iarg = va_arg (args, int);
2143
2144 op->invisible = iarg;
2145 break;
2146
2147 case CFAPI_OBJECT_PROP_PICK_UP:
2148 iarg = va_arg (args, int);
2149
2150 op->pick_up = iarg;
2151 break;
2152
2153 case CFAPI_OBJECT_PROP_ITEM_POWER:
2154 iarg = va_arg (args, int);
2155
2156 op->item_power = iarg;
2157 break;
2158
2159 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
2160 iarg = va_arg (args, int);
2161
2162 op->gen_sp_armour = iarg;
2163 break;
2164
2165 case CFAPI_OBJECT_PROP_WEIGHT:
2166 iarg = va_arg (args, int);
2167
2168 if (op->weight != iarg)
2169 {
2170 object *tmp;
2171 player *pl;
2172
2173 op->weight = iarg;
2174 if (op->env != NULL)
2175 {
2176 tmp = is_player_inv (op->env);
2177 if (!tmp)
2178 {
2179 for (pl = first_player; pl; pl = pl->next)
2180 if (pl->ob->container == op->env)
2181 break;
2182 if (pl)
2183 tmp = pl->ob;
2184 else
2185 tmp = NULL;
2186 }
2187 else
2188 {
2189 sum_weight (tmp);
2190 fix_player (tmp);
2191 }
2192 if (tmp)
2193 esrv_send_item (tmp, op);
2194 }
2195 else
2196 {
2197 object *above = op->above;
2198
2199 for (tmp = above; tmp != NULL; tmp = tmp->above)
2200 if (tmp->type == PLAYER)
2201 esrv_send_item (tmp, op);
2202 }
2203 }
2204 break;
2205
2206 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
2207 iarg = va_arg (args, int);
2208
2209 op->weight_limit = iarg;
2210 break;
2211
2212 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
2213 iarg = va_arg (args, int);
2214
2215 op->glow_radius = iarg;
2216 break;
2217
2218 case CFAPI_OBJECT_PROP_PERM_EXP:
2219 larg = va_arg (args, long);
2220
2221 op->perm_exp = larg;
2222 break;
2223
2224 case CFAPI_OBJECT_PROP_ENEMY:
2225 oparg = va_arg (args, object *);
2226
2227 op->enemy = oparg;
2228 break;
2229
2230 case CFAPI_OBJECT_PROP_RUN_AWAY:
2231 iarg = va_arg (args, int);
2232
2233 op->run_away = iarg;
2234 break;
2235
2236 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
2237 oparg = va_arg (args, object *);
2238
2239 op->chosen_skill = oparg;
2240 break;
2241
2242 case CFAPI_OBJECT_PROP_HIDDEN:
2243 iarg = va_arg (args, int);
2244
2245 op->hide = iarg;
2246 break;
2247
2248 case CFAPI_OBJECT_PROP_MOVE_STATUS:
2249 iarg = va_arg (args, int);
2250
2251 op->move_status = iarg;
2252 break;
2253
2254 case CFAPI_OBJECT_PROP_MOVE_TYPE:
2255 iarg = va_arg (args, int);
2256
2257 op->attack_movement = iarg;
2258 break;
2259
2260 case CFAPI_OBJECT_PROP_SPELL_ITEM:
2261 oparg = va_arg (args, object *);
2262
2263 op->spellitem = oparg;
2264 break;
2265
2266 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
2267 darg = va_arg (args, double);
2268
2269 op->expmul = darg;
2270 break;
2271
2272 case CFAPI_OBJECT_PROP_CUSTOM_NAME:
2273 sarg = va_arg (args, char *);
2274
2275 FREE_AND_COPY (op->custom_name, sarg);
2276 send_changed_object (op);
2277 break;
2278
2279 case CFAPI_OBJECT_PROP_ANIM_SPEED:
2280 iarg = va_arg (args, int);
2281
2282 op->anim_speed = iarg;
2283 break;
2284
2285 case CFAPI_OBJECT_PROP_FRIENDLY:
2286 iarg = va_arg (args, int);
2287
2288 if (iarg == 1 && is_friendly (op) == 0)
2289 add_friendly_object (op);
2290 else if (iarg == 0 && is_friendly (op) == 1)
2291 remove_friendly_object (op);
2292 break;
2293
2294 case CFAPI_OBJECT_PROP_LUCK:
2295 iarg = va_arg (args, int);
2296
2297 op->stats.luck = iarg;
2298 break;
2299
2300 case CFAPI_OBJECT_PROP_EXP:
2301 {
2302 char *skillname;
2303
2304 larg = va_arg (args, long);
2305 skillname = va_arg (args, char *);
2306 iarg = va_arg (args, int);
2307
2308 change_exp (op, larg, skillname, iarg);
2309 }
2310 break;
2311
2312 case CFAPI_OBJECT_PROP_OWNER:
2313 oparg = va_arg (args, object *);
2314
2315 set_owner (op, oparg);
2316 break;
2317
2318 case CFAPI_OBJECT_PROP_CHEATER:
2319 set_cheat (op);
2320 break;
2321
2322 case CFAPI_OBJECT_PROP_FLAGS:
2323 {
2324 int iargbis;
2325 iarg = va_arg (args, int);
2326 iargbis = va_arg (args, int);
2327
2328 if (iargbis == 1)
2329 SET_FLAG (op, iarg);
2330 else
2331 CLEAR_FLAG (op, iarg);
2332 }
2333 break;
2334
2335 case CFAPI_OBJECT_PROP_STR:
2336 iarg = va_arg (args, int);
2337
2338 op->stats.Str = iarg;
2339 break;
2340
2341 case CFAPI_OBJECT_PROP_DEX:
2342 iarg = va_arg (args, int);
2343
2344 op->stats.Dex = iarg;
2345 break;
2346
2347 case CFAPI_OBJECT_PROP_CON:
2348 iarg = va_arg (args, int);
2349
2350 op->stats.Con = iarg;
2351 break;
2352
2353 case CFAPI_OBJECT_PROP_WIS:
2354 iarg = va_arg (args, int);
2355
2356 op->stats.Wis = iarg;
2357 break;
2358
2359 case CFAPI_OBJECT_PROP_INT:
2360 iarg = va_arg (args, int);
2361
2362 op->stats.Int = iarg;
2363 break;
2364
2365 case CFAPI_OBJECT_PROP_POW:
2366 iarg = va_arg (args, int);
2367
2368 op->stats.Pow = iarg;
2369 break;
2370
2371 case CFAPI_OBJECT_PROP_CHA:
2372 iarg = va_arg (args, int);
2373
2374 op->stats.Cha = iarg;
2375 break;
2376
2377 case CFAPI_OBJECT_PROP_WC:
2378 iarg = va_arg (args, int);
2379
2380 op->stats.wc = iarg;
2381 break;
2382
2383 case CFAPI_OBJECT_PROP_AC:
2384 iarg = va_arg (args, int);
2385
2386 op->stats.ac = iarg;
2387 break;
2388
2389 case CFAPI_OBJECT_PROP_HP:
2390 iarg = va_arg (args, int);
2391
2392 op->stats.hp = iarg;
2393 break;
2394
2395 case CFAPI_OBJECT_PROP_SP:
2396 iarg = va_arg (args, int);
2397
2398 op->stats.sp = iarg;
2399 break;
2400
2401 case CFAPI_OBJECT_PROP_GP:
2402 iarg = va_arg (args, int);
2403
2404 op->stats.grace = iarg;
2405 break;
2406
2407 case CFAPI_OBJECT_PROP_FP:
2408 iarg = va_arg (args, int);
2409
2410 op->stats.food = iarg;
2411 break;
2412
2413 case CFAPI_OBJECT_PROP_MAXHP:
2414 iarg = va_arg (args, int);
2415
2416 op->stats.maxhp = iarg;
2417 break;
2418
2419 case CFAPI_OBJECT_PROP_MAXSP:
2420 iarg = va_arg (args, int);
2421
2422 op->stats.maxsp = iarg;
2423 break;
2424
2425 case CFAPI_OBJECT_PROP_MAXGP:
2426 iarg = va_arg (args, int);
2427
2428 op->stats.maxgrace = iarg;
2429 break;
2430
2431 case CFAPI_OBJECT_PROP_DAM:
2432 iarg = va_arg (args, int);
2433
2434 op->stats.dam = iarg;
2435 break;
2436
2437 case CFAPI_OBJECT_PROP_FACE:
2438 iarg = va_arg (args, int);
2439
2440 op->animation_id = iarg;
2441 update_object (op, UP_OBJ_FACE);
2442 break;
2443
2444 case CFAPI_OBJECT_ANIMATION:
2445 iarg = va_arg (args, int);
2446
2447 if (iarg != -1)
2448 {
2449 SET_ANIMATION (op, iarg);
2450 }
2451 update_object (op, UP_OBJ_FACE);
2452 break;
2453
2454 case CFAPI_PLAYER_PROP_MARKED_ITEM:
2455 if (op->contr)
2456 {
2457 oparg = va_arg (args, object *);
2458
2459 op->contr->mark = oparg;
2460 if (oparg)
2461 op->contr->mark_count = oparg->count;
2462 }
2463 break;
2464
2465 case CFAPI_PLAYER_PROP_PARTY:
2466 if (op->contr)
2467 {
2468 partyarg = va_arg (args, partylist *);
2469
2470 op->contr->party = partyarg;
2471 }
2472 break;
2473
2474 default:
2475 *type = CFAPI_NONE;
2476 break;
2477 }
2478 }
2479 va_end (args);
2480
2481 *type = CFAPI_NONE;
2482 return NULL;
2483} 851}
2484 852
2485void * 853void *
2486cfapi_object_apply_below (int *type, ...) 854cfapi_object_apply_below (int *type, ...)
2487{ 855{
… …
2557} 925}
2558 926
2559void * 927void *
2560cfapi_object_drain (int *type, ...) 928cfapi_object_drain (int *type, ...)
2561{ 929{
2562 va_list args; 930 abort ();
2563
2564 object *op;
2565 int ds;
2566
2567 va_start (args, type);
2568
2569 op = va_arg (args, object *);
2570 ds = va_arg (args, int);
2571
2572 va_end (args);
2573
2574 drain_specific_stat (op, ds);
2575
2576 *type = CFAPI_NONE;
2577 return NULL;
2578} 931}
2579 932
2580void * 933void *
2581cfapi_object_fix (int *type, ...) 934cfapi_object_fix (int *type, ...)
2582{ 935{
… …
2587 940
2588 op = va_arg (args, object *); 941 op = va_arg (args, object *);
2589 942
2590 va_end (args); 943 va_end (args);
2591 944
2592 fix_player (op); 945 op->update_stats ();
2593 946
2594 *type = CFAPI_NONE; 947 *type = CFAPI_NONE;
2595 return NULL; 948 return NULL;
2596} 949}
2597 950
… …
2645 op = va_arg (args, object *); 998 op = va_arg (args, object *);
2646 999
2647 va_end (args); 1000 va_end (args);
2648 1001
2649 send_removed_object (op); 1002 send_removed_object (op);
2650 remove_ob (op); 1003 op->remove ();
2651 *type = CFAPI_NONE; 1004 *type = CFAPI_NONE;
2652 return NULL; 1005 return NULL;
2653} 1006}
2654 1007
2655void * 1008void *
… …
2662 1015
2663 op = va_arg (args, object *); 1016 op = va_arg (args, object *);
2664 1017
2665 va_end (args); 1018 va_end (args);
2666 1019
2667 free_object (op); 1020 op->destroy ();
2668 1021
2669 *type = CFAPI_NONE; 1022 *type = CFAPI_NONE;
2670 return NULL; 1023 return NULL;
2671} 1024}
2672 1025
… …
2689 *type = CFAPI_POBJECT; 1042 *type = CFAPI_POBJECT;
2690 return object_create_clone (op); 1043 return object_create_clone (op);
2691 } 1044 }
2692 else 1045 else
2693 { 1046 {
2694 object *tmp; 1047 object *tmp = op->clone ();
2695
2696 tmp = get_object ();
2697 copy_object (op, tmp);
2698 *type = CFAPI_POBJECT; 1048 *type = CFAPI_POBJECT;
2699 return tmp; 1049 return tmp;
2700 } 1050 }
2701} 1051}
2702void * 1052void *
… …
2738 break; 1088 break;
2739 1089
2740 case 3: 1090 case 3:
2741 op = va_arg (args, object *); 1091 op = va_arg (args, object *);
2742 1092
2743 rv = is_player_inv (op); 1093 rv = op->in_player ();
2744 break; 1094 break;
2745 1095
2746 default: 1096 default:
2747 rv = NULL; 1097 rv = NULL;
2748 *type = CFAPI_NONE; 1098 *type = CFAPI_NONE;
… …
2766 *type = CFAPI_POBJECT; 1116 *type = CFAPI_POBJECT;
2767 switch (ival) 1117 switch (ival)
2768 { 1118 {
2769 case 0: 1119 case 0:
2770 va_end (args); 1120 va_end (args);
2771 return get_object (); 1121 return object::create ();
2772 break; 1122 break;
2773 1123
2774 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 */
2775 { 1125 {
2776 char *sval; 1126 char *sval;
… …
2779 1129
2780 op = get_archetype_by_object_name (sval); 1130 op = get_archetype_by_object_name (sval);
2781 1131
2782 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) 1132 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
2783 { 1133 {
2784 free_object (op); 1134 op->destroy ();
2785 /* Try with archetype names... */ 1135 /* Try with archetype names... */
2786 op = get_archetype (sval); 1136 op = get_archetype (sval);
2787 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) 1137 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
2788 { 1138 {
2789 free_object (op); 1139 op->destroy ();
2790 *type = CFAPI_NONE; 1140 *type = CFAPI_NONE;
2791 va_end (args); 1141 va_end (args);
2792 return NULL; 1142 return NULL;
2793 } 1143 }
2794 } 1144 }
… …
2944} 1294}
2945 1295
2946void * 1296void *
2947cfapi_object_clear (int *type, ...) 1297cfapi_object_clear (int *type, ...)
2948{ 1298{
2949 va_list args; 1299 abort ();
2950 object *op;
2951
2952 va_start (args, type);
2953
2954 op = va_arg (args, object *);
2955
2956 va_end (args);
2957
2958 clear_object (op);
2959 *type = CFAPI_NONE;
2960 return NULL;
2961} 1300}
2962 1301
2963void * 1302void *
2964cfapi_object_reset (int *type, ...) 1303cfapi_object_reset (int *type, ...)
2965{ 1304{
… …
2998} 1337}
2999 1338
3000void * 1339void *
3001cfapi_object_clean_object (int *type, ...) 1340cfapi_object_clean_object (int *type, ...)
3002{ 1341{
3003 va_list args; 1342 abort ();
3004 object *op;
3005
3006 va_start (args, type);
3007 op = va_arg (args, object *);
3008
3009 clean_object (op);
3010 va_end (args);
3011 *type = CFAPI_NONE;
3012 return NULL;
3013} 1343}
3014 1344
3015void * 1345void *
3016cfapi_object_on_same_map (int *type, ...) 1346cfapi_object_on_same_map (int *type, ...)
3017{ 1347{
… …
3263 x = map->enter_x; 1593 x = map->enter_x;
3264 y = map->enter_y; 1594 y = map->enter_y;
3265 } 1595 }
3266 1596
3267/* 1597/*
3268 originator = get_object(); 1598 originator = object::create();
3269 EXIT_PATH(originator) = add_string(map->path); 1599 EXIT_PATH(originator) = map->path;
3270 EXIT_X(originator) = x; 1600 EXIT_X(originator) = x;
3271 EXIT_Y(originator) = y; 1601 EXIT_Y(originator) = y;
3272 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);*/
3273 /*enter_exit(op, originator); */ 1603 /*enter_exit(op, originator); */
3274 insert_ob_in_map_at (op, map, NULL, 0, x, y); 1604 insert_ob_in_map_at (op, map, NULL, 0, x, y);
3275 /*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);
3276 free_object(originator); 1606 originator->destroy ();
3277 */ 1607 */
3278 *type = CFAPI_INT; 1608 *type = CFAPI_INT;
3279 return &rv; 1609 return &rv;
3280 break; 1610 break;
3281 1611
… …
3354 drop (author, op); 1684 drop (author, op);
3355 1685
3356 if (author->type == PLAYER) 1686 if (author->type == PLAYER)
3357 { 1687 {
3358 author->contr->count = 0; 1688 author->contr->count = 0;
3359 author->contr->socket.update_look = 1; 1689 author->contr->ns->floorbox_update ();
3360 } 1690 }
3361 1691
3362 *type = CFAPI_NONE; 1692 *type = CFAPI_NONE;
3363 return NULL; 1693 return NULL;
3364} 1694}
… …
3395 1725
3396/* PLAYER SUBCLASS */ 1726/* PLAYER SUBCLASS */
3397void * 1727void *
3398cfapi_player_find (int *type, ...) 1728cfapi_player_find (int *type, ...)
3399{ 1729{
3400 va_list args; 1730 abort ();
3401 void *rv;
3402 char *sval;
3403
3404 va_start (args, type);
3405
3406 sval = va_arg (args, char *);
3407
3408 va_end (args);
3409
3410 rv = find_player (sval);
3411
3412 *type = CFAPI_PPLAYER;
3413 return rv;
3414} 1731}
3415 1732
3416void * 1733void *
3417cfapi_player_message (int *type, ...) 1734cfapi_player_message (int *type, ...)
3418{ 1735{
… …
3470 result = 1; 1787 result = 1;
3471 return &result; 1788 return &result;
3472 } 1789 }
3473 1790
3474 send_removed_object (who); 1791 send_removed_object (who);
3475 remove_ob (who); 1792 who->remove ();
3476 1793
3477 for (tmp = who; tmp != NULL; tmp = tmp->more) 1794 for (tmp = who; tmp != NULL; tmp = tmp->more)
3478 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),
3479 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);
3480 1797
… …
3565 1882
3566/* Party-related functions */ 1883/* Party-related functions */
3567void * 1884void *
3568cfapi_party_get_property (int *type, ...) 1885cfapi_party_get_property (int *type, ...)
3569{ 1886{
3570 partylist *party; 1887 abort ();
3571 int prop;
3572 va_list args;
3573 void *rv;
3574 object *obarg;
3575 player *pl;
3576
3577 va_start (args, type);
3578 party = va_arg (args, partylist *);
3579 prop = va_arg (args, int);
3580
3581 switch (prop)
3582 {
3583 case CFAPI_PARTY_PROP_NAME:
3584 *type = CFAPI_STRING;
3585 rv = (void *) party->partyname;
3586 break;
3587
3588 case CFAPI_PARTY_PROP_NEXT:
3589 *type = CFAPI_PPARTY;
3590 rv = (party ? party->next : get_firstparty ());
3591 break;
3592
3593 case CFAPI_PARTY_PROP_PASSWORD:
3594 *type = CFAPI_STRING;
3595 rv = (void *) party->passwd;
3596 break;
3597
3598 case CFAPI_PARTY_PROP_PLAYER:
3599 *type = CFAPI_PPLAYER;
3600 obarg = va_arg (args, object *);
3601
3602 pl = (obarg ? obarg->contr : first_player);
3603 rv = NULL;
3604 for (; pl != NULL; pl = pl->next)
3605 if (pl->ob->contr->party == party)
3606 {
3607 rv = (void *) pl;
3608 break;
3609 }
3610 break;
3611
3612 default:
3613 *type = CFAPI_NONE;
3614 rv = NULL;
3615 break;
3616 }
3617 va_end (args);
3618 return rv;
3619} 1888}
3620 1889
3621/* Regions-related functions */ 1890/* Regions-related functions */
3622void * 1891void *
3623cfapi_region_get_property (int *type, ...) 1892cfapi_region_get_property (int *type, ...)
3624{ 1893{
3625 region *reg; 1894 abort ();
3626 int prop;
3627 va_list args;
3628 void *rv;
3629
3630 va_start (args, type);
3631 reg = va_arg (args, region *);
3632 prop = va_arg (args, int);
3633
3634 switch (prop)
3635 {
3636 case CFAPI_REGION_PROP_NAME:
3637 *type = CFAPI_STRING;
3638 rv = (void *) reg->name;
3639 break;
3640
3641 case CFAPI_REGION_PROP_NEXT:
3642 *type = CFAPI_PREGION;
3643 rv = (reg ? reg->next : first_region);
3644 break;
3645
3646 case CFAPI_REGION_PROP_PARENT:
3647 *type = CFAPI_PREGION;
3648 rv = (void *) reg->parent;
3649 break;
3650
3651 case CFAPI_REGION_PROP_LONGNAME:
3652 *type = CFAPI_STRING;
3653 rv = (void *) reg->longname;
3654 break;
3655
3656 case CFAPI_REGION_PROP_MESSAGE:
3657 *type = CFAPI_STRING;
3658 rv = (void *) reg->msg;
3659 break;
3660
3661 default:
3662 *type = CFAPI_NONE;
3663 rv = NULL;
3664 break;
3665 }
3666 va_end (args);
3667 return rv;
3668} 1895}
3669 1896
3670/*****************************************************************************/ 1897/*****************************************************************************/
3671 1898
3672/* NEW PLUGIN STUFF ENDS HERE */ 1899/* NEW PLUGIN STUFF ENDS HERE */
… …
3702 return NULL; 1929 return NULL;
3703} 1930}
3704 1931
3705/*****************************************************************************/ 1932/*****************************************************************************/
3706 1933
3707/* Plugins initialization. Browses the plugins directory and call */ 1934/* Plugins initialisation. Browses the plugins directory and call */
3708 1935
3709/* initOnePlugin for each file found. */ 1936/* initOnePlugin for each file found. */
3710 1937
3711/* 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 */
3712 1939
… …
3719 size_t l; 1946 size_t l;
3720 char buf[MAX_BUF]; 1947 char buf[MAX_BUF];
3721 char buf2[MAX_BUF]; 1948 char buf2[MAX_BUF];
3722 int result; 1949 int result;
3723 1950
3724 LOG (llevInfo, "Initializing plugins\n"); 1951 LOG (llevInfo, "Initialising plugins\n");
3725 strcpy (buf, LIBDIR); 1952 strcpy (buf, LIBDIR);
3726 strcat (buf, "/plugins/"); 1953 strcat (buf, "/plugins/");
3727 LOG (llevInfo, "Plugins directory is %s\n", buf); 1954 LOG (llevInfo, "Plugins directory is %s\n", buf);
3728 1955
3729 plugins_init_perl (); 1956 plugins_init_perl ();

Diff Legend

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