Crossfire Server  1.75.0
plugins.cpp
Go to the documentation of this file.
1 /*
2  * Crossfire -- cooperative multi-player graphical RPG and adventure game
3  *
4  * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
5  * Copyright (c) 1992 Frank Tore Johansen
6  *
7  * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
8  * welcome to redistribute it under certain conditions. For details, please
9  * see COPYING and LICENSE.
10  *
11  * The authors can be reached via e-mail at <crossfire@metalforge.org>.
12  */
13 
22 #if 0
23 
24 #define PLUGIN_DEBUG
25 #endif
26 
27 /*****************************************************************************/
28 /* First, the headers. We only include plugin.h, because all other includes */
29 /* are done into it, and plugproto.h (which is used only by this file). */
30 /*****************************************************************************/
31 
32 #include <assert.h>
33 #include <stdlib.h>
34 #include <string.h>
35 
36 #include "plugin.h"
37 #include "shop.h"
38 #include "sproto.h"
39 #include "svnversion.h"
40 #include "timers.h"
41 #include "assets.h"
42 #include "AssetsManager.h"
43 #include "server.h"
44 
45 #ifdef WIN32
46 #include "libloaderapi.h"
47 #endif
48 
50 #define NR_OF_HOOKS (sizeof(plug_hooks)/sizeof(*plug_hooks))
51 
52 static void cfapi_cost_string_from_value(int *type, ...);
53 static void cfapi_system_find_animation(int *type, ...);
54 static void cfapi_system_find_face(int *type, ...);
55 static void cfapi_system_strdup_local(int *type, ...);
56 static void cfapi_system_register_global_event(int *type, ...);
57 static void cfapi_system_unregister_global_event(int *type, ...);
58 static void cfapi_system_add_string(int *type, ...);
59 static void cfapi_system_remove_string(int *type, ...);
60 static void cfapi_system_find_string(int *type, ...);
61 static void cfapi_system_check_path(int *type, ...);
62 static void cfapi_system_re_cmp(int *type, ...);
63 static void cfapi_system_directory(int *type, ...);
64 static void cfapi_get_time(int *type, ...);
65 static void cfapi_get_season_name(int *type, ...);
66 static void cfapi_get_weekday_name(int *type, ...);
67 static void cfapi_get_month_name(int *type, ...);
68 static void cfapi_get_periodofday_name(int *type, ...);
69 static void cfapi_timer_create(int *type, ...);
70 static void cfapi_timer_destroy(int *type, ...);
71 static void cfapi_log(int *type, ...);
72 static void cfapi_map_get_map(int *type, ...);
73 static void cfapi_map_has_been_loaded(int *type, ...);
74 static void cfapi_map_create_path(int *type, ...);
75 static void cfapi_map_get_map_property(int *type, ...);
76 static void cfapi_map_set_map_property(int *type, ...);
77 static void cfapi_map_out_of_map(int *type, ...);
78 static void cfapi_map_update_position(int *type, ...);
79 static void cfapi_map_delete_map(int *type, ...);
80 static void cfapi_map_message(int *type, ...);
81 static void cfapi_map_get_object_at(int *type, ...);
82 static void cfapi_map_find_by_archetype_name(int *type, ...);
83 static void cfapi_map_change_light(int *type, ...);
84 static void cfapi_object_move(int *type, ...);
85 static void cfapi_object_get_key(int *type, ...);
86 static void cfapi_object_set_key(int *type, ...);
87 static void cfapi_object_get_property(int *type, ...);
88 static void cfapi_object_set_property(int *type, ...);
89 static void cfapi_object_apply_below(int *type, ...);
90 static void cfapi_object_apply(int *type, ...);
91 static void cfapi_object_identify(int *type, ...);
92 static void cfapi_object_describe(int *type, ...);
93 static void cfapi_object_drain(int *type, ...);
94 static void cfapi_object_remove_depletion(int *type, ...);
95 static void cfapi_object_fix(int *type, ...);
96 static void cfapi_object_give_skill(int *type, ...);
97 static void cfapi_object_transmute(int *type, ...);
98 static void cfapi_object_remove(int *type, ...);
99 static void cfapi_object_delete(int *type, ...);
100 static void cfapi_object_clone(int *type, ...);
101 static void cfapi_object_create(int *type, ...);
102 static void cfapi_object_insert(int *type, ...);
103 static void cfapi_object_split(int *type, ...);
104 static void cfapi_object_merge(int *type, ...);
105 static void cfapi_object_distance(int *type, ...);
106 static void cfapi_object_update(int *type, ...);
107 static void cfapi_object_clear(int *type, ...);
108 static void cfapi_object_reset(int *type, ...);
109 static void cfapi_object_clean_object(int *type, ...);
110 static void cfapi_object_on_same_map(int *type, ...);
111 static void cfapi_object_spring_trap(int *type, ...);
112 static void cfapi_object_check_trigger(int *type, ...);
113 static void cfapi_map_trigger_connected(int *type, ...);
114 static void cfapi_object_query_money(int *type, ...);
115 static void cfapi_object_cast(int *type, ...);
116 static void cfapi_object_learn_spell(int *type, ...);
117 static void cfapi_object_forget_spell(int *type, ...);
118 static void cfapi_object_check_spell(int *type, ...);
119 static void cfapi_object_pay_amount(int *type, ...);
120 static void cfapi_object_pay_item(int *type, ...);
121 static void cfapi_object_transfer(int *type, ...);
122 static void cfapi_object_find_archetype_inside(int *type, ...);
123 static void cfapi_object_find_by_arch_name(int *type, ...);
124 static void cfapi_object_find_by_name(int *type, ...);
125 static void cfapi_object_drop(int *type, ...);
126 static void cfapi_object_change_abil(int *type, ...);
127 static void cfapi_object_say(int *type, ...);
128 static void cfapi_player_find(int *type, ...);
129 static void cfapi_player_message(int *type, ...);
130 static void cfapi_object_change_exp(int *type, ...);
131 static void cfapi_player_can_pay(int *type, ...);
132 static void cfapi_player_knowledge(int *type, ...);
133 static void cfapi_object_teleport(int *type, ...);
134 static void cfapi_object_pickup(int *type, ...);
135 static void cfapi_archetype_get_property(int *type, ...);
136 static void cfapi_party_get_property(int *type, ...);
137 static void cfapi_region_get_property(int *type, ...);
138 static void cfapi_friendlylist_get_next(int *type, ...);
139 static void cfapi_set_random_map_variable(int *type, ...);
140 static void cfapi_generate_random_map(int *type, ...);
141 static void cfapi_object_user_event(int *type, ...);
142 static void cfapi_player_quest(int *type, ...);
143 static void cfapi_object_perm_exp(int *type, ...);
144 static void cfapi_register_command(int *type, ...);
145 static void cfapi_unregister_command(int *type, ...);
146 static void cfapi_system_get_object_vector(int *type, ...);
147 static void cfapi_system_get_map_vector(int *type, ...);
148 static void cfapi_system_get_archetype_vector(int *type, ...);
149 static void cfapi_system_get_party_vector(int *type, ...);
150 static void cfapi_system_get_region_vector(int *type, ...);
151 
155 static const hook_entry plug_hooks[] = {
156  { cfapi_system_add_string, 0, "cfapi_system_add_string" },
157  { cfapi_system_register_global_event, 1, "cfapi_system_register_global_event" },
158  { cfapi_system_remove_string, 2, "cfapi_system_remove_string" },
159  { cfapi_system_unregister_global_event, 3, "cfapi_system_unregister_global_event" },
160  { cfapi_system_check_path, 4, "cfapi_system_check_path" },
161  { cfapi_system_re_cmp, 5, "cfapi_system_re_cmp" },
162  { cfapi_system_strdup_local, 6, "cfapi_system_strdup_local" },
163  { cfapi_system_directory, 7, "cfapi_system_directory" },
164  { cfapi_system_find_animation, 8, "cfapi_system_find_animation" },
165  { cfapi_object_clean_object, 9, "cfapi_object_clean_object" },
166  { cfapi_object_on_same_map, 10, "cfapi_object_on_same_map" },
167  { cfapi_object_get_key, 11, "cfapi_object_get_key" },
168  { cfapi_object_set_key, 12, "cfapi_object_set_key" },
169  { cfapi_object_get_property, 13, "cfapi_object_get_property" },
170  { cfapi_object_set_property, 14, "cfapi_object_set_property" },
171  { cfapi_object_apply, 15, "cfapi_object_apply" },
172  { cfapi_object_identify, 16, "cfapi_object_identify" },
173  { cfapi_object_describe, 17, "cfapi_object_describe" },
174  { cfapi_object_drain, 18, "cfapi_object_drain" },
175  { cfapi_object_fix, 19, "cfapi_object_fix" },
176  { cfapi_object_give_skill, 20, "cfapi_object_give_skill" },
177  { cfapi_object_transmute, 21, "cfapi_object_transmute" },
178  { cfapi_object_remove, 22, "cfapi_object_remove" },
179  { cfapi_object_delete, 23, "cfapi_object_delete" },
180  { cfapi_object_clone, 24, "cfapi_object_clone" },
181  { cfapi_object_create, 26, "cfapi_object_create" },
182  { cfapi_object_insert, 27, "cfapi_object_insert" },
183  { cfapi_object_split, 28, "cfapi_object_split" },
184  { cfapi_object_merge, 29, "cfapi_object_merge" },
185  { cfapi_object_distance, 30, "cfapi_object_distance" },
186  { cfapi_object_update, 31, "cfapi_object_update" },
187  { cfapi_object_clear, 32, "cfapi_object_clear" },
188  { cfapi_object_reset, 33, "cfapi_object_reset" },
189  { cfapi_object_spring_trap, 35, "cfapi_object_spring_trap" },
190  { cfapi_object_check_trigger, 36, "cfapi_object_check_trigger" },
191  { cfapi_object_query_money, 38, "cfapi_object_query_money" },
192  { cfapi_object_cast, 39, "cfapi_object_cast" },
193  { cfapi_object_learn_spell, 40, "cfapi_object_learn_spell" },
194  { cfapi_object_forget_spell, 41, "cfapi_object_forget_spell" },
195  { cfapi_object_check_spell, 42, "cfapi_object_check_spell" },
196  { cfapi_object_pay_amount, 43, "cfapi_object_pay_amount" },
197  { cfapi_object_pay_item, 44, "cfapi_object_pay_item" },
198  { cfapi_object_transfer, 45, "cfapi_object_transfer" },
199  { cfapi_object_drop, 46, "cfapi_object_drop" },
200  { cfapi_object_change_abil, 47, "cfapi_object_change_abil" },
201  { cfapi_object_find_archetype_inside, 48, "cfapi_object_find_archetype_inside" },
202  { cfapi_object_say, 49, "cfapi_object_say" },
203  { cfapi_map_get_map, 50, "cfapi_map_get_map" },
204  { cfapi_map_has_been_loaded, 51, "cfapi_map_has_been_loaded" },
205  { cfapi_map_create_path, 52, "cfapi_map_create_path" },
206  { cfapi_map_get_map_property, 53, "cfapi_map_get_property" },
207  { cfapi_map_set_map_property, 54, "cfapi_map_set_property" },
208  { cfapi_map_out_of_map, 55, "cfapi_map_out_of_map" },
209  { cfapi_map_update_position, 56, "cfapi_map_update_position" },
210  { cfapi_map_delete_map, 57, "cfapi_map_delete_map" },
211  { cfapi_map_message, 58, "cfapi_map_message" },
212  { cfapi_map_get_object_at, 59, "cfapi_map_get_object_at" },
213  { cfapi_map_change_light, 60, "cfapi_map_change_light" },
214  { cfapi_map_find_by_archetype_name, 61, "cfapi_map_find_by_archetype_name" },
215  { cfapi_player_find, 62, "cfapi_player_find" },
216  { cfapi_player_message, 63, "cfapi_player_message" },
217  { cfapi_object_change_exp, 64, "cfapi_object_change_exp" },
218  { cfapi_object_teleport, 65, "cfapi_object_teleport" },
219  { cfapi_object_pickup, 67, "cfapi_object_pickup" },
220  { cfapi_object_move, 68, "cfapi_object_move" },
221  { cfapi_object_apply_below, 69, "cfapi_object_apply_below" },
222  { cfapi_generate_random_map, 70, "cfapi_generate_random_map" },
223  { cfapi_archetype_get_property, 71, "cfapi_archetype_get_property" },
224  { cfapi_party_get_property, 72, "cfapi_party_get_property" },
225  { cfapi_region_get_property, 73, "cfapi_region_get_property" },
226  { cfapi_player_can_pay, 74, "cfapi_player_can_pay" },
227  { cfapi_log, 75, "cfapi_log" },
228  { cfapi_get_time, 76, "cfapi_system_get_time" },
229  { cfapi_timer_create, 77, "cfapi_system_timer_create" },
230  { cfapi_timer_destroy, 78, "cfapi_system_timer_destroy" },
231  { cfapi_friendlylist_get_next, 79, "cfapi_friendlylist_get_next" },
232  { cfapi_set_random_map_variable, 80, "cfapi_set_random_map_variable" },
233  { cfapi_system_find_face, 81, "cfapi_system_find_face" },
234  { cfapi_get_season_name, 82, "cfapi_system_get_season_name" },
235  { cfapi_get_month_name, 83, "cfapi_system_get_month_name" },
236  { cfapi_get_weekday_name, 84, "cfapi_system_get_weekday_name" },
237  { cfapi_get_periodofday_name, 85, "cfapi_system_get_periodofday_name" },
238  { cfapi_map_trigger_connected, 86, "cfapi_map_trigger_connected" },
239  { cfapi_object_user_event, 87, "cfapi_object_user_event" },
240  { cfapi_system_find_string, 88, "cfapi_system_find_string" },
241  { cfapi_cost_string_from_value, 90, "cfapi_cost_string_from_value" },
242  { cfapi_player_quest, 91, "cfapi_player_quest" },
243  { cfapi_object_remove_depletion, 92, "cfapi_object_remove_depletion" },
244  { cfapi_object_find_by_arch_name, 93, "cfapi_object_find_by_arch_name" },
245  { cfapi_object_find_by_name, 94, "cfapi_object_find_by_name" },
246  { cfapi_player_knowledge, 95, "cfapi_player_knowledge" },
247  { cfapi_object_perm_exp, 96, "cfapi_object_perm_exp" },
248  { cfapi_register_command, 97, "cfapi_register_command" },
249  { cfapi_unregister_command, 98, "cfapi_unregister_command" },
250  { cfapi_system_get_object_vector, 99, "cfapi_get_object_vector" },
251  { cfapi_system_get_map_vector, 100, "cfapi_get_map_vector" },
252  { cfapi_system_get_archetype_vector, 101, "cfapi_get_archetype_vector" },
253  { cfapi_system_get_party_vector, 102, "cfapi_get_party_vector" },
254  { cfapi_system_get_region_vector, 103, "cfapi_get_region_vector" },
255 };
256 
258 std::vector<crossfire_plugin *> plugins_list;
259 
260 /*****************************************************************************/
261 /* NEW PLUGIN STUFF STARTS HERE */
262 /*****************************************************************************/
263 
269 static crossfire_plugin *plugins_find_plugin(const char *id) {
270  for (crossfire_plugin *plugin : plugins_list) {
271  if (!strcmp(id, plugin->id)) {
272  return plugin;
273  }
274  }
275  return NULL;
276 }
277 
278 #ifdef WIN32
279 static const char *plugins_dlerror(void)
280 {
281  static char buf[256];
282  DWORD err;
283  char *p;
284 
285  err = GetLastError();
286  if (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, sizeof (buf), NULL) == 0)
287  snprintf(buf, sizeof (buf), "error %lu", err);
288  p = strchr(buf, '\0');
289  while (p > buf && (p[-1] == '\r' || p[-1] == '\n'))
290  p--;
291  *p = '\0';
292  return buf;
293 }
294 
295 #endif /* WIN32 */
296 
302 static void send_changed_object(object *op) {
303  object *tmp;
304  player *pl;
305 
306  if (op->env != NULL) {
307  tmp = object_get_player_container(op->env);
308  if (!tmp) {
309  for (pl = first_player; pl; pl = pl->next)
310  if (pl->ob->container == op->env)
311  break;
312  if (pl)
313  tmp = pl->ob;
314  else
315  tmp = NULL;
316  }
317  if (tmp)
318  /* We don't know what changed, so we send everything. */
319  esrv_update_item(UPD_ALL, tmp, op);
320  } else {
321  FOR_ABOVE_PREPARE(op, tmp)
322  if (tmp->type == PLAYER)
323  tmp->contr->socket->update_look = 1;
324  FOR_ABOVE_FINISH();
325  }
326 }
327 
328 static void cfapi_get_hooks(int *type, ...) {
329  va_list args;
330  int request_type;
331  char *buf;
332  f_plug_api *rapi;
333 
334  *type = CFAPI_NONE;
335 
336  va_start(args, type);
337  request_type = va_arg(args, int);
338  if (request_type == 0) { /* By nr */
339  size_t fid;
340 
341  fid = va_arg(args, int);
342  rapi = va_arg(args, f_plug_api *);
343  if (fid >= NR_OF_HOOKS) {
344  *rapi = NULL;
345  *type = CFAPI_NONE;
346  } else {
347  *rapi = plug_hooks[fid].func;
348  *type = CFAPI_FUNC;
349  }
350  } else { /* by name */
351  size_t i;
352 
353  buf = va_arg(args, char *);
354  rapi = va_arg(args, f_plug_api *);
355  *rapi = NULL;
356  *type = CFAPI_NONE;
357  for (i = 0; i < NR_OF_HOOKS; i++) {
358  if (!strcmp(buf, plug_hooks[i].fname)) {
359  *rapi = plug_hooks[i].func;
360  *type = CFAPI_FUNC;
361  break;
362  }
363  }
364  }
365  va_end(args);
366 }
367 
374 int plugins_init_plugin(const char *libfile) {
375  LIBPTRTYPE ptr;
376  f_plug_init initfunc;
377  f_plug_property propfunc;
378  f_plug_event eventfunc;
379  f_plug_postinit postfunc;
380  f_plug_postinit closefunc;
381  int i;
382  crossfire_plugin *cp;
383  char *svn_rev;
384 
385 
386  /* Open the plugin lib and load the required functions */
387  ptr = plugins_dlopen(libfile);
388  if (ptr == NULL) {
389  LOG(llevError, "Error trying to load %s: %s\n", libfile, plugins_dlerror());
390  return -1;
391  }
392  svn_rev = (char*) plugins_dlsym(ptr, "SvnRevPlugin");
393  if (svn_rev == NULL) {
394  LOG(llevError, "Unable to find SvnRevPlugin in %s\n", libfile);
395  plugins_dlclose(ptr);
396  return -1;
397  }
398  if (settings.ignore_plugin_compatibility == 0 && strcmp(svn_rev, SVN_REV)) {
399  LOG(llevError, "Version mismatch in in %s (%s != %s)\n", libfile, svn_rev, SVN_REV);
400  plugins_dlclose(ptr);
401  return -1;
402  }
403 
404  initfunc = (f_plug_init)plugins_dlsym(ptr, "initPlugin");
405  if (initfunc == NULL) {
406  LOG(llevError, "Plugin error while requesting %s.initPlugin: %s\n", libfile, plugins_dlerror());
407  plugins_dlclose(ptr);
408  return -1;
409  }
410  propfunc = (f_plug_property)plugins_dlsym(ptr, "getPluginProperty");
411  if (propfunc == NULL) {
412  LOG(llevError, "Plugin error while requesting %s.getPluginProperty: %s\n", libfile, plugins_dlerror());
413  plugins_dlclose(ptr);
414  return -1;
415  }
416  eventfunc = (f_plug_event)plugins_dlsym(ptr, "eventListener");
417  if (eventfunc == NULL) {
418  LOG(llevError, "Plugin error while requesting %s.eventListener: %s\n", libfile, plugins_dlerror());
419  plugins_dlclose(ptr);
420  return -1;
421  }
422  postfunc = (f_plug_postinit)plugins_dlsym(ptr, "postInitPlugin");
423  if (postfunc == NULL) {
424  LOG(llevError, "Plugin error while requesting %s.postInitPlugin: %s\n", libfile, plugins_dlerror());
425  plugins_dlclose(ptr);
426  return -1;
427  }
428  closefunc = (f_plug_postinit)plugins_dlsym(ptr, "closePlugin");
429  if (closefunc == NULL) {
430  LOG(llevError, "Plugin error while requesting %s.closePlugin: %s\n", libfile, plugins_dlerror());
431  plugins_dlclose(ptr);
432  return -1;
433  }
434  i = initfunc("2.0", cfapi_get_hooks);
435  cp = static_cast<crossfire_plugin *>(malloc(sizeof(crossfire_plugin)));
436  for (i = 0; i < NR_EVENTS; i++)
437  cp->global_registration[i] = 0;
438  cp->propfunc = propfunc;
439  cp->closefunc = closefunc;
440  cp->libptr = ptr;
441  propfunc(&i, "Identification", cp->id, sizeof(cp->id));
442  propfunc(&i, "FullName", cp->fullname, sizeof(cp->fullname));
443  events_register_object_handler(cp->id, eventfunc);
444  plugins_list.push_back(cp);
445  postfunc();
446  return 0;
447 }
448 
455 int plugins_remove_plugin(const char *id) {
456  auto plugin = std::find_if(plugins_list.begin(), plugins_list.end(), [&id] (const auto cp) { return strcmp(id, cp->id) == 0; });
457  if (plugin != plugins_list.end()) {
458  crossfire_plugin *cp = *plugin;
459  plugins_list.erase(plugin);
460  for (int eventcode = 0; eventcode < NR_EVENTS; eventcode++) {
461  if (cp->global_registration[eventcode]) {
462  events_unregister_global_handler(eventcode, cp->global_registration[eventcode]);
463  }
464  }
465  events_unregister_object_handler(cp->id);
466  if (cp->closefunc)
467  cp->closefunc();
468  plugins_dlclose(cp->libptr);
469  free(cp);
470  return 0;
471  }
472  return -1;
473 }
474 
480 void plugins_display_list(object *op) {
481  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_DEBUG,
482  "List of loaded plugins:\n-----------------------");
483 
484  for (crossfire_plugin *cp : plugins_list) {
485  draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_DEBUG,
486  "%s, %s",
487  cp->id, cp->fullname);
488  }
489 }
490 
491 /* SYSTEM-RELATED HOOKS */
492 
498 static void cfapi_cost_string_from_value(int *type, ...) {
499  uint64_t cost;
500  char *buffer, *final;
501  int length, largest_coin;
502  va_list args;
503 
504  va_start(args, type);
505  cost = va_arg(args, uint64_t);
506  largest_coin = va_arg(args, int);
507  buffer = va_arg(args, char*);
508  length = va_arg(args, int);
509  va_end(args);
510 
511  *type = CFAPI_NONE;
512 
513  if (length < 1)
514  return;
515 
516  final = cost_string_from_value(cost, largest_coin);
517 
518  strncpy(buffer, final, length - 1);
519  buffer[length - 1] = '\0';
520  free(final);
521 }
522 
528 static void cfapi_system_find_animation(int *type, ...) {
529  va_list args;
530  const char *name;
531  int *num;
532  const Animations *anim;
533 
534  va_start(args, type);
535  name = va_arg(args, const char *);
536  num = va_arg(args, int *);
537  va_end(args);
538 
539  anim = try_find_animation(name);
540  (*num) = anim ? anim->num : 0;
541  *type = CFAPI_INT;
542 }
543 
549 static void cfapi_system_find_face(int *type, ...) {
550  va_list args;
551  const char *face;
552  int error;
553  int *num;
554  const Face *f;
555 
556  va_start(args, type);
557  face = va_arg(args, const char *);
558  error = va_arg(args, int);
559  num = va_arg(args, int *);
560  va_end(args);
561 
562  f = try_find_face(face, get_face_by_id(error));
563  (*num) = f ? f->number : 0;
564  *type = CFAPI_INT;
565 }
566 
572 static void cfapi_system_strdup_local(int *type, ...) {
573  va_list args;
574  const char *txt;
575  char **ret;
576 
577  va_start(args, type);
578  txt = va_arg(args, const char *);
579  ret = va_arg(args, char **);
580  va_end(args);
581 
582  *ret = strdup_local(txt);
583  *type = CFAPI_STRING;
584 }
585 
586 static void cfapi_system_register_global_event(int *type, ...) {
587  va_list args;
588  int eventcode;
589  char *pname;
590  f_plug_event hook;
591  crossfire_plugin *cp;
592 
593  va_start(args, type);
594  eventcode = va_arg(args, int);
595  pname = va_arg(args, char *);
596  hook = va_arg(args, f_plug_event);
597  va_end(args);
598 
599  *type = CFAPI_NONE;
600 
601  cp = plugins_find_plugin(pname);
602  if (!cp->global_registration[eventcode]) {
603  cp->global_registration[eventcode] = events_register_global_handler(eventcode, hook);
604  }
605 }
606 
607 static void cfapi_system_unregister_global_event(int *type, ...) {
608  va_list args;
609  int eventcode;
610  char *pname;
611  crossfire_plugin *cp;
612 
613  va_start(args, type);
614  eventcode = va_arg(args, int);
615  pname = va_arg(args, char *);
616  va_end(args);
617 
618  *type = CFAPI_NONE;
619 
620  cp = plugins_find_plugin(pname);
621  if (cp->global_registration[eventcode]) {
622  events_unregister_global_handler(eventcode, cp->global_registration[eventcode]);
623  cp->global_registration[eventcode] = 0;
624  }
625 }
626 
627 static void cfapi_system_get_object_vector(int *type, ...) {
628  va_list args;
629  va_start(args, type);
630  int property = va_arg(args, int);
631  std::vector<object *> *list = va_arg(args, std::vector<object *> *);
632 
633  *type = CFAPI_OBJECT_VECTOR;
634  switch (property) {
635  case CFAPI_SYSTEM_PLAYERS:
636  for (auto pl = first_player; pl ; pl = pl->next) {
637  list->push_back(pl->ob);
638  }
639  break;
640  case CFAPI_SYSTEM_FRIENDLY_LIST: {
641  auto f = get_next_friend(nullptr);
642  while (f) {
643  list->push_back(f);
644  f = get_next_friend(f);
645  }
646  break;
647  }
648  default:
649  assert(0);
650  }
651 
652  va_end(args);
653 }
654 
655 static void cfapi_system_get_map_vector(int *type, ...) {
656  va_list args;
657  va_start(args, type);
658  int property = va_arg(args, int);
659  std::vector<mapstruct *> *list = va_arg(args, std::vector<mapstruct *> *);
660 
661  *type = CFAPI_MAP_VECTOR;
662  if (property == CFAPI_SYSTEM_MAPS) {
663  for (auto map = first_map; map ; map = map->next) {
664  list->push_back(map);
665  }
666  }
667 
668  va_end(args);
669 }
670 
671 static void cfapi_system_get_archetype_vector(int *type, ...) {
672  va_list args;
673  va_start(args, type);
674  int property = va_arg(args, int);
675  std::vector<archetype *> *list = va_arg(args, std::vector<archetype *> *);
676 
677  *type = CFAPI_ARCHETYPE_VECTOR;
678  if (property == CFAPI_SYSTEM_ARCHETYPES) {
679  getManager()->archetypes()->each([&] (const auto &arch) { list->push_back(arch); });
680  }
681 
682  va_end(args);
683 }
684 
685 static void cfapi_system_get_region_vector(int *type, ...) {
686  va_list args;
687  va_start(args, type);
688  int property = va_arg(args, int);
689  std::vector<region *> *list = va_arg(args, std::vector<region *> *);
690 
691  *type = CFAPI_REGION_VECTOR;
692  if (property == CFAPI_SYSTEM_REGIONS) {
693  *list = all_regions;
694  }
695 
696  va_end(args);
697 }
698 
699 static void cfapi_system_get_party_vector(int *type, ...) {
700  va_list args;
701  va_start(args, type);
702  int property = va_arg(args, int);
703  std::vector<partylist *> *list = va_arg(args, std::vector<partylist *> *);
704 
705  *type = CFAPI_PARTY_VECTOR;
706  if (property == CFAPI_SYSTEM_PARTIES) {
707  auto party = party_get_first();
708  while (party) {
709  list->push_back(party);
710  party = party_get_next(party);
711  }
712  }
713 
714  va_end(args);
715 }
716 
723 static void cfapi_system_add_string(int *type, ...) {
724  va_list args;
725  const char *str;
726  sstring *rv;
727 
728  va_start(args, type);
729  str = va_arg(args, const char *);
730  rv = va_arg(args, sstring *);
731  va_end(args);
732 
733  *rv = add_string(str);
734  *type = CFAPI_SSTRING;
735 }
736 
743 static void cfapi_system_remove_string(int *type, ...) {
744  va_list args;
745  sstring str;
746 
747  va_start(args, type);
748  str = va_arg(args, sstring);
749  va_end(args);
750 
751  free_string(str);
752  *type = CFAPI_NONE;
753 }
754 
761 static void cfapi_system_find_string(int *type, ...) {
762  va_list args;
763  const char *str;
764  sstring *rv;
765 
766  va_start(args, type);
767  str = va_arg(args, const char *);
768  rv = va_arg(args, sstring *);
769  va_end(args);
770 
771  *rv = find_string(str);
772  *type = CFAPI_SSTRING;
773 }
774 
780 static void cfapi_system_check_path(int *type, ...) {
781  va_list args;
782  const char *name;
783  int prepend_dir;
784  int *ret;
785 
786  va_start(args, type);
787 
788  name = va_arg(args, char *);
789  prepend_dir = va_arg(args, int);
790  ret = va_arg(args, int *);
791 
792  *ret = check_path(name, prepend_dir);
793 
794  va_end(args);
795  *type = CFAPI_INT;
796 }
797 
803 static void cfapi_system_re_cmp(int *type, ...) {
804  va_list args;
805  const char *str;
806  const char *regexp;
807  const char **rv;
808 
809  va_start(args, type);
810 
811  str = va_arg(args, char *);
812  regexp = va_arg(args, char *);
813  rv = va_arg(args, const char **);
814 
815  *rv = re_cmp(str, regexp);
816 
817  va_end(args);
818  *type = CFAPI_STRING;
819 }
820 
821 static void cfapi_system_directory(int *type, ...) {
822  va_list args;
823  int dirtype;
824  const char **str;
825 
826  va_start(args, type);
827 
828  dirtype = va_arg(args, int);
829  str = va_arg(args, const char **);
830  va_end(args);
831 
832  *type = CFAPI_STRING;
833 
834  switch (dirtype) {
835  case 0:
836  *str = settings.mapdir;
837  break;
838 
839  case 1:
840  *str = settings.uniquedir;
841  break;
842 
843  case 2:
844  *str = settings.tmpdir;
845  break;
846 
847  case 3:
848  *str = settings.confdir;
849  break;
850 
851  case 4:
852  *str = settings.localdir;
853  break;
854 
855  case 5:
856  *str = settings.playerdir;
857  break;
858 
859  case 6:
860  *str = settings.datadir;
861  break;
862 
863  default:
864  *str = NULL;
865  }
866 }
867 
874 static void cfapi_get_time(int *type, ...) {
875  va_list args;
876  timeofday_t *tod;
877 
878  va_start(args, type);
879  tod = va_arg(args, timeofday_t *);
880  va_end(args);
881 
882  get_tod(tod);
883  *type = CFAPI_NONE;
884 }
885 
886 #define string_get_int(name) \
887  va_list args; \
888  int index; \
889  const char **str; \
890  va_start(args, type); \
891  index = va_arg(args, int); \
892  str = va_arg(args, const char **); \
893  va_end(args); \
894  *str = name(index); \
895  *type = CFAPI_STRING; \
896 
897 
905 static void cfapi_get_season_name(int *type, ...) {
906  string_get_int(get_season_name)
907 }
908 
917 static void cfapi_get_weekday_name(int *type, ...) {
918  string_get_int(get_weekday)
919 }
920 
929 static void cfapi_get_month_name(int *type, ...) {
930  string_get_int(get_month_name)
931 }
932 
941 static void cfapi_get_periodofday_name(int *type, ...) {
942  string_get_int(get_periodofday)
943 }
944 
956 static void cfapi_timer_create(int *type, ...) {
957  va_list args;
958  int res;
959  object *ob;
960  long delay;
961  int mode;
962  int *timer;
963 
964  va_start(args, type);
965  ob = va_arg(args, object *);
966  delay = va_arg(args, long);
967  mode = va_arg(args, int);
968  timer = va_arg(args, int *);
969  va_end(args);
970  *type = CFAPI_INT;
971 
972  *timer = cftimer_find_free_id();
973  if (*timer != TIMER_ERR_ID) {
974  res = cftimer_create(*timer, delay, ob, mode);
975  if (res != TIMER_ERR_NONE)
976  *timer = res;
977  }
978 }
979 
989 static void cfapi_timer_destroy(int *type, ...) {
990  va_list args;
991  int id;
992  int *err;
993 
994  va_start(args, type);
995  id = va_arg(args, int);
996  err = va_arg(args, int *);
997  va_end(args);
998  *type = CFAPI_INT;
999 
1000  *err = cftimer_destroy(id);
1001 }
1002 
1008 static void cfapi_log(int *type, ...) {
1009  va_list args;
1010  LogLevel logLevel;
1011  const char *message;
1012 
1013  va_start(args, type);
1014  logLevel = static_cast<LogLevel>(va_arg(args, int));
1015  message = va_arg(args, const char *);
1016  LOG(logLevel, "%s", message);
1017  va_end(args);
1018 
1019  *type = CFAPI_NONE;
1020 }
1021 
1022 /* MAP RELATED HOOKS */
1023 
1032 static void cfapi_map_get_map(int *type, ...) {
1033  va_list args;
1034  mapstruct **ret;
1035  int ctype;
1036  int x, y;
1037  int16_t nx, ny;
1038  const char *name;
1039  mapstruct *m;
1040 
1041  va_start(args, type);
1042 
1043  ctype = va_arg(args, int);
1044 
1045  switch (ctype) {
1046  case 0:
1047  x = va_arg(args, int);
1048  y = va_arg(args, int);
1049  ret = va_arg(args, mapstruct **);
1050  *ret = get_empty_map(x, y);
1051  break;
1052 
1053  case 1:
1054  name = va_arg(args, const char *);
1055  x = va_arg(args, int);
1056  ret = va_arg(args, mapstruct **);
1057  *ret = ready_map_name(name, x);
1058  break;
1059 
1060  case 2:
1061  m = va_arg(args, mapstruct *);
1062  nx = va_arg(args, int);
1063  ny = va_arg(args, int);
1064  ret = va_arg(args, mapstruct **);
1065  *ret = get_map_from_coord(m, &nx, &ny);
1066  break;
1067 
1068  default:
1069  *type = CFAPI_NONE;
1070  va_end(args);
1071  return;
1072  break;
1073  }
1074  va_end(args);
1075  *type = CFAPI_PMAP;
1076 }
1077 
1083 static void cfapi_map_has_been_loaded(int *type, ...) {
1084  va_list args;
1085  mapstruct **map;
1086  char *string;
1087 
1088  va_start(args, type);
1089  string = va_arg(args, char *);
1090  map = va_arg(args, mapstruct **);
1091  *map = has_been_loaded(string);
1092  va_end(args);
1093  *type = CFAPI_PMAP;
1094 }
1095 
1101 static void cfapi_map_create_path(int *type, ...) {
1102  va_list args;
1103  int ctype, size;
1104  const char *str;
1105  char *name;
1106 
1107  va_start(args, type);
1108 
1109  ctype = va_arg(args, int);
1110  str = va_arg(args, const char *);
1111  name = va_arg(args, char *);
1112  size = va_arg(args, int);
1113  *type = CFAPI_STRING;
1114 
1115  switch (ctype) {
1116  case 0:
1117  create_pathname(str, name, size);
1118  break;
1119 
1120  case 1:
1121  create_overlay_pathname(str, name, MAX_BUF);
1122  break;
1123 
1124 /* case 2:
1125  rv = create_items_path(str);
1126  break;*/
1127 
1128  default:
1129  *type = CFAPI_NONE;
1130  break;
1131  }
1132  va_end(args);
1133 }
1134 
1135 static void cfapi_map_get_map_property(int *type, ...) {
1136  va_list args;
1137  mapstruct *map;
1138  int property;
1139 
1140  int *rint;
1141  mapstruct **rmap;
1142  sstring *rstr;
1143  region **rreg;
1144  int16_t *nx, *ny;
1145  int x, y;
1146 
1147  va_start(args, type);
1148 
1149  map = va_arg(args, mapstruct *);
1150  property = va_arg(args, int);
1151 
1152  switch (property) {
1153  case CFAPI_MAP_PROP_FLAGS:
1154  rmap = va_arg(args, mapstruct **);
1155  x = va_arg(args, int);
1156  y = va_arg(args, int);
1157  nx = va_arg(args, int16_t *);
1158  ny = va_arg(args, int16_t *);
1159  rint = va_arg(args, int *);
1160  *rint = get_map_flags(map, rmap, x, y, nx, ny);
1161  *type = CFAPI_INT;
1162  break;
1163 
1164  case CFAPI_MAP_PROP_DIFFICULTY:
1165  rint = va_arg(args, int *);
1166  *rint = calculate_difficulty(map);
1167  *type = CFAPI_INT;
1168  break;
1169 
1170  case CFAPI_MAP_PROP_PATH:
1171  rstr = va_arg(args, sstring *);
1172  *rstr = map->path;
1173  *type = CFAPI_SSTRING;
1174  break;
1175 
1176  case CFAPI_MAP_PROP_TMPNAME:
1177  rstr = va_arg(args, sstring *);
1178  *rstr = map->tmpname;
1179  *type = CFAPI_SSTRING;
1180  break;
1181 
1182  case CFAPI_MAP_PROP_NAME:
1183  rstr = va_arg(args, sstring *);
1184  *rstr = map->name;
1185  *type = CFAPI_SSTRING;
1186  break;
1187 
1188  case CFAPI_MAP_PROP_RESET_TIME:
1189  rint = va_arg(args, int *);
1190  *rint = map->reset_time;
1191  *type = CFAPI_INT;
1192  break;
1193 
1194  case CFAPI_MAP_PROP_RESET_TIMEOUT:
1195  rint = va_arg(args, int *);
1196  *rint = map->reset_timeout;
1197  *type = CFAPI_INT;
1198  break;
1199 
1200  case CFAPI_MAP_PROP_PLAYERS:
1201  rint = va_arg(args, int *);
1202  *rint = map->players;
1203  *type = CFAPI_INT;
1204  break;
1205 
1206  case CFAPI_MAP_PROP_DARKNESS:
1207  rint = va_arg(args, int *);
1208  *rint = map->darkness;
1209  *type = CFAPI_INT;
1210  break;
1211 
1212  case CFAPI_MAP_PROP_WIDTH:
1213  rint = va_arg(args, int *);
1214  *rint = map->width;
1215  *type = CFAPI_INT;
1216  break;
1217 
1218  case CFAPI_MAP_PROP_HEIGHT:
1219  rint = va_arg(args, int *);
1220  *rint = map->height;
1221  *type = CFAPI_INT;
1222  break;
1223 
1224  case CFAPI_MAP_PROP_ENTER_X:
1225  rint = va_arg(args, int *);
1226  *rint = map->enter_x;
1227  *type = CFAPI_INT;
1228  break;
1229 
1230  case CFAPI_MAP_PROP_ENTER_Y:
1231  rint = va_arg(args, int *);
1232  *rint = map->enter_y;
1233  *type = CFAPI_INT;
1234  break;
1235 
1236  case CFAPI_MAP_PROP_MESSAGE:
1237  rstr = va_arg(args, sstring *);
1238  *rstr = map->msg;
1239  *type = CFAPI_SSTRING;
1240  break;
1241 
1242  case CFAPI_MAP_PROP_NEXT:
1243  rmap = va_arg(args, mapstruct **);
1244  *rmap = map ? map->next : first_map;
1245  *type = CFAPI_PMAP;
1246  break;
1247 
1248  case CFAPI_MAP_PROP_REGION:
1249  rreg = va_arg(args, region **);
1250  *rreg = get_region_by_map(map);
1251  *type = CFAPI_PREGION;
1252  break;
1253 
1254  case CFAPI_MAP_PROP_UNIQUE:
1255  rint = va_arg(args, int *);
1256  *rint = map->unique;
1257  *type = CFAPI_INT;
1258  break;
1259 
1260  default:
1261  *type = CFAPI_NONE;
1262  break;
1263  }
1264  va_end(args);
1265 }
1266 
1267 static void cfapi_map_set_map_property(int *type, ...) {
1268  va_list args;
1269  mapstruct *map;
1270  int property;
1271  const char *buf;
1272 
1273  va_start(args, type);
1274 
1275  map = va_arg(args, mapstruct *);
1276  property = va_arg(args, int);
1277 
1278  switch (property) {
1279  case CFAPI_MAP_PROP_PATH:
1280  buf = va_arg(args, const char *);
1281  strlcpy(map->path, buf, sizeof(map->path));
1282  *type = CFAPI_STRING;
1283  break;
1284 
1285  default:
1286  *type = CFAPI_NONE;
1287  break;
1288  }
1289  va_end(args);
1290 }
1291 
1297 static void cfapi_map_out_of_map(int *type, ...) {
1298  va_list args;
1299  mapstruct *map;
1300  int x, y;
1301  int *rint;
1302 
1303  va_start(args, type);
1304  map = va_arg(args, mapstruct *);
1305  x = va_arg(args, int);
1306  y = va_arg(args, int);
1307  rint = va_arg(args, int *);
1308 
1309  *rint = out_of_map(map, x, y);
1310  va_end(args);
1311  *type = CFAPI_INT;
1312 }
1313 
1319 static void cfapi_map_update_position(int *type, ...) {
1320  va_list args;
1321  mapstruct *map;
1322  int x, y;
1323 
1324  va_start(args, type);
1325 
1326  map = va_arg(args, mapstruct *);
1327  x = va_arg(args, int);
1328  y = va_arg(args, int);
1329 
1330  update_position(map, x, y);
1331  va_end(args);
1332  *type = CFAPI_NONE;
1333 }
1334 
1335 static void cfapi_map_delete_map(int *type, ...) {
1336  va_list args;
1337  mapstruct *map;
1338  va_start(args, type);
1339 
1340  map = va_arg(args, mapstruct *);
1341 
1342  delete_map(map);
1343 
1344  va_end(args);
1345  *type = CFAPI_NONE;
1346 }
1347 
1348 static void cfapi_map_message(int *type, ...) {
1349  va_list args;
1350  mapstruct *map;
1351  const char *string;
1352  int color;
1353 
1354  va_start(args, type);
1355  map = va_arg(args, mapstruct *);
1356  string = va_arg(args, const char *);
1357  color = va_arg(args, int);
1358  va_end(args);
1359 
1360  /* function should be extended to take message types probably */
1361  ext_info_map(color, map, MSG_TYPE_MISC, MSG_SUBTYPE_NONE, string);
1362  *type = CFAPI_NONE;
1363 }
1364 
1370 static void cfapi_map_get_object_at(int *type, ...) {
1371  va_list args;
1372  mapstruct *map;
1373  int x, y;
1374  int16_t sx, sy;
1375  object **robj;
1376 
1377  va_start(args, type);
1378  map = va_arg(args, mapstruct *);
1379  x = va_arg(args, int);
1380  y = va_arg(args, int);
1381  robj = va_arg(args, object **);
1382  va_end(args);
1383 
1384  sx = x;
1385  sy = y;
1386  if (get_map_flags(map, &map, x, y, &sx, &sy)&P_OUT_OF_MAP)
1387  *robj = NULL;
1388  else
1389  *robj = GET_MAP_OB(map, sx, sy);
1390  *type = CFAPI_POBJECT;
1391 }
1392 
1399 static void cfapi_map_find_by_archetype_name(int *type, ...) {
1400  va_list args;
1401  int x, y;
1402  mapstruct *map;
1403  char *msg;
1404  object **robj;
1405 
1406  va_start(args, type);
1407 
1408  msg = va_arg(args, char *);
1409  map = va_arg(args, mapstruct *);
1410  x = va_arg(args, int);
1411  y = va_arg(args, int);
1412  robj = va_arg(args, object **);
1413 
1414  va_end(args);
1415 
1416  archetype *at = try_find_archetype(msg);
1417  *robj = at == NULL ? NULL : map_find_by_archetype(map, x, y, at);
1418  *type = CFAPI_POBJECT;
1419 }
1420 
1426 static void cfapi_map_change_light(int *type, ...) {
1427  va_list args;
1428  int change;
1429  mapstruct *map;
1430  int *rint;
1431 
1432  va_start(args, type);
1433  map = va_arg(args, mapstruct *);
1434  change = va_arg(args, int);
1435  rint = va_arg(args, int *);
1436  va_end(args);
1437 
1438  *type = CFAPI_INT;
1439  *rint = change_map_light(map, change);
1440 }
1441 
1442 /* OBJECT-RELATED HOOKS */
1443 
1457 static void cfapi_object_move(int *type, ...) {
1458  va_list args;
1459  int kind;
1460  object *op;
1461  object *activator;
1462  player *pl;
1463  int direction;
1464  int *ret;
1465 
1466  va_start(args, type);
1467  kind = va_arg(args, int);
1468  switch (kind) {
1469  case 0:
1470  op = va_arg(args, object *);
1471  direction = va_arg(args, int);
1472  activator = va_arg(args, object *);
1473  ret = va_arg(args, int *);
1474  va_end(args);
1475  *ret = move_ob(op, direction, activator);
1476  break;
1477 
1478  case 1:
1479  pl = va_arg(args, player *);
1480  direction = va_arg(args, int);
1481  ret = va_arg(args, int *);
1482  va_end(args);
1483  *ret = move_player(pl->ob, direction);
1484  break;
1485 
1486  case 2:
1487  op = va_arg(args, object *);
1488  ret = va_arg(args, int *);
1489  va_end(args);
1490  *ret = player_arrest(op);
1491  break;
1492 
1493  default:
1494  // Just end the use of variable args. We got a wrong type.
1495  va_end(args);
1496  }
1497  *type = CFAPI_INT;
1498 }
1499 
1507 static void cfapi_object_get_key(int *type, ...) {
1508  va_list args;
1509  const char *keyname;
1510  const char **value;
1511  object *op;
1512 
1513  va_start(args, type);
1514  op = va_arg(args, object *);
1515  keyname = va_arg(args, const char *);
1516  value = va_arg(args, const char **);
1517  va_end(args);
1518 
1519  *value = object_get_value(op, keyname);
1520  *type = CFAPI_SSTRING;
1521 }
1522 
1529 static void cfapi_object_set_key(int *type, ...) {
1530  va_list args;
1531  const char *keyname;
1532  const char *value;
1533  int *ret;
1534  object *op;
1535  int add_key;
1536 
1537  va_start(args, type);
1538  op = va_arg(args, object *);
1539  keyname = va_arg(args, char *);
1540  value = va_arg(args, char *);
1541  add_key = va_arg(args, int);
1542  ret = va_arg(args, int *);
1543  va_end(args);
1544 
1545  *ret = object_set_value(op, keyname, value, add_key);
1546  *type = CFAPI_INT;
1547 }
1548 
1552 static void cfapi_object_get_property(int *type, ...) {
1553  va_list args;
1554  int property;
1555  object *op;
1556  int *rint;
1557  object **robject;
1558  mapstruct **rmap;
1559  float *rfloat;
1560  archetype **rarch;
1561  sstring *rsstring;
1562  char *rbuffer;
1563  int rbufsize;
1564  MoveType *rmove;
1565  int64_t *rint64;
1566  partylist **rparty;
1567  double *rdouble;
1568  long *rlong;
1569 
1570  va_start(args, type);
1571 
1572  op = va_arg(args, object *);
1573  property = va_arg(args, int);
1574  switch (property) {
1575  case CFAPI_OBJECT_PROP_OB_ABOVE:
1576  robject = va_arg(args, object **);
1577  *robject = op->above;
1578  *type = CFAPI_POBJECT;
1579  break;
1580 
1581  case CFAPI_OBJECT_PROP_OB_BELOW:
1582  robject = va_arg(args, object **);
1583  *robject = op->below;
1584  *type = CFAPI_POBJECT;
1585  break;
1586 
1587  case CFAPI_OBJECT_PROP_NEXT_ACTIVE_OB:
1588  robject = va_arg(args, object **);
1589  *robject = op->active_next;
1590  *type = CFAPI_POBJECT;
1591  break;
1592 
1593  case CFAPI_OBJECT_PROP_PREV_ACTIVE_OB:
1594  robject = va_arg(args, object **);
1595  *robject = op->active_prev;
1596  *type = CFAPI_POBJECT;
1597  break;
1598 
1599  case CFAPI_OBJECT_PROP_INVENTORY:
1600  robject = va_arg(args, object **);
1601  *robject = op->inv;
1602  *type = CFAPI_POBJECT;
1603  break;
1604 
1605  case CFAPI_OBJECT_PROP_ENVIRONMENT:
1606  robject = va_arg(args, object **);
1607  *robject = op->env;
1608  *type = CFAPI_POBJECT;
1609  break;
1610 
1611  case CFAPI_OBJECT_PROP_HEAD:
1612  robject = va_arg(args, object **);
1613  *robject = op->head;
1614  *type = CFAPI_POBJECT;
1615  break;
1616 
1617  case CFAPI_OBJECT_PROP_CONTAINER:
1618  robject = va_arg(args, object **);
1619  *robject = op->container;
1620  *type = CFAPI_POBJECT;
1621  break;
1622 
1623  case CFAPI_OBJECT_PROP_MAP:
1624  rmap = va_arg(args, mapstruct **);
1625  *rmap = op->map;
1626  *type = CFAPI_PMAP;
1627  break;
1628 
1629  case CFAPI_OBJECT_PROP_COUNT:
1630  rint = va_arg(args, int *);
1631  *rint = op->count;
1632  *type = CFAPI_INT;
1633  break;
1634 
1635  case CFAPI_OBJECT_PROP_NAME:
1636  rbuffer = va_arg(args, char *);
1637  rbufsize = va_arg(args, int);
1638  query_name(op, rbuffer, rbufsize);
1639  *type = CFAPI_STRING;
1640  break;
1641 
1642  case CFAPI_OBJECT_PROP_NAME_PLURAL:
1643  rsstring = va_arg(args, sstring *);
1644  *rsstring = op->name_pl;
1645  *type = CFAPI_SSTRING;
1646  break;
1647 
1648  case CFAPI_OBJECT_PROP_TITLE:
1649  rsstring = va_arg(args, sstring *);
1650  *rsstring = op->title;
1651  *type = CFAPI_SSTRING;
1652  break;
1653 
1654  case CFAPI_OBJECT_PROP_RACE:
1655  rsstring = va_arg(args, sstring *);
1656  *rsstring = op->race;
1657  *type = CFAPI_SSTRING;
1658  break;
1659 
1660  case CFAPI_OBJECT_PROP_SLAYING:
1661  rsstring = va_arg(args, sstring *);
1662  *rsstring = op->slaying;
1663  *type = CFAPI_SSTRING;
1664  break;
1665 
1666  case CFAPI_OBJECT_PROP_SKILL:
1667  rsstring = va_arg(args, sstring *);
1668  *rsstring = op->skill;
1669  *type = CFAPI_SSTRING;
1670  break;
1671 
1672  case CFAPI_OBJECT_PROP_MESSAGE:
1673  rsstring = va_arg(args, sstring *);
1674  *rsstring = op->msg;
1675  *type = CFAPI_SSTRING;
1676  break;
1677 
1678  case CFAPI_OBJECT_PROP_LORE:
1679  rsstring = va_arg(args, sstring *);
1680  *rsstring = op->lore;
1681  *type = CFAPI_SSTRING;
1682  break;
1683 
1684  case CFAPI_OBJECT_PROP_X:
1685  rint = va_arg(args, int *);
1686  *rint = op->x;
1687  *type = CFAPI_INT;
1688  break;
1689 
1690  case CFAPI_OBJECT_PROP_Y:
1691  rint = va_arg(args, int *);
1692  *rint = op->y;
1693  *type = CFAPI_INT;
1694  break;
1695 
1696  case CFAPI_OBJECT_PROP_SPEED:
1697  rfloat = va_arg(args, float *);
1698  *rfloat = op->speed;
1699  *type = CFAPI_FLOAT;
1700  break;
1701 
1702  case CFAPI_OBJECT_PROP_SPEED_LEFT:
1703  rfloat = va_arg(args, float *);
1704  *rfloat = op->speed_left;
1705  *type = CFAPI_FLOAT;
1706  break;
1707 
1708  case CFAPI_OBJECT_PROP_NROF:
1709  rint = va_arg(args, int *);
1710  *rint = NROF(op);
1711  *type = CFAPI_INT;
1712  break;
1713 
1714  case CFAPI_OBJECT_PROP_DIRECTION:
1715  rint = va_arg(args, int *);
1716  *rint = op->direction;
1717  *type = CFAPI_INT;
1718  break;
1719 
1720  case CFAPI_OBJECT_PROP_FACING:
1721  rint = va_arg(args, int *);
1722  *rint = op->facing;
1723  *type = CFAPI_INT;
1724  break;
1725 
1726  case CFAPI_OBJECT_PROP_TYPE:
1727  rint = va_arg(args, int *);
1728  *rint = op->type;
1729  *type = CFAPI_INT;
1730  break;
1731 
1732  case CFAPI_OBJECT_PROP_SUBTYPE:
1733  rint = va_arg(args, int *);
1734  *rint = op->subtype;
1735  *type = CFAPI_INT;
1736  break;
1737 
1738  case CFAPI_OBJECT_PROP_CLIENT_TYPE:
1739  rint = va_arg(args, int *);
1740  *rint = op->client_type;
1741  *type = CFAPI_INT;
1742  break;
1743 
1744  case CFAPI_OBJECT_PROP_RESIST: {
1745  int idx;
1746  int16_t *resist;
1747 
1748  idx = va_arg(args, int);
1749  resist = va_arg(args, int16_t *);
1750  *resist = op->resist[idx];
1751  }
1752  *type = CFAPI_INT16;
1753  break;
1754 
1755  case CFAPI_OBJECT_PROP_ATTACK_TYPE:
1756  rint = va_arg(args, int *);
1757  *rint = op->attacktype;
1758  *type = CFAPI_INT;
1759  break;
1760 
1761  case CFAPI_OBJECT_PROP_PATH_ATTUNED:
1762  rint = va_arg(args, int *);
1763  *rint = op->path_attuned;
1764  *type = CFAPI_INT;
1765  break;
1766 
1767  case CFAPI_OBJECT_PROP_PATH_REPELLED:
1768  rint = va_arg(args, int *);
1769  *rint = op->path_repelled;
1770  *type = CFAPI_INT;
1771  break;
1772 
1773  case CFAPI_OBJECT_PROP_PATH_DENIED:
1774  rint = va_arg(args, int *);
1775  *rint = op->path_denied;
1776  *type = CFAPI_INT;
1777  break;
1778 
1779  case CFAPI_OBJECT_PROP_MATERIAL:
1780  rint = va_arg(args, int *);
1781  *rint = op->material;
1782  *type = CFAPI_INT;
1783  break;
1784 
1785  case CFAPI_OBJECT_PROP_MATERIAL_NAME:
1786  rsstring = va_arg(args, sstring *);
1787  *rsstring = op->materialname;
1788  *type = CFAPI_SSTRING;
1789  break;
1790 
1791  case CFAPI_OBJECT_PROP_MAGIC:
1792  rint = va_arg(args, int *);
1793  *rint = op->magic;
1794  *type = CFAPI_INT;
1795  break;
1796 
1797  case CFAPI_OBJECT_PROP_VALUE:
1798  rlong = va_arg(args, long *);
1799  *rlong = op->value;
1800  *type = CFAPI_LONG;
1801  break;
1802 
1803  case CFAPI_OBJECT_PROP_LEVEL:
1804  rint = va_arg(args, int *);
1805  *rint = op->level;
1806  *type = CFAPI_INT;
1807  break;
1808 
1809  case CFAPI_OBJECT_PROP_LAST_HEAL:
1810  rint = va_arg(args, int *);
1811  *rint = op->last_heal;
1812  *type = CFAPI_INT;
1813  break;
1814 
1815  case CFAPI_OBJECT_PROP_LAST_SP:
1816  rint = va_arg(args, int *);
1817  *rint = op->last_sp;
1818  *type = CFAPI_INT;
1819  break;
1820 
1821  case CFAPI_OBJECT_PROP_LAST_GRACE:
1822  rint = va_arg(args, int *);
1823  *rint = op->last_grace;
1824  *type = CFAPI_INT;
1825  break;
1826 
1827  case CFAPI_OBJECT_PROP_LAST_EAT:
1828  rint = va_arg(args, int *);
1829  *rint = op->last_eat;
1830  *type = CFAPI_INT;
1831  break;
1832 
1833  case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
1834  rint = va_arg(args, int *);
1835  *rint = op->invisible;
1836  *type = CFAPI_INT;
1837  break;
1838 
1839  case CFAPI_OBJECT_PROP_PICK_UP:
1840  rint = va_arg(args, int *);
1841  *rint = op->pick_up;
1842  *type = CFAPI_INT;
1843  break;
1844 
1845  case CFAPI_OBJECT_PROP_ITEM_POWER:
1846  rint = va_arg(args, int *);
1847  *rint = op->item_power;
1848  *type = CFAPI_INT;
1849  break;
1850 
1851  case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
1852  rint = va_arg(args, int *);
1853  *rint = op->gen_sp_armour;
1854  *type = CFAPI_INT;
1855  break;
1856 
1857  case CFAPI_OBJECT_PROP_WEIGHT:
1858  rint = va_arg(args, int *);
1859  *rint = op->weight;
1860  *type = CFAPI_INT;
1861  break;
1862 
1863  case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
1864  rint = va_arg(args, int *);
1865  *rint = op->weight_limit;
1866  *type = CFAPI_INT;
1867  break;
1868 
1869  case CFAPI_OBJECT_PROP_CARRYING:
1870  rint = va_arg(args, int *);
1871  *rint = op->carrying;
1872  *type = CFAPI_INT;
1873  break;
1874 
1875  case CFAPI_OBJECT_PROP_GLOW_RADIUS:
1876  rint = va_arg(args, int *);
1877  *rint = op->glow_radius;
1878  *type = CFAPI_INT;
1879  break;
1880 
1881  case CFAPI_OBJECT_PROP_TOTAL_EXP:
1882  rint64 = va_arg(args, int64_t *);
1883  *rint64 = op->total_exp;
1884  *type = CFAPI_SINT64;
1885  break;
1886 
1887  case CFAPI_OBJECT_PROP_CURRENT_WEAPON:
1888  robject = va_arg(args, object **);
1889  *robject = op->current_weapon;
1890  *type = CFAPI_POBJECT;
1891  break;
1892 
1893  case CFAPI_OBJECT_PROP_ENEMY:
1894  robject = va_arg(args, object **);
1895  *robject = op->enemy;
1896  *type = CFAPI_POBJECT;
1897  break;
1898 
1899  case CFAPI_OBJECT_PROP_ATTACKED_BY:
1900  robject = va_arg(args, object **);
1901  *robject = op->attacked_by;
1902  *type = CFAPI_POBJECT;
1903  break;
1904 
1905  case CFAPI_OBJECT_PROP_RUN_AWAY:
1906  rint = va_arg(args, int *);
1907  *rint = op->run_away;
1908  *type = CFAPI_INT;
1909  break;
1910 
1911  case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
1912  robject = va_arg(args, object **);
1913  *robject = op->chosen_skill;
1914  *type = CFAPI_POBJECT;
1915  break;
1916 
1917  case CFAPI_OBJECT_PROP_HIDDEN:
1918  rint = va_arg(args, int *);
1919  *rint = op->hide;
1920  *type = CFAPI_INT;
1921  break;
1922 
1923  case CFAPI_OBJECT_PROP_MOVE_STATUS:
1924  rint = va_arg(args, int *);
1925  *rint = op->move_status;
1926  *type = CFAPI_INT;
1927  break;
1928 
1929  case CFAPI_OBJECT_PROP_ATTACK_MOVEMENT:
1930  rint = va_arg(args, int *);
1931  *rint = op->attack_movement;
1932  *type = CFAPI_INT;
1933  break;
1934 
1935  case CFAPI_OBJECT_PROP_SPELL_ITEM:
1936  robject = va_arg(args, object **);
1937  *robject = op->spellitem;
1938  *type = CFAPI_POBJECT;
1939  break;
1940 
1941  case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
1942  rdouble = va_arg(args, double *);
1943  *rdouble = op->expmul;
1944  *type = CFAPI_DOUBLE;
1945  break;
1946 
1947  case CFAPI_OBJECT_PROP_ARCHETYPE:
1948  rarch = va_arg(args, archetype **);
1949  *rarch = op->arch;
1950  *type = CFAPI_PARCH;
1951  break;
1952 
1953  case CFAPI_OBJECT_PROP_OTHER_ARCH:
1954  rarch = va_arg(args, archetype **);
1955  *rarch = op->other_arch;
1956  *type = CFAPI_PARCH;
1957  break;
1958 
1959  case CFAPI_OBJECT_PROP_CUSTOM_NAME:
1960  rsstring = va_arg(args, sstring *);
1961  *rsstring = object_get_value(op, CUSTOM_NAME_FIELD);
1962  *type = CFAPI_SSTRING;
1963  break;
1964 
1965  case CFAPI_OBJECT_PROP_ANIM_SPEED:
1966  rint = va_arg(args, int *);
1967  *rint = op->anim_speed;
1968  *type = CFAPI_INT;
1969  break;
1970 
1971  case CFAPI_OBJECT_PROP_FRIENDLY:
1972  rint = va_arg(args, int *);
1973  *rint = is_friendly(op);
1974  *type = CFAPI_INT;
1975  break;
1976 
1977  case CFAPI_OBJECT_PROP_SHORT_NAME:
1978  rbuffer = va_arg(args, char *);
1979  rbufsize = va_arg(args, int);
1980  query_short_name(op, rbuffer, rbufsize);
1981  *type = CFAPI_STRING;
1982  break;
1983 
1984  case CFAPI_OBJECT_PROP_BASE_NAME: {
1985  int i;
1986 
1987  i = va_arg(args, int);
1988  rbuffer = va_arg(args, char *);
1989  rbufsize = va_arg(args, int);
1990  query_base_name(op, i, rbuffer, rbufsize);
1991  *type = CFAPI_STRING;
1992  }
1993  break;
1994 
1995  case CFAPI_OBJECT_PROP_RAW_NAME:
1996  rsstring = va_arg(args, sstring *);
1997  *rsstring = op->name;
1998  *type = CFAPI_SSTRING;
1999  break;
2000 
2001  case CFAPI_OBJECT_PROP_MAGICAL:
2002  rint = va_arg(args, int *);
2003  *rint = is_magical(op);
2004  *type = CFAPI_INT;
2005  break;
2006 
2007  case CFAPI_OBJECT_PROP_LUCK:
2008  rint = va_arg(args, int *);
2009  *rint = op->stats.luck;
2010  *type = CFAPI_INT;
2011  break;
2012 
2013  case CFAPI_OBJECT_PROP_EXP:
2014  rint64 = va_arg(args, int64_t *);
2015  *rint64 = op->stats.exp;
2016  *type = CFAPI_SINT64;
2017  break;
2018 
2019  case CFAPI_OBJECT_PROP_OWNER:
2020  robject = va_arg(args, object **);
2021  *robject = object_get_owner(op);
2022  *type = CFAPI_POBJECT;
2023  break;
2024 
2025  case CFAPI_OBJECT_PROP_PRESENT: {
2026  int stype;
2027 
2028  stype = va_arg(args, int);
2029  switch (stype) {
2030  unsigned char ptype;
2031  char *buf;
2032  archetype *at;
2033 
2034  case 0: /* present_in_ob */
2035  ptype = (unsigned char)(va_arg(args, int));
2036  robject = va_arg(args, object **);
2037  *robject = object_present_in_ob(ptype, op);
2038  break;
2039 
2040  case 1: /* present_in_ob_by_name */
2041  ptype = (unsigned char)(va_arg(args, int));
2042  buf = va_arg(args, char *);
2043  robject = va_arg(args, object **);
2044  *robject = object_present_in_ob_by_name(ptype, buf, op);
2045  break;
2046 
2047  case 2: /* arch_present_in_ob */
2048  at = va_arg(args, archetype *);
2049  robject = va_arg(args, object **);
2050  *robject = arch_present_in_ob(at, op);
2051  break;
2052  }
2053  }
2054  *type = CFAPI_POBJECT;
2055  break;
2056 
2057  case CFAPI_OBJECT_PROP_CHEATER:
2058  rint = va_arg(args, int *);
2059  *rint = (QUERY_FLAG(op, FLAG_WAS_WIZ));
2060  *type = CFAPI_INT;
2061  break;
2062 
2063  case CFAPI_OBJECT_PROP_MERGEABLE: {
2064  object *op2;
2065 
2066  op2 = va_arg(args, object *);
2067  rint = va_arg(args, int *);
2068  *rint = object_can_merge(op, op2);
2069  }
2070  *type = CFAPI_INT;
2071  break;
2072 
2073  case CFAPI_OBJECT_PROP_PICKABLE: {
2074  object *op2;
2075 
2076  op2 = va_arg(args, object *);
2077  rint = va_arg(args, int *);
2078  *rint = object_can_pick(op2, op);
2079  }
2080  *type = CFAPI_INT;
2081  break;
2082 
2083  case CFAPI_OBJECT_PROP_FLAGS: {
2084  int fl;
2085 
2086  fl = va_arg(args, int);
2087  rint = va_arg(args, int *);
2088  *rint = QUERY_FLAG(op, fl);
2089  }
2090  *type = CFAPI_INT;
2091  break;
2092 
2093  case CFAPI_OBJECT_PROP_STR:
2094  rint = va_arg(args, int *);
2095  *rint = op->stats.Str;
2096  *type = CFAPI_INT;
2097  break;
2098 
2099  case CFAPI_OBJECT_PROP_DEX:
2100  rint = va_arg(args, int *);
2101  *rint = op->stats.Dex;
2102  *type = CFAPI_INT;
2103  break;
2104 
2105  case CFAPI_OBJECT_PROP_CON:
2106  rint = va_arg(args, int *);
2107  *rint = op->stats.Con;
2108  *type = CFAPI_INT;
2109  break;
2110 
2111  case CFAPI_OBJECT_PROP_WIS:
2112  rint = va_arg(args, int *);
2113  *rint = op->stats.Wis;
2114  *type = CFAPI_INT;
2115  break;
2116 
2117  case CFAPI_OBJECT_PROP_INT:
2118  rint = va_arg(args, int *);
2119  *rint = op->stats.Int;
2120  *type = CFAPI_INT;
2121  break;
2122 
2123  case CFAPI_OBJECT_PROP_POW:
2124  rint = va_arg(args, int *);
2125  *rint = op->stats.Pow;
2126  *type = CFAPI_INT;
2127  break;
2128 
2129  case CFAPI_OBJECT_PROP_CHA:
2130  rint = va_arg(args, int *);
2131  *rint = op->stats.Cha;
2132  *type = CFAPI_INT;
2133  break;
2134 
2135  case CFAPI_OBJECT_PROP_WC:
2136  rint = va_arg(args, int *);
2137  *rint = op->stats.wc;
2138  *type = CFAPI_INT;
2139  break;
2140 
2141  case CFAPI_OBJECT_PROP_AC:
2142  rint = va_arg(args, int *);
2143  *rint = op->stats.ac;
2144  *type = CFAPI_INT;
2145  break;
2146 
2147  case CFAPI_OBJECT_PROP_HP:
2148  rint = va_arg(args, int *);
2149  *rint = op->stats.hp;
2150  *type = CFAPI_INT;
2151  break;
2152 
2153  case CFAPI_OBJECT_PROP_SP:
2154  rint = va_arg(args, int *);
2155  *rint = op->stats.sp;
2156  *type = CFAPI_INT;
2157  break;
2158 
2159  case CFAPI_OBJECT_PROP_GP:
2160  rint = va_arg(args, int *);
2161  *rint = op->stats.grace;
2162  *type = CFAPI_INT;
2163  break;
2164 
2165  case CFAPI_OBJECT_PROP_FP:
2166  rint = va_arg(args, int *);
2167  *rint = op->stats.food;
2168  *type = CFAPI_INT;
2169  break;
2170 
2171  case CFAPI_OBJECT_PROP_MAXHP:
2172  rint = va_arg(args, int *);
2173  *rint = op->stats.maxhp;
2174  *type = CFAPI_INT;
2175  break;
2176 
2177  case CFAPI_OBJECT_PROP_MAXSP:
2178  rint = va_arg(args, int *);
2179  *rint = op->stats.maxsp;
2180  *type = CFAPI_INT;
2181  break;
2182 
2183  case CFAPI_OBJECT_PROP_MAXGP:
2184  rint = va_arg(args, int *);
2185  *rint = op->stats.maxgrace;
2186  *type = CFAPI_INT;
2187  break;
2188 
2189  case CFAPI_OBJECT_PROP_DAM:
2190  rint = va_arg(args, int *);
2191  *rint = op->stats.dam;
2192  *type = CFAPI_INT;
2193  break;
2194 
2195  case CFAPI_OBJECT_PROP_GOD:
2196  rsstring = va_arg(args, sstring *);
2197  *rsstring = determine_god(op);
2198  *type = CFAPI_SSTRING;
2199  break;
2200 
2201  case CFAPI_OBJECT_PROP_ARCH_NAME:
2202  rsstring = va_arg(args, sstring *);
2203  *rsstring = op->arch->name;
2204  *type = CFAPI_SSTRING;
2205  break;
2206 
2207  case CFAPI_OBJECT_PROP_INVISIBLE:
2208  rint = va_arg(args, int *);
2209  *rint = op->invisible;
2210  *type = CFAPI_INT;
2211  break;
2212 
2213  case CFAPI_OBJECT_PROP_FACE:
2214  rsstring = va_arg(args, sstring *);
2215  if (op->face != NULL) {
2216  (*rsstring) = op->face->name;
2217  }
2218  else {
2219  (*rsstring) = NULL;
2220  }
2221  *type = CFAPI_SSTRING;
2222  break;
2223 
2224  case CFAPI_OBJECT_PROP_ANIMATION:
2225  rsstring = va_arg(args, sstring *);
2226  if (op->animation != NULL) {
2227  (*rsstring) = op->animation->name;
2228  }
2229  else {
2230  (*rsstring) = NULL;
2231  }
2232  *type = CFAPI_SSTRING;
2233  break;
2234 
2235  case CFAPI_PLAYER_PROP_COUNT:
2236  rint = va_arg(args, int *);
2237  *rint = op->contr->count;
2238  *type = CFAPI_INT;
2239  break;
2240 
2241  case CFAPI_PLAYER_PROP_IP:
2242  rsstring = va_arg(args, sstring *);
2243  *rsstring = op->contr->socket->host;
2244  *type = CFAPI_SSTRING;
2245  break;
2246 
2247  case CFAPI_PLAYER_PROP_MARKED_ITEM:
2248  robject = va_arg(args, object **);
2249  *robject = find_marked_object(op);
2250  *type = CFAPI_POBJECT;
2251  break;
2252 
2253  case CFAPI_PLAYER_PROP_PARTY:
2254  rparty = va_arg(args, partylist **);
2255  *rparty = (op->contr ? op->contr->party : NULL);
2256  *type = CFAPI_PPARTY;
2257  break;
2258 
2259  case CFAPI_PLAYER_PROP_NEXT:
2260  robject = va_arg(args, object **);
2261  if (op)
2262  *robject = op->contr->next ? op->contr->next->ob : NULL;
2263  else
2264  /* This can be called when there is no player. */
2265  *robject = first_player ? first_player->ob : NULL;
2266  *type = CFAPI_POBJECT;
2267  break;
2268 
2269  case CFAPI_PLAYER_PROP_TITLE:
2270  rbuffer = va_arg(args, char *);
2271  rbufsize = va_arg(args, int);
2272  player_get_title(op->contr, rbuffer, rbufsize);
2273  *type = CFAPI_STRING;
2274  break;
2275 
2276  case CFAPI_PLAYER_PROP_TRANSPORT:
2277  robject = va_arg(args, object **);
2278  *robject = op->contr->transport;
2279  *type = CFAPI_POBJECT;
2280  break;
2281 
2282  case CFAPI_OBJECT_PROP_MOVE_TYPE:
2283  rmove = va_arg(args, MoveType *);
2284  *rmove = op->move_type;
2285  *type = CFAPI_MOVETYPE;
2286  break;
2287 
2288  case CFAPI_OBJECT_PROP_MOVE_BLOCK:
2289  rmove = va_arg(args, MoveType *);
2290  *rmove = op->move_block;
2291  *type = CFAPI_MOVETYPE;
2292  break;
2293 
2294  case CFAPI_OBJECT_PROP_MOVE_ALLOW:
2295  rmove = va_arg(args, MoveType *);
2296  *rmove = op->move_allow;
2297  *type = CFAPI_MOVETYPE;
2298  break;
2299 
2300  case CFAPI_OBJECT_PROP_MOVE_ON:
2301  rmove = va_arg(args, MoveType *);
2302  *rmove = op->move_on;
2303  *type = CFAPI_MOVETYPE;
2304  break;
2305 
2306  case CFAPI_OBJECT_PROP_MOVE_OFF:
2307  rmove = va_arg(args, MoveType *);
2308  *rmove = op->move_off;
2309  *type = CFAPI_MOVETYPE;
2310  break;
2311 
2312  case CFAPI_OBJECT_PROP_MOVE_SLOW:
2313  rmove = va_arg(args, MoveType *);
2314  *rmove = op->move_type;
2315  *type = CFAPI_MOVETYPE;
2316  break;
2317 
2318  case CFAPI_OBJECT_PROP_MOVE_SLOW_PENALTY:
2319  rfloat = va_arg(args, float *);
2320  *rfloat = op->move_slow_penalty;
2321  *type = CFAPI_FLOAT;
2322  break;
2323 
2324  case CFAPI_PLAYER_PROP_BED_MAP:
2325  rbuffer = va_arg(args, char *);
2326  rbufsize = va_arg(args, int);
2327  strlcpy(rbuffer, op->contr->savebed_map, rbufsize);
2328  *type = CFAPI_STRING;
2329  break;
2330 
2331  case CFAPI_PLAYER_PROP_BED_X:
2332  rint = va_arg(args, int *);
2333  *rint = op->contr->bed_x;
2334  *type = CFAPI_INT;
2335  break;
2336 
2337  case CFAPI_PLAYER_PROP_BED_Y:
2338  rint = va_arg(args, int *);
2339  *rint = op->contr->bed_y;
2340  *type = CFAPI_INT;
2341  break;
2342 
2343  case CFAPI_OBJECT_PROP_DURATION:
2344  rint = va_arg(args, int *);
2345  *rint = op->duration;
2346  *type = CFAPI_INT;
2347  break;
2348 
2349  default:
2350  *type = CFAPI_NONE;
2351  break;
2352  }
2353  va_end(args);
2354 }
2355 
2364 static void copy_message(object *op, const char *msg) {
2365  /* need to reset parsed dialog information */
2366  free_dialog_information(op);
2367  if (strlen(msg) == 0) {
2368  msg = NULL;
2369  }
2370  object_set_msg(op, msg);
2371 }
2372 
2381 static void cfapi_object_set_property(int *type, ...) {
2382  va_list args;
2383  int iarg, *ret;
2384  long larg;
2385  char *sarg;
2386  double darg;
2387  object *oparg;
2388  object *op;
2389  int property;
2390  int64_t s64arg;
2391  partylist *partyarg;
2392  float farg;
2393  MoveType *move; /* MoveType can't be used through va_arg so use MoveType * */
2394 
2395  va_start(args, type);
2396  op = va_arg(args, object *);
2397  property = va_arg(args, int);
2398  *type = CFAPI_NONE;
2399 
2400  if (op != NULL && (!op->arch || (op != &op->arch->clone))) {
2401  switch (property) {
2402  case CFAPI_OBJECT_PROP_NAME:
2403  sarg = va_arg(args, char *);
2404  *type = CFAPI_STRING;
2405  FREE_AND_COPY(op->name, sarg);
2406  send_changed_object(op);
2407  break;
2408 
2409  case CFAPI_OBJECT_PROP_NAME_PLURAL:
2410  sarg = va_arg(args, char *);
2411  *type = CFAPI_STRING;
2412  FREE_AND_COPY(op->name_pl, sarg);
2413  send_changed_object(op);
2414  break;
2415 
2416  case CFAPI_OBJECT_PROP_TITLE:
2417  sarg = va_arg(args, char *);
2418  *type = CFAPI_STRING;
2419  FREE_AND_COPY(op->title, sarg);
2420  break;
2421 
2422  case CFAPI_OBJECT_PROP_RACE:
2423  sarg = va_arg(args, char *);
2424  *type = CFAPI_STRING;
2425  FREE_AND_COPY(op->race, sarg);
2426  break;
2427 
2428  case CFAPI_OBJECT_PROP_SLAYING:
2429  sarg = va_arg(args, char *);
2430  *type = CFAPI_STRING;
2431  FREE_AND_COPY(op->slaying, sarg);
2432  break;
2433 
2434  case CFAPI_OBJECT_PROP_SKILL:
2435  sarg = va_arg(args, char *);
2436  *type = CFAPI_STRING;
2437  FREE_AND_COPY(op->skill, sarg);
2438  break;
2439 
2440  case CFAPI_OBJECT_PROP_MESSAGE:
2441  sarg = va_arg(args, char *);
2442  *type = CFAPI_STRING;
2443  copy_message(op, sarg);
2444  break;
2445 
2446  case CFAPI_OBJECT_PROP_LORE:
2447  sarg = va_arg(args, char *);
2448  *type = CFAPI_STRING;
2449  FREE_AND_COPY(op->lore, sarg);
2450  break;
2451 
2452  case CFAPI_OBJECT_PROP_SPEED:
2453  farg = va_arg(args, double);
2454  *type = CFAPI_FLOAT;
2455  if (farg != op->speed) {
2456  op->speed = farg;
2457  object_update_speed(op);
2458  }
2459  break;
2460 
2461  case CFAPI_OBJECT_PROP_SPEED_LEFT:
2462  farg = va_arg(args, double);
2463  *type = CFAPI_FLOAT;
2464  op->speed_left = farg;
2465  break;
2466 
2467  case CFAPI_OBJECT_PROP_NROF:
2468  iarg = va_arg(args, int);
2469  *type = CFAPI_INT;
2470  if (iarg < 0)
2471  iarg = 0;
2472  if (op->nrof > (uint32_t)iarg)
2473  object_decrease_nrof(op, op->nrof-iarg);
2474  else if (op->nrof < (uint32_t)iarg) {
2475  object *tmp;
2476  player *pl;
2477 
2478  op->nrof = iarg;
2479  if (op->env != NULL) {
2480  tmp = object_get_player_container(op->env);
2481  if (!tmp) {
2482  for (pl = first_player; pl; pl = pl->next)
2483  if (pl->ob->container == op->env)
2484  break;
2485  if (pl)
2486  tmp = pl->ob;
2487  else
2488  tmp = NULL;
2489  } else {
2490  object_sum_weight(tmp);
2491  fix_object(tmp);
2492  }
2493  if (tmp)
2494  esrv_update_item(UPD_NROF, tmp, op);
2495  } else {
2496  FOR_ABOVE_PREPARE(op, tmp)
2497  if (tmp->type == PLAYER)
2498  tmp->contr->socket->update_look = 1;
2499  FOR_ABOVE_FINISH();
2500  }
2501  }
2502  break;
2503 
2504  case CFAPI_OBJECT_PROP_DIRECTION:
2505  iarg = va_arg(args, int);
2506  *type = CFAPI_INT;
2507  op->direction = iarg;
2508  break;
2509 
2510  case CFAPI_OBJECT_PROP_FACING:
2511  iarg = va_arg(args, int);
2512  *type = CFAPI_INT;
2513  op->facing = iarg;
2514  break;
2515 
2516  case CFAPI_OBJECT_PROP_RESIST: {
2517  int iargbis = va_arg(args, int);
2518 
2519  *type = CFAPI_INT16;
2520  iarg = va_arg(args, int);
2521  op->resist[iargbis] = iarg;
2522  }
2523  break;
2524 
2525  case CFAPI_OBJECT_PROP_ATTACK_TYPE:
2526  iarg = va_arg(args, int);
2527  *type = CFAPI_INT;
2528  op->attacktype = iarg;
2529  break;
2530 
2531  case CFAPI_OBJECT_PROP_PATH_ATTUNED:
2532  iarg = va_arg(args, int);
2533  *type = CFAPI_INT;
2534  op->path_attuned = iarg;
2535  break;
2536 
2537  case CFAPI_OBJECT_PROP_PATH_REPELLED:
2538  iarg = va_arg(args, int);
2539  *type = CFAPI_INT;
2540  op->path_repelled = iarg;
2541  break;
2542 
2543  case CFAPI_OBJECT_PROP_PATH_DENIED:
2544  iarg = va_arg(args, int);
2545  *type = CFAPI_INT;
2546  op->path_denied = iarg;
2547  break;
2548 
2549  case CFAPI_OBJECT_PROP_MATERIAL:
2550  iarg = va_arg(args, int);
2551  *type = CFAPI_INT;
2552  op->material = iarg;
2553  break;
2554 
2555  case CFAPI_OBJECT_PROP_MATERIAL_NAME:
2556  break;
2557 
2558  case CFAPI_OBJECT_PROP_MAGIC:
2559  iarg = va_arg(args, int);
2560  *type = CFAPI_INT;
2561  op->magic = iarg;
2562  break;
2563 
2564  case CFAPI_OBJECT_PROP_VALUE:
2565  larg = va_arg(args, long);
2566  *type = CFAPI_LONG;
2567  op->value = larg;
2568  break;
2569 
2570  case CFAPI_OBJECT_PROP_LEVEL:
2571  iarg = va_arg(args, int);
2572  *type = CFAPI_INT;
2573  op->level = iarg;
2574  send_changed_object(op);
2575  break;
2576 
2577  case CFAPI_OBJECT_PROP_LAST_HEAL:
2578  iarg = va_arg(args, int);
2579  *type = CFAPI_INT;
2580  op->last_heal = iarg;
2581  break;
2582 
2583  case CFAPI_OBJECT_PROP_LAST_SP:
2584  iarg = va_arg(args, int);
2585  *type = CFAPI_INT;
2586  op->last_sp = iarg;
2587  break;
2588 
2589  case CFAPI_OBJECT_PROP_LAST_GRACE:
2590  iarg = va_arg(args, int);
2591  *type = CFAPI_INT;
2592  op->last_grace = iarg;
2593  break;
2594 
2595  case CFAPI_OBJECT_PROP_LAST_EAT:
2596  iarg = va_arg(args, int);
2597  *type = CFAPI_INT;
2598  op->last_eat = iarg;
2599  break;
2600 
2601  case CFAPI_OBJECT_PROP_INVISIBLE_TIME:
2602  iarg = va_arg(args, int);
2603  *type = CFAPI_INT;
2604  op->invisible = iarg;
2605  break;
2606 
2607  case CFAPI_OBJECT_PROP_PICK_UP:
2608  iarg = va_arg(args, int);
2609  *type = CFAPI_INT;
2610  op->pick_up = iarg;
2611  break;
2612 
2613  case CFAPI_OBJECT_PROP_ITEM_POWER:
2614  iarg = va_arg(args, int);
2615  *type = CFAPI_INT;
2616  op->item_power = iarg;
2617  break;
2618 
2619  case CFAPI_OBJECT_PROP_GEN_SP_ARMOUR:
2620  iarg = va_arg(args, int);
2621  *type = CFAPI_INT;
2622  op->gen_sp_armour = iarg;
2623  break;
2624 
2625  case CFAPI_OBJECT_PROP_WEIGHT:
2626  iarg = va_arg(args, int);
2627  *type = CFAPI_INT;
2628  if (op->weight != iarg) {
2629  object *tmp;
2630  player *pl;
2631 
2632  op->weight = iarg;
2633  if (op->env != NULL) {
2634  tmp = object_get_player_container(op->env);
2635  if (!tmp) {
2636  for (pl = first_player; pl; pl = pl->next)
2637  if (pl->ob->container == op->env)
2638  break;
2639  if (pl)
2640  tmp = pl->ob;
2641  else
2642  tmp = NULL;
2643  } else {
2644  object_sum_weight(tmp);
2645  fix_object(tmp);
2646  }
2647  if (tmp)
2648  esrv_update_item(UPD_WEIGHT, tmp, op);
2649  } else {
2650  FOR_ABOVE_PREPARE(op, tmp)
2651  if (tmp->type == PLAYER)
2652  esrv_update_item(UPD_WEIGHT, tmp, op);
2653  FOR_ABOVE_FINISH();
2654  }
2655  }
2656  break;
2657 
2658  case CFAPI_OBJECT_PROP_WEIGHT_LIMIT:
2659  iarg = va_arg(args, int);
2660  *type = CFAPI_INT;
2661  op->weight_limit = iarg;
2662  break;
2663 
2664  case CFAPI_OBJECT_PROP_GLOW_RADIUS:
2665  iarg = va_arg(args, int);
2666  *type = CFAPI_INT;
2667  if (op->glow_radius != iarg) {
2668  object *tmp;
2669 
2670  op->glow_radius = iarg;
2671  tmp = object_get_env_recursive(op);
2672  if (tmp->map != NULL) {
2673  SET_MAP_FLAGS(tmp->map, tmp->x, tmp->y, P_NEED_UPDATE);
2674  update_position(tmp->map, tmp->x, tmp->y);
2675  update_all_los(tmp->map, tmp->x, tmp->y);
2676  }
2677  }
2678  break;
2679 
2680  case CFAPI_OBJECT_PROP_TOTAL_EXP:
2681  s64arg = va_arg(args, int64_t);
2682  *type = CFAPI_SINT64;
2683  op->total_exp = s64arg;
2684  break;
2685 
2686  case CFAPI_OBJECT_PROP_ENEMY:
2687  oparg = va_arg(args, object *);
2688  *type = CFAPI_POBJECT;
2689  object_set_enemy(op, oparg);
2690  break;
2691 
2692  case CFAPI_OBJECT_PROP_RUN_AWAY:
2693  iarg = va_arg(args, int);
2694  *type = CFAPI_INT;
2695  op->run_away = iarg;
2696  break;
2697 
2698  case CFAPI_OBJECT_PROP_CHOSEN_SKILL:
2699  oparg = va_arg(args, object *);
2700  *type = CFAPI_POBJECT;
2701  op->chosen_skill = oparg;
2702  break;
2703 
2704  case CFAPI_OBJECT_PROP_HIDDEN:
2705  iarg = va_arg(args, int);
2706  *type = CFAPI_INT;
2707  op->hide = iarg;
2708  break;
2709 
2710  case CFAPI_OBJECT_PROP_MOVE_STATUS:
2711  iarg = va_arg(args, int);
2712  *type = CFAPI_INT;
2713  op->move_status = iarg;
2714  break;
2715 
2716  case CFAPI_OBJECT_PROP_ATTACK_MOVEMENT:
2717  iarg = va_arg(args, int);
2718  *type = CFAPI_INT;
2719  op->attack_movement = iarg;
2720  break;
2721 
2722  case CFAPI_OBJECT_PROP_SPELL_ITEM:
2723  oparg = va_arg(args, object *);
2724  *type = CFAPI_POBJECT;
2725  op->spellitem = oparg;
2726  break;
2727 
2728  case CFAPI_OBJECT_PROP_EXP_MULTIPLIER:
2729  darg = va_arg(args, double);
2730  *type = CFAPI_DOUBLE;
2731  op->expmul = darg;
2732  break;
2733 
2734  case CFAPI_OBJECT_PROP_CUSTOM_NAME:
2735  sarg = va_arg(args, char *);
2736  *type = CFAPI_STRING;
2737  object_set_value(op, CUSTOM_NAME_FIELD, sarg, 1);
2738  send_changed_object(op);
2739  break;
2740 
2741  case CFAPI_OBJECT_PROP_ANIM_SPEED:
2742  iarg = va_arg(args, int);
2743  *type = CFAPI_INT;
2744  op->anim_speed = iarg;
2745  break;
2746 
2747  case CFAPI_OBJECT_PROP_FRIENDLY:
2748  iarg = va_arg(args, int);
2749  *type = CFAPI_INT;
2750  if (iarg == 1 && is_friendly(op) == 0)
2751  add_friendly_object(op);
2752  else if (iarg == 0 && is_friendly(op) == 1)
2753  remove_friendly_object(op);
2754  break;
2755 
2756  case CFAPI_OBJECT_PROP_LUCK:
2757  iarg = va_arg(args, int);
2758  *type = CFAPI_INT;
2759  op->stats.luck = iarg;
2760  break;
2761 
2762  case CFAPI_OBJECT_PROP_EXP:
2763  s64arg = va_arg(args, int64_t);
2764  *type = CFAPI_SINT64;
2765  op->stats.exp = s64arg;
2766  break;
2767 
2768  case CFAPI_OBJECT_PROP_OWNER:
2769  oparg = va_arg(args, object *);
2770  *type = CFAPI_POBJECT;
2771  object_set_owner(op, oparg);
2772  break;
2773 
2774  case CFAPI_OBJECT_PROP_CHEATER:
2775  object_set_cheat(op);
2776  *type = CFAPI_NONE;
2777  break;
2778 
2779  case CFAPI_OBJECT_PROP_FLAGS: {
2780  int iargbis;
2781 
2782  iarg = va_arg(args, int);
2783  iargbis = va_arg(args, int);
2784  *type = CFAPI_INT;
2785 
2786  if (iargbis == 1)
2787  SET_FLAG(op, iarg);
2788  else
2789  CLEAR_FLAG(op, iarg);
2790  send_changed_object(op);
2791  }
2792  break;
2793 
2794  case CFAPI_OBJECT_PROP_STR:
2795  iarg = va_arg(args, int);
2796  *type = CFAPI_INT;
2797  op->stats.Str = iarg;
2798  break;
2799 
2800  case CFAPI_OBJECT_PROP_DEX:
2801  iarg = va_arg(args, int);
2802  *type = CFAPI_INT;
2803  op->stats.Dex = iarg;
2804  break;
2805 
2806  case CFAPI_OBJECT_PROP_CON:
2807  iarg = va_arg(args, int);
2808  *type = CFAPI_INT;
2809  op->stats.Con = iarg;
2810  break;
2811 
2812  case CFAPI_OBJECT_PROP_WIS:
2813  iarg = va_arg(args, int);
2814  *type = CFAPI_INT;
2815  op->stats.Wis = iarg;
2816  break;
2817 
2818  case CFAPI_OBJECT_PROP_INT:
2819  iarg = va_arg(args, int);
2820  *type = CFAPI_INT;
2821  op->stats.Int = iarg;
2822  break;
2823 
2824  case CFAPI_OBJECT_PROP_POW:
2825  iarg = va_arg(args, int);
2826  *type = CFAPI_INT;
2827  op->stats.Pow = iarg;
2828  break;
2829 
2830  case CFAPI_OBJECT_PROP_CHA:
2831  iarg = va_arg(args, int);
2832  *type = CFAPI_INT;
2833  op->stats.Cha = iarg;
2834  break;
2835 
2836  case CFAPI_OBJECT_PROP_WC:
2837  iarg = va_arg(args, int);
2838  *type = CFAPI_INT;
2839  op->stats.wc = iarg;
2840  break;
2841 
2842  case CFAPI_OBJECT_PROP_AC:
2843  iarg = va_arg(args, int);
2844  *type = CFAPI_INT;
2845  op->stats.ac = iarg;
2846  break;
2847 
2848  case CFAPI_OBJECT_PROP_HP:
2849  iarg = va_arg(args, int);
2850  *type = CFAPI_INT;
2851  op->stats.hp = iarg;
2852  break;
2853 
2854  case CFAPI_OBJECT_PROP_SP:
2855  iarg = va_arg(args, int);
2856  *type = CFAPI_INT;
2857  op->stats.sp = iarg;
2858  break;
2859 
2860  case CFAPI_OBJECT_PROP_GP:
2861  iarg = va_arg(args, int);
2862  *type = CFAPI_INT;
2863  op->stats.grace = iarg;
2864  break;
2865 
2866  case CFAPI_OBJECT_PROP_FP:
2867  iarg = va_arg(args, int);
2868  *type = CFAPI_INT;
2869  op->stats.food = iarg;
2870  break;
2871 
2872  case CFAPI_OBJECT_PROP_MAXHP:
2873  iarg = va_arg(args, int);
2874  *type = CFAPI_INT;
2875  op->stats.maxhp = iarg;
2876  break;
2877 
2878  case CFAPI_OBJECT_PROP_MAXSP:
2879  iarg = va_arg(args, int);
2880  *type = CFAPI_INT;
2881  op->stats.maxsp = iarg;
2882  break;
2883 
2884  case CFAPI_OBJECT_PROP_MAXGP:
2885  iarg = va_arg(args, int);
2886  *type = CFAPI_INT;
2887  op->stats.maxgrace = iarg;
2888  break;
2889 
2890  case CFAPI_OBJECT_PROP_DAM:
2891  iarg = va_arg(args, int);
2892  *type = CFAPI_INT;
2893  op->stats.dam = iarg;
2894  break;
2895 
2896  case CFAPI_OBJECT_PROP_FACE: {
2897  const Face *face;
2898  sarg = va_arg(args, char *);
2899  ret = va_arg(args, int *);
2900  *type = CFAPI_INT;
2901  face = try_find_face(sarg, 0);
2902  if (face != NULL) {
2903  op->face = face;
2904  op->state = 0;
2905  object_update(op, UP_OBJ_FACE);
2906  (*ret) = face->number;
2907  } else
2908  (*ret) = 0;
2909  break;
2910  }
2911 
2912  case CFAPI_OBJECT_PROP_ANIMATION: {
2913  const Animations *anim;
2914  sarg = va_arg(args, char *);
2915  ret = va_arg(args, int *);
2916  *type = CFAPI_INT;
2917  anim = try_find_animation(sarg);
2918  if (anim != NULL) {
2919  op->animation = anim;
2920  SET_ANIMATION(op, 0);
2921  object_update(op, UP_OBJ_FACE);
2922  (*ret) = anim->num;
2923  } else {
2924  (*ret) = 0;
2925  }
2926  break;
2927  }
2928 
2929  case CFAPI_OBJECT_PROP_DURATION:
2930  iarg = va_arg(args, int);
2931  *type = CFAPI_INT;
2932  op->duration = iarg;
2933  break;
2934 
2935  case CFAPI_PLAYER_PROP_MARKED_ITEM:
2936  if (op->contr) {
2937  oparg = va_arg(args, object *);
2938  *type = CFAPI_POBJECT;
2939  op->contr->mark = oparg;
2940  if (oparg) {
2941  op->contr->mark_count = oparg->count;
2942  } else {
2943  op->contr->mark_count = 0;
2944  }
2945  }
2946  break;
2947 
2948  case CFAPI_PLAYER_PROP_PARTY:
2949  if (op->contr) {
2950  partyarg = va_arg(args, partylist *);
2951  *type = CFAPI_PPARTY;
2952  party_join(op, partyarg);
2953  }
2954  break;
2955 
2956  case CFAPI_PLAYER_PROP_BED_MAP:
2957  sarg = va_arg(args, char *);
2958  *type = CFAPI_STRING;
2959  safe_strncpy(op->contr->savebed_map, sarg, MAX_BUF);
2960  break;
2961 
2962  case CFAPI_PLAYER_PROP_BED_X:
2963  iarg = va_arg(args, int);
2964  *type = CFAPI_INT;
2965  op->contr->bed_x = iarg;
2966  break;
2967 
2968  case CFAPI_PLAYER_PROP_BED_Y:
2969  iarg = va_arg(args, int);
2970  *type = CFAPI_INT;
2971  op->contr->bed_y = iarg;
2972  break;
2973 
2974  case CFAPI_PLAYER_PROP_TITLE:
2975  sarg = va_arg(args, char *);
2976  *type = CFAPI_STRING;
2977  player_set_own_title(op->contr, sarg);
2978  break;
2979 
2980  case CFAPI_OBJECT_PROP_MOVE_TYPE:
2981  move = va_arg(args, MoveType *);
2982  op->move_type = *move & MOVE_ALL;
2983  object_update(op, UP_OBJ_INSERT);
2984  *type = CFAPI_MOVETYPE;
2985  break;
2986 
2987  case CFAPI_OBJECT_PROP_MOVE_BLOCK:
2988  move = va_arg(args, MoveType *);
2989  op->move_block = *move & MOVE_ALL;
2990  object_update(op, UP_OBJ_INSERT);
2991  *type = CFAPI_MOVETYPE;
2992  break;
2993 
2994  case CFAPI_OBJECT_PROP_MOVE_ALLOW:
2995  move = va_arg(args, MoveType *);
2996  op->move_allow = *move & MOVE_ALL;
2997  object_update(op, UP_OBJ_INSERT);
2998  *type = CFAPI_MOVETYPE;
2999  break;
3000 
3001  case CFAPI_OBJECT_PROP_MOVE_ON:
3002  move = va_arg(args, MoveType *);
3003  op->move_on = *move & MOVE_ALL;
3004  object_update(op, UP_OBJ_INSERT);
3005  *type = CFAPI_MOVETYPE;
3006  break;
3007 
3008  case CFAPI_OBJECT_PROP_MOVE_OFF:
3009  move = va_arg(args, MoveType *);
3010  op->move_off = *move & MOVE_ALL;
3011  object_update(op, UP_OBJ_INSERT);
3012  *type = CFAPI_MOVETYPE;
3013  break;
3014 
3015  case CFAPI_OBJECT_PROP_MOVE_SLOW:
3016  move = va_arg(args, MoveType *);
3017  op->move_type = *move & MOVE_ALL;
3018  object_update(op, UP_OBJ_INSERT);
3019  *type = CFAPI_MOVETYPE;
3020  break;
3021 
3022  default:
3023  break;
3024  }
3025  }
3026  va_end(args);
3027 }
3028 
3035 static void cfapi_object_apply_below(int *type, ...) {
3036  va_list args;
3037  object *applier;
3038 
3039  va_start(args, type);
3040 
3041  applier = va_arg(args, object *);
3042 
3043  va_end(args);
3044 
3045  apply_by_living_below(applier);
3046  *type = CFAPI_NONE;
3047 }
3048 
3055 static void cfapi_object_apply(int *type, ...) {
3056  va_list args;
3057  object *applied;
3058  object *applier;
3059  int aflags;
3060  int *ret;
3061 
3062  va_start(args, type);
3063 
3064  applier = va_arg(args, object *);
3065  applied = va_arg(args, object *);
3066  aflags = va_arg(args, int);
3067  ret = va_arg(args, int *);
3068 
3069  va_end(args);
3070 
3071  *type = CFAPI_INT;
3072  *ret = apply_manual(applier, applied, aflags);
3073 }
3074 
3080 static void cfapi_object_identify(int *type, ...) {
3081  va_list args;
3082  object *op, **result;
3083 
3084  va_start(args, type);
3085 
3086  op = va_arg(args, object *);
3087  result = va_arg(args, object **);
3088 
3089  va_end(args);
3090 
3091  (*result) = identify(op);
3092  *type = CFAPI_POBJECT;
3093 }
3094 
3100 static void cfapi_object_describe(int *type, ...) {
3101  va_list args;
3102  object *op;
3103  object *owner;
3104  char *desc, *final;
3105  int size;
3106 
3107  va_start(args, type);
3108 
3109  op = va_arg(args, object *);
3110  owner = va_arg(args, object *);
3111  desc = va_arg(args, char *);
3112  size = va_arg(args, int);
3113  va_end(args);
3114 
3115  *type = CFAPI_STRING;
3116  final = stringbuffer_finish(describe_item(op, owner, 0, NULL));
3117  strncpy(desc, final, size);
3118  desc[size - 1] = '\0';
3119  free(final);
3120 }
3121 
3122 static void cfapi_object_drain(int *type, ...) {
3123  va_list args;
3124 
3125  object *op;
3126  int ds;
3127 
3128  va_start(args, type);
3129 
3130  op = va_arg(args, object *);
3131  ds = va_arg(args, int);
3132 
3133  va_end(args);
3134 
3135  drain_specific_stat(op, ds);
3136 
3137  *type = CFAPI_NONE;
3138 }
3139 
3140 static void cfapi_object_remove_depletion(int *type, ...) {
3141  va_list args;
3142 
3143  object *op;
3144  int level, *result;
3145 
3146  va_start(args, type);
3147 
3148  op = va_arg(args, object *);
3149  level = va_arg(args, int);
3150  result = va_arg(args, int*);
3151 
3152  va_end(args);
3153 
3154  *result = remove_depletion(op, level);
3155 
3156  *type = CFAPI_INT;
3157 }
3158 
3159 static void cfapi_object_fix(int *type, ...) {
3160  va_list args;
3161  object *op;
3162 
3163  va_start(args, type);
3164 
3165  op = va_arg(args, object *);
3166 
3167  va_end(args);
3168 
3169  fix_object(op);
3170 
3171  *type = CFAPI_NONE;
3172 }
3173 
3175 static void cfapi_object_give_skill(int *type, ...) {
3176  va_list args;
3177 
3178  object *op;
3179  char *skillname;
3180 
3181  va_start(args, type);
3182 
3183  op = va_arg(args, object *);
3184  skillname = va_arg(args, char *);
3185 
3186  va_end(args);
3187 
3188  *type = CFAPI_POBJECT;
3189  give_skill_by_name(op, skillname);
3190 }
3191 
3192 static void cfapi_object_transmute(int *type, ...) {
3193  va_list args;
3194 
3195  object *op;
3196  object *chg;
3197 
3198  va_start(args, type);
3199 
3200  op = va_arg(args, object *);
3201  chg = va_arg(args, object *);
3202 
3203  va_end(args);
3204 
3205  transmute_materialname(op, chg);
3206  *type = CFAPI_NONE;
3207 }
3208 
3209 static void cfapi_object_remove(int *type, ...) {
3210  va_list args;
3211  object *op;
3212 
3213  va_start(args, type);
3214 
3215  op = va_arg(args, object *);
3216 
3217  if (QUERY_FLAG(op, FLAG_REMOVED)) {
3218  LOG(llevError, "Plugin trying to remove removed object %s\n", op->name);
3219  va_end(args);
3220  *type = CFAPI_NONE;
3221  return;
3222  }
3223 
3224  va_end(args);
3225 
3226  object_remove(op);
3227  *type = CFAPI_NONE;
3228 }
3229 
3230 static void cfapi_object_delete(int *type, ...) {
3231  va_list args;
3232  object *op;
3233 
3234  va_start(args, type);
3235 
3236  op = va_arg(args, object *);
3237 
3238  if (QUERY_FLAG(op, FLAG_FREED) || !QUERY_FLAG(op, FLAG_REMOVED)) {
3239  LOG(llevError, "Plugin trying to free freed/non removed object %s\n", op->name);
3240  *type = CFAPI_NONE;
3241  va_end(args);
3242  return;
3243  }
3244 
3245  va_end(args);
3246 
3247  object_free_drop_inventory(op);
3248 
3249  *type = CFAPI_NONE;
3250 }
3251 
3257 static void cfapi_object_clone(int *type, ...) {
3258  va_list args;
3259  object *op;
3260  int kind;
3261  object **robj;
3262 
3263  va_start(args, type);
3264 
3265  op = va_arg(args, object *);
3266  kind = va_arg(args, int);
3267  robj = va_arg(args, object **);
3268 
3269  va_end(args);
3270 
3271  if (kind == 0) {
3272  *type = CFAPI_POBJECT;
3273  *robj = object_create_clone(op);
3274  } else {
3275  object *tmp;
3276  tmp = object_new();
3277  object_copy(op, tmp);
3278  *type = CFAPI_POBJECT;
3279  *robj = tmp;
3280  }
3281  return;
3282 }
3283 
3289 static void cfapi_object_create(int *type, ...) {
3290  va_list args;
3291  int ival;
3292  object **robj;
3293  va_start(args, type);
3294  ival = va_arg(args, int);
3295 
3296  *type = CFAPI_POBJECT;
3297  switch (ival) {
3298  case 0:
3299  robj = va_arg(args, object **);
3300  *robj = object_new();
3301  break;
3302 
3303  case 1: { /* Named object. Nearly the old plugin behavior, but we don't add artifact suffixes */
3304  const char *sval;
3305  archetype *at;
3306 
3307  sval = va_arg(args, const char *);
3308  robj = va_arg(args, object **);
3309  va_end(args);
3310 
3311  at = try_find_archetype(sval);
3312  if (!at)
3313  at = find_archetype_by_object_name(sval);
3314  if (at) {
3315  *robj = object_create_arch(at);
3316  } else
3317  *robj = NULL;
3318  }
3319  break;
3320 
3321  default:
3322  *type = CFAPI_NONE;
3323  break;
3324  }
3325  va_end(args);
3326 }
3327 
3328 static void cfapi_object_insert(int *type, ...) {
3329  va_list args;
3330  object *op;
3331  object *orig;
3332  mapstruct *map;
3333  int flag, x, y;
3334  int itype;
3335  object **robj;
3336 
3337  va_start(args, type);
3338 
3339  op = va_arg(args, object *);
3340  if (!op) {
3341  LOG(llevError, "cfapi_object_insert: called with NULL object!\n");
3342  va_end(args);
3343  return;
3344  }
3345  if (QUERY_FLAG(op, FLAG_FREED)) {
3346  LOG(llevError, "cfapi_object_insert: called with FREED object!\n");
3347  va_end(args);
3348  return;
3349  }
3350  if (!QUERY_FLAG(op, FLAG_REMOVED)) {
3351  LOG(llevError, "cfapi_object_insert: called with not removed object %s!\n", op->name);
3352  object_remove(op);
3353  }
3354  itype = va_arg(args, int);
3355 
3356  switch (itype) {
3357  case 0:
3358  map = va_arg(args, mapstruct *);
3359  orig = va_arg(args, object *);
3360  flag = va_arg(args, int);
3361  x = va_arg(args, int);
3362  y = va_arg(args, int);
3363  robj = va_arg(args, object **);
3364  if (!map) {
3365  LOG(llevError, "cfapi_object_insert (0): called with NULL map, object %s!\n", op->name);
3366  object_free(op, FREE_OBJ_NO_DESTROY_CALLBACK);
3367  *robj = NULL;
3368  } else
3369  *robj = object_insert_in_map_at(op, map, orig, flag, x, y);
3370  *type = CFAPI_POBJECT;
3371  break;
3372 
3373  case 1:
3374  map = va_arg(args, mapstruct *);
3375  orig = va_arg(args, object *);
3376  flag = va_arg(args, int);
3377  robj = va_arg(args, object **);
3378  if (!map) {
3379  LOG(llevError, "cfapi_object_insert (1): called with NULL map, object %s!\n", op->name);
3380  object_free(op, FREE_OBJ_NO_DESTROY_CALLBACK);
3381  *robj = NULL;
3382  } else
3383  *robj = object_insert_in_map_at(op, map, orig, flag, op->x, op->y);
3384  *type = CFAPI_POBJECT;
3385  break;
3386 
3387  case 2:
3388  map = va_arg(args, mapstruct *);
3389  orig = va_arg(args, object *);
3390  flag = va_arg(args, int);
3391  x = va_arg(args, int);
3392  y = va_arg(args, int);
3393  robj = va_arg(args, object **);
3394  if (!map) {
3395  LOG(llevError, "cfapi_object_insert (0): called with NULL map, object %s!\n", op->name);
3396  object_free(op, FREE_OBJ_NO_DESTROY_CALLBACK);
3397  *robj = NULL;
3398  } else {
3399  int dir = object_find_free_spot(op, map, x, y, 0, SIZEOFFREE);
3400  if (dir != -1) {
3401  *robj = object_insert_in_map_at(op, map, orig, flag, x + freearr_x[dir], y + freearr_y[dir]);
3402  } else {
3403  object_free_drop_inventory(op);
3404  *robj = NULL;
3405  }
3406  }
3407  *type = CFAPI_POBJECT;
3408  break;
3409 
3410  case 3:
3411  orig = va_arg(args, object *);
3412  robj = va_arg(args, object **);
3413  if (!orig) {
3414  LOG(llevError, "cfapi_object_insert (3): called with NULL orig, object %s!\n", op->name);
3415  object_free(op, FREE_OBJ_NO_DESTROY_CALLBACK);
3416  *robj = NULL;
3417  } else
3418  *robj = object_insert_in_ob(op, orig);
3419  *type = CFAPI_POBJECT;
3420  break;
3421 
3422  default:
3423  LOG(llevError, "cfapi_object_insert (1): called with itype %d which is not valid, object %s!\n", itype, op->name);
3424  object_free(op, FREE_OBJ_NO_DESTROY_CALLBACK);
3425  *type = CFAPI_NONE;
3426  break;
3427  }
3428 
3429  va_end(args);
3430 }
3436 static void cfapi_object_split(int *type, ...) {
3437  va_list args;
3438 
3439  int nr, size;
3440  object *op;
3441  char *buf;
3442  object **split;
3443 
3444  va_start(args, type);
3445 
3446  op = va_arg(args, object *);
3447  nr = va_arg(args, int);
3448  buf = va_arg(args, char *);
3449  size = va_arg(args, int);
3450  split = va_arg(args, object **);
3451  va_end(args);
3452 
3453  *split = object_split(op, nr, buf, size);
3454  if (*split != NULL)
3455  {
3456  *type = CFAPI_POBJECT;
3457  }
3458  else
3459  {
3460  *type = CFAPI_NONE;
3461  }
3462 }
3463 
3469 static void cfapi_object_merge(int *type, ...) {
3470  va_list args;
3471  object *op;
3472  object *op2;
3473  object **merge;
3474 
3475  va_start(args, type);
3476 
3477  op = va_arg(args, object *);
3478  op2 = va_arg(args, object *);
3479  merge = va_arg(args, object **);
3480 
3481  va_end(args);
3482 
3483  *type = CFAPI_POBJECT;
3484  *merge = object_merge(op, op2);
3485 }
3486 
3492 static void cfapi_object_distance(int *type, ...) {
3493  va_list args;
3494  object *op;
3495  object *op2;
3496  int *rint;
3497  va_start(args, type);
3498 
3499  op = va_arg(args, object *);
3500  op2 = va_arg(args, object *);
3501  rint = va_arg(args, int *);
3502 
3503  va_end(args);
3504 
3505  *type = CFAPI_INT;
3506  *rint = object_distance(op, op2);
3507 }
3513 static void cfapi_object_update(int *type, ...) {
3514  va_list args;
3515  int action;
3516  object *op;
3517  va_start(args, type);
3518 
3519  op = va_arg(args, object *);
3520  action = va_arg(args, int);
3521 
3522  va_end(args);
3523 
3524  object_update(op, action);
3525  *type = CFAPI_NONE;
3526 }
3527 
3533 static void cfapi_object_clear(int *type, ...) {
3534  va_list args;
3535  object *op;
3536  va_start(args, type);
3537 
3538  op = va_arg(args, object *);
3539 
3540  va_end(args);
3541 
3542  object_clear(op);
3543  *type = CFAPI_NONE;
3544 }
3545 
3551 static void cfapi_object_reset(int *type, ...) {
3552  va_list args;
3553  object *op;
3554 
3555  va_start(args, type);
3556 
3557  op = va_arg(args, object *);
3558 
3559  va_end(args);
3560 
3561  object_reset(op);
3562  *type = CFAPI_NONE;
3563 }
3564 
3565 static void cfapi_object_clean_object(int *type, ...) {
3566  va_list args;
3567  object *op;
3568 
3569  va_start(args, type);
3570  op = va_arg(args, object *);
3571  clean_object(op);
3572  va_end(args);
3573  *type = CFAPI_NONE;
3574 }
3575 
3576 static void cfapi_object_on_same_map(int *type, ...) {
3577  va_list args;
3578  object *op1;
3579  object *op2;
3580  int *rint;
3581 
3582  va_start(args, type);
3583  op1 = va_arg(args, object *);
3584  op2 = va_arg(args, object *);
3585  rint = va_arg(args, int *);
3586  va_end(args);
3587 
3588  *type = CFAPI_INT;
3589  *rint = on_same_map(op1, op2);
3590 }
3591 
3592 static void cfapi_object_spring_trap(int *type, ...) {
3593  object *trap;
3594  object *victim;
3595  va_list args;
3596 
3597  va_start(args, type);
3598  trap = va_arg(args, object *);
3599  victim = va_arg(args, object *);
3600  va_end(args);
3601 
3602  spring_trap(trap, victim);
3603  *type = CFAPI_NONE;
3604 }
3605 
3611 static void cfapi_object_check_trigger(int *type, ...) {
3612  object *op;
3613  object *cause;
3614  va_list args;
3615  int *rint;
3616 
3617  va_start(args, type);
3618  op = va_arg(args, object *);
3619  cause = va_arg(args, object *);
3620  rint = va_arg(args, int *);
3621  va_end(args);
3622 
3623  *rint = check_trigger(op, cause);
3624  *type = CFAPI_INT;
3625 }
3626 
3638 static void cfapi_map_trigger_connected(int *type, ...) {
3639  objectlink *ol;
3640  object *cause;
3641  int state;
3642  va_list args;
3643 
3644  va_start(args, type);
3645  ol = va_arg(args, objectlink *);
3646  cause = va_arg(args, object *);
3647  state = va_arg(args, int);
3648  va_end(args);
3649  trigger_connected(ol, cause, state);
3650  *type = CFAPI_NONE;
3651 }
3652 
3658 static void cfapi_object_query_money(int *type, ...) {
3659  object *op;
3660  va_list args;
3661  int *rint;
3662 
3663  va_start(args, type);
3664  op = va_arg(args, object *);
3665  rint = va_arg(args, int *);
3666  va_end(args);
3667 
3668  *rint = query_money(op);
3669  *type = CFAPI_INT;
3670 }
3671 
3677 static void cfapi_object_cast(int *type, ...) {
3678  object *op;
3679  object *sp;
3680  int dir;
3681  char *str;
3682  object *caster;
3683  va_list args;
3684  int *rint;
3685 
3686  va_start(args, type);
3687  op = va_arg(args, object *);
3688  caster = va_arg(args, object *);
3689  dir = va_arg(args, int);
3690  sp = va_arg(args, object *);
3691  str = va_arg(args, char *);
3692  rint = va_arg(args, int *);
3693  va_end(args);
3694 
3695  *type = CFAPI_INT;
3696 
3697  if (!op->map) {
3698  *rint = -1;
3699  return;
3700  }
3701 
3702  *rint = cast_spell(op, caster, dir, sp, str);
3703 }
3704 
3705 static void cfapi_object_learn_spell(int *type, ...) {
3706  object *op;
3707  object *sp;
3708  int prayer;
3709  va_list args;
3710 
3711  va_start(args, type);
3712  op = va_arg(args, object *);
3713  sp = va_arg(args, object *);
3714  prayer = va_arg(args, int);
3715  va_end(args);
3716  do_learn_spell(op, sp, prayer);
3717  *type = CFAPI_NONE;
3718 }
3719 
3720 static void cfapi_object_forget_spell(int *type, ...) {
3721  object *op;
3722  object *sp;
3723  va_list args;
3724  char name[MAX_BUF];
3725 
3726  va_start(args, type);
3727  op = va_arg(args, object *);
3728  sp = va_arg(args, object *);
3729  va_end(args);
3730  query_name(sp, name, MAX_BUF);
3731  do_forget_spell(op, name);
3732  *type = CFAPI_NONE;
3733 }
3734 
3740 static void cfapi_object_check_spell(int *type, ...) {
3741  object *op;
3742  char *spellname;
3743  va_list args;
3744  object **robj;
3745 
3746  va_start(args, type);
3747  op = va_arg(args, object *);
3748  spellname = va_arg(args, char *);
3749  robj = va_arg(args, object **);
3750  va_end(args);
3751  *robj = check_spell_known(op, spellname);
3752  *type = CFAPI_POBJECT;
3753 }
3754 
3760 static void cfapi_object_pay_amount(int *type, ...) {
3761  object *op;
3762  uint64_t amount;
3763  va_list args;
3764  int *rint;
3765 
3766  va_start(args, type);
3767  op = va_arg(args, object *);
3768  amount = va_arg(args, uint64_t);
3769  rint = va_arg(args, int *);
3770  va_end(args);
3771 
3772  *rint = pay_for_amount(amount, op);
3773  *type = CFAPI_INT;
3774 }
3775 
3781 static void cfapi_object_pay_item(int *type, ...) {
3782  object *op;
3783  object *tobuy;
3784  int *rint;
3785 
3786  va_list args;
3787 
3788  va_start(args, type);
3789  tobuy = va_arg(args, object *);
3790  op = va_arg(args, object *);
3791  rint = va_arg(args, int *);
3792  va_end(args);
3793 
3794  *rint = pay_for_item(tobuy, op, 0);
3795  *type = CFAPI_INT;
3796 }
3797 
3805 static void cfapi_object_transfer(int *type, ...) {
3806  object *op;
3807  object *originator;
3808  int x, y, randompos, ttype, flag;
3809  va_list args;
3810  mapstruct *map;
3811  int *rint;
3812  object **robj;
3813 
3814  va_start(args, type);
3815  op = va_arg(args, object *);
3816  ttype = va_arg(args, int);
3817  switch (ttype) {
3818  case 0:
3819  x = va_arg(args, int);
3820  y = va_arg(args, int);
3821  randompos = va_arg(args, int);
3822  originator = va_arg(args, object *);
3823  rint = va_arg(args, int *);
3824  va_end(args);
3825 
3826  *rint = transfer_ob(op, x, y, randompos, originator);
3827  *type = CFAPI_INT;
3828  return;
3829  break;
3830 
3831  case 1:
3832  map = va_arg(args, mapstruct *);
3833  originator = va_arg(args, object *);
3834  flag = va_arg(args, int);
3835  x = va_arg(args, int);
3836  y = va_arg(args, int);
3837  robj = va_arg(args, object **);
3838  va_end(args);
3839  if (x < 0 || y < 0) {
3840  x = map->enter_x;
3841  y = map->enter_y;
3842  }
3843  *robj = object_insert_in_map_at(op, map, originator, flag, x, y);
3844  *type = CFAPI_POBJECT;
3845  return;
3846  break;
3847 
3848  case 2:
3849  x = va_arg(args, int);
3850  y = va_arg(args, int);
3851  rint = va_arg(args, int *);
3852  va_end(args);
3853 
3854  *rint = move_to(op, x, y);
3855  *type = CFAPI_INT;
3856  return;
3857 
3858  default:
3859  va_end(args);
3860  *type = CFAPI_NONE;
3861  return;
3862  break;
3863  }
3864 }
3865 
3869 static void cfapi_object_find_archetype_inside(int *type, ...) {
3870  object *op;
3871  char *str;
3872  va_list args;
3873  object **robj;
3874 
3875  *type = CFAPI_POBJECT;
3876  va_start(args, type);
3877  op = va_arg(args, object *);
3878 
3879  str = va_arg(args, char *);
3880  robj = va_arg(args, object **);
3881  archetype *at = try_find_archetype(str);
3882  *robj = at == NULL ? NULL : arch_present_in_ob(at, op);
3883  if (*robj == NULL) {
3884  char name[MAX_BUF];
3885 
3886  /* Search by name or slaying instead */
3887  FOR_INV_PREPARE(op, tmp) {
3888  if (tmp->name) {
3889  query_name(tmp, name, MAX_BUF);
3890  if (!strncmp(name, str, strlen(str)))
3891  *robj = tmp;
3892  if (!strncmp(tmp->name, str, strlen(str)))
3893  *robj = tmp;
3894  }
3895  if (tmp->slaying && !strcmp(tmp->slaying, str))
3896  *robj = tmp;
3897  if (*robj != NULL)
3898  break;
3899  } FOR_INV_FINISH();
3900  }
3901  va_end(args);
3902 }
3903 
3904 static void cfapi_object_find_by_arch_name(int *type, ...) {
3905  const object *who;
3906  object **result;
3907  const char *name;
3908  va_list args;
3909 
3910  va_start(args, type);
3911  who = va_arg(args, const object *);
3912  name = va_arg(args, const char *);
3913  result = va_arg(args, object **);
3914  va_end(args);
3915  *type = CFAPI_POBJECT;
3916 
3917  *result = object_find_by_arch_name(who, name);
3918 }
3919 
3920 static void cfapi_object_find_by_name(int *type, ...) {
3921  const object *who;
3922  object **result;
3923  const char *name;
3924  va_list args;
3925 
3926  va_start(args, type);
3927  who = va_arg(args, const object *);
3928  name = va_arg(args, const char *);
3929  result = va_arg(args, object **);
3930  va_end(args);
3931  *type = CFAPI_POBJECT;
3932 
3933  *result = object_find_by_name(who, name);
3934 }
3935 
3941 static void cfapi_object_drop(int *type, ...) {
3942  object *op;
3943  object *author;
3944  va_list args;
3945 
3946  va_start(args, type);
3947  op = va_arg(args, object *);
3948  author = va_arg(args, object *);
3949  va_end(args);
3950  *type = CFAPI_NONE;
3951 
3952  if (QUERY_FLAG(op, FLAG_NO_DROP))
3953  return;
3954  drop(author, op);
3955 
3956  if (author->type == PLAYER) {
3957  author->contr->count = 0;
3958  author->contr->socket->update_look = 1;
3959  }
3960 }
3961 
3965 static void cfapi_object_change_abil(int *type, ...) {
3966  object *op, *tmp;
3967  int *rint;
3968  va_list args;
3969 
3970  va_start(args, type);
3971  op = va_arg(args, object *);
3972  tmp = va_arg(args, object *);
3973  rint = va_arg(args, int *);
3974  va_end(args);
3975 
3976  *type = CFAPI_INT;
3977  *rint = change_abil(op, tmp);
3978 }
3979 
3980 static void cfapi_object_say(int *type, ...) {
3981  object *op;
3982  char *msg;
3983  va_list args;
3984  int *rint;
3985  char empty[] = "";
3986 
3987  va_start(args, type);
3988  op = va_arg(args, object *);
3989  msg = va_arg(args, char *);
3990  rint = va_arg(args, int *);
3991  va_end(args);
3992 
3993  if (op->type == PLAYER) {
3994  command_say(op, msg == NULL ? empty : msg);
3995  } else {
3996  monster_npc_say(op, msg);
3997  }
3998  *rint = 0;
3999  *type = CFAPI_INT;
4000 }
4001 
4002 /* PLAYER SUBCLASS */
4003 
4009 static void cfapi_player_find(int *type, ...) {
4010  va_list args;
4011  char *sval;
4012  player **rpl;
4013  va_start(args, type);
4014 
4015  sval = va_arg(args, char *);
4016  rpl = va_arg(args, player **);
4017  va_end(args);
4018 
4019  *rpl = find_player_partial_name(sval);
4020 
4021  *type = CFAPI_PPLAYER;
4022 }
4023 
4024 static void cfapi_player_message(int *type, ...) {
4025  va_list args;
4026  int flags;
4027  int pri;
4028  object *pl;
4029  const char *buf;
4030 
4031  va_start(args, type);
4032 
4033  flags = va_arg(args, int);
4034  pri = va_arg(args, int);
4035  pl = va_arg(args, object *);
4036  buf = va_arg(args, const char *);
4037  va_end(args);
4038 
4039  draw_ext_info(flags | NDI_DELAYED, pri, pl, MSG_TYPE_MISC, MSG_SUBTYPE_NONE,
4040  buf);
4041  *type = CFAPI_NONE;
4042 }
4043 
4050 static void cfapi_object_perm_exp(int *type, ...) {
4051  va_list args;
4052  object *op;
4053  int64_t *rlong;
4054 
4055  va_start(args, type);
4056  op = va_arg(args, object *);
4057  rlong = va_arg(args, int64_t *);
4058  va_end(args);
4059 
4060  *type = CFAPI_SINT64;
4061  *rlong = PERM_EXP(op->total_exp);
4062 }
4063 
4069 static void cfapi_object_change_exp(int *type, ...) {
4070  va_list args;
4071  int flag;
4072  object *ob;
4073  const char *skill;
4074  int64_t exp;
4075 
4076  va_start(args, type);
4077  ob = va_arg(args, object *);
4078  exp = va_arg(args, int64_t);
4079  skill = va_arg(args, const char *);
4080  flag = va_arg(args, int);
4081  va_end(args);
4082 
4083  *type = CFAPI_NONE;
4084  change_exp(ob, exp, skill, flag);
4085 }
4086 
4092 static void cfapi_player_can_pay(int *type, ...) {
4093  va_list args;
4094  object *pl;
4095  int *rint;
4096 
4097  va_start(args, type);
4098  pl = va_arg(args, object *);
4099  rint = va_arg(args, int *);
4100  va_end(args);
4101 
4102  *rint = can_pay(pl);
4103  *type = CFAPI_INT;
4104 }
4105 
4111 static void cfapi_player_knowledge(int *type, ...) {
4112  va_list args;
4113  object *pl;
4114  int *rint, what;
4115  const char *knowledge;
4116 
4117  va_start(args, type);
4118  what = va_arg(args, int);
4119 
4120  switch(what)
4121  {
4122  case 1:
4123  pl = va_arg(args, object *);
4124  knowledge = va_arg(args, const char *);
4125  rint = va_arg(args, int *);
4126 
4127  *type = CFAPI_INT;
4128 
4129  if (pl->contr == NULL) {
4130  LOG(llevError, "cfapi_player_knowledge: 'has' called for non player object %s", pl->name);
4131  *rint = 0;
4132  va_end(args);
4133  return;
4134  }
4135 
4136  *rint = knowledge_player_knows(pl->contr, knowledge);
4137  break;
4138 
4139  case 2:
4140  pl = va_arg(args, object *);
4141  knowledge = va_arg(args, const char *);
4142  *type = CFAPI_NONE;
4143  if (pl->contr != NULL)
4144  knowledge_give(pl->contr, knowledge, NULL);
4145 
4146  break;
4147 
4148  default:
4149  LOG(llevError, "cfapi_player_knowledge: invalid what %d", what);
4150  }
4151 
4152  va_end(args);
4153 }
4154 
4160 static void cfapi_object_teleport(int *type, ...) {
4161  mapstruct *map;
4162  int x, y;
4163  object *who;
4164  int *res;
4165  va_list args;
4166 
4167  va_start(args, type);
4168  who = va_arg(args, object *);
4169  map = va_arg(args, mapstruct *);
4170  x = va_arg(args, int);
4171  y = va_arg(args, int);
4172  res = va_arg(args, int *);
4173  va_end(args);
4174 
4175  *type = CFAPI_INT;
4176  *res = object_teleport(who, map, x, y);
4177 }
4178 
4179 static void cfapi_object_pickup(int *type, ...) {
4180  object *who;
4181  object *what;
4182  va_list args;
4183 
4184  va_start(args, type);
4185  who = va_arg(args, object *);
4186  what = va_arg(args, object *);
4187  int *res = va_arg(args, int *);
4188  va_end(args);
4189 
4190  *type = CFAPI_INT;
4191  *res = pick_up(who, what);
4192 }
4193 
4194 /* Archetype-related functions */
4195 static void cfapi_archetype_get_property(int *type, ...) {
4196  int prop;
4197  archetype *arch;
4198  va_list args;
4199  sstring *rsstring;
4200  archetype **rarch;
4201  object **robject;
4202 
4203  va_start(args, type);
4204  arch = va_arg(args, archetype *);
4205  prop = va_arg(args, int);
4206  switch (prop) {
4207  case CFAPI_ARCH_PROP_NAME:
4208  *type = CFAPI_SSTRING;
4209  rsstring = va_arg(args, sstring *);
4210  *rsstring = arch->name;
4211  break;
4212 
4213  case CFAPI_ARCH_PROP_NEXT:
4214  *type = CFAPI_PARCH;
4215  rarch = va_arg(args, archetype **);
4216  *rarch = get_next_archetype(arch);
4217  break;
4218 
4219  case CFAPI_ARCH_PROP_HEAD:
4220  *type = CFAPI_PARCH;
4221  rarch = va_arg(args, archetype **);
4222  *rarch = arch->head;
4223  break;
4224 
4225  case CFAPI_ARCH_PROP_MORE:
4226  *type = CFAPI_PARCH;
4227  rarch = va_arg(args, archetype **);
4228  *rarch = arch->more;
4229  break;
4230 
4231  case CFAPI_ARCH_PROP_CLONE:
4232  *type = CFAPI_POBJECT;
4233  robject = va_arg(args, object **);
4234  *robject = &arch->clone;
4235  break;
4236 
4237  default:
4238  *type = CFAPI_NONE;
4239  break;
4240  }
4241  va_end(args);
4242 }
4243 
4250 static void cfapi_party_get_property(int *type, ...) {
4251  partylist *party;
4252  int prop;
4253  va_list args;
4254  object *obarg;
4255  sstring *rsstring;
4256  player **rplayer;
4257  partylist **rparty;
4258 
4259  va_start(args, type);
4260  party = va_arg(args, partylist *);
4261  prop = va_arg(args, int);
4262  switch (prop) {
4263  case CFAPI_PARTY_PROP_NAME:
4264  rsstring = va_arg(args, sstring *);
4265  *rsstring = party->partyname;
4266  *type = CFAPI_SSTRING;
4267  break;
4268 
4269  case CFAPI_PARTY_PROP_NEXT:
4270  rparty = va_arg(args, partylist **);
4271  *rparty = (party ? party_get_next(party) : party_get_first());
4272  *type = CFAPI_PPARTY;
4273  break;
4274 
4275  case CFAPI_PARTY_PROP_PASSWORD:
4276  rsstring = va_arg(args, sstring *);
4277  *rsstring = party_get_password(party);
4278  *type = CFAPI_SSTRING;
4279  break;
4280 
4281  case CFAPI_PARTY_PROP_PLAYER:
4282  *type = CFAPI_PPLAYER;
4283  obarg = va_arg(args, object *);
4284  rplayer = va_arg(args, player **);
4285  *rplayer = (obarg ? obarg->contr : first_player);
4286  for (; *rplayer != NULL; (*rplayer) = (*rplayer)->next)
4287  if ((*rplayer)->ob->contr->party == party) {
4288  break;
4289  }
4290  break;
4291 
4292  default:
4293  *type = CFAPI_NONE;
4294  break;
4295  }
4296  va_end(args);
4297 }
4298 
4305 static void cfapi_region_get_property(int *type, ...) {
4306  region *reg;
4307  int prop, *rint;
4308  va_list args;
4310  sstring *rsstring;
4311  region **rregion;
4312 
4313  va_start(args, type);
4314  reg = va_arg(args, region *);
4315  prop = va_arg(args, int);
4316  switch (prop) {
4317  case CFAPI_REGION_PROP_NAME:
4318  rsstring = va_arg(args, sstring *);
4319  *rsstring = reg->name;
4320  *type = CFAPI_SSTRING;
4321  break;
4322 
4323  case CFAPI_REGION_PROP_NEXT:
4324  rregion = va_arg(args, region **);
4325  *rregion = nullptr;
4326  *type = CFAPI_PREGION;
4327  break;
4328 
4329  case CFAPI_REGION_PROP_PARENT:
4330  rregion = va_arg(args, region **);
4331  *rregion = reg->parent;
4332  *type = CFAPI_PREGION;
4333  break;
4334 
4335  case CFAPI_REGION_PROP_LONGNAME:
4336  rsstring = va_arg(args, sstring *);
4337  *rsstring = reg->longname;
4338  *type = CFAPI_SSTRING;
4339  break;
4340 
4341  case CFAPI_REGION_PROP_MESSAGE:
4342  rsstring = va_arg(args, sstring *);
4343  *rsstring = reg->msg;
4344  *type = CFAPI_SSTRING;
4345  break;
4346 
4347  case CFAPI_REGION_PROP_JAIL_X:
4348  case CFAPI_REGION_PROP_JAIL_Y:
4349  rint = va_arg(args, int*);
4350  *rint = (prop == CFAPI_REGION_PROP_JAIL_X ? reg->jailx : reg->jaily);
4351  *type = CFAPI_INT;
4352  break;
4353 
4354  case CFAPI_REGION_PROP_JAIL_PATH:
4355  rsstring = va_arg(args, sstring *);
4356  *rsstring = reg->jailmap;
4357  *type = CFAPI_SSTRING;
4358  break;
4359 
4360  default:
4361  *type = CFAPI_NONE;
4362  break;
4363  }
4364  va_end(args);
4365 }
4366 
4378 static void cfapi_friendlylist_get_next(int *type, ...) {
4379  object *ob;
4380  va_list args;
4381  object **robject;
4382 
4383  va_start(args, type);
4384  ob = va_arg(args, object *);
4385  robject = va_arg(args, object **);
4386  va_end(args);
4387 
4388  *type = CFAPI_POBJECT;
4389  *robject = get_next_friend(ob);
4390 }
4391 
4392 /*
4393  * Random-map related stuff.
4394  */
4395 
4402 static void cfapi_set_random_map_variable(int *type, ...) {
4403  va_list args;
4404  RMParms *rp;
4405  const char *buf;
4406  int *ret;
4407 
4408  va_start(args, type);
4409  rp = va_arg(args, RMParms *);
4410  buf = va_arg(args, const char *);
4411  ret = va_arg(args, int *);
4412  va_end(args);
4413 
4414  *ret = set_random_map_variable(rp, buf);
4415  *type = CFAPI_INT;
4416 }
4417 
4424 static void cfapi_generate_random_map(int *type, ...) {
4425  va_list args;
4426  const char *name;
4427  RMParms *rp;
4428  char **use_layout;
4429  sstring reset_group;
4430  mapstruct **ret;
4431 
4432  va_start(args, type);
4433  name = va_arg(args, const char *);
4434  rp = va_arg(args, RMParms *);
4435  use_layout = va_arg(args, char **);
4436  reset_group = va_arg(args, sstring);
4437  ret = va_arg(args, mapstruct **);
4438  va_end(args);
4439 
4440  *ret = generate_random_map(name, rp, use_layout, reset_group);
4441 }
4442 
4443 static void cfapi_object_user_event(int *type, ...) {
4444  object *op;
4445  object *activator;
4446  object *third;
4447  const char *message;
4448  int fix;
4449  int *ret;
4450  va_list args;
4451 
4452  va_start(args, type);
4453  op = va_arg(args, object *);
4454  activator = va_arg(args, object *);
4455  third = va_arg(args, object *);
4456  message = va_arg(args, const char *);
4457  fix = va_arg(args, int);
4458  ret = va_arg(args, int *);
4459  va_end(args);
4460 
4461  *ret = events_execute_object_user(op, activator, third, message, fix);
4462  *type = CFAPI_INT;
4463 }
4464 
4467 static void cfapi_player_quest(int *type, ...) {
4468  int op;
4469  va_list args;
4470  object *player;
4471  sstring code;
4472 
4473  va_start(args, type);
4474  op = va_arg(args, int);
4475  player = va_arg(args, object *);
4476  code = va_arg(args, sstring);
4477 
4478  if (player->contr == NULL) {
4479  LOG(llevError, "cfapi_player_quest called with non player object %s!\n", player->name);
4480  va_end(args);
4481  /* crash/quit? */
4482  return;
4483  }
4484 
4485  switch(op) {
4486  case CFAPI_PLAYER_QUEST_START: {
4487  int state = va_arg(args, int);
4488  quest_start(player->contr, code, state);
4489  *type = CFAPI_NONE;
4490  break;
4491  }
4492  case CFAPI_PLAYER_QUEST_GET_STATE: {
4493  int *ret = va_arg(args, int *);
4494  *ret = quest_get_player_state(player->contr, code);
4495  *type = CFAPI_INT;
4496  break;
4497  }
4498  case CFAPI_PLAYER_QUEST_SET_STATE: {
4499  int state = va_arg(args, int);
4500  quest_set_player_state(player->contr, code, state);
4501  *type = CFAPI_NONE;
4502  break;
4503  }
4504  case CFAPI_PLAYER_QUEST_WAS_COMPLETED: {
4505  int *ret = va_arg(args, int*);
4506  *ret = quest_was_completed(player->contr, code);
4507  *type = CFAPI_INT;
4508  break;
4509  }
4510  default:
4511  LOG(llevError, "invalid quest type: %d\n", op);
4512  *type = CFAPI_NONE;
4513  }
4514 
4515  va_end(args);
4516 }
4517 
4518 static void cfapi_register_command(int *type, ...) {
4519  va_list args;
4520  const char *name = NULL, *extra = NULL;
4521  float time;
4522  command_function func = NULL;
4523  command_function_extra func_extra = NULL;
4524  uint8_t register_type, command_type;
4525  command_registration *cr;
4526 
4527  va_start(args, type);
4528  register_type = va_arg(args, int);
4529  name = va_arg(args, const char *);
4530  if (register_type == 1) {
4531  func = va_arg(args, command_function);
4532  } else {
4533  extra = va_arg(args, const char *);
4534  func_extra = va_arg(args, command_function_extra);
4535  }
4536  command_type = (uint8_t)va_arg(args, int);
4537  if (command_type > COMMAND_TYPE_WIZARD) {
4538  command_type = COMMAND_TYPE_NORMAL;
4539  }
4540  time = va_arg(args, double);
4541  cr = va_arg(args, command_registration *);
4542  va_end(args);
4543 
4544  if (register_type == 1) {
4545  (*cr) = command_register(name, command_type, func, time);
4546  } else {
4547  (*cr) = command_register_extra(name, extra, command_type, func_extra, time);
4548  }
4549 
4550  *type = CFAPI_SINT64;
4551 }
4552 
4553 static void cfapi_unregister_command(int *type, ...) {
4554  va_list args;
4555  command_registration cr;
4556 
4557  va_start(args, type);
4558  cr = va_arg(args, command_registration);
4559  va_end(args);
4560 
4561  command_unregister(cr);
4562 }
4563 
4564 /*****************************************************************************/
4565 /* NEW PLUGIN STUFF ENDS HERE */
4566 /*****************************************************************************/
4567 
4568 
4573 void initPlugins(void) {
4574  struct dirent *currentfile;
4575  DIR *plugdir;
4576  size_t l;
4577  char buf[sizeof(LIBDIR) + 9 + sizeof(dirent::d_name)];
4578 
4579  snprintf(buf, sizeof(buf), "%s/plugins/", LIBDIR);
4580  LOG(llevDebug, "plugins: loading from %s\n", buf);
4581 
4582  plugdir = opendir(buf);
4583  if (plugdir == NULL)
4584  return;
4585 
4586  while ((currentfile = readdir(plugdir)) != NULL) {
4587  l = strlen(currentfile->d_name);
4588  if (l > strlen(PLUGIN_SUFFIX)) {
4589  int ignore = 0;
4590 
4591  if (strcmp(currentfile->d_name+l-strlen(PLUGIN_SUFFIX), PLUGIN_SUFFIX) != 0)
4592  continue;
4593 
4594  for (auto disable = serverSettings.disabled_plugins.cbegin(); disable != serverSettings.disabled_plugins.cend(); ++disable) {
4595  if (strcmp(disable->c_str(), "All") == 0) {
4596  LOG(llevInfo, "plugins: disabling (all) %s\n", currentfile->d_name);
4597  ignore = 1;
4598  break;
4599  }
4600  if (strncmp(disable->c_str(), currentfile->d_name, disable->length()) == 0 && strlen(currentfile->d_name) == strlen(PLUGIN_SUFFIX) + disable->length()) {
4601  LOG(llevInfo, "plugins: disabling %s\n", currentfile->d_name);
4602  ignore = 1;
4603  break;
4604  }
4605  }
4606  if (ignore == 0) {
4607  snprintf(buf, sizeof(buf), "%s/plugins/%s", LIBDIR, currentfile->d_name);
4608  LOG(llevInfo, "plugins: loading %s\n", currentfile->d_name);
4609  plugins_init_plugin(buf);
4610  }
4611  }
4612  }
4613 
4614  closedir(plugdir);
4615 }
4616 
4621 void cleanupPlugins(void) {
4622  for (crossfire_plugin *cp : plugins_list) {
4623  if (cp->closefunc)
4624  cp->closefunc();
4625  /* Don't actually unload plugins, it makes backtraces for memory
4626  * debugging (printed at exit) messed up. And it doesn't matter if we
4627  * don't free it here. The OS will do it for us.
4628  */
4629  /* plugins_dlclose(cp->libptr); */
4630  free(cp);
4631  }
4632  plugins_list.clear();
4633 }
CFAPI_OBJECT_PROP_STR
#define CFAPI_OBJECT_PROP_STR
Definition: plugin.h:197
CFAPI_OBJECT_PROP_MAP
#define CFAPI_OBJECT_PROP_MAP
Definition: plugin.h:128
CFAPI_OBJECT_PROP_RUN_AWAY
#define CFAPI_OBJECT_PROP_RUN_AWAY
Definition: plugin.h:174
cfapi_object_create
static void cfapi_object_create(int *type,...)
Wrapper for object_new(), create_archetype() and create_archetype_by_object_name().
Definition: plugins.cpp:3289
llevError
Error, serious thing.
Definition: logger.h:11
dirent
#define dirent
Definition: global.h:215
spring_trap
void spring_trap(object *trap, object *victim)
This function generalizes attacks by runes/traps.
Definition: rune.cpp:214
CFAPI_PLAYER_PROP_TRANSPORT
#define CFAPI_PLAYER_PROP_TRANSPORT
Definition: plugin.h:238
CFAPI_OBJECT_PROP_MAGIC
#define CFAPI_OBJECT_PROP_MAGIC
Definition: plugin.h:155
apply_by_living_below
void apply_by_living_below(object *pl)
Attempt to apply the object &#39;below&#39; the player.
Definition: apply.cpp:357
on_same_map
int on_same_map(const object *op1, const object *op2)
Checks whether 2 objects are on the same map or not.
Definition: map.cpp:2628
CFAPI_PLAYER_QUEST_GET_STATE
#define CFAPI_PLAYER_QUEST_GET_STATE
Definition: plugin.h:242
check_path
int check_path(const char *name, int prepend_dir)
This function checks if a file with the given path exists.
Definition: map.cpp:201
MSG_TYPE_MISC
#define MSG_TYPE_MISC
Messages that don&#39;t go elsewhere.
Definition: newclient.h:430
FLAG_NO_DROP
#define FLAG_NO_DROP
Object can&#39;t be dropped.
Definition: define.h:276
NDI_DELAYED
#define NDI_DELAYED
If set, then message is sent only after the player&#39;s tick completes.
Definition: newclient.h:280
cfapi_map_get_object_at
static void cfapi_map_get_object_at(int *type,...)
Wrapper for GET_MAP_OB().
Definition: plugins.cpp:1370
object_sum_weight
signed long object_sum_weight(object *op)
object_sum_weight() is a recursive function which calculates the weight an object is carrying...
Definition: object.cpp:553
get_periodofday
const char * get_periodofday(const int index)
give access to weekday names
Definition: time.cpp:106
CFAPI_PARTY_PROP_PASSWORD
#define CFAPI_PARTY_PROP_PASSWORD
Definition: plugin.h:273
cfapi_system_add_string
static void cfapi_system_add_string(int *type,...)
Wrapper for add_string().
Definition: plugins.cpp:723
apply_manual
int apply_manual(object *op, object *tmp, int aflag)
Main apply handler.
Definition: apply.cpp:259
CFAPI_OBJECT_PROP_MATERIAL
#define CFAPI_OBJECT_PROP_MATERIAL
Definition: plugin.h:153
object::attack_movement
uint16_t attack_movement
What kind of attack movement.
Definition: object.h:401
determine_god
const char * determine_god(object *op)
Determines if op worships a god.
Definition: gods.cpp:55
RMParms
Random map parameters.
Definition: random_map.h:14
CFAPI_OBJECT_PROP_ANIMATION
#define CFAPI_OBJECT_PROP_ANIMATION
Definition: plugin.h:218
CFAPI_OBJECT_PROP_SP
#define CFAPI_OBJECT_PROP_SP
Definition: plugin.h:207
UP_OBJ_FACE
#define UP_OBJ_FACE
Only thing that changed was the face.
Definition: object.h:533
events_register_object_handler
void events_register_object_handler(const char *id, f_plug_event handler)
Register an object event handler.
Definition: events.cpp:299
update_position
void update_position(mapstruct *m, int x, int y)
This function updates various attributes about a specific space on the map (what it looks like...
Definition: map.cpp:2147
stringbuffer_finish
char * stringbuffer_finish(StringBuffer *sb)
Deallocate the string buffer instance and return the string.
Definition: stringbuffer.cpp:76
CFAPI_OBJECT_PROP_CARRYING
#define CFAPI_OBJECT_PROP_CARRYING
Definition: plugin.h:168
plugins_dlopen
#define plugins_dlopen(fname)
Load a shared library.
Definition: plugin.h:112
get_month_name
const char * get_month_name(const int index)
give access to month names
Definition: time.cpp:113
COMMAND_TYPE_WIZARD
#define COMMAND_TYPE_WIZARD
Wizard-only commands.
Definition: commands.h:39
CFAPI_OBJECT_PROP_NAME
#define CFAPI_OBJECT_PROP_NAME
Definition: plugin.h:130
CFAPI_OBJECT_PROP_OB_BELOW
#define CFAPI_OBJECT_PROP_OB_BELOW
Definition: plugin.h:121
CFAPI_PREGION
#define CFAPI_PREGION
Definition: plugin.h:66
CFAPI_PLAYER_PROP_TITLE
#define CFAPI_PLAYER_PROP_TITLE
Definition: plugin.h:237
CFAPI_MAP_PROP_NAME
#define CFAPI_MAP_PROP_NAME
Definition: plugin.h:250
move_player
int move_player(object *op, int dir)
Move player in the given direction.
Definition: player.cpp:2962
free_dialog_information
void free_dialog_information(object *op)
Frees obj::dialog_information.
Definition: dialog.cpp:34
llevInfo
Information.
Definition: logger.h:12
object::item_power
int8_t item_power
Power rating of the object.
Definition: object.h:372
Animations
This represents one animation.
Definition: face.h:25
cfapi_map_get_map
static void cfapi_map_get_map(int *type,...)
Gets map information.
Definition: plugins.cpp:1032
object::arch
struct archetype * arch
Pointer to archetype.
Definition: object.h:424
quest_start
void quest_start(player *pl, sstring quest_code, int state)
Start a quest for a player.
Definition: quest.cpp:686
plugins_display_list
void plugins_display_list(object *op)
Displays a list of loaded plugins (keystrings and description) in the game log window.
Definition: plugins.cpp:480
describe_item
StringBuffer * describe_item(const object *op, const object *owner, int use_media_tags, StringBuffer *buf)
Describes an item, in all its details.
Definition: item.cpp:955
cfapi_object_drop
static void cfapi_object_drop(int *type,...)
Wrapper for drop().
Definition: plugins.cpp:3941
crossfire_plugin::id
char id[MAX_BUF]
Plugin identification string.
Definition: plugin.h:99
CFAPI_OBJECT_PROP_RACE
#define CFAPI_OBJECT_PROP_RACE
Definition: plugin.h:133
cfapi_object_change_abil
static void cfapi_object_change_abil(int *type,...)
Wrapper for change_abil().
Definition: plugins.cpp:3965
cfapi_system_unregister_global_event
static void cfapi_system_unregister_global_event(int *type,...)
Definition: plugins.cpp:607
check_spell_known
object * check_spell_known(object *op, const char *name)
Checks to see if player knows the spell.
Definition: spell_util.cpp:394
CFAPI_MAP_PROP_ENTER_Y
#define CFAPI_MAP_PROP_ENTER_Y
Definition: plugin.h:259
CFAPI_REGION_PROP_MESSAGE
#define CFAPI_REGION_PROP_MESSAGE
Definition: plugin.h:280
P_NEED_UPDATE
#define P_NEED_UPDATE
This space is out of date.
Definition: map.h:242
cfapi_log
static void cfapi_log(int *type,...)
Wrapper for LOG().
Definition: plugins.cpp:1008
CFAPI_MAP_PROP_FLAGS
#define CFAPI_MAP_PROP_FLAGS
Definition: plugin.h:246
CFAPI_MAP_PROP_DARKNESS
#define CFAPI_MAP_PROP_DARKNESS
Definition: plugin.h:255
CFAPI_OBJECT_PROP_ARCHETYPE
#define CFAPI_OBJECT_PROP_ARCHETYPE
Definition: plugin.h:181
CFAPI_OBJECT_PROP_WEIGHT
#define CFAPI_OBJECT_PROP_WEIGHT
Definition: plugin.h:166
object_get_owner
object * object_get_owner(object *op)
Returns the object which this object marks as being the owner.
Definition: object.cpp:789
CFAPI_OBJECT_PROP_ATTACK_TYPE
#define CFAPI_OBJECT_PROP_ATTACK_TYPE
Definition: plugin.h:149
cfapi_system_remove_string
static void cfapi_system_remove_string(int *type,...)
Wrapper for free_string().
Definition: plugins.cpp:743
mapstruct::players
int16_t players
How many players are on this level right now.
Definition: map.h:339
CFAPI_OBJECT_PROP_FACE
#define CFAPI_OBJECT_PROP_FACE
Definition: plugin.h:217
get_region_by_map
region * get_region_by_map(mapstruct *m)
Gets a region from a map.
Definition: region.cpp:71
CFAPI_SYSTEM_MAPS
#define CFAPI_SYSTEM_MAPS
Definition: plugin.h:285
object_split
object * object_split(object *orig_ob, uint32_t nr, char *err, size_t size)
object_split(ob,nr) splits up ob into two parts.
Definition: object.cpp:2622
cfapi_object_pickup
static void cfapi_object_pickup(int *type,...)
Definition: plugins.cpp:4179
LOG
void LOG(LogLevel logLevel, const char *format,...)
Logs a message to stderr, or to file.
Definition: logger.cpp:58
cfapi_object_clone
static void cfapi_object_clone(int *type,...)
Clone an object, either through object_create_clone() or object_copy().
Definition: plugins.cpp:3257
do_forget_spell
void do_forget_spell(object *op, const char *spell)
Erases spell from player&#39;s inventory.
Definition: apply.cpp:187
object::direction
int8_t direction
Means the object is moving that way.
Definition: object.h:344
plugins_dlsym
#define plugins_dlsym(lib, name)
Get a function from a shared library.
Definition: plugin.h:114
cfapi_object_find_archetype_inside
static void cfapi_object_find_archetype_inside(int *type,...)
Kinda wrapper for arch__present_in_ob().
Definition: plugins.cpp:3869
CFAPI_FUNC
#define CFAPI_FUNC
Definition: plugin.h:63
CFAPI_OBJECT_PROP_GOD
#define CFAPI_OBJECT_PROP_GOD
Definition: plugin.h:214
CFAPI_OBJECT_PROP_PICK_UP
#define CFAPI_OBJECT_PROP_PICK_UP
Definition: plugin.h:163
CFAPI_MAP_PROP_DIFFICULTY
#define CFAPI_MAP_PROP_DIFFICULTY
Definition: plugin.h:247
CFAPI_MAP_PROP_HEIGHT
#define CFAPI_MAP_PROP_HEIGHT
Definition: plugin.h:257
cfapi_system_re_cmp
static void cfapi_system_re_cmp(int *type,...)
Wrapper for re_cmp().
Definition: plugins.cpp:803
CFAPI_OBJECT_PROP_DIRECTION
#define CFAPI_OBJECT_PROP_DIRECTION
Definition: plugin.h:143
command_unregister
void command_unregister(command_registration command)
Unregister a previously registered command.
Definition: commands.cpp:535
strdup_local
#define strdup_local
Definition: compat.h:29
CFAPI_SYSTEM_FRIENDLY_LIST
#define CFAPI_SYSTEM_FRIENDLY_LIST
Definition: plugin.h:290
draw_ext_info_format
void draw_ext_info_format(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *format,...) PRINTF_ARGS(6
cfapi_map_set_map_property
static void cfapi_map_set_map_property(int *type,...)
Definition: plugins.cpp:1267
split
static std::vector< std::string > split(const std::string &field, const std::string &by)
Definition: mapper.cpp:2734
living::grace
int16_t grace
Grace.
Definition: living.h:44
player_set_own_title
void player_set_own_title(struct player *pl, const char *title)
Sets the custom title.
Definition: player.cpp:273
CFAPI_OBJECT_PROP_NEXT_ACTIVE_OB
#define CFAPI_OBJECT_PROP_NEXT_ACTIVE_OB
Definition: plugin.h:122
CFAPI_OBJECT_PROP_MAXGP
#define CFAPI_OBJECT_PROP_MAXGP
Definition: plugin.h:212
player_arrest
int player_arrest(object *who)
Put a player into jail, taking into account cursed exits and player&#39;s region.
Definition: c_wiz.cpp:789
object::move_slow_penalty
float move_slow_penalty
How much this slows down the object.
Definition: object.h:442
CFAPI_OBJECT_PROP_HIDDEN
#define CFAPI_OBJECT_PROP_HIDDEN
Definition: plugin.h:176
cfapi_map_message
static void cfapi_map_message(int *type,...)
Definition: plugins.cpp:1348
cfapi_object_drain
static void cfapi_object_drain(int *type,...)
Definition: plugins.cpp:3122
fix_object
void fix_object(object *op)
Updates all abilities given by applied objects in the inventory of the given object.
Definition: living.cpp:1132
object_set_msg
void object_set_msg(object *op, const char *msg)
Set the message field of an object.
Definition: object.cpp:4796
object_remove
void object_remove(object *op)
This function removes the object op from the linked list of objects which it is currently tied to...
Definition: object.cpp:1818
CFAPI_OBJECT_PROP_MOVE_STATUS
#define CFAPI_OBJECT_PROP_MOVE_STATUS
Definition: plugin.h:177
cfapi_object_insert
static void cfapi_object_insert(int *type,...)
Definition: plugins.cpp:3328
mapstruct::reset_timeout
uint32_t reset_timeout
How many seconds must elapse before this map should be reset.
Definition: map.h:328
first_player
player * first_player
First player.
Definition: init.cpp:106
living::maxgrace
int16_t maxgrace
Maximum grace.
Definition: living.h:45
Face
New face structure - this enforces the notion that data is face by face only - you can not change the...
Definition: face.h:14
knowledge_give
void knowledge_give(player *pl, const char *marker, const object *book)
Give a knowledge item from its code.
Definition: knowledge.cpp:996
level
int level
Definition: readable.cpp:1561
remove_depletion
int remove_depletion(object *op, int level)
Remove depletion from op, if present, and warn player of such restorations.
Definition: living.cpp:755
Settings::playerdir
const char * playerdir
Where the player files are.
Definition: global.h:251
cfapi_system_find_animation
static void cfapi_system_find_animation(int *type,...)
Wrapper for find_animation().
Definition: plugins.cpp:528
object::below
object * below
Pointer to the object stacked below this one.
Definition: object.h:295
CFAPI_OBJECT_PROP_SUBTYPE
#define CFAPI_OBJECT_PROP_SUBTYPE
Definition: plugin.h:146
party_get_next
partylist * party_get_next(const partylist *party)
Returns the next party from the list of all parties.
Definition: party.cpp:208
UP_OBJ_INSERT
#define UP_OBJ_INSERT
Object was inserted.
Definition: object.h:530
object_find_free_spot
int object_find_free_spot(const object *ob, mapstruct *m, int x, int y, int start, int stop)
object_find_free_spot(object, map, x, y, start, stop) will search for a spot at the given map and coo...
Definition: object.cpp:3544
object_find_by_name
object * object_find_by_name(const object *who, const char *name)
Finds an object in inventory name.
Definition: object.cpp:3941
player::count
uint32_t count
Any numbers typed before a command.
Definition: player.h:124
TIMER_ERR_ID
#define TIMER_ERR_ID
Invalid timer id.
Definition: timers.h:67
CFAPI_REGION_PROP_JAIL_X
#define CFAPI_REGION_PROP_JAIL_X
Definition: plugin.h:281
CFAPI_ARCH_PROP_MORE
#define CFAPI_ARCH_PROP_MORE
Definition: plugin.h:268
SET_ANIMATION
#define SET_ANIMATION(ob, newanim)
Definition: global.h:164
esrv_update_item
void esrv_update_item(int flags, object *pl, object *op)
Updates object *op for player *pl.
Definition: main.cpp:359
CFAPI_OBJECT_PROP_CONTAINER
#define CFAPI_OBJECT_PROP_CONTAINER
Definition: plugin.h:127
CFAPI_INT16
#define CFAPI_INT16
Definition: plugin.h:67
command_function
void(* command_function)(object *op, const char *params)
One command function.
Definition: commands.h:17
player::party
partylist * party
Party this player is part of.
Definition: player.h:205
object::slaying
sstring slaying
Which race to do double damage to.
Definition: object.h:327
CFAPI_OBJECT_PROP_INVENTORY
#define CFAPI_OBJECT_PROP_INVENTORY
Definition: plugin.h:124
NROF
static uint32_t NROF(const object *const ob)
Returns ob->nrof, unless it is 0, in which case return 1.
Definition: object.h:627
cfapi_system_find_string
static void cfapi_system_find_string(int *type,...)
Wrapper for find_string().
Definition: plugins.cpp:761
add_string
sstring add_string(const char *str)
Share a string.
Definition: shstr.cpp:137
object::value
int32_t value
How much money it is worth (or contains)
Definition: object.h:360
NR_EVENTS
#define NR_EVENTS
Number of events, maximum code + 1.
Definition: events.h:74
living::luck
int8_t luck
Affects thaco and ac from time to time.
Definition: living.h:39
CFAPI_OBJECT_PROP_FLAGS
#define CFAPI_OBJECT_PROP_FLAGS
Definition: plugin.h:196
all_regions
std::vector< region * > all_regions
Definition: init.cpp:108
object::above
object * above
Pointer to the object stacked above this one.
Definition: object.h:296
cfapi_object_split
static void cfapi_object_split(int *type,...)
Wrapper for object_split().
Definition: plugins.cpp:3436
CFAPI_PARTY_VECTOR
#define CFAPI_PARTY_VECTOR
Pointer to a std::vector<partylist *>
Definition: plugin.h:76
CFAPI_SINT64
#define CFAPI_SINT64
Definition: plugin.h:69
remove_friendly_object
void remove_friendly_object(object *op)
Removes the specified object from the linked list of friendly objects.
Definition: friend.cpp:52
object_teleport
int object_teleport(object *op, mapstruct *map, int x, int y)
Move the specified object in a free spot around the map&#39;s x & y.
Definition: move.cpp:597
CFAPI_OBJECT_PROP_NAME_PLURAL
#define CFAPI_OBJECT_PROP_NAME_PLURAL
Definition: plugin.h:131
hook_entry::func
f_plug_api func
Function itself.
Definition: plugin.h:355
change_exp
void change_exp(object *op, int64_t exp, const char *skill_name, int flag)
Changes experience to a player/monster.
Definition: living.cpp:2179
find_string
sstring find_string(const char *str)
Searches a string in the shared strings.
Definition: shstr.cpp:250
plugin.h
Definitions for the plugin system.
opendir
DIR * opendir(const char *)
region::jailx
int16_t jailx
Definition: map.h:293
MoveType
unsigned char MoveType
Typdef here to define type large enough to hold bitmask of all movement types.
Definition: define.h:424
crossfire_plugin::fullname
char fullname[MAX_BUF]
Plugin full name.
Definition: plugin.h:100
CFAPI_OBJECT_PROP_OWNER
#define CFAPI_OBJECT_PROP_OWNER
Definition: plugin.h:191
party_get_password
const char * party_get_password(const partylist *party)
Returns the party&#39;s password.
Definition: party.cpp:232
cfapi_system_directory
static void cfapi_system_directory(int *type,...)
Definition: plugins.cpp:821
object::y
int16_t y
Position in the map for this object.
Definition: object.h:335
cfapi_object_user_event
static void cfapi_object_user_event(int *type,...)
Definition: plugins.cpp:4443
object::magic
int8_t magic
Any magical bonuses to this item.
Definition: object.h:358
CFAPI_OBJECT_PROP_MOVE_ON
#define CFAPI_OBJECT_PROP_MOVE_ON
Definition: plugin.h:223
CFAPI_OBJECT_PROP_MESSAGE
#define CFAPI_OBJECT_PROP_MESSAGE
Definition: plugin.h:136
FREE_OBJ_NO_DESTROY_CALLBACK
#define FREE_OBJ_NO_DESTROY_CALLBACK
Do not run the destroy callback.
Definition: object.h:547
cfapi_object_transmute
static void cfapi_object_transmute(int *type,...)
Definition: plugins.cpp:3192
cfapi_object_set_property
static void cfapi_object_set_property(int *type,...)
Sets the property of an object.
Definition: plugins.cpp:2381
object::material
uint16_t material
What materials this object consist of.
Definition: object.h:357
CFAPI_OBJECT_PROP_EXP_MULTIPLIER
#define CFAPI_OBJECT_PROP_EXP_MULTIPLIER
Definition: plugin.h:180
cfapi_object_update
static void cfapi_object_update(int *type,...)
Wrapper for object_update().
Definition: plugins.cpp:3513
mapstruct::reset_time
uint32_t reset_time
Server time when map gets reset, seconds since epoch.
Definition: map.h:327
object::move_block
MoveType move_block
What movement types this blocks.
Definition: object.h:437
timeofday_t
Represents the ingame time.
Definition: tod.h:38
plugins_dlclose
#define plugins_dlclose(lib)
Unload a shared library.
Definition: plugin.h:113
CFAPI_MAP_PROP_RESET_TIMEOUT
#define CFAPI_MAP_PROP_RESET_TIMEOUT
Definition: plugin.h:252
cfapi_map_has_been_loaded
static void cfapi_map_has_been_loaded(int *type,...)
Wrapper for has_been_loaded().
Definition: plugins.cpp:1083
mapstruct::height
uint16_t height
Width and height of map.
Definition: map.h:342
mapstruct::width
uint16_t width
Definition: map.h:342
copy_message
static void copy_message(object *op, const char *msg)
Utility function to copy the string to op->msg.
Definition: plugins.cpp:2364
crossfire_plugin
One loaded plugin.
Definition: plugin.h:95
CFAPI_PLAYER_QUEST_START
#define CFAPI_PLAYER_QUEST_START
Definition: plugin.h:241
object::attacked_by
object * attacked_by
This object start to attack us! only player & monster.
Definition: object.h:392
CFAPI_DOUBLE
#define CFAPI_DOUBLE
Definition: plugin.h:61
object::duration
int16_t duration
Number of moves (see &#39;speed&#39;) spell lasts.
Definition: object.h:415
object::move_on
MoveType move_on
Move types affected moving on to this space.
Definition: object.h:439
create_overlay_pathname
void create_overlay_pathname(const char *name, char *buf, size_t size)
Same as create_pathname(), but for the overlay maps.
Definition: map.cpp:125
cfapi_object_fix
static void cfapi_object_fix(int *type,...)
Definition: plugins.cpp:3159
object::chosen_skill
object * chosen_skill
The skill chosen to use.
Definition: object.h:396
CFAPI_SYSTEM_ARCHETYPES
#define CFAPI_SYSTEM_ARCHETYPES
Definition: plugin.h:287
CFAPI_REGION_PROP_NEXT
#define CFAPI_REGION_PROP_NEXT
Definition: plugin.h:277
command_register
command_registration command_register(const char *name, uint8_t type, command_function func, float time)
Register a player-issued command.
Definition: commands.cpp:101
object_set_owner
void object_set_owner(object *op, object *owner)
Sets the owner and sets the skill and exp pointers to owner&#39;s current skill and experience objects...
Definition: object.cpp:825
object::x
int16_t x
Definition: object.h:335
object_distance
int object_distance(const object *ob1, const object *ob2)
Return the square of the distance between the two given objects.
Definition: object.cpp:3646
object::path_repelled
uint32_t path_repelled
Paths the object is repelled from.
Definition: object.h:354
cfapi_object_clean_object
static void cfapi_object_clean_object(int *type,...)
Definition: plugins.cpp:3565
cfapi_system_register_global_event
static void cfapi_system_register_global_event(int *type,...)
Definition: plugins.cpp:586
CFAPI_MAP_PROP_NEXT
#define CFAPI_MAP_PROP_NEXT
Definition: plugin.h:261
CFAPI_OBJECT_PROP_SLAYING
#define CFAPI_OBJECT_PROP_SLAYING
Definition: plugin.h:134
is_friendly
int is_friendly(const object *op)
Checks if the given object is already in the friendly list or not.
Definition: friend.cpp:108
safe_strncpy
#define safe_strncpy
Definition: compat.h:27
object::contr
struct player * contr
Pointer to the player which control this object.
Definition: object.h:284
living::Con
int8_t Con
Use
Definition: living.h:36
object::expmul
double expmul
needed experience = (calc_exp*expmul) - means some races/classes can need less/more exp to gain level...
Definition: object.h:407
object_find_by_arch_name
object * object_find_by_arch_name(const object *who, const char *name)
Find object in inventory by archetype name.
Definition: object.cpp:4237
draw_ext_info
void draw_ext_info(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *message)
Sends message to player(s).
Definition: main.cpp:308
region::longname
char * longname
Official title of the region, this might be defined to be the same as name.
Definition: map.h:286
CFAPI_PMAP
#define CFAPI_PMAP
Definition: plugin.h:59
object::anim_speed
uint8_t anim_speed
Ticks between animation-frames.
Definition: object.h:429
socket_struct::host
char * host
Which host it is connected from (ip address).
Definition: newserver.h:104
cfapi_map_change_light
static void cfapi_map_change_light(int *type,...)
Wrapper for change_map_light().
Definition: plugins.cpp:1426
CFAPI_POBJECT
#define CFAPI_POBJECT
Definition: plugin.h:58
CFAPI_OBJECT_PROP_CHOSEN_SKILL
#define CFAPI_OBJECT_PROP_CHOSEN_SKILL
Definition: plugin.h:175
initPlugins
void initPlugins(void)
Plugins initialization.
Definition: plugins.cpp:4573
CFAPI_OBJECT_PROP_OTHER_ARCH
#define CFAPI_OBJECT_PROP_OTHER_ARCH
Definition: plugin.h:182
CFAPI_OBJECT_PROP_LAST_SP
#define CFAPI_OBJECT_PROP_LAST_SP
Definition: plugin.h:159
try_find_archetype
archetype * try_find_archetype(const char *name)
Definition: assets.cpp:274
CFAPI_REGION_PROP_JAIL_PATH
#define CFAPI_REGION_PROP_JAIL_PATH
Definition: plugin.h:283
FLAG_REMOVED
#define FLAG_REMOVED
Object is not in any map or invenory.
Definition: define.h:219
CFAPI_MAP_VECTOR
#define CFAPI_MAP_VECTOR
Pointer to a std::vector<mapstruct *>
Definition: plugin.h:73
cfapi_get_month_name
static void cfapi_get_month_name(int *type,...)
Wrapper for get_season_name().
Definition: plugins.cpp:929
object::weight
int32_t weight
Attributes of the object.
Definition: object.h:375
CFAPI_OBJECT_PROP_LAST_GRACE
#define CFAPI_OBJECT_PROP_LAST_GRACE
Definition: plugin.h:160
player::transport
object * transport
Transport the player is in.
Definition: player.h:216
CFAPI_OBJECT_PROP_COUNT
#define CFAPI_OBJECT_PROP_COUNT
Definition: plugin.h:129
get_empty_map
mapstruct * get_empty_map(int sizex, int sizey)
Creates and returns a map of the specific size.
Definition: map.cpp:852
archetype::head
archetype * head
The main part of a linked object.
Definition: object.h:485
cfapi_object_check_trigger
static void cfapi_object_check_trigger(int *type,...)
Wrapper for check_trigger().
Definition: plugins.cpp:3611
CFAPI_NONE
#define CFAPI_NONE
Definition: plugin.h:53
player::bed_x
int16_t bed_x
Definition: player.h:113
UPD_ALL
#define UPD_ALL
Definition: newclient.h:338
command_say
void command_say(object *op, const char *params)
&#39;say&#39; command.
Definition: c_chat.cpp:34
MOVE_ALL
#define MOVE_ALL
Mask of all movement types.
Definition: define.h:404
object::run_away
uint8_t run_away
Monster runs away if it&#39;s hp goes below this percentage.
Definition: object.h:394
cfapi_system_find_face
static void cfapi_system_find_face(int *type,...)
Wrapper for find_face().
Definition: plugins.cpp:549
crossfire_plugin::closefunc
f_plug_postinit closefunc
Plugin Termination function.
Definition: plugin.h:97
object_create_clone
object * object_create_clone(object *asrc)
Create clone from object to another.
Definition: object.cpp:3894
getManager
AssetsManager * getManager()
Definition: assets.cpp:309
CFAPI_FLOAT
#define CFAPI_FLOAT
Definition: plugin.h:60
CFAPI_REGION_VECTOR
#define CFAPI_REGION_VECTOR
Pointer to a std::vector<region *>
Definition: plugin.h:75
cfapi_object_identify
static void cfapi_object_identify(int *type,...)
Wrapper for identify().
Definition: plugins.cpp:3080
plugins_find_plugin
static crossfire_plugin * plugins_find_plugin(const char *id)
Find a plugin from its internal name.
Definition: plugins.cpp:269
cfapi_friendlylist_get_next
static void cfapi_friendlylist_get_next(int *type,...)
Friend list access, to get objects on it.
Definition: plugins.cpp:4378
try_find_face
const Face * try_find_face(const char *name, const Face *error)
Definition: assets.cpp:290
change_abil
int change_abil(object *op, object *tmp)
Permanently alters an object&#39;s stats/flags based on another object.
Definition: living.cpp:394
free_string
void free_string(sstring str)
This will reduce the refcount, and if it has reached 0, str will be freed.
Definition: shstr.cpp:294
CFAPI_PLAYER_PROP_BED_X
#define CFAPI_PLAYER_PROP_BED_X
Definition: plugin.h:234
CFAPI_PARCH
#define CFAPI_PARCH
Definition: plugin.h:62
is_magical
int is_magical(const object *op)
Checks whether object is magical.
Definition: item.cpp:1236
socket_struct::update_look
uint32_t update_look
If true, we need to send the look window.
Definition: newserver.h:108
object::level
int16_t level
Level of creature or object.
Definition: object.h:361
cfapi_object_apply
static void cfapi_object_apply(int *type,...)
Applies an object.
Definition: plugins.cpp:3055
CFAPI_MAP_PROP_PLAYERS
#define CFAPI_MAP_PROP_PLAYERS
Definition: plugin.h:253
object_decrease_nrof
object * object_decrease_nrof(object *op, uint32_t i)
Decreases a specified number from the amount of an object.
Definition: object.cpp:2661
living::sp
int16_t sp
Spell points.
Definition: living.h:42
move_to
int move_to(object *op, int x, int y)
Move an object one square toward a specified destination on the same map.
Definition: move.cpp:563
CFAPI_OBJECT_PROP_FACING
#define CFAPI_OBJECT_PROP_FACING
Definition: plugin.h:144
object_free
void object_free(object *ob, int flags)
Frees everything allocated by an object, removes it from the list of used objects, and puts it on the list of free objects.
Definition: object.cpp:1577
player::next
player * next
Pointer to next player, NULL if this is last.
Definition: player.h:108
partylist
One party.
Definition: party.h:10
MSG_TYPE_COMMAND
#define MSG_TYPE_COMMAND
Responses to commands, eg, who.
Definition: newclient.h:420
plugins_init_plugin
int plugins_init_plugin(const char *libfile)
Try to load the specified plugin.
Definition: plugins.cpp:374
object::hide
uint8_t hide
The object is hidden, not invisible.
Definition: object.h:397
CFAPI_PLAYER_PROP_IP
#define CFAPI_PLAYER_PROP_IP
Definition: plugin.h:230
cfapi_get_hooks
static void cfapi_get_hooks(int *type,...)
Definition: plugins.cpp:328
object::resist
int16_t resist[NROFATTACKS]
Resistance adjustments for attacks.
Definition: object.h:351
CFAPI_OBJECT_PROP_ENVIRONMENT
#define CFAPI_OBJECT_PROP_ENVIRONMENT
Definition: plugin.h:125
cfapi_system_get_object_vector
static void cfapi_system_get_object_vector(int *type,...)
Definition: plugins.cpp:627
CFAPI_OBJECT_PROP_GP
#define CFAPI_OBJECT_PROP_GP
Definition: plugin.h:208
CFAPI_OBJECT_PROP_CHA
#define CFAPI_OBJECT_PROP_CHA
Definition: plugin.h:203
CFAPI_PARTY_PROP_PLAYER
#define CFAPI_PARTY_PROP_PLAYER
Definition: plugin.h:274
plugins_remove_plugin
int plugins_remove_plugin(const char *id)
Unload the specified plugin.
Definition: plugins.cpp:455
cfapi_system_check_path
static void cfapi_system_check_path(int *type,...)
Wrapper for check_path().
Definition: plugins.cpp:780
identify
object * identify(object *op)
Identifies an item.
Definition: item.cpp:1446
archetype
The archetype structure is a set of rules on how to generate and manipulate objects which point to ar...
Definition: object.h:483
check_trigger
int check_trigger(object *op, object *cause)
Definition: button.cpp:518
CFAPI_OBJECT_PROP_ATTACKED_BY
#define CFAPI_OBJECT_PROP_ATTACKED_BY
Definition: plugin.h:173
CFAPI_STRING
#define CFAPI_STRING
Definition: plugin.h:57
object::materialname
sstring materialname
Specific material name.
Definition: object.h:356
CFAPI_OBJECT_PROP_MOVE_SLOW_PENALTY
#define CFAPI_OBJECT_PROP_MOVE_SLOW_PENALTY
Definition: plugin.h:226
CFAPI_PLAYER_PROP_COUNT
#define CFAPI_PLAYER_PROP_COUNT
Definition: plugin.h:239
archetype::name
sstring name
More definite name, like "generate_kobold".
Definition: object.h:484
CFAPI_MAP_PROP_UNIQUE
#define CFAPI_MAP_PROP_UNIQUE
Definition: plugin.h:263
mapstruct::unique
uint32_t unique
If set, this is a per player unique map.
Definition: map.h:333
cfapi_system_strdup_local
static void cfapi_system_strdup_local(int *type,...)
Wrapper for strdup_local().
Definition: plugins.cpp:572
command_register_extra
command_registration command_register_extra(const char *name, const char *extra, uint8_t type, command_function_extra func, float time)
Register a player-issued command with an extra parameter.
Definition: commands.cpp:526
mapstruct::msg
char * msg
Message map creator may have left.
Definition: map.h:356
knowledge_player_knows
int knowledge_player_knows(const player *pl, const char *knowledge)
Determines whether a player knows a specific knowledge or not.
Definition: knowledge.cpp:1298
f_plug_property
void *(* f_plug_property)(int *type,...)
Get various plugin properties.
Definition: plugin.h:85
CFAPI_OBJECT_PROP_INT
#define CFAPI_OBJECT_PROP_INT
Definition: plugin.h:201
living::Dex
int8_t Dex
Use
Definition: living.h:36
cfapi_object_delete
static void cfapi_object_delete(int *type,...)
Definition: plugins.cpp:3230
CFAPI_MAP_PROP_RESET_TIME
#define CFAPI_MAP_PROP_RESET_TIME
Definition: plugin.h:251
object::speed
float speed
Frequency of object &#39;moves&#39; relative to server tick rate.
Definition: object.h:337
object::carrying
int32_t carrying
How much weight this object contains.
Definition: object.h:377
CFAPI_ARCH_PROP_HEAD
#define CFAPI_ARCH_PROP_HEAD
Definition: plugin.h:267
monster_npc_say
void monster_npc_say(object *npc, const char *cp)
Simple function to have some NPC say something.
Definition: monster.cpp:2606
cfapi_player_message
static void cfapi_player_message(int *type,...)
Definition: plugins.cpp:4024
CFAPI_OBJECT_PROP_LEVEL
#define CFAPI_OBJECT_PROP_LEVEL
Definition: plugin.h:157
mapstruct::path
char path[HUGE_BUF]
Filename of the map.
Definition: map.h:360
FOR_ABOVE_FINISH
#define FOR_ABOVE_FINISH()
Finishes FOR_ABOVE_PREPARE().
Definition: define.h:717
Settings::tmpdir
const char * tmpdir
Directory to use for temporary files.
Definition: global.h:256
cfapi_object_distance
static void cfapi_object_distance(int *type,...)
Wrapper for object_distance().
Definition: plugins.cpp:3492
object::env
object * env
Pointer to the object which is the environment.
Definition: object.h:301
SET_FLAG
#define SET_FLAG(xyz, p)
Definition: define.h:384
CFAPI_OBJECT_PROP_HEAD
#define CFAPI_OBJECT_PROP_HEAD
Definition: plugin.h:126
object::last_sp
int32_t last_sp
As last_heal, but for spell points.
Definition: object.h:368
CFAPI_PLAYER_PROP_BED_MAP
#define CFAPI_PLAYER_PROP_BED_MAP
Definition: plugin.h:233
QUERY_FLAG
#define QUERY_FLAG(xyz, p)
Definition: define.h:386
CFAPI_OBJECT_PROP_MOVE_ALLOW
#define CFAPI_OBJECT_PROP_MOVE_ALLOW
Definition: plugin.h:222
living::Wis
int8_t Wis
Use
Definition: living.h:36
cfapi_object_give_skill
static void cfapi_object_give_skill(int *type,...)
Definition: plugins.cpp:3175
cfapi_object_say
static void cfapi_object_say(int *type,...)
Definition: plugins.cpp:3980
CFAPI_OBJECT_PROP_RAW_NAME
#define CFAPI_OBJECT_PROP_RAW_NAME
Definition: plugin.h:228
player_get_title
void player_get_title(const player *pl, char *buf, size_t bufsize)
Returns the player&#39;s title.
Definition: player.cpp:233
command_registration
uint64_t command_registration
Identifier when registering a command.
Definition: commands.h:32
object::pick_up
uint8_t pick_up
See crossfire.doc.
Definition: object.h:371
CFAPI_ARCH_PROP_NEXT
#define CFAPI_ARCH_PROP_NEXT
Definition: plugin.h:266
ServerSettings::disabled_plugins
std::vector< std::string > disabled_plugins
List of disabled plugins, &#39;All&#39; means all.
Definition: server.h:16
query_name
void query_name(const object *op, char *buf, size_t size)
Describes an item.
Definition: item.cpp:594
plugins_list
std::vector< crossfire_plugin * > plugins_list
List of loaded plugins.
Definition: plugins.cpp:258
PERM_EXP
#define PERM_EXP(exptotal)
Convert saved total experience into permanent experience.
Definition: global.h:232
object_set_cheat
void object_set_cheat(object *op)
object_set_cheat(object) sets the cheat flag (WAS_WIZ) in the object and in all it&#39;s inventory (recur...
Definition: object.cpp:3259
object_free_drop_inventory
void object_free_drop_inventory(object *ob)
Frees everything allocated by an object, removes it from the list of used objects, and puts it on the list of free objects.
Definition: object.cpp:1545
mapstruct::enter_x
int16_t enter_x
Definition: map.h:343
freearr_x
short freearr_x[SIZEOFFREE]
X offset when searching around a spot.
Definition: object.cpp:299
query_money
uint64_t query_money(const object *op)
Determine the amount of money the given object contains, including what is inside containers...
Definition: shop.cpp:373
hook_entry
One function the server exposes to plugins.
Definition: plugin.h:354
clean_object
void clean_object(object *op)
Remove and free all objects in the inventory of the given object.
Definition: map.cpp:1596
command_function_extra
void(* command_function_extra)(object *op, const char *params, const char *extra)
One command function, with a custom parameter specified at registration time.
Definition: commands.h:29
f_plug_postinit
int(* f_plug_postinit)(void)
Function called after the plugin was initialized.
Definition: plugin.h:81
FOR_INV_FINISH
#define FOR_INV_FINISH()
Finishes FOR_INV_PREPARE().
Definition: define.h:700
cfapi_map_delete_map
static void cfapi_map_delete_map(int *type,...)
Definition: plugins.cpp:1335
player::socket
socket_struct * socket
Socket information for this player.
Definition: player.h:109
object::msg
sstring msg
If this is a book/sign/magic mouth/etc.
Definition: object.h:330
region::name
char * name
Shortend name of the region as maps refer to it.
Definition: map.h:280
object::head
object * head
Points to the main object of a large body.
Definition: object.h:304
cfapi_object_on_same_map
static void cfapi_object_on_same_map(int *type,...)
Definition: plugins.cpp:3576
CFAPI_ARCHETYPE_VECTOR
#define CFAPI_ARCHETYPE_VECTOR
Pointer to a std::vector<archetype *>
Definition: plugin.h:74
object::race
sstring race
Human, goblin, dragon, etc.
Definition: object.h:326
mapstruct
This is a game-map.
Definition: map.h:320
cfapi_player_knowledge
static void cfapi_player_knowledge(int *type,...)
Wrapper for knowledge-related functions().
Definition: plugins.cpp:4111
object_reset
void object_reset(object *op)
Totally resets the specified object, without freeing associated memory.
Definition: object.cpp:919
object::animation
const Animations * animation
Animation of this item, NULL if not animated.
Definition: object.h:428
CFAPI_OBJECT_PROP_FP
#define CFAPI_OBJECT_PROP_FP
Definition: plugin.h:209
cfapi_system_get_region_vector
static void cfapi_system_get_region_vector(int *type,...)
Definition: plugins.cpp:685
cfapi_region_get_property
static void cfapi_region_get_property(int *type,...)
Regions-related functions.
Definition: plugins.cpp:4305
update_all_los
void update_all_los(const mapstruct *map, int x, int y)
This function makes sure that update_los() will be called for all players on the given map within the...
Definition: los.cpp:595
FOR_ABOVE_PREPARE
#define FOR_ABOVE_PREPARE(op_, it_)
Constructs a loop iterating over all objects above an object.
Definition: define.h:710
CFAPI_OBJECT_PROP_MAGICAL
#define CFAPI_OBJECT_PROP_MAGICAL
Definition: plugin.h:188
calculate_difficulty
int calculate_difficulty(mapstruct *m)
This routine is supposed to find out the difficulty of the map.
Definition: map.cpp:1925
cfapi_unregister_command
static void cfapi_unregister_command(int *type,...)
Definition: plugins.cpp:4553
cfapi_system_get_archetype_vector
static void cfapi_system_get_archetype_vector(int *type,...)
Definition: plugins.cpp:671
cfapi_object_spring_trap
static void cfapi_object_spring_trap(int *type,...)
Definition: plugins.cpp:3592
change_map_light
int change_map_light(mapstruct *m, int change)
Used to change map light level (darkness) up or down.
Definition: map.cpp:2023
LIBPTRTYPE
#define LIBPTRTYPE
Definition: plugin.h:88
serverSettings
ServerSettings serverSettings
Definition: init.cpp:42
send_changed_object
static void send_changed_object(object *op)
Notify clients about a changed object.
Definition: plugins.cpp:302
cfapi_object_perm_exp
static void cfapi_object_perm_exp(int *type,...)
Wrapper for permanent experience calculation.
Definition: plugins.cpp:4050
AssetsManager::archetypes
Archetypes * archetypes()
Get archetypes.
Definition: AssetsManager.h:44
cfapi_map_trigger_connected
static void cfapi_map_trigger_connected(int *type,...)
Wrapper for trigger_connected().
Definition: plugins.cpp:3638
CFAPI_OBJECT_PROP_LAST_EAT
#define CFAPI_OBJECT_PROP_LAST_EAT
Definition: plugin.h:161
out_of_map
int out_of_map(mapstruct *m, int x, int y)
Return 1 if coordinates X and Y are out of the map M, taking into account tiling. ...
Definition: map.cpp:2323
object_get_value
sstring object_get_value(const object *op, const char *const key)
Get an extra value by key.
Definition: object.cpp:4331
partylist::partyname
char * partyname
Party name.
Definition: party.h:14
cfapi_set_random_map_variable
static void cfapi_set_random_map_variable(int *type,...)
Wrapper for set_random_map_variable().
Definition: plugins.cpp:4402
trigger_connected
void trigger_connected(objectlink *ol, object *cause, const int state)
Trigger every object in an objectlink.
Definition: button.cpp:41
pay_for_amount
int pay_for_amount(uint64_t to_pay, object *pl)
Takes the amount of money from the the player inventory and from it&#39;s various pouches using the pay_f...
Definition: shop.cpp:402
CFAPI_OBJECT_PROP_MOVE_OFF
#define CFAPI_OBJECT_PROP_MOVE_OFF
Definition: plugin.h:224
CFAPI_OBJECT_PROP_WEIGHT_LIMIT
#define CFAPI_OBJECT_PROP_WEIGHT_LIMIT
Definition: plugin.h:167
CFAPI_PLAYER_QUEST_SET_STATE
#define CFAPI_PLAYER_QUEST_SET_STATE
Definition: plugin.h:243
player::ob
object * ob
The object representing the player.
Definition: player.h:179
CFAPI_LONG
#define CFAPI_LONG
Definition: plugin.h:55
object::face
const Face * face
Face with colors.
Definition: object.h:341
cfapi_object_remove
static void cfapi_object_remove(int *type,...)
Definition: plugins.cpp:3209
object::glow_radius
int8_t glow_radius
indicates the glow radius of the object
Definition: object.h:374
CFAPI_OBJECT_PROP_CURRENT_WEAPON
#define CFAPI_OBJECT_PROP_CURRENT_WEAPON
Definition: plugin.h:171
CFAPI_SSTRING
#define CFAPI_SSTRING
Definition: plugin.h:70
CFAPI_PPLAYER
#define CFAPI_PPLAYER
Definition: plugin.h:64
player::mark_count
uint32_t mark_count
Count of marked object.
Definition: player.h:214
SIZEOFFREE
#define SIZEOFFREE
Definition: define.h:155
P_OUT_OF_MAP
#define P_OUT_OF_MAP
This space is outside the map.
Definition: map.h:254
move_ob
int move_ob(object *op, int dir, object *originator)
Op is trying to move in direction dir.
Definition: move.cpp:58
cftimer_destroy
int cftimer_destroy(int id)
Destroys an existing timer.
Definition: timers.cpp:128
CFAPI_OBJECT_PROP_X
#define CFAPI_OBJECT_PROP_X
Definition: plugin.h:138
do_learn_spell
void do_learn_spell(object *op, object *spell, int special_prayer)
Actually makes op learn spell.
Definition: apply.cpp:146
cfapi_object_clear
static void cfapi_object_clear(int *type,...)
Wrapper for object_clear().
Definition: plugins.cpp:3533
first_map
mapstruct * first_map
First map.
Definition: init.cpp:107
cfapi_object_describe
static void cfapi_object_describe(int *type,...)
Wrapper for describe_item().
Definition: plugins.cpp:3100
CFAPI_OBJECT_PROP_CHEATER
#define CFAPI_OBJECT_PROP_CHEATER
Definition: plugin.h:193
pay_for_item
int pay_for_item(object *op, object *pl, uint64_t reduction)
Player attemps to buy an item, if she has enough money then remove coins as needed from active contai...
Definition: shop.cpp:440
CFAPI_OBJECT_PROP_PICKABLE
#define CFAPI_OBJECT_PROP_PICKABLE
Definition: plugin.h:195
settings
struct Settings settings
Global settings.
Definition: init.cpp:139
object::state
uint8_t state
How the object was last drawn (animation)
Definition: object.h:359
Settings::ignore_plugin_compatibility
uint8_t ignore_plugin_compatibility
If set, don&#39;t check plugin version.
Definition: global.h:327
get_next_archetype
archetype * get_next_archetype(archetype *current)
Definition: assets.cpp:266
cfapi_object_learn_spell
static void cfapi_object_learn_spell(int *type,...)
Definition: plugins.cpp:3705
CFAPI_MAP_PROP_MESSAGE
#define CFAPI_MAP_PROP_MESSAGE
Definition: plugin.h:260
object::lore
sstring lore
Obscure information about this object, to get put into books and the like.
Definition: object.h:332
object_get_env_recursive
object * object_get_env_recursive(object *op)
Utility function.
Definition: object.cpp:575
CFAPI_OBJECT_PROP_ENEMY
#define CFAPI_OBJECT_PROP_ENEMY
Definition: plugin.h:172
CFAPI_REGION_PROP_JAIL_Y
#define CFAPI_REGION_PROP_JAIL_Y
Definition: plugin.h:282
object_new
object * object_new(void)
Grabs an object from the list of unused objects, makes sure it is initialised, and returns it...
Definition: object.cpp:1258
object_present_in_ob
object * object_present_in_ob(uint8_t type, const object *op)
Searches for any objects with a matching type variable in the inventory of the given object...
Definition: object.cpp:3153
get_next_friend
object * get_next_friend(object *current)
Get the next object on the friendly list.
Definition: friend.cpp:143
find_marked_object
object * find_marked_object(object *op)
Return the object the player has marked with the &#39;mark&#39; command below.
Definition: c_object.cpp:1472
CFAPI_OBJECT_PROP_PATH_REPELLED
#define CFAPI_OBJECT_PROP_PATH_REPELLED
Definition: plugin.h:151
player::bed_y
int16_t bed_y
x,y - coordinates of respawn (savebed).
Definition: player.h:113
cfapi_object_apply_below
static void cfapi_object_apply_below(int *type,...)
Applies an object below.
Definition: plugins.cpp:3035
Face::number
uint16_t number
This is the image unique identifier.
Definition: face.h:15
cfapi_object_pay_amount
static void cfapi_object_pay_amount(int *type,...)
Wrapper for pay_for_amount().
Definition: plugins.cpp:3760
UPD_WEIGHT
#define UPD_WEIGHT
Definition: newclient.h:332
living::dam
int16_t dam
How much damage this object does when hitting.
Definition: living.h:46
CFAPI_MAP_PROP_TMPNAME
#define CFAPI_MAP_PROP_TMPNAME
Definition: plugin.h:249
cfapi_object_merge
static void cfapi_object_merge(int *type,...)
Wrapper for object_merge().
Definition: plugins.cpp:3469
region::parent
region * parent
Pointer to the region that is a parent of the current region, if a value isn&#39;t defined in the current...
Definition: map.h:281
cfapi_register_command
static void cfapi_register_command(int *type,...)
Definition: plugins.cpp:4518
player::savebed_map
char savebed_map[MAX_BUF]
Map where player will respawn after death.
Definition: player.h:112
cfapi_object_get_property
static void cfapi_object_get_property(int *type,...)
Main object property getter.
Definition: plugins.cpp:1552
object::path_denied
uint32_t path_denied
Paths the object is denied access to.
Definition: object.h:355
CFAPI_OBJECT_PROP_LORE
#define CFAPI_OBJECT_PROP_LORE
Definition: plugin.h:137
party_get_first
partylist * party_get_first(void)
Returns the first party from the list of all parties.
Definition: party.cpp:196
CFAPI_OBJECT_PROP_ITEM_POWER
#define CFAPI_OBJECT_PROP_ITEM_POWER
Definition: plugin.h:164
cfapi_system_get_map_vector
static void cfapi_system_get_map_vector(int *type,...)
Definition: plugins.cpp:655
CFAPI_REGION_PROP_LONGNAME
#define CFAPI_REGION_PROP_LONGNAME
Definition: plugin.h:279
MSG_TYPE_COMMAND_DEBUG
#define MSG_TYPE_COMMAND_DEBUG
Various debug type commands.
Definition: newclient.h:549
object::stats
living stats
Str, Con, Dex, etc.
Definition: object.h:378
re_cmp
const char * re_cmp(const char *, const char *)
re-cmp - get regular expression match.
Definition: re-cmp.cpp:68
MAX_BUF
#define MAX_BUF
Used for all kinds of things.
Definition: define.h:35
cfapi_timer_create
static void cfapi_timer_create(int *type,...)
Wrapper for cfapi_timer_create().
Definition: plugins.cpp:956
quest_get_player_state
int quest_get_player_state(player *pl, sstring quest_code)
Get the quest state for a player.
Definition: quest.cpp:666
cfapi_object_find_by_name
static void cfapi_object_find_by_name(int *type,...)
Definition: plugins.cpp:3920
CFAPI_PARTY_PROP_NAME
#define CFAPI_PARTY_PROP_NAME
Definition: plugin.h:271
CFAPI_PLAYER_PROP_PARTY
#define CFAPI_PLAYER_PROP_PARTY
Definition: plugin.h:232
object::invisible
int16_t invisible
How much longer the object will be invis.
Definition: object.h:370
cfapi_object_check_spell
static void cfapi_object_check_spell(int *type,...)
Wrapper for check_spell_known().
Definition: plugins.cpp:3740
LogLevel
LogLevel
Log levels for the LOG() function.
Definition: logger.h:10
add_friendly_object
void add_friendly_object(object *op)
Add a new friendly object to the list of friendly objects.
Definition: friend.cpp:32
drop
void drop(object *op, object *tmp)
Drop an item, either on the floor or in a container.
Definition: c_object.cpp:1120
CFAPI_OBJECT_PROP_EXP
#define CFAPI_OBJECT_PROP_EXP
Definition: plugin.h:190
delete_map
void delete_map(mapstruct *m)
Frees the map, including the mapstruct.
Definition: map.cpp:1705
strlcpy
size_t strlcpy(char *dst, const char *src, size_t size)
Portable implementation of strlcpy(3).
Definition: porting.cpp:222
cfapi_object_cast
static void cfapi_object_cast(int *type,...)
Wrapper for query_money().
Definition: plugins.cpp:3677
map_find_by_archetype
object * map_find_by_archetype(mapstruct *m, int x, int y, const archetype *at)
Searches for any objects with a matching archetype at the given map and coordinates.
Definition: object.cpp:3103
get_map_from_coord
mapstruct * get_map_from_coord(mapstruct *m, int16_t *x, int16_t *y)
This is basically the same as out_of_map above(), but instead we return NULL if no map is valid (coor...
Definition: map.cpp:2351
object::speed_left
float speed_left
How much speed is left to spend this round.
Definition: object.h:338
arch_present_in_ob
object * arch_present_in_ob(const archetype *at, const object *op)
Searches for any objects with a matching archetype in the inventory of the given object.
Definition: object.cpp:3207
object_copy
void object_copy(const object *src_ob, object *dest_ob)
Copy object first frees everything allocated by the second object, and then copies the contents of th...
Definition: object.cpp:1177
NR_OF_HOOKS
#define NR_OF_HOOKS
Number of hooked functions a plugin can call.
Definition: plugins.cpp:50
cfapi_object_move
static void cfapi_object_move(int *type,...)
Moves an object.
Definition: plugins.cpp:1457
object::map
struct mapstruct * map
Pointer to the map in which this object is present.
Definition: object.h:305
plugins_dlerror
#define plugins_dlerror()
Library error.
Definition: plugin.h:115
player::mark
object * mark
Marked object.
Definition: player.h:215
Settings::confdir
const char * confdir
Configuration files.
Definition: global.h:248
object_can_pick
int object_can_pick(const object *who, const object *item)
Finds out if an object can be picked up.
Definition: object.cpp:3852
cfapi_object_remove_depletion
static void cfapi_object_remove_depletion(int *type,...)
Definition: plugins.cpp:3140
CFAPI_OBJECT_PROP_TOTAL_EXP
#define CFAPI_OBJECT_PROP_TOTAL_EXP
Definition: plugin.h:170
freearr_y
short freearr_y[SIZEOFFREE]
Y offset when searching around a spot.
Definition: object.cpp:305
object_present_in_ob_by_name
object * object_present_in_ob_by_name(int type, const char *str, const object *op)
Searches for any objects with a matching type & name variable in the inventory of the given object...
Definition: object.cpp:3188
flags
static const flag_definition flags[]
Flag mapping.
Definition: gridarta-types-convert.cpp:101
object_create_arch
object * object_create_arch(archetype *at)
Create a full object using the given archetype.
Definition: arch.cpp:296
object::facing
int8_t facing
Object is oriented/facing that way.
Definition: object.h:345
Settings::uniquedir
const char * uniquedir
Directory for the unique items.
Definition: global.h:254
cleanupPlugins
void cleanupPlugins(void)
Call the crossfire_plugin::closefunc on the various plugins, used at server shutdown.
Definition: plugins.cpp:4621
object_merge
object * object_merge(object *op, object *top)
This function goes through all objects below and including top, and merges op to the first matching o...
Definition: object.cpp:2036
CFAPI_OBJECT_PROP_DAM
#define CFAPI_OBJECT_PROP_DAM
Definition: plugin.h:213
CFAPI_OBJECT_PROP_MOVE_TYPE
#define CFAPI_OBJECT_PROP_MOVE_TYPE
Definition: plugin.h:220
PLAYER
See Player.
Definition: object.h:112
Settings::datadir
const char * datadir
Read only data files.
Definition: global.h:249
CFAPI_OBJECT_PROP_SKILL
#define CFAPI_OBJECT_PROP_SKILL
Definition: plugin.h:135
object::other_arch
struct archetype * other_arch
Pointer used for various things - mostly used for what this objects turns into or what this object cr...
Definition: object.h:425
mapstruct::enter_y
int16_t enter_y
Enter_x and enter_y are default entrance coordinates to use for a map such that when an exit specifie...
Definition: map.h:343
CFAPI_PLAYER_PROP_NEXT
#define CFAPI_PLAYER_PROP_NEXT
Definition: plugin.h:236
region::jailmap
char * jailmap
Where a player that is arrested in this region should be imprisoned.
Definition: map.h:292
CFAPI_OBJECT_PROP_AC
#define CFAPI_OBJECT_PROP_AC
Definition: plugin.h:205
CFAPI_SYSTEM_PLAYERS
#define CFAPI_SYSTEM_PLAYERS
Definition: plugin.h:286
get_tod
void get_tod(timeofday_t *tod)
Computes the ingame time of the day.
Definition: time.cpp:219
SET_MAP_FLAGS
#define SET_MAP_FLAGS(M, X, Y, C)
Sets map flags.
Definition: map.h:162
cfapi_object_reset
static void cfapi_object_reset(int *type,...)
Wrapper for clear_reset().
Definition: plugins.cpp:3551
CFAPI_OBJECT_PROP_BASE_NAME
#define CFAPI_OBJECT_PROP_BASE_NAME
Definition: plugin.h:187
TIMER_ERR_NONE
#define TIMER_ERR_NONE
No error.
Definition: timers.h:66
Animations::num
uint16_t num
Where we are in the array.
Definition: face.h:29
CFAPI_REGION_PROP_PARENT
#define CFAPI_REGION_PROP_PARENT
Definition: plugin.h:278
object::name_pl
sstring name_pl
The plural name of the object.
Definition: object.h:323
query_base_name
void query_base_name(const object *op, int plural, char *buf, size_t size)
Query a short name for the item.
Definition: item.cpp:692
transmute_materialname
void transmute_materialname(object *op, const object *change)
When doing transmutation of objects, we have to recheck the resistances, as some that did not apply p...
Definition: utils.cpp:263
cfapi_player_find
static void cfapi_player_find(int *type,...)
Wrapper for find_player_partial_name().
Definition: plugins.cpp:4009
CFAPI_INT
#define CFAPI_INT
Definition: plugin.h:54
cfapi_object_find_by_arch_name
static void cfapi_object_find_by_arch_name(int *type,...)
Definition: plugins.cpp:3904
object::active_next
object * active_next
Next object in the &#39;active&#39; list This is used in process_events so that the entire object list does n...
Definition: object.h:287
CFAPI_ARCH_PROP_NAME
#define CFAPI_ARCH_PROP_NAME
Definition: plugin.h:265
cfapi_object_forget_spell
static void cfapi_object_forget_spell(int *type,...)
Definition: plugins.cpp:3720
quest_set_player_state
void quest_set_player_state(player *pl, sstring quest_code, int state)
Set the state of a quest for a player.
Definition: quest.cpp:722
timers.h
Variables for the custom timers.
m
static event_registration m
Definition: citylife.cpp:424
object::container
object * container
Current container being used.
Definition: object.h:299
create_pathname
char * create_pathname(const char *name, char *buf, size_t size)
Get the full path to a map file.
Definition: map.cpp:104
set_random_map_variable
int set_random_map_variable(RMParms *rp, const char *buf)
CFAPI_OBJECT_PROP_SPEED_LEFT
#define CFAPI_OBJECT_PROP_SPEED_LEFT
Definition: plugin.h:141
FREE_AND_COPY
#define FREE_AND_COPY(sv, nv)
Release the shared string if not NULL, and make it a reference to nv.
Definition: global.h:206
UPD_NROF
#define UPD_NROF
Definition: newclient.h:337
f_plug_event
int(* f_plug_event)(int *type,...)
Function to call to handle global or object-related events.
Definition: events.h:82
region::jaily
int16_t jaily
The coodinates in jailmap to which the player should be sent.
Definition: map.h:293
cftimer_create
int cftimer_create(int id, long delay, object *ob, int mode)
Creates a new timer.
Definition: timers.cpp:97
Settings::localdir
const char * localdir
Read/write data files.
Definition: global.h:250
try_find_animation
Animations * try_find_animation(const char *name)
Definition: assets.cpp:282
object::move_type
MoveType move_type
Type of movement this object uses.
Definition: object.h:436
object::name
sstring name
The name of the object, obviously...
Definition: object.h:319
CFAPI_OBJECT_PROP_HP
#define CFAPI_OBJECT_PROP_HP
Definition: plugin.h:206
object::title
sstring title
Of foo, etc.
Definition: object.h:325
object::spellitem
object * spellitem
Spell ability monster is choosing to use.
Definition: object.h:406
llevDebug
Only for debugging purposes.
Definition: logger.h:13
object::nrof
uint32_t nrof
Number of objects.
Definition: object.h:342
get_map_flags
int get_map_flags(mapstruct *oldmap, mapstruct **newmap, int16_t x, int16_t y, int16_t *nx, int16_t *ny)
This rolls up wall, blocks_magic, blocks_view, etc, all into one function that just returns a P_...
Definition: map.cpp:300
CFAPI_OBJECT_PROP_TITLE
#define CFAPI_OBJECT_PROP_TITLE
Definition: plugin.h:132
drain_specific_stat
void drain_specific_stat(object *op, int deplete_stats)
Drain a specified stat from op.
Definition: living.cpp:728
cfapi_object_teleport
static void cfapi_object_teleport(int *type,...)
Teleports an object at a specified destination if possible.
Definition: plugins.cpp:4160
cftimer_find_free_id
int cftimer_find_free_id(void)
Finds a free ID for a new timer.
Definition: timers.cpp:144
mapstruct::darkness
uint8_t darkness
Indicates level of darkness of map.
Definition: map.h:341
living::Cha
int8_t Cha
Use
Definition: living.h:36
object::move_off
MoveType move_off
Move types affected moving off this space.
Definition: object.h:440
Settings::mapdir
const char * mapdir
Where the map files are.
Definition: global.h:252
string_get_int
#define string_get_int(name)
Definition: plugins.cpp:886
CFAPI_PLAYER_PROP_BED_Y
#define CFAPI_PLAYER_PROP_BED_Y
Definition: plugin.h:235
object::move_allow
MoveType move_allow
What movement types explicitly allowed.
Definition: object.h:438
CFAPI_OBJECT_PROP_SPEED
#define CFAPI_OBJECT_PROP_SPEED
Definition: plugin.h:140
cfapi_get_season_name
static void cfapi_get_season_name(int *type,...)
Wrapper for get_season_name().
Definition: plugins.cpp:905
object_set_enemy
void object_set_enemy(object *op, object *enemy)
Sets the enemy of an object.
Definition: object.cpp:900
plug_hooks
static const hook_entry plug_hooks[]
All hooked functions plugins can call.
Definition: plugins.cpp:155
CFAPI_MAP_PROP_PATH
#define CFAPI_MAP_PROP_PATH
Definition: plugin.h:248
cfapi_object_get_key
static void cfapi_object_get_key(int *type,...)
Gets a key/value value for an object.
Definition: plugins.cpp:1507
cfapi_get_time
static void cfapi_get_time(int *type,...)
Wrapper for get_tod().
Definition: plugins.cpp:874
CFAPI_OBJECT_PROP_FRIENDLY
#define CFAPI_OBJECT_PROP_FRIENDLY
Definition: plugin.h:185
region::msg
char * msg
The description of the region.
Definition: map.h:288
CLEAR_FLAG
#define CLEAR_FLAG(xyz, p)
Definition: define.h:385
CFAPI_OBJECT_VECTOR
#define CFAPI_OBJECT_VECTOR
Pointer to a std::vector<object *>
Definition: plugin.h:72
object::type
uint8_t type
PLAYER, BULLET, etc.
Definition: object.h:348
CFAPI_OBJECT_PROP_ANIM_SPEED
#define CFAPI_OBJECT_PROP_ANIM_SPEED
Definition: plugin.h:184
living::ac
int8_t ac
Armor Class, lower AC increases probability of not getting hit.
Definition: living.h:38
CFAPI_OBJECT_PROP_LUCK
#define CFAPI_OBJECT_PROP_LUCK
Definition: plugin.h:189
party_join
void party_join(object *op, partylist *party)
Makes a player join a party.
Definition: party.cpp:85
readdir
struct dirent * readdir(DIR *)
CFAPI_OBJECT_PROP_ARCH_NAME
#define CFAPI_OBJECT_PROP_ARCH_NAME
Definition: plugin.h:215
living::Pow
int8_t Pow
Use
Definition: living.h:36
object::active_prev
object * active_prev
Previous object in the &#39;active list This is used in process_events so that the entire object list doe...
Definition: object.h:291
CFAPI_OBJECT_PROP_INVISIBLE_TIME
#define CFAPI_OBJECT_PROP_INVISIBLE_TIME
Definition: plugin.h:162
CFAPI_OBJECT_PROP_DEX
#define CFAPI_OBJECT_PROP_DEX
Definition: plugin.h:198
object_update_speed
void object_update_speed(object *op)
Updates the speed of an object.
Definition: object.cpp:1334
CFAPI_MOVETYPE
#define CFAPI_MOVETYPE
Definition: plugin.h:71
CFAPI_OBJECT_PROP_ATTACK_MOVEMENT
#define CFAPI_OBJECT_PROP_ATTACK_MOVEMENT
Definition: plugin.h:178
CFAPI_MAP_PROP_REGION
#define CFAPI_MAP_PROP_REGION
Definition: plugin.h:262
events_unregister_global_handler
void events_unregister_global_handler(int eventcode, event_registration id)
Remove a global event handler.
Definition: events.cpp:26
object::client_type
uint16_t client_type
Public type information.
Definition: object.h:350
object_set_value
int object_set_value(object *op, const char *key, const char *value, int add_key)
Updates the key in op to value.
Definition: object.cpp:4484
object::inv
object * inv
Pointer to the first object in the inventory.
Definition: object.h:298
mapstruct::tmpname
char * tmpname
Name of temporary file.
Definition: map.h:322
CFAPI_MAP_PROP_WIDTH
#define CFAPI_MAP_PROP_WIDTH
Definition: plugin.h:256
cfapi_player_quest
static void cfapi_player_quest(int *type,...)
Quest-related wrappers, for all quest-related operations.
Definition: plugins.cpp:4467
CFAPI_OBJECT_PROP_CON
#define CFAPI_OBJECT_PROP_CON
Definition: plugin.h:199
cfapi_player_can_pay
static void cfapi_player_can_pay(int *type,...)
Wrapper for can_pay().
Definition: plugins.cpp:4092
Animations::name
sstring name
Name of the animation sequence.
Definition: face.h:26
CFAPI_PLAYER_QUEST_WAS_COMPLETED
#define CFAPI_PLAYER_QUEST_WAS_COMPLETED
Definition: plugin.h:244
cost_string_from_value
char * cost_string_from_value(uint64_t cost, int largest_coin)
Converts a price to number of coins.
Definition: shop.cpp:220
CFAPI_PARTY_PROP_NEXT
#define CFAPI_PARTY_PROP_NEXT
Definition: plugin.h:272
crossfire_plugin::global_registration
event_registration global_registration[NR_EVENTS]
Global event registration identifiers.
Definition: plugin.h:101
object::total_exp
int64_t total_exp
All exp ever earned (used to calc perm_exp)
Definition: object.h:379
object::gen_sp_armour
int8_t gen_sp_armour
Sp regen penalty this object has (was last_heal)
Definition: object.h:373
find_archetype_by_object_name
archetype * find_archetype_by_object_name(const char *name)
This function retrieves an archetype given the name that appears during the game (for example...
Definition: arch.cpp:51
GET_MAP_OB
#define GET_MAP_OB(M, X, Y)
Gets the bottom object on a map.
Definition: map.h:173
living::exp
int64_t exp
Experience.
Definition: living.h:47
CFAPI_OBJECT_PROP_NROF
#define CFAPI_OBJECT_PROP_NROF
Definition: plugin.h:142
object::skill
sstring skill
Name of the skill this object uses/grants.
Definition: object.h:329
cfapi_get_periodofday_name
static void cfapi_get_periodofday_name(int *type,...)
Wrapper for get_season_name().
Definition: plugins.cpp:941
living::maxsp
int16_t maxsp
Max spell points.
Definition: living.h:43
object::attacktype
uint32_t attacktype
Bitmask of attacks this object does.
Definition: object.h:352
CFAPI_OBJECT_PROP_MAXSP
#define CFAPI_OBJECT_PROP_MAXSP
Definition: plugin.h:211
CFAPI_ARCH_PROP_CLONE
#define CFAPI_ARCH_PROP_CLONE
Definition: plugin.h:269
cfapi_party_get_property
static void cfapi_party_get_property(int *type,...)
Party-related functions.
Definition: plugins.cpp:4250
closedir
int closedir(DIR *)
give_skill_by_name
object * give_skill_by_name(object *op, const char *skill_name)
Given the skill name skill_name, we find the skill archetype/object, set appropriate values...
Definition: living.cpp:1788
NDI_UNIQUE
#define NDI_UNIQUE
Print immediately, don&#39;t buffer.
Definition: newclient.h:270
object::last_heal
int32_t last_heal
Last healed.
Definition: object.h:367
CFAPI_PLAYER_PROP_MARKED_ITEM
#define CFAPI_PLAYER_PROP_MARKED_ITEM
Definition: plugin.h:231
cfapi_timer_destroy
static void cfapi_timer_destroy(int *type,...)
Wrapper for cftimer_destroy().
Definition: plugins.cpp:989
get_season_name
const char * get_season_name(const int index)
give access to season names
Definition: time.cpp:127
MSG_SUBTYPE_NONE
#define MSG_SUBTYPE_NONE
Definition: newclient.h:439
CFAPI_OBJECT_PROP_LAST_HEAL
#define CFAPI_OBJECT_PROP_LAST_HEAL
Definition: plugin.h:158
CFAPI_OBJECT_PROP_CLIENT_TYPE
#define CFAPI_OBJECT_PROP_CLIENT_TYPE
Definition: plugin.h:147
CFAPI_OBJECT_PROP_INVISIBLE
#define CFAPI_OBJECT_PROP_INVISIBLE
Definition: plugin.h:216
pick_up
bool pick_up(object *op, object *alt)
Try to pick up an item.
Definition: c_object.cpp:470
assets.h
C function wrappers to interact with assets.
events_unregister_object_handler
void events_unregister_object_handler(const char *id)
Remove an object event handler.
Definition: events.cpp:304
CFAPI_OBJECT_PROP_TYPE
#define CFAPI_OBJECT_PROP_TYPE
Definition: plugin.h:145
events_register_global_handler
event_registration events_register_global_handler(int eventcode, f_plug_event hook)
Register a global event handler.
Definition: events.cpp:19
has_been_loaded
mapstruct * has_been_loaded(const char *name)
Checks whether map has been loaded.
Definition: map.cpp:79
player
One player.
Definition: player.h:107
CFAPI_OBJECT_PROP_POW
#define CFAPI_OBJECT_PROP_POW
Definition: plugin.h:202
cfapi_system_get_party_vector
static void cfapi_system_get_party_vector(int *type,...)
Definition: plugins.cpp:699
archetype::more
archetype * more
Next part of a linked object.
Definition: object.h:486
cfapi_map_update_position
static void cfapi_map_update_position(int *type,...)
Wrapper for update_position().
Definition: plugins.cpp:1319
FLAG_WAS_WIZ
#define FLAG_WAS_WIZ
Player was once a wiz.
Definition: define.h:221
CFAPI_OBJECT_PROP_GEN_SP_ARMOUR
#define CFAPI_OBJECT_PROP_GEN_SP_ARMOUR
Definition: plugin.h:165
crossfire_plugin::propfunc
f_plug_property propfunc
Plugin getProperty function.
Definition: plugin.h:96
transfer_ob
int transfer_ob(object *op, int x, int y, int randomly, object *originator)
Move an object (even linked objects) to another spot on the same map.
Definition: move.cpp:163
living::food
int32_t food
How much food in stomach.
Definition: living.h:48
buf
StringBuffer * buf
Definition: readable.cpp:1563
CFAPI_OBJECT_PROP_GLOW_RADIUS
#define CFAPI_OBJECT_PROP_GLOW_RADIUS
Definition: plugin.h:169
cfapi_object_change_exp
static void cfapi_object_change_exp(int *type,...)
Wrapper for change_exp().
Definition: plugins.cpp:4069
object::current_weapon
object * current_weapon
Pointer to the weapon currently used.
Definition: object.h:380
cfapi_archetype_get_property
static void cfapi_archetype_get_property(int *type,...)
Definition: plugins.cpp:4195
events_execute_object_user
int events_execute_object_user(object *op, object *activator, object *third, const char *message, int fix)
Execute an EVENT_USER on the specified object.
Definition: events.cpp:317
cfapi_map_out_of_map
static void cfapi_map_out_of_map(int *type,...)
Wrapper for out_of_map().
Definition: plugins.cpp:1297
CFAPI_OBJECT_PROP_PRESENT
#define CFAPI_OBJECT_PROP_PRESENT
Definition: plugin.h:192
CFAPI_SYSTEM_PARTIES
#define CFAPI_SYSTEM_PARTIES
Definition: plugin.h:289
CFAPI_OBJECT_PROP_MERGEABLE
#define CFAPI_OBJECT_PROP_MERGEABLE
Definition: plugin.h:194
CFAPI_OBJECT_PROP_WC
#define CFAPI_OBJECT_PROP_WC
Definition: plugin.h:204
living::maxhp
int16_t maxhp
Max hit points.
Definition: living.h:41
object::subtype
uint8_t subtype
Subtype of object.
Definition: object.h:349
CFAPI_OBJECT_PROP_RESIST
#define CFAPI_OBJECT_PROP_RESIST
Definition: plugin.h:148
CFAPI_OBJECT_PROP_SHORT_NAME
#define CFAPI_OBJECT_PROP_SHORT_NAME
Definition: plugin.h:186
CFAPI_OBJECT_PROP_MOVE_SLOW
#define CFAPI_OBJECT_PROP_MOVE_SLOW
Definition: plugin.h:225
object_get_player_container
object * object_get_player_container(object *op)
Finds the player carrying an object.
Definition: object.cpp:592
CFAPI_OBJECT_PROP_MATERIAL_NAME
#define CFAPI_OBJECT_PROP_MATERIAL_NAME
Definition: plugin.h:154
object::weight_limit
int32_t weight_limit
Weight-limit of object.
Definition: object.h:376
CFAPI_SYSTEM_REGIONS
#define CFAPI_SYSTEM_REGIONS
Definition: plugin.h:288
sstring
const char * sstring
Definition: sstring.h:2
cfapi_generate_random_map
static void cfapi_generate_random_map(int *type,...)
Wrapper for generate_random_map().
Definition: plugins.cpp:4424
mapstruct::next
mapstruct * next
Next map, linked list.
Definition: map.h:321
object_insert_in_ob
object * object_insert_in_ob(object *op, object *where)
This function inserts the object op in the linked list inside the object environment.
Definition: object.cpp:2842
object_insert_in_map_at
object * object_insert_in_map_at(object *op, mapstruct *m, object *originator, int flag, int x, int y)
Same as object_insert_in_map() except it handle separate coordinates and do a clean job preparing mul...
Definition: object.cpp:2085
cfapi_map_get_map_property
static void cfapi_map_get_map_property(int *type,...)
Definition: plugins.cpp:1135
living::wc
int8_t wc
Weapon Class, lower WC increases probability of hitting.
Definition: living.h:37
living::Int
int8_t Int
Use
Definition: living.h:36
cfapi_cost_string_from_value
static void cfapi_cost_string_from_value(int *type,...)
Wrapper for cost_string_from_value, modified to take a buffer and length instead of a StringBuffer...
Definition: plugins.cpp:498
cfapi_object_transfer
static void cfapi_object_transfer(int *type,...)
Object transfer.
Definition: plugins.cpp:3805
CFAPI_OBJECT_PROP_MAXHP
#define CFAPI_OBJECT_PROP_MAXHP
Definition: plugin.h:210
can_pay
int can_pay(object *pl)
Checks all unpaid items in op&#39;s inventory, adds up all the money they have, and checks that they can ...
Definition: shop.cpp:778
object_update
void object_update(object *op, int action)
object_update() updates the array which represents the map.
Definition: object.cpp:1419
object::count
tag_t count
Unique object number for this object.
Definition: object.h:307
region
This is a game region.
Definition: map.h:279
ready_map_name
mapstruct * ready_map_name(const char *name, int flags)
Makes sure the given map is loaded and swapped in.
Definition: map.cpp:1777
CFAPI_OBJECT_PROP_VALUE
#define CFAPI_OBJECT_PROP_VALUE
Definition: plugin.h:156
COMMAND_TYPE_NORMAL
#define COMMAND_TYPE_NORMAL
Standard commands.
Definition: commands.h:35
CFAPI_OBJECT_PROP_SPELL_ITEM
#define CFAPI_OBJECT_PROP_SPELL_ITEM
Definition: plugin.h:179
cfapi_map_find_by_archetype_name
static void cfapi_map_find_by_archetype_name(int *type,...)
Kinda wrapper for map_find_by_archetype() (but uses a string, not an archetype*). ...
Definition: plugins.cpp:1399
object::move_status
int32_t move_status
What stage in attack mode.
Definition: object.h:400
CFAPI_OBJECT_PROP_PATH_ATTUNED
#define CFAPI_OBJECT_PROP_PATH_ATTUNED
Definition: plugin.h:150
f_plug_init
int(* f_plug_init)(const char *iversion, f_plug_api gethooksptr)
First function called in a plugin.
Definition: plugin.h:83
ext_info_map
void void ext_info_map(int color, const mapstruct *map, uint8_t type, uint8_t subtype, const char *str1)
Writes to everyone on the specified map.
Definition: main.cpp:334
crossfire_plugin::libptr
LIBPTRTYPE libptr
Pointer to the plugin library.
Definition: plugin.h:98
query_short_name
void query_short_name(const object *op, char *buf, size_t size)
query_short_name(object) is similar to query_name(), but doesn&#39;t contain any information about object...
Definition: item.cpp:518
object::last_grace
int16_t last_grace
As last_sp, except for grace.
Definition: object.h:369
cfapi_object_set_key
static void cfapi_object_set_key(int *type,...)
Write a key/value for an object.
Definition: plugins.cpp:1529
cfapi_object_query_money
static void cfapi_object_query_money(int *type,...)
Wrapper for query_money().
Definition: plugins.cpp:3658
find_player_partial_name
player * find_player_partial_name(const char *plname)
Find a player by a partial name.
Definition: player.cpp:114
CFAPI_OBJECT_PROP_WIS
#define CFAPI_OBJECT_PROP_WIS
Definition: plugin.h:200
quest_was_completed
int quest_was_completed(player *pl, sstring quest_code)
Check if a quest was completed once for a player, without taking account the current state...
Definition: quest.cpp:732
object_can_merge
int object_can_merge(object *ob1, object *ob2)
Examines the 2 objects given to it, and returns true if they can be merged together, including inventory.
Definition: object.cpp:433
CFAPI_OBJECT_PROP_DURATION
#define CFAPI_OBJECT_PROP_DURATION
Definition: plugin.h:227
CFAPI_MAP_PROP_ENTER_X
#define CFAPI_MAP_PROP_ENTER_X
Definition: plugin.h:258
object_clear
void object_clear(object *op)
Frees everything allocated by an object, and also clears all variables and flags to default settings...
Definition: object.cpp:968
Face::name
sstring name
Face name, as used by archetypes and such.
Definition: face.h:19
CFAPI_OBJECT_PROP_OB_ABOVE
#define CFAPI_OBJECT_PROP_OB_ABOVE
Definition: plugin.h:120
CFAPI_OBJECT_PROP_Y
#define CFAPI_OBJECT_PROP_Y
Definition: plugin.h:139
CFAPI_OBJECT_PROP_CUSTOM_NAME
#define CFAPI_OBJECT_PROP_CUSTOM_NAME
Definition: plugin.h:183
archetype::clone
object clone
An object from which to do object_copy()
Definition: object.h:487
f_plug_api
void(* f_plug_api)(int *type,...)
General API function.
Definition: plugin.h:79
cfapi_get_weekday_name
static void cfapi_get_weekday_name(int *type,...)
Wrapper for get_season_name().
Definition: plugins.cpp:917
CUSTOM_NAME_FIELD
#define CUSTOM_NAME_FIELD
Key in an object for the player-assigned custom name.
Definition: object.h:98
living::Str
int8_t Str
Use
Definition: living.h:36
CFAPI_OBJECT_PROP_PREV_ACTIVE_OB
#define CFAPI_OBJECT_PROP_PREV_ACTIVE_OB
Definition: plugin.h:123
FOR_INV_PREPARE
#define FOR_INV_PREPARE(op_, it_)
Constructs a loop iterating over the inventory of an object.
Definition: define.h:693
cfapi_map_create_path
static void cfapi_map_create_path(int *type,...)
Wrapper for create_pathname() and create_overlay_pathname().
Definition: plugins.cpp:1101
cast_spell
int cast_spell(object *op, object *caster, int dir, object *spell_ob, char *stringarg)
Main dispatch when someone casts a spell.
Definition: spell_util.cpp:1424
CFAPI_OBJECT_PROP_PATH_DENIED
#define CFAPI_OBJECT_PROP_PATH_DENIED
Definition: plugin.h:152
CFAPI_OBJECT_PROP_MOVE_BLOCK
#define CFAPI_OBJECT_PROP_MOVE_BLOCK
Definition: plugin.h:221
mapstruct::name
char * name
Name of map as given by its creator.
Definition: map.h:323
cfapi_object_pay_item
static void cfapi_object_pay_item(int *type,...)
Wrapper for pay_for_item().
Definition: plugins.cpp:3781
CFAPI_REGION_PROP_NAME
#define CFAPI_REGION_PROP_NAME
Definition: plugin.h:276
living::hp
int16_t hp
Hit Points.
Definition: living.h:40
generate_random_map
mapstruct * generate_random_map(const char *OutFileName, RMParms *RP, char **use_layout, sstring reset_group)
Main random map routine.
Definition: random_map.cpp:75
object::path_attuned
uint32_t path_attuned
Paths the object is attuned to.
Definition: object.h:353
CFAPI_PPARTY
#define CFAPI_PPARTY
Definition: plugin.h:65
get_face_by_id
const Face * get_face_by_id(uint16_t id)
Get a face from its unique identifier.
Definition: assets.cpp:319
object::last_eat
int32_t last_eat
How long since we last ate.
Definition: object.h:366
FLAG_FREED
#define FLAG_FREED
Object is in the list of free objects.
Definition: define.h:220
object::enemy
object * enemy
Monster/player to follow even if not closest.
Definition: object.h:391
get_weekday
const char * get_weekday(const int index)
give access to weekday names
Definition: time.cpp:120
AssetsCollection::each
void each(std::function< void(T *)> op)
Apply a function to each asset.
Definition: AssetsCollection.h:158