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.14 by root, Thu Sep 14 21:16:12 2006 UTC vs.
Revision 1.44 by root, Sun Mar 18 03:05:40 2007 UTC

1
2/*
3 * static char *rcsid_plugins_c =
4 * "$Id: plugins.C,v 1.14 2006/09/14 21:16:12 root Exp $";
5 */
6
7/*****************************************************************************/ 1/*****************************************************************************/
8
9/* CrossFire, A Multiplayer game for X-windows */ 2/* CrossFire, A Multiplayer game for X-windows */
10
11/* */ 3/* */
12
13/* Copyright (C) 2000 Mark Wedel */ 4/* Copyright (C) 2000 Mark Wedel */
14
15/* Copyright (C) 1992 Frank Tore Johansen */ 5/* Copyright (C) 1992 Frank Tore Johansen */
16
17/* */ 6/* */
18
19/* This program is free software; you can redistribute it and/or modify */ 7/* This program is free software; you can redistribute it and/or modify */
20
21/* it under the terms of the GNU General Public License as published by */ 8/* it under the terms of the GNU General Public License as published by */
22
23/* the Free Software Foundation; either version 2 of the License, or */ 9/* the Free Software Foundation; either version 2 of the License, or */
24
25/* (at your option) any later version. */ 10/* (at your option) any later version. */
26
27/* */ 11/* */
28
29/* This program is distributed in the hope that it will be useful, */ 12/* This program is distributed in the hope that it will be useful, */
30
31/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ 13/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
32
33/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ 14/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
34
35/* GNU General Public License for more details. */ 15/* GNU General Public License for more details. */
36
37/* */ 16/* */
38
39/* You should have received a copy of the GNU General Public License */ 17/* You should have received a copy of the GNU General Public License */
40
41/* along with this program; if not, write to the Free Software */ 18/* along with this program; if not, write to the Free Software */
42
43/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 19/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
44
45/* */ 20/* */
46
47/*****************************************************************************/ 21/*****************************************************************************/
48
49/* This is the server-side plugin management part. */ 22/* This is the server-side plugin management part. */
50
51/*****************************************************************************/ 23/*****************************************************************************/
52
53/* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */ 24/* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */
54
55/* Special thanks to: */ 25/* Special thanks to: */
56
57/* David Delbecq (david.delbecq@mailandnews.com); */ 26/* David Delbecq (david.delbecq@mailandnews.com); */
58
59/* Joris Bontje (jbontje@suespammers.org); */ 27/* Joris Bontje (jbontje@suespammers.org); */
60
61/* Philip Currlin (?); */ 28/* Philip Currlin (?); */
62
63/*****************************************************************************/ 29/*****************************************************************************/
64
65/*****************************************************************************/ 30/*****************************************************************************/
66
67/* First, the headers. We only include plugin.h, because all other includes */ 31/* First, the headers. We only include plugin.h, because all other includes */
68
69/* are done into it, and plugproto.h (which is used only by this file). */ 32/* are done into it, and plugproto.h (which is used only by this file). */
70
71/*****************************************************************************/ 33/*****************************************************************************/
34
72#include <plugin.h> 35#include <plugin.h>
73 36
74#ifndef __CEXTRACT__ 37#ifndef __CEXTRACT__
75# include <sproto.h> 38# include <sproto.h>
76#endif 39#endif
… …
79 42
80static const hook_entry plug_hooks[NR_OF_HOOKS] = { 43static const hook_entry plug_hooks[NR_OF_HOOKS] = {
81 {cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"}, 44 {cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"},
82 {cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"}, 45 {cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"},
83 {cfapi_system_check_path, 4, "cfapi_system_check_path"}, 46 {cfapi_system_check_path, 4, "cfapi_system_check_path"},
84 {cfapi_system_re_cmp, 5, "cfapi_system_re_cmp"}, 47 {NULL, 5, "cfapi_system_re_cmp"},
85 {cfapi_system_strdup_local, 6, "cfapi_system_strdup_local"}, 48 {cfapi_system_strdup, 6, "cfapi_system_strdup"},
86 {cfapi_system_directory, 7, "cfapi_system_directory"}, 49 {cfapi_system_directory, 7, "cfapi_system_directory"},
87 {cfapi_system_find_animation, 8, "cfapi_system_find_animation"}, 50 {cfapi_system_find_animation, 8, "cfapi_system_find_animation"},
88 {cfapi_object_clean_object, 9, "cfapi_object_clean_object"}, 51 {cfapi_object_clean_object, 9, "cfapi_object_clean_object"},
89 {cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"}, 52 {cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"},
90 {cfapi_object_get_key, 11, "cfapi_object_get_key"}, 53 {cfapi_object_get_key, 11, "cfapi_object_get_key"},
… …
158 121
159/* NEW PLUGIN STUFF STARTS HERE */ 122/* NEW PLUGIN STUFF STARTS HERE */
160 123
161/*****************************************************************************/ 124/*****************************************************************************/
162 125
163#ifdef WIN32
164static const char *
165plugins_dlerror (void)
166{
167 static char buf[256];
168 DWORD err;
169 char *p;
170
171 err = GetLastError ();
172 if (FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, sizeof (buf), NULL) == 0)
173 snprintf (buf, sizeof (buf), "error %lu", err);
174 p = strchr (buf, '\0');
175 while (p > buf && (p[-1] == '\r' || p[-1] == '\n'))
176 p--;
177 *p = '\0';
178 return buf;
179}
180#endif /* WIN32 */
181
182/**
183 * Notify clients about a changed object.
184 *
185 * @param op the object that has changed
186 */
187static void
188send_changed_object (object *op)
189{
190 object *tmp;
191 player *pl;
192
193 if (op->env != NULL)
194 {
195 tmp = is_player_inv (op->env);
196 if (!tmp)
197 {
198 for (pl = first_player; pl; pl = pl->next)
199 if (pl->ob->container == op->env)
200 break;
201 if (pl)
202 tmp = pl->ob;
203 else
204 tmp = NULL;
205 }
206 if (tmp)
207 esrv_send_item (tmp, op);
208 }
209 else
210 {
211 for (tmp = op->above; tmp != NULL; tmp = tmp->above)
212 if (tmp->type == PLAYER)
213 esrv_send_item (tmp, op);
214 }
215}
216
217/** 126/**
218 * Notify clients about a removed object. 127 * Notify clients about a removed object.
219 * 128 *
220 * @param op the object about to be removed from its environment; it must still 129 * @param op the object about to be removed from its environment; it must still
221 * be present in its environment 130 * be present in its environment
222 */ 131 */
223static void 132static void
224send_removed_object (object *op) 133send_removed_object (object *op)
225{ 134{
226 object *tmp; 135 object *tmp;
227 player *pl;
228 136
229 if (op->env == NULL) 137 if (op->env == NULL)
230 { 138 {
231 /* no action necessary: remove_ob() notifies the client */ 139 /* no action necessary: remove_ob() notifies the client */
232 return; 140 return;
233 } 141 }
234 142
235 tmp = is_player_inv (op->env); 143 tmp = op->in_player ();
236 if (!tmp) 144 if (!tmp)
237 { 145 {
238 for (pl = first_player; pl; pl = pl->next) 146 for_all_players (pl)
239 if (pl->ob->container == op->env) 147 if (pl->ob->container == op->env)
148 {
149 tmp = pl->ob;
240 break; 150 break;
241 if (pl) 151 }
242 tmp = pl->ob;
243 else
244 tmp = NULL;
245 } 152 }
153
246 if (tmp) 154 if (tmp)
247 esrv_del_item (tmp->contr, op->count); 155 esrv_del_item (tmp->contr, op->count);
248} 156}
249 157
250extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr); 158extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr);
… …
538 *type = CFAPI_INT; 446 *type = CFAPI_INT;
539 return &rv; 447 return &rv;
540} 448}
541 449
542void * 450void *
543cfapi_system_strdup_local (int *type, ...) 451cfapi_system_strdup (int *type, ...)
544{ 452{
545 va_list args; 453 va_list args;
546 char *txt; 454 char *txt;
547 455
548 va_start (args, type); 456 va_start (args, type);
549 txt = va_arg (args, char *); 457 txt = va_arg (args, char *);
550 458
551 va_end (args); 459 va_end (args);
552 *type = CFAPI_STRING; 460 *type = CFAPI_STRING;
553 return strdup_local (txt); 461 return strdup (txt);
554} 462}
555 463
556void * 464void *
557cfapi_system_register_global_event (int *type, ...) 465cfapi_system_register_global_event (int *type, ...)
558{ 466{
… …
612 *type = CFAPI_INT; 520 *type = CFAPI_INT;
613 return &rv; 521 return &rv;
614} 522}
615 523
616void * 524void *
617cfapi_system_re_cmp (int *type, ...) 525cfapi_system_directory (int *type, ...)
618{ 526{
619 va_list args; 527 va_list args;
620 char *rv; 528 int dirtype;
621 const char *str;
622 const char *regexp;
623 529
624 va_start (args, type); 530 va_start (args, type);
625 531
626 str = va_arg (args, char *); 532 dirtype = va_arg (args, int);
627 regexp = va_arg (args, char *);
628 533
629 rv = (char *) re_cmp (str, regexp);
630
631 va_end (args); 534 va_end (args);
535
632 *type = CFAPI_STRING; 536 *type = CFAPI_STRING;
633 return rv;
634}
635
636void *
637cfapi_system_directory (int *type, ...)
638{
639 va_list args;
640 int dirtype;
641
642 va_start (args, type);
643
644 dirtype = va_arg (args, int);
645
646 va_end (args);
647
648 *type = CFAPI_STRING;
649 537
650 switch (dirtype) 538 switch (dirtype)
651 { 539 {
652 case 0: 540 case 0:
653 return settings.mapdir; 541 return (char *)settings.mapdir;
654 break; 542 break;
655 543
656 case 1: 544 case 1:
657 return settings.uniquedir; 545 return (char *)settings.uniquedir;
658 break; 546 break;
659 547
660 case 2: 548 case 2:
661 return settings.tmpdir; 549 return (char *)settings.tmpdir;
662 break; 550 break;
663 551
664 case 3: 552 case 3:
665 return settings.confdir; 553 return (char *)settings.confdir;
666 break; 554 break;
667 555
668 case 4: 556 case 4:
669 return settings.localdir; 557 return (char *)settings.localdir;
670 break; 558 break;
671 559
672 case 5: 560 case 5:
673 return settings.playerdir; 561 return (char *)settings.playerdir;
674 break; 562 break;
675 563
676 case 6: 564 case 6:
677 return settings.datadir; 565 return (char *)settings.datadir;
678 break; 566 break;
679 } 567 }
680 568
681 *type = CFAPI_NONE; 569 *type = CFAPI_NONE;
682 return NULL; 570 return NULL;
… …
686/* MAP RELATED HOOKS */ 574/* MAP RELATED HOOKS */
687 575
688void * 576void *
689cfapi_map_get_map (int *type, ...) 577cfapi_map_get_map (int *type, ...)
690{ 578{
579 abort ();
580}
581
582void *
583cfapi_map_has_been_loaded (int *type, ...)
584{
585 abort ();
586}
587
588void *
589cfapi_map_create_path (int *type, ...)
590{
591 abort ();
592}
593
594void *
595cfapi_map_get_map_property (int *type, ...)
596{
597 abort ();
598}
599
600void *
601cfapi_map_set_map_property (int *type, ...)
602{
603 abort ();
604}
605
606void *
607cfapi_map_out_of_map (int *type, ...)
608{
609 abort ();
610}
611
612void *
613cfapi_map_update_position (int *type, ...)
614{
691 va_list args; 615 va_list args;
692 mapstruct *rv; 616 maptile *map;
693 int ctype;
694 int x, y; 617 int x, y;
695 sint16 nx, ny;
696 char *name;
697 mapstruct *m;
698 618
699 va_start (args, type); 619 va_start (args, type);
700 620
701 ctype = va_arg (args, int);
702
703 switch (ctype)
704 {
705 case 0:
706 x = va_arg (args, int);
707 y = va_arg (args, int);
708
709 rv = get_empty_map (x, y);
710 break;
711
712 case 1:
713 name = va_arg (args, char *);
714 x = va_arg (args, int);
715
716 rv = ready_map_name (name, x);
717 break;
718
719 case 2:
720 m = va_arg (args, mapstruct *);
721 nx = va_arg (args, int);
722 ny = va_arg (args, int);
723
724 rv = get_map_from_coord (m, &nx, &ny);
725 break;
726
727 case 3:
728 rv = first_map;
729 break;
730
731 default:
732 *type = CFAPI_NONE;
733 va_end (args);
734 return NULL;
735 break;
736 }
737 va_end (args);
738 *type = CFAPI_PMAP;
739 return rv;
740}
741
742void *
743cfapi_map_has_been_loaded (int *type, ...)
744{
745 va_list args;
746 mapstruct *map;
747 char *string;
748
749 va_start (args, type);
750 string = va_arg (args, char *);
751
752 map = has_been_loaded (string);
753 va_end (args);
754 *type = CFAPI_PMAP;
755 return map;
756}
757
758void *
759cfapi_map_create_path (int *type, ...)
760{
761 va_list args;
762 int ctype;
763 const char *str;
764 char *rv;
765
766 va_start (args, type);
767
768 ctype = va_arg (args, int);
769 str = va_arg (args, char *);
770
771 *type = CFAPI_STRING;
772
773 switch (ctype)
774 {
775 case 0:
776 rv = (char *) create_pathname (str);
777 break;
778
779 case 1:
780 rv = (char *) create_overlay_pathname (str);
781 break;
782
783 /*case 2:
784 rv = create_items_path(str);
785 break; */
786
787 default:
788 rv = NULL;
789 *type = CFAPI_NONE;
790 break;
791 }
792 va_end (args);
793 return rv;
794}
795
796void *
797cfapi_map_get_map_property (int *type, ...)
798{
799 va_list args;
800 int x, y;
801 sint16 nx, ny;
802 mapstruct *map;
803 mapstruct *newmap;
804 static int rv;
805 int property;
806 char *buf;
807
808 va_start (args, type);
809
810 property = va_arg (args, int);
811
812 switch (property)
813 {
814 case CFAPI_MAP_PROP_FLAGS:
815 map = va_arg (args, mapstruct *);
816 newmap = va_arg (args, mapstruct *);
817 x = va_arg (args, int);
818 y = va_arg (args, int);
819 nx = va_arg (args, int);
820 ny = va_arg (args, int);
821
822 rv = get_map_flags (map, &newmap, x, y, &nx, &ny);
823 va_end (args);
824 *type = CFAPI_INT;
825 return &rv;
826 break;
827
828 case CFAPI_MAP_PROP_DIFFICULTY:
829 map = va_arg (args, mapstruct *);
830
831 rv = calculate_difficulty (map);
832 va_end (args);
833 *type = CFAPI_INT;
834 return &rv;
835 break;
836
837 case CFAPI_MAP_PROP_PATH:
838 map = va_arg (args, mapstruct *);
839
840 buf = map->path;
841 *type = CFAPI_STRING;
842 va_end (args);
843 return buf;
844 break;
845
846 case CFAPI_MAP_PROP_TMPNAME:
847 map = va_arg (args, mapstruct *);
848
849 buf = map->tmpname;
850 *type = CFAPI_STRING;
851 va_end (args);
852 return buf;
853 break;
854
855 case CFAPI_MAP_PROP_NAME:
856 map = va_arg (args, mapstruct *);
857
858 buf = map->name;
859 *type = CFAPI_STRING;
860 va_end (args);
861 return buf;
862 break;
863
864 case CFAPI_MAP_PROP_RESET_TIME:
865 map = va_arg (args, mapstruct *);
866
867 rv = map->reset_time;
868 *type = CFAPI_INT;
869 va_end (args);
870 return &rv;
871 break;
872
873 case CFAPI_MAP_PROP_RESET_TIMEOUT:
874 map = va_arg (args, mapstruct *);
875
876 rv = map->reset_timeout;
877 *type = CFAPI_INT;
878 va_end (args);
879 return &rv;
880 break;
881
882 case CFAPI_MAP_PROP_PLAYERS:
883 map = va_arg (args, mapstruct *);
884
885 rv = map->players;
886 *type = CFAPI_INT;
887 va_end (args);
888 return &rv;
889 break;
890
891 case CFAPI_MAP_PROP_DARKNESS:
892 map = va_arg (args, mapstruct *);
893
894 rv = map->darkness;
895 *type = CFAPI_INT;
896 va_end (args);
897 return &rv;
898 break;
899
900 case CFAPI_MAP_PROP_WIDTH:
901 map = va_arg (args, mapstruct *);
902
903 rv = map->width;
904 *type = CFAPI_INT;
905 va_end (args);
906 return &rv;
907 break;
908
909 case CFAPI_MAP_PROP_HEIGHT:
910 map = va_arg (args, mapstruct *);
911
912 rv = map->height;
913 *type = CFAPI_INT;
914 va_end (args);
915 return &rv;
916 break;
917
918 case CFAPI_MAP_PROP_ENTER_X:
919 map = va_arg (args, mapstruct *);
920
921 rv = map->enter_x;
922 *type = CFAPI_INT;
923 va_end (args);
924 return &rv;
925 break;
926
927 case CFAPI_MAP_PROP_ENTER_Y:
928 map = va_arg (args, mapstruct *);
929
930 rv = map->enter_y;
931 *type = CFAPI_INT;
932 va_end (args);
933 return &rv;
934 break;
935
936 case CFAPI_MAP_PROP_TEMPERATURE:
937 map = va_arg (args, mapstruct *);
938
939 rv = map->temp;
940 *type = CFAPI_INT;
941 va_end (args);
942 return &rv;
943 break;
944
945 case CFAPI_MAP_PROP_PRESSURE:
946 map = va_arg (args, mapstruct *);
947
948 rv = map->pressure;
949 *type = CFAPI_INT;
950 va_end (args);
951 return &rv;
952 break;
953
954 case CFAPI_MAP_PROP_HUMIDITY:
955 map = va_arg (args, mapstruct *);
956
957 rv = map->humid;
958 *type = CFAPI_INT;
959 va_end (args);
960 return &rv;
961 break;
962
963 case CFAPI_MAP_PROP_WINDSPEED:
964 map = va_arg (args, mapstruct *);
965
966 rv = map->windspeed;
967 *type = CFAPI_INT;
968 va_end (args);
969 return &rv;
970 break;
971
972 case CFAPI_MAP_PROP_WINDDIR:
973 map = va_arg (args, mapstruct *);
974
975 rv = map->winddir;
976 *type = CFAPI_INT;
977 va_end (args);
978 return &rv;
979 break;
980
981 case CFAPI_MAP_PROP_SKY:
982 map = va_arg (args, mapstruct *);
983
984 rv = map->sky;
985 *type = CFAPI_INT;
986 va_end (args);
987 return &rv;
988 break;
989
990 case CFAPI_MAP_PROP_WPARTX:
991 map = va_arg (args, mapstruct *);
992
993 rv = map->wpartx;
994 *type = CFAPI_INT;
995 va_end (args);
996 return &rv;
997 break;
998
999 case CFAPI_MAP_PROP_WPARTY:
1000 map = va_arg (args, mapstruct *);
1001
1002 rv = map->wparty;
1003 *type = CFAPI_INT;
1004 va_end (args);
1005 return &rv;
1006 break;
1007
1008 case CFAPI_MAP_PROP_MESSAGE:
1009 map = va_arg (args, mapstruct *);
1010
1011 buf = map->msg;
1012 *type = CFAPI_STRING;
1013 va_end (args);
1014 return buf;
1015 break;
1016
1017 case CFAPI_MAP_PROP_NEXT:
1018 map = va_arg (args, mapstruct *);
1019
1020 *type = CFAPI_PMAP;
1021 va_end (args);
1022 return map->next;
1023 break;
1024
1025 case CFAPI_MAP_PROP_REGION:
1026 map = va_arg (args, mapstruct *);
1027
1028 *type = CFAPI_PREGION;
1029 va_end (args);
1030 return get_region_by_map (map);
1031 break;
1032
1033 default:
1034 *type = CFAPI_NONE;
1035 va_end (args);
1036 return NULL;
1037 break;
1038 }
1039}
1040
1041void *
1042cfapi_map_set_map_property (int *type, ...)
1043{
1044 va_list args;
1045 static int rv;
1046 mapstruct *map;
1047 int val;
1048 int property;
1049
1050 va_start (args, type);
1051
1052 property = va_arg (args, int);
1053
1054 switch (property)
1055 {
1056 case CFAPI_MAP_PROP_LIGHT:
1057 map = va_arg (args, mapstruct *);
1058 val = va_arg (args, int);
1059
1060 rv = change_map_light (map, val);
1061 *type = CFAPI_INT;
1062 va_end (args);
1063 return &rv;
1064 break;
1065
1066 case CFAPI_MAP_PROP_RESET_TIME:
1067 map = va_arg (args, mapstruct *);
1068
1069 *type = CFAPI_NONE;
1070 va_end (args);
1071 return NULL;
1072 break;
1073
1074 default:
1075 *type = CFAPI_NONE;
1076 va_end (args);
1077 return NULL;
1078 break;
1079 }
1080}
1081void *
1082cfapi_map_out_of_map (int *type, ...)
1083{
1084 va_list args;
1085 static int rv;
1086 mapstruct *map;
1087 int x, y;
1088
1089 va_start (args, type);
1090 map = va_arg (args, mapstruct *); 621 map = va_arg (args, maptile *);
1091 x = va_arg (args, int); 622 x = va_arg (args, int);
1092 y = va_arg (args, int); 623 y = va_arg (args, int);
1093 624
1094 rv = out_of_map (map, x, y); 625 map->at (x, y).flags_ &= ~P_UPTODATE;
626
1095 va_end (args); 627 va_end (args);
628 *type = CFAPI_NONE;
629 return NULL;
630}
631
632void *
633cfapi_map_delete_map (int *type, ...)
634{
635 abort ();
636}
637
638void *
639cfapi_map_message (int *type, ...)
640{
641 va_list args;
642 maptile *map;
643 char *string;
644 int color;
645
646 va_start (args, type);
647 map = va_arg (args, maptile *);
648 string = va_arg (args, char *);
649 color = va_arg (args, int);
650
651 va_end (args);
652
653 new_info_map (color, map, string);
654 *type = CFAPI_NONE;
655 return NULL;
656}
657
658void *
659cfapi_map_get_object_at (int *type, ...)
660{
661 va_list args;
662 maptile *map;
663 int x, y;
664 object *rv;
665
666 va_start (args, type);
667 map = va_arg (args, maptile *);
668 x = va_arg (args, int);
669 y = va_arg (args, int);
670
671 va_end (args);
672
673 rv = GET_MAP_OB (map, x, y);
674 *type = CFAPI_POBJECT;
675 return rv;
676}
677
678void *
679cfapi_map_get_flags (int *type, ...)
680{
681 va_list args;
682 sint16 x, y;
683 sint16 *nx, *ny;
684 static maptile *map;
685 maptile **newmap;
686 static int rv;
687
688 va_start (args, type);
689
690 map = va_arg (args, maptile *);
691 newmap = va_arg (args, maptile **);
692 x = va_arg (args, int);
693 y = va_arg (args, int);
694
695 nx = va_arg (args, sint16 *);
696 ny = va_arg (args, sint16 *);
697 va_end (args);
698
699 rv = get_map_flags (map, newmap, x, y, nx, ny);
700
1096 *type = CFAPI_INT; 701 *type = CFAPI_INT;
1097 return &rv; 702 return &rv;
1098} 703}
1099 704
1100void * 705void *
1101cfapi_map_update_position (int *type, ...)
1102{
1103 va_list args;
1104 mapstruct *map;
1105 int x, y;
1106
1107 va_start (args, type);
1108
1109 map = va_arg (args, mapstruct *);
1110 x = va_arg (args, int);
1111 y = va_arg (args, int);
1112
1113 update_position (map, x, y);
1114 va_end (args);
1115 *type = CFAPI_NONE;
1116 return NULL;
1117}
1118
1119void *
1120cfapi_map_delete_map (int *type, ...)
1121{
1122 va_list args;
1123 mapstruct *map;
1124
1125 va_start (args, type);
1126
1127 map = va_arg (args, mapstruct *);
1128
1129 delete_map (map);
1130
1131 va_end (args);
1132 *type = CFAPI_NONE;
1133 return NULL;
1134}
1135
1136void *
1137cfapi_map_message (int *type, ...)
1138{
1139 va_list args;
1140 mapstruct *map;
1141 char *string;
1142 int color;
1143
1144 va_start (args, type);
1145 map = va_arg (args, mapstruct *);
1146 string = va_arg (args, char *);
1147 color = va_arg (args, int);
1148
1149 va_end (args);
1150
1151 new_info_map (color, map, string);
1152 *type = CFAPI_NONE;
1153 return NULL;
1154}
1155
1156void *
1157cfapi_map_get_object_at (int *type, ...)
1158{
1159 va_list args;
1160 mapstruct *map;
1161 int x, y;
1162 object *rv;
1163
1164 va_start (args, type);
1165 map = va_arg (args, mapstruct *);
1166 x = va_arg (args, int);
1167 y = va_arg (args, int);
1168
1169 va_end (args);
1170
1171 rv = get_map_ob (map, x, y);
1172 *type = CFAPI_POBJECT;
1173 return rv;
1174}
1175
1176void *
1177cfapi_map_get_flags (int *type, ...)
1178{
1179 va_list args;
1180 sint16 x, y;
1181 sint16 *nx, *ny;
1182 static mapstruct *map;
1183 mapstruct **newmap;
1184 static int rv;
1185
1186 va_start (args, type);
1187
1188 map = va_arg (args, mapstruct *);
1189 newmap = va_arg (args, mapstruct **);
1190 x = va_arg (args, int);
1191 y = va_arg (args, int);
1192
1193 nx = va_arg (args, sint16 *);
1194 ny = va_arg (args, sint16 *);
1195 va_end (args);
1196
1197 rv = get_map_flags (map, newmap, x, y, nx, ny);
1198
1199 *type = CFAPI_INT;
1200 return &rv;
1201}
1202
1203void *
1204cfapi_map_present_arch_by_name (int *type, ...) 706cfapi_map_present_arch_by_name (int *type, ...)
1205{ 707{
1206 va_list args; 708 va_list args;
1207 object *rv; 709 object *rv;
1208 int x, y; 710 int x, y;
1209 mapstruct *map; 711 maptile *map;
1210 char *msg; 712 char *msg;
1211 713
1212 va_start (args, type); 714 va_start (args, type);
1213 715
1214 msg = va_arg (args, char *); 716 msg = va_arg (args, char *);
1215 map = va_arg (args, mapstruct *); 717 map = va_arg (args, maptile *);
1216 x = va_arg (args, int); 718 x = va_arg (args, int);
1217 y = va_arg (args, int); 719 y = va_arg (args, int);
1218 720
1219 va_end (args); 721 va_end (args);
1220 722
… …
1302} 804}
1303 805
1304void * 806void *
1305cfapi_object_get_property (int *type, ...) 807cfapi_object_get_property (int *type, ...)
1306{ 808{
1307 va_list args; 809 abort ();
1308 int property;
1309 object *op;
1310 void *rv;
1311 static int ri;
1312
1313 va_start (args, type);
1314
1315 op = va_arg (args, object *);
1316 property = va_arg (args, int);
1317
1318 rv = NULL;
1319 if (op != NULL)
1320 {
1321 switch (property)
1322 {
1323 case CFAPI_OBJECT_PROP_OB_ABOVE:
1324 rv = op->above;
1325 *type = CFAPI_POBJECT;
1326 break;
1327
1328 case CFAPI_OBJECT_PROP_OB_BELOW:
1329 rv = op->below;
1330 *type = CFAPI_POBJECT;
1331 break;
1332
1333 case CFAPI_OBJECT_PROP_NEXT_ACTIVE_OB:
1334 rv = op->active_next;
1335 *type = CFAPI_POBJECT;
1336 break;
1337
1338 case CFAPI_OBJECT_PROP_PREV_ACTIVE_OB:
1339 rv = op->active_prev;
1340 *type = CFAPI_POBJECT;
1341 break;
1342
1343 case CFAPI_OBJECT_PROP_INVENTORY:
1344 rv = op->inv;
1345 *type = CFAPI_POBJECT;
1346 break;
1347
1348 case CFAPI_OBJECT_PROP_ENVIRONMENT:
1349 rv = op->env;
1350 *type = CFAPI_POBJECT;
1351 break;
1352
1353 case CFAPI_OBJECT_PROP_HEAD:
1354 rv = op->head;
1355 *type = CFAPI_POBJECT;
1356 break;
1357
1358 case CFAPI_OBJECT_PROP_CONTAINER:
1359 rv = op->container;
1360 *type = CFAPI_POBJECT;
1361 break;
1362
1363 case CFAPI_OBJECT_PROP_MAP:
1364 rv = op->map;
1365 *type = CFAPI_PMAP;
1366 break;
1367
1368 case CFAPI_OBJECT_PROP_COUNT:
1369 ri = op->count;
1370 rv = &ri;
1371 *type = CFAPI_INT;
1372 break;
1373
1374 case CFAPI_OBJECT_PROP_REFCOUNT:
1375 abort ();
1376 break;
1377
1378 case CFAPI_OBJECT_PROP_NAME:
1379 rv = query_name (op);
1380 *type = CFAPI_STRING;
1381 break;
1382
1383 case CFAPI_OBJECT_PROP_NAME_PLURAL:
1384 rv = (char *) &op->name_pl;
1385 *type = CFAPI_STRING;
1386 break;
1387
1388 case CFAPI_OBJECT_PROP_TITLE:
1389 rv = (char *) &op->title;
1390 *type = CFAPI_STRING;
1391 break;
1392
1393 case CFAPI_OBJECT_PROP_RACE:
1394 rv = (char *) &op->race;
1395 *type = CFAPI_STRING;
1396 break;
1397
1398 case CFAPI_OBJECT_PROP_SLAYING:
1399 rv = (char *) &op->slaying;
1400 *type = CFAPI_STRING;
1401 break;
1402
1403 case CFAPI_OBJECT_PROP_SKILL:
1404 rv = (char *) &op->skill;
1405 *type = CFAPI_STRING;
1406 break;
1407
1408 case CFAPI_OBJECT_PROP_MESSAGE:
1409 rv = (char *) &op->msg;
1410 if (rv == NULL)
1411 rv = (void *) "";
1412 *type = CFAPI_STRING;
1413 break;
1414
1415 case CFAPI_OBJECT_PROP_LORE:
1416 rv = (char *) &op->lore;
1417 *type = CFAPI_STRING;
1418 break;
1419
1420 case CFAPI_OBJECT_PROP_X:
1421 ri = op->x;
1422 rv = &ri;
1423 *type = CFAPI_INT;
1424 break;
1425
1426 case CFAPI_OBJECT_PROP_Y:
1427 ri = op->y;
1428 rv = &ri;
1429 *type = CFAPI_INT;
1430 break;
1431
1432 case CFAPI_OBJECT_PROP_SPEED:
1433 rv = &op->speed;
1434 *type = CFAPI_DOUBLE;
1435 break;
1436
1437 case CFAPI_OBJECT_PROP_SPEED_LEFT:
1438 rv = &op->speed_left;
1439 *type = CFAPI_DOUBLE;
1440 break;
1441
1442 case CFAPI_OBJECT_PROP_NROF:
1443 ri = op->nrof;
1444 rv = &ri;
1445 *type = CFAPI_INT;
1446 break;
1447
1448 case CFAPI_OBJECT_PROP_DIRECTION:
1449 ri = op->direction;
1450 rv = &ri;
1451 *type = CFAPI_INT;
1452 break;
1453
1454 case CFAPI_OBJECT_PROP_FACING:
1455 ri = op->facing;
1456 rv = &ri;
1457 *type = CFAPI_INT;
1458 break;
1459
1460 case CFAPI_OBJECT_PROP_TYPE:
1461 ri = op->type;
1462 rv = &ri;
1463 *type = CFAPI_INT;
1464 break;
1465
1466 case CFAPI_OBJECT_PROP_SUBTYPE:
1467 ri = op->subtype;
1468 rv = &ri;
1469 *type = CFAPI_INT;
1470 break;
1471
1472 case CFAPI_OBJECT_PROP_CLIENT_TYPE:
1473 ri = op->client_type;
1474 rv = &ri;
1475 *type = CFAPI_INT;
1476 break;
1477
1478 case CFAPI_OBJECT_PROP_RESIST:
1479 {
1480 int idx;
1481 idx = va_arg (args, int);
1482
1483 ri = op->resist[idx];
1484 rv = &ri;
1485 }
1486 *type = CFAPI_INT;
1487 break;
1488
1489 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
1490 ri = op->attacktype;
1491 rv = &ri;
1492 *type = CFAPI_INT;
1493 break;
1494
1495 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
1496 ri = op->path_attuned;
1497 rv = &ri;
1498 *type = CFAPI_INT;
1499 break;
1500
1501 case CFAPI_OBJECT_PROP_PATH_REPELLED:
1502 ri = op->path_repelled;
1503 rv = &ri;
1504 *type = CFAPI_INT;
1505 break;
1506
1507 case CFAPI_OBJECT_PROP_PATH_DENIED:
1508 ri = op->path_denied;
1509 rv = &ri;
1510 *type = CFAPI_INT;
1511 break;
1512
1513 case CFAPI_OBJECT_PROP_MATERIAL:
1514 ri = op->material;
1515 rv = &ri;
1516 *type = CFAPI_INT;
1517 break;
1518
1519 case CFAPI_OBJECT_PROP_MAGIC:
1520 ri = op->magic;
1521 rv = &ri;
1522 *type = CFAPI_INT;
1523 break;
1524
1525 case CFAPI_OBJECT_PROP_VALUE:
1526 ri = op->value;
1527 rv = &ri;
1528 *type = CFAPI_INT;
1529 break;
1530
1531 case CFAPI_OBJECT_PROP_LEVEL:
1532 ri = op->level;
1533 rv = &ri;
1534 *type = CFAPI_INT;
1535 break;
1536
1537 case CFAPI_OBJECT_PROP_LAST_HEAL:
1538 ri = op->last_heal;
1539 rv = &ri;
1540 *type = CFAPI_INT;
1541 break;
1542
1543 case CFAPI_OBJECT_PROP_LAST_SP:
1544 ri = op->last_sp;
1545 rv = &ri;
1546 *type = CFAPI_INT;
1547 break;
1548
1549 case CFAPI_OBJECT_PROP_LAST_GRACE:
1550 ri = op->last_grace;
1551 rv = &ri;
1552 *type = CFAPI_INT;
1553 break;
1554
1555 case CFAPI_OBJECT_PROP_LAST_EAT:
1556 ri = op->last_eat;
1557 rv = &ri;
1558 *type = CFAPI_INT;
1559 break;
1560
1561 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
1562 ri = op->invisible;
1563 rv = &ri;
1564 *type = CFAPI_INT;
1565 break;
1566
1567 case CFAPI_OBJECT_PROP_PICK_UP:
1568 ri = op->pick_up;
1569 rv = &ri;
1570 *type = CFAPI_INT;
1571 break;
1572
1573 case CFAPI_OBJECT_PROP_ITEM_POWER:
1574 ri = op->item_power;
1575 rv = &ri;
1576 *type = CFAPI_INT;
1577 break;
1578
1579 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
1580 ri = op->gen_sp_armour;
1581 rv = &ri;
1582 *type = CFAPI_INT;
1583 break;
1584
1585 case CFAPI_OBJECT_PROP_WEIGHT:
1586 ri = op->weight;
1587 rv = &ri;
1588 *type = CFAPI_INT;
1589 break;
1590
1591 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
1592 ri = op->weight_limit;
1593 rv = &ri;
1594 *type = CFAPI_INT;
1595 break;
1596
1597 case CFAPI_OBJECT_PROP_CARRYING:
1598 ri = op->carrying;
1599 rv = &ri;
1600 *type = CFAPI_INT;
1601 break;
1602
1603 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
1604 ri = op->glow_radius;
1605 rv = &ri;
1606 *type = CFAPI_INT;
1607 break;
1608
1609 case CFAPI_OBJECT_PROP_PERM_EXP:
1610 rv = &op->perm_exp;
1611 *type = CFAPI_LONG;
1612 break;
1613
1614 case CFAPI_OBJECT_PROP_CURRENT_WEAPON:
1615 rv = op->current_weapon;
1616 *type = CFAPI_POBJECT;
1617 break;
1618
1619 case CFAPI_OBJECT_PROP_ENEMY:
1620 rv = op->enemy;
1621 *type = CFAPI_POBJECT;
1622 break;
1623
1624 case CFAPI_OBJECT_PROP_ATTACKED_BY:
1625 rv = op->attacked_by;
1626 *type = CFAPI_POBJECT;
1627 break;
1628
1629 case CFAPI_OBJECT_PROP_RUN_AWAY:
1630 ri = op->run_away;
1631 rv = &ri;
1632 *type = CFAPI_INT;
1633 break;
1634
1635 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
1636 rv = op->chosen_skill;
1637 *type = CFAPI_POBJECT;
1638 break;
1639
1640 case CFAPI_OBJECT_PROP_HIDDEN:
1641 ri = op->hide;
1642 rv = &ri;
1643 *type = CFAPI_INT;
1644 break;
1645
1646 case CFAPI_OBJECT_PROP_MOVE_STATUS:
1647 ri = op->move_status;
1648 rv = &ri;
1649 *type = CFAPI_INT;
1650 break;
1651
1652 case CFAPI_OBJECT_PROP_MOVE_TYPE:
1653 ri = op->attack_movement;
1654 rv = &ri;
1655 *type = CFAPI_INT;
1656 break;
1657
1658 case CFAPI_OBJECT_PROP_SPELL_ITEM:
1659 rv = op->spellitem;
1660 *type = CFAPI_POBJECT;
1661 break;
1662
1663 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
1664 rv = &op->expmul;
1665 *type = CFAPI_DOUBLE;
1666 break;
1667
1668 case CFAPI_OBJECT_PROP_ARCHETYPE:
1669 rv = op->arch;
1670 *type = CFAPI_PARCH;
1671 break;
1672
1673 case CFAPI_OBJECT_PROP_OTHER_ARCH:
1674 rv = op->other_arch;
1675 *type = CFAPI_PARCH;
1676 break;
1677
1678 case CFAPI_OBJECT_PROP_ANIM_SPEED:
1679 ri = op->anim_speed;
1680 rv = &ri;
1681 *type = CFAPI_INT;
1682 break;
1683
1684 case CFAPI_OBJECT_PROP_FRIENDLY:
1685 ri = is_friendly (op);
1686 rv = &ri;
1687 *type = CFAPI_INT;
1688 break;
1689
1690 case CFAPI_OBJECT_PROP_BASE_NAME:
1691 {
1692 int i;
1693 i = va_arg (args, int);
1694
1695 rv = (char *) query_base_name (op, i);
1696 *type = CFAPI_STRING;
1697 }
1698 break;
1699
1700 case CFAPI_OBJECT_PROP_MAGICAL:
1701 ri = is_magical (op);
1702 rv = &ri;
1703 *type = CFAPI_INT;
1704 break;
1705
1706 case CFAPI_OBJECT_PROP_LUCK:
1707 ri = op->stats.luck;
1708 rv = &ri;
1709 *type = CFAPI_INT;
1710 break;
1711
1712 case CFAPI_OBJECT_PROP_EXP:
1713 rv = &op->stats.exp;
1714 *type = CFAPI_LONG;
1715 break;
1716
1717 case CFAPI_OBJECT_PROP_OWNER:
1718 rv = get_owner (op);
1719 *type = CFAPI_POBJECT;
1720 break;
1721
1722 case CFAPI_OBJECT_PROP_PRESENT:
1723 {
1724 int stype;
1725
1726 rv = 0;
1727 stype = va_arg (args, int);
1728
1729 switch (stype)
1730 {
1731
1732 unsigned char ptype;
1733 char *buf;
1734 archetype *at;
1735
1736 case 0: /* present_in_ob */
1737 ptype = (unsigned char) (va_arg (args, int));
1738
1739 rv = present_in_ob (ptype, op);
1740 break;
1741
1742 case 1: /* present_in_ob_by_name */
1743 ptype = (unsigned char) (va_arg (args, int));
1744 buf = va_arg (args, char *);
1745
1746 rv = present_in_ob_by_name (ptype, buf, op);
1747 break;
1748
1749 case 2: /* present_arch_in_ob */
1750 at = va_arg (args, archetype *);
1751
1752 rv = present_arch_in_ob (at, op);
1753 break;
1754 }
1755 }
1756 *type = CFAPI_POBJECT;
1757 break;
1758
1759 case CFAPI_OBJECT_PROP_CHEATER:
1760 ri = (QUERY_FLAG (op, FLAG_WAS_WIZ));
1761 rv = &ri;
1762 *type = CFAPI_INT;
1763 break;
1764
1765 case CFAPI_OBJECT_PROP_MERGEABLE:
1766 {
1767 object *op2;
1768 op2 = va_arg (args, object *);
1769
1770 ri = CAN_MERGE (op, op2);
1771 rv = &ri;
1772 }
1773 *type = CFAPI_INT;
1774 break;
1775
1776 case CFAPI_OBJECT_PROP_PICKABLE:
1777 {
1778 object *op2;
1779
1780 rv = 0;
1781 op2 = va_arg (args, object *);
1782
1783 ri = can_pick (op2, op);
1784 rv = &ri;
1785 }
1786 *type = CFAPI_INT;
1787 break;
1788
1789 case CFAPI_OBJECT_PROP_FLAGS:
1790 {
1791 int fl;
1792
1793 ri = 0;
1794 fl = va_arg (args, int);
1795
1796 ri = QUERY_FLAG (op, fl);
1797 rv = &ri;
1798 }
1799 *type = CFAPI_INT;
1800 break;
1801
1802 case CFAPI_OBJECT_PROP_STR:
1803 ri = op->stats.Str;
1804 rv = &ri;
1805 *type = CFAPI_INT;
1806 break;
1807
1808 case CFAPI_OBJECT_PROP_DEX:
1809 ri = op->stats.Dex;
1810 rv = &ri;
1811 *type = CFAPI_INT;
1812 break;
1813
1814 case CFAPI_OBJECT_PROP_CON:
1815 ri = op->stats.Con;
1816 rv = &ri;
1817 *type = CFAPI_INT;
1818 break;
1819
1820 case CFAPI_OBJECT_PROP_WIS:
1821 ri = op->stats.Wis;
1822 rv = &ri;
1823 *type = CFAPI_INT;
1824 break;
1825
1826 case CFAPI_OBJECT_PROP_INT:
1827 ri = op->stats.Int;
1828 rv = &ri;
1829 *type = CFAPI_INT;
1830 break;
1831
1832 case CFAPI_OBJECT_PROP_POW:
1833 ri = op->stats.Pow;
1834 rv = &ri;
1835 *type = CFAPI_INT;
1836 break;
1837
1838 case CFAPI_OBJECT_PROP_CHA:
1839 ri = op->stats.Cha;
1840 rv = &ri;
1841 *type = CFAPI_INT;
1842 break;
1843
1844 case CFAPI_OBJECT_PROP_WC:
1845 ri = op->stats.wc;
1846 rv = &ri;
1847 *type = CFAPI_INT;
1848 break;
1849
1850 case CFAPI_OBJECT_PROP_AC:
1851 ri = op->stats.ac;
1852 rv = &ri;
1853 *type = CFAPI_INT;
1854 break;
1855
1856 case CFAPI_OBJECT_PROP_HP:
1857 ri = op->stats.hp;
1858 rv = &ri;
1859 *type = CFAPI_INT;
1860 break;
1861
1862 case CFAPI_OBJECT_PROP_SP:
1863 ri = op->stats.sp;
1864 rv = &ri;
1865 *type = CFAPI_INT;
1866 break;
1867
1868 case CFAPI_OBJECT_PROP_GP:
1869 ri = op->stats.grace;
1870 rv = &ri;
1871 *type = CFAPI_INT;
1872 break;
1873
1874 case CFAPI_OBJECT_PROP_FP:
1875 ri = op->stats.food;
1876 rv = &ri;
1877 *type = CFAPI_INT;
1878 break;
1879
1880 case CFAPI_OBJECT_PROP_MAXHP:
1881 ri = op->stats.maxhp;
1882 rv = &ri;
1883 *type = CFAPI_INT;
1884 break;
1885
1886 case CFAPI_OBJECT_PROP_MAXSP:
1887 ri = op->stats.maxsp;
1888 rv = &ri;
1889 *type = CFAPI_INT;
1890 break;
1891
1892 case CFAPI_OBJECT_PROP_MAXGP:
1893 ri = op->stats.maxgrace;
1894 rv = &ri;
1895 *type = CFAPI_INT;
1896 break;
1897
1898 case CFAPI_OBJECT_PROP_DAM:
1899 ri = op->stats.dam;
1900 rv = &ri;
1901 *type = CFAPI_INT;
1902 break;
1903
1904 case CFAPI_OBJECT_PROP_GOD:
1905 rv = (char *) determine_god (op);
1906 *type = CFAPI_STRING;
1907 break;
1908
1909 case CFAPI_OBJECT_PROP_ARCH_NAME:
1910 rv = (char *) &op->arch->name;
1911 *type = CFAPI_STRING;
1912 break;
1913
1914 case CFAPI_OBJECT_PROP_INVISIBLE:
1915 ri = op->invisible;
1916 rv = &ri;
1917 *type = CFAPI_INT;
1918 break;
1919
1920 case CFAPI_OBJECT_PROP_FACE:
1921 ri = op->animation_id;
1922 rv = &ri;
1923 *type = CFAPI_INT;
1924 break;
1925
1926 case CFAPI_PLAYER_PROP_IP:
1927 rv = op->contr->socket.host;
1928 *type = CFAPI_STRING;
1929 break;
1930
1931 case CFAPI_PLAYER_PROP_MARKED_ITEM:
1932 rv = find_marked_object (op);
1933 *type = CFAPI_POBJECT;
1934 break;
1935
1936 case CFAPI_PLAYER_PROP_PARTY:
1937 rv = (op->contr ? op->contr->party : NULL);
1938 *type = CFAPI_PPARTY;
1939 break;
1940 default:
1941 *type = CFAPI_NONE;
1942 break;
1943 }
1944 }
1945 va_end (args);
1946 return rv;
1947} 810}
1948 811
1949void * 812void *
1950cfapi_object_set_property (int *type, ...) 813cfapi_object_set_property (int *type, ...)
1951{ 814{
1952 va_list args; 815 abort ();
1953 int iarg;
1954 long larg;
1955 char *sarg;
1956 double darg;
1957 object *oparg;
1958 object *op;
1959 int property;
1960 void *rv;
1961 partylist *partyarg;
1962
1963 va_start (args, type);
1964
1965 op = va_arg (args, object *);
1966 property = va_arg (args, int);
1967
1968 rv = NULL;
1969
1970 if (op != NULL && (!op->arch || (op != &op->arch->clone)))
1971 {
1972 switch (property)
1973 {
1974 case CFAPI_OBJECT_PROP_NAME:
1975 sarg = va_arg (args, char *);
1976
1977#define FREE_AND_COPY(a,b) (a) = (b) // TODO: remove, but plugins.C is considered zombie code
1978 FREE_AND_COPY (op->name, sarg);
1979 send_changed_object (op);
1980 break;
1981
1982 case CFAPI_OBJECT_PROP_NAME_PLURAL:
1983 sarg = va_arg (args, char *);
1984
1985 FREE_AND_COPY (op->name_pl, sarg);
1986 send_changed_object (op);
1987 break;
1988
1989 case CFAPI_OBJECT_PROP_TITLE:
1990 sarg = va_arg (args, char *);
1991
1992 FREE_AND_COPY (op->title, sarg);
1993 break;
1994
1995 case CFAPI_OBJECT_PROP_RACE:
1996 sarg = va_arg (args, char *);
1997
1998 FREE_AND_COPY (op->race, sarg);
1999 break;
2000
2001 case CFAPI_OBJECT_PROP_SLAYING:
2002 sarg = va_arg (args, char *);
2003
2004 FREE_AND_COPY (op->slaying, sarg);
2005 break;
2006
2007 case CFAPI_OBJECT_PROP_SKILL:
2008 sarg = va_arg (args, char *);
2009
2010 FREE_AND_COPY (op->skill, sarg);
2011 break;
2012
2013 case CFAPI_OBJECT_PROP_MESSAGE:
2014 sarg = va_arg (args, char *);
2015
2016 FREE_AND_COPY (op->msg, sarg);
2017 break;
2018
2019 case CFAPI_OBJECT_PROP_LORE:
2020 sarg = va_arg (args, char *);
2021
2022 FREE_AND_COPY (op->lore, sarg);
2023 break;
2024
2025 case CFAPI_OBJECT_PROP_SPEED:
2026 darg = va_arg (args, double);
2027
2028 op->speed = darg;
2029 break;
2030
2031 case CFAPI_OBJECT_PROP_SPEED_LEFT:
2032 darg = va_arg (args, double);
2033
2034 op->speed_left = darg;
2035 break;
2036
2037 case CFAPI_OBJECT_PROP_NROF:
2038 iarg = va_arg (args, int);
2039
2040 if (iarg < 0)
2041 iarg = 0;
2042 if (op->nrof > (uint32) iarg)
2043 decrease_ob_nr (op, op->nrof - iarg);
2044 else if (op->nrof < (uint32) iarg)
2045 {
2046 object *tmp;
2047 player *pl;
2048
2049 op->nrof = iarg;
2050 if (op->env != NULL)
2051 {
2052 tmp = is_player_inv (op->env);
2053 if (!tmp)
2054 {
2055 for (pl = first_player; pl; pl = pl->next)
2056 if (pl->ob->container == op->env)
2057 break;
2058 if (pl)
2059 tmp = pl->ob;
2060 else
2061 tmp = NULL;
2062 }
2063 else
2064 {
2065 sum_weight (tmp);
2066 fix_player (tmp);
2067 }
2068 if (tmp)
2069 esrv_send_item (tmp, op);
2070 }
2071 else
2072 {
2073 object *above = op->above;
2074
2075 for (tmp = above; tmp != NULL; tmp = tmp->above)
2076 if (tmp->type == PLAYER)
2077 esrv_send_item (tmp, op);
2078 }
2079 }
2080 break;
2081
2082 case CFAPI_OBJECT_PROP_DIRECTION:
2083 iarg = va_arg (args, int);
2084
2085 op->direction = iarg;
2086 break;
2087
2088 case CFAPI_OBJECT_PROP_FACING:
2089 iarg = va_arg (args, int);
2090
2091 op->facing = iarg;
2092 break;
2093
2094 case CFAPI_OBJECT_PROP_RESIST:
2095 {
2096 int iargbis = va_arg (args, int);
2097 iarg = va_arg (args, int);
2098
2099 op->resist[iargbis] = iarg;
2100 }
2101 break;
2102
2103 case CFAPI_OBJECT_PROP_ATTACK_TYPE:
2104 iarg = va_arg (args, int);
2105
2106 op->attacktype = iarg;
2107 break;
2108
2109 case CFAPI_OBJECT_PROP_PATH_ATTUNED:
2110 iarg = va_arg (args, int);
2111
2112 op->path_attuned = iarg;
2113 break;
2114
2115 case CFAPI_OBJECT_PROP_PATH_REPELLED:
2116 iarg = va_arg (args, int);
2117
2118 op->path_repelled = iarg;
2119 break;
2120
2121 case CFAPI_OBJECT_PROP_PATH_DENIED:
2122 iarg = va_arg (args, int);
2123
2124 op->path_denied = iarg;
2125 break;
2126
2127 case CFAPI_OBJECT_PROP_MATERIAL:
2128 iarg = va_arg (args, int);
2129
2130 op->material = iarg;
2131 break;
2132
2133 case CFAPI_OBJECT_PROP_MATERIAL_NAME:
2134 break;
2135
2136 case CFAPI_OBJECT_PROP_MAGIC:
2137 iarg = va_arg (args, int);
2138
2139 op->magic = iarg;
2140 break;
2141
2142 case CFAPI_OBJECT_PROP_VALUE:
2143 iarg = va_arg (args, int);
2144
2145 op->value = iarg;
2146 break;
2147
2148 case CFAPI_OBJECT_PROP_LEVEL:
2149 iarg = va_arg (args, int);
2150
2151 op->level = iarg;
2152 break;
2153
2154 case CFAPI_OBJECT_PROP_LAST_HEAL:
2155 iarg = va_arg (args, int);
2156
2157 op->last_heal = iarg;
2158 break;
2159
2160 case CFAPI_OBJECT_PROP_LAST_SP:
2161 iarg = va_arg (args, int);
2162
2163 op->last_sp = iarg;
2164 break;
2165
2166 case CFAPI_OBJECT_PROP_LAST_GRACE:
2167 iarg = va_arg (args, int);
2168
2169 op->last_grace = iarg;
2170 break;
2171
2172 case CFAPI_OBJECT_PROP_LAST_EAT:
2173 iarg = va_arg (args, int);
2174
2175 op->last_eat = iarg;
2176 break;
2177
2178 case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
2179 iarg = va_arg (args, int);
2180
2181 op->invisible = iarg;
2182 break;
2183
2184 case CFAPI_OBJECT_PROP_PICK_UP:
2185 iarg = va_arg (args, int);
2186
2187 op->pick_up = iarg;
2188 break;
2189
2190 case CFAPI_OBJECT_PROP_ITEM_POWER:
2191 iarg = va_arg (args, int);
2192
2193 op->item_power = iarg;
2194 break;
2195
2196 case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
2197 iarg = va_arg (args, int);
2198
2199 op->gen_sp_armour = iarg;
2200 break;
2201
2202 case CFAPI_OBJECT_PROP_WEIGHT:
2203 iarg = va_arg (args, int);
2204
2205 if (op->weight != iarg)
2206 {
2207 object *tmp;
2208 player *pl;
2209
2210 op->weight = iarg;
2211 if (op->env != NULL)
2212 {
2213 tmp = is_player_inv (op->env);
2214 if (!tmp)
2215 {
2216 for (pl = first_player; pl; pl = pl->next)
2217 if (pl->ob->container == op->env)
2218 break;
2219 if (pl)
2220 tmp = pl->ob;
2221 else
2222 tmp = NULL;
2223 }
2224 else
2225 {
2226 sum_weight (tmp);
2227 fix_player (tmp);
2228 }
2229 if (tmp)
2230 esrv_send_item (tmp, op);
2231 }
2232 else
2233 {
2234 object *above = op->above;
2235
2236 for (tmp = above; tmp != NULL; tmp = tmp->above)
2237 if (tmp->type == PLAYER)
2238 esrv_send_item (tmp, op);
2239 }
2240 }
2241 break;
2242
2243 case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
2244 iarg = va_arg (args, int);
2245
2246 op->weight_limit = iarg;
2247 break;
2248
2249 case CFAPI_OBJECT_PROP_GLOW_RADIUS:
2250 iarg = va_arg (args, int);
2251
2252 op->glow_radius = iarg;
2253 break;
2254
2255 case CFAPI_OBJECT_PROP_PERM_EXP:
2256 larg = va_arg (args, long);
2257
2258 op->perm_exp = larg;
2259 break;
2260
2261 case CFAPI_OBJECT_PROP_ENEMY:
2262 oparg = va_arg (args, object *);
2263
2264 op->enemy = oparg;
2265 break;
2266
2267 case CFAPI_OBJECT_PROP_RUN_AWAY:
2268 iarg = va_arg (args, int);
2269
2270 op->run_away = iarg;
2271 break;
2272
2273 case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
2274 oparg = va_arg (args, object *);
2275
2276 op->chosen_skill = oparg;
2277 break;
2278
2279 case CFAPI_OBJECT_PROP_HIDDEN:
2280 iarg = va_arg (args, int);
2281
2282 op->hide = iarg;
2283 break;
2284
2285 case CFAPI_OBJECT_PROP_MOVE_STATUS:
2286 iarg = va_arg (args, int);
2287
2288 op->move_status = iarg;
2289 break;
2290
2291 case CFAPI_OBJECT_PROP_MOVE_TYPE:
2292 iarg = va_arg (args, int);
2293
2294 op->attack_movement = iarg;
2295 break;
2296
2297 case CFAPI_OBJECT_PROP_SPELL_ITEM:
2298 oparg = va_arg (args, object *);
2299
2300 op->spellitem = oparg;
2301 break;
2302
2303 case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
2304 darg = va_arg (args, double);
2305
2306 op->expmul = darg;
2307 break;
2308
2309 case CFAPI_OBJECT_PROP_CUSTOM_NAME:
2310 sarg = va_arg (args, char *);
2311
2312 FREE_AND_COPY (op->custom_name, sarg);
2313 send_changed_object (op);
2314 break;
2315
2316 case CFAPI_OBJECT_PROP_ANIM_SPEED:
2317 iarg = va_arg (args, int);
2318
2319 op->anim_speed = iarg;
2320 break;
2321
2322 case CFAPI_OBJECT_PROP_FRIENDLY:
2323 iarg = va_arg (args, int);
2324
2325 if (iarg == 1 && is_friendly (op) == 0)
2326 add_friendly_object (op);
2327 else if (iarg == 0 && is_friendly (op) == 1)
2328 remove_friendly_object (op);
2329 break;
2330
2331 case CFAPI_OBJECT_PROP_LUCK:
2332 iarg = va_arg (args, int);
2333
2334 op->stats.luck = iarg;
2335 break;
2336
2337 case CFAPI_OBJECT_PROP_EXP:
2338 {
2339 char *skillname;
2340
2341 larg = va_arg (args, long);
2342 skillname = va_arg (args, char *);
2343 iarg = va_arg (args, int);
2344
2345 change_exp (op, larg, skillname, iarg);
2346 }
2347 break;
2348
2349 case CFAPI_OBJECT_PROP_OWNER:
2350 oparg = va_arg (args, object *);
2351
2352 set_owner (op, oparg);
2353 break;
2354
2355 case CFAPI_OBJECT_PROP_CHEATER:
2356 set_cheat (op);
2357 break;
2358
2359 case CFAPI_OBJECT_PROP_FLAGS:
2360 {
2361 int iargbis;
2362 iarg = va_arg (args, int);
2363 iargbis = va_arg (args, int);
2364
2365 if (iargbis == 1)
2366 SET_FLAG (op, iarg);
2367 else
2368 CLEAR_FLAG (op, iarg);
2369 }
2370 break;
2371
2372 case CFAPI_OBJECT_PROP_STR:
2373 iarg = va_arg (args, int);
2374
2375 op->stats.Str = iarg;
2376 break;
2377
2378 case CFAPI_OBJECT_PROP_DEX:
2379 iarg = va_arg (args, int);
2380
2381 op->stats.Dex = iarg;
2382 break;
2383
2384 case CFAPI_OBJECT_PROP_CON:
2385 iarg = va_arg (args, int);
2386
2387 op->stats.Con = iarg;
2388 break;
2389
2390 case CFAPI_OBJECT_PROP_WIS:
2391 iarg = va_arg (args, int);
2392
2393 op->stats.Wis = iarg;
2394 break;
2395
2396 case CFAPI_OBJECT_PROP_INT:
2397 iarg = va_arg (args, int);
2398
2399 op->stats.Int = iarg;
2400 break;
2401
2402 case CFAPI_OBJECT_PROP_POW:
2403 iarg = va_arg (args, int);
2404
2405 op->stats.Pow = iarg;
2406 break;
2407
2408 case CFAPI_OBJECT_PROP_CHA:
2409 iarg = va_arg (args, int);
2410
2411 op->stats.Cha = iarg;
2412 break;
2413
2414 case CFAPI_OBJECT_PROP_WC:
2415 iarg = va_arg (args, int);
2416
2417 op->stats.wc = iarg;
2418 break;
2419
2420 case CFAPI_OBJECT_PROP_AC:
2421 iarg = va_arg (args, int);
2422
2423 op->stats.ac = iarg;
2424 break;
2425
2426 case CFAPI_OBJECT_PROP_HP:
2427 iarg = va_arg (args, int);
2428
2429 op->stats.hp = iarg;
2430 break;
2431
2432 case CFAPI_OBJECT_PROP_SP:
2433 iarg = va_arg (args, int);
2434
2435 op->stats.sp = iarg;
2436 break;
2437
2438 case CFAPI_OBJECT_PROP_GP:
2439 iarg = va_arg (args, int);
2440
2441 op->stats.grace = iarg;
2442 break;
2443
2444 case CFAPI_OBJECT_PROP_FP:
2445 iarg = va_arg (args, int);
2446
2447 op->stats.food = iarg;
2448 break;
2449
2450 case CFAPI_OBJECT_PROP_MAXHP:
2451 iarg = va_arg (args, int);
2452
2453 op->stats.maxhp = iarg;
2454 break;
2455
2456 case CFAPI_OBJECT_PROP_MAXSP:
2457 iarg = va_arg (args, int);
2458
2459 op->stats.maxsp = iarg;
2460 break;
2461
2462 case CFAPI_OBJECT_PROP_MAXGP:
2463 iarg = va_arg (args, int);
2464
2465 op->stats.maxgrace = iarg;
2466 break;
2467
2468 case CFAPI_OBJECT_PROP_DAM:
2469 iarg = va_arg (args, int);
2470
2471 op->stats.dam = iarg;
2472 break;
2473
2474 case CFAPI_OBJECT_PROP_FACE:
2475 iarg = va_arg (args, int);
2476
2477 op->animation_id = iarg;
2478 update_object (op, UP_OBJ_FACE);
2479 break;
2480
2481 case CFAPI_OBJECT_ANIMATION:
2482 iarg = va_arg (args, int);
2483
2484 if (iarg != -1)
2485 {
2486 SET_ANIMATION (op, iarg);
2487 }
2488 update_object (op, UP_OBJ_FACE);
2489 break;
2490
2491 case CFAPI_PLAYER_PROP_MARKED_ITEM:
2492 if (op->contr)
2493 {
2494 oparg = va_arg (args, object *);
2495
2496 op->contr->mark = oparg;
2497 if (oparg)
2498 op->contr->mark_count = oparg->count;
2499 }
2500 break;
2501
2502 case CFAPI_PLAYER_PROP_PARTY:
2503 if (op->contr)
2504 {
2505 partyarg = va_arg (args, partylist *);
2506
2507 op->contr->party = partyarg;
2508 }
2509 break;
2510
2511 default:
2512 *type = CFAPI_NONE;
2513 break;
2514 }
2515 }
2516 va_end (args);
2517
2518 *type = CFAPI_NONE;
2519 return NULL;
2520} 816}
2521 817
2522void * 818void *
2523cfapi_object_apply_below (int *type, ...) 819cfapi_object_apply_below (int *type, ...)
2524{ 820{
… …
2588 owner = va_arg (args, object *); 884 owner = va_arg (args, object *);
2589 885
2590 va_end (args); 886 va_end (args);
2591 887
2592 *type = CFAPI_STRING; 888 *type = CFAPI_STRING;
2593 return describe_item (op, owner); 889 return (char *)describe_item (op, owner);
2594} 890}
2595 891
2596void * 892void *
2597cfapi_object_drain (int *type, ...) 893cfapi_object_drain (int *type, ...)
2598{ 894{
2599 va_list args; 895 abort ();
2600
2601 object *op;
2602 int ds;
2603
2604 va_start (args, type);
2605
2606 op = va_arg (args, object *);
2607 ds = va_arg (args, int);
2608
2609 va_end (args);
2610
2611 drain_specific_stat (op, ds);
2612
2613 *type = CFAPI_NONE;
2614 return NULL;
2615} 896}
2616 897
2617void * 898void *
2618cfapi_object_fix (int *type, ...) 899cfapi_object_fix (int *type, ...)
2619{ 900{
… …
2624 905
2625 op = va_arg (args, object *); 906 op = va_arg (args, object *);
2626 907
2627 va_end (args); 908 va_end (args);
2628 909
2629 fix_player (op); 910 op->update_stats ();
2630 911
2631 *type = CFAPI_NONE; 912 *type = CFAPI_NONE;
2632 return NULL; 913 return NULL;
2633} 914}
2634 915
… …
2682 op = va_arg (args, object *); 963 op = va_arg (args, object *);
2683 964
2684 va_end (args); 965 va_end (args);
2685 966
2686 send_removed_object (op); 967 send_removed_object (op);
2687 remove_ob (op); 968 op->remove ();
2688 *type = CFAPI_NONE; 969 *type = CFAPI_NONE;
2689 return NULL; 970 return NULL;
2690} 971}
2691 972
2692void * 973void *
… …
2699 980
2700 op = va_arg (args, object *); 981 op = va_arg (args, object *);
2701 982
2702 va_end (args); 983 va_end (args);
2703 984
2704 free_object (op); 985 op->destroy ();
2705 986
2706 *type = CFAPI_NONE; 987 *type = CFAPI_NONE;
2707 return NULL; 988 return NULL;
2708} 989}
2709 990
… …
2726 *type = CFAPI_POBJECT; 1007 *type = CFAPI_POBJECT;
2727 return object_create_clone (op); 1008 return object_create_clone (op);
2728 } 1009 }
2729 else 1010 else
2730 { 1011 {
2731 object *tmp; 1012 object *tmp = op->clone ();
2732
2733 tmp = get_object ();
2734 copy_object (op, tmp);
2735 *type = CFAPI_POBJECT; 1013 *type = CFAPI_POBJECT;
2736 return tmp; 1014 return tmp;
2737 } 1015 }
2738} 1016}
2739void * 1017void *
… …
2775 break; 1053 break;
2776 1054
2777 case 3: 1055 case 3:
2778 op = va_arg (args, object *); 1056 op = va_arg (args, object *);
2779 1057
2780 rv = is_player_inv (op); 1058 rv = op->in_player ();
2781 break; 1059 break;
2782 1060
2783 default: 1061 default:
2784 rv = NULL; 1062 rv = NULL;
2785 *type = CFAPI_NONE; 1063 *type = CFAPI_NONE;
… …
2803 *type = CFAPI_POBJECT; 1081 *type = CFAPI_POBJECT;
2804 switch (ival) 1082 switch (ival)
2805 { 1083 {
2806 case 0: 1084 case 0:
2807 va_end (args); 1085 va_end (args);
2808 return get_object (); 1086 return object::create ();
2809 break; 1087 break;
2810 1088
2811 case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */ 1089 case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */
2812 { 1090 {
2813 char *sval; 1091 char *sval;
… …
2816 1094
2817 op = get_archetype_by_object_name (sval); 1095 op = get_archetype_by_object_name (sval);
2818 1096
2819 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) 1097 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
2820 { 1098 {
2821 free_object (op); 1099 op->destroy ();
2822 /* Try with archetype names... */ 1100 /* Try with archetype names... */
2823 op = get_archetype (sval); 1101 op = get_archetype (sval);
2824 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) 1102 if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
2825 { 1103 {
2826 free_object (op); 1104 op->destroy ();
2827 *type = CFAPI_NONE; 1105 *type = CFAPI_NONE;
2828 va_end (args); 1106 va_end (args);
2829 return NULL; 1107 return NULL;
2830 } 1108 }
2831 } 1109 }
… …
2845cfapi_object_insert (int *type, ...) 1123cfapi_object_insert (int *type, ...)
2846{ 1124{
2847 va_list args; 1125 va_list args;
2848 object *op; 1126 object *op;
2849 object *orig; 1127 object *orig;
2850 mapstruct *map; 1128 maptile *map;
2851 int flag, x, y; 1129 int flag, x, y;
2852 int itype; 1130 int itype;
2853 char *arch_string; 1131 char *arch_string;
2854 void *rv = NULL; 1132 void *rv = NULL;
2855 1133
… …
2859 itype = va_arg (args, int); 1137 itype = va_arg (args, int);
2860 1138
2861 switch (itype) 1139 switch (itype)
2862 { 1140 {
2863 case 0: 1141 case 0:
2864 map = va_arg (args, mapstruct *); 1142 map = va_arg (args, maptile *);
2865 orig = va_arg (args, object *); 1143 orig = va_arg (args, object *);
2866 flag = va_arg (args, int); 1144 flag = va_arg (args, int);
2867 x = va_arg (args, int); 1145 x = va_arg (args, int);
2868 y = va_arg (args, int); 1146 y = va_arg (args, int);
2869 1147
2870 rv = insert_ob_in_map_at (op, map, orig, flag, x, y); 1148 rv = insert_ob_in_map_at (op, map, orig, flag, x, y);
2871 *type = CFAPI_POBJECT; 1149 *type = CFAPI_POBJECT;
2872 break; 1150 break;
2873 1151
2874 case 1: 1152 case 1:
2875 map = va_arg (args, mapstruct *); 1153 map = va_arg (args, maptile *);
2876 orig = va_arg (args, object *); 1154 orig = va_arg (args, object *);
2877 flag = va_arg (args, int); 1155 flag = va_arg (args, int);
2878 1156
2879 rv = insert_ob_in_map (op, map, orig, flag); 1157 rv = insert_ob_in_map (op, map, orig, flag);
2880 *type = CFAPI_POBJECT; 1158 *type = CFAPI_POBJECT;
… …
2981} 1259}
2982 1260
2983void * 1261void *
2984cfapi_object_clear (int *type, ...) 1262cfapi_object_clear (int *type, ...)
2985{ 1263{
2986 va_list args; 1264 abort ();
2987 object *op;
2988
2989 va_start (args, type);
2990
2991 op = va_arg (args, object *);
2992
2993 va_end (args);
2994
2995 clear_object (op);
2996 *type = CFAPI_NONE;
2997 return NULL;
2998} 1265}
2999 1266
3000void * 1267void *
3001cfapi_object_reset (int *type, ...) 1268cfapi_object_reset (int *type, ...)
3002{ 1269{
… …
3035} 1302}
3036 1303
3037void * 1304void *
3038cfapi_object_clean_object (int *type, ...) 1305cfapi_object_clean_object (int *type, ...)
3039{ 1306{
3040 va_list args; 1307 abort ();
3041 object *op;
3042
3043 va_start (args, type);
3044 op = va_arg (args, object *);
3045
3046 clean_object (op);
3047 va_end (args);
3048 *type = CFAPI_NONE;
3049 return NULL;
3050} 1308}
3051 1309
3052void * 1310void *
3053cfapi_object_on_same_map (int *type, ...) 1311cfapi_object_on_same_map (int *type, ...)
3054{ 1312{
… …
3266 object *op; 1524 object *op;
3267 object *originator; 1525 object *originator;
3268 int x, y, randompos, ttype; 1526 int x, y, randompos, ttype;
3269 va_list args; 1527 va_list args;
3270 static int rv = 0; 1528 static int rv = 0;
3271 mapstruct *map; 1529 maptile *map;
3272 1530
3273 va_start (args, type); 1531 va_start (args, type);
3274 op = va_arg (args, object *); 1532 op = va_arg (args, object *);
3275 ttype = va_arg (args, int); 1533 ttype = va_arg (args, int);
3276 1534
… …
3290 break; 1548 break;
3291 1549
3292 case 1: 1550 case 1:
3293 x = va_arg (args, int); 1551 x = va_arg (args, int);
3294 y = va_arg (args, int); 1552 y = va_arg (args, int);
3295 map = va_arg (args, mapstruct *); 1553 map = va_arg (args, maptile *);
3296 1554
3297 va_end (args); 1555 va_end (args);
3298 if (x < 0 || y < 0) 1556 if (x < 0 || y < 0)
3299 { 1557 {
3300 x = map->enter_x; 1558 x = map->enter_x;
3301 y = map->enter_y; 1559 y = map->enter_y;
3302 } 1560 }
3303 1561
3304/* 1562/*
3305 originator = get_object(); 1563 originator = object::create();
3306 EXIT_PATH(originator) = add_string(map->path); 1564 EXIT_PATH(originator) = map->path;
3307 EXIT_X(originator) = x; 1565 EXIT_X(originator) = x;
3308 EXIT_Y(originator) = y; 1566 EXIT_Y(originator) = y;
3309 printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/ 1567 printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/
3310 /*enter_exit(op, originator); */ 1568 /*enter_exit(op, originator); */
3311 insert_ob_in_map_at (op, map, NULL, 0, x, y); 1569 insert_ob_in_map_at (op, map, NULL, 0, x, y);
3312 /*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name); 1570 /*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name);
3313 free_object(originator); 1571 originator->destroy ();
3314 */ 1572 */
3315 *type = CFAPI_INT; 1573 *type = CFAPI_INT;
3316 return &rv; 1574 return &rv;
3317 break; 1575 break;
3318 1576
… …
3391 drop (author, op); 1649 drop (author, op);
3392 1650
3393 if (author->type == PLAYER) 1651 if (author->type == PLAYER)
3394 { 1652 {
3395 author->contr->count = 0; 1653 author->contr->count = 0;
3396 author->contr->socket.update_look = 1; 1654 author->contr->ns->floorbox_update ();
3397 } 1655 }
3398 1656
3399 *type = CFAPI_NONE; 1657 *type = CFAPI_NONE;
3400 return NULL; 1658 return NULL;
3401} 1659}
… …
3432 1690
3433/* PLAYER SUBCLASS */ 1691/* PLAYER SUBCLASS */
3434void * 1692void *
3435cfapi_player_find (int *type, ...) 1693cfapi_player_find (int *type, ...)
3436{ 1694{
3437 va_list args; 1695 abort ();
3438 void *rv;
3439 char *sval;
3440
3441 va_start (args, type);
3442
3443 sval = va_arg (args, char *);
3444
3445 va_end (args);
3446
3447 rv = find_player (sval);
3448
3449 *type = CFAPI_PPLAYER;
3450 return rv;
3451} 1696}
3452 1697
3453void * 1698void *
3454cfapi_player_message (int *type, ...) 1699cfapi_player_message (int *type, ...)
3455{ 1700{
… …
3482} 1727}
3483 1728
3484void * 1729void *
3485cfapi_object_teleport (int *type, ...) 1730cfapi_object_teleport (int *type, ...)
3486{ 1731{
3487 mapstruct *map; 1732 maptile *map;
3488 int x, y; 1733 int x, y;
3489 object *who; 1734 object *who;
3490 static int result; 1735 static int result;
3491 va_list args; 1736 va_list args;
3492 1737
3493 va_start (args, type); 1738 va_start (args, type);
3494 who = va_arg (args, object *); 1739 who = va_arg (args, object *);
3495 map = va_arg (args, mapstruct *); 1740 map = va_arg (args, maptile *);
3496 x = va_arg (args, int); 1741 x = va_arg (args, int);
3497 y = va_arg (args, int); 1742 y = va_arg (args, int);
3498 1743
3499 if (!out_of_map (map, x, y)) 1744 if (!out_of_map (map, x, y))
3500 { 1745 {
… …
3507 result = 1; 1752 result = 1;
3508 return &result; 1753 return &result;
3509 } 1754 }
3510 1755
3511 send_removed_object (who); 1756 send_removed_object (who);
3512 remove_ob (who); 1757 who->remove ();
3513 1758
3514 for (tmp = who; tmp != NULL; tmp = tmp->more) 1759 for (tmp = who; tmp != NULL; tmp = tmp->more)
3515 tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x), 1760 tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x),
3516 tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y); 1761 tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);
3517 1762
… …
3602 1847
3603/* Party-related functions */ 1848/* Party-related functions */
3604void * 1849void *
3605cfapi_party_get_property (int *type, ...) 1850cfapi_party_get_property (int *type, ...)
3606{ 1851{
3607 partylist *party; 1852 abort ();
3608 int prop;
3609 va_list args;
3610 void *rv;
3611 object *obarg;
3612 player *pl;
3613
3614 va_start (args, type);
3615 party = va_arg (args, partylist *);
3616 prop = va_arg (args, int);
3617
3618 switch (prop)
3619 {
3620 case CFAPI_PARTY_PROP_NAME:
3621 *type = CFAPI_STRING;
3622 rv = (void *) party->partyname;
3623 break;
3624
3625 case CFAPI_PARTY_PROP_NEXT:
3626 *type = CFAPI_PPARTY;
3627 rv = (party ? party->next : get_firstparty ());
3628 break;
3629
3630 case CFAPI_PARTY_PROP_PASSWORD:
3631 *type = CFAPI_STRING;
3632 rv = (void *) party->passwd;
3633 break;
3634
3635 case CFAPI_PARTY_PROP_PLAYER:
3636 *type = CFAPI_PPLAYER;
3637 obarg = va_arg (args, object *);
3638
3639 pl = (obarg ? obarg->contr : first_player);
3640 rv = NULL;
3641 for (; pl != NULL; pl = pl->next)
3642 if (pl->ob->contr->party == party)
3643 {
3644 rv = (void *) pl;
3645 break;
3646 }
3647 break;
3648
3649 default:
3650 *type = CFAPI_NONE;
3651 rv = NULL;
3652 break;
3653 }
3654 va_end (args);
3655 return rv;
3656} 1853}
3657 1854
3658/* Regions-related functions */ 1855/* Regions-related functions */
3659void * 1856void *
3660cfapi_region_get_property (int *type, ...) 1857cfapi_region_get_property (int *type, ...)
3661{ 1858{
3662 region *reg; 1859 abort ();
3663 int prop;
3664 va_list args;
3665 void *rv;
3666
3667 va_start (args, type);
3668 reg = va_arg (args, region *);
3669 prop = va_arg (args, int);
3670
3671 switch (prop)
3672 {
3673 case CFAPI_REGION_PROP_NAME:
3674 *type = CFAPI_STRING;
3675 rv = (void *) reg->name;
3676 break;
3677
3678 case CFAPI_REGION_PROP_NEXT:
3679 *type = CFAPI_PREGION;
3680 rv = (reg ? reg->next : first_region);
3681 break;
3682
3683 case CFAPI_REGION_PROP_PARENT:
3684 *type = CFAPI_PREGION;
3685 rv = (void *) reg->parent;
3686 break;
3687
3688 case CFAPI_REGION_PROP_LONGNAME:
3689 *type = CFAPI_STRING;
3690 rv = (void *) reg->longname;
3691 break;
3692
3693 case CFAPI_REGION_PROP_MESSAGE:
3694 *type = CFAPI_STRING;
3695 rv = (void *) reg->msg;
3696 break;
3697
3698 default:
3699 *type = CFAPI_NONE;
3700 rv = NULL;
3701 break;
3702 }
3703 va_end (args);
3704 return rv;
3705} 1860}
3706 1861
3707/*****************************************************************************/ 1862/*****************************************************************************/
3708 1863
3709/* NEW PLUGIN STUFF ENDS HERE */ 1864/* NEW PLUGIN STUFF ENDS HERE */
… …
3739 return NULL; 1894 return NULL;
3740} 1895}
3741 1896
3742/*****************************************************************************/ 1897/*****************************************************************************/
3743 1898
3744/* Plugins initialization. Browses the plugins directory and call */ 1899/* Plugins initialisation. Browses the plugins directory and call */
3745 1900
3746/* initOnePlugin for each file found. */ 1901/* initOnePlugin for each file found. */
3747 1902
3748/* Returns 0 if at least one plugin was successfully loaded, -1 if not */ 1903/* Returns 0 if at least one plugin was successfully loaded, -1 if not */
3749 1904
… …
3756 size_t l; 1911 size_t l;
3757 char buf[MAX_BUF]; 1912 char buf[MAX_BUF];
3758 char buf2[MAX_BUF]; 1913 char buf2[MAX_BUF];
3759 int result; 1914 int result;
3760 1915
3761 LOG (llevInfo, "Initializing plugins\n"); 1916 LOG (llevInfo, "Initialising plugins\n");
3762 strcpy (buf, LIBDIR); 1917 strcpy (buf, LIBDIR);
3763 strcat (buf, "/plugins/"); 1918 strcat (buf, "/plugins/");
3764 LOG (llevInfo, "Plugins directory is %s\n", buf); 1919 LOG (llevInfo, "Plugins directory is %s\n", buf);
3765 1920
3766 plugins_init_perl (); 1921 plugins_init_perl ();

Diff Legend

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