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.5 by root, Sat Aug 26 08:44:07 2006 UTC vs.
Revision 1.23 by root, Wed Dec 13 03:28:42 2006 UTC

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

Diff Legend

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