ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/plugins.C

Comparing deliantra/server/server/plugins.C (file contents):
Revision 1.14 by root, Thu Sep 14 21:16:12 2006 UTC vs.
Revision 1.48 by root, Mon Jun 4 13:04:00 2007 UTC

1
2	/*	1	/*
3	* static char *rcsid_plugins_c =	2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
4	* "$Id: plugins.C,v 1.14 2006/09/14 21:16:12 root Exp $";	3	*
		4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
		5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
		6	* Copyright (©) 1992,2007 Frank Tore Johansen
		7	*
		8	* Crossfire TRT is free software; you can redistribute it and/or modify it
		9	* under the terms of the GNU General Public License as published by the Free
		10	* Software Foundation; either version 2 of the License, or (at your option)
		11	* any later version.
		12	*
		13	* This program is distributed in the hope that it will be useful, but
		14	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
		15	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
		16	* for more details.
		17	*
		18	* You should have received a copy of the GNU General Public License along
		19	* with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
		20	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		21	*
		22	* The authors can be reached via e-mail to <crossfire@schmorp.de>
5	*/	23	*/
6		24
7	/*****************************************************************************/	25	/*****************************************************************************/
8		26	/* This is the server-side plugin management part. */
9	/* CrossFire, A Multiplayer game for X-windows */
10
11	/* */
12
13	/* Copyright (C) 2000 Mark Wedel */
14
15	/* Copyright (C) 1992 Frank Tore Johansen */
16
17	/* */
18
19	/* 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 */
22
23	/* the Free Software Foundation; either version 2 of the License, or */
24
25	/* (at your option) any later version. */
26
27	/* */
28
29	/* This program is distributed in the hope that it will be useful, */
30
31	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
32
33	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
34
35	/* GNU General Public License for more details. */
36
37	/* */
38
39	/* 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 */
42
43	/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
44
45	/* */
46
47	/*****************************************************************************/	27	/*****************************************************************************/
48		28	/* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */
49	/* This is the server-side plugin management part. */	29	/* Special thanks to: */
50		30	/* David Delbecq (david.delbecq@mailandnews.com); */
		31	/* Joris Bontje (jbontje@suespammers.org); */
		32	/* Philip Currlin (?); */
51	/*****************************************************************************/	33	/*****************************************************************************/
52		34
53	/* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */
54
55	/* Special thanks to: */
56
57	/* David Delbecq (david.delbecq@mailandnews.com); */
58
59	/* Joris Bontje (jbontje@suespammers.org); */
60
61	/* Philip Currlin (?); */
62
63	/*****************************************************************************/	35	/*****************************************************************************/
64		36	/* First, the headers. We only include plugin.h, because all other includes */
		37	/* are done into it, and plugproto.h (which is used only by this file). */
65	/*****************************************************************************/	38	/*****************************************************************************/
66		39
67	/* 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). */
70
71	/*****************************************************************************/
72	#include <plugin.h>	40	#include <plugin.h>
73		41
74	#ifndef __CEXTRACT__	42	#ifndef __CEXTRACT__
75	# include <sproto.h>	43	# include <sproto.h>
76	#endif	44	#endif
…		…
79		47
80	static const hook_entry plug_hooks[NR_OF_HOOKS] = {	48	static const hook_entry plug_hooks[NR_OF_HOOKS] = {
81	{cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"},	49	{cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"},
82	{cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"},	50	{cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"},
83	{cfapi_system_check_path, 4, "cfapi_system_check_path"},	51	{cfapi_system_check_path, 4, "cfapi_system_check_path"},
84	{cfapi_system_re_cmp, 5, "cfapi_system_re_cmp"},	52	{NULL, 5, "cfapi_system_re_cmp"},
85	{cfapi_system_strdup_local, 6, "cfapi_system_strdup_local"},	53	{cfapi_system_strdup, 6, "cfapi_system_strdup"},
86	{cfapi_system_directory, 7, "cfapi_system_directory"},	54	{cfapi_system_directory, 7, "cfapi_system_directory"},
87	{cfapi_system_find_animation, 8, "cfapi_system_find_animation"},	55	{cfapi_system_find_animation, 8, "cfapi_system_find_animation"},
88	{cfapi_object_clean_object, 9, "cfapi_object_clean_object"},	56	{cfapi_object_clean_object, 9, "cfapi_object_clean_object"},
89	{cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"},	57	{cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"},
90	{cfapi_object_get_key, 11, "cfapi_object_get_key"},	58	{cfapi_object_get_key, 11, "cfapi_object_get_key"},
…		…
158		126
159	/* NEW PLUGIN STUFF STARTS HERE */	127	/* NEW PLUGIN STUFF STARTS HERE */
160		128
161	/*****************************************************************************/	129	/*****************************************************************************/
162		130
163	#ifdef WIN32
164	static const char *
165	plugins_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	*/
187	static void
188	send_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	/**	131	/**
218	* Notify clients about a removed object.	132	* Notify clients about a removed object.
219	*	133	*
220	* @param op the object about to be removed from its environment; it must still	134	* @param op the object about to be removed from its environment; it must still
221	* be present in its environment	135	* be present in its environment
222	*/	136	*/
223	static void	137	static void
224	send_removed_object (object *op)	138	send_removed_object (object *op)
225	{	139	{
226	object *tmp;	140	object *tmp;
227	player *pl;
228		141
229	if (op->env == NULL)	142	if (op->env == NULL)
230	{	143	{
231	/* no action necessary: remove_ob() notifies the client */	144	/* no action necessary: remove_ob() notifies the client */
232	return;	145	return;
233	}	146	}
234		147
235	tmp = is_player_inv (op->env);	148	tmp = op->in_player ();
236	if (!tmp)	149	if (!tmp)
237	{	150	{
238	for (pl = first_player; pl; pl = pl->next)	151	for_all_players (pl)
239	if (pl->ob->container == op->env)	152	if (pl->ob->container == op->env)
		153	{
		154	tmp = pl->ob;
240	break;	155	break;
241	if (pl)	156	}
242	tmp = pl->ob;
243	else
244	tmp = NULL;
245	}	157	}
		158
246	if (tmp)	159	if (tmp)
247	esrv_del_item (tmp->contr, op->count);	160	esrv_del_item (tmp->contr, op->count);
248	}	161	}
249		162
250	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr);	163	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr);
…		…
538	*type = CFAPI_INT;	451	*type = CFAPI_INT;
539	return &rv;	452	return &rv;
540	}	453	}
541		454
542	void *	455	void *
543	cfapi_system_strdup_local (int *type, ...)	456	cfapi_system_strdup (int *type, ...)
544	{	457	{
545	va_list args;	458	va_list args;
546	char *txt;	459	char *txt;
547		460
548	va_start (args, type);	461	va_start (args, type);
549	txt = va_arg (args, char *);	462	txt = va_arg (args, char *);
550		463
551	va_end (args);	464	va_end (args);
552	*type = CFAPI_STRING;	465	*type = CFAPI_STRING;
553	return strdup_local (txt);	466	return strdup (txt);
554	}	467	}
555		468
556	void *	469	void *
557	cfapi_system_register_global_event (int *type, ...)	470	cfapi_system_register_global_event (int *type, ...)
558	{	471	{
…		…
612	*type = CFAPI_INT;	525	*type = CFAPI_INT;
613	return &rv;	526	return &rv;
614	}	527	}
615		528
616	void *	529	void *
617	cfapi_system_re_cmp (int *type, ...)	530	cfapi_system_directory (int *type, ...)
618	{	531	{
619	va_list args;	532	va_list args;
620	char *rv;	533	int dirtype;
621	const char *str;
622	const char *regexp;
623		534
624	va_start (args, type);	535	va_start (args, type);
625		536
626	str = va_arg (args, char *);	537	dirtype = va_arg (args, int);
627	regexp = va_arg (args, char *);
628		538
629	rv = (char *) re_cmp (str, regexp);
630
631	va_end (args);	539	va_end (args);
		540
632	*type = CFAPI_STRING;	541	*type = CFAPI_STRING;
633	return rv;
634	}
635
636	void *
637	cfapi_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		542
650	switch (dirtype)	543	switch (dirtype)
651	{	544	{
652	case 0:	545	case 0:
653	return settings.mapdir;	546	return (char *)settings.mapdir;
654	break;	547	break;
655		548
656	case 1:	549	case 1:
657	return settings.uniquedir;	550	return (char *)settings.uniquedir;
658	break;	551	break;
659		552
660	case 2:	553	case 2:
661	return settings.tmpdir;	554	return (char *)settings.tmpdir;
662	break;	555	break;
663		556
664	case 3:	557	case 3:
665	return settings.confdir;	558	return (char *)settings.confdir;
666	break;	559	break;
667		560
668	case 4:	561	case 4:
669	return settings.localdir;	562	return (char *)settings.localdir;
670	break;	563	break;
671		564
672	case 5:	565	case 5:
673	return settings.playerdir;	566	return (char *)settings.playerdir;
674	break;	567	break;
675		568
676	case 6:	569	case 6:
677	return settings.datadir;	570	return (char *)settings.datadir;
678	break;	571	break;
679	}	572	}
680		573
681	*type = CFAPI_NONE;	574	*type = CFAPI_NONE;
682	return NULL;	575	return NULL;
…		…
686	/* MAP RELATED HOOKS */	579	/* MAP RELATED HOOKS */
687		580
688	void *	581	void *
689	cfapi_map_get_map (int *type, ...)	582	cfapi_map_get_map (int *type, ...)
690	{	583	{
		584	abort ();
		585	}
		586
		587	void *
		588	cfapi_map_has_been_loaded (int *type, ...)
		589	{
		590	abort ();
		591	}
		592
		593	void *
		594	cfapi_map_create_path (int *type, ...)
		595	{
		596	abort ();
		597	}
		598
		599	void *
		600	cfapi_map_get_map_property (int *type, ...)
		601	{
		602	abort ();
		603	}
		604
		605	void *
		606	cfapi_map_set_map_property (int *type, ...)
		607	{
		608	abort ();
		609	}
		610
		611	void *
		612	cfapi_map_out_of_map (int *type, ...)
		613	{
		614	abort ();
		615	}
		616
		617	void *
		618	cfapi_map_update_position (int *type, ...)
		619	{
691	va_list args;	620	va_list args;
692	mapstruct *rv;	621	maptile *map;
693	int ctype;
694	int x, y;	622	int x, y;
695	sint16 nx, ny;
696	char *name;
697	mapstruct *m;
698		623
699	va_start (args, type);	624	va_start (args, type);
700		625
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
742	void *
743	cfapi_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
758	void *
759	cfapi_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
796	void *
797	cfapi_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
1041	void *
1042	cfapi_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	}
1081	void *
1082	cfapi_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 *);	626	map = va_arg (args, maptile *);
1091	x = va_arg (args, int);	627	x = va_arg (args, int);
1092	y = va_arg (args, int);	628	y = va_arg (args, int);
1093		629
1094	rv = out_of_map (map, x, y);	630	map->at (x, y).flags_ &= ~P_UPTODATE;
		631
1095	va_end (args);	632	va_end (args);
		633	*type = CFAPI_NONE;
		634	return NULL;
		635	}
		636
		637	void *
		638	cfapi_map_delete_map (int *type, ...)
		639	{
		640	abort ();
		641	}
		642
		643	void *
		644	cfapi_map_message (int *type, ...)
		645	{
		646	va_list args;
		647	maptile *map;
		648	char *string;
		649	int color;
		650
		651	va_start (args, type);
		652	map = va_arg (args, maptile *);
		653	string = va_arg (args, char *);
		654	color = va_arg (args, int);
		655
		656	va_end (args);
		657
		658	new_info_map (color, map, string);
		659	*type = CFAPI_NONE;
		660	return NULL;
		661	}
		662
		663	void *
		664	cfapi_map_get_object_at (int *type, ...)
		665	{
		666	va_list args;
		667	maptile *map;
		668	int x, y;
		669	object *rv;
		670
		671	va_start (args, type);
		672	map = va_arg (args, maptile *);
		673	x = va_arg (args, int);
		674	y = va_arg (args, int);
		675
		676	va_end (args);
		677
		678	rv = GET_MAP_OB (map, x, y);
		679	*type = CFAPI_POBJECT;
		680	return rv;
		681	}
		682
		683	void *
		684	cfapi_map_get_flags (int *type, ...)
		685	{
		686	va_list args;
		687	sint16 x, y;
		688	sint16 *nx, *ny;
		689	static maptile *map;
		690	maptile **newmap;
		691	static int rv;
		692
		693	va_start (args, type);
		694
		695	map = va_arg (args, maptile *);
		696	newmap = va_arg (args, maptile **);
		697	x = va_arg (args, int);
		698	y = va_arg (args, int);
		699
		700	nx = va_arg (args, sint16 *);
		701	ny = va_arg (args, sint16 *);
		702	va_end (args);
		703
		704	rv = get_map_flags (map, newmap, x, y, nx, ny);
		705
1096	*type = CFAPI_INT;	706	*type = CFAPI_INT;
1097	return &rv;	707	return &rv;
1098	}	708	}
1099		709
1100	void *	710	void *
1101	cfapi_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
1119	void *
1120	cfapi_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
1136	void *
1137	cfapi_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
1156	void *
1157	cfapi_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
1176	void *
1177	cfapi_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
1203	void *
1204	cfapi_map_present_arch_by_name (int *type, ...)	711	cfapi_map_present_arch_by_name (int *type, ...)
1205	{	712	{
1206	va_list args;	713	va_list args;
1207	object *rv;	714	object *rv;
1208	int x, y;	715	int x, y;
1209	mapstruct *map;	716	maptile *map;
1210	char *msg;	717	char *msg;
1211		718
1212	va_start (args, type);	719	va_start (args, type);
1213		720
1214	msg = va_arg (args, char *);	721	msg = va_arg (args, char *);
1215	map = va_arg (args, mapstruct *);	722	map = va_arg (args, maptile *);
1216	x = va_arg (args, int);	723	x = va_arg (args, int);
1217	y = va_arg (args, int);	724	y = va_arg (args, int);
1218		725
1219	va_end (args);	726	va_end (args);
1220		727
…		…
1302	}	809	}
1303		810
1304	void *	811	void *
1305	cfapi_object_get_property (int *type, ...)	812	cfapi_object_get_property (int *type, ...)
1306	{	813	{
1307	va_list args;	814	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	}	815	}
1948		816
1949	void *	817	void *
1950	cfapi_object_set_property (int *type, ...)	818	cfapi_object_set_property (int *type, ...)
1951	{	819	{
1952	va_list args;	820	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	}	821	}
2521		822
2522	void *	823	void *
2523	cfapi_object_apply_below (int *type, ...)	824	cfapi_object_apply_below (int *type, ...)
2524	{	825	{
…		…
2588	owner = va_arg (args, object *);	889	owner = va_arg (args, object *);
2589		890
2590	va_end (args);	891	va_end (args);
2591		892
2592	*type = CFAPI_STRING;	893	*type = CFAPI_STRING;
2593	return describe_item (op, owner);	894	return (char *)describe_item (op, owner);
2594	}	895	}
2595		896
2596	void *	897	void *
2597	cfapi_object_drain (int *type, ...)	898	cfapi_object_drain (int *type, ...)
2598	{	899	{
2599	va_list args;	900	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	}	901	}
2616		902
2617	void *	903	void *
2618	cfapi_object_fix (int *type, ...)	904	cfapi_object_fix (int *type, ...)
2619	{	905	{
…		…
2624		910
2625	op = va_arg (args, object *);	911	op = va_arg (args, object *);
2626		912
2627	va_end (args);	913	va_end (args);
2628		914
2629	fix_player (op);	915	op->update_stats ();
2630		916
2631	*type = CFAPI_NONE;	917	*type = CFAPI_NONE;
2632	return NULL;	918	return NULL;
2633	}	919	}
2634		920
…		…
2682	op = va_arg (args, object *);	968	op = va_arg (args, object *);
2683		969
2684	va_end (args);	970	va_end (args);
2685		971
2686	send_removed_object (op);	972	send_removed_object (op);
2687	remove_ob (op);	973	op->remove ();
2688	*type = CFAPI_NONE;	974	*type = CFAPI_NONE;
2689	return NULL;	975	return NULL;
2690	}	976	}
2691		977
2692	void *	978	void *
…		…
2699		985
2700	op = va_arg (args, object *);	986	op = va_arg (args, object *);
2701		987
2702	va_end (args);	988	va_end (args);
2703		989
2704	free_object (op);	990	op->destroy ();
2705		991
2706	*type = CFAPI_NONE;	992	*type = CFAPI_NONE;
2707	return NULL;	993	return NULL;
2708	}	994	}
2709		995
…		…
2726	*type = CFAPI_POBJECT;	1012	*type = CFAPI_POBJECT;
2727	return object_create_clone (op);	1013	return object_create_clone (op);
2728	}	1014	}
2729	else	1015	else
2730	{	1016	{
2731	object *tmp;	1017	object *tmp = op->clone ();
2732
2733	tmp = get_object ();
2734	copy_object (op, tmp);
2735	*type = CFAPI_POBJECT;	1018	*type = CFAPI_POBJECT;
2736	return tmp;	1019	return tmp;
2737	}	1020	}
2738	}	1021	}
2739	void *	1022	void *
…		…
2775	break;	1058	break;
2776		1059
2777	case 3:	1060	case 3:
2778	op = va_arg (args, object *);	1061	op = va_arg (args, object *);
2779		1062
2780	rv = is_player_inv (op);	1063	rv = op->in_player ();
2781	break;	1064	break;
2782		1065
2783	default:	1066	default:
2784	rv = NULL;	1067	rv = NULL;
2785	*type = CFAPI_NONE;	1068	*type = CFAPI_NONE;
…		…
2803	*type = CFAPI_POBJECT;	1086	*type = CFAPI_POBJECT;
2804	switch (ival)	1087	switch (ival)
2805	{	1088	{
2806	case 0:	1089	case 0:
2807	va_end (args);	1090	va_end (args);
2808	return get_object ();	1091	return object::create ();
2809	break;	1092	break;
2810		1093
2811	case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */	1094	case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */
2812	{	1095	{
2813	char *sval;	1096	char *sval;
2814	object *op;	1097	object *op;
2815	sval = va_arg (args, char *);	1098	sval = va_arg (args, char *);
2816		1099
2817	op = get_archetype_by_object_name (sval);	1100	op = get_archetype_by_object_name (sval);
2818		1101
2819	if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)	1102	if (strcmp (query_name (op), ARCH_SINGULARITY) == 0)
2820	{	1103	{
2821	free_object (op);	1104	op->destroy ();
2822	/* Try with archetype names... */	1105	/* Try with archetype names... */
2823	op = get_archetype (sval);	1106	op = get_archetype (sval);
2824	if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)	1107	if (strcmp (query_name (op), ARCH_SINGULARITY) == 0)
2825	{	1108	{
2826	free_object (op);	1109	op->destroy ();
2827	*type = CFAPI_NONE;	1110	*type = CFAPI_NONE;
2828	va_end (args);	1111	va_end (args);
2829	return NULL;	1112	return NULL;
2830	}	1113	}
2831	}	1114	}
…		…
2845	cfapi_object_insert (int *type, ...)	1128	cfapi_object_insert (int *type, ...)
2846	{	1129	{
2847	va_list args;	1130	va_list args;
2848	object *op;	1131	object *op;
2849	object *orig;	1132	object *orig;
2850	mapstruct *map;	1133	maptile *map;
2851	int flag, x, y;	1134	int flag, x, y;
2852	int itype;	1135	int itype;
2853	char *arch_string;	1136	char *arch_string;
2854	void *rv = NULL;	1137	void *rv = NULL;
2855		1138
…		…
2859	itype = va_arg (args, int);	1142	itype = va_arg (args, int);
2860		1143
2861	switch (itype)	1144	switch (itype)
2862	{	1145	{
2863	case 0:	1146	case 0:
2864	map = va_arg (args, mapstruct *);	1147	map = va_arg (args, maptile *);
2865	orig = va_arg (args, object *);	1148	orig = va_arg (args, object *);
2866	flag = va_arg (args, int);	1149	flag = va_arg (args, int);
2867	x = va_arg (args, int);	1150	x = va_arg (args, int);
2868	y = va_arg (args, int);	1151	y = va_arg (args, int);
2869		1152
2870	rv = insert_ob_in_map_at (op, map, orig, flag, x, y);	1153	rv = insert_ob_in_map_at (op, map, orig, flag, x, y);
2871	*type = CFAPI_POBJECT;	1154	*type = CFAPI_POBJECT;
2872	break;	1155	break;
2873		1156
2874	case 1:	1157	case 1:
2875	map = va_arg (args, mapstruct *);	1158	map = va_arg (args, maptile *);
2876	orig = va_arg (args, object *);	1159	orig = va_arg (args, object *);
2877	flag = va_arg (args, int);	1160	flag = va_arg (args, int);
2878		1161
2879	rv = insert_ob_in_map (op, map, orig, flag);	1162	rv = insert_ob_in_map (op, map, orig, flag);
2880	*type = CFAPI_POBJECT;	1163	*type = CFAPI_POBJECT;
…		…
2981	}	1264	}
2982		1265
2983	void *	1266	void *
2984	cfapi_object_clear (int *type, ...)	1267	cfapi_object_clear (int *type, ...)
2985	{	1268	{
2986	va_list args;	1269	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	}	1270	}
2999		1271
3000	void *	1272	void *
3001	cfapi_object_reset (int *type, ...)	1273	cfapi_object_reset (int *type, ...)
3002	{	1274	{
…		…
3035	}	1307	}
3036		1308
3037	void *	1309	void *
3038	cfapi_object_clean_object (int *type, ...)	1310	cfapi_object_clean_object (int *type, ...)
3039	{	1311	{
3040	va_list args;	1312	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	}	1313	}
3051		1314
3052	void *	1315	void *
3053	cfapi_object_on_same_map (int *type, ...)	1316	cfapi_object_on_same_map (int *type, ...)
3054	{	1317	{
…		…
3266	object *op;	1529	object *op;
3267	object *originator;	1530	object *originator;
3268	int x, y, randompos, ttype;	1531	int x, y, randompos, ttype;
3269	va_list args;	1532	va_list args;
3270	static int rv = 0;	1533	static int rv = 0;
3271	mapstruct *map;	1534	maptile *map;
3272		1535
3273	va_start (args, type);	1536	va_start (args, type);
3274	op = va_arg (args, object *);	1537	op = va_arg (args, object *);
3275	ttype = va_arg (args, int);	1538	ttype = va_arg (args, int);
3276		1539
…		…
3290	break;	1553	break;
3291		1554
3292	case 1:	1555	case 1:
3293	x = va_arg (args, int);	1556	x = va_arg (args, int);
3294	y = va_arg (args, int);	1557	y = va_arg (args, int);
3295	map = va_arg (args, mapstruct *);	1558	map = va_arg (args, maptile *);
3296		1559
3297	va_end (args);	1560	va_end (args);
3298	if (x < 0 || y < 0)	1561	if (x < 0 || y < 0)
3299	{	1562	{
3300	x = map->enter_x;	1563	x = map->enter_x;
3301	y = map->enter_y;	1564	y = map->enter_y;
3302	}	1565	}
3303		1566
3304	/*	1567	/*
3305	originator = get_object();	1568	originator = object::create();
3306	EXIT_PATH(originator) = add_string(map->path);	1569	EXIT_PATH(originator) = map->path;
3307	EXIT_X(originator) = x;	1570	EXIT_X(originator) = x;
3308	EXIT_Y(originator) = y;	1571	EXIT_Y(originator) = y;
3309	printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/	1572	printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/
3310	/*enter_exit(op, originator); */	1573	/*enter_exit(op, originator); */
3311	insert_ob_in_map_at (op, map, NULL, 0, x, y);	1574	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);	1575	/*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name);
3313	free_object(originator);	1576	originator->destroy ();
3314	*/	1577	*/
3315	*type = CFAPI_INT;	1578	*type = CFAPI_INT;
3316	return &rv;	1579	return &rv;
3317	break;	1580	break;
3318		1581
…		…
3391	drop (author, op);	1654	drop (author, op);
3392		1655
3393	if (author->type == PLAYER)	1656	if (author->type == PLAYER)
3394	{	1657	{
3395	author->contr->count = 0;	1658	author->contr->count = 0;
3396	author->contr->socket.update_look = 1;	1659	author->contr->ns->floorbox_update ();
3397	}	1660	}
3398		1661
3399	*type = CFAPI_NONE;	1662	*type = CFAPI_NONE;
3400	return NULL;	1663	return NULL;
3401	}	1664	}
…		…
3432		1695
3433	/* PLAYER SUBCLASS */	1696	/* PLAYER SUBCLASS */
3434	void *	1697	void *
3435	cfapi_player_find (int *type, ...)	1698	cfapi_player_find (int *type, ...)
3436	{	1699	{
3437	va_list args;	1700	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	}	1701	}
3452		1702
3453	void *	1703	void *
3454	cfapi_player_message (int *type, ...)	1704	cfapi_player_message (int *type, ...)
3455	{	1705	{
…		…
3482	}	1732	}
3483		1733
3484	void *	1734	void *
3485	cfapi_object_teleport (int *type, ...)	1735	cfapi_object_teleport (int *type, ...)
3486	{	1736	{
3487	mapstruct *map;	1737	maptile *map;
3488	int x, y;	1738	int x, y;
3489	object *who;	1739	object *who;
3490	static int result;	1740	static int result;
3491	va_list args;	1741	va_list args;
3492		1742
3493	va_start (args, type);	1743	va_start (args, type);
3494	who = va_arg (args, object *);	1744	who = va_arg (args, object *);
3495	map = va_arg (args, mapstruct *);	1745	map = va_arg (args, maptile *);
3496	x = va_arg (args, int);	1746	x = va_arg (args, int);
3497	y = va_arg (args, int);	1747	y = va_arg (args, int);
3498		1748
3499	if (!out_of_map (map, x, y))	1749	if (!out_of_map (map, x, y))
3500	{	1750	{
…		…
3507	result = 1;	1757	result = 1;
3508	return &result;	1758	return &result;
3509	}	1759	}
3510		1760
3511	send_removed_object (who);	1761	send_removed_object (who);
3512	remove_ob (who);	1762	who->remove ();
3513		1763
3514	for (tmp = who; tmp != NULL; tmp = tmp->more)	1764	for (tmp = who; tmp != NULL; tmp = tmp->more)
3515	tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x),	1765	tmp->x = x + freearr_x[k] + (tmp->arch == NULL ? 0 : tmp->arch->x),
3516	tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);	1766	tmp->y = y + freearr_y[k] + (tmp->arch == NULL ? 0 : tmp->arch->y);
3517		1767
3518	insert_ob_in_map (who, map, NULL, 0);	1768	insert_ob_in_map (who, map, NULL, 0);
3519	result = 0;	1769	result = 0;
3520	}	1770	}
3521		1771
…		…
3542		1792
3543	/* Archetype-related functions */	1793	/* Archetype-related functions */
3544	void *	1794	void *
3545	cfapi_archetype_get_first (int *type, ...)	1795	cfapi_archetype_get_first (int *type, ...)
3546	{	1796	{
3547	va_list args;	1797	abort ();
3548
3549	va_start (args, type);
3550	va_end (args);
3551	*type = CFAPI_PARCH;
3552	return first_archetype;
3553	}	1798	}
3554		1799
3555	void *	1800	void *
3556	cfapi_archetype_get_property (int *type, ...)	1801	cfapi_archetype_get_property (int *type, ...)
3557	{	1802	{
3558	archetype *arch;	1803	abort ();
3559	int prop;
3560	va_list args;
3561	void *rv;
3562
3563	va_start (args, type);
3564	arch = va_arg (args, archetype *);
3565	prop = va_arg (args, int);
3566
3567	switch (prop)
3568	{
3569	case CFAPI_ARCH_PROP_NAME:
3570	*type = CFAPI_STRING;
3571	rv = (void *) &arch->name;
3572	break;
3573
3574	case CFAPI_ARCH_PROP_NEXT:
3575	*type = CFAPI_PARCH;
3576	rv = arch->next;
3577	break;
3578
3579	case CFAPI_ARCH_PROP_HEAD:
3580	*type = CFAPI_PARCH;
3581	rv = arch->head;
3582	break;
3583
3584	case CFAPI_ARCH_PROP_MORE:
3585	*type = CFAPI_PARCH;
3586	rv = arch->more;
3587	break;
3588
3589	case CFAPI_ARCH_PROP_CLONE:
3590	*type = CFAPI_POBJECT;
3591	rv = &arch->clone;
3592	break;
3593
3594	default:
3595	*type = CFAPI_NONE;
3596	rv = NULL;
3597	break;
3598	}
3599	va_end (args);
3600	return rv;
3601	}	1804	}
3602		1805
3603	/* Party-related functions */	1806	/* Party-related functions */
3604	void *	1807	void *
3605	cfapi_party_get_property (int *type, ...)	1808	cfapi_party_get_property (int *type, ...)
3606	{	1809	{
3607	partylist *party;	1810	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	}	1811	}
3657		1812
3658	/* Regions-related functions */	1813	/* Regions-related functions */
3659	void *	1814	void *
3660	cfapi_region_get_property (int *type, ...)	1815	cfapi_region_get_property (int *type, ...)
3661	{	1816	{
3662	region *reg;	1817	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	}	1818	}
3706		1819
3707	/*****************************************************************************/	1820	/*****************************************************************************/
3708		1821
3709	/* NEW PLUGIN STUFF ENDS HERE */	1822	/* NEW PLUGIN STUFF ENDS HERE */
…		…
3739	return NULL;	1852	return NULL;
3740	}	1853	}
3741		1854
3742	/*****************************************************************************/	1855	/*****************************************************************************/
3743		1856
3744	/* Plugins initialization. Browses the plugins directory and call */	1857	/* Plugins initialisation. Browses the plugins directory and call */
3745		1858
3746	/* initOnePlugin for each file found. */	1859	/* initOnePlugin for each file found. */
3747		1860
3748	/* Returns 0 if at least one plugin was successfully loaded, -1 if not */	1861	/* Returns 0 if at least one plugin was successfully loaded, -1 if not */
3749		1862
…		…
3756	size_t l;	1869	size_t l;
3757	char buf[MAX_BUF];	1870	char buf[MAX_BUF];
3758	char buf2[MAX_BUF];	1871	char buf2[MAX_BUF];
3759	int result;	1872	int result;
3760		1873
3761	LOG (llevInfo, "Initializing plugins\n");	1874	LOG (llevInfo, "Initialising plugins\n");
3762	strcpy (buf, LIBDIR);	1875	strcpy (buf, LIBDIR);
3763	strcat (buf, "/plugins/");	1876	strcat (buf, "/plugins/");
3764	LOG (llevInfo, "Plugins directory is %s\n", buf);	1877	LOG (llevInfo, "Plugins directory is %s\n", buf);
3765		1878
3766	plugins_init_perl ();	1879	plugins_init_perl ();

Diff Legend

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