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.23 by root, Wed Dec 13 03:28:42 2006 UTC vs.
Revision 1.51 by root, Thu Jul 26 00:27:09 2007 UTC

1/*****************************************************************************/ 1/*
2/* CrossFire, A Multiplayer game for X-windows */ 2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3/* */ 3 *
4/* Copyright (C) 2000 Mark Wedel */ 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5/* Copyright (C) 1992 Frank Tore Johansen */ 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6/* */ 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 *
7/* This program is free software; you can redistribute it and/or modify */ 8 * Crossfire TRT is free software: you can redistribute it and/or modify
8/* it under the terms of the GNU General Public License as published by */ 9 * it under the terms of the GNU General Public License as published by
9/* the Free Software Foundation; either version 2 of the License, or */ 10 * the Free Software Foundation, either version 3 of the License, or
10/* (at your option) any later version. */ 11 * (at your option) any later version.
11/* */ 12 *
12/* This program is distributed in the hope that it will be useful, */ 13 * This program is distributed in the hope that it will be useful,
13/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15/* GNU General Public License for more details. */ 16 * GNU General Public License for more details.
16/* */ 17 *
17/* You should have received a copy of the GNU General Public License */ 18 * You should have received a copy of the GNU General Public License
18/* along with this program; if not, write to the Free Software */ 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 20 *
20/* */ 21 * The authors can be reached via e-mail to <crossfire@schmorp.de>
22 */
23
21/*****************************************************************************/ 24/*****************************************************************************/
22/* This is the server-side plugin management part. */ 25/* This is the server-side plugin management part. */
23/*****************************************************************************/ 26/*****************************************************************************/
24/* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */ 27/* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */
25/* Special thanks to: */ 28/* Special thanks to: */
26/* David Delbecq (david.delbecq@mailandnews.com); */ 29/* David Delbecq (david.delbecq@mailandnews.com); */
27/* Joris Bontje (jbontje@suespammers.org); */ 30/* Joris Bontje (jbontje@suespammers.org); */
28/* Philip Currlin (?); */ 31/* Philip Currlin (?); */
29/*****************************************************************************/ 32/*****************************************************************************/
33
30/*****************************************************************************/ 34/*****************************************************************************/
31/* First, the headers. We only include plugin.h, because all other includes */ 35/* First, the headers. We only include plugin.h, because all other includes */
32/* are done into it, and plugproto.h (which is used only by this file). */ 36/* are done into it, and plugproto.h (which is used only by this file). */
33/*****************************************************************************/ 37/*****************************************************************************/
34 38
… …
41#define NR_OF_HOOKS 74 45#define NR_OF_HOOKS 74
42 46
43static const hook_entry plug_hooks[NR_OF_HOOKS] = { 47static const hook_entry plug_hooks[NR_OF_HOOKS] = {
44 {cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"}, 48 {cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"},
45 {cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"}, 49 {cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"},
46 {cfapi_system_check_path, 4, "cfapi_system_check_path"}, 50 {NULL, 4, "cfapi_system_check_path"},
47 {NULL, 5, "cfapi_system_re_cmp"}, 51 {NULL, 5, "cfapi_system_re_cmp"},
48 {cfapi_system_strdup_local, 6, "cfapi_system_strdup_local"}, 52 {cfapi_system_strdup, 6, "cfapi_system_strdup"},
49 {cfapi_system_directory, 7, "cfapi_system_directory"}, 53 {cfapi_system_directory, 7, "cfapi_system_directory"},
50 {cfapi_system_find_animation, 8, "cfapi_system_find_animation"}, 54 {cfapi_system_find_animation, 8, "cfapi_system_find_animation"},
51 {cfapi_object_clean_object, 9, "cfapi_object_clean_object"}, 55 {cfapi_object_clean_object, 9, "cfapi_object_clean_object"},
52 {cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"}, 56 {cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"},
53 {cfapi_object_get_key, 11, "cfapi_object_get_key"}, 57 {cfapi_object_get_key, 11, "cfapi_object_get_key"},
… …
122/* NEW PLUGIN STUFF STARTS HERE */ 126/* NEW PLUGIN STUFF STARTS HERE */
123 127
124/*****************************************************************************/ 128/*****************************************************************************/
125 129
126/** 130/**
127 * Notify clients about a changed object.
128 *
129 * @param op the object that has changed
130 */
131static void
132send_changed_object (object *op)
133{
134 object *tmp;
135 player *pl;
136
137 if (op->env != NULL)
138 {
139 tmp = is_player_inv (op->env);
140 if (!tmp)
141 {
142 for (pl = first_player; pl; pl = pl->next)
143 if (pl->ob->container == op->env)
144 break;
145 if (pl)
146 tmp = pl->ob;
147 else
148 tmp = NULL;
149 }
150 if (tmp)
151 esrv_send_item (tmp, op);
152 }
153 else
154 {
155 for (tmp = op->above; tmp != NULL; tmp = tmp->above)
156 if (tmp->type == PLAYER)
157 esrv_send_item (tmp, op);
158 }
159}
160
161/**
162 * Notify clients about a removed object. 131 * Notify clients about a removed object.
163 * 132 *
164 * @param op the object about to be removed from its environment; it must still 133 * @param op the object about to be removed from its environment; it must still
165 * be present in its environment 134 * be present in its environment
166 */ 135 */
167static void 136static void
168send_removed_object (object *op) 137send_removed_object (object *op)
169{ 138{
170 object *tmp; 139 object *tmp;
171 player *pl;
172 140
173 if (op->env == NULL) 141 if (op->env == NULL)
174 { 142 {
175 /* no action necessary: remove_ob() notifies the client */ 143 /* no action necessary: remove_ob() notifies the client */
176 return; 144 return;
177 } 145 }
178 146
179 tmp = is_player_inv (op->env); 147 tmp = op->in_player ();
180 if (!tmp) 148 if (!tmp)
181 { 149 {
182 for (pl = first_player; pl; pl = pl->next) 150 for_all_players (pl)
183 if (pl->ob->container == op->env) 151 if (pl->ob->container == op->env)
152 {
153 tmp = pl->ob;
184 break; 154 break;
185 if (pl) 155 }
186 tmp = pl->ob;
187 else
188 tmp = NULL;
189 } 156 }
157
190 if (tmp) 158 if (tmp)
191 esrv_del_item (tmp->contr, op->count); 159 esrv_del_item (tmp->contr, op->count);
192} 160}
193 161
194extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr); 162extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr);
… …
482 *type = CFAPI_INT; 450 *type = CFAPI_INT;
483 return &rv; 451 return &rv;
484} 452}
485 453
486void * 454void *
487cfapi_system_strdup_local (int *type, ...) 455cfapi_system_strdup (int *type, ...)
488{ 456{
489 va_list args; 457 va_list args;
490 char *txt; 458 char *txt;
491 459
492 va_start (args, type); 460 va_start (args, type);
493 txt = va_arg (args, char *); 461 txt = va_arg (args, char *);
494 462
495 va_end (args); 463 va_end (args);
496 *type = CFAPI_STRING; 464 *type = CFAPI_STRING;
497 return strdup_local (txt); 465 return strdup (txt);
498} 466}
499 467
500void * 468void *
501cfapi_system_register_global_event (int *type, ...) 469cfapi_system_register_global_event (int *type, ...)
502{ 470{
… …
538} 506}
539 507
540void * 508void *
541cfapi_system_check_path (int *type, ...) 509cfapi_system_check_path (int *type, ...)
542{ 510{
543 va_list args; 511 abort ();
544 static int rv;
545 char *name;
546 int prepend_dir;
547
548 va_start (args, type);
549
550 name = va_arg (args, char *);
551 prepend_dir = va_arg (args, int);
552
553 rv = check_path (name, prepend_dir);
554
555 va_end (args);
556 *type = CFAPI_INT;
557 return &rv;
558} 512}
559 513
560void * 514void *
561cfapi_system_directory (int *type, ...) 515cfapi_system_directory (int *type, ...)
562{ 516{
… …
572 *type = CFAPI_STRING; 526 *type = CFAPI_STRING;
573 527
574 switch (dirtype) 528 switch (dirtype)
575 { 529 {
576 case 0: 530 case 0:
577 return settings.mapdir; 531 return (char *)settings.mapdir;
578 break; 532 break;
579 533
580 case 1: 534 case 1:
581 return settings.uniquedir; 535 return (char *)settings.uniquedir;
582 break; 536 break;
583 537
584 case 2: 538 case 2:
585 return settings.tmpdir; 539 return (char *)settings.tmpdir;
586 break; 540 break;
587 541
588 case 3: 542 case 3:
589 return settings.confdir; 543 return (char *)settings.confdir;
590 break; 544 break;
591 545
592 case 4: 546 case 4:
593 return settings.localdir; 547 return (char *)settings.localdir;
594 break; 548 break;
595 549
596 case 5: 550 case 5:
597 return settings.playerdir; 551 return (char *)settings.playerdir;
598 break; 552 break;
599 553
600 case 6: 554 case 6:
601 return settings.datadir; 555 return (char *)settings.datadir;
602 break; 556 break;
603 } 557 }
604 558
605 *type = CFAPI_NONE; 559 *type = CFAPI_NONE;
606 return NULL; 560 return NULL;
… …
610/* MAP RELATED HOOKS */ 564/* MAP RELATED HOOKS */
611 565
612void * 566void *
613cfapi_map_get_map (int *type, ...) 567cfapi_map_get_map (int *type, ...)
614{ 568{
615 va_list args; 569 abort ();
616 maptile *rv;
617 int ctype;
618 int x, y;
619 sint16 nx, ny;
620 char *name;
621 maptile *m;
622
623 va_start (args, type);
624
625 ctype = va_arg (args, int);
626
627 switch (ctype)
628 {
629 case 0:
630 x = va_arg (args, int);
631 y = va_arg (args, int);
632
633 rv = get_empty_map (x, y);
634 break;
635
636 case 1:
637 name = va_arg (args, char *);
638 x = va_arg (args, int);
639
640 rv = ready_map_name (name, x);
641 break;
642
643 case 2:
644 m = va_arg (args, maptile *);
645 nx = va_arg (args, int);
646 ny = va_arg (args, int);
647
648 rv = get_map_from_coord (m, &nx, &ny);
649 break;
650
651 case 3:
652 rv = first_map;
653 break;
654
655 default:
656 *type = CFAPI_NONE;
657 va_end (args);
658 return NULL;
659 break;
660 }
661 va_end (args);
662 *type = CFAPI_PMAP;
663 return rv;
664} 570}
665 571
666void * 572void *
667cfapi_map_has_been_loaded (int *type, ...) 573cfapi_map_has_been_loaded (int *type, ...)
668{ 574{
669 va_list args; 575 abort ();
670 maptile *map;
671 char *string;
672
673 va_start (args, type);
674 string = va_arg (args, char *);
675
676 map = has_been_loaded (string);
677 va_end (args);
678 *type = CFAPI_PMAP;
679 return map;
680} 576}
681 577
682void * 578void *
683cfapi_map_create_path (int *type, ...) 579cfapi_map_create_path (int *type, ...)
684{ 580{
685 va_list args; 581 abort ();
686 int ctype;
687 const char *str;
688 char *rv;
689
690 va_start (args, type);
691
692 ctype = va_arg (args, int);
693 str = va_arg (args, char *);
694
695 *type = CFAPI_STRING;
696
697 switch (ctype)
698 {
699 case 0:
700 rv = (char *) create_pathname (str);
701 break;
702
703 case 1:
704 rv = (char *) create_overlay_pathname (str);
705 break;
706
707 /*case 2:
708 rv = create_items_path(str);
709 break; */
710
711 default:
712 rv = NULL;
713 *type = CFAPI_NONE;
714 break;
715 }
716 va_end (args);
717 return rv;
718} 582}
719 583
720void * 584void *
721cfapi_map_get_map_property (int *type, ...) 585cfapi_map_get_map_property (int *type, ...)
722{ 586{
723 va_list args; 587 abort ();
724 int x, y;
725 sint16 nx, ny;
726 maptile *map;
727 maptile *newmap;
728 static int rv;
729 int property;
730 char *buf;
731
732 va_start (args, type);
733
734 property = va_arg (args, int);
735
736 switch (property)
737 {
738 case CFAPI_MAP_PROP_FLAGS:
739 map = va_arg (args, maptile *);
740 newmap = va_arg (args, maptile *);
741 x = va_arg (args, int);
742 y = va_arg (args, int);
743 nx = va_arg (args, int);
744 ny = va_arg (args, int);
745
746 rv = get_map_flags (map, &newmap, x, y, &nx, &ny);
747 va_end (args);
748 *type = CFAPI_INT;
749 return &rv;
750 break;
751
752 case CFAPI_MAP_PROP_DIFFICULTY:
753 map = va_arg (args, maptile *);
754
755 rv = calculate_difficulty (map);
756 va_end (args);
757 *type = CFAPI_INT;
758 return &rv;
759 break;
760
761 case CFAPI_MAP_PROP_PATH:
762 map = va_arg (args, maptile *);
763
764 buf = map->path;
765 *type = CFAPI_STRING;
766 va_end (args);
767 return buf;
768 break;
769
770 case CFAPI_MAP_PROP_TMPNAME:
771 map = va_arg (args, maptile *);
772
773 buf = map->tmpname;
774 *type = CFAPI_STRING;
775 va_end (args);
776 return buf;
777 break;
778
779 case CFAPI_MAP_PROP_NAME:
780 map = va_arg (args, maptile *);
781
782 buf = map->name;
783 *type = CFAPI_STRING;
784 va_end (args);
785 return buf;
786 break;
787
788 case CFAPI_MAP_PROP_RESET_TIME:
789 map = va_arg (args, maptile *);
790
791 rv = map->reset_time;
792 *type = CFAPI_INT;
793 va_end (args);
794 return &rv;
795 break;
796
797 case CFAPI_MAP_PROP_RESET_TIMEOUT:
798 map = va_arg (args, maptile *);
799
800 rv = map->reset_timeout;
801 *type = CFAPI_INT;
802 va_end (args);
803 return &rv;
804 break;
805
806 case CFAPI_MAP_PROP_PLAYERS:
807 map = va_arg (args, maptile *);
808
809 rv = map->players;
810 *type = CFAPI_INT;
811 va_end (args);
812 return &rv;
813 break;
814
815 case CFAPI_MAP_PROP_DARKNESS:
816 map = va_arg (args, maptile *);
817
818 rv = map->darkness;
819 *type = CFAPI_INT;
820 va_end (args);
821 return &rv;
822 break;
823
824 case CFAPI_MAP_PROP_WIDTH:
825 map = va_arg (args, maptile *);
826
827 rv = map->width;
828 *type = CFAPI_INT;
829 va_end (args);
830 return &rv;
831 break;
832
833 case CFAPI_MAP_PROP_HEIGHT:
834 map = va_arg (args, maptile *);
835
836 rv = map->height;
837 *type = CFAPI_INT;
838 va_end (args);
839 return &rv;
840 break;
841
842 case CFAPI_MAP_PROP_ENTER_X:
843 map = va_arg (args, maptile *);
844
845 rv = map->enter_x;
846 *type = CFAPI_INT;
847 va_end (args);
848 return &rv;
849 break;
850
851 case CFAPI_MAP_PROP_ENTER_Y:
852 map = va_arg (args, maptile *);
853
854 rv = map->enter_y;
855 *type = CFAPI_INT;
856 va_end (args);
857 return &rv;
858 break;
859
860 case CFAPI_MAP_PROP_TEMPERATURE:
861 map = va_arg (args, maptile *);
862
863 rv = map->temp;
864 *type = CFAPI_INT;
865 va_end (args);
866 return &rv;
867 break;
868
869 case CFAPI_MAP_PROP_PRESSURE:
870 map = va_arg (args, maptile *);
871
872 rv = map->pressure;
873 *type = CFAPI_INT;
874 va_end (args);
875 return &rv;
876 break;
877
878 case CFAPI_MAP_PROP_HUMIDITY:
879 map = va_arg (args, maptile *);
880
881 rv = map->humid;
882 *type = CFAPI_INT;
883 va_end (args);
884 return &rv;
885 break;
886
887 case CFAPI_MAP_PROP_WINDSPEED:
888 map = va_arg (args, maptile *);
889
890 rv = map->windspeed;
891 *type = CFAPI_INT;
892 va_end (args);
893 return &rv;
894 break;
895
896 case CFAPI_MAP_PROP_WINDDIR:
897 map = va_arg (args, maptile *);
898
899 rv = map->winddir;
900 *type = CFAPI_INT;
901 va_end (args);
902 return &rv;
903 break;
904
905 case CFAPI_MAP_PROP_SKY:
906 map = va_arg (args, maptile *);
907
908 rv = map->sky;
909 *type = CFAPI_INT;
910 va_end (args);
911 return &rv;
912 break;
913
914 case CFAPI_MAP_PROP_WPARTX:
915 map = va_arg (args, maptile *);
916
917 rv = map->wpartx;
918 *type = CFAPI_INT;
919 va_end (args);
920 return &rv;
921 break;
922
923 case CFAPI_MAP_PROP_WPARTY:
924 map = va_arg (args, maptile *);
925
926 rv = map->wparty;
927 *type = CFAPI_INT;
928 va_end (args);
929 return &rv;
930 break;
931
932 case CFAPI_MAP_PROP_MESSAGE:
933 map = va_arg (args, maptile *);
934
935 buf = map->msg;
936 *type = CFAPI_STRING;
937 va_end (args);
938 return buf;
939 break;
940
941 case CFAPI_MAP_PROP_NEXT:
942 map = va_arg (args, maptile *);
943
944 *type = CFAPI_PMAP;
945 va_end (args);
946 return map->next;
947 break;
948
949 case CFAPI_MAP_PROP_REGION:
950 map = va_arg (args, maptile *);
951
952 *type = CFAPI_PREGION;
953 va_end (args);
954 return get_region_by_map (map);
955 break;
956
957 default:
958 *type = CFAPI_NONE;
959 va_end (args);
960 return NULL;
961 break;
962 }
963} 588}
964 589
965void * 590void *
966cfapi_map_set_map_property (int *type, ...) 591cfapi_map_set_map_property (int *type, ...)
967{ 592{
968 va_list args; 593 abort ();
969 static int rv;
970 maptile *map;
971 int val;
972 int property;
973
974 va_start (args, type);
975
976 property = va_arg (args, int);
977
978 switch (property)
979 {
980 case CFAPI_MAP_PROP_LIGHT:
981 map = va_arg (args, maptile *);
982 val = va_arg (args, int);
983
984 rv = change_map_light (map, val);
985 *type = CFAPI_INT;
986 va_end (args);
987 return &rv;
988 break;
989
990 case CFAPI_MAP_PROP_RESET_TIME:
991 map = va_arg (args, maptile *);
992
993 *type = CFAPI_NONE;
994 va_end (args);
995 return NULL;
996 break;
997
998 default:
999 *type = CFAPI_NONE;
1000 va_end (args);
1001 return NULL;
1002 break;
1003 }
1004} 594}
595
1005void * 596void *
1006cfapi_map_out_of_map (int *type, ...) 597cfapi_map_out_of_map (int *type, ...)
1007{ 598{
599 abort ();
600}
601
602void *
603cfapi_map_update_position (int *type, ...)
604{
1008 va_list args; 605 va_list args;
1009 static int rv;
1010 maptile *map; 606 maptile *map;
1011 int x, y; 607 int x, y;
1012 608
1013 va_start (args, type); 609 va_start (args, type);
610
1014 map = va_arg (args, maptile *); 611 map = va_arg (args, maptile *);
1015 x = va_arg (args, int); 612 x = va_arg (args, int);
1016 y = va_arg (args, int); 613 y = va_arg (args, int);
1017 614
1018 rv = out_of_map (map, x, y); 615 map->at (x, y).flags_ &= ~P_UPTODATE;
616
1019 va_end (args); 617 va_end (args);
1020 *type = CFAPI_INT; 618 *type = CFAPI_NONE;
1021 return &rv; 619 return NULL;
1022} 620}
1023 621
1024void * 622void *
1025cfapi_map_update_position (int *type, ...) 623cfapi_map_delete_map (int *type, ...)
624{
625 abort ();
626}
627
628void *
629cfapi_map_message (int *type, ...)
630{
631 va_list args;
632 maptile *map;
633 char *string;
634 int color;
635
636 va_start (args, type);
637 map = va_arg (args, maptile *);
638 string = va_arg (args, char *);
639 color = va_arg (args, int);
640
641 va_end (args);
642
643 new_info_map (color, map, string);
644 *type = CFAPI_NONE;
645 return NULL;
646}
647
648void *
649cfapi_map_get_object_at (int *type, ...)
1026{ 650{
1027 va_list args; 651 va_list args;
1028 maptile *map; 652 maptile *map;
1029 int x, y; 653 int x, y;
654 object *rv;
1030 655
1031 va_start (args, type); 656 va_start (args, type);
1032
1033 map = va_arg (args, maptile *); 657 map = va_arg (args, maptile *);
1034 x = va_arg (args, int); 658 x = va_arg (args, int);
1035 y = va_arg (args, int); 659 y = va_arg (args, int);
1036 660
1037 update_position (map, x, y);
1038 va_end (args); 661 va_end (args);
1039 *type = CFAPI_NONE;
1040 return NULL;
1041}
1042 662
1043void * 663 rv = GET_MAP_OB (map, x, y);
1044cfapi_map_delete_map (int *type, ...)
1045{
1046 va_list args;
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}
1059
1060void *
1061cfapi_map_message (int *type, ...)
1062{
1063 va_list args;
1064 maptile *map;
1065 char *string;
1066 int color;
1067
1068 va_start (args, type);
1069 map = va_arg (args, maptile *);
1070 string = va_arg (args, char *);
1071 color = va_arg (args, int);
1072
1073 va_end (args);
1074
1075 new_info_map (color, map, string);
1076 *type = CFAPI_NONE;
1077 return NULL;
1078}
1079
1080void *
1081cfapi_map_get_object_at (int *type, ...)
1082{
1083 va_list args;
1084 maptile *map;
1085 int x, y;
1086 object *rv;
1087
1088 va_start (args, type);
1089 map = va_arg (args, maptile *);
1090 x = va_arg (args, int);
1091 y = va_arg (args, int);
1092
1093 va_end (args);
1094
1095 rv = get_map_ob (map, x, y);
1096 *type = CFAPI_POBJECT; 664 *type = CFAPI_POBJECT;
1097 return rv; 665 return rv;
1098} 666}
1099 667
1100void * 668void *
… …
1226} 794}
1227 795
1228void * 796void *
1229cfapi_object_get_property (int *type, ...) 797cfapi_object_get_property (int *type, ...)
1230{ 798{
1231 va_list args; 799 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->socket.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} 800}
1872 801
1873void * 802void *
1874cfapi_object_set_property (int *type, ...) 803cfapi_object_set_property (int *type, ...)
1875{ 804{
1876 va_list args; 805 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 player *pl;
1972
1973 op->nrof = iarg;
1974 if (op->env != NULL)
1975 {
1976 tmp = is_player_inv (op->env);
1977 if (!tmp)
1978 {
1979 for (pl = first_player; pl; pl = pl->next)
1980 if (pl->ob->container == op->env)
1981 break;
1982 if (pl)
1983 tmp = pl->ob;
1984 else
1985 tmp = NULL;
1986 }
1987 else
1988 {
1989 sum_weight (tmp);
1990 fix_player (tmp);
1991 }
1992 if (tmp)
1993 esrv_send_item (tmp, op);
1994 }
1995 else
1996 {
1997 object *above = op->above;
1998
1999 for (tmp = above; tmp != NULL; tmp = tmp->above)
2000 if (tmp->type == PLAYER)
2001 esrv_send_item (tmp, op);
2002 }
2003 }
2004 break;
2005
2006 case CFAPI_OBJECT_PROP_DIRECTION:
2007 iarg = va_arg (args, int);
2008
2009 op->direction = iarg;
2010 break;
2011
2012 case CFAPI_OBJECT_PROP_FACING:
2013 iarg = va_arg (args, int);
2014
2015 op->facing = iarg;
2016 break;
2017
2018 case CFAPI_OBJECT_PROP_RESIST:
2019 {
2020 int iargbis = va_arg (args, int);
2021 iarg = va_arg (args, int);
2022
2023 op->resist[iargbis] = iarg;
2024 }
2025 break;
2026
2027 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
2028 iarg = va_arg (args, int);
2029
2030 op->attacktype = iarg;
2031 break;
2032
2033 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
2034 iarg = va_arg (args, int);
2035
2036 op->path_attuned = iarg;
2037 break;
2038
2039 case CFAPI_OBJECT_PROP_PATH_REPELLED:
2040 iarg = va_arg (args, int);
2041
2042 op->path_repelled = iarg;
2043 break;
2044
2045 case CFAPI_OBJECT_PROP_PATH_DENIED:
2046 iarg = va_arg (args, int);
2047
2048 op->path_denied = iarg;
2049 break;
2050
2051 case CFAPI_OBJECT_PROP_MATERIAL:
2052 iarg = va_arg (args, int);
2053
2054 op->material = iarg;
2055 break;
2056
2057 case CFAPI_OBJECT_PROP_MATERIAL_NAME:
2058 break;
2059
2060 case CFAPI_OBJECT_PROP_MAGIC:
2061 iarg = va_arg (args, int);
2062
2063 op->magic = iarg;
2064 break;
2065
2066 case CFAPI_OBJECT_PROP_VALUE:
2067 iarg = va_arg (args, int);
2068
2069 op->value = iarg;
2070 break;
2071
2072 case CFAPI_OBJECT_PROP_LEVEL:
2073 iarg = va_arg (args, int);
2074
2075 op->level = iarg;
2076 break;
2077
2078 case CFAPI_OBJECT_PROP_LAST_HEAL:
2079 iarg = va_arg (args, int);
2080
2081 op->last_heal = iarg;
2082 break;
2083
2084 case CFAPI_OBJECT_PROP_LAST_SP:
2085 iarg = va_arg (args, int);
2086
2087 op->last_sp = iarg;
2088 break;
2089
2090 case CFAPI_OBJECT_PROP_LAST_GRACE:
2091 iarg = va_arg (args, int);
2092
2093 op->last_grace = iarg;
2094 break;
2095
2096 case CFAPI_OBJECT_PROP_LAST_EAT:
2097 iarg = va_arg (args, int);
2098
2099 op->last_eat = iarg;
2100 break;
2101
2102 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
2103 iarg = va_arg (args, int);
2104
2105 op->invisible = iarg;
2106 break;
2107
2108 case CFAPI_OBJECT_PROP_PICK_UP:
2109 iarg = va_arg (args, int);
2110
2111 op->pick_up = iarg;
2112 break;
2113
2114 case CFAPI_OBJECT_PROP_ITEM_POWER:
2115 iarg = va_arg (args, int);
2116
2117 op->item_power = iarg;
2118 break;
2119
2120 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
2121 iarg = va_arg (args, int);
2122
2123 op->gen_sp_armour = iarg;
2124 break;
2125
2126 case CFAPI_OBJECT_PROP_WEIGHT:
2127 iarg = va_arg (args, int);
2128
2129 if (op->weight != iarg)
2130 {
2131 object *tmp;
2132 player *pl;
2133
2134 op->weight = iarg;
2135 if (op->env != NULL)
2136 {
2137 tmp = is_player_inv (op->env);
2138 if (!tmp)
2139 {
2140 for (pl = first_player; pl; pl = pl->next)
2141 if (pl->ob->container == op->env)
2142 break;
2143 if (pl)
2144 tmp = pl->ob;
2145 else
2146 tmp = NULL;
2147 }
2148 else
2149 {
2150 sum_weight (tmp);
2151 fix_player (tmp);
2152 }
2153 if (tmp)
2154 esrv_send_item (tmp, op);
2155 }
2156 else
2157 {
2158 object *above = op->above;
2159
2160 for (tmp = above; tmp != NULL; tmp = tmp->above)
2161 if (tmp->type == PLAYER)
2162 esrv_send_item (tmp, op);
2163 }
2164 }
2165 break;
2166
2167 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
2168 iarg = va_arg (args, int);
2169
2170 op->weight_limit = iarg;
2171 break;
2172
2173 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
2174 iarg = va_arg (args, int);
2175
2176 op->glow_radius = iarg;
2177 break;
2178
2179 case CFAPI_OBJECT_PROP_PERM_EXP:
2180 larg = va_arg (args, long);
2181
2182 op->perm_exp = larg;
2183 break;
2184
2185 case CFAPI_OBJECT_PROP_ENEMY:
2186 oparg = va_arg (args, object *);
2187
2188 op->enemy = oparg;
2189 break;
2190
2191 case CFAPI_OBJECT_PROP_RUN_AWAY:
2192 iarg = va_arg (args, int);
2193
2194 op->run_away = iarg;
2195 break;
2196
2197 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
2198 oparg = va_arg (args, object *);
2199
2200 op->chosen_skill = oparg;
2201 break;
2202
2203 case CFAPI_OBJECT_PROP_HIDDEN:
2204 iarg = va_arg (args, int);
2205
2206 op->hide = iarg;
2207 break;
2208
2209 case CFAPI_OBJECT_PROP_MOVE_STATUS:
2210 iarg = va_arg (args, int);
2211
2212 op->move_status = iarg;
2213 break;
2214
2215 case CFAPI_OBJECT_PROP_MOVE_TYPE:
2216 iarg = va_arg (args, int);
2217
2218 op->attack_movement = iarg;
2219 break;
2220
2221 case CFAPI_OBJECT_PROP_SPELL_ITEM:
2222 oparg = va_arg (args, object *);
2223
2224 op->spellitem = oparg;
2225 break;
2226
2227 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
2228 darg = va_arg (args, double);
2229
2230 op->expmul = darg;
2231 break;
2232
2233 case CFAPI_OBJECT_PROP_CUSTOM_NAME:
2234 sarg = va_arg (args, char *);
2235
2236 FREE_AND_COPY (op->custom_name, sarg);
2237 send_changed_object (op);
2238 break;
2239
2240 case CFAPI_OBJECT_PROP_ANIM_SPEED:
2241 iarg = va_arg (args, int);
2242
2243 op->anim_speed = iarg;
2244 break;
2245
2246 case CFAPI_OBJECT_PROP_FRIENDLY:
2247 iarg = va_arg (args, int);
2248
2249 if (iarg == 1 && is_friendly (op) == 0)
2250 add_friendly_object (op);
2251 else if (iarg == 0 && is_friendly (op) == 1)
2252 remove_friendly_object (op);
2253 break;
2254
2255 case CFAPI_OBJECT_PROP_LUCK:
2256 iarg = va_arg (args, int);
2257
2258 op->stats.luck = iarg;
2259 break;
2260
2261 case CFAPI_OBJECT_PROP_EXP:
2262 {
2263 char *skillname;
2264
2265 larg = va_arg (args, long);
2266 skillname = va_arg (args, char *);
2267 iarg = va_arg (args, int);
2268
2269 change_exp (op, larg, skillname, iarg);
2270 }
2271 break;
2272
2273 case CFAPI_OBJECT_PROP_OWNER:
2274 oparg = va_arg (args, object *);
2275
2276 op->set_owner (oparg);
2277 break;
2278
2279 case CFAPI_OBJECT_PROP_CHEATER:
2280 set_cheat (op);
2281 break;
2282
2283 case CFAPI_OBJECT_PROP_FLAGS:
2284 {
2285 int iargbis;
2286 iarg = va_arg (args, int);
2287 iargbis = va_arg (args, int);
2288
2289 if (iargbis == 1)
2290 SET_FLAG (op, iarg);
2291 else
2292 CLEAR_FLAG (op, iarg);
2293 }
2294 break;
2295
2296 case CFAPI_OBJECT_PROP_STR:
2297 iarg = va_arg (args, int);
2298
2299 op->stats.Str = iarg;
2300 break;
2301
2302 case CFAPI_OBJECT_PROP_DEX:
2303 iarg = va_arg (args, int);
2304
2305 op->stats.Dex = iarg;
2306 break;
2307
2308 case CFAPI_OBJECT_PROP_CON:
2309 iarg = va_arg (args, int);
2310
2311 op->stats.Con = iarg;
2312 break;
2313
2314 case CFAPI_OBJECT_PROP_WIS:
2315 iarg = va_arg (args, int);
2316
2317 op->stats.Wis = iarg;
2318 break;
2319
2320 case CFAPI_OBJECT_PROP_INT:
2321 iarg = va_arg (args, int);
2322
2323 op->stats.Int = iarg;
2324 break;
2325
2326 case CFAPI_OBJECT_PROP_POW:
2327 iarg = va_arg (args, int);
2328
2329 op->stats.Pow = iarg;
2330 break;
2331
2332 case CFAPI_OBJECT_PROP_CHA:
2333 iarg = va_arg (args, int);
2334
2335 op->stats.Cha = iarg;
2336 break;
2337
2338 case CFAPI_OBJECT_PROP_WC:
2339 iarg = va_arg (args, int);
2340
2341 op->stats.wc = iarg;
2342 break;
2343
2344 case CFAPI_OBJECT_PROP_AC:
2345 iarg = va_arg (args, int);
2346
2347 op->stats.ac = iarg;
2348 break;
2349
2350 case CFAPI_OBJECT_PROP_HP:
2351 iarg = va_arg (args, int);
2352
2353 op->stats.hp = iarg;
2354 break;
2355
2356 case CFAPI_OBJECT_PROP_SP:
2357 iarg = va_arg (args, int);
2358
2359 op->stats.sp = iarg;
2360 break;
2361
2362 case CFAPI_OBJECT_PROP_GP:
2363 iarg = va_arg (args, int);
2364
2365 op->stats.grace = iarg;
2366 break;
2367
2368 case CFAPI_OBJECT_PROP_FP:
2369 iarg = va_arg (args, int);
2370
2371 op->stats.food = iarg;
2372 break;
2373
2374 case CFAPI_OBJECT_PROP_MAXHP:
2375 iarg = va_arg (args, int);
2376
2377 op->stats.maxhp = iarg;
2378 break;
2379
2380 case CFAPI_OBJECT_PROP_MAXSP:
2381 iarg = va_arg (args, int);
2382
2383 op->stats.maxsp = iarg;
2384 break;
2385
2386 case CFAPI_OBJECT_PROP_MAXGP:
2387 iarg = va_arg (args, int);
2388
2389 op->stats.maxgrace = iarg;
2390 break;
2391
2392 case CFAPI_OBJECT_PROP_DAM:
2393 iarg = va_arg (args, int);
2394
2395 op->stats.dam = iarg;
2396 break;
2397
2398 case CFAPI_OBJECT_PROP_FACE:
2399 iarg = va_arg (args, int);
2400
2401 op->animation_id = iarg;
2402 update_object (op, UP_OBJ_FACE);
2403 break;
2404
2405 case CFAPI_OBJECT_ANIMATION:
2406 iarg = va_arg (args, int);
2407
2408 if (iarg != -1)
2409 {
2410 SET_ANIMATION (op, iarg);
2411 }
2412 update_object (op, UP_OBJ_FACE);
2413 break;
2414
2415 case CFAPI_PLAYER_PROP_MARKED_ITEM:
2416 if (op->contr)
2417 {
2418 oparg = va_arg (args, object *);
2419
2420 op->contr->mark = oparg;
2421 }
2422 break;
2423
2424 case CFAPI_PLAYER_PROP_PARTY:
2425 if (op->contr)
2426 {
2427 partyarg = va_arg (args, partylist *);
2428
2429 op->contr->party = partyarg;
2430 }
2431 break;
2432
2433 default:
2434 *type = CFAPI_NONE;
2435 break;
2436 }
2437 }
2438 va_end (args);
2439
2440 *type = CFAPI_NONE;
2441 return NULL;
2442} 806}
2443 807
2444void * 808void *
2445cfapi_object_apply_below (int *type, ...) 809cfapi_object_apply_below (int *type, ...)
2446{ 810{
… …
2510 owner = va_arg (args, object *); 874 owner = va_arg (args, object *);
2511 875
2512 va_end (args); 876 va_end (args);
2513 877
2514 *type = CFAPI_STRING; 878 *type = CFAPI_STRING;
2515 return describe_item (op, owner); 879 return (char *)describe_item (op, owner);
2516} 880}
2517 881
2518void * 882void *
2519cfapi_object_drain (int *type, ...) 883cfapi_object_drain (int *type, ...)
2520{ 884{
2521 va_list args; 885 abort ();
2522
2523 object *op;
2524 int ds;
2525
2526 va_start (args, type);
2527
2528 op = va_arg (args, object *);
2529 ds = va_arg (args, int);
2530
2531 va_end (args);
2532
2533 drain_specific_stat (op, ds);
2534
2535 *type = CFAPI_NONE;
2536 return NULL;
2537} 886}
2538 887
2539void * 888void *
2540cfapi_object_fix (int *type, ...) 889cfapi_object_fix (int *type, ...)
2541{ 890{
… …
2546 895
2547 op = va_arg (args, object *); 896 op = va_arg (args, object *);
2548 897
2549 va_end (args); 898 va_end (args);
2550 899
2551 fix_player (op); 900 op->update_stats ();
2552 901
2553 *type = CFAPI_NONE; 902 *type = CFAPI_NONE;
2554 return NULL; 903 return NULL;
2555} 904}
2556 905
… …
2694 break; 1043 break;
2695 1044
2696 case 3: 1045 case 3:
2697 op = va_arg (args, object *); 1046 op = va_arg (args, object *);
2698 1047
2699 rv = is_player_inv (op); 1048 rv = op->in_player ();
2700 break; 1049 break;
2701 1050
2702 default: 1051 default:
2703 rv = NULL; 1052 rv = NULL;
2704 *type = CFAPI_NONE; 1053 *type = CFAPI_NONE;
… …
2711} 1060}
2712 1061
2713void * 1062void *
2714cfapi_object_create (int *type, ...) 1063cfapi_object_create (int *type, ...)
2715{ 1064{
2716 va_list args; 1065 abort ();
2717 int ival;
2718
2719 va_start (args, type);
2720 ival = va_arg (args, int);
2721
2722 *type = CFAPI_POBJECT;
2723 switch (ival)
2724 {
2725 case 0:
2726 va_end (args);
2727 return object::create ();
2728 break;
2729
2730 case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */
2731 {
2732 char *sval;
2733 object *op;
2734 sval = va_arg (args, char *);
2735
2736 op = get_archetype_by_object_name (sval);
2737
2738 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
2739 {
2740 op->destroy ();
2741 /* Try with archetype names... */
2742 op = get_archetype (sval);
2743 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
2744 {
2745 op->destroy ();
2746 *type = CFAPI_NONE;
2747 va_end (args);
2748 return NULL;
2749 }
2750 }
2751 va_end (args);
2752 return op;
2753 }
2754 break;
2755
2756 default:
2757 *type = CFAPI_NONE;
2758 va_end (args);
2759 return NULL;
2760 break;
2761 }
2762} 1066}
1067
2763void * 1068void *
2764cfapi_object_insert (int *type, ...) 1069cfapi_object_insert (int *type, ...)
2765{ 1070{
2766 va_list args; 1071 va_list args;
2767 object *op; 1072 object *op;
… …
2900} 1205}
2901 1206
2902void * 1207void *
2903cfapi_object_clear (int *type, ...) 1208cfapi_object_clear (int *type, ...)
2904{ 1209{
2905 va_list args; 1210 abort ();
2906 object *op;
2907
2908 va_start (args, type);
2909
2910 op = va_arg (args, object *);
2911
2912 va_end (args);
2913
2914 op->clear ();
2915 *type = CFAPI_NONE;
2916 return NULL;
2917} 1211}
2918 1212
2919void * 1213void *
2920cfapi_object_reset (int *type, ...) 1214cfapi_object_reset (int *type, ...)
2921{ 1215{
… …
2954} 1248}
2955 1249
2956void * 1250void *
2957cfapi_object_clean_object (int *type, ...) 1251cfapi_object_clean_object (int *type, ...)
2958{ 1252{
2959 va_list args; 1253 abort ();
2960 object *op;
2961
2962 va_start (args, type);
2963 op = va_arg (args, object *);
2964
2965 clean_object (op);
2966 va_end (args);
2967 *type = CFAPI_NONE;
2968 return NULL;
2969} 1254}
2970 1255
2971void * 1256void *
2972cfapi_object_on_same_map (int *type, ...) 1257cfapi_object_on_same_map (int *type, ...)
2973{ 1258{
… …
3220 y = map->enter_y; 1505 y = map->enter_y;
3221 } 1506 }
3222 1507
3223/* 1508/*
3224 originator = object::create(); 1509 originator = object::create();
3225 EXIT_PATH(originator) = add_string(map->path); 1510 EXIT_PATH(originator) = map->path;
3226 EXIT_X(originator) = x; 1511 EXIT_X(originator) = x;
3227 EXIT_Y(originator) = y; 1512 EXIT_Y(originator) = y;
3228 printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/ 1513 printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/
3229 /*enter_exit(op, originator); */ 1514 /*enter_exit(op, originator); */
3230 insert_ob_in_map_at (op, map, NULL, 0, x, y); 1515 insert_ob_in_map_at (op, map, NULL, 0, x, y);
… …
3310 drop (author, op); 1595 drop (author, op);
3311 1596
3312 if (author->type == PLAYER) 1597 if (author->type == PLAYER)
3313 { 1598 {
3314 author->contr->count = 0; 1599 author->contr->count = 0;
3315 author->contr->socket.update_look = 1; 1600 author->contr->ns->floorbox_update ();
3316 } 1601 }
3317 1602
3318 *type = CFAPI_NONE; 1603 *type = CFAPI_NONE;
3319 return NULL; 1604 return NULL;
3320} 1605}
… …
3351 1636
3352/* PLAYER SUBCLASS */ 1637/* PLAYER SUBCLASS */
3353void * 1638void *
3354cfapi_player_find (int *type, ...) 1639cfapi_player_find (int *type, ...)
3355{ 1640{
3356 va_list args; 1641 abort ();
3357 void *rv;
3358 char *sval;
3359
3360 va_start (args, type);
3361
3362 sval = va_arg (args, char *);
3363
3364 va_end (args);
3365
3366 rv = find_player (sval);
3367
3368 *type = CFAPI_PPLAYER;
3369 return rv;
3370} 1642}
3371 1643
3372void * 1644void *
3373cfapi_player_message (int *type, ...) 1645cfapi_player_message (int *type, ...)
3374{ 1646{
… …
3429 1701
3430 send_removed_object (who); 1702 send_removed_object (who);
3431 who->remove (); 1703 who->remove ();
3432 1704
3433 for (tmp = who; tmp != NULL; tmp = tmp->more) 1705 for (tmp = who; tmp != NULL; tmp = tmp->more)
3434 tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x), 1706 tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->x),
3435 tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y); 1707 tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->y);
3436 1708
3437 insert_ob_in_map (who, map, NULL, 0); 1709 insert_ob_in_map (who, map, NULL, 0);
3438 result = 0; 1710 result = 0;
3439 } 1711 }
3440 1712
… …
3461 1733
3462/* Archetype-related functions */ 1734/* Archetype-related functions */
3463void * 1735void *
3464cfapi_archetype_get_first (int *type, ...) 1736cfapi_archetype_get_first (int *type, ...)
3465{ 1737{
3466 va_list args; 1738 abort ();
3467
3468 va_start (args, type);
3469 va_end (args);
3470 *type = CFAPI_PARCH;
3471 return first_archetype;
3472} 1739}
3473 1740
3474void * 1741void *
3475cfapi_archetype_get_property (int *type, ...) 1742cfapi_archetype_get_property (int *type, ...)
3476{ 1743{
3477 archetype *arch; 1744 abort ();
3478 int prop;
3479 va_list args;
3480 void *rv;
3481
3482 va_start (args, type);
3483 arch = va_arg (args, archetype *);
3484 prop = va_arg (args, int);
3485
3486 switch (prop)
3487 {
3488 case CFAPI_ARCH_PROP_NAME:
3489 *type = CFAPI_STRING;
3490 rv = (void *) &arch->name;
3491 break;
3492
3493 case CFAPI_ARCH_PROP_NEXT:
3494 *type = CFAPI_PARCH;
3495 rv = arch->next;
3496 break;
3497
3498 case CFAPI_ARCH_PROP_HEAD:
3499 *type = CFAPI_PARCH;
3500 rv = arch->head;
3501 break;
3502
3503 case CFAPI_ARCH_PROP_MORE:
3504 *type = CFAPI_PARCH;
3505 rv = arch->more;
3506 break;
3507
3508 case CFAPI_ARCH_PROP_CLONE:
3509 *type = CFAPI_POBJECT;
3510 rv = &arch->clone;
3511 break;
3512
3513 default:
3514 *type = CFAPI_NONE;
3515 rv = NULL;
3516 break;
3517 }
3518 va_end (args);
3519 return rv;
3520} 1745}
3521 1746
3522/* Party-related functions */ 1747/* Party-related functions */
3523void * 1748void *
3524cfapi_party_get_property (int *type, ...) 1749cfapi_party_get_property (int *type, ...)
3525{ 1750{
3526 partylist *party; 1751 abort ();
3527 int prop;
3528 va_list args;
3529 void *rv;
3530 object *obarg;
3531 player *pl;
3532
3533 va_start (args, type);
3534 party = va_arg (args, partylist *);
3535 prop = va_arg (args, int);
3536
3537 switch (prop)
3538 {
3539 case CFAPI_PARTY_PROP_NAME:
3540 *type = CFAPI_STRING;
3541 rv = (void *) party->partyname;
3542 break;
3543
3544 case CFAPI_PARTY_PROP_NEXT:
3545 *type = CFAPI_PPARTY;
3546 rv = (party ? party->next : get_firstparty ());
3547 break;
3548
3549 case CFAPI_PARTY_PROP_PASSWORD:
3550 *type = CFAPI_STRING;
3551 rv = (void *) party->passwd;
3552 break;
3553
3554 case CFAPI_PARTY_PROP_PLAYER:
3555 *type = CFAPI_PPLAYER;
3556 obarg = va_arg (args, object *);
3557
3558 pl = (obarg ? obarg->contr : first_player);
3559 rv = NULL;
3560 for (; pl != NULL; pl = pl->next)
3561 if (pl->ob->contr->party == party)
3562 {
3563 rv = (void *) pl;
3564 break;
3565 }
3566 break;
3567
3568 default:
3569 *type = CFAPI_NONE;
3570 rv = NULL;
3571 break;
3572 }
3573 va_end (args);
3574 return rv;
3575} 1752}
3576 1753
3577/* Regions-related functions */ 1754/* Regions-related functions */
3578void * 1755void *
3579cfapi_region_get_property (int *type, ...) 1756cfapi_region_get_property (int *type, ...)
3580{ 1757{
3581 region *reg; 1758 abort ();
3582 int prop;
3583 va_list args;
3584 void *rv;
3585
3586 va_start (args, type);
3587 reg = va_arg (args, region *);
3588 prop = va_arg (args, int);
3589
3590 switch (prop)
3591 {
3592 case CFAPI_REGION_PROP_NAME:
3593 *type = CFAPI_STRING;
3594 rv = (void *) reg->name;
3595 break;
3596
3597 case CFAPI_REGION_PROP_NEXT:
3598 *type = CFAPI_PREGION;
3599 rv = (reg ? reg->next : first_region);
3600 break;
3601
3602 case CFAPI_REGION_PROP_PARENT:
3603 *type = CFAPI_PREGION;
3604 rv = (void *) reg->parent;
3605 break;
3606
3607 case CFAPI_REGION_PROP_LONGNAME:
3608 *type = CFAPI_STRING;
3609 rv = (void *) reg->longname;
3610 break;
3611
3612 case CFAPI_REGION_PROP_MESSAGE:
3613 *type = CFAPI_STRING;
3614 rv = (void *) reg->msg;
3615 break;
3616
3617 default:
3618 *type = CFAPI_NONE;
3619 rv = NULL;
3620 break;
3621 }
3622 va_end (args);
3623 return rv;
3624} 1759}
3625 1760
3626/*****************************************************************************/ 1761/*****************************************************************************/
3627 1762
3628/* NEW PLUGIN STUFF ENDS HERE */ 1763/* NEW PLUGIN STUFF ENDS HERE */
… …
3658 return NULL; 1793 return NULL;
3659} 1794}
3660 1795
3661/*****************************************************************************/ 1796/*****************************************************************************/
3662 1797
3663/* Plugins initialization. Browses the plugins directory and call */ 1798/* Plugins initialisation. Browses the plugins directory and call */
3664 1799
3665/* initOnePlugin for each file found. */ 1800/* initOnePlugin for each file found. */
3666 1801
3667/* Returns 0 if at least one plugin was successfully loaded, -1 if not */ 1802/* Returns 0 if at least one plugin was successfully loaded, -1 if not */
3668 1803
… …
3675 size_t l; 1810 size_t l;
3676 char buf[MAX_BUF]; 1811 char buf[MAX_BUF];
3677 char buf2[MAX_BUF]; 1812 char buf2[MAX_BUF];
3678 int result; 1813 int result;
3679 1814
3680 LOG (llevInfo, "Initializing plugins\n"); 1815 LOG (llevInfo, "Initialising plugins\n");
3681 strcpy (buf, LIBDIR); 1816 strcpy (buf, LIBDIR);
3682 strcat (buf, "/plugins/"); 1817 strcat (buf, "/plugins/");
3683 LOG (llevInfo, "Plugins directory is %s\n", buf); 1818 LOG (llevInfo, "Plugins directory is %s\n", buf);
3684 1819
3685 plugins_init_perl (); 1820 plugins_init_perl ();

Diff Legend

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