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.9 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.21 by root, Tue Dec 12 21:39:57 2006 UTC

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

Diff Legend

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