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.34 by root, Sat Dec 23 13:56:25 2006 UTC vs.
Revision 1.42 by root, Mon Feb 5 01:47:23 2007 UTC

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

Diff Legend

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