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.4 by root, Fri Aug 25 17:11:53 2006 UTC vs.
Revision 1.14 by root, Thu Sep 14 21:16:12 2006 UTC

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

Diff Legend

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