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

Diff Legend

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