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.3 by root, Fri Aug 25 13:24:50 2006 UTC vs.
Revision 1.14 by root, Thu Sep 14 21:16:12 2006 UTC

		1
1	/*	2	/*
2	* static char *rcsid_plugins_c =	3	* static char *rcsid_plugins_c =
3	* "$Id: plugins.C,v 1.3 2006/08/25 13:24:50 root Exp $";	4	* "$Id: plugins.C,v 1.14 2006/09/14 21:16:12 root Exp $";
4	*/	5	*/
5		6
6	/*****************************************************************************/	7	/*****************************************************************************/
		8
7	/* CrossFire, A Multiplayer game for X-windows */	9	/* CrossFire, A Multiplayer game for X-windows */
		10
8	/* */	11	/* */
		12
9	/* Copyright (C) 2000 Mark Wedel */	13	/* Copyright (C) 2000 Mark Wedel */
		14
10	/* Copyright (C) 1992 Frank Tore Johansen */	15	/* Copyright (C) 1992 Frank Tore Johansen */
		16
11	/* */	17	/* */
		18
12	/* This program is free software; you can redistribute it and/or modify */	19	/* This program is free software; you can redistribute it and/or modify */
		20
13	/* it under the terms of the GNU General Public License as published by */	21	/* it under the terms of the GNU General Public License as published by */
		22
14	/* the Free Software Foundation; either version 2 of the License, or */	23	/* the Free Software Foundation; either version 2 of the License, or */
		24
15	/* (at your option) any later version. */	25	/* (at your option) any later version. */
		26
16	/* */	27	/* */
		28
17	/* This program is distributed in the hope that it will be useful, */	29	/* This program is distributed in the hope that it will be useful, */
		30
18	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */	31	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
		32
19	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */	33	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
		34
20	/* GNU General Public License for more details. */	35	/* GNU General Public License for more details. */
		36
21	/* */	37	/* */
		38
22	/* You should have received a copy of the GNU General Public License */	39	/* You should have received a copy of the GNU General Public License */
		40
23	/* along with this program; if not, write to the Free Software */	41	/* along with this program; if not, write to the Free Software */
		42
24	/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */	43	/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
		44
25	/* */	45	/* */
		46
26	/*****************************************************************************/	47	/*****************************************************************************/
		48
27	/* This is the server-side plugin management part. */	49	/* This is the server-side plugin management part. */
		50
28	/*****************************************************************************/	51	/*****************************************************************************/
		52
29	/* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */	53	/* Original code by Yann Chachkoff (yann.chachkoff@mailandnews.com). */
		54
30	/* Special thanks to: */	55	/* Special thanks to: */
		56
31	/* David Delbecq (david.delbecq@mailandnews.com); */	57	/* David Delbecq (david.delbecq@mailandnews.com); */
		58
32	/* Joris Bontje (jbontje@suespammers.org); */	59	/* Joris Bontje (jbontje@suespammers.org); */
		60
33	/* Philip Currlin (?); */	61	/* Philip Currlin (?); */
		62
34	/*****************************************************************************/	63	/*****************************************************************************/
35		64
36	/*****************************************************************************/	65	/*****************************************************************************/
		66
37	/* First, the headers. We only include plugin.h, because all other includes */	67	/* First, the headers. We only include plugin.h, because all other includes */
		68
38	/* are done into it, and plugproto.h (which is used only by this file). */	69	/* are done into it, and plugproto.h (which is used only by this file). */
		70
39	/*****************************************************************************/	71	/*****************************************************************************/
40	#include <plugin.h>	72	#include <plugin.h>
41		73
42	#ifndef __CEXTRACT__	74	#ifndef __CEXTRACT__
43	#include <sproto.h>	75	# include <sproto.h>
44	#endif	76	#endif
45		77
46	#define NR_OF_HOOKS 74	78	#define NR_OF_HOOKS 74
47		79
48	static const hook_entry plug_hooks[NR_OF_HOOKS] =	80	static const hook_entry plug_hooks[NR_OF_HOOKS] = {
49	{
50	{cfapi_system_add_string, 0, "cfapi_system_add_string"},
51	{cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"},	81	{cfapi_system_register_global_event, 1, "cfapi_system_register_global_event"},
52	{cfapi_system_remove_string, 2, "cfapi_system_remove_string"},
53	{cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"},	82	{cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event"},
54	{cfapi_system_check_path, 4, "cfapi_system_check_path"},	83	{cfapi_system_check_path, 4, "cfapi_system_check_path"},
55	{cfapi_system_re_cmp, 5, "cfapi_system_re_cmp"},	84	{cfapi_system_re_cmp, 5, "cfapi_system_re_cmp"},
56	{cfapi_system_strdup_local, 6, "cfapi_system_strdup_local"},	85	{cfapi_system_strdup_local, 6, "cfapi_system_strdup_local"},
57	{cfapi_system_directory, 7, "cfapi_system_directory"},	86	{cfapi_system_directory, 7, "cfapi_system_directory"},
58	{cfapi_system_find_animation, 8, "cfapi_system_find_animation"},	87	{cfapi_system_find_animation, 8, "cfapi_system_find_animation"},
59	{cfapi_object_clean_object, 9, "cfapi_object_clean_object"},	88	{cfapi_object_clean_object, 9, "cfapi_object_clean_object"},
60	{cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"},	89	{cfapi_object_on_same_map, 10, "cfapi_object_on_same_map"},
61	{cfapi_object_get_key, 11, "cfapi_object_get_key"},	90	{cfapi_object_get_key, 11, "cfapi_object_get_key"},
62	{cfapi_object_set_key, 12, "cfapi_object_set_key"},	91	{cfapi_object_set_key, 12, "cfapi_object_set_key"},
63	{cfapi_object_get_property, 13, "cfapi_object_get_property"},	92	{cfapi_object_get_property, 13, "cfapi_object_get_property"},
64	{cfapi_object_set_property, 14,"cfapi_object_set_property"},	93	{cfapi_object_set_property, 14, "cfapi_object_set_property"},
65	{cfapi_object_apply, 15, "cfapi_object_apply"},	94	{cfapi_object_apply, 15, "cfapi_object_apply"},
66	{cfapi_object_identify, 16, "cfapi_object_identify"},	95	{cfapi_object_identify, 16, "cfapi_object_identify"},
67	{cfapi_object_describe, 17, "cfapi_object_describe"},	96	{cfapi_object_describe, 17, "cfapi_object_describe"},
68	{cfapi_object_drain, 18, "cfapi_object_drain"},	97	{cfapi_object_drain, 18, "cfapi_object_drain"},
69	{cfapi_object_fix, 19, "cfapi_object_fix"},	98	{cfapi_object_fix, 19, "cfapi_object_fix"},
70	{cfapi_object_give_skill, 20, "cfapi_object_give_skill"},	99	{cfapi_object_give_skill, 20, "cfapi_object_give_skill"},
71	{cfapi_object_transmute, 21, "cfapi_object_transmute"},	100	{cfapi_object_transmute, 21, "cfapi_object_transmute"},
72	{cfapi_object_remove, 22, "cfapi_object_remove"},	101	{cfapi_object_remove, 22, "cfapi_object_remove"},
73	{cfapi_object_delete, 23, "cfapi_object_delete"},	102	{cfapi_object_delete, 23, "cfapi_object_delete"},
74	{cfapi_object_clone, 24, "cfapi_object_clone"},	103	{cfapi_object_clone, 24, "cfapi_object_clone"},
75	{cfapi_object_find, 25, "cfapi_object_find"},	104	{cfapi_object_find, 25, "cfapi_object_find"},
76	{cfapi_object_create, 26, "cfapi_object_create"},	105	{cfapi_object_create, 26, "cfapi_object_create"},
77	{cfapi_object_insert, 27, "cfapi_object_insert"},	106	{cfapi_object_insert, 27, "cfapi_object_insert"},
78	{cfapi_object_split, 28, "cfapi_object_split"},	107	{cfapi_object_split, 28, "cfapi_object_split"},
79	{cfapi_object_merge, 29, "cfapi_object_merge"},	108	{cfapi_object_merge, 29, "cfapi_object_merge"},
80	{cfapi_object_distance, 30, "cfapi_object_distance"},	109	{cfapi_object_distance, 30, "cfapi_object_distance"},
81	{cfapi_object_update, 31, "cfapi_object_update"},	110	{cfapi_object_update, 31, "cfapi_object_update"},
82	{cfapi_object_clear, 32, "cfapi_object_clear"},	111	{cfapi_object_clear, 32, "cfapi_object_clear"},
83	{cfapi_object_reset, 33, "cfapi_object_reset"},	112	{cfapi_object_reset, 33, "cfapi_object_reset"},
84	{cfapi_object_check_inventory, 34, "cfapi_object_check_inventory"},	113	{cfapi_object_check_inventory, 34, "cfapi_object_check_inventory"},
85	{cfapi_object_spring_trap, 35, "cfapi_object_spring_trap"},	114	{cfapi_object_spring_trap, 35, "cfapi_object_spring_trap"},
86	{cfapi_object_check_trigger, 36, "cfapi_object_check_trigger"},	115	{cfapi_object_check_trigger, 36, "cfapi_object_check_trigger"},
87	{cfapi_object_query_cost, 37, "cfapi_object_query_cost"},	116	{cfapi_object_query_cost, 37, "cfapi_object_query_cost"},
88	{cfapi_object_query_money, 38, "cfapi_object_query_money"},	117	{cfapi_object_query_money, 38, "cfapi_object_query_money"},
89	{cfapi_object_cast, 39, "cfapi_object_cast"},	118	{cfapi_object_cast, 39, "cfapi_object_cast"},
90	{cfapi_object_learn_spell, 40, "cfapi_object_learn_spell"},	119	{cfapi_object_learn_spell, 40, "cfapi_object_learn_spell"},
91	{cfapi_object_forget_spell, 41, "cfapi_object_forget_spell"},	120	{cfapi_object_forget_spell, 41, "cfapi_object_forget_spell"},
92	{cfapi_object_check_spell, 42, "cfapi_object_check_spell"},	121	{cfapi_object_check_spell, 42, "cfapi_object_check_spell"},
93	{cfapi_object_pay_amount, 43, "cfapi_object_pay_amount"},	122	{cfapi_object_pay_amount, 43, "cfapi_object_pay_amount"},
94	{cfapi_object_pay_item, 44, "cfapi_object_pay_item"},	123	{cfapi_object_pay_item, 44, "cfapi_object_pay_item"},
95	{cfapi_object_transfer, 45, "cfapi_object_transfer"},	124	{cfapi_object_transfer, 45, "cfapi_object_transfer"},
96	{cfapi_object_drop, 46, "cfapi_object_drop"},	125	{cfapi_object_drop, 46, "cfapi_object_drop"},
97	{cfapi_object_take, 47, "cfapi_object_take"},	126	{cfapi_object_take, 47, "cfapi_object_take"},
98	{cfapi_object_find_archetype_inside, 48, "cfapi_object_find_archetype_inside"},	127	{cfapi_object_find_archetype_inside, 48, "cfapi_object_find_archetype_inside"},
99	{cfapi_object_say, 49, "cfapi_object_say"},	128	{cfapi_object_say, 49, "cfapi_object_say"},
100	{cfapi_map_get_map, 50, "cfapi_map_get_map"},	129	{cfapi_map_get_map, 50, "cfapi_map_get_map"},
101	{cfapi_map_has_been_loaded, 51, "cfapi_map_has_been_loaded"},	130	{cfapi_map_has_been_loaded, 51, "cfapi_map_has_been_loaded"},
102	{cfapi_map_create_path, 52, "cfapi_map_create_path"},	131	{cfapi_map_create_path, 52, "cfapi_map_create_path"},
103	{cfapi_map_get_map_property, 53, "cfapi_map_get_property"},	132	{cfapi_map_get_map_property, 53, "cfapi_map_get_property"},
104	{cfapi_map_set_map_property, 54, "cfapi_map_set_property"},	133	{cfapi_map_set_map_property, 54, "cfapi_map_set_property"},
105	{cfapi_map_out_of_map, 55, "cfapi_map_out_of_map"},	134	{cfapi_map_out_of_map, 55, "cfapi_map_out_of_map"},
106	{cfapi_map_update_position, 56, "cfapi_map_update_position"},	135	{cfapi_map_update_position, 56, "cfapi_map_update_position"},
107	{cfapi_map_delete_map, 57, "cfapi_map_delete_map"},	136	{cfapi_map_delete_map, 57, "cfapi_map_delete_map"},
108	{cfapi_map_message, 58, "cfapi_map_message"},	137	{cfapi_map_message, 58, "cfapi_map_message"},
109	{cfapi_map_get_object_at, 59, "cfapi_map_get_object_at"},	138	{cfapi_map_get_object_at, 59, "cfapi_map_get_object_at"},
110	{cfapi_map_get_flags, 60, "cfapi_map_get_flags"},	139	{cfapi_map_get_flags, 60, "cfapi_map_get_flags"},
111	{cfapi_map_present_arch_by_name,61, "cfapi_map_present_arch_by_name"},	140	{cfapi_map_present_arch_by_name, 61, "cfapi_map_present_arch_by_name"},
112	{cfapi_player_find, 62, "cfapi_player_find"},	141	{cfapi_player_find, 62, "cfapi_player_find"},
113	{cfapi_player_message, 63, "cfapi_player_message"},	142	{cfapi_player_message, 63, "cfapi_player_message"},
114	{cfapi_player_send_inventory, 64, "cfapi_player_send_inventory"},	143	{cfapi_player_send_inventory, 64, "cfapi_player_send_inventory"},
115	{cfapi_object_teleport, 65, "cfapi_object_teleport"},	144	{cfapi_object_teleport, 65, "cfapi_object_teleport"},
116	{cfapi_object_speak, 66, "cfapi_object_speak"},	145	{cfapi_object_speak, 66, "cfapi_object_speak"},
117	{cfapi_object_pickup, 67, "cfapi_object_pickup"},	146	{cfapi_object_pickup, 67, "cfapi_object_pickup"},
118	{cfapi_object_move, 68, "cfapi_object_move"},	147	{cfapi_object_move, 68, "cfapi_object_move"},
119	{cfapi_object_apply_below, 69, "cfapi_object_apply_below"},	148	{cfapi_object_apply_below, 69, "cfapi_object_apply_below"},
120	{cfapi_archetype_get_first, 70, "cfapi_archetype_get_first"},	149	{cfapi_archetype_get_first, 70, "cfapi_archetype_get_first"},
121	{cfapi_archetype_get_property, 71, "cfapi_archetype_get_property"},	150	{cfapi_archetype_get_property, 71, "cfapi_archetype_get_property"},
122	{cfapi_party_get_property, 72, "cfapi_party_get_property"},	151	{cfapi_party_get_property, 72, "cfapi_party_get_property"},
123	{cfapi_region_get_property, 73, "cfapi_region_get_property"},	152	{cfapi_region_get_property, 73, "cfapi_region_get_property"},
124	};	153	};
125	int plugin_number = 0;	154	int plugin_number = 0;
126	crossfire_plugin* plugins_list = NULL;	155	crossfire_plugin *plugins_list = NULL;
127		156
128	/*****************************************************************************/	157	/*****************************************************************************/
		158
129	/* NEW PLUGIN STUFF STARTS HERE */	159	/* NEW PLUGIN STUFF STARTS HERE */
		160
130	/*****************************************************************************/	161	/*****************************************************************************/
131		162
132	#ifdef WIN32	163	#ifdef WIN32
133	static const char *plugins_dlerror(void)	164	static const char *
		165	plugins_dlerror (void)
134	{	166	{
135	static char buf[256];	167	static char buf[256];
136	DWORD err;	168	DWORD err;
137	char* p;	169	char *p;
		170
138	err = GetLastError();	171	err = GetLastError ();
139	if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, sizeof(buf), NULL) == 0)	172	if (FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, sizeof (buf), NULL) == 0)
140	snprintf(buf, sizeof(buf), "error %lu", err);	173	snprintf (buf, sizeof (buf), "error %lu", err);
141	p = strchr(buf, '\0');	174	p = strchr (buf, '\0');
142	while (p > buf && (p[-1] == '\r' || p[-1] == '\n'))	175	while (p > buf && (p[-1] == '\r' || p[-1] == '\n'))
143	p--;	176	p--;
144	*p = '\0';	177	*p = '\0';
145	return buf;	178	return buf;
146	}	179	}
147	#endif /* WIN32 */	180	#endif /* WIN32 */
148		181
149	/**	182	/**
150	* Notify clients about a changed object.	183	* Notify clients about a changed object.
151	*	184	*
152	* @param op the object that has changed	185	* @param op the object that has changed
153	*/	186	*/
		187	static void
154	static void send_changed_object(object *op)	188	send_changed_object (object *op)
155	{	189	{
156	object* tmp;	190	object *tmp;
157	player *pl;	191	player *pl;
158		192
159	if (op->env != NULL) {	193	if (op->env != NULL)
		194	{
160	tmp = is_player_inv(op->env);	195	tmp = is_player_inv (op->env);
161	if (!tmp) {	196	if (!tmp)
		197	{
162	for (pl = first_player; pl; pl = pl->next)	198	for (pl = first_player; pl; pl = pl->next)
163	if (pl->ob->container == op->env)	199	if (pl->ob->container == op->env)
164	break;	200	break;
165	if (pl)	201	if (pl)
166	tmp = pl->ob;	202	tmp = pl->ob;
167	else	203	else
168	tmp = NULL;	204	tmp = NULL;
169	}	205	}
170	if (tmp)	206	if (tmp)
171	esrv_send_item(tmp, op);	207	esrv_send_item (tmp, op);
172	} else {	208	}
		209	else
		210	{
173	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	211	for (tmp = op->above; tmp != NULL; tmp = tmp->above)
174	if (tmp->type == PLAYER)	212	if (tmp->type == PLAYER)
175	esrv_send_item(tmp, op);	213	esrv_send_item (tmp, op);
176	}	214	}
177	}	215	}
178		216
179	/**	217	/**
180	* Notify clients about a removed object.	218	* Notify clients about a removed object.
181	*	219	*
182	* @param op the object about to be removed from its environment; it must still	220	* @param op the object about to be removed from its environment; it must still
183	* be present in its environment	221	* be present in its environment
184	*/	222	*/
		223	static void
185	static void send_removed_object(object *op)	224	send_removed_object (object *op)
186	{	225	{
187	object* tmp;	226	object *tmp;
188	player *pl;	227	player *pl;
189		228
190	if (op->env == NULL) {	229	if (op->env == NULL)
		230	{
191	/* no action necessary: remove_ob() notifies the client */	231	/* no action necessary: remove_ob() notifies the client */
192	return;	232	return;
193	}	233	}
194		234
195	tmp = is_player_inv(op->env);	235	tmp = is_player_inv (op->env);
196	if (!tmp) {	236	if (!tmp)
		237	{
197	for (pl = first_player; pl; pl = pl->next)	238	for (pl = first_player; pl; pl = pl->next)
198	if (pl->ob->container == op->env)	239	if (pl->ob->container == op->env)
199	break;	240	break;
200	if (pl)	241	if (pl)
201	tmp = pl->ob;	242	tmp = pl->ob;
202	else	243	else
203	tmp = NULL;	244	tmp = NULL;
204	}	245	}
205	if (tmp)	246	if (tmp)
206	esrv_del_item(tmp->contr, op->count);	247	esrv_del_item (tmp->contr, op->count);
207	}
208
209	int execute_event(object* op, int eventcode, object* activator, object* third, const char* message, int fix)
210	{
211	object *tmp, *next;
212	crossfire_plugin* plugin;
213	int rv = 0;
214	for (tmp = op->inv; tmp != NULL; tmp = next) {
215	next = tmp->below;
216	if (tmp->type == EVENT_CONNECTOR && tmp->subtype == eventcode) {
217	#if 0
218	LOG(llevDebug, "********** EVENT HANDLER **********\n");
219	LOG(llevDebug, " - Who am I :%s\n", op->name);
220	if (activator != NULL)
221	LOG(llevDebug, " - Activator :%s\n", activator->name);
222	if (third != NULL)
223	LOG(llevDebug, " - Other object :%s\n", third->name);
224	LOG(llevDebug, " - Event code :%d\n", tmp->subtype);
225	if (tmp->title != NULL)
226	LOG(llevDebug, " - Event plugin :%s\n", tmp->title);
227	if (tmp->slaying != NULL)
228	LOG(llevDebug, " - Event hook :%s\n", tmp->slaying);
229	if (tmp->name != NULL)
230	LOG(llevDebug, " - Event options :%s\n", tmp->name);
231	#endif
232
233	if (tmp->title == NULL) {
234	object *env = object_get_env_recursive(tmp);
235	LOG(llevError, "Event object without title at %d/%d in map %s\n", env->x, env->y, env->map->name);
236	send_removed_object(tmp);
237	remove_ob(tmp);
238	free_object(tmp);
239	} else if (tmp->slaying == NULL) {
240	object *env = object_get_env_recursive(tmp);
241	LOG(llevError, "Event object without slaying at %d/%d in map %s\n", env->x, env->y, env->map->name);
242	send_removed_object(tmp);
243	remove_ob(tmp);
244	free_object(tmp);
245	} else {
246	plugin = plugins_find_plugin(tmp->title);
247	if (plugin == NULL) {
248	object *env = object_get_env_recursive(tmp);
249	LOG(llevError, "The requested plugin doesn't exist: %s at %d/%d in map %s\n", tmp->title, env->x, env->y, env->map->name);
250	send_removed_object(tmp);
251	remove_ob(tmp);
252	free_object(tmp);
253	} else {
254	int rvt = 0;
255	int *rv;
256
257	rv = (int*) plugin->eventfunc(&rvt, op, eventcode, activator, third, message, fix, tmp->slaying, tmp->name, tmp);
258	return *rv;
259	}
260	}
261	}
262	}
263	return rv;
264	}
265
266	int execute_global_event(int eventcode, ...)
267	{
268	va_list args;
269	object* op;
270	object* op2;
271	object* op3;
272	mapstruct *map;
273	player* pl;
274	char* buf;
275	int i, rt, retval = 0, *tmpretval = NULL, fix;
276	crossfire_plugin* cp;
277	if (plugins_list == NULL)
278	return -1;
279
280	va_start(args, eventcode);
281
282	switch (eventcode) {
283
284	case EVENT_CLOCK:
285	case EVENT_CRASH:
286	case EVENT_TELL:
287	/* no additional arguments */
288	for (cp = plugins_list; cp != NULL; cp = cp->next) {
289	if (cp->gevent[eventcode] != NULL)
290	cp->gevent[eventcode](&rt, eventcode);
291	}
292	break;
293
294	case EVENT_GKILL:
295	/*GKILL: op, hitter*/
296	op = va_arg(args, object*);
297	op2 = va_arg(args, object*);
298	for (cp = plugins_list; cp != NULL; cp = cp->next) {
299	if (cp->gevent[eventcode] != NULL)
300	cp->gevent[eventcode](&rt, eventcode, op, op2);
301	}
302	break;
303
304	case EVENT_SHOUT:
305	/*SHOUT: op, parms, priority*/
306	op = va_arg(args, object*);
307	buf = va_arg(args, char*);
308	i = va_arg(args, int);
309	for (cp = plugins_list; cp != NULL; cp = cp->next) {
310	if (cp->gevent[eventcode] != NULL)
311	cp->gevent[eventcode](&rt, eventcode, op, buf, i);
312	}
313	break;
314
315	case EVENT_MUZZLE:
316	/*MUZZLE: op, parms*/
317	op = va_arg(args, object*);
318	buf = va_arg(args, char*);
319	for (cp = plugins_list; cp != NULL; cp = cp->next) {
320	if (cp->gevent[eventcode] != NULL)
321	cp->gevent[eventcode](&rt, eventcode, op, buf);
322	}
323	break;
324
325	case EVENT_KICK:
326	/*KICK: op, parms*/
327	op = va_arg(args, object*);
328	buf = va_arg(args, char*);
329	for (cp = plugins_list; cp != NULL; cp = cp->next) {
330	if (cp->gevent[eventcode] != NULL)
331	cp->gevent[eventcode](&rt, eventcode, op, buf);
332	}
333	break;
334
335	case EVENT_FIND_UNARMED_SKILL:
336	op = va_arg(args, object*);
337	for (cp = plugins_list; cp != NULL; cp = cp->next) {
338	if (cp->gevent[eventcode] != NULL)
339	if ((tmpretval = (int*) cp->gevent[eventcode](&rt, eventcode, op)) && *tmpretval > 0) {
340	retval = *tmpretval;
341	}
342	}
343	break;
344
345	case EVENT_PLAYER_USE_SKILL:
346	case EVENT_MONSTER_USE_SKILL:
347	op = va_arg(args, object*);
348	op2 = va_arg(args, object*);
349	op3 = va_arg(args, object*);
350	fix = va_arg(args, int);
351	buf = va_arg(args, char*);
352	for (cp = plugins_list; cp != NULL; cp = cp->next) {
353	if (cp->gevent[eventcode] != NULL)
354	if ((tmpretval = (int*) cp->gevent[eventcode](&rt, eventcode, op, op2, op3, fix, buf)) && *tmpretval != 0) {
355	retval = *tmpretval;
356	}
357	}
358	break;
359
360	case EVENT_CAST_SPELL:
361	op = va_arg(args, object*);
362	op2 = va_arg(args, object*);
363	op3 = va_arg(args, object*);
364	fix = va_arg(args, int);
365	buf = va_arg(args, char*);
366	for (cp = plugins_list; cp != NULL; cp = cp->next) {
367	if (cp->gevent[eventcode] != NULL)
368	if ((tmpretval = (int*) cp->gevent[eventcode](&rt, eventcode, op, op2, op3, fix, buf)) && *tmpretval != 0) {
369	retval = *tmpretval;
370	break; /* The first who did something wins! */
371	}
372	}
373	break;
374
375	case EVENT_EXTCMD:
376	/*KICK: op, parms*/
377	pl = va_arg (args, player *);
378	buf = va_arg (args, char *);
379	i = va_arg (args, int);
380	for (cp = plugins_list; cp != NULL; cp = cp->next) {
381	if (cp->gevent[eventcode] != NULL)
382	cp->gevent[eventcode](&rt, eventcode, pl, buf, i, buf);
383	}
384	break;
385	}
386	va_end(args);
387
388	return retval;
389	}	248	}
390		249
391	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr);	250	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr);
392	extern "C" void *cfperl_getPluginProperty (int *type, ...);	251	extern "C" void *cfperl_getPluginProperty (int *type, ...);
393	extern "C" int cfperl_postInitPlugin ();	252	extern "C" int cfperl_postInitPlugin ();
394	extern "C" void *cfperl_eventListener (int *type, ...);
395	extern "C" int cfperl_closePlugin ();	253	extern "C" int cfperl_closePlugin ();
396		254
397	// this is a temporary hack till the old plugin stuff is removed	255	// this is a temporary hack till the old plugin stuff is removed
		256	int
398	int plugins_init_perl()	257	plugins_init_perl ()
399	{	258	{
400	f_plug_init initfunc;	259	f_plug_init initfunc;
401	f_plug_api propfunc;	260	f_plug_api propfunc;
402	f_plug_api eventfunc;
403	f_plug_postinit postfunc;	261	f_plug_postinit postfunc;
404	f_plug_postinit closefunc;	262	f_plug_postinit closefunc;
405	int i;	263	int i;
406	crossfire_plugin* cp;	264	crossfire_plugin *cp;
407	crossfire_plugin* ccp;	265	crossfire_plugin *ccp;
408		266
409	initfunc = (f_plug_init)cfperl_initPlugin;	267	initfunc = (f_plug_init) cfperl_initPlugin;
410	propfunc = (f_plug_api)cfperl_getPluginProperty;	268	propfunc = (f_plug_api) cfperl_getPluginProperty;
411	eventfunc = (f_plug_api)cfperl_eventListener;
412	postfunc = (f_plug_postinit)cfperl_postInitPlugin;	269	postfunc = (f_plug_postinit) cfperl_postInitPlugin;
413	closefunc = (f_plug_postinit)cfperl_closePlugin;	270	closefunc = (f_plug_postinit) cfperl_closePlugin;
414	i = initfunc("2.0", cfapi_get_hooks);	271	i = initfunc ("2.0", cfapi_get_hooks);
415	cp = (crossfire_plugin*) malloc(sizeof(crossfire_plugin));	272	cp = (crossfire_plugin *) malloc (sizeof (crossfire_plugin));
416	for (i = 0; i < NR_EVENTS; i++)	273	for (i = 0; i < NR_EVENTS; i++)
417	cp->gevent[i] = NULL;	274	cp->gevent[i] = NULL;
418	cp->eventfunc = eventfunc;	275	cp->eventfunc = 0;
419	cp->propfunc = propfunc;	276	cp->propfunc = propfunc;
420	cp->closefunc = closefunc;	277	cp->closefunc = closefunc;
421	cp->libptr = 0;	278	cp->libptr = 0;
422	strcpy(cp->id, (const char*) propfunc(&i, "Identification"));	279	strcpy (cp->id, (const char *) propfunc (&i, "Identification"));
423	strcpy(cp->fullname, (const char*) propfunc(&i, "FullName"));	280	strcpy (cp->fullname, (const char *) propfunc (&i, "FullName"));
424	cp->next = NULL;	281	cp->next = NULL;
425	cp->prev = NULL;	282	cp->prev = NULL;
426	if (plugins_list == NULL) {	283	if (plugins_list == NULL)
		284	{
427	plugins_list = cp;	285	plugins_list = cp;
428	} else {	286	}
		287	else
		288	{
429	for (ccp = plugins_list; ccp->next != NULL; ccp = ccp->next)	289	for (ccp = plugins_list; ccp->next != NULL; ccp = ccp->next)
430	;	290	;
431	ccp->next = cp;	291	ccp->next = cp;
432	cp->prev = ccp;	292	cp->prev = ccp;
433	}	293	}
434	postfunc();	294	postfunc ();
435	plugin_number++;	295	plugin_number++;
436	return 0;	296	return 0;
437	}	297	}
438		298
		299	int
439	int plugins_init_plugin(const char* libfile)	300	plugins_init_plugin (const char *libfile)
440	{	301	{
		302	return 0;
		303
441	LIBPTRTYPE ptr;	304	LIBPTRTYPE ptr;
442	f_plug_init initfunc;	305	f_plug_init initfunc;
443	f_plug_api propfunc;	306	f_plug_api propfunc;
444	f_plug_api eventfunc;	307	f_plug_api eventfunc;
445	f_plug_postinit postfunc;	308	f_plug_postinit postfunc;
446	f_plug_postinit closefunc;	309	f_plug_postinit closefunc;
447	int i;	310	int i;
448	crossfire_plugin* cp;	311	crossfire_plugin *cp;
449	crossfire_plugin* ccp;	312	crossfire_plugin *ccp;
450		313
451	/* Open the plugin lib and load the required functions */	314	/* Open the plugin lib and load the required functions */
452	ptr = plugins_dlopen(libfile);	315	ptr = plugins_dlopen (libfile);
453	if (ptr == NULL) {	316	if (ptr == NULL)
		317	{
454	LOG(llevError, "Error trying to load %s: %s\n", libfile, plugins_dlerror());	318	LOG (llevError, "Error trying to load %s: %s\n", libfile, plugins_dlerror ());
455	return -1;	319	return -1;
456	}	320	}
457	initfunc = (f_plug_init)plugins_dlsym(ptr, "initPlugin");	321	initfunc = (f_plug_init) plugins_dlsym (ptr, "initPlugin");
458	if (initfunc == NULL) {	322	if (initfunc == NULL)
		323	{
459	LOG(llevError, "Plugin error while requesting %s.initPlugin: %s\n",	324	LOG (llevError, "Plugin error while requesting %s.initPlugin: %s\n", libfile, plugins_dlerror ());
460	libfile, plugins_dlerror());
461	plugins_dlclose(ptr);	325	plugins_dlclose (ptr);
462	return -1;	326	return -1;
463	}	327	}
464	propfunc = (f_plug_api)plugins_dlsym(ptr, "getPluginProperty");	328	propfunc = (f_plug_api) plugins_dlsym (ptr, "getPluginProperty");
465	if (propfunc == NULL) {	329	if (propfunc == NULL)
		330	{
466	LOG(llevError, "Plugin error while requesting %s.getPluginProperty: %s\n",	331	LOG (llevError, "Plugin error while requesting %s.getPluginProperty: %s\n", libfile, plugins_dlerror ());
467	libfile, plugins_dlerror());
468	plugins_dlclose(ptr);	332	plugins_dlclose (ptr);
469	return -1;	333	return -1;
470	}	334	}
471	eventfunc = (f_plug_api)plugins_dlsym(ptr, "eventListener");	335	eventfunc = (f_plug_api) plugins_dlsym (ptr, "eventListener");
472	if (eventfunc == NULL) {	336	if (eventfunc == NULL)
		337	{
473	LOG(llevError, "Plugin error while requesting %s.eventListener: %s\n",	338	LOG (llevError, "Plugin error while requesting %s.eventListener: %s\n", libfile, plugins_dlerror ());
474	libfile, plugins_dlerror());
475	plugins_dlclose(ptr);	339	plugins_dlclose (ptr);
476	return -1;	340	return -1;
477	}	341	}
478	postfunc = (f_plug_postinit)plugins_dlsym(ptr, "postInitPlugin");	342	postfunc = (f_plug_postinit) plugins_dlsym (ptr, "postInitPlugin");
479	if (postfunc == NULL) {	343	if (postfunc == NULL)
		344	{
480	LOG(llevError, "Plugin error while requesting %s.postInitPlugin: %s\n",	345	LOG (llevError, "Plugin error while requesting %s.postInitPlugin: %s\n", libfile, plugins_dlerror ());
481	libfile, plugins_dlerror());
482	plugins_dlclose(ptr);	346	plugins_dlclose (ptr);
483	return -1;	347	return -1;
484	}	348	}
485	closefunc = (f_plug_postinit)plugins_dlsym(ptr, "closePlugin");	349	closefunc = (f_plug_postinit) plugins_dlsym (ptr, "closePlugin");
486	if (postfunc == NULL) {	350	if (postfunc == NULL)
		351	{
487	LOG(llevError, "Plugin error while requesting %s.closePlugin: %s\n",	352	LOG (llevError, "Plugin error while requesting %s.closePlugin: %s\n", libfile, plugins_dlerror ());
488	libfile, plugins_dlerror());
489	plugins_dlclose(ptr);	353	plugins_dlclose (ptr);
490	return -1;	354	return -1;
491	}	355	}
492	i = initfunc("2.0", cfapi_get_hooks);	356	i = initfunc ("2.0", cfapi_get_hooks);
493	cp = (crossfire_plugin*) malloc(sizeof(crossfire_plugin));	357	cp = (crossfire_plugin *) malloc (sizeof (crossfire_plugin));
494	for (i = 0; i < NR_EVENTS; i++)	358	for (i = 0; i < NR_EVENTS; i++)
495	cp->gevent[i] = NULL;	359	cp->gevent[i] = NULL;
496	cp->eventfunc = eventfunc;	360	cp->eventfunc = eventfunc;
497	cp->propfunc = propfunc;	361	cp->propfunc = propfunc;
498	cp->closefunc = closefunc;	362	cp->closefunc = closefunc;
499	cp->libptr = ptr;	363	cp->libptr = ptr;
500	strcpy(cp->id, (const char*) propfunc(&i, "Identification"));	364	strcpy (cp->id, (const char *) propfunc (&i, "Identification"));
501	strcpy(cp->fullname, (const char*) propfunc(&i, "FullName"));	365	strcpy (cp->fullname, (const char *) propfunc (&i, "FullName"));
502	cp->next = NULL;	366	cp->next = NULL;
503	cp->prev = NULL;	367	cp->prev = NULL;
504	if (plugins_list == NULL) {	368	if (plugins_list == NULL)
		369	{
505	plugins_list = cp;	370	plugins_list = cp;
506	} else {	371	}
		372	else
		373	{
507	for (ccp = plugins_list; ccp->next != NULL; ccp = ccp->next)	374	for (ccp = plugins_list; ccp->next != NULL; ccp = ccp->next)
508	;	375	;
509	ccp->next = cp;	376	ccp->next = cp;
510	cp->prev = ccp;	377	cp->prev = ccp;
511	}	378	}
512	postfunc();	379	postfunc ();
513	plugin_number++;	380	plugin_number++;
514	return 0;	381	return 0;
515	}	382	}
516		383
		384	void *
517	void* cfapi_get_hooks(int* type, ...)	385	cfapi_get_hooks (int *type, ...)
518	{	386	{
519	va_list args;	387	va_list args;
520	int request_type;	388	int request_type;
521	char* buf;	389	char *buf;
522	int fid;	390	int fid;
523	f_plug_api rv;	391	f_plug_api rv;
524	int i;	392	int i;
525		393
526	va_start(args, type);	394	va_start (args, type);
527	request_type = va_arg(args, int);	395	request_type = va_arg (args, int);
		396
528	if (request_type == 0) { /* By nr */	397	if (request_type == 0)
		398	{ /* By nr */
529	fid = va_arg(args, int);	399	fid = va_arg (args, int);
		400
530	if (fid < 0 || fid >= NR_OF_HOOKS) {	401	if (fid < 0 || fid >= NR_OF_HOOKS)
		402	{
531	rv = NULL;	403	rv = NULL;
532	*type = CFAPI_NONE;	404	*type = CFAPI_NONE;
533	} else {
534	rv = plug_hooks[fid].func;
535	*type = CFAPI_FUNC;
536	}	405	}
537	} else { /* by name */	406	else
		407	{
		408	rv = plug_hooks[fid].func;
		409	*type = CFAPI_FUNC;
		410	}
		411	}
		412	else
		413	{ /* by name */
538	buf = va_arg(args, char*);	414	buf = va_arg (args, char *);
		415
539	rv = NULL;	416	rv = NULL;
540	for (i = 0; i < NR_OF_HOOKS; i++) {	417	for (i = 0; i < NR_OF_HOOKS; i++)
		418	{
541	if (!strcmp(buf, plug_hooks[i].fname)) {	419	if (!strcmp (buf, plug_hooks[i].fname))
		420	{
542	rv = plug_hooks[i].func;	421	rv = plug_hooks[i].func;
543	*type = CFAPI_FUNC;	422	*type = CFAPI_FUNC;
544	break;	423	break;
545	}	424	}
546	}	425	}
547	if (rv == NULL) {	426	if (rv == NULL)
		427	{
548	*type = CFAPI_NONE;	428	*type = CFAPI_NONE;
549	}	429	}
550	}	430	}
551	va_end(args);	431	va_end (args);
552	return (void*)rv;	432	return (void *) rv;
553	}	433	}
554		434
		435	int
555	int plugins_remove_plugin(const char* id)	436	plugins_remove_plugin (const char *id)
556	{	437	{
557	crossfire_plugin* cp;	438	crossfire_plugin *cp;
558		439
559	if (plugins_list == NULL)	440	if (plugins_list == NULL)
560	return -1;	441	return -1;
561		442
562	for (cp = plugins_list; cp != NULL; cp = cp->next) {	443	for (cp = plugins_list; cp != NULL; cp = cp->next)
		444	{
563	if (!strcmp(id, cp->id) && cp->libptr) {	445	if (!strcmp (id, cp->id) && cp->libptr)
		446	{
564	crossfire_plugin* n;	447	crossfire_plugin *n;
565	crossfire_plugin* p;	448	crossfire_plugin *p;
		449
566	n = cp->next;	450	n = cp->next;
567	p = cp->prev;	451	p = cp->prev;
568	plugins_dlclose(cp->libptr);	452	plugins_dlclose (cp->libptr);
569	if (n != NULL) {	453	if (n != NULL)
		454	{
570	if (p != NULL) {	455	if (p != NULL)
		456	{
571	n->prev = p;	457	n->prev = p;
572	p->next = n;	458	p->next = n;
573	} else {
574	n->prev = NULL;
575	plugins_list = n;
576	}	459	}
577	} else {
578	if (p != NULL)
579	p->next = NULL;
580	else	460	else
		461	{
		462	n->prev = NULL;
581	plugins_list = NULL;	463	plugins_list = n;
582	}
583	free(cp);
584	plugin_number --;
585	return 0;
586	}
587	}
588	return -1;
589	}
590
591	crossfire_plugin* plugins_find_plugin(const char* id)
592	{
593	crossfire_plugin* cp;
594
595	if (plugins_list == NULL)
596	return NULL;
597
598	for (cp = plugins_list; cp != NULL; cp = cp->next) {
599	if (!strcmp(id, cp->id)) {
600	return cp;
601	}
602	}
603	return NULL;
604	}
605
606	/*****************************************************************************/
607	/* Displays a list of loaded plugins (keystrings and description) in the */
608	/* game log window. */
609	/*****************************************************************************/
610	void plugins_display_list(object *op)
611	{
612	crossfire_plugin* cp;
613
614	new_draw_info(NDI_UNIQUE, 0, op, "List of loaded plugins:");
615	new_draw_info(NDI_UNIQUE, 0, op, "-----------------------");
616
617	if (plugins_list == NULL)
618	return;
619
620	for (cp = plugins_list; cp != NULL; cp = cp->next) {
621	new_draw_info_format(NDI_UNIQUE, 0, op, "%s, %s", cp->id, cp->fullname);
622	}
623	}
624
625	/* SYSTEM-RELATED HOOKS */
626
627	void* cfapi_system_find_animation(int *type, ...)
628	{
629	va_list args;
630	static int rv;
631	char* anim;
632	va_start(args, type);
633	anim = va_arg(args, char*);
634	va_end(args);
635
636	rv = find_animation(anim);
637	*type = CFAPI_INT;
638	return &rv;
639	}
640
641	void* cfapi_system_strdup_local(int *type, ...)
642	{
643	va_list args;
644	char* txt;
645	va_start(args, type);
646	txt = va_arg(args, char*);
647	va_end(args);
648	*type = CFAPI_STRING;
649	return strdup_local(txt);
650	}
651
652	void* cfapi_system_register_global_event(int *type, ...)
653	{
654	va_list args;
655	int eventcode;
656	char* pname;
657	f_plug_api hook;
658	crossfire_plugin* cp;
659
660	va_start(args, type);
661	eventcode = va_arg(args, int);
662	pname = va_arg(args, char*);
663	hook = va_arg(args, f_plug_api);
664
665	va_end(args);
666	cp = plugins_find_plugin(pname);
667	cp->gevent[eventcode] = hook;
668	return NULL;
669	}
670
671	void* cfapi_system_unregister_global_event(int *type, ...)
672	{
673	va_list args;
674	int eventcode;
675	char* pname;
676	crossfire_plugin* cp;
677
678	va_start(args, type);
679	eventcode = va_arg(args, int);
680	pname = va_arg(args, char*);
681
682	cp = plugins_find_plugin(pname);
683	cp->gevent[eventcode] = NULL;
684
685	va_end(args);
686	return NULL;
687	}
688
689	void* cfapi_system_add_string(int *type, ...)
690	{
691	va_list args;
692	const char* str;
693	char* rv;
694
695	va_start(args, type);
696	str = va_arg(args, char*);
697	va_end(args);
698
699	rv = (char*)add_string(str);
700	*type = CFAPI_STRING;
701	return rv;
702	}
703
704	void* cfapi_system_remove_string(int *type, ...)
705	{
706	va_list args;
707	char* str;
708
709	va_start(args, type);
710	str = va_arg(args, char*);
711	va_end(args);
712
713	free_string(str);
714	*type = CFAPI_NONE;
715	return NULL;
716	}
717	void* cfapi_system_check_path(int* type, ...)
718	{
719	va_list args;
720	static int rv;
721	char* name;
722	int prepend_dir;
723
724	va_start(args, type);
725
726	name = va_arg(args, char*);
727	prepend_dir = va_arg(args, int);
728
729	rv = check_path(name, prepend_dir);
730
731	va_end(args);
732	*type = CFAPI_INT;
733	return &rv;
734	}
735
736	void* cfapi_system_re_cmp(int* type, ...)
737	{
738	va_list args;
739	char* rv;
740	const char* str;
741	const char* regexp;
742
743	va_start(args, type);
744
745	str = va_arg(args, char*);
746	regexp = va_arg(args, char*);
747
748	rv = (char*)re_cmp(str, regexp);
749
750	va_end(args);
751	*type = CFAPI_STRING;
752	return rv;
753	}
754
755	void* cfapi_system_directory(int* type, ...)
756	{
757	va_list args;
758	int dirtype;
759
760	va_start(args, type);
761
762	dirtype = va_arg(args, int);
763	va_end(args);
764
765	*type = CFAPI_STRING;
766
767	switch (dirtype)
768	{
769	case 0:
770	return settings.mapdir;
771	break;
772
773	case 1:
774	return settings.uniquedir;
775	break;
776
777	case 2:
778	return settings.tmpdir;
779	break;
780
781	case 3:
782	return settings.confdir;
783	break;
784
785	case 4:
786	return settings.localdir;
787	break;
788
789	case 5:
790	return settings.playerdir;
791	break;
792
793	case 6:
794	return settings.datadir;
795	break;
796	}
797
798	*type = CFAPI_NONE;
799	return NULL;
800	}
801
802
803	/* MAP RELATED HOOKS */
804
805	void* cfapi_map_get_map(int* type, ...)
806	{
807	va_list args;
808	mapstruct* rv;
809	int ctype;
810	int x, y;
811	sint16 nx, ny;
812	char* name;
813	mapstruct* m;
814
815	va_start(args, type);
816
817	ctype = va_arg(args, int);
818
819	switch (ctype)
820	{
821	case 0:
822	x = va_arg(args, int);
823	y = va_arg(args, int);
824	rv = get_empty_map(x, y);
825	break;
826
827	case 1:
828	name = va_arg(args, char*);
829	x = va_arg(args, int);
830	rv = ready_map_name(name, x);
831	break;
832
833	case 2:
834	m = va_arg(args, mapstruct*);
835	nx = va_arg(args, int);
836	ny = va_arg(args, int);
837	rv = get_map_from_coord(m, &nx, &ny);
838	break;
839
840	case 3:
841	rv = first_map;
842	break;
843
844	default:
845	*type = CFAPI_NONE;
846	va_end(args);
847	return NULL;
848	break;
849	}
850	va_end(args);
851	*type = CFAPI_PMAP;
852	return rv;
853	}
854	void* cfapi_map_has_been_loaded(int* type, ...)
855	{
856	va_list args;
857	mapstruct* map;
858	char* string;
859
860	va_start(args, type);
861	string = va_arg(args, char*);
862	map = has_been_loaded(string);
863	va_end(args);
864	*type = CFAPI_PMAP;
865	return map;
866	}
867	void* cfapi_map_create_path(int* type, ...)
868	{
869	va_list args;
870	int ctype;
871	const char* str;
872	char* rv;
873	va_start(args, type);
874
875	ctype = va_arg(args, int);
876	str = va_arg(args, char*);
877	*type = CFAPI_STRING;
878
879	switch (ctype)
880	{
881	case 0:
882	rv = (char*)create_pathname(str);
883	break;
884
885	case 1:
886	rv = (char*)create_overlay_pathname(str);
887	break;
888
889	/*case 2:
890	rv = create_items_path(str);
891	break;*/
892
893	default:
894	rv = NULL;
895	*type = CFAPI_NONE;
896	break;
897	}
898	va_end(args);
899	return rv;
900	}
901	void* cfapi_map_get_map_property(int* type, ...)
902	{
903	va_list args;
904	int x, y;
905	sint16 nx, ny;
906	mapstruct* map;
907	mapstruct* newmap;
908	static int rv;
909	int property;
910	char* buf;
911
912	va_start(args, type);
913
914	property = va_arg(args, int);
915	switch (property)
916	{
917	case CFAPI_MAP_PROP_FLAGS:
918	map = va_arg(args, mapstruct*);
919	newmap = va_arg(args, mapstruct*);
920	x = va_arg(args, int);
921	y = va_arg(args, int);
922	nx = va_arg(args, int);
923	ny = va_arg(args, int);
924	rv = get_map_flags(map, &newmap, x, y, &nx, &ny);
925	va_end(args);
926	*type = CFAPI_INT;
927	return &rv;
928	break;
929
930	case CFAPI_MAP_PROP_DIFFICULTY:
931	map = va_arg(args, mapstruct*);
932	rv = calculate_difficulty(map);
933	va_end(args);
934	*type = CFAPI_INT;
935	return &rv;
936	break;
937
938	case CFAPI_MAP_PROP_PATH:
939	map = va_arg(args, mapstruct*);
940	buf = map->path;
941	*type = CFAPI_STRING;
942	va_end(args);
943	return buf;
944	break;
945
946	case CFAPI_MAP_PROP_TMPNAME:
947	map = va_arg(args, mapstruct*);
948	buf = map->tmpname;
949	*type = CFAPI_STRING;
950	va_end(args);
951	return buf;
952	break;
953
954	case CFAPI_MAP_PROP_NAME:
955	map = va_arg(args, mapstruct*);
956	buf = map->name;
957	*type = CFAPI_STRING;
958	va_end(args);
959	return buf;
960	break;
961
962	case CFAPI_MAP_PROP_RESET_TIME:
963	map = va_arg(args, mapstruct*);
964	rv = map->reset_time;
965	*type = CFAPI_INT;
966	va_end(args);
967	return &rv;
968	break;
969
970	case CFAPI_MAP_PROP_RESET_TIMEOUT:
971	map = va_arg(args, mapstruct*);
972	rv = map->reset_timeout;
973	*type = CFAPI_INT;
974	va_end(args);
975	return &rv;
976	break;
977
978	case CFAPI_MAP_PROP_PLAYERS:
979	map = va_arg(args, mapstruct*);
980	rv = map->players;
981	*type = CFAPI_INT;
982	va_end(args);
983	return &rv;
984	break;
985
986	case CFAPI_MAP_PROP_DARKNESS:
987	map = va_arg(args, mapstruct*);
988	rv = map->darkness;
989	*type = CFAPI_INT;
990	va_end(args);
991	return &rv;
992	break;
993
994	case CFAPI_MAP_PROP_WIDTH:
995	map = va_arg(args, mapstruct*);
996	rv = map->width;
997	*type = CFAPI_INT;
998	va_end(args);
999	return &rv;
1000	break;
1001
1002	case CFAPI_MAP_PROP_HEIGHT:
1003	map = va_arg(args, mapstruct*);
1004	rv = map->height;
1005	*type = CFAPI_INT;
1006	va_end(args);
1007	return &rv;
1008	break;
1009
1010	case CFAPI_MAP_PROP_ENTER_X:
1011	map = va_arg(args, mapstruct*);
1012	rv = map->enter_x;
1013	*type = CFAPI_INT;
1014	va_end(args);
1015	return &rv;
1016	break;
1017
1018	case CFAPI_MAP_PROP_ENTER_Y:
1019	map = va_arg(args, mapstruct*);
1020	rv = map->enter_y;
1021	*type = CFAPI_INT;
1022	va_end(args);
1023	return &rv;
1024	break;
1025
1026	case CFAPI_MAP_PROP_TEMPERATURE:
1027	map = va_arg(args, mapstruct*);
1028	rv = map->temp;
1029	*type = CFAPI_INT;
1030	va_end(args);
1031	return &rv;
1032	break;
1033
1034	case CFAPI_MAP_PROP_PRESSURE:
1035	map = va_arg(args, mapstruct*);
1036	rv = map->pressure;
1037	*type = CFAPI_INT;
1038	va_end(args);
1039	return &rv;
1040	break;
1041
1042	case CFAPI_MAP_PROP_HUMIDITY:
1043	map = va_arg(args, mapstruct*);
1044	rv = map->humid;
1045	*type = CFAPI_INT;
1046	va_end(args);
1047	return &rv;
1048	break;
1049
1050	case CFAPI_MAP_PROP_WINDSPEED:
1051	map = va_arg(args, mapstruct*);
1052	rv = map->windspeed;
1053	*type = CFAPI_INT;
1054	va_end(args);
1055	return &rv;
1056	break;
1057
1058	case CFAPI_MAP_PROP_WINDDIR:
1059	map = va_arg(args, mapstruct*);
1060	rv = map->winddir;
1061	*type = CFAPI_INT;
1062	va_end(args);
1063	return &rv;
1064	break;
1065
1066	case CFAPI_MAP_PROP_SKY:
1067	map = va_arg(args, mapstruct*);
1068	rv = map->sky;
1069	*type = CFAPI_INT;
1070	va_end(args);
1071	return &rv;
1072	break;
1073
1074	case CFAPI_MAP_PROP_WPARTX:
1075	map = va_arg(args, mapstruct*);
1076	rv = map->wpartx;
1077	*type = CFAPI_INT;
1078	va_end(args);
1079	return &rv;
1080	break;
1081
1082	case CFAPI_MAP_PROP_WPARTY:
1083	map = va_arg(args, mapstruct*);
1084	rv = map->wparty;
1085	*type = CFAPI_INT;
1086	va_end(args);
1087	return &rv;
1088	break;
1089
1090	case CFAPI_MAP_PROP_MESSAGE:
1091	map = va_arg(args, mapstruct*);
1092	buf = map->msg;
1093	*type = CFAPI_STRING;
1094	va_end(args);
1095	return buf;
1096	break;
1097
1098	case CFAPI_MAP_PROP_NEXT:
1099	map = va_arg(args, mapstruct*);
1100	*type = CFAPI_PMAP;
1101	va_end(args);
1102	return map->next;
1103	break;
1104
1105	case CFAPI_MAP_PROP_REGION:
1106	map = va_arg(args, mapstruct*);
1107	*type = CFAPI_PREGION;
1108	va_end(args);
1109	return get_region_by_map(map);
1110	break;
1111
1112	default:
1113	*type = CFAPI_NONE;
1114	va_end(args);
1115	return NULL;
1116	break;
1117	}
1118	}
1119
1120	void* cfapi_map_set_map_property(int* type, ...)
1121	{
1122	va_list args;
1123	static int rv;
1124	mapstruct* map;
1125	int val;
1126	int property;
1127
1128	va_start(args, type);
1129
1130	property = va_arg(args, int);
1131
1132	switch (property)
1133	{
1134	case CFAPI_MAP_PROP_LIGHT:
1135	map = va_arg(args, mapstruct*);
1136	val = va_arg(args, int);
1137	rv = change_map_light(map, val);
1138	*type = CFAPI_INT;
1139	va_end(args);
1140	return &rv;
1141	break;
1142
1143	case CFAPI_MAP_PROP_RESET_TIME:
1144	map = va_arg(args, mapstruct*);
1145	*type = CFAPI_NONE;
1146	va_end(args);
1147	return NULL;
1148	break;
1149
1150	default:
1151	*type = CFAPI_NONE;
1152	va_end(args);
1153	return NULL;
1154	break;
1155	}
1156	}
1157	void* cfapi_map_out_of_map(int* type, ...)
1158	{
1159	va_list args;
1160	static int rv;
1161	mapstruct* map;
1162	int x, y;
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	rv = out_of_map(map, x, y);
1170	va_end(args);
1171	*type = CFAPI_INT;
1172	return &rv;
1173	}
1174	void* cfapi_map_update_position(int* type, ...)
1175	{
1176	va_list args;
1177	mapstruct* map;
1178	int x, y;
1179
1180	va_start(args, type);
1181
1182	map = va_arg(args, mapstruct*);
1183	x = va_arg(args, int);
1184	y = va_arg(args, int);
1185
1186	update_position(map, x, y);
1187	va_end(args);
1188	*type = CFAPI_NONE;
1189	return NULL;
1190	}
1191	void* cfapi_map_delete_map(int* type, ...)
1192	{
1193	va_list args;
1194	mapstruct* map;
1195	va_start(args, type);
1196
1197	map = va_arg(args, mapstruct*);
1198
1199	delete_map(map);
1200
1201	va_end(args);
1202	*type = CFAPI_NONE;
1203	return NULL;
1204	}
1205	void* cfapi_map_message(int* type, ...)
1206	{
1207	va_list args;
1208	mapstruct* map;
1209	char* string;
1210	int color;
1211
1212	va_start(args, type);
1213	map = va_arg(args, mapstruct*);
1214	string = va_arg(args, char*);
1215	color = va_arg(args, int);
1216	va_end(args);
1217
1218	new_info_map(color, map, string);
1219	*type = CFAPI_NONE;
1220	return NULL;
1221	}
1222	void* cfapi_map_get_object_at(int* type, ...)
1223	{
1224	va_list args;
1225	mapstruct* map;
1226	int x, y;
1227	object* rv;
1228
1229	va_start(args, type);
1230	map = va_arg(args, mapstruct*);
1231	x = va_arg(args, int);
1232	y = va_arg(args, int);
1233	va_end(args);
1234
1235	rv = get_map_ob(map, x, y);
1236	*type = CFAPI_POBJECT;
1237	return rv;
1238	}
1239	void* cfapi_map_get_flags(int* type, ...)
1240	{
1241	va_list args;
1242	sint16 x, y;
1243	sint16 *nx, *ny;
1244	static mapstruct* map;
1245	mapstruct** newmap;
1246	static int rv;
1247
1248	va_start(args, type);
1249
1250	map = va_arg(args, mapstruct*);
1251	newmap = va_arg(args, mapstruct**);
1252	x = va_arg(args, int);
1253	y = va_arg(args, int);
1254	nx = va_arg(args, sint16*);
1255	ny = va_arg(args, sint16*);
1256	va_end(args);
1257
1258	rv = get_map_flags(map, newmap, x, y, nx, ny);
1259
1260	*type = CFAPI_INT;
1261	return &rv;
1262	}
1263	void* cfapi_map_present_arch_by_name(int* type, ...)
1264	{
1265	va_list args;
1266	object* rv;
1267	int x, y;
1268	mapstruct* map;
1269	char* msg;
1270
1271	va_start(args, type);
1272
1273	msg = va_arg(args, char*);
1274	map = va_arg(args, mapstruct*);
1275	x = va_arg(args, int);
1276	y = va_arg(args, int);
1277
1278	va_end(args);
1279
1280	rv = present_arch(find_archetype(msg), map, x, y);
1281	*type = CFAPI_POBJECT;
1282	return rv;
1283	}
1284
1285	/* OBJECT-RELATED HOOKS */
1286
1287	void* cfapi_object_move(int* type, ...)
1288	{
1289	va_list args;
1290	int kind;
1291	object* op;
1292	object* activator;
1293	player* pl;
1294	int direction;
1295	static int rv=0;
1296
1297	va_start(args, type);
1298	kind = va_arg(args, int);
1299	switch (kind)
1300	{
1301	case 0:
1302	op = va_arg(args, object*);
1303	direction = va_arg(args, int);
1304	activator = va_arg(args, object*);
1305	va_end(args);
1306	rv = move_ob(op, direction, activator);
1307	break;
1308
1309	case 1:
1310	pl = va_arg(args, player*);
1311	direction = va_arg(args, int);
1312	va_end(args);
1313	rv = move_player(pl->ob, direction);
1314	break;
1315	}
1316	*type = CFAPI_INT;
1317	return &rv;
1318	}
1319
1320	void* cfapi_object_get_key(int* type, ...)
1321	{
1322	va_list args;
1323	char* rv;
1324	char* keyname;
1325	object* op;
1326
1327	va_start(args, type);
1328	op = va_arg(args, object*);
1329	keyname = va_arg(args, char*);
1330	va_end(args);
1331
1332	rv = (char*)get_ob_key_value(op, keyname);
1333	*type = CFAPI_STRING;
1334	return rv;
1335	}
1336	void* cfapi_object_set_key(int* type, ...)
1337	{
1338	va_list args;
1339	char* keyname;
1340	char* value;
1341	object* op;
1342
1343	va_start(args, type);
1344	op = va_arg(args, object*);
1345	keyname = va_arg(args, char*);
1346	value = va_arg(args, char*);
1347	va_end(args);
1348
1349	set_ob_key_value(op, keyname, value, 0);
1350	*type = CFAPI_NONE;
1351	return NULL;
1352	}
1353	void* cfapi_object_get_property(int* type, ...)
1354	{
1355	va_list args;
1356	int property;
1357	object* op;
1358	void* rv;
1359	static int ri;
1360
1361	va_start(args, type);
1362
1363	op = va_arg(args, object*);
1364	property = va_arg(args, int);
1365	rv = NULL;
1366	if (op != NULL) {
1367	switch (property)
1368	{
1369	case CFAPI_OBJECT_PROP_OB_ABOVE:
1370	rv = op->above;
1371	*type = CFAPI_POBJECT;
1372	break;
1373
1374	case CFAPI_OBJECT_PROP_OB_BELOW:
1375	rv = op->below;
1376	*type = CFAPI_POBJECT;
1377	break;
1378
1379	case CFAPI_OBJECT_PROP_NEXT_ACTIVE_OB:
1380	rv = op->active_next;
1381	*type = CFAPI_POBJECT;
1382	break;
1383
1384	case CFAPI_OBJECT_PROP_PREV_ACTIVE_OB:
1385	rv = op->active_prev;
1386	*type = CFAPI_POBJECT;
1387	break;
1388
1389	case CFAPI_OBJECT_PROP_INVENTORY:
1390	rv = op->inv;
1391	*type = CFAPI_POBJECT;
1392	break;
1393
1394	case CFAPI_OBJECT_PROP_ENVIRONMENT:
1395	rv = op->env;
1396	*type = CFAPI_POBJECT;
1397	break;
1398
1399	case CFAPI_OBJECT_PROP_HEAD:
1400	rv = op->head;
1401	*type = CFAPI_POBJECT;
1402	break;
1403
1404	case CFAPI_OBJECT_PROP_CONTAINER:
1405	rv = op->container;
1406	*type = CFAPI_POBJECT;
1407	break;
1408
1409	case CFAPI_OBJECT_PROP_MAP:
1410	rv = op->map;
1411	*type = CFAPI_PMAP;
1412	break;
1413
1414	case CFAPI_OBJECT_PROP_COUNT:
1415	ri = op->count; rv = &ri;
1416	*type = CFAPI_INT;
1417	break;
1418
1419	case CFAPI_OBJECT_PROP_REFCOUNT:
1420	ri = op->refcount; rv = &ri;
1421	*type = CFAPI_INT;
1422	break;
1423
1424	case CFAPI_OBJECT_PROP_NAME:
1425	rv = query_name(op);
1426	*type = CFAPI_STRING;
1427	break;
1428
1429	case CFAPI_OBJECT_PROP_NAME_PLURAL:
1430	rv = (char*)op->name_pl;
1431	*type = CFAPI_STRING;
1432	break;
1433
1434	case CFAPI_OBJECT_PROP_TITLE:
1435	rv = (char*)op->title;
1436	*type = CFAPI_STRING;
1437	break;
1438
1439	case CFAPI_OBJECT_PROP_RACE:
1440	rv = (char*)op->race;
1441	*type = CFAPI_STRING;
1442	break;
1443
1444	case CFAPI_OBJECT_PROP_SLAYING:
1445	rv = (char*)op->slaying;
1446	*type = CFAPI_STRING;
1447	break;
1448
1449	case CFAPI_OBJECT_PROP_SKILL:
1450	rv = (char*)op->skill;
1451	*type = CFAPI_STRING;
1452	break;
1453
1454	case CFAPI_OBJECT_PROP_MESSAGE:
1455	rv = (char*)op->msg;
1456	if (rv == NULL)
1457	rv = (void*)"";
1458	*type = CFAPI_STRING;
1459	break;
1460
1461	case CFAPI_OBJECT_PROP_LORE:
1462	rv = (char*)op->lore;
1463	*type = CFAPI_STRING;
1464	break;
1465
1466	case CFAPI_OBJECT_PROP_X:
1467	ri = op->x;
1468	rv = &ri;
1469	*type = CFAPI_INT;
1470	break;
1471
1472	case CFAPI_OBJECT_PROP_Y:
1473	ri = op->y;
1474	rv = &ri;
1475	*type = CFAPI_INT;
1476	break;
1477
1478	case CFAPI_OBJECT_PROP_SPEED:
1479	rv = &op->speed;
1480	*type = CFAPI_DOUBLE;
1481	break;
1482
1483	case CFAPI_OBJECT_PROP_SPEED_LEFT:
1484	rv = &op->speed_left;
1485	*type = CFAPI_DOUBLE;
1486	break;
1487
1488	case CFAPI_OBJECT_PROP_NROF:
1489	ri = op->nrof; rv = &ri;
1490	*type = CFAPI_INT;
1491	break;
1492
1493	case CFAPI_OBJECT_PROP_DIRECTION:
1494	ri = op->direction; rv = &ri;
1495	*type = CFAPI_INT;
1496	break;
1497
1498	case CFAPI_OBJECT_PROP_FACING:
1499	ri = op->facing; rv = &ri;
1500	*type = CFAPI_INT;
1501	break;
1502
1503	case CFAPI_OBJECT_PROP_TYPE:
1504	ri = op->type; rv = &ri;
1505	*type = CFAPI_INT;
1506	break;
1507
1508	case CFAPI_OBJECT_PROP_SUBTYPE:
1509	ri = op->subtype; rv = &ri;
1510	*type = CFAPI_INT;
1511	break;
1512
1513	case CFAPI_OBJECT_PROP_CLIENT_TYPE:
1514	ri = op->client_type; rv = &ri;
1515	*type = CFAPI_INT;
1516	break;
1517
1518	case CFAPI_OBJECT_PROP_RESIST:
1519	{
1520	int idx;
1521	idx = va_arg(args, int);
1522	ri = op->resist[idx]; rv = &ri;
1523	}
1524	*type = CFAPI_INT;
1525	break;
1526
1527	case CFAPI_OBJECT_PROP_ATTACK_TYPE:
1528	ri = op->attacktype; rv = &ri;
1529	*type = CFAPI_INT;
1530	break;
1531
1532	case CFAPI_OBJECT_PROP_PATH_ATTUNED:
1533	ri = op->path_attuned; rv = &ri;
1534	*type = CFAPI_INT;
1535	break;
1536
1537	case CFAPI_OBJECT_PROP_PATH_REPELLED:
1538	ri = op->path_repelled; rv = &ri;
1539	*type = CFAPI_INT;
1540	break;
1541
1542	case CFAPI_OBJECT_PROP_PATH_DENIED:
1543	ri = op->path_denied; rv = &ri;
1544	*type = CFAPI_INT;
1545	break;
1546
1547	case CFAPI_OBJECT_PROP_MATERIAL:
1548	ri = op->material; rv = &ri;
1549	*type = CFAPI_INT;
1550	break;
1551
1552	case CFAPI_OBJECT_PROP_MATERIAL_NAME:
1553	rv = (char*)op->materialname;
1554	*type = CFAPI_STRING;
1555	break;
1556
1557	case CFAPI_OBJECT_PROP_MAGIC:
1558	ri = op->magic; rv = &ri;
1559	*type = CFAPI_INT;
1560	break;
1561
1562	case CFAPI_OBJECT_PROP_VALUE:
1563	ri = op->value; rv = &ri;
1564	*type = CFAPI_INT;
1565	break;
1566
1567	case CFAPI_OBJECT_PROP_LEVEL:
1568	ri = op->level; rv = &ri;
1569	*type = CFAPI_INT;
1570	break;
1571
1572	case CFAPI_OBJECT_PROP_LAST_HEAL:
1573	ri = op->last_heal; rv = &ri;
1574	*type = CFAPI_INT;
1575	break;
1576
1577	case CFAPI_OBJECT_PROP_LAST_SP:
1578	ri = op->last_sp; rv = &ri;
1579	*type = CFAPI_INT;
1580	break;
1581
1582	case CFAPI_OBJECT_PROP_LAST_GRACE:
1583	ri = op->last_grace; rv = &ri;
1584	*type = CFAPI_INT;
1585	break;
1586
1587	case CFAPI_OBJECT_PROP_LAST_EAT:
1588	ri = op->last_eat; rv = &ri;
1589	*type = CFAPI_INT;
1590	break;
1591
1592	case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
1593	ri = op->invisible; rv = &ri;
1594	*type = CFAPI_INT;
1595	break;
1596
1597	case CFAPI_OBJECT_PROP_PICK_UP:
1598	ri = op->pick_up; rv = &ri;
1599	*type = CFAPI_INT;
1600	break;
1601
1602	case CFAPI_OBJECT_PROP_ITEM_POWER:
1603	ri = op->item_power; rv = &ri;
1604	*type = CFAPI_INT;
1605	break;
1606
1607	case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
1608	ri = op->gen_sp_armour; rv = &ri;
1609	*type = CFAPI_INT;
1610	break;
1611
1612	case CFAPI_OBJECT_PROP_WEIGHT:
1613	ri = op->weight; rv = &ri;
1614	*type = CFAPI_INT;
1615	break;
1616
1617	case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
1618	ri = op->weight_limit; rv = &ri;
1619	*type = CFAPI_INT;
1620	break;
1621
1622	case CFAPI_OBJECT_PROP_CARRYING:
1623	ri = op->carrying; rv = &ri;
1624	*type = CFAPI_INT;
1625	break;
1626
1627	case CFAPI_OBJECT_PROP_GLOW_RADIUS:
1628	ri = op->glow_radius; rv = &ri;
1629	*type = CFAPI_INT;
1630	break;
1631
1632	case CFAPI_OBJECT_PROP_PERM_EXP:
1633	rv = &op->perm_exp;
1634	*type = CFAPI_LONG;
1635	break;
1636
1637	case CFAPI_OBJECT_PROP_CURRENT_WEAPON:
1638	rv = op->current_weapon;
1639	*type = CFAPI_POBJECT;
1640	break;
1641
1642	case CFAPI_OBJECT_PROP_ENEMY:
1643	rv = op->enemy;
1644	*type = CFAPI_POBJECT;
1645	break;
1646
1647	case CFAPI_OBJECT_PROP_ATTACKED_BY:
1648	rv = op->attacked_by;
1649	*type = CFAPI_POBJECT;
1650	break;
1651
1652	case CFAPI_OBJECT_PROP_RUN_AWAY:
1653	ri = op->run_away; rv = &ri;
1654	*type = CFAPI_INT;
1655	break;
1656
1657	case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
1658	rv = op->chosen_skill;
1659	*type = CFAPI_POBJECT;
1660	break;
1661
1662	case CFAPI_OBJECT_PROP_HIDDEN:
1663	ri = op->hide; rv = &ri;
1664	*type = CFAPI_INT;
1665	break;
1666
1667	case CFAPI_OBJECT_PROP_MOVE_STATUS:
1668	ri = op->move_status; rv = &ri;
1669	*type = CFAPI_INT;
1670	break;
1671
1672	case CFAPI_OBJECT_PROP_MOVE_TYPE:
1673	ri = op->attack_movement; rv = &ri;
1674	*type = CFAPI_INT;
1675	break;
1676
1677	case CFAPI_OBJECT_PROP_SPELL_ITEM:
1678	rv = op->spellitem;
1679	*type = CFAPI_POBJECT;
1680	break;
1681
1682	case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
1683	rv = &op->expmul;
1684	*type = CFAPI_DOUBLE;
1685	break;
1686
1687	case CFAPI_OBJECT_PROP_ARCHETYPE:
1688	rv = op->arch;
1689	*type = CFAPI_PARCH;
1690	break;
1691
1692	case CFAPI_OBJECT_PROP_OTHER_ARCH:
1693	rv = op->other_arch;
1694	*type = CFAPI_PARCH;
1695	break;
1696
1697	case CFAPI_OBJECT_PROP_CUSTOM_NAME:
1698	rv = (char*)op->custom_name;
1699	*type = CFAPI_STRING;
1700	break;
1701
1702	case CFAPI_OBJECT_PROP_ANIM_SPEED:
1703	ri = op->anim_speed; rv = &ri;
1704	*type = CFAPI_INT;
1705	break;
1706
1707	case CFAPI_OBJECT_PROP_FRIENDLY:
1708	ri = is_friendly(op);
1709	rv = &ri;
1710	*type = CFAPI_INT;
1711	break;
1712
1713	case CFAPI_OBJECT_PROP_SHORT_NAME:
1714	rv = (char*)query_short_name(op);
1715	*type = CFAPI_STRING;
1716	break;
1717
1718	case CFAPI_OBJECT_PROP_BASE_NAME:
1719	{
1720	int i;
1721	i = va_arg(args, int);
1722	rv = (char*)query_base_name(op, i);
1723	*type = CFAPI_STRING;
1724	}
1725	break;
1726
1727	case CFAPI_OBJECT_PROP_MAGICAL:
1728	ri = is_magical(op);
1729	rv = &ri;
1730	*type = CFAPI_INT;
1731	break;
1732
1733	case CFAPI_OBJECT_PROP_LUCK:
1734	ri = op->stats.luck; rv = &ri;
1735	*type = CFAPI_INT;
1736	break;
1737
1738	case CFAPI_OBJECT_PROP_EXP:
1739	rv = &op->stats.exp;
1740	*type = CFAPI_LONG;
1741	break;
1742
1743	case CFAPI_OBJECT_PROP_OWNER:
1744	rv = get_owner(op);
1745	*type = CFAPI_POBJECT;
1746	break;
1747
1748	case CFAPI_OBJECT_PROP_PRESENT:
1749	{
1750	int stype;
1751	rv = 0;
1752	stype = va_arg(args, int);
1753	switch (stype) {
1754
1755	unsigned char ptype;
1756	char* buf;
1757	archetype* at;
1758
1759	case 0: /* present_in_ob */
1760	ptype = (unsigned char)(va_arg(args, int));
1761	rv = present_in_ob(ptype, op);
1762	break;
1763
1764	case 1: /* present_in_ob_by_name */
1765	ptype = (unsigned char)(va_arg(args, int));
1766	buf = va_arg(args, char*);
1767	rv = present_in_ob_by_name(ptype, buf, op);
1768	break;
1769
1770	case 2: /* present_arch_in_ob */
1771	at = va_arg(args, archetype*);
1772	rv = present_arch_in_ob(at, op);
1773	break;
1774	}	464	}
1775	}	465	}
1776	*type = CFAPI_POBJECT;	466	else
1777	break;
1778
1779	case CFAPI_OBJECT_PROP_CHEATER:
1780	ri = (QUERY_FLAG(op, FLAG_WAS_WIZ));
1781	rv = &ri;
1782	*type = CFAPI_INT;
1783	break;
1784
1785	case CFAPI_OBJECT_PROP_MERGEABLE:
1786	{	467	{
1787	object* op2;	468	if (p != NULL)
		469	p->next = NULL;
		470	else
		471	plugins_list = NULL;
		472	}
		473	free (cp);
		474	plugin_number--;
		475	return 0;
		476	}
		477	}
		478	return -1;
		479	}
		480
		481	crossfire_plugin *
		482	plugins_find_plugin (const char *id)
		483	{
		484	crossfire_plugin *cp;
		485
		486	if (plugins_list == NULL)
		487	return NULL;
		488
		489	for (cp = plugins_list; cp != NULL; cp = cp->next)
		490	{
		491	if (!strcmp (id, cp->id))
		492	{
		493	return cp;
		494	}
		495	}
		496	return NULL;
		497	}
		498
		499	/*****************************************************************************/
		500
		501	/* Displays a list of loaded plugins (keystrings and description) in the */
		502
		503	/* game log window. */
		504
		505	/*****************************************************************************/
		506	void
		507	plugins_display_list (object *op)
		508	{
		509	crossfire_plugin *cp;
		510
		511	new_draw_info (NDI_UNIQUE, 0, op, "List of loaded plugins:");
		512	new_draw_info (NDI_UNIQUE, 0, op, "-----------------------");
		513
		514	if (plugins_list == NULL)
		515	return;
		516
		517	for (cp = plugins_list; cp != NULL; cp = cp->next)
		518	{
		519	new_draw_info_format (NDI_UNIQUE, 0, op, "%s, %s", cp->id, cp->fullname);
		520	}
		521	}
		522
		523	/* SYSTEM-RELATED HOOKS */
		524
		525	void *
		526	cfapi_system_find_animation (int *type, ...)
		527	{
		528	va_list args;
		529	static int rv;
		530	char *anim;
		531
		532	va_start (args, type);
		533	anim = va_arg (args, char *);
		534
		535	va_end (args);
		536
		537	rv = find_animation (anim);
		538	*type = CFAPI_INT;
		539	return &rv;
		540	}
		541
		542	void *
		543	cfapi_system_strdup_local (int *type, ...)
		544	{
		545	va_list args;
		546	char *txt;
		547
		548	va_start (args, type);
		549	txt = va_arg (args, char *);
		550
		551	va_end (args);
		552	*type = CFAPI_STRING;
		553	return strdup_local (txt);
		554	}
		555
		556	void *
		557	cfapi_system_register_global_event (int *type, ...)
		558	{
		559	va_list args;
		560	int eventcode;
		561	char *pname;
		562	f_plug_api hook;
		563	crossfire_plugin *cp;
		564
		565	va_start (args, type);
		566	eventcode = va_arg (args, int);
		567	pname = va_arg (args, char *);
		568
		569	hook = va_arg (args, f_plug_api);
		570
		571	va_end (args);
		572	cp = plugins_find_plugin (pname);
		573	cp->gevent[eventcode] = hook;
		574	return NULL;
		575	}
		576
		577	void *
		578	cfapi_system_unregister_global_event (int *type, ...)
		579	{
		580	va_list args;
		581	int eventcode;
		582	char *pname;
		583	crossfire_plugin *cp;
		584
		585	va_start (args, type);
		586	eventcode = va_arg (args, int);
		587	pname = va_arg (args, char *);
		588
		589	cp = plugins_find_plugin (pname);
		590	cp->gevent[eventcode] = NULL;
		591
		592	va_end (args);
		593	return NULL;
		594	}
		595
		596	void *
		597	cfapi_system_check_path (int *type, ...)
		598	{
		599	va_list args;
		600	static int rv;
		601	char *name;
		602	int prepend_dir;
		603
		604	va_start (args, type);
		605
		606	name = va_arg (args, char *);
		607	prepend_dir = va_arg (args, int);
		608
		609	rv = check_path (name, prepend_dir);
		610
		611	va_end (args);
		612	*type = CFAPI_INT;
		613	return &rv;
		614	}
		615
		616	void *
		617	cfapi_system_re_cmp (int *type, ...)
		618	{
		619	va_list args;
		620	char *rv;
		621	const char *str;
		622	const char *regexp;
		623
		624	va_start (args, type);
		625
		626	str = va_arg (args, char *);
		627	regexp = va_arg (args, char *);
		628
		629	rv = (char *) re_cmp (str, regexp);
		630
		631	va_end (args);
		632	*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
		650	switch (dirtype)
		651	{
		652	case 0:
		653	return settings.mapdir;
		654	break;
		655
		656	case 1:
		657	return settings.uniquedir;
		658	break;
		659
		660	case 2:
		661	return settings.tmpdir;
		662	break;
		663
		664	case 3:
		665	return settings.confdir;
		666	break;
		667
		668	case 4:
		669	return settings.localdir;
		670	break;
		671
		672	case 5:
		673	return settings.playerdir;
		674	break;
		675
		676	case 6:
		677	return settings.datadir;
		678	break;
		679	}
		680
		681	*type = CFAPI_NONE;
		682	return NULL;
		683	}
		684
		685
		686	/* MAP RELATED HOOKS */
		687
		688	void *
		689	cfapi_map_get_map (int *type, ...)
		690	{
		691	va_list args;
		692	mapstruct *rv;
		693	int ctype;
		694	int x, y;
		695	sint16 nx, ny;
		696	char *name;
		697	mapstruct *m;
		698
		699	va_start (args, type);
		700
		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 *);
		1091	x = va_arg (args, int);
		1092	y = va_arg (args, int);
		1093
		1094	rv = out_of_map (map, x, y);
		1095	va_end (args);
		1096	*type = CFAPI_INT;
		1097	return &rv;
		1098	}
		1099
		1100	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, ...)
		1205	{
		1206	va_list args;
		1207	object *rv;
		1208	int x, y;
		1209	mapstruct *map;
		1210	char *msg;
		1211
		1212	va_start (args, type);
		1213
		1214	msg = va_arg (args, char *);
		1215	map = va_arg (args, mapstruct *);
		1216	x = va_arg (args, int);
		1217	y = va_arg (args, int);
		1218
		1219	va_end (args);
		1220
		1221	rv = present_arch (archetype::find (msg), map, x, y);
		1222	*type = CFAPI_POBJECT;
		1223	return rv;
		1224	}
		1225
		1226	/* OBJECT-RELATED HOOKS */
		1227
		1228	void *
		1229	cfapi_object_move (int *type, ...)
		1230	{
		1231	va_list args;
		1232	int kind;
		1233	object *op;
		1234	object *activator;
		1235	player *pl;
		1236	int direction;
		1237	static int rv = 0;
		1238
		1239	va_start (args, type);
		1240	kind = va_arg (args, int);
		1241
		1242	switch (kind)
		1243	{
		1244	case 0:
1788	op2 = va_arg(args, object*);	1245	op = va_arg (args, object *);
1789	ri = CAN_MERGE(op, op2);	1246	direction = va_arg (args, int);
		1247	activator = va_arg (args, object *);
		1248
		1249	va_end (args);
		1250	rv = move_ob (op, direction, activator);
		1251	break;
		1252
		1253	case 1:
		1254	pl = va_arg (args, player *);
		1255	direction = va_arg (args, int);
		1256
		1257	va_end (args);
		1258	rv = move_player (pl->ob, direction);
		1259	break;
		1260	}
		1261	*type = CFAPI_INT;
		1262	return &rv;
		1263	}
		1264
		1265	void *
		1266	cfapi_object_get_key (int *type, ...)
		1267	{
		1268	va_list args;
		1269	char *rv;
		1270	char *keyname;
		1271	object *op;
		1272
		1273	va_start (args, type);
		1274	op = va_arg (args, object *);
		1275	keyname = va_arg (args, char *);
		1276
		1277	va_end (args);
		1278
		1279	rv = (char *) get_ob_key_value (op, keyname);
		1280	*type = CFAPI_STRING;
		1281	return rv;
		1282	}
		1283
		1284	void *
		1285	cfapi_object_set_key (int *type, ...)
		1286	{
		1287	va_list args;
		1288	char *keyname;
		1289	char *value;
		1290	object *op;
		1291
		1292	va_start (args, type);
		1293	op = va_arg (args, object *);
		1294	keyname = va_arg (args, char *);
		1295	value = va_arg (args, char *);
		1296
		1297	va_end (args);
		1298
		1299	set_ob_key_value (op, keyname, value, 0);
		1300	*type = CFAPI_NONE;
		1301	return NULL;
		1302	}
		1303
		1304	void *
		1305	cfapi_object_get_property (int *type, ...)
		1306	{
		1307	va_list args;
		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];
1790	rv = &ri;	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	}
		1948
		1949	void *
		1950	cfapi_object_set_property (int *type, ...)
		1951	{
		1952	va_list args;
		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	}
		2521
		2522	void *
		2523	cfapi_object_apply_below (int *type, ...)
		2524	{
		2525	va_list args;
		2526	object *applier;
		2527
		2528	va_start (args, type);
		2529
		2530	applier = va_arg (args, object *);
		2531
		2532	va_end (args);
		2533
		2534	player_apply_below (applier);
		2535	*type = CFAPI_NONE;
		2536	return NULL;
		2537	}
		2538
		2539	void *
		2540	cfapi_object_apply (int *type, ...)
		2541	{
		2542	va_list args;
		2543	object *applied;
		2544	object *applier;
		2545	int aflags;
		2546	static int rv;
		2547
		2548	va_start (args, type);
		2549
		2550	applied = va_arg (args, object *);
		2551	applier = va_arg (args, object *);
		2552	aflags = va_arg (args, int);
		2553
		2554	va_end (args);
		2555
		2556	*type = CFAPI_INT;
		2557	rv = manual_apply (applier, applied, aflags);
		2558	return &rv;
		2559	}
		2560
		2561	void *
		2562	cfapi_object_identify (int *type, ...)
		2563	{
		2564	va_list args;
		2565	object *op;
		2566
		2567	va_start (args, type);
		2568
		2569	op = va_arg (args, object *);
		2570
		2571	va_end (args);
		2572
		2573	identify (op);
		2574	*type = CFAPI_NONE;
		2575	return NULL;
		2576	}
		2577
		2578	void *
		2579	cfapi_object_describe (int *type, ...)
		2580	{
		2581	va_list args;
		2582	object *op;
		2583	object *owner;
		2584
		2585	va_start (args, type);
		2586
		2587	op = va_arg (args, object *);
		2588	owner = va_arg (args, object *);
		2589
		2590	va_end (args);
		2591
		2592	*type = CFAPI_STRING;
		2593	return describe_item (op, owner);
		2594	}
		2595
		2596	void *
		2597	cfapi_object_drain (int *type, ...)
		2598	{
		2599	va_list args;
		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	}
		2616
		2617	void *
		2618	cfapi_object_fix (int *type, ...)
		2619	{
		2620	va_list args;
		2621	object *op;
		2622
		2623	va_start (args, type);
		2624
		2625	op = va_arg (args, object *);
		2626
		2627	va_end (args);
		2628
		2629	fix_player (op);
		2630
		2631	*type = CFAPI_NONE;
		2632	return NULL;
		2633	}
		2634
		2635	void *
		2636	cfapi_object_give_skill (int *type, ...)
		2637	{
		2638	va_list args;
		2639
		2640	object *op;
		2641	char *skillname;
		2642
		2643	va_start (args, type);
		2644
		2645	op = va_arg (args, object *);
		2646	skillname = va_arg (args, char *);
		2647
		2648	va_end (args);
		2649
		2650	*type = CFAPI_POBJECT;
		2651	return give_skill_by_name (op, skillname);
		2652	}
		2653
		2654	void *
		2655	cfapi_object_transmute (int *type, ...)
		2656	{
		2657	va_list args;
		2658
		2659	object *op;
		2660	object *chg;
		2661
		2662	va_start (args, type);
		2663
		2664	op = va_arg (args, object *);
		2665	chg = va_arg (args, object *);
		2666
		2667	va_end (args);
		2668
		2669	transmute_materialname (op, chg);
		2670	*type = CFAPI_NONE;
		2671	return NULL;
		2672	}
		2673
		2674	void *
		2675	cfapi_object_remove (int *type, ...)
		2676	{
		2677	va_list args;
		2678	object *op;
		2679
		2680	va_start (args, type);
		2681
		2682	op = va_arg (args, object *);
		2683
		2684	va_end (args);
		2685
		2686	send_removed_object (op);
		2687	remove_ob (op);
		2688	*type = CFAPI_NONE;
		2689	return NULL;
		2690	}
		2691
		2692	void *
		2693	cfapi_object_delete (int *type, ...)
		2694	{
		2695	va_list args;
		2696	object *op;
		2697
		2698	va_start (args, type);
		2699
		2700	op = va_arg (args, object *);
		2701
		2702	va_end (args);
		2703
		2704	free_object (op);
		2705
		2706	*type = CFAPI_NONE;
		2707	return NULL;
		2708	}
		2709
		2710	void *
		2711	cfapi_object_clone (int *type, ...)
		2712	{
		2713	va_list args;
		2714	object *op;
		2715	int kind;
		2716
		2717	va_start (args, type);
		2718
		2719	op = va_arg (args, object *);
		2720	kind = va_arg (args, int);
		2721
		2722	va_end (args);
		2723
		2724	if (kind == 0)
		2725	{
		2726	*type = CFAPI_POBJECT;
		2727	return object_create_clone (op);
		2728	}
		2729	else
		2730	{
		2731	object *tmp;
		2732
		2733	tmp = get_object ();
		2734	copy_object (op, tmp);
		2735	*type = CFAPI_POBJECT;
		2736	return tmp;
		2737	}
		2738	}
		2739	void *
		2740	cfapi_object_find (int *type, ...)
		2741	{
		2742	va_list args;
		2743	int ftype;
		2744	void *rv;
		2745	int ival;
		2746	int ival2;
		2747	char *sval;
		2748	object *op;
		2749
		2750	va_start (args, type);
		2751
		2752	*type = CFAPI_POBJECT;
		2753	ftype = va_arg (args, int);
		2754
		2755	switch (ftype)
		2756	{
		2757	case 0:
		2758	ival = va_arg (args, int);
		2759
		2760	rv = find_object (ival);
		2761	break;
		2762
		2763	case 1:
		2764	sval = va_arg (args, char *);
		2765
		2766	rv = find_object_name (sval);
		2767	break;
		2768
		2769	case 2:
		2770	op = va_arg (args, object *);
		2771	ival = va_arg (args, int);
		2772	ival2 = va_arg (args, int);
		2773
		2774	rv = find_obj_by_type_subtype (op, ival, ival2);
		2775	break;
		2776
		2777	case 3:
		2778	op = va_arg (args, object *);
		2779
		2780	rv = is_player_inv (op);
		2781	break;
		2782
		2783	default:
		2784	rv = NULL;
		2785	*type = CFAPI_NONE;
		2786	break;
		2787	}
		2788
		2789	va_end (args);
		2790
		2791	return rv;
		2792	}
		2793
		2794	void *
		2795	cfapi_object_create (int *type, ...)
		2796	{
		2797	va_list args;
		2798	int ival;
		2799
		2800	va_start (args, type);
		2801	ival = va_arg (args, int);
		2802
		2803	*type = CFAPI_POBJECT;
		2804	switch (ival)
		2805	{
		2806	case 0:
		2807	va_end (args);
		2808	return get_object ();
		2809	break;
		2810
		2811	case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */
		2812	{
		2813	char *sval;
		2814	object *op;
		2815	sval = va_arg (args, char *);
		2816
		2817	op = get_archetype_by_object_name (sval);
		2818
		2819	if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
		2820	{
		2821	free_object (op);
		2822	/* Try with archetype names... */
		2823	op = get_archetype (sval);
		2824	if (strncmp (query_name (op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0)
		2825	{
		2826	free_object (op);
		2827	*type = CFAPI_NONE;
		2828	va_end (args);
		2829	return NULL;
		2830	}
		2831	}
		2832	va_end (args);
		2833	return op;
		2834	}
		2835	break;
		2836
		2837	default:
		2838	*type = CFAPI_NONE;
		2839	va_end (args);
		2840	return NULL;
		2841	break;
		2842	}
		2843	}
		2844	void *
		2845	cfapi_object_insert (int *type, ...)
		2846	{
		2847	va_list args;
		2848	object *op;
		2849	object *orig;
		2850	mapstruct *map;
		2851	int flag, x, y;
		2852	int itype;
		2853	char *arch_string;
		2854	void *rv = NULL;
		2855
		2856	va_start (args, type);
		2857
		2858	op = va_arg (args, object *);
		2859	itype = va_arg (args, int);
		2860
		2861	switch (itype)
		2862	{
		2863	case 0:
		2864	map = va_arg (args, mapstruct *);
		2865	orig = va_arg (args, object *);
		2866	flag = va_arg (args, int);
		2867	x = va_arg (args, int);
		2868	y = va_arg (args, int);
		2869
		2870	rv = insert_ob_in_map_at (op, map, orig, flag, x, y);
		2871	*type = CFAPI_POBJECT;
		2872	break;
		2873
		2874	case 1:
		2875	map = va_arg (args, mapstruct *);
		2876	orig = va_arg (args, object *);
		2877	flag = va_arg (args, int);
		2878
		2879	rv = insert_ob_in_map (op, map, orig, flag);
		2880	*type = CFAPI_POBJECT;
		2881	break;
		2882
		2883	case 2:
		2884	arch_string = va_arg (args, char *);
		2885
		2886	replace_insert_ob_in_map (arch_string, op);
		2887	*type = CFAPI_NONE;
		2888	break;
		2889
		2890	case 3:
		2891	orig = va_arg (args, object *);
		2892
		2893	rv = insert_ob_in_ob (op, orig);
		2894	if (orig->type == PLAYER)
		2895	{
		2896	esrv_send_item (orig, op);
1791	}	2897	}
		2898	*type = CFAPI_POBJECT;
		2899	break;
		2900	}
		2901
		2902	va_end (args);
		2903
		2904	return rv;
		2905	}
		2906
		2907	void *
		2908	cfapi_object_split (int *type, ...)
		2909	{
		2910	va_list args;
		2911
		2912	int nr;
		2913	object *op;
		2914
		2915	va_start (args, type);
		2916
		2917	op = va_arg (args, object *);
		2918	nr = va_arg (args, int);
		2919
		2920	va_end (args);
		2921	*type = CFAPI_POBJECT;
		2922	return get_split_ob (op, nr);
		2923	}
		2924
		2925	void *
		2926	cfapi_object_merge (int *type, ...)
		2927	{
		2928	va_list args;
		2929	object *op;
		2930	object *op2;
		2931
		2932	va_start (args, type);
		2933
		2934	op = va_arg (args, object *);
		2935	op2 = va_arg (args, object *);
		2936
		2937	va_end (args);
		2938
		2939
		2940	*type = CFAPI_POBJECT;
		2941	return merge_ob (op, op2);
		2942	}
		2943
		2944	void *
		2945	cfapi_object_distance (int *type, ...)
		2946	{
		2947	va_list args;
		2948	static int rv;
		2949	object *op;
		2950	object *op2;
		2951
		2952	va_start (args, type);
		2953
		2954	op = va_arg (args, object *);
		2955	op2 = va_arg (args, object *);
		2956
		2957	va_end (args);
		2958
		2959	*type = CFAPI_INT;
		2960	rv = distance (op, op2);
		2961	return &rv;
		2962	}
		2963
		2964	void *
		2965	cfapi_object_update (int *type, ...)
		2966	{
		2967	va_list args;
		2968	int action;
		2969	object *op;
		2970
		2971	va_start (args, type);
		2972
		2973	op = va_arg (args, object *);
		2974	action = va_arg (args, int);
		2975
		2976	va_end (args);
		2977
		2978	update_object (op, action);
		2979	*type = CFAPI_NONE;
		2980	return NULL;
		2981	}
		2982
		2983	void *
		2984	cfapi_object_clear (int *type, ...)
		2985	{
		2986	va_list args;
		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	}
		2999
		3000	void *
		3001	cfapi_object_reset (int *type, ...)
		3002	{
		3003	abort ();
		3004	}
		3005
		3006	void *
		3007	cfapi_object_check_inventory (int *type, ...)
		3008	{
		3009	va_list args;
		3010	object *op;
		3011	object *op2;
		3012	int checktype;
		3013	object *ret = NULL;
		3014
		3015	va_start (args, type);
		3016
		3017	op = va_arg (args, object *);
		3018	op2 = va_arg (args, object *);
		3019	checktype = va_arg (args, int);
		3020
		3021	if (checktype == 0)
		3022	{
		3023	check_inv (op, op2);
		3024	*type = CFAPI_NONE;
		3025	}
		3026	else
		3027	{
		3028	ret = check_inv_recursive (op, op2);
		3029	*type = CFAPI_POBJECT;
		3030	}
		3031
		3032	va_end (args);
		3033
		3034	return ret;
		3035	}
		3036
		3037	void *
		3038	cfapi_object_clean_object (int *type, ...)
		3039	{
		3040	va_list args;
		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	}
		3051
		3052	void *
		3053	cfapi_object_on_same_map (int *type, ...)
		3054	{
		3055	va_list args;
		3056	static int rv;
		3057	object *op1;
		3058	object *op2;
		3059
		3060	va_start (args, type);
		3061	op1 = va_arg (args, object *);
		3062	op2 = va_arg (args, object *);
		3063
		3064	rv = on_same_map (op1, op2);
		3065	va_end (args);
		3066
		3067	*type = CFAPI_INT;
		3068	return &rv;
		3069	}
		3070
		3071	void *
		3072	cfapi_object_spring_trap (int *type, ...)
		3073	{
		3074	object *trap;
		3075	object *victim;
		3076	va_list args;
		3077
		3078	va_start (args, type);
		3079	trap = va_arg (args, object *);
		3080	victim = va_arg (args, object *);
		3081
		3082	va_end (args);
		3083
		3084	spring_trap (trap, victim);
		3085	*type = CFAPI_NONE;
		3086	return NULL;
		3087	}
		3088
		3089	void *
		3090	cfapi_object_check_trigger (int *type, ...)
		3091	{
		3092	object *op;
		3093	object *cause;
		3094	va_list args;
		3095	static int rv;
		3096
		3097	va_start (args, type);
		3098	op = va_arg (args, object *);
		3099	cause = va_arg (args, object *);
		3100
		3101	va_end (args);
		3102
		3103	rv = check_trigger (op, cause);
		3104	*type = CFAPI_INT;
		3105	return &rv;
		3106	}
		3107
		3108	void *
		3109	cfapi_object_query_cost (int *type, ...)
		3110	{
		3111	object *op;
		3112	object *who;
		3113	int flags;
		3114	va_list args;
		3115	static int rv;
		3116
		3117	va_start (args, type);
		3118	op = va_arg (args, object *);
		3119	who = va_arg (args, object *);
		3120	flags = va_arg (args, int);
		3121
		3122	va_end (args);
		3123
		3124	rv = query_cost (op, who, flags);
		3125	*type = CFAPI_INT;
		3126	return &rv;
		3127	}
		3128
		3129	void *
		3130	cfapi_object_query_money (int *type, ...)
		3131	{
		3132	object *op;
		3133	va_list args;
		3134	static int rv;
		3135
		3136	va_start (args, type);
		3137	op = va_arg (args, object *);
		3138
		3139	va_end (args);
		3140
		3141	rv = query_money (op);
		3142	*type = CFAPI_INT;
		3143	return &rv;
		3144	}
		3145
		3146	void *
		3147	cfapi_object_cast (int *type, ...)
		3148	{
		3149	object *op;
		3150	object *sp;
		3151	int dir;
		3152	char *str;
		3153	object *caster;
		3154	va_list args;
		3155	static int rv;
		3156
		3157	va_start (args, type);
		3158	op = va_arg (args, object *);
		3159	caster = va_arg (args, object *);
		3160	dir = va_arg (args, int);
		3161	sp = va_arg (args, object *);
		3162	str = va_arg (args, char *);
		3163
		3164	va_end (args);
		3165	rv = cast_spell (op, caster, dir, sp, str);
		3166	*type = CFAPI_INT;
		3167	return &rv;
		3168	}
		3169
		3170	void *
		3171	cfapi_object_learn_spell (int *type, ...)
		3172	{
		3173	object *op;
		3174	object *sp;
		3175	int prayer;
		3176	va_list args;
		3177
		3178	va_start (args, type);
		3179	op = va_arg (args, object *);
		3180	sp = va_arg (args, object *);
		3181	prayer = va_arg (args, int);
		3182
		3183	va_end (args);
		3184	do_learn_spell (op, sp, prayer);
		3185	*type = CFAPI_NONE;
		3186	return NULL;
		3187	}
		3188
		3189	void *
		3190	cfapi_object_forget_spell (int *type, ...)
		3191	{
		3192	object *op;
		3193	object *sp;
		3194	va_list args;
		3195
		3196	va_start (args, type);
		3197	op = va_arg (args, object *);
		3198	sp = va_arg (args, object *);
		3199
		3200	va_end (args);
		3201	do_forget_spell (op, query_name (sp));
		3202	*type = CFAPI_NONE;
		3203	return NULL;
		3204	}
		3205
		3206	void *
		3207	cfapi_object_check_spell (int *type, ...)
		3208	{
		3209	object *op;
		3210	char *spellname;
		3211	va_list args;
		3212	object *rv;
		3213
		3214	va_start (args, type);
		3215	op = va_arg (args, object *);
		3216	spellname = va_arg (args, char *);
		3217
		3218	va_end (args);
		3219	rv = check_spell_known (op, spellname);
		3220	*type = CFAPI_POBJECT;
		3221	return rv;
		3222	}
		3223
		3224	void *
		3225	cfapi_object_pay_amount (int *type, ...)
		3226	{
		3227	object *op;
		3228	uint64 amount;
		3229	va_list args;
		3230	static int rv;
		3231
		3232	va_start (args, type);
		3233	op = va_arg (args, object *);
		3234
		3235	amount = va_arg (args, uint64);
		3236	va_end (args);
		3237
		3238	rv = pay_for_amount (amount, op);
		3239	*type = CFAPI_INT;
		3240	return &rv;
		3241	}
		3242
		3243	void *
		3244	cfapi_object_pay_item (int *type, ...)
		3245	{
		3246	object *op;
		3247	object *tobuy;
		3248
		3249	va_list args;
		3250	static int rv;
		3251
		3252	va_start (args, type);
		3253	tobuy = va_arg (args, object *);
		3254	op = va_arg (args, object *);
		3255
		3256	va_end (args);
		3257
		3258	rv = pay_for_item (tobuy, op);
		3259	*type = CFAPI_INT;
		3260	return &rv;
		3261	}
		3262
		3263	void *
		3264	cfapi_object_transfer (int *type, ...)
		3265	{
		3266	object *op;
		3267	object *originator;
		3268	int x, y, randompos, ttype;
		3269	va_list args;
		3270	static int rv = 0;
		3271	mapstruct *map;
		3272
		3273	va_start (args, type);
		3274	op = va_arg (args, object *);
		3275	ttype = va_arg (args, int);
		3276
		3277	switch (ttype)
		3278	{
		3279	case 0:
		3280	x = va_arg (args, int);
		3281	y = va_arg (args, int);
		3282	randompos = va_arg (args, int);
		3283	originator = va_arg (args, object *);
		3284
		3285	va_end (args);
		3286
		3287	rv = transfer_ob (op, x, y, randompos, originator);
1792	*type = CFAPI_INT;	3288	*type = CFAPI_INT;
		3289	return &rv;
1793	break;	3290	break;
1794		3291
1795	case CFAPI_OBJECT_PROP_PICKABLE:	3292	case 1:
		3293	x = va_arg (args, int);
		3294	y = va_arg (args, int);
		3295	map = va_arg (args, mapstruct *);
		3296
		3297	va_end (args);
		3298	if (x < 0 || y < 0)
1796	{	3299	{
1797	object* op2;	3300	x = map->enter_x;
1798	rv = 0;	3301	y = map->enter_y;
1799	op2 = va_arg(args, object*);
1800	ri = can_pick(op2, op);
1801	rv = &ri;
1802	}	3302	}
1803	*type = CFAPI_INT;
1804	break;
1805		3303
1806	case CFAPI_OBJECT_PROP_FLAGS:
1807	{
1808	int fl;
1809	ri = 0;
1810	fl = va_arg(args, int);
1811	ri = QUERY_FLAG(op, fl);
1812	rv = &ri;
1813	}
1814	*type = CFAPI_INT;
1815	break;
1816
1817	case CFAPI_OBJECT_PROP_STR:
1818	ri = op->stats.Str;
1819	rv = &ri;
1820	*type = CFAPI_INT;
1821	break;
1822
1823	case CFAPI_OBJECT_PROP_DEX:
1824	ri = op->stats.Dex;
1825	rv = &ri;
1826	*type = CFAPI_INT;
1827	break;
1828
1829	case CFAPI_OBJECT_PROP_CON:
1830	ri = op->stats.Con;
1831	rv = &ri;
1832	*type = CFAPI_INT;
1833	break;
1834
1835	case CFAPI_OBJECT_PROP_WIS:
1836	ri = op->stats.Wis;
1837	rv = &ri;
1838	*type = CFAPI_INT;
1839	break;
1840
1841	case CFAPI_OBJECT_PROP_INT:
1842	ri = op->stats.Int;
1843	rv = &ri;
1844	*type = CFAPI_INT;
1845	break;
1846
1847	case CFAPI_OBJECT_PROP_POW:
1848	ri = op->stats.Pow;
1849	rv = &ri;
1850	*type = CFAPI_INT;
1851	break;
1852
1853	case CFAPI_OBJECT_PROP_CHA:
1854	ri = op->stats.Cha;
1855	rv = &ri;
1856	*type = CFAPI_INT;
1857	break;
1858
1859	case CFAPI_OBJECT_PROP_WC:
1860	ri = op->stats.wc;
1861	rv = &ri;
1862	*type = CFAPI_INT;
1863	break;
1864
1865	case CFAPI_OBJECT_PROP_AC:
1866	ri = op->stats.ac;
1867	rv = &ri;
1868	*type = CFAPI_INT;
1869	break;
1870
1871	case CFAPI_OBJECT_PROP_HP:
1872	ri = op->stats.hp;
1873	rv = &ri;
1874	*type = CFAPI_INT;
1875	break;
1876
1877	case CFAPI_OBJECT_PROP_SP:
1878	ri = op->stats.sp;
1879	rv = &ri;
1880	*type = CFAPI_INT;
1881	break;
1882
1883	case CFAPI_OBJECT_PROP_GP:
1884	ri = op->stats.grace;
1885	rv = &ri;
1886	*type = CFAPI_INT;
1887	break;
1888
1889	case CFAPI_OBJECT_PROP_FP:
1890	ri = op->stats.food;
1891	rv = &ri;
1892	*type = CFAPI_INT;
1893	break;
1894
1895	case CFAPI_OBJECT_PROP_MAXHP:
1896	ri = op->stats.maxhp;
1897	rv = &ri;
1898	*type = CFAPI_INT;
1899	break;
1900
1901	case CFAPI_OBJECT_PROP_MAXSP:
1902	ri = op->stats.maxsp;
1903	rv = &ri;
1904	*type = CFAPI_INT;
1905	break;
1906
1907	case CFAPI_OBJECT_PROP_MAXGP:
1908	ri = op->stats.maxgrace;
1909	rv = &ri;
1910	*type = CFAPI_INT;
1911	break;
1912
1913	case CFAPI_OBJECT_PROP_DAM:
1914	ri = op->stats.dam;
1915	rv = &ri;
1916	*type = CFAPI_INT;
1917	break;
1918
1919	case CFAPI_OBJECT_PROP_GOD:
1920	rv = (char*)determine_god(op);
1921	*type = CFAPI_STRING;
1922	break;
1923
1924	case CFAPI_OBJECT_PROP_ARCH_NAME:
1925	rv = (char*)op->arch->name;
1926	*type = CFAPI_STRING;
1927	break;
1928
1929	case CFAPI_OBJECT_PROP_INVISIBLE:
1930	ri = op->invisible;
1931	rv = &ri;
1932	*type = CFAPI_INT;
1933	break;
1934
1935	case CFAPI_OBJECT_PROP_FACE:
1936	ri = op->animation_id;
1937	rv = &ri;
1938	*type = CFAPI_INT;
1939	break;
1940
1941	case CFAPI_PLAYER_PROP_IP:
1942	rv = op->contr->socket.host;
1943	*type = CFAPI_STRING;
1944	break;
1945
1946	case CFAPI_PLAYER_PROP_MARKED_ITEM:
1947	rv = find_marked_object(op);
1948	*type = CFAPI_POBJECT;
1949	break;
1950
1951	case CFAPI_PLAYER_PROP_PARTY:
1952	rv = (op->contr ? op->contr->party : NULL);
1953	*type = CFAPI_PPARTY;
1954	break;
1955	default:
1956	*type = CFAPI_NONE;
1957	break;
1958	}
1959	}
1960	va_end(args);
1961	return rv;
1962	}
1963
1964	void* cfapi_object_set_property(int* type, ...)
1965	{
1966	va_list args;
1967	int iarg;
1968	long larg;
1969	char* sarg;
1970	double darg;
1971	object* oparg;
1972	object* op;
1973	int property;
1974	void* rv;
1975	partylist* partyarg;
1976	va_start(args, type);
1977
1978	op = va_arg(args, object*);
1979	property = va_arg(args, int);
1980	rv = NULL;
1981
1982	if (op != NULL && (!op->arch || (op != &op->arch->clone))) {
1983	switch (property)
1984	{
1985	case CFAPI_OBJECT_PROP_NAME:
1986	sarg = va_arg(args, char*);
1987	FREE_AND_COPY(op->name, sarg);
1988	send_changed_object(op);
1989	break;
1990
1991	case CFAPI_OBJECT_PROP_NAME_PLURAL:
1992	sarg = va_arg(args, char*);
1993	FREE_AND_COPY(op->name_pl, sarg);
1994	send_changed_object(op);
1995	break;
1996
1997	case CFAPI_OBJECT_PROP_TITLE:
1998	sarg = va_arg(args, char*);
1999	FREE_AND_COPY(op->title, sarg);
2000	break;
2001
2002	case CFAPI_OBJECT_PROP_RACE:
2003	sarg = va_arg(args, char*);
2004	FREE_AND_COPY(op->race, sarg);
2005	break;
2006
2007	case CFAPI_OBJECT_PROP_SLAYING:
2008	sarg = va_arg(args, char*);
2009	FREE_AND_COPY(op->slaying, sarg);
2010	break;
2011
2012	case CFAPI_OBJECT_PROP_SKILL:
2013	sarg = va_arg(args, char*);
2014	FREE_AND_COPY(op->skill, sarg);
2015	break;
2016
2017	case CFAPI_OBJECT_PROP_MESSAGE:
2018	sarg = va_arg(args, char*);
2019	FREE_AND_COPY(op->msg, sarg);
2020	break;
2021
2022	case CFAPI_OBJECT_PROP_LORE:
2023	sarg = va_arg(args, char*);
2024	FREE_AND_COPY(op->lore, sarg);
2025	break;
2026
2027	case CFAPI_OBJECT_PROP_SPEED:
2028	darg = va_arg(args, double);
2029	op->speed = darg;
2030	break;
2031
2032	case CFAPI_OBJECT_PROP_SPEED_LEFT:
2033	darg = va_arg(args, double);
2034	op->speed_left = darg;
2035	break;
2036
2037	case CFAPI_OBJECT_PROP_NROF:
2038	iarg = va_arg(args, int);
2039	if (iarg < 0)
2040	iarg = 0;
2041	if (op->nrof > (uint32)iarg)
2042	decrease_ob_nr(op, op->nrof-iarg);
2043	else if (op->nrof < (uint32)iarg) {
2044	object* tmp;
2045	player *pl;
2046	op->nrof = iarg;
2047	if (op->env != NULL) {
2048	tmp = is_player_inv(op->env);
2049	if (!tmp) {
2050	for (pl = first_player; pl; pl = pl->next)
2051	if (pl->ob->container == op->env)
2052	break;
2053	if (pl)
2054	tmp = pl->ob;
2055	else
2056	tmp = NULL;
2057	}
2058	else {
2059	sum_weight(tmp);
2060	fix_player(tmp);
2061	}
2062	if (tmp)
2063	esrv_send_item(tmp, op);
2064	}
2065	else
2066	{
2067	object *above = op->above;
2068
2069	for (tmp = above; tmp != NULL; tmp = tmp->above)
2070	if (tmp->type == PLAYER)
2071	esrv_send_item(tmp, op);
2072	}
2073	}
2074	break;
2075
2076	case CFAPI_OBJECT_PROP_DIRECTION:
2077	iarg = va_arg(args, int);
2078	op->direction = iarg;
2079	break;
2080
2081	case CFAPI_OBJECT_PROP_FACING:
2082	iarg = va_arg(args, int);
2083	op->facing = iarg;
2084	break;
2085
2086	case CFAPI_OBJECT_PROP_RESIST:
2087	{
2088	int iargbis = va_arg(args, int);
2089	iarg = va_arg(args, int);
2090	op->resist[iargbis] = iarg;
2091	}
2092	break;
2093
2094	case CFAPI_OBJECT_PROP_ATTACK_TYPE:
2095	iarg = va_arg(args, int);
2096	op->attacktype = iarg;
2097	break;
2098
2099	case CFAPI_OBJECT_PROP_PATH_ATTUNED:
2100	iarg = va_arg(args, int);
2101	op->path_attuned = iarg;
2102	break;
2103
2104	case CFAPI_OBJECT_PROP_PATH_REPELLED:
2105	iarg = va_arg(args, int);
2106	op->path_repelled = iarg;
2107	break;
2108
2109	case CFAPI_OBJECT_PROP_PATH_DENIED:
2110	iarg = va_arg(args, int);
2111	op->path_denied = iarg;
2112	break;
2113
2114	case CFAPI_OBJECT_PROP_MATERIAL:
2115	iarg = va_arg(args, int);
2116	op->material = iarg;
2117	break;
2118
2119	case CFAPI_OBJECT_PROP_MATERIAL_NAME:
2120	break;
2121
2122	case CFAPI_OBJECT_PROP_MAGIC:
2123	iarg = va_arg(args, int);
2124	op->magic = iarg;
2125	break;
2126
2127	case CFAPI_OBJECT_PROP_VALUE:
2128	iarg = va_arg(args, int);
2129	op->value = iarg;
2130	break;
2131
2132	case CFAPI_OBJECT_PROP_LEVEL:
2133	iarg = va_arg(args, int);
2134	op->level = iarg;
2135	break;
2136
2137	case CFAPI_OBJECT_PROP_LAST_HEAL:
2138	iarg = va_arg(args, int);
2139	op->last_heal = iarg;
2140	break;
2141
2142	case CFAPI_OBJECT_PROP_LAST_SP:
2143	iarg = va_arg(args, int);
2144	op->last_sp = iarg;
2145	break;
2146
2147	case CFAPI_OBJECT_PROP_LAST_GRACE:
2148	iarg = va_arg(args, int);
2149	op->last_grace = iarg;
2150	break;
2151
2152	case CFAPI_OBJECT_PROP_LAST_EAT:
2153	iarg = va_arg(args, int);
2154	op->last_eat = iarg;
2155	break;
2156
2157	case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
2158	iarg = va_arg(args, int);
2159	op->invisible = iarg;
2160	break;
2161
2162	case CFAPI_OBJECT_PROP_PICK_UP:
2163	iarg = va_arg(args, int);
2164	op->pick_up = iarg;
2165	break;
2166
2167	case CFAPI_OBJECT_PROP_ITEM_POWER:
2168	iarg = va_arg(args, int);
2169	op->item_power = iarg;
2170	break;
2171
2172	case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
2173	iarg = va_arg(args, int);
2174	op->gen_sp_armour = iarg;
2175	break;
2176
2177	case CFAPI_OBJECT_PROP_WEIGHT:
2178	iarg = va_arg(args, int);
2179	if (op->weight != iarg) {
2180	object* tmp;
2181	player *pl;
2182	op->weight = iarg;
2183	if (op->env != NULL) {
2184	tmp = is_player_inv(op->env);
2185	if (!tmp) {
2186	for (pl = first_player; pl; pl = pl->next)
2187	if (pl->ob->container == op->env)
2188	break;
2189	if (pl)
2190	tmp = pl->ob;
2191	else
2192	tmp = NULL;
2193	} else {
2194	sum_weight(tmp);
2195	fix_player(tmp);
2196	}
2197	if (tmp)
2198	esrv_send_item(tmp, op);
2199	}
2200	else
2201	{
2202	object *above = op->above;
2203
2204	for (tmp = above; tmp != NULL; tmp = tmp->above)
2205	if (tmp->type == PLAYER)
2206	esrv_send_item(tmp, op);
2207	}
2208	}
2209	break;
2210
2211	case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
2212	iarg = va_arg(args, int);
2213	op->weight_limit = iarg;
2214	break;
2215
2216	case CFAPI_OBJECT_PROP_GLOW_RADIUS:
2217	iarg = va_arg(args, int);
2218	op->glow_radius = iarg;
2219	break;
2220
2221	case CFAPI_OBJECT_PROP_PERM_EXP:
2222	larg = va_arg(args, long);
2223	op->perm_exp = larg;
2224	break;
2225
2226	case CFAPI_OBJECT_PROP_ENEMY:
2227	oparg = va_arg(args, object*);
2228	op->enemy = oparg;
2229	break;
2230
2231	case CFAPI_OBJECT_PROP_RUN_AWAY:
2232	iarg = va_arg(args, int);
2233	op->run_away = iarg;
2234	break;
2235
2236	case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
2237	oparg = va_arg(args, object*);
2238	op->chosen_skill = oparg;
2239	break;
2240
2241	case CFAPI_OBJECT_PROP_HIDDEN:
2242	iarg = va_arg(args, int);
2243	op->hide = iarg;
2244	break;
2245
2246	case CFAPI_OBJECT_PROP_MOVE_STATUS:
2247	iarg = va_arg(args, int);
2248	op->move_status = iarg;
2249	break;
2250
2251	case CFAPI_OBJECT_PROP_MOVE_TYPE:
2252	iarg = va_arg(args, int);
2253	op->attack_movement = iarg;
2254	break;
2255
2256	case CFAPI_OBJECT_PROP_SPELL_ITEM:
2257	oparg = va_arg(args, object*);
2258	op->spellitem = oparg;
2259	break;
2260
2261	case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
2262	darg = va_arg(args, double);
2263	op->expmul = darg;
2264	break;
2265
2266	case CFAPI_OBJECT_PROP_CUSTOM_NAME:
2267	sarg = va_arg(args, char*);
2268	FREE_AND_COPY(op->custom_name, sarg);
2269	send_changed_object(op);
2270	break;
2271
2272	case CFAPI_OBJECT_PROP_ANIM_SPEED:
2273	iarg = va_arg(args, int);
2274	op->anim_speed = iarg;
2275	break;
2276
2277	case CFAPI_OBJECT_PROP_FRIENDLY:
2278	iarg = va_arg(args, int);
2279	if (iarg == 1 && is_friendly(op) == 0)
2280	add_friendly_object(op);
2281	else if (iarg == 0 && is_friendly(op) == 1)
2282	remove_friendly_object(op);
2283	break;
2284
2285	case CFAPI_OBJECT_PROP_LUCK:
2286	iarg = va_arg(args, int);
2287	op->stats.luck = iarg;
2288	break;
2289
2290	case CFAPI_OBJECT_PROP_EXP:
2291	{
2292	char* skillname;
2293
2294	larg = va_arg(args, long);
2295	skillname = va_arg(args, char*);
2296	iarg = va_arg(args, int);
2297	change_exp(op, larg, skillname, iarg);
2298	}
2299	break;
2300
2301	case CFAPI_OBJECT_PROP_OWNER:
2302	oparg = va_arg(args, object*);
2303	set_owner(op, oparg);
2304	break;
2305
2306	case CFAPI_OBJECT_PROP_CHEATER:
2307	set_cheat(op);
2308	break;
2309
2310	case CFAPI_OBJECT_PROP_FLAGS:
2311	{
2312	int iargbis;
2313	iarg = va_arg(args, int);
2314	iargbis = va_arg(args, int);
2315	if (iargbis == 1)
2316	SET_FLAG(op, iarg);
2317	else
2318	CLEAR_FLAG(op, iarg);
2319	}
2320	break;
2321
2322	case CFAPI_OBJECT_PROP_STR:
2323	iarg = va_arg(args, int);
2324	op->stats.Str=iarg;
2325	break;
2326
2327	case CFAPI_OBJECT_PROP_DEX:
2328	iarg = va_arg(args, int);
2329	op->stats.Dex=iarg;
2330	break;
2331
2332	case CFAPI_OBJECT_PROP_CON:
2333	iarg = va_arg(args, int);
2334	op->stats.Con=iarg;
2335	break;
2336
2337	case CFAPI_OBJECT_PROP_WIS:
2338	iarg = va_arg(args, int);
2339	op->stats.Wis=iarg;
2340	break;
2341
2342	case CFAPI_OBJECT_PROP_INT:
2343	iarg = va_arg(args, int);
2344	op->stats.Int=iarg;
2345	break;
2346
2347	case CFAPI_OBJECT_PROP_POW:
2348	iarg = va_arg(args, int);
2349	op->stats.Pow=iarg;
2350	break;
2351
2352	case CFAPI_OBJECT_PROP_CHA:
2353	iarg = va_arg(args, int);
2354	op->stats.Cha=iarg;
2355	break;
2356
2357	case CFAPI_OBJECT_PROP_WC:
2358	iarg = va_arg(args, int);
2359	op->stats.wc=iarg;
2360	break;
2361
2362	case CFAPI_OBJECT_PROP_AC:
2363	iarg = va_arg(args, int);
2364	op->stats.ac=iarg;
2365	break;
2366
2367	case CFAPI_OBJECT_PROP_HP:
2368	iarg = va_arg(args, int);
2369	op->stats.hp=iarg;
2370	break;
2371
2372	case CFAPI_OBJECT_PROP_SP:
2373	iarg = va_arg(args, int);
2374	op->stats.sp=iarg;
2375	break;
2376
2377	case CFAPI_OBJECT_PROP_GP:
2378	iarg = va_arg(args, int);
2379	op->stats.grace=iarg;
2380	break;
2381
2382	case CFAPI_OBJECT_PROP_FP:
2383	iarg = va_arg(args, int);
2384	op->stats.food=iarg;
2385	break;
2386
2387	case CFAPI_OBJECT_PROP_MAXHP:
2388	iarg = va_arg(args, int);
2389	op->stats.maxhp=iarg;
2390	break;
2391
2392	case CFAPI_OBJECT_PROP_MAXSP:
2393	iarg = va_arg(args, int);
2394	op->stats.maxsp=iarg;
2395	break;
2396
2397	case CFAPI_OBJECT_PROP_MAXGP:
2398	iarg = va_arg(args, int);
2399	op->stats.maxgrace=iarg;
2400	break;
2401
2402	case CFAPI_OBJECT_PROP_DAM:
2403	iarg = va_arg(args, int);
2404	op->stats.dam=iarg;
2405	break;
2406
2407	case CFAPI_OBJECT_PROP_FACE:
2408	iarg = va_arg(args, int);
2409	op->animation_id = iarg;
2410	update_object(op, UP_OBJ_FACE);
2411	break;
2412
2413	case CFAPI_OBJECT_ANIMATION:
2414	iarg = va_arg(args, int);
2415	if (iarg != -1) {
2416	SET_ANIMATION(op, iarg);
2417	}
2418	update_object(op, UP_OBJ_FACE);
2419	break;
2420
2421	case CFAPI_PLAYER_PROP_MARKED_ITEM:
2422	if (op->contr) {
2423	oparg = va_arg(args, object*);
2424	op->contr->mark = oparg;
2425	if (oparg)
2426	op->contr->mark_count = oparg->count;
2427	}
2428	break;
2429
2430	case CFAPI_PLAYER_PROP_PARTY:
2431	if (op->contr) {
2432	partyarg = va_arg(args, partylist*);
2433	op->contr->party = partyarg;
2434	}
2435	break;
2436
2437	default:
2438	*type = CFAPI_NONE;
2439	break;
2440	}
2441	}
2442	va_end(args);
2443
2444	*type = CFAPI_NONE;
2445	return NULL;
2446	}
2447
2448	void* cfapi_object_apply_below(int* type, ...)
2449	{
2450	va_list args;
2451	object* applier;
2452
2453	va_start(args, type);
2454
2455	applier = va_arg(args, object*);
2456
2457	va_end(args);
2458
2459	player_apply_below(applier);
2460	*type = CFAPI_NONE;
2461	return NULL;
2462	}
2463
2464	void* cfapi_object_apply(int* type, ...)
2465	{
2466	va_list args;
2467	object* applied;
2468	object* applier;
2469	int aflags;
2470	static int rv;
2471
2472	va_start(args, type);
2473
2474	applied = va_arg(args, object*);
2475	applier = va_arg(args, object*);
2476	aflags = va_arg(args, int);
2477
2478	va_end(args);
2479
2480	*type = CFAPI_INT;
2481	rv = manual_apply(applier, applied, aflags);
2482	return &rv;
2483	}
2484	void* cfapi_object_identify(int* type, ...)
2485	{
2486	va_list args;
2487	object* op;
2488
2489	va_start(args, type);
2490
2491	op = va_arg(args, object*);
2492
2493	va_end(args);
2494
2495	identify(op);
2496	*type = CFAPI_NONE;
2497	return NULL;
2498	}
2499	void* cfapi_object_describe(int* type, ...)
2500	{
2501	va_list args;
2502	object* op;
2503	object* owner;
2504
2505	va_start(args, type);
2506
2507	op = va_arg(args, object*);
2508	owner = va_arg(args, object*);
2509	va_end(args);
2510
2511	*type = CFAPI_STRING;
2512	return describe_item(op, owner);
2513	}
2514	void* cfapi_object_drain(int* type, ...)
2515	{
2516	va_list args;
2517
2518	object* op;
2519	int ds;
2520
2521	va_start(args, type);
2522
2523	op = va_arg(args, object*);
2524	ds = va_arg(args, int);
2525
2526	va_end(args);
2527
2528	drain_specific_stat(op, ds);
2529
2530	*type = CFAPI_NONE;
2531	return NULL;
2532	}
2533	void* cfapi_object_fix(int* type, ...)
2534	{
2535	va_list args;
2536	object* op;
2537
2538	va_start(args, type);
2539
2540	op = va_arg(args, object*);
2541
2542	va_end(args);
2543
2544	fix_player(op);
2545
2546	*type = CFAPI_NONE;
2547	return NULL;
2548	}
2549	void* cfapi_object_give_skill(int* type, ...)
2550	{
2551	va_list args;
2552
2553	object* op;
2554	char* skillname;
2555
2556	va_start(args, type);
2557
2558	op = va_arg(args, object*);
2559	skillname = va_arg(args, char*);
2560
2561	va_end(args);
2562
2563	*type = CFAPI_POBJECT;
2564	return give_skill_by_name(op, skillname);
2565	}
2566	void* cfapi_object_transmute(int* type, ...)
2567	{
2568	va_list args;
2569
2570	object* op;
2571	object* chg;
2572
2573	va_start(args, type);
2574
2575	op = va_arg(args, object*);
2576	chg = va_arg(args, object*);
2577
2578	va_end(args);
2579
2580	transmute_materialname(op, chg);
2581	*type = CFAPI_NONE;
2582	return NULL;
2583	}
2584	void* cfapi_object_remove(int* type, ...)
2585	{
2586	va_list args;
2587	object* op;
2588
2589	va_start(args, type);
2590
2591	op = va_arg(args, object*);
2592
2593	va_end(args);
2594
2595	send_removed_object(op);
2596	remove_ob(op);
2597	*type = CFAPI_NONE;
2598	return NULL;
2599	}
2600	void* cfapi_object_delete(int* type, ...)
2601	{
2602	va_list args;
2603	object* op;
2604
2605	va_start(args, type);
2606
2607	op = va_arg(args, object*);
2608
2609	va_end(args);
2610
2611	free_object(op);
2612
2613	*type = CFAPI_NONE;
2614	return NULL;
2615	}
2616	void* cfapi_object_clone(int* type, ...)
2617	{
2618	va_list args;
2619	object* op;
2620	int kind;
2621
2622	va_start(args, type);
2623
2624	op = va_arg(args, object*);
2625	kind = va_arg(args, int);
2626
2627	va_end(args);
2628
2629	if (kind == 0) {
2630	*type = CFAPI_POBJECT;
2631	return object_create_clone(op);
2632	} else {
2633	object* tmp;
2634	tmp = get_object();
2635	copy_object(op, tmp);
2636	*type = CFAPI_POBJECT;
2637	return tmp;
2638	}
2639	}
2640	void* cfapi_object_find(int* type, ...)
2641	{
2642	va_list args;
2643	int ftype;
2644	void* rv;
2645	int ival;
2646	int ival2;
2647	char* sval;
2648	object* op;
2649	va_start(args, type);
2650
2651	*type = CFAPI_POBJECT;
2652	ftype = va_arg(args, int);
2653	switch (ftype)
2654	{
2655	case 0:
2656	ival = va_arg(args, int);
2657	rv = find_object(ival);
2658	break;
2659
2660	case 1:
2661	sval = va_arg(args, char*);
2662	rv = find_object_name(sval);
2663	break;
2664
2665	case 2:
2666	op = va_arg(args, object*);
2667	ival = va_arg(args, int);
2668	ival2 = va_arg(args, int);
2669	rv = find_obj_by_type_subtype(op, ival, ival2);
2670	break;
2671
2672	case 3:
2673	op = va_arg(args, object*);
2674	rv = is_player_inv(op);
2675	break;
2676
2677	default:
2678	rv = NULL;
2679	*type = CFAPI_NONE;
2680	break;
2681	}
2682
2683	va_end(args);
2684
2685	return rv;
2686	}
2687	void* cfapi_object_create(int* type, ...)
2688	{
2689	va_list args;
2690	int ival;
2691	va_start(args, type);
2692	ival = va_arg(args, int);
2693
2694	*type = CFAPI_POBJECT;
2695	switch (ival)
2696	{
2697	case 0:
2698	va_end(args);
2699	return get_object();
2700	break;
2701
2702	case 1: /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */
2703	{
2704	char* sval;
2705	object* op;
2706	sval = va_arg(args, char*);
2707
2708	op = get_archetype_by_object_name(sval);
2709
2710	if (strncmp(query_name(op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) {
2711	free_object(op);
2712	/* Try with archetype names... */
2713	op = get_archetype(sval);
2714	if (strncmp(query_name(op), ARCH_SINGULARITY, ARCH_SINGULARITY_LEN) == 0) {
2715	free_object(op);
2716	*type = CFAPI_NONE;
2717	va_end(args);
2718	return NULL;
2719	}
2720	}
2721	va_end(args);
2722	return op;
2723	}
2724	break;
2725
2726	default:
2727	*type = CFAPI_NONE;
2728	va_end(args);
2729	return NULL;
2730	break;
2731	}
2732	}
2733	void* cfapi_object_insert(int* type, ...)
2734	{
2735	va_list args;
2736	object* op;
2737	object* orig;
2738	mapstruct* map;
2739	int flag, x, y;
2740	int itype;
2741	char* arch_string;
2742	void* rv = NULL;
2743
2744	va_start(args, type);
2745
2746	op = va_arg(args, object*);
2747	itype = va_arg(args, int);
2748
2749	switch (itype) {
2750	case 0:
2751	map = va_arg(args, mapstruct*);
2752	orig = va_arg(args, object*);
2753	flag = va_arg(args, int);
2754	x = va_arg(args, int);
2755	y = va_arg(args, int);
2756	rv = insert_ob_in_map_at(op, map, orig, flag, x, y);
2757	*type = CFAPI_POBJECT;
2758	break;
2759
2760	case 1:
2761	map = va_arg(args, mapstruct*);
2762	orig = va_arg(args, object*);
2763	flag = va_arg(args, int);
2764	rv = insert_ob_in_map(op, map, orig, flag);
2765	*type = CFAPI_POBJECT;
2766	break;
2767
2768	case 2:
2769	arch_string = va_arg(args, char*);
2770	replace_insert_ob_in_map(arch_string, op);
2771	*type = CFAPI_NONE;
2772	break;
2773
2774	case 3:
2775	orig = va_arg(args, object*);
2776	rv = insert_ob_in_ob(op, orig);
2777	if (orig->type == PLAYER) {
2778	esrv_send_item(orig, op);
2779	}
2780	*type = CFAPI_POBJECT;
2781	break;
2782	}
2783
2784	va_end(args);
2785
2786	return rv;
2787	}
2788	void* cfapi_object_split(int* type, ...)
2789	{
2790	va_list args;
2791
2792	int nr;
2793	object* op;
2794	va_start(args, type);
2795
2796	op = va_arg(args, object*);
2797	nr = va_arg(args, int);
2798
2799	va_end(args);
2800	*type = CFAPI_POBJECT;
2801	return get_split_ob(op, nr);
2802	}
2803	void* cfapi_object_merge(int* type, ...)
2804	{
2805	va_list args;
2806	object* op;
2807	object* op2;
2808
2809	va_start(args, type);
2810
2811	op = va_arg(args, object*);
2812	op2 = va_arg(args, object*);
2813
2814	va_end(args);
2815
2816
2817	*type = CFAPI_POBJECT;
2818	return merge_ob(op, op2);
2819	}
2820	void* cfapi_object_distance(int* type, ...)
2821	{
2822	va_list args;
2823	static int rv;
2824	object* op;
2825	object* op2;
2826	va_start(args, type);
2827
2828	op = va_arg(args, object*);
2829	op2 = va_arg(args, object*);
2830
2831	va_end(args);
2832
2833	*type = CFAPI_INT;
2834	rv = distance(op, op2);
2835	return &rv;
2836	}
2837	void* cfapi_object_update(int* type, ...)
2838	{
2839	va_list args;
2840	int action;
2841	object* op;
2842	va_start(args, type);
2843
2844	op = va_arg(args, object*);
2845	action = va_arg(args, int);
2846
2847	va_end(args);
2848
2849	update_object(op, action);
2850	*type = CFAPI_NONE;
2851	return NULL;
2852	}
2853	void* cfapi_object_clear(int* type, ...)
2854	{
2855	va_list args;
2856	object* op;
2857	va_start(args, type);
2858
2859	op = va_arg(args, object*);
2860
2861	va_end(args);
2862
2863	clear_object(op);
2864	*type = CFAPI_NONE;
2865	return NULL;
2866	}
2867	void* cfapi_object_reset(int* type, ...)
2868	{
2869	va_list args;
2870	object* op;
2871
2872	va_start(args, type);
2873
2874	op = va_arg(args, object*);
2875
2876	va_end(args);
2877
2878	reset_object(op);
2879	*type = CFAPI_NONE;
2880	return NULL;
2881	}
2882
2883	void* cfapi_object_check_inventory(int* type, ...)
2884	{
2885	va_list args;
2886	object* op;
2887	object* op2;
2888	int checktype;
2889	object* ret = NULL;
2890
2891	va_start(args, type);
2892
2893	op = va_arg(args, object*);
2894	op2 = va_arg(args, object*);
2895	checktype = va_arg(args, int);
2896
2897	if (checktype == 0) {
2898	check_inv(op, op2);
2899	*type = CFAPI_NONE;
2900	} else {
2901	ret = check_inv_recursive(op, op2);
2902	*type = CFAPI_POBJECT;
2903	}
2904
2905	va_end(args);
2906
2907	return ret;
2908	}
2909
2910	void* cfapi_object_clean_object(int* type, ...)
2911	{
2912	va_list args;
2913	object* op;
2914	va_start(args, type);
2915	op = va_arg(args, object*);
2916	clean_object(op);
2917	va_end(args);
2918	*type = CFAPI_NONE;
2919	return NULL;
2920	}
2921	void* cfapi_object_on_same_map(int* type, ...)
2922	{
2923	va_list args;
2924	static int rv;
2925	object* op1;
2926	object* op2;
2927
2928	va_start(args, type);
2929	op1 = va_arg(args, object*);
2930	op2 = va_arg(args, object*);
2931
2932	rv = on_same_map(op1, op2);
2933	va_end(args);
2934
2935	*type = CFAPI_INT;
2936	return &rv;
2937	}
2938
2939	void* cfapi_object_spring_trap(int* type, ...)
2940	{
2941	object* trap;
2942	object* victim;
2943	va_list args;
2944
2945	va_start(args, type);
2946	trap = va_arg(args, object*);
2947	victim = va_arg(args, object*);
2948	va_end(args);
2949
2950	spring_trap(trap, victim);
2951	*type = CFAPI_NONE;
2952	return NULL;
2953	}
2954
2955	void* cfapi_object_check_trigger(int* type, ...)
2956	{
2957	object* op;
2958	object* cause;
2959	va_list args;
2960	static int rv;
2961
2962	va_start(args, type);
2963	op = va_arg(args, object*);
2964	cause = va_arg(args, object*);
2965	va_end(args);
2966
2967	rv = check_trigger(op, cause);
2968	*type = CFAPI_INT;
2969	return &rv;
2970	}
2971
2972	void* cfapi_object_query_cost(int* type, ...)
2973	{
2974	object* op;
2975	object* who;
2976	int flags;
2977	va_list args;
2978	static int rv;
2979
2980	va_start(args, type);
2981	op = va_arg(args, object*);
2982	who = va_arg(args, object*);
2983	flags = va_arg(args, int);
2984	va_end(args);
2985
2986	rv = query_cost(op, who, flags);
2987	*type = CFAPI_INT;
2988	return &rv;
2989	}
2990
2991	void* cfapi_object_query_money(int* type, ...)
2992	{
2993	object* op;
2994	va_list args;
2995	static int rv;
2996
2997	va_start(args, type);
2998	op = va_arg(args, object*);
2999	va_end(args);
3000
3001	rv = query_money(op);
3002	*type = CFAPI_INT;
3003	return &rv;
3004	}
3005	void* cfapi_object_cast(int* type, ...)
3006	{
3007	object* op;
3008	object* sp;
3009	int dir;
3010	char* str;
3011	object* caster;
3012	va_list args;
3013	static int rv;
3014	va_start(args, type);
3015	op = va_arg(args, object*);
3016	caster = va_arg(args, object*);
3017	dir = va_arg(args, int);
3018	sp = va_arg(args, object*);
3019	str = va_arg(args, char*);
3020	va_end(args);
3021	rv = cast_spell(op, caster, dir, sp, str);
3022	*type = CFAPI_INT;
3023	return &rv;
3024	}
3025	void* cfapi_object_learn_spell(int* type, ...)
3026	{
3027	object* op;
3028	object* sp;
3029	int prayer;
3030	va_list args;
3031
3032	va_start(args, type);
3033	op = va_arg(args, object*);
3034	sp = va_arg(args, object*);
3035	prayer = va_arg(args, int);
3036	va_end(args);
3037	do_learn_spell(op, sp, prayer);
3038	*type = CFAPI_NONE;
3039	return NULL;
3040	}
3041	void* cfapi_object_forget_spell(int* type, ...)
3042	{
3043	object* op;
3044	object* sp;
3045	va_list args;
3046
3047	va_start(args, type);
3048	op = va_arg(args, object*);
3049	sp = va_arg(args, object*);
3050	va_end(args);
3051	do_forget_spell(op, query_name(sp));
3052	*type = CFAPI_NONE;
3053	return NULL;
3054	}
3055	void* cfapi_object_check_spell(int* type, ...)
3056	{
3057	object* op;
3058	char* spellname;
3059	va_list args;
3060	object* rv;
3061
3062	va_start(args, type);
3063	op = va_arg(args, object*);
3064	spellname = va_arg(args, char*);
3065	va_end(args);
3066	rv = check_spell_known(op, spellname);
3067	*type = CFAPI_POBJECT;
3068	return rv;
3069	}
3070	void* cfapi_object_pay_amount(int* type, ...)
3071	{
3072	object* op;
3073	uint64 amount;
3074	va_list args;
3075	static int rv;
3076
3077	va_start(args, type);
3078	op = va_arg(args, object*);
3079	amount = va_arg(args, uint64);
3080	va_end(args);
3081
3082	rv = pay_for_amount(amount, op);
3083	*type = CFAPI_INT;
3084	return &rv;
3085	}
3086	void* cfapi_object_pay_item(int* type, ...)
3087	{
3088	object* op;
3089	object* tobuy;
3090
3091	va_list args;
3092	static int rv;
3093
3094	va_start(args, type);
3095	tobuy = va_arg(args, object*);
3096	op = va_arg(args, object*);
3097	va_end(args);
3098
3099	rv = pay_for_item(tobuy, op);
3100	*type = CFAPI_INT;
3101	return &rv;
3102	}
3103	void* cfapi_object_transfer(int* type, ...)
3104	{
3105	object* op;
3106	object* originator;
3107	int x, y, randompos, ttype;
3108	va_list args;
3109	static int rv=0;
3110	mapstruct* map;
3111
3112	va_start(args, type);
3113	op = va_arg(args, object*);
3114	ttype = va_arg(args, int);
3115	switch (ttype)
3116	{
3117	case 0:
3118	x = va_arg(args, int);
3119	y = va_arg(args, int);
3120	randompos = va_arg(args, int);
3121	originator = va_arg(args, object*);
3122	va_end(args);
3123
3124	rv = transfer_ob(op, x, y, randompos, originator);
3125	*type = CFAPI_INT;
3126	return &rv;
3127	break;
3128
3129	case 1:
3130	x = va_arg(args, int);
3131	y = va_arg(args, int);
3132	map = va_arg(args, mapstruct*);
3133	va_end(args);
3134	if (x < 0 || y < 0) {
3135	x = map->enter_x;
3136	y = map->enter_y;
3137	}
3138	/*	3304	/*
3139	originator = get_object();	3305	originator = get_object();
3140	EXIT_PATH(originator) = add_string(map->path);	3306	EXIT_PATH(originator) = add_string(map->path);
3141	EXIT_X(originator) = x;	3307	EXIT_X(originator) = x;
3142	EXIT_Y(originator) = y;	3308	EXIT_Y(originator) = y;
3143	printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/	3309	printf("B Transfer: X=%d, Y=%d, OP=%s\n", x, y, op->name);*/
3144	/*enter_exit(op, originator);*/	3310	/*enter_exit(op, originator); */
3145	insert_ob_in_map_at(op, map, NULL, 0, x, y);	3311	insert_ob_in_map_at (op, map, NULL, 0, x, y);
3146	/*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name);	3312	/*printf("A Transfer: X=%d, Y=%d, MAP=%s\n", x, y, op->map->name);
3147	free_object(originator);	3313	free_object(originator);
3148	*/	3314	*/
3149	*type = CFAPI_INT;	3315	*type = CFAPI_INT;
3150	return &rv;	3316	return &rv;
3151	break;	3317	break;
3152		3318
3153	default:	3319	default:
3154	*type = CFAPI_NONE;	3320	*type = CFAPI_NONE;
3155	return NULL;	3321	return NULL;
3156	break;	3322	break;
3157	}	3323	}
3158	}	3324	}
3159		3325
		3326	void *
3160	void* cfapi_object_find_archetype_inside(int* type, ...)	3327	cfapi_object_find_archetype_inside (int *type, ...)
3161	{	3328	{
3162	object* op;	3329	object *op;
3163	int critera;	3330	int critera;
3164	char* str;	3331	char *str;
3165	va_list args;	3332	va_list args;
3166	object* rv;	3333	object *rv;
3167		3334
3168	*type = CFAPI_POBJECT;	3335	*type = CFAPI_POBJECT;
3169	va_start(args, type);	3336	va_start (args, type);
3170	op = va_arg(args, object*);	3337	op = va_arg (args, object *);
3171	critera = va_arg(args, int);	3338	critera = va_arg (args, int);
3172		3339
3173	switch(critera)	3340	switch (critera)
3174	{	3341	{
3175	case 0: /* By name, either exact or from query_name */	3342	case 0: /* By name, either exact or from query_name */
3176	str = va_arg(args, char*);	3343	str = va_arg (args, char *);
		3344
3177	rv = present_arch_in_ob(find_archetype(str), op);	3345	rv = present_arch_in_ob (archetype::find (str), op);
3178	if (rv == NULL) {	3346	if (rv == NULL)
		3347	{
3179	object* tmp;	3348	object *tmp;
		3349
3180	/* Search by query_name instead */	3350	/* Search by query_name instead */
3181	for (tmp = op->inv; tmp; tmp = tmp->below) {	3351	for (tmp = op->inv; tmp; tmp = tmp->below)
		3352	{
3182	if (!strncmp(query_name(tmp), str, strlen(str)))	3353	if (!strncmp (query_name (tmp), str, strlen (str)))
3183	rv = tmp;	3354	rv = tmp;
3184	if (!strncmp(tmp->name, str, strlen(str)))	3355	if (!strncmp (tmp->name, str, strlen (str)))
3185	rv = tmp;	3356	rv = tmp;
3186	if (rv != NULL)	3357	if (rv != NULL)
3187	break;	3358	break;
		3359	}
		3360	}
		3361	break;
		3362
		3363	default:
		3364	rv = NULL;
		3365	break;
		3366	}
		3367	va_end (args);
		3368
		3369	if (rv == NULL)
		3370	{
		3371	*type = CFAPI_NONE;
		3372	}
		3373	return rv;
		3374	}
		3375
		3376	void *
		3377	cfapi_object_drop (int *type, ...)
		3378	{
		3379	object *op;
		3380	object *author;
		3381	va_list args;
		3382
		3383	va_start (args, type);
		3384	op = va_arg (args, object *);
		3385	author = va_arg (args, object *);
		3386
		3387	va_end (args);
		3388
		3389	if (QUERY_FLAG (op, FLAG_NO_DROP))
		3390	return NULL;
		3391	drop (author, op);
		3392
		3393	if (author->type == PLAYER)
		3394	{
		3395	author->contr->count = 0;
		3396	author->contr->socket.update_look = 1;
		3397	}
		3398
		3399	*type = CFAPI_NONE;
		3400	return NULL;
		3401	}
		3402
		3403	void *
		3404	cfapi_object_take (int *type, ...)
		3405	{
		3406	object *op;
		3407	object *author;
		3408	va_list args;
		3409
		3410	va_start (args, type);
		3411	op = va_arg (args, object *);
		3412	author = va_arg (args, object *);
		3413
		3414	va_end (args);
		3415	pick_up (author, op);
		3416
		3417	*type = CFAPI_NONE;
		3418	return NULL;
		3419	}
		3420
		3421	void *
		3422	cfapi_object_say (int *type, ...)
		3423	{
		3424	abort ();
		3425	}
		3426
		3427	void *
		3428	cfapi_object_speak (int *type, ...)
		3429	{
		3430	abort ();
		3431	}
		3432
		3433	/* PLAYER SUBCLASS */
		3434	void *
		3435	cfapi_player_find (int *type, ...)
		3436	{
		3437	va_list args;
		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	}
		3452
		3453	void *
		3454	cfapi_player_message (int *type, ...)
		3455	{
		3456	va_list args;
		3457	int flags;
		3458	int pri;
		3459	object *pl;
		3460	char *buf;
		3461
		3462	va_start (args, type);
		3463
		3464	flags = va_arg (args, int);
		3465	pri = va_arg (args, int);
		3466	pl = va_arg (args, object *);
		3467	buf = va_arg (args, char *);
		3468
		3469	va_end (args);
		3470
		3471	new_draw_info (flags, pri, pl, buf);
		3472	*type = CFAPI_NONE;
		3473	return NULL;
		3474	}
		3475
		3476	void *
		3477	cfapi_player_send_inventory (int *type, ...)
		3478	{
		3479	/* Currently a stub. Do we really need this anymore ? */
		3480	*type = CFAPI_NONE;
		3481	return NULL;
		3482	}
		3483
		3484	void *
		3485	cfapi_object_teleport (int *type, ...)
		3486	{
		3487	mapstruct *map;
		3488	int x, y;
		3489	object *who;
		3490	static int result;
		3491	va_list args;
		3492
		3493	va_start (args, type);
		3494	who = va_arg (args, object *);
		3495	map = va_arg (args, mapstruct *);
		3496	x = va_arg (args, int);
		3497	y = va_arg (args, int);
		3498
		3499	if (!out_of_map (map, x, y))
		3500	{
		3501	int k;
		3502	object *tmp;
		3503
		3504	k = find_first_free_spot (who, map, x, y);
		3505	if (k == -1)
		3506	{
		3507	result = 1;
		3508	return &result;
		3509	}
		3510
		3511	send_removed_object (who);
		3512	remove_ob (who);
		3513
		3514	for (tmp = who; tmp != NULL; tmp = tmp->more)
		3515	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);
		3517
		3518	insert_ob_in_map (who, map, NULL, 0);
		3519	result = 0;
		3520	}
		3521
		3522	return &result;
		3523	}
		3524
		3525	void *
		3526	cfapi_object_pickup (int *type, ...)
		3527	{
		3528	object *who;
		3529	object *what;
		3530	va_list args;
		3531
		3532	va_start (args, type);
		3533	who = va_arg (args, object *);
		3534	what = va_arg (args, object *);
		3535
		3536	va_end (args);
		3537
		3538	pick_up (who, what);
		3539	*type = CFAPI_NONE;
		3540	return NULL;
		3541	}
		3542
		3543	/* Archetype-related functions */
		3544	void *
		3545	cfapi_archetype_get_first (int *type, ...)
		3546	{
		3547	va_list args;
		3548
		3549	va_start (args, type);
		3550	va_end (args);
		3551	*type = CFAPI_PARCH;
		3552	return first_archetype;
		3553	}
		3554
		3555	void *
		3556	cfapi_archetype_get_property (int *type, ...)
		3557	{
		3558	archetype *arch;
		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	}
		3602
		3603	/* Party-related functions */
		3604	void *
		3605	cfapi_party_get_property (int *type, ...)
		3606	{
		3607	partylist *party;
		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	}
		3657
		3658	/* Regions-related functions */
		3659	void *
		3660	cfapi_region_get_property (int *type, ...)
		3661	{
		3662	region *reg;
		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	}
		3706
		3707	/*****************************************************************************/
		3708
		3709	/* NEW PLUGIN STUFF ENDS HERE */
		3710
		3711	/*****************************************************************************/
		3712
		3713
		3714	/*****************************************************************************/
		3715
		3716	/* Tries to find if a given command is handled by a plugin. */
		3717
		3718	/* Note that find_plugin_command is called *before* the internal commands are*/
		3719
		3720	/* checked, meaning that you can "overwrite" them. */
		3721
		3722	/*****************************************************************************/
		3723	CommArray_s *
		3724	find_plugin_command (char *cmd, object *op)
		3725	{
		3726	int i;
		3727	crossfire_plugin *cp;
		3728	CommArray_s *rtn_cmd;
		3729
		3730	if (plugins_list == NULL)
		3731	return NULL;
		3732
		3733	for (cp = plugins_list; cp != NULL; cp = cp->next)
		3734	{
		3735	rtn_cmd = (CommArray_s *) cp->propfunc (&i, "command?", cmd);
		3736	if (rtn_cmd)
		3737	return rtn_cmd;
		3738	}
		3739	return NULL;
		3740	}
		3741
		3742	/*****************************************************************************/
		3743
		3744	/* Plugins initialization. Browses the plugins directory and call */
		3745
		3746	/* initOnePlugin for each file found. */
		3747
		3748	/* Returns 0 if at least one plugin was successfully loaded, -1 if not */
		3749
		3750	/*****************************************************************************/
		3751	int
		3752	initPlugins (void)
		3753	{
		3754	struct dirent *currentfile;
		3755	DIR *plugdir;
		3756	size_t l;
		3757	char buf[MAX_BUF];
		3758	char buf2[MAX_BUF];
		3759	int result;
		3760
		3761	LOG (llevInfo, "Initializing plugins\n");
		3762	strcpy (buf, LIBDIR);
		3763	strcat (buf, "/plugins/");
		3764	LOG (llevInfo, "Plugins directory is %s\n", buf);
		3765
		3766	plugins_init_perl ();
		3767
		3768	plugdir = opendir (buf);
		3769	if (plugdir == NULL)
		3770	return -1;
		3771
		3772	result = -1;
		3773	while ((currentfile = readdir (plugdir)) != NULL)
		3774	{
		3775	l = strlen (currentfile->d_name);
		3776	if (l > strlen (PLUGIN_SUFFIX))
		3777	{
		3778	if (strcmp (currentfile->d_name + l - strlen (PLUGIN_SUFFIX), PLUGIN_SUFFIX) == 0)
		3779	{
		3780	strcpy (buf2, buf);
		3781	strcat (buf2, currentfile->d_name);
		3782	LOG (llevInfo, " -> Loading plugin : %s\n", currentfile->d_name);
		3783	if (plugins_init_plugin (buf2) == 0)
		3784	result = 0;
3188	}	3785	}
3189	}	3786	}
3190	break;
3191
3192	default:
3193	rv = NULL;
3194	break;
3195	}
3196	va_end(args);
3197
3198	if (rv == NULL) {
3199	*type = CFAPI_NONE;
3200	}
3201	return rv;
3202	}
3203
3204	void* cfapi_object_drop(int* type, ...)
3205	{
3206	object* op;
3207	object* author;
3208	va_list args;
3209
3210	va_start(args, type);
3211	op = va_arg(args, object*);
3212	author = va_arg(args, object*);
3213	va_end(args);
3214
3215	if (QUERY_FLAG(op, FLAG_NO_DROP))
3216	return NULL;
3217	drop(author, op);
3218
3219	if (author->type == PLAYER) {
3220	author->contr->count = 0;
3221	author->contr->socket.update_look = 1;
3222	}
3223
3224	*type = CFAPI_NONE;
3225	return NULL;
3226	}
3227
3228	void* cfapi_object_take(int* type, ...)
3229	{
3230	object *op;
3231	object *author;
3232	va_list args;
3233
3234	va_start(args, type);
3235	op = va_arg(args, object*);
3236	author = va_arg(args, object*);
3237	va_end(args);
3238	pick_up(author, op);
3239
3240	*type = CFAPI_NONE;
3241	return NULL;
3242	}
3243
3244	void* cfapi_object_say(int* type, ...)
3245	{
3246	static int rv;
3247	object* op;
3248	char* msg;
3249	va_list args;
3250
3251	va_start(args, type);
3252	op = va_arg(args, object*);
3253	msg = va_arg(args, char*);
3254	va_end(args);
3255
3256	rv = command_say(op, msg);
3257	*type = CFAPI_INT;
3258	return &rv;
3259	}
3260	void* cfapi_object_speak(int* type, ...)
3261	{
3262	object* op;
3263	char* msg;
3264	va_list args;
3265	static char buf[MAX_BUF];
3266
3267	va_start(args, type);
3268	op = va_arg(args, object*);
3269	msg = va_arg(args, char*);
3270	va_end(args);
3271
3272	if (!op || !msg)
3273	return NULL;
3274	sprintf(buf, "%s says: ", op->name);
3275	strncat(buf, msg, MAX_BUF-strlen(buf)-1);
3276	buf[MAX_BUF-1]=0;
3277	new_info_map(NDI_WHITE, op->map, buf);
3278	communicate(op, msg);
3279	*type = CFAPI_NONE;
3280	return NULL;
3281	}
3282	/* PLAYER SUBCLASS */
3283	void* cfapi_player_find(int* type, ...)
3284	{
3285	va_list args;
3286	void* rv;
3287	char* sval;
3288	va_start(args, type);
3289
3290	sval = va_arg(args, char*);
3291	va_end(args);
3292
3293	rv = find_player(sval);
3294
3295	*type = CFAPI_PPLAYER;
3296	return rv;
3297	}
3298	void* cfapi_player_message(int* type, ...)
3299	{
3300	va_list args;
3301	int flags;
3302	int pri;
3303	object* pl;
3304	char* buf;
3305
3306	va_start(args, type);
3307
3308	flags = va_arg(args, int);
3309	pri = va_arg(args, int);
3310	pl = va_arg(args, object*);
3311	buf = va_arg(args, char*);
3312	va_end(args);
3313
3314	new_draw_info(flags, pri, pl, buf);
3315	*type = CFAPI_NONE;
3316	return NULL;
3317	}
3318	void *cfapi_player_send_inventory(int *type, ...)
3319	{
3320	/* Currently a stub. Do we really need this anymore ? */
3321	*type = CFAPI_NONE;
3322	return NULL;
3323	}
3324
3325	void* cfapi_object_teleport(int *type, ...)
3326	{
3327	mapstruct* map;
3328	int x, y;
3329	object* who;
3330	static int result;
3331	va_list args;
3332
3333	va_start(args, type);
3334	who = va_arg(args, object*);
3335	map = va_arg(args, mapstruct*);
3336	x = va_arg(args, int);
3337	y = va_arg(args, int);
3338
3339	if (!out_of_map(map, x, y)) {
3340	int k;
3341	object *tmp;
3342	k = find_first_free_spot(who, map, x, y);
3343	if (k == -1) {
3344	result = 1;
3345	return &result;
3346	}
3347
3348	send_removed_object(who);
3349	remove_ob(who);
3350
3351	for (tmp = who; tmp != NULL; tmp = tmp->more)
3352	tmp->x = x+freearr_x[k]+(tmp->arch == NULL ? 0 : tmp->arch->clone.x),
3353	tmp->y = y+freearr_y[k]+(tmp->arch == NULL ? 0 : tmp->arch->clone.y);
3354
3355	insert_ob_in_map(who, map, NULL, 0);
3356	result = 0;
3357	}
3358
3359	return &result;
3360	}
3361	void* cfapi_object_pickup(int *type, ...)
3362	{
3363	object* who;
3364	object* what;
3365	va_list args;
3366
3367	va_start(args, type);
3368	who = va_arg(args, object*);
3369	what = va_arg(args, object*);
3370	va_end(args);
3371
3372	pick_up(who, what);
3373	*type = CFAPI_NONE;
3374	return NULL;
3375	}
3376
3377	/* Archetype-related functions */
3378	void* cfapi_archetype_get_first(int* type, ...)
3379	{
3380	va_list args;
3381	va_start(args, type);
3382	va_end(args);
3383	*type = CFAPI_PARCH;
3384	return first_archetype;
3385	}
3386
3387	void* cfapi_archetype_get_property(int* type, ...)
3388	{
3389	archetype* arch;
3390	int prop;
3391	va_list args;
3392	void* rv;
3393
3394	va_start(args, type);
3395	arch = va_arg(args, archetype*);
3396	prop = va_arg(args, int);
3397	switch (prop) {
3398	case CFAPI_ARCH_PROP_NAME:
3399	*type = CFAPI_STRING;
3400	rv = (void*)arch->name;
3401	break;
3402
3403	case CFAPI_ARCH_PROP_NEXT:
3404	*type = CFAPI_PARCH;
3405	rv = arch->next;
3406	break;
3407
3408	case CFAPI_ARCH_PROP_HEAD:
3409	*type = CFAPI_PARCH;
3410	rv = arch->head;
3411	break;
3412
3413	case CFAPI_ARCH_PROP_MORE:
3414	*type = CFAPI_PARCH;
3415	rv = arch->more;
3416	break;
3417
3418	case CFAPI_ARCH_PROP_CLONE:
3419	*type = CFAPI_POBJECT;
3420	rv = &arch->clone;
3421	break;
3422
3423	default:
3424	*type = CFAPI_NONE;
3425	rv = NULL;
3426	break;
3427	}
3428	va_end(args);
3429	return rv;
3430	}
3431
3432	/* Party-related functions */
3433	void* cfapi_party_get_property(int* type, ...)
3434	{
3435	partylist* party;
3436	int prop;
3437	va_list args;
3438	void* rv;
3439	object* obarg;
3440	player* pl;
3441
3442	va_start(args, type);
3443	party = va_arg(args, partylist*);
3444	prop = va_arg(args, int);
3445	switch (prop)
3446	{	3787	}
3447	case CFAPI_PARTY_PROP_NAME:
3448	*type = CFAPI_STRING;
3449	rv = (void*)party->partyname;
3450	break;
3451		3788
3452	case CFAPI_PARTY_PROP_NEXT:
3453	*type = CFAPI_PPARTY;
3454	rv = (party ? party->next : get_firstparty());
3455	break;
3456
3457	case CFAPI_PARTY_PROP_PASSWORD:
3458	*type = CFAPI_STRING;
3459	rv = (void*)party->passwd;
3460	break;
3461
3462	case CFAPI_PARTY_PROP_PLAYER:
3463	*type = CFAPI_PPLAYER;
3464	obarg = va_arg(args, object*);
3465	pl = (obarg ? obarg->contr : first_player);
3466	rv = NULL;
3467	for (; pl != NULL; pl = pl->next)
3468	if (pl->ob->contr->party == party) {
3469	rv = (void*)pl;
3470	break;
3471	}
3472	break;
3473
3474	default:
3475	*type = CFAPI_NONE;
3476	rv = NULL;
3477	break;
3478	}
3479	va_end(args);
3480	return rv;
3481	}
3482
3483	/* Regions-related functions */
3484	void* cfapi_region_get_property(int* type, ...)
3485	{
3486	region* reg;
3487	int prop;
3488	va_list args;
3489	void* rv;
3490
3491	va_start(args, type);
3492	reg = va_arg(args, region*);
3493	prop = va_arg(args, int);
3494	switch (prop) {
3495	case CFAPI_REGION_PROP_NAME:
3496	*type = CFAPI_STRING;
3497	rv = (void*)reg->name;
3498	break;
3499
3500	case CFAPI_REGION_PROP_NEXT:
3501	*type = CFAPI_PREGION;
3502	rv = (reg?reg->next:first_region);
3503	break;
3504
3505	case CFAPI_REGION_PROP_PARENT:
3506	*type = CFAPI_PREGION;
3507	rv = (void*)reg->parent;
3508	break;
3509
3510	case CFAPI_REGION_PROP_LONGNAME:
3511	*type = CFAPI_STRING;
3512	rv = (void*)reg->longname;
3513	break;
3514
3515	case CFAPI_REGION_PROP_MESSAGE:
3516	*type = CFAPI_STRING;
3517	rv = (void*)reg->msg;
3518	break;
3519
3520	default:
3521	*type = CFAPI_NONE;
3522	rv = NULL;
3523	break;
3524	}
3525	va_end(args);
3526	return rv;
3527	}
3528
3529	/*****************************************************************************/
3530	/* NEW PLUGIN STUFF ENDS HERE */
3531	/*****************************************************************************/
3532
3533
3534	/*****************************************************************************/
3535	/* Tries to find if a given command is handled by a plugin. */
3536	/* Note that find_plugin_command is called *before* the internal commands are*/
3537	/* checked, meaning that you can "overwrite" them. */
3538	/*****************************************************************************/
3539	CommArray_s *find_plugin_command(char *cmd, object *op)
3540	{
3541	int i;
3542	crossfire_plugin* cp;
3543	CommArray_s* rtn_cmd;
3544
3545	if (plugins_list == NULL)
3546	return NULL;
3547
3548	for (cp = plugins_list; cp != NULL; cp = cp->next) {
3549	rtn_cmd = (CommArray_s*) cp->propfunc(&i, "command?", cmd);
3550	if (rtn_cmd)
3551	return rtn_cmd;
3552	}
3553	return NULL;
3554	}
3555
3556	/*****************************************************************************/
3557	/* Plugins initialization. Browses the plugins directory and call */
3558	/* initOnePlugin for each file found. */
3559	/* Returns 0 if at least one plugin was successfully loaded, -1 if not */
3560	/*****************************************************************************/
3561	int initPlugins(void)
3562	{
3563	struct dirent *currentfile;
3564	DIR *plugdir;
3565	size_t l;
3566	char buf[MAX_BUF];
3567	char buf2[MAX_BUF];
3568	int result;
3569
3570	LOG(llevInfo, "Initializing plugins\n");
3571	strcpy(buf, LIBDIR);
3572	strcat(buf, "/plugins/");
3573	LOG(llevInfo, "Plugins directory is %s\n", buf);
3574
3575	plugins_init_perl ();
3576
3577	plugdir = opendir(buf);
3578	if (plugdir == NULL)
3579	return -1;
3580
3581	result = -1;
3582	while ((currentfile = readdir(plugdir)) != NULL) {
3583	l = strlen(currentfile->d_name);
3584	if (l > strlen(PLUGIN_SUFFIX)) {
3585	if (strcmp(currentfile->d_name+l-strlen(PLUGIN_SUFFIX), PLUGIN_SUFFIX) == 0) {
3586	strcpy(buf2, buf);
3587	strcat(buf2, currentfile->d_name);
3588	LOG(llevInfo, " -> Loading plugin : %s\n", currentfile->d_name);
3589	if (plugins_init_plugin(buf2) == 0)
3590	result = 0;
3591	}
3592	}
3593	}
3594
3595	closedir(plugdir);	3789	closedir (plugdir);
3596	return result;	3790	return result;
3597	}	3791	}

Diff Legend

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