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.7 by root, Mon Aug 28 16:52:51 2006 UTC vs.
Revision 1.29 by root, Wed Dec 20 09:14:22 2006 UTC

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

Diff Legend

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