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.3 by root, Fri Aug 25 13:24:50 2006 UTC vs.
Revision 1.31 by root, Thu Dec 21 23:37:06 2006 UTC

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

Diff Legend

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