ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/plugins.C
(Generate patch)

Comparing deliantra/server/server/plugins.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:04 2006 UTC vs.
Revision 1.42 by root, Mon Feb 5 01:47:23 2007 UTC

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

Diff Legend

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