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

Diff Legend

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