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.6 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.42 by root, Mon Feb 5 01:47:23 2007 UTC

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

Diff Legend

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