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.29 by root, Wed Dec 20 09:14:22 2006 UTC vs.
Revision 1.40 by root, Sun Jan 7 02:39:14 2007 UTC

… …
130 */ 130 */
131static void 131static void
132send_changed_object (object *op) 132send_changed_object (object *op)
133{ 133{
134 object *tmp; 134 object *tmp;
135 player *pl;
136 135
137 if (op->env) 136 if (op->env)
138 { 137 {
139 tmp = op->in_player (); 138 tmp = op->in_player ();
140 139
141 if (!tmp) 140 if (!tmp)
142 { 141 {
143 for (pl = first_player; pl; pl = pl->next) 142 for_all_players (pl)
144 if (pl->ob->container == op->env) 143 if (pl->ob->container == op->env)
144 {
145 tmp = pl->ob;
145 break; 146 break;
146 147 }
147 if (pl)
148 tmp = pl->ob;
149 else
150 tmp = NULL;
151 } 148 }
152 149
153 if (tmp) 150 if (tmp)
154 esrv_send_item (tmp, op); 151 esrv_send_item (tmp, op);
155 } 152 }
… …
169 */ 166 */
170static void 167static void
171send_removed_object (object *op) 168send_removed_object (object *op)
172{ 169{
173 object *tmp; 170 object *tmp;
174 player *pl;
175 171
176 if (op->env == NULL) 172 if (op->env == NULL)
177 { 173 {
178 /* no action necessary: remove_ob() notifies the client */ 174 /* no action necessary: remove_ob() notifies the client */
179 return; 175 return;
180 } 176 }
181 177
182 tmp = op->in_player (); 178 tmp = op->in_player ();
183 if (!tmp) 179 if (!tmp)
184 { 180 {
185 for (pl = first_player; pl; pl = pl->next) 181 for_all_players (pl)
186 if (pl->ob->container == op->env) 182 if (pl->ob->container == op->env)
183 {
184 tmp = pl->ob;
187 break; 185 break;
188 if (pl) 186 }
189 tmp = pl->ob;
190 else
191 tmp = NULL;
192 } 187 }
188
193 if (tmp) 189 if (tmp)
194 esrv_del_item (tmp->contr, op->count); 190 esrv_del_item (tmp->contr, op->count);
195} 191}
196 192
197extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr); 193extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr);
… …
613/* MAP RELATED HOOKS */ 609/* MAP RELATED HOOKS */
614 610
615void * 611void *
616cfapi_map_get_map (int *type, ...) 612cfapi_map_get_map (int *type, ...)
617{ 613{
618 va_list args; 614 abort ();
619 maptile *rv;
620 int ctype;
621 int x, y;
622 sint16 nx, ny;
623 char *name;
624 maptile *m;
625
626 va_start (args, type);
627
628 ctype = va_arg (args, int);
629
630 switch (ctype)
631 {
632 case 0:
633 x = va_arg (args, int);
634 y = va_arg (args, int);
635
636 rv = get_empty_map (x, y);
637 break;
638
639 case 1:
640 name = va_arg (args, char *);
641 x = va_arg (args, int);
642
643 rv = ready_map_name (name, x);
644 break;
645
646 case 2:
647 m = va_arg (args, maptile *);
648 nx = va_arg (args, int);
649 ny = va_arg (args, int);
650
651 rv = get_map_from_coord (m, &nx, &ny);
652 break;
653
654 case 3:
655 rv = first_map;
656 break;
657
658 default:
659 *type = CFAPI_NONE;
660 va_end (args);
661 return NULL;
662 break;
663 }
664 va_end (args);
665 *type = CFAPI_PMAP;
666 return rv;
667} 615}
668 616
669void * 617void *
670cfapi_map_has_been_loaded (int *type, ...) 618cfapi_map_has_been_loaded (int *type, ...)
671{ 619{
672 va_list args; 620 abort ();
673 maptile *map;
674 char *string;
675
676 va_start (args, type);
677 string = va_arg (args, char *);
678
679 map = has_been_loaded (string);
680 va_end (args);
681 *type = CFAPI_PMAP;
682 return map;
683} 621}
684 622
685void * 623void *
686cfapi_map_create_path (int *type, ...) 624cfapi_map_create_path (int *type, ...)
687{ 625{
688 va_list args; 626 abort ();
689 int ctype;
690 const char *str;
691 char *rv;
692
693 va_start (args, type);
694
695 ctype = va_arg (args, int);
696 str = va_arg (args, char *);
697
698 *type = CFAPI_STRING;
699
700 switch (ctype)
701 {
702 case 0:
703 rv = (char *) create_pathname (str);
704 break;
705
706 case 1:
707 rv = (char *) create_overlay_pathname (str);
708 break;
709
710 /*case 2:
711 rv = create_items_path(str);
712 break; */
713
714 default:
715 rv = NULL;
716 *type = CFAPI_NONE;
717 break;
718 }
719 va_end (args);
720 return rv;
721} 627}
722 628
723void * 629void *
724cfapi_map_get_map_property (int *type, ...) 630cfapi_map_get_map_property (int *type, ...)
725{ 631{
726 va_list args; 632 abort ();
727 int x, y;
728 sint16 nx, ny;
729 maptile *map;
730 maptile *newmap;
731 static int rv;
732 int property;
733 char *buf;
734
735 va_start (args, type);
736
737 property = va_arg (args, int);
738
739 switch (property)
740 {
741 case CFAPI_MAP_PROP_FLAGS:
742 map = va_arg (args, maptile *);
743 newmap = va_arg (args, maptile *);
744 x = va_arg (args, int);
745 y = va_arg (args, int);
746 nx = va_arg (args, int);
747 ny = va_arg (args, int);
748
749 rv = get_map_flags (map, &newmap, x, y, &nx, &ny);
750 va_end (args);
751 *type = CFAPI_INT;
752 return &rv;
753 break;
754
755 case CFAPI_MAP_PROP_DIFFICULTY:
756 map = va_arg (args, maptile *);
757
758 rv = calculate_difficulty (map);
759 va_end (args);
760 *type = CFAPI_INT;
761 return &rv;
762 break;
763
764 case CFAPI_MAP_PROP_PATH:
765 map = va_arg (args, maptile *);
766
767 buf = map->path;
768 *type = CFAPI_STRING;
769 va_end (args);
770 return buf;
771 break;
772
773 case CFAPI_MAP_PROP_TMPNAME:
774 map = va_arg (args, maptile *);
775
776 buf = map->tmpname;
777 *type = CFAPI_STRING;
778 va_end (args);
779 return buf;
780 break;
781
782 case CFAPI_MAP_PROP_NAME:
783 map = va_arg (args, maptile *);
784
785 buf = map->name;
786 *type = CFAPI_STRING;
787 va_end (args);
788 return buf;
789 break;
790
791 case CFAPI_MAP_PROP_RESET_TIME:
792 map = va_arg (args, maptile *);
793
794 rv = map->reset_time;
795 *type = CFAPI_INT;
796 va_end (args);
797 return &rv;
798 break;
799
800 case CFAPI_MAP_PROP_RESET_TIMEOUT:
801 map = va_arg (args, maptile *);
802
803 rv = map->reset_timeout;
804 *type = CFAPI_INT;
805 va_end (args);
806 return &rv;
807 break;
808
809 case CFAPI_MAP_PROP_PLAYERS:
810 map = va_arg (args, maptile *);
811
812 rv = map->players;
813 *type = CFAPI_INT;
814 va_end (args);
815 return &rv;
816 break;
817
818 case CFAPI_MAP_PROP_DARKNESS:
819 map = va_arg (args, maptile *);
820
821 rv = map->darkness;
822 *type = CFAPI_INT;
823 va_end (args);
824 return &rv;
825 break;
826
827 case CFAPI_MAP_PROP_WIDTH:
828 map = va_arg (args, maptile *);
829
830 rv = map->width;
831 *type = CFAPI_INT;
832 va_end (args);
833 return &rv;
834 break;
835
836 case CFAPI_MAP_PROP_HEIGHT:
837 map = va_arg (args, maptile *);
838
839 rv = map->height;
840 *type = CFAPI_INT;
841 va_end (args);
842 return &rv;
843 break;
844
845 case CFAPI_MAP_PROP_ENTER_X:
846 map = va_arg (args, maptile *);
847
848 rv = map->enter_x;
849 *type = CFAPI_INT;
850 va_end (args);
851 return &rv;
852 break;
853
854 case CFAPI_MAP_PROP_ENTER_Y:
855 map = va_arg (args, maptile *);
856
857 rv = map->enter_y;
858 *type = CFAPI_INT;
859 va_end (args);
860 return &rv;
861 break;
862
863 case CFAPI_MAP_PROP_TEMPERATURE:
864 map = va_arg (args, maptile *);
865
866 rv = map->temp;
867 *type = CFAPI_INT;
868 va_end (args);
869 return &rv;
870 break;
871
872 case CFAPI_MAP_PROP_PRESSURE:
873 map = va_arg (args, maptile *);
874
875 rv = map->pressure;
876 *type = CFAPI_INT;
877 va_end (args);
878 return &rv;
879 break;
880
881 case CFAPI_MAP_PROP_HUMIDITY:
882 map = va_arg (args, maptile *);
883
884 rv = map->humid;
885 *type = CFAPI_INT;
886 va_end (args);
887 return &rv;
888 break;
889
890 case CFAPI_MAP_PROP_WINDSPEED:
891 map = va_arg (args, maptile *);
892
893 rv = map->windspeed;
894 *type = CFAPI_INT;
895 va_end (args);
896 return &rv;
897 break;
898
899 case CFAPI_MAP_PROP_WINDDIR:
900 map = va_arg (args, maptile *);
901
902 rv = map->winddir;
903 *type = CFAPI_INT;
904 va_end (args);
905 return &rv;
906 break;
907
908 case CFAPI_MAP_PROP_SKY:
909 map = va_arg (args, maptile *);
910
911 rv = map->sky;
912 *type = CFAPI_INT;
913 va_end (args);
914 return &rv;
915 break;
916
917 case CFAPI_MAP_PROP_WPARTX:
918 map = va_arg (args, maptile *);
919
920 rv = map->wpartx;
921 *type = CFAPI_INT;
922 va_end (args);
923 return &rv;
924 break;
925
926 case CFAPI_MAP_PROP_WPARTY:
927 map = va_arg (args, maptile *);
928
929 rv = map->wparty;
930 *type = CFAPI_INT;
931 va_end (args);
932 return &rv;
933 break;
934
935 case CFAPI_MAP_PROP_MESSAGE:
936 map = va_arg (args, maptile *);
937
938 buf = map->msg;
939 *type = CFAPI_STRING;
940 va_end (args);
941 return buf;
942 break;
943
944 case CFAPI_MAP_PROP_NEXT:
945 map = va_arg (args, maptile *);
946
947 *type = CFAPI_PMAP;
948 va_end (args);
949 return map->next;
950 break;
951
952 case CFAPI_MAP_PROP_REGION:
953 map = va_arg (args, maptile *);
954
955 *type = CFAPI_PREGION;
956 va_end (args);
957 return get_region_by_map (map);
958 break;
959
960 default:
961 *type = CFAPI_NONE;
962 va_end (args);
963 return NULL;
964 break;
965 }
966} 633}
967 634
968void * 635void *
969cfapi_map_set_map_property (int *type, ...) 636cfapi_map_set_map_property (int *type, ...)
970{ 637{
971 va_list args; 638 abort ();
972 static int rv;
973 maptile *map;
974 int val;
975 int property;
976
977 va_start (args, type);
978
979 property = va_arg (args, int);
980
981 switch (property)
982 {
983 case CFAPI_MAP_PROP_LIGHT:
984 map = va_arg (args, maptile *);
985 val = va_arg (args, int);
986
987 rv = change_map_light (map, val);
988 *type = CFAPI_INT;
989 va_end (args);
990 return &rv;
991 break;
992
993 case CFAPI_MAP_PROP_RESET_TIME:
994 map = va_arg (args, maptile *);
995
996 *type = CFAPI_NONE;
997 va_end (args);
998 return NULL;
999 break;
1000
1001 default:
1002 *type = CFAPI_NONE;
1003 va_end (args);
1004 return NULL;
1005 break;
1006 }
1007} 639}
640
1008void * 641void *
1009cfapi_map_out_of_map (int *type, ...) 642cfapi_map_out_of_map (int *type, ...)
1010{ 643{
644 abort ();
645}
646
647void *
648cfapi_map_update_position (int *type, ...)
649{
1011 va_list args; 650 va_list args;
1012 static int rv;
1013 maptile *map; 651 maptile *map;
1014 int x, y; 652 int x, y;
1015 653
1016 va_start (args, type); 654 va_start (args, type);
655
1017 map = va_arg (args, maptile *); 656 map = va_arg (args, maptile *);
1018 x = va_arg (args, int); 657 x = va_arg (args, int);
1019 y = va_arg (args, int); 658 y = va_arg (args, int);
1020 659
1021 rv = out_of_map (map, x, y); 660 map->at (x, y).flags_ &= ~P_UPTODATE;
1022 va_end (args);
1023 *type = CFAPI_INT;
1024 return &rv;
1025}
1026 661
1027void *
1028cfapi_map_update_position (int *type, ...)
1029{
1030 va_list args;
1031 maptile *map;
1032 int x, y;
1033
1034 va_start (args, type);
1035
1036 map = va_arg (args, maptile *);
1037 x = va_arg (args, int);
1038 y = va_arg (args, int);
1039
1040 update_position (map, x, y);
1041 va_end (args); 662 va_end (args);
1042 *type = CFAPI_NONE; 663 *type = CFAPI_NONE;
1043 return NULL; 664 return NULL;
1044} 665}
1045 666
1046void * 667void *
1047cfapi_map_delete_map (int *type, ...) 668cfapi_map_delete_map (int *type, ...)
1048{ 669{
1049 va_list args; 670 abort ();
1050 maptile *map;
1051
1052 va_start (args, type);
1053
1054 map = va_arg (args, maptile *);
1055
1056 delete_map (map);
1057
1058 va_end (args);
1059 *type = CFAPI_NONE;
1060 return NULL;
1061} 671}
1062 672
1063void * 673void *
1064cfapi_map_message (int *type, ...) 674cfapi_map_message (int *type, ...)
1065{ 675{
… …
1229} 839}
1230 840
1231void * 841void *
1232cfapi_object_get_property (int *type, ...) 842cfapi_object_get_property (int *type, ...)
1233{ 843{
1234 va_list args; 844 abort ();
1235 int property;
1236 object *op;
1237 void *rv;
1238 static int ri;
1239
1240 va_start (args, type);
1241
1242 op = va_arg (args, object *);
1243 property = va_arg (args, int);
1244
1245 rv = NULL;
1246 if (op != NULL)
1247 {
1248 switch (property)
1249 {
1250 case CFAPI_OBJECT_PROP_OB_ABOVE:
1251 rv = op->above;
1252 *type = CFAPI_POBJECT;
1253 break;
1254
1255 case CFAPI_OBJECT_PROP_OB_BELOW:
1256 rv = op->below;
1257 *type = CFAPI_POBJECT;
1258 break;
1259
1260 case CFAPI_OBJECT_PROP_NEXT_ACTIVE_OB:
1261 rv = op->active_next;
1262 *type = CFAPI_POBJECT;
1263 break;
1264
1265 case CFAPI_OBJECT_PROP_PREV_ACTIVE_OB:
1266 rv = op->active_prev;
1267 *type = CFAPI_POBJECT;
1268 break;
1269
1270 case CFAPI_OBJECT_PROP_INVENTORY:
1271 rv = op->inv;
1272 *type = CFAPI_POBJECT;
1273 break;
1274
1275 case CFAPI_OBJECT_PROP_ENVIRONMENT:
1276 rv = op->env;
1277 *type = CFAPI_POBJECT;
1278 break;
1279
1280 case CFAPI_OBJECT_PROP_HEAD:
1281 rv = op->head;
1282 *type = CFAPI_POBJECT;
1283 break;
1284
1285 case CFAPI_OBJECT_PROP_CONTAINER:
1286 rv = op->container;
1287 *type = CFAPI_POBJECT;
1288 break;
1289
1290 case CFAPI_OBJECT_PROP_MAP:
1291 rv = op->map;
1292 *type = CFAPI_PMAP;
1293 break;
1294
1295 case CFAPI_OBJECT_PROP_COUNT:
1296 ri = op->count;
1297 rv = &ri;
1298 *type = CFAPI_INT;
1299 break;
1300
1301 case CFAPI_OBJECT_PROP_REFCOUNT:
1302 abort ();
1303 break;
1304
1305 case CFAPI_OBJECT_PROP_NAME:
1306 rv = query_name (op);
1307 *type = CFAPI_STRING;
1308 break;
1309
1310 case CFAPI_OBJECT_PROP_NAME_PLURAL:
1311 rv = (char *) &op->name_pl;
1312 *type = CFAPI_STRING;
1313 break;
1314
1315 case CFAPI_OBJECT_PROP_TITLE:
1316 rv = (char *) &op->title;
1317 *type = CFAPI_STRING;
1318 break;
1319
1320 case CFAPI_OBJECT_PROP_RACE:
1321 rv = (char *) &op->race;
1322 *type = CFAPI_STRING;
1323 break;
1324
1325 case CFAPI_OBJECT_PROP_SLAYING:
1326 rv = (char *) &op->slaying;
1327 *type = CFAPI_STRING;
1328 break;
1329
1330 case CFAPI_OBJECT_PROP_SKILL:
1331 rv = (char *) &op->skill;
1332 *type = CFAPI_STRING;
1333 break;
1334
1335 case CFAPI_OBJECT_PROP_MESSAGE:
1336 rv = (char *) &op->msg;
1337 if (rv == NULL)
1338 rv = (void *) "";
1339 *type = CFAPI_STRING;
1340 break;
1341
1342 case CFAPI_OBJECT_PROP_LORE:
1343 rv = (char *) &op->lore;
1344 *type = CFAPI_STRING;
1345 break;
1346
1347 case CFAPI_OBJECT_PROP_X:
1348 ri = op->x;
1349 rv = &ri;
1350 *type = CFAPI_INT;
1351 break;
1352
1353 case CFAPI_OBJECT_PROP_Y:
1354 ri = op->y;
1355 rv = &ri;
1356 *type = CFAPI_INT;
1357 break;
1358
1359 case CFAPI_OBJECT_PROP_SPEED:
1360 rv = &op->speed;
1361 *type = CFAPI_DOUBLE;
1362 break;
1363
1364 case CFAPI_OBJECT_PROP_SPEED_LEFT:
1365 rv = &op->speed_left;
1366 *type = CFAPI_DOUBLE;
1367 break;
1368
1369 case CFAPI_OBJECT_PROP_NROF:
1370 ri = op->nrof;
1371 rv = &ri;
1372 *type = CFAPI_INT;
1373 break;
1374
1375 case CFAPI_OBJECT_PROP_DIRECTION:
1376 ri = op->direction;
1377 rv = &ri;
1378 *type = CFAPI_INT;
1379 break;
1380
1381 case CFAPI_OBJECT_PROP_FACING:
1382 ri = op->facing;
1383 rv = &ri;
1384 *type = CFAPI_INT;
1385 break;
1386
1387 case CFAPI_OBJECT_PROP_TYPE:
1388 ri = op->type;
1389 rv = &ri;
1390 *type = CFAPI_INT;
1391 break;
1392
1393 case CFAPI_OBJECT_PROP_SUBTYPE:
1394 ri = op->subtype;
1395 rv = &ri;
1396 *type = CFAPI_INT;
1397 break;
1398
1399 case CFAPI_OBJECT_PROP_CLIENT_TYPE:
1400 ri = op->client_type;
1401 rv = &ri;
1402 *type = CFAPI_INT;
1403 break;
1404
1405 case CFAPI_OBJECT_PROP_RESIST:
1406 {
1407 int idx;
1408 idx = va_arg (args, int);
1409
1410 ri = op->resist[idx];
1411 rv = &ri;
1412 }
1413 *type = CFAPI_INT;
1414 break;
1415
1416 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
1417 ri = op->attacktype;
1418 rv = &ri;
1419 *type = CFAPI_INT;
1420 break;
1421
1422 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
1423 ri = op->path_attuned;
1424 rv = &ri;
1425 *type = CFAPI_INT;
1426 break;
1427
1428 case CFAPI_OBJECT_PROP_PATH_REPELLED:
1429 ri = op->path_repelled;
1430 rv = &ri;
1431 *type = CFAPI_INT;
1432 break;
1433
1434 case CFAPI_OBJECT_PROP_PATH_DENIED:
1435 ri = op->path_denied;
1436 rv = &ri;
1437 *type = CFAPI_INT;
1438 break;
1439
1440 case CFAPI_OBJECT_PROP_MATERIAL:
1441 ri = op->material;
1442 rv = &ri;
1443 *type = CFAPI_INT;
1444 break;
1445
1446 case CFAPI_OBJECT_PROP_MAGIC:
1447 ri = op->magic;
1448 rv = &ri;
1449 *type = CFAPI_INT;
1450 break;
1451
1452 case CFAPI_OBJECT_PROP_VALUE:
1453 ri = op->value;
1454 rv = &ri;
1455 *type = CFAPI_INT;
1456 break;
1457
1458 case CFAPI_OBJECT_PROP_LEVEL:
1459 ri = op->level;
1460 rv = &ri;
1461 *type = CFAPI_INT;
1462 break;
1463
1464 case CFAPI_OBJECT_PROP_LAST_HEAL:
1465 ri = op->last_heal;
1466 rv = &ri;
1467 *type = CFAPI_INT;
1468 break;
1469
1470 case CFAPI_OBJECT_PROP_LAST_SP:
1471 ri = op->last_sp;
1472 rv = &ri;
1473 *type = CFAPI_INT;
1474 break;
1475
1476 case CFAPI_OBJECT_PROP_LAST_GRACE:
1477 ri = op->last_grace;
1478 rv = &ri;
1479 *type = CFAPI_INT;
1480 break;
1481
1482 case CFAPI_OBJECT_PROP_LAST_EAT:
1483 ri = op->last_eat;
1484 rv = &ri;
1485 *type = CFAPI_INT;
1486 break;
1487
1488 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
1489 ri = op->invisible;
1490 rv = &ri;
1491 *type = CFAPI_INT;
1492 break;
1493
1494 case CFAPI_OBJECT_PROP_PICK_UP:
1495 ri = op->pick_up;
1496 rv = &ri;
1497 *type = CFAPI_INT;
1498 break;
1499
1500 case CFAPI_OBJECT_PROP_ITEM_POWER:
1501 ri = op->item_power;
1502 rv = &ri;
1503 *type = CFAPI_INT;
1504 break;
1505
1506 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
1507 ri = op->gen_sp_armour;
1508 rv = &ri;
1509 *type = CFAPI_INT;
1510 break;
1511
1512 case CFAPI_OBJECT_PROP_WEIGHT:
1513 ri = op->weight;
1514 rv = &ri;
1515 *type = CFAPI_INT;
1516 break;
1517
1518 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
1519 ri = op->weight_limit;
1520 rv = &ri;
1521 *type = CFAPI_INT;
1522 break;
1523
1524 case CFAPI_OBJECT_PROP_CARRYING:
1525 ri = op->carrying;
1526 rv = &ri;
1527 *type = CFAPI_INT;
1528 break;
1529
1530 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
1531 ri = op->glow_radius;
1532 rv = &ri;
1533 *type = CFAPI_INT;
1534 break;
1535
1536 case CFAPI_OBJECT_PROP_PERM_EXP:
1537 rv = &op->perm_exp;
1538 *type = CFAPI_LONG;
1539 break;
1540
1541 case CFAPI_OBJECT_PROP_CURRENT_WEAPON:
1542 rv = op->current_weapon;
1543 *type = CFAPI_POBJECT;
1544 break;
1545
1546 case CFAPI_OBJECT_PROP_ENEMY:
1547 rv = op->enemy;
1548 *type = CFAPI_POBJECT;
1549 break;
1550
1551 case CFAPI_OBJECT_PROP_ATTACKED_BY:
1552 rv = op->attacked_by;
1553 *type = CFAPI_POBJECT;
1554 break;
1555
1556 case CFAPI_OBJECT_PROP_RUN_AWAY:
1557 ri = op->run_away;
1558 rv = &ri;
1559 *type = CFAPI_INT;
1560 break;
1561
1562 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
1563 rv = op->chosen_skill;
1564 *type = CFAPI_POBJECT;
1565 break;
1566
1567 case CFAPI_OBJECT_PROP_HIDDEN:
1568 ri = op->hide;
1569 rv = &ri;
1570 *type = CFAPI_INT;
1571 break;
1572
1573 case CFAPI_OBJECT_PROP_MOVE_STATUS:
1574 ri = op->move_status;
1575 rv = &ri;
1576 *type = CFAPI_INT;
1577 break;
1578
1579 case CFAPI_OBJECT_PROP_MOVE_TYPE:
1580 ri = op->attack_movement;
1581 rv = &ri;
1582 *type = CFAPI_INT;
1583 break;
1584
1585 case CFAPI_OBJECT_PROP_SPELL_ITEM:
1586 rv = op->spellitem;
1587 *type = CFAPI_POBJECT;
1588 break;
1589
1590 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
1591 rv = &op->expmul;
1592 *type = CFAPI_DOUBLE;
1593 break;
1594
1595 case CFAPI_OBJECT_PROP_ARCHETYPE:
1596 rv = op->arch;
1597 *type = CFAPI_PARCH;
1598 break;
1599
1600 case CFAPI_OBJECT_PROP_OTHER_ARCH:
1601 rv = op->other_arch;
1602 *type = CFAPI_PARCH;
1603 break;
1604
1605 case CFAPI_OBJECT_PROP_ANIM_SPEED:
1606 ri = op->anim_speed;
1607 rv = &ri;
1608 *type = CFAPI_INT;
1609 break;
1610
1611 case CFAPI_OBJECT_PROP_FRIENDLY:
1612 ri = is_friendly (op);
1613 rv = &ri;
1614 *type = CFAPI_INT;
1615 break;
1616
1617 case CFAPI_OBJECT_PROP_BASE_NAME:
1618 {
1619 int i;
1620 i = va_arg (args, int);
1621
1622 rv = (char *) query_base_name (op, i);
1623 *type = CFAPI_STRING;
1624 }
1625 break;
1626
1627 case CFAPI_OBJECT_PROP_MAGICAL:
1628 ri = is_magical (op);
1629 rv = &ri;
1630 *type = CFAPI_INT;
1631 break;
1632
1633 case CFAPI_OBJECT_PROP_LUCK:
1634 ri = op->stats.luck;
1635 rv = &ri;
1636 *type = CFAPI_INT;
1637 break;
1638
1639 case CFAPI_OBJECT_PROP_EXP:
1640 rv = &op->stats.exp;
1641 *type = CFAPI_LONG;
1642 break;
1643
1644 case CFAPI_OBJECT_PROP_OWNER:
1645 rv = op->owner;
1646 *type = CFAPI_POBJECT;
1647 break;
1648
1649 case CFAPI_OBJECT_PROP_PRESENT:
1650 {
1651 int stype;
1652
1653 rv = 0;
1654 stype = va_arg (args, int);
1655
1656 switch (stype)
1657 {
1658
1659 unsigned char ptype;
1660 char *buf;
1661 archetype *at;
1662
1663 case 0: /* present_in_ob */
1664 ptype = (unsigned char) (va_arg (args, int));
1665
1666 rv = present_in_ob (ptype, op);
1667 break;
1668
1669 case 1: /* present_in_ob_by_name */
1670 ptype = (unsigned char) (va_arg (args, int));
1671 buf = va_arg (args, char *);
1672
1673 rv = present_in_ob_by_name (ptype, buf, op);
1674 break;
1675
1676 case 2: /* present_arch_in_ob */
1677 at = va_arg (args, archetype *);
1678
1679 rv = present_arch_in_ob (at, op);
1680 break;
1681 }
1682 }
1683 *type = CFAPI_POBJECT;
1684 break;
1685
1686 case CFAPI_OBJECT_PROP_CHEATER:
1687 ri = (QUERY_FLAG (op, FLAG_WAS_WIZ));
1688 rv = &ri;
1689 *type = CFAPI_INT;
1690 break;
1691
1692 case CFAPI_OBJECT_PROP_MERGEABLE:
1693 {
1694 object *op2;
1695 op2 = va_arg (args, object *);
1696
1697 ri = object::can_merge_slow (op, op2);
1698 rv = &ri;
1699 }
1700 *type = CFAPI_INT;
1701 break;
1702
1703 case CFAPI_OBJECT_PROP_PICKABLE:
1704 {
1705 object *op2;
1706
1707 rv = 0;
1708 op2 = va_arg (args, object *);
1709
1710 ri = can_pick (op2, op);
1711 rv = &ri;
1712 }
1713 *type = CFAPI_INT;
1714 break;
1715
1716 case CFAPI_OBJECT_PROP_FLAGS:
1717 {
1718 int fl;
1719
1720 ri = 0;
1721 fl = va_arg (args, int);
1722
1723 ri = QUERY_FLAG (op, fl);
1724 rv = &ri;
1725 }
1726 *type = CFAPI_INT;
1727 break;
1728
1729 case CFAPI_OBJECT_PROP_STR:
1730 ri = op->stats.Str;
1731 rv = &ri;
1732 *type = CFAPI_INT;
1733 break;
1734
1735 case CFAPI_OBJECT_PROP_DEX:
1736 ri = op->stats.Dex;
1737 rv = &ri;
1738 *type = CFAPI_INT;
1739 break;
1740
1741 case CFAPI_OBJECT_PROP_CON:
1742 ri = op->stats.Con;
1743 rv = &ri;
1744 *type = CFAPI_INT;
1745 break;
1746
1747 case CFAPI_OBJECT_PROP_WIS:
1748 ri = op->stats.Wis;
1749 rv = &ri;
1750 *type = CFAPI_INT;
1751 break;
1752
1753 case CFAPI_OBJECT_PROP_INT:
1754 ri = op->stats.Int;
1755 rv = &ri;
1756 *type = CFAPI_INT;
1757 break;
1758
1759 case CFAPI_OBJECT_PROP_POW:
1760 ri = op->stats.Pow;
1761 rv = &ri;
1762 *type = CFAPI_INT;
1763 break;
1764
1765 case CFAPI_OBJECT_PROP_CHA:
1766 ri = op->stats.Cha;
1767 rv = &ri;
1768 *type = CFAPI_INT;
1769 break;
1770
1771 case CFAPI_OBJECT_PROP_WC:
1772 ri = op->stats.wc;
1773 rv = &ri;
1774 *type = CFAPI_INT;
1775 break;
1776
1777 case CFAPI_OBJECT_PROP_AC:
1778 ri = op->stats.ac;
1779 rv = &ri;
1780 *type = CFAPI_INT;
1781 break;
1782
1783 case CFAPI_OBJECT_PROP_HP:
1784 ri = op->stats.hp;
1785 rv = &ri;
1786 *type = CFAPI_INT;
1787 break;
1788
1789 case CFAPI_OBJECT_PROP_SP:
1790 ri = op->stats.sp;
1791 rv = &ri;
1792 *type = CFAPI_INT;
1793 break;
1794
1795 case CFAPI_OBJECT_PROP_GP:
1796 ri = op->stats.grace;
1797 rv = &ri;
1798 *type = CFAPI_INT;
1799 break;
1800
1801 case CFAPI_OBJECT_PROP_FP:
1802 ri = op->stats.food;
1803 rv = &ri;
1804 *type = CFAPI_INT;
1805 break;
1806
1807 case CFAPI_OBJECT_PROP_MAXHP:
1808 ri = op->stats.maxhp;
1809 rv = &ri;
1810 *type = CFAPI_INT;
1811 break;
1812
1813 case CFAPI_OBJECT_PROP_MAXSP:
1814 ri = op->stats.maxsp;
1815 rv = &ri;
1816 *type = CFAPI_INT;
1817 break;
1818
1819 case CFAPI_OBJECT_PROP_MAXGP:
1820 ri = op->stats.maxgrace;
1821 rv = &ri;
1822 *type = CFAPI_INT;
1823 break;
1824
1825 case CFAPI_OBJECT_PROP_DAM:
1826 ri = op->stats.dam;
1827 rv = &ri;
1828 *type = CFAPI_INT;
1829 break;
1830
1831 case CFAPI_OBJECT_PROP_GOD:
1832 rv = (char *) determine_god (op);
1833 *type = CFAPI_STRING;
1834 break;
1835
1836 case CFAPI_OBJECT_PROP_ARCH_NAME:
1837 rv = (char *) &op->arch->name;
1838 *type = CFAPI_STRING;
1839 break;
1840
1841 case CFAPI_OBJECT_PROP_INVISIBLE:
1842 ri = op->invisible;
1843 rv = &ri;
1844 *type = CFAPI_INT;
1845 break;
1846
1847 case CFAPI_OBJECT_PROP_FACE:
1848 ri = op->animation_id;
1849 rv = &ri;
1850 *type = CFAPI_INT;
1851 break;
1852
1853 case CFAPI_PLAYER_PROP_IP:
1854 rv = op->contr->socket->host;
1855 *type = CFAPI_STRING;
1856 break;
1857
1858 case CFAPI_PLAYER_PROP_MARKED_ITEM:
1859 rv = find_marked_object (op);
1860 *type = CFAPI_POBJECT;
1861 break;
1862
1863 case CFAPI_PLAYER_PROP_PARTY:
1864 rv = (op->contr ? op->contr->party : NULL);
1865 *type = CFAPI_PPARTY;
1866 break;
1867 default:
1868 *type = CFAPI_NONE;
1869 break;
1870 }
1871 }
1872 va_end (args);
1873 return rv;
1874} 845}
1875 846
1876void * 847void *
1877cfapi_object_set_property (int *type, ...) 848cfapi_object_set_property (int *type, ...)
1878{ 849{
1879 va_list args; 850 abort ();
1880 int iarg;
1881 long larg;
1882 char *sarg;
1883 double darg;
1884 object *oparg;
1885 object *op;
1886 int property;
1887 void *rv;
1888 partylist *partyarg;
1889
1890 va_start (args, type);
1891
1892 op = va_arg (args, object *);
1893 property = va_arg (args, int);
1894
1895 rv = NULL;
1896
1897 if (op != NULL && (!op->arch || (op != &op->arch->clone)))
1898 {
1899 switch (property)
1900 {
1901 case CFAPI_OBJECT_PROP_NAME:
1902 sarg = va_arg (args, char *);
1903
1904#define FREE_AND_COPY(a,b) (a) = (b) // TODO: remove, but plugins.C is considered zombie code
1905 FREE_AND_COPY (op->name, sarg);
1906 send_changed_object (op);
1907 break;
1908
1909 case CFAPI_OBJECT_PROP_NAME_PLURAL:
1910 sarg = va_arg (args, char *);
1911
1912 FREE_AND_COPY (op->name_pl, sarg);
1913 send_changed_object (op);
1914 break;
1915
1916 case CFAPI_OBJECT_PROP_TITLE:
1917 sarg = va_arg (args, char *);
1918
1919 FREE_AND_COPY (op->title, sarg);
1920 break;
1921
1922 case CFAPI_OBJECT_PROP_RACE:
1923 sarg = va_arg (args, char *);
1924
1925 FREE_AND_COPY (op->race, sarg);
1926 break;
1927
1928 case CFAPI_OBJECT_PROP_SLAYING:
1929 sarg = va_arg (args, char *);
1930
1931 FREE_AND_COPY (op->slaying, sarg);
1932 break;
1933
1934 case CFAPI_OBJECT_PROP_SKILL:
1935 sarg = va_arg (args, char *);
1936
1937 FREE_AND_COPY (op->skill, sarg);
1938 break;
1939
1940 case CFAPI_OBJECT_PROP_MESSAGE:
1941 sarg = va_arg (args, char *);
1942
1943 FREE_AND_COPY (op->msg, sarg);
1944 break;
1945
1946 case CFAPI_OBJECT_PROP_LORE:
1947 sarg = va_arg (args, char *);
1948
1949 FREE_AND_COPY (op->lore, sarg);
1950 break;
1951
1952 case CFAPI_OBJECT_PROP_SPEED:
1953 darg = va_arg (args, double);
1954
1955 op->speed = darg;
1956 break;
1957
1958 case CFAPI_OBJECT_PROP_SPEED_LEFT:
1959 darg = va_arg (args, double);
1960
1961 op->speed_left = darg;
1962 break;
1963
1964 case CFAPI_OBJECT_PROP_NROF:
1965 iarg = va_arg (args, int);
1966
1967 if (iarg < 0)
1968 iarg = 0;
1969 if (op->nrof > (uint32) iarg)
1970 decrease_ob_nr (op, op->nrof - iarg);
1971 else if (op->nrof < (uint32) iarg)
1972 {
1973 object *tmp;
1974 player *pl;
1975
1976 op->nrof = iarg;
1977 if (op->env != NULL)
1978 {
1979 tmp = op->in_player ();
1980 if (!tmp)
1981 {
1982 for (pl = first_player; pl; pl = pl->next)
1983 if (pl->ob->container == op->env)
1984 break;
1985 if (pl)
1986 tmp = pl->ob;
1987 else
1988 tmp = NULL;
1989 }
1990 else
1991 {
1992 sum_weight (tmp);
1993 fix_player (tmp);
1994 }
1995 if (tmp)
1996 esrv_send_item (tmp, op);
1997 }
1998 else
1999 {
2000 object *above = op->above;
2001
2002 for (tmp = above; tmp != NULL; tmp = tmp->above)
2003 if (tmp->type == PLAYER)
2004 esrv_send_item (tmp, op);
2005 }
2006 }
2007 break;
2008
2009 case CFAPI_OBJECT_PROP_DIRECTION:
2010 iarg = va_arg (args, int);
2011
2012 op->direction = iarg;
2013 break;
2014
2015 case CFAPI_OBJECT_PROP_FACING:
2016 iarg = va_arg (args, int);
2017
2018 op->facing = iarg;
2019 break;
2020
2021 case CFAPI_OBJECT_PROP_RESIST:
2022 {
2023 int iargbis = va_arg (args, int);
2024 iarg = va_arg (args, int);
2025
2026 op->resist[iargbis] = iarg;
2027 }
2028 break;
2029
2030 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
2031 iarg = va_arg (args, int);
2032
2033 op->attacktype = iarg;
2034 break;
2035
2036 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
2037 iarg = va_arg (args, int);
2038
2039 op->path_attuned = iarg;
2040 break;
2041
2042 case CFAPI_OBJECT_PROP_PATH_REPELLED:
2043 iarg = va_arg (args, int);
2044
2045 op->path_repelled = iarg;
2046 break;
2047
2048 case CFAPI_OBJECT_PROP_PATH_DENIED:
2049 iarg = va_arg (args, int);
2050
2051 op->path_denied = iarg;
2052 break;
2053
2054 case CFAPI_OBJECT_PROP_MATERIAL:
2055 iarg = va_arg (args, int);
2056
2057 op->material = iarg;
2058 break;
2059
2060 case CFAPI_OBJECT_PROP_MATERIAL_NAME:
2061 break;
2062
2063 case CFAPI_OBJECT_PROP_MAGIC:
2064 iarg = va_arg (args, int);
2065
2066 op->magic = iarg;
2067 break;
2068
2069 case CFAPI_OBJECT_PROP_VALUE:
2070 iarg = va_arg (args, int);
2071
2072 op->value = iarg;
2073 break;
2074
2075 case CFAPI_OBJECT_PROP_LEVEL:
2076 iarg = va_arg (args, int);
2077
2078 op->level = iarg;
2079 break;
2080
2081 case CFAPI_OBJECT_PROP_LAST_HEAL:
2082 iarg = va_arg (args, int);
2083
2084 op->last_heal = iarg;
2085 break;
2086
2087 case CFAPI_OBJECT_PROP_LAST_SP:
2088 iarg = va_arg (args, int);
2089
2090 op->last_sp = iarg;
2091 break;
2092
2093 case CFAPI_OBJECT_PROP_LAST_GRACE:
2094 iarg = va_arg (args, int);
2095
2096 op->last_grace = iarg;
2097 break;
2098
2099 case CFAPI_OBJECT_PROP_LAST_EAT:
2100 iarg = va_arg (args, int);
2101
2102 op->last_eat = iarg;
2103 break;
2104
2105 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
2106 iarg = va_arg (args, int);
2107
2108 op->invisible = iarg;
2109 break;
2110
2111 case CFAPI_OBJECT_PROP_PICK_UP:
2112 iarg = va_arg (args, int);
2113
2114 op->pick_up = iarg;
2115 break;
2116
2117 case CFAPI_OBJECT_PROP_ITEM_POWER:
2118 iarg = va_arg (args, int);
2119
2120 op->item_power = iarg;
2121 break;
2122
2123 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
2124 iarg = va_arg (args, int);
2125
2126 op->gen_sp_armour = iarg;
2127 break;
2128
2129 case CFAPI_OBJECT_PROP_WEIGHT:
2130 iarg = va_arg (args, int);
2131
2132 if (op->weight != iarg)
2133 {
2134 object *tmp;
2135 player *pl;
2136
2137 op->weight = iarg;
2138 if (op->env != NULL)
2139 {
2140 tmp = op->in_player ();
2141 if (!tmp)
2142 {
2143 for (pl = first_player; pl; pl = pl->next)
2144 if (pl->ob->container == op->env)
2145 break;
2146 if (pl)
2147 tmp = pl->ob;
2148 else
2149 tmp = NULL;
2150 }
2151 else
2152 {
2153 sum_weight (tmp);
2154 fix_player (tmp);
2155 }
2156 if (tmp)
2157 esrv_send_item (tmp, op);
2158 }
2159 else
2160 {
2161 object *above = op->above;
2162
2163 for (tmp = above; tmp != NULL; tmp = tmp->above)
2164 if (tmp->type == PLAYER)
2165 esrv_send_item (tmp, op);
2166 }
2167 }
2168 break;
2169
2170 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
2171 iarg = va_arg (args, int);
2172
2173 op->weight_limit = iarg;
2174 break;
2175
2176 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
2177 iarg = va_arg (args, int);
2178
2179 op->glow_radius = iarg;
2180 break;
2181
2182 case CFAPI_OBJECT_PROP_PERM_EXP:
2183 larg = va_arg (args, long);
2184
2185 op->perm_exp = larg;
2186 break;
2187
2188 case CFAPI_OBJECT_PROP_ENEMY:
2189 oparg = va_arg (args, object *);
2190
2191 op->enemy = oparg;
2192 break;
2193
2194 case CFAPI_OBJECT_PROP_RUN_AWAY:
2195 iarg = va_arg (args, int);
2196
2197 op->run_away = iarg;
2198 break;
2199
2200 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
2201 oparg = va_arg (args, object *);
2202
2203 op->chosen_skill = oparg;
2204 break;
2205
2206 case CFAPI_OBJECT_PROP_HIDDEN:
2207 iarg = va_arg (args, int);
2208
2209 op->hide = iarg;
2210 break;
2211
2212 case CFAPI_OBJECT_PROP_MOVE_STATUS:
2213 iarg = va_arg (args, int);
2214
2215 op->move_status = iarg;
2216 break;
2217
2218 case CFAPI_OBJECT_PROP_MOVE_TYPE:
2219 iarg = va_arg (args, int);
2220
2221 op->attack_movement = iarg;
2222 break;
2223
2224 case CFAPI_OBJECT_PROP_SPELL_ITEM:
2225 oparg = va_arg (args, object *);
2226
2227 op->spellitem = oparg;
2228 break;
2229
2230 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
2231 darg = va_arg (args, double);
2232
2233 op->expmul = darg;
2234 break;
2235
2236 case CFAPI_OBJECT_PROP_CUSTOM_NAME:
2237 sarg = va_arg (args, char *);
2238
2239 FREE_AND_COPY (op->custom_name, sarg);
2240 send_changed_object (op);
2241 break;
2242
2243 case CFAPI_OBJECT_PROP_ANIM_SPEED:
2244 iarg = va_arg (args, int);
2245
2246 op->anim_speed = iarg;
2247 break;
2248
2249 case CFAPI_OBJECT_PROP_FRIENDLY:
2250 iarg = va_arg (args, int);
2251
2252 if (iarg == 1 && is_friendly (op) == 0)
2253 add_friendly_object (op);
2254 else if (iarg == 0 && is_friendly (op) == 1)
2255 remove_friendly_object (op);
2256 break;
2257
2258 case CFAPI_OBJECT_PROP_LUCK:
2259 iarg = va_arg (args, int);
2260
2261 op->stats.luck = iarg;
2262 break;
2263
2264 case CFAPI_OBJECT_PROP_EXP:
2265 {
2266 char *skillname;
2267
2268 larg = va_arg (args, long);
2269 skillname = va_arg (args, char *);
2270 iarg = va_arg (args, int);
2271
2272 change_exp (op, larg, skillname, iarg);
2273 }
2274 break;
2275
2276 case CFAPI_OBJECT_PROP_OWNER:
2277 oparg = va_arg (args, object *);
2278
2279 op->set_owner (oparg);
2280 break;
2281
2282 case CFAPI_OBJECT_PROP_CHEATER:
2283 set_cheat (op);
2284 break;
2285
2286 case CFAPI_OBJECT_PROP_FLAGS:
2287 {
2288 int iargbis;
2289 iarg = va_arg (args, int);
2290 iargbis = va_arg (args, int);
2291
2292 if (iargbis == 1)
2293 SET_FLAG (op, iarg);
2294 else
2295 CLEAR_FLAG (op, iarg);
2296 }
2297 break;
2298
2299 case CFAPI_OBJECT_PROP_STR:
2300 iarg = va_arg (args, int);
2301
2302 op->stats.Str = iarg;
2303 break;
2304
2305 case CFAPI_OBJECT_PROP_DEX:
2306 iarg = va_arg (args, int);
2307
2308 op->stats.Dex = iarg;
2309 break;
2310
2311 case CFAPI_OBJECT_PROP_CON:
2312 iarg = va_arg (args, int);
2313
2314 op->stats.Con = iarg;
2315 break;
2316
2317 case CFAPI_OBJECT_PROP_WIS:
2318 iarg = va_arg (args, int);
2319
2320 op->stats.Wis = iarg;
2321 break;
2322
2323 case CFAPI_OBJECT_PROP_INT:
2324 iarg = va_arg (args, int);
2325
2326 op->stats.Int = iarg;
2327 break;
2328
2329 case CFAPI_OBJECT_PROP_POW:
2330 iarg = va_arg (args, int);
2331
2332 op->stats.Pow = iarg;
2333 break;
2334
2335 case CFAPI_OBJECT_PROP_CHA:
2336 iarg = va_arg (args, int);
2337
2338 op->stats.Cha = iarg;
2339 break;
2340
2341 case CFAPI_OBJECT_PROP_WC:
2342 iarg = va_arg (args, int);
2343
2344 op->stats.wc = iarg;
2345 break;
2346
2347 case CFAPI_OBJECT_PROP_AC:
2348 iarg = va_arg (args, int);
2349
2350 op->stats.ac = iarg;
2351 break;
2352
2353 case CFAPI_OBJECT_PROP_HP:
2354 iarg = va_arg (args, int);
2355
2356 op->stats.hp = iarg;
2357 break;
2358
2359 case CFAPI_OBJECT_PROP_SP:
2360 iarg = va_arg (args, int);
2361
2362 op->stats.sp = iarg;
2363 break;
2364
2365 case CFAPI_OBJECT_PROP_GP:
2366 iarg = va_arg (args, int);
2367
2368 op->stats.grace = iarg;
2369 break;
2370
2371 case CFAPI_OBJECT_PROP_FP:
2372 iarg = va_arg (args, int);
2373
2374 op->stats.food = iarg;
2375 break;
2376
2377 case CFAPI_OBJECT_PROP_MAXHP:
2378 iarg = va_arg (args, int);
2379
2380 op->stats.maxhp = iarg;
2381 break;
2382
2383 case CFAPI_OBJECT_PROP_MAXSP:
2384 iarg = va_arg (args, int);
2385
2386 op->stats.maxsp = iarg;
2387 break;
2388
2389 case CFAPI_OBJECT_PROP_MAXGP:
2390 iarg = va_arg (args, int);
2391
2392 op->stats.maxgrace = iarg;
2393 break;
2394
2395 case CFAPI_OBJECT_PROP_DAM:
2396 iarg = va_arg (args, int);
2397
2398 op->stats.dam = iarg;
2399 break;
2400
2401 case CFAPI_OBJECT_PROP_FACE:
2402 iarg = va_arg (args, int);
2403
2404 op->animation_id = iarg;
2405 update_object (op, UP_OBJ_FACE);
2406 break;
2407
2408 case CFAPI_OBJECT_ANIMATION:
2409 iarg = va_arg (args, int);
2410
2411 if (iarg != -1)
2412 {
2413 SET_ANIMATION (op, iarg);
2414 }
2415 update_object (op, UP_OBJ_FACE);
2416 break;
2417
2418 case CFAPI_PLAYER_PROP_MARKED_ITEM:
2419 if (op->contr)
2420 {
2421 oparg = va_arg (args, object *);
2422
2423 op->contr->mark = oparg;
2424 }
2425 break;
2426
2427 case CFAPI_PLAYER_PROP_PARTY:
2428 if (op->contr)
2429 {
2430 partyarg = va_arg (args, partylist *);
2431
2432 op->contr->party = partyarg;
2433 }
2434 break;
2435
2436 default:
2437 *type = CFAPI_NONE;
2438 break;
2439 }
2440 }
2441 va_end (args);
2442
2443 *type = CFAPI_NONE;
2444 return NULL;
2445} 851}
2446 852
2447void * 853void *
2448cfapi_object_apply_below (int *type, ...) 854cfapi_object_apply_below (int *type, ...)
2449{ 855{
… …
2519} 925}
2520 926
2521void * 927void *
2522cfapi_object_drain (int *type, ...) 928cfapi_object_drain (int *type, ...)
2523{ 929{
2524 va_list args; 930 abort ();
2525
2526 object *op;
2527 int ds;
2528
2529 va_start (args, type);
2530
2531 op = va_arg (args, object *);
2532 ds = va_arg (args, int);
2533
2534 va_end (args);
2535
2536 drain_specific_stat (op, ds);
2537
2538 *type = CFAPI_NONE;
2539 return NULL;
2540} 931}
2541 932
2542void * 933void *
2543cfapi_object_fix (int *type, ...) 934cfapi_object_fix (int *type, ...)
2544{ 935{
… …
2549 940
2550 op = va_arg (args, object *); 941 op = va_arg (args, object *);
2551 942
2552 va_end (args); 943 va_end (args);
2553 944
2554 fix_player (op); 945 op->update_stats ();
2555 946
2556 *type = CFAPI_NONE; 947 *type = CFAPI_NONE;
2557 return NULL; 948 return NULL;
2558} 949}
2559 950
… …
2903} 1294}
2904 1295
2905void * 1296void *
2906cfapi_object_clear (int *type, ...) 1297cfapi_object_clear (int *type, ...)
2907{ 1298{
2908 va_list args; 1299 abort ();
2909 object *op;
2910
2911 va_start (args, type);
2912
2913 op = va_arg (args, object *);
2914
2915 va_end (args);
2916
2917 op->clear ();
2918 *type = CFAPI_NONE;
2919 return NULL;
2920} 1300}
2921 1301
2922void * 1302void *
2923cfapi_object_reset (int *type, ...) 1303cfapi_object_reset (int *type, ...)
2924{ 1304{
… …
2957} 1337}
2958 1338
2959void * 1339void *
2960cfapi_object_clean_object (int *type, ...) 1340cfapi_object_clean_object (int *type, ...)
2961{ 1341{
2962 va_list args; 1342 abort ();
2963 object *op;
2964
2965 va_start (args, type);
2966 op = va_arg (args, object *);
2967
2968 clean_object (op);
2969 va_end (args);
2970 *type = CFAPI_NONE;
2971 return NULL;
2972} 1343}
2973 1344
2974void * 1345void *
2975cfapi_object_on_same_map (int *type, ...) 1346cfapi_object_on_same_map (int *type, ...)
2976{ 1347{
… …
3313 drop (author, op); 1684 drop (author, op);
3314 1685
3315 if (author->type == PLAYER) 1686 if (author->type == PLAYER)
3316 { 1687 {
3317 author->contr->count = 0; 1688 author->contr->count = 0;
3318 author->contr->socket->floorbox_update (); 1689 author->contr->ns->floorbox_update ();
3319 } 1690 }
3320 1691
3321 *type = CFAPI_NONE; 1692 *type = CFAPI_NONE;
3322 return NULL; 1693 return NULL;
3323} 1694}
… …
3354 1725
3355/* PLAYER SUBCLASS */ 1726/* PLAYER SUBCLASS */
3356void * 1727void *
3357cfapi_player_find (int *type, ...) 1728cfapi_player_find (int *type, ...)
3358{ 1729{
3359 va_list args; 1730 abort ();
3360 void *rv;
3361 char *sval;
3362
3363 va_start (args, type);
3364
3365 sval = va_arg (args, char *);
3366
3367 va_end (args);
3368
3369 rv = find_player (sval);
3370
3371 *type = CFAPI_PPLAYER;
3372 return rv;
3373} 1731}
3374 1732
3375void * 1733void *
3376cfapi_player_message (int *type, ...) 1734cfapi_player_message (int *type, ...)
3377{ 1735{
… …
3524 1882
3525/* Party-related functions */ 1883/* Party-related functions */
3526void * 1884void *
3527cfapi_party_get_property (int *type, ...) 1885cfapi_party_get_property (int *type, ...)
3528{ 1886{
3529 partylist *party; 1887 abort ();
1888}
1889
1890/* Regions-related functions */
1891void *
1892cfapi_region_get_property (int *type, ...)
1893{
1894 region *reg;
3530 int prop; 1895 int prop;
3531 va_list args; 1896 va_list args;
3532 void *rv; 1897 void *rv;
3533 object *obarg;
3534 player *pl;
3535 1898
3536 va_start (args, type); 1899 va_start (args, type);
3537 party = va_arg (args, partylist *); 1900 reg = va_arg (args, region *);
3538 prop = va_arg (args, int); 1901 prop = va_arg (args, int);
3539 1902
3540 switch (prop) 1903 switch (prop)
3541 { 1904 {
3542 case CFAPI_PARTY_PROP_NAME: 1905 case CFAPI_REGION_PROP_NAME:
3543 *type = CFAPI_STRING; 1906 *type = CFAPI_STRING;
3544 rv = (void *) party->partyname; 1907 rv = (void *) reg->name;
3545 break; 1908 break;
3546 1909
3547 case CFAPI_PARTY_PROP_NEXT: 1910 case CFAPI_REGION_PROP_NEXT:
3548 *type = CFAPI_PPARTY; 1911 *type = CFAPI_PREGION;
3549 rv = (party ? party->next : get_firstparty ()); 1912 rv = (reg ? reg->next : first_region);
3550 break; 1913 break;
3551 1914
3552 case CFAPI_PARTY_PROP_PASSWORD: 1915 case CFAPI_REGION_PROP_PARENT:
1916 *type = CFAPI_PREGION;
1917 rv = (void *) reg->parent;
1918 break;
1919
1920 case CFAPI_REGION_PROP_LONGNAME:
3553 *type = CFAPI_STRING; 1921 *type = CFAPI_STRING;
3554 rv = (void *) party->passwd; 1922 rv = (void *) reg->longname;
3555 break;
3556
3557 case CFAPI_PARTY_PROP_PLAYER:
3558 *type = CFAPI_PPLAYER;
3559 obarg = va_arg (args, object *);
3560
3561 pl = (obarg ? obarg->contr : first_player);
3562 rv = NULL;
3563 for (; pl != NULL; pl = pl->next)
3564 if (pl->ob->contr->party == party)
3565 {
3566 rv = (void *) pl;
3567 break; 1923 break;
3568 } 1924
1925 case CFAPI_REGION_PROP_MESSAGE:
1926 *type = CFAPI_STRING;
1927 rv = (void *) reg->msg;
3569 break; 1928 break;
3570 1929
3571 default: 1930 default:
3572 *type = CFAPI_NONE; 1931 *type = CFAPI_NONE;
3573 rv = NULL; 1932 rv = NULL;
… …
3575 } 1934 }
3576 va_end (args); 1935 va_end (args);
3577 return rv; 1936 return rv;
3578} 1937}
3579 1938
3580/* Regions-related functions */
3581void *
3582cfapi_region_get_property (int *type, ...)
3583{
3584 region *reg;
3585 int prop;
3586 va_list args;
3587 void *rv;
3588
3589 va_start (args, type);
3590 reg = va_arg (args, region *);
3591 prop = va_arg (args, int);
3592
3593 switch (prop)
3594 {
3595 case CFAPI_REGION_PROP_NAME:
3596 *type = CFAPI_STRING;
3597 rv = (void *) reg->name;
3598 break;
3599
3600 case CFAPI_REGION_PROP_NEXT:
3601 *type = CFAPI_PREGION;
3602 rv = (reg ? reg->next : first_region);
3603 break;
3604
3605 case CFAPI_REGION_PROP_PARENT:
3606 *type = CFAPI_PREGION;
3607 rv = (void *) reg->parent;
3608 break;
3609
3610 case CFAPI_REGION_PROP_LONGNAME:
3611 *type = CFAPI_STRING;
3612 rv = (void *) reg->longname;
3613 break;
3614
3615 case CFAPI_REGION_PROP_MESSAGE:
3616 *type = CFAPI_STRING;
3617 rv = (void *) reg->msg;
3618 break;
3619
3620 default:
3621 *type = CFAPI_NONE;
3622 rv = NULL;
3623 break;
3624 }
3625 va_end (args);
3626 return rv;
3627}
3628
3629/*****************************************************************************/ 1939/*****************************************************************************/
3630 1940
3631/* NEW PLUGIN STUFF ENDS HERE */ 1941/* NEW PLUGIN STUFF ENDS HERE */
3632 1942
3633/*****************************************************************************/ 1943/*****************************************************************************/
… …
3661 return NULL; 1971 return NULL;
3662} 1972}
3663 1973
3664/*****************************************************************************/ 1974/*****************************************************************************/
3665 1975
3666/* Plugins initialization. Browses the plugins directory and call */ 1976/* Plugins initialisation. Browses the plugins directory and call */
3667 1977
3668/* initOnePlugin for each file found. */ 1978/* initOnePlugin for each file found. */
3669 1979
3670/* Returns 0 if at least one plugin was successfully loaded, -1 if not */ 1980/* Returns 0 if at least one plugin was successfully loaded, -1 if not */
3671 1981
… …
3678 size_t l; 1988 size_t l;
3679 char buf[MAX_BUF]; 1989 char buf[MAX_BUF];
3680 char buf2[MAX_BUF]; 1990 char buf2[MAX_BUF];
3681 int result; 1991 int result;
3682 1992
3683 LOG (llevInfo, "Initializing plugins\n"); 1993 LOG (llevInfo, "Initialising plugins\n");
3684 strcpy (buf, LIBDIR); 1994 strcpy (buf, LIBDIR);
3685 strcat (buf, "/plugins/"); 1995 strcat (buf, "/plugins/");
3686 LOG (llevInfo, "Plugins directory is %s\n", buf); 1996 LOG (llevInfo, "Plugins directory is %s\n", buf);
3687 1997
3688 plugins_init_perl (); 1998 plugins_init_perl ();

Diff Legend

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