Crossfire Server, Trunk  1.75.0
plugin_common.cpp
Go to the documentation of this file.
1 /*****************************************************************************/
2 /* Crossfire Plugin Interface Common Parts */
3 /* Version: 2.0beta8 (also known as "Alexander") */
4 /* Contact: yann.chachkoff@myrealbox.com */
5 /*****************************************************************************/
6 /* The CPICP are the various functions of the server that can be used by all */
7 /* plugins. It is recommended that plugins do not call the server-provided */
8 /* functions directly, but instead use the wrappers provided here by the */
9 /* CPICP interface. By doing so, various validity checks can be performed */
10 /* by CPICP, protecting the server from potential nasty effects of passing */
11 /* it wrong parameter values. */
12 /*****************************************************************************/
13 /* That code is placed under the GNU General Public Licence (GPL) */
14 /* (C)2001-2005 by Chachkoff Yann (Feel free to deliver your complaints) */
15 /*****************************************************************************/
16 /* CrossFire, A Multiplayer game for X-windows */
17 /* */
18 /* Copyright (C) 2000 Mark Wedel */
19 /* Copyright (C) 1992 Frank Tore Johansen */
20 /* */
21 /* This program is free software; you can redistribute it and/or modify */
22 /* it under the terms of the GNU General Public License as published by */
23 /* the Free Software Foundation; either version 2 of the License, or */
24 /* (at your option) any later version. */
25 /* */
26 /* This program is distributed in the hope that it will be useful, */
27 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
28 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
29 /* GNU General Public License for more details. */
30 /* */
31 /* You should have received a copy of the GNU General Public License */
32 /* along with this program; if not, write to the Free Software */
33 /* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
34 /* */
35 /*****************************************************************************/
36 
37 #include <assert.h>
38 #include <string.h>
39 
40 #include "plugin_common.h"
41 
42 static f_plug_api cfapiSystem_add_string = NULL;
43 static f_plug_api cfapiSystem_find_string = NULL;
44 static f_plug_api cfapiSystem_register_global_event = NULL;
45 static f_plug_api cfapiSystem_remove_string = NULL;
46 static f_plug_api cfapiSystem_unregister_global_event = NULL;
47 static f_plug_api cfapiSystem_strdup_local = NULL;
48 static f_plug_api cfapiSystem_find_animation = NULL;
49 static f_plug_api cfapiSystem_find_face = NULL;
50 static f_plug_api cfapiSystem_log = NULL;
51 static f_plug_api cfapiSystem_get_time = NULL;
52 static f_plug_api cfapiSystem_timer_create = NULL;
53 static f_plug_api cfapiSystem_timer_destroy = NULL;
54 static f_plug_api cfapiSystem_directory = NULL;
55 static f_plug_api cfapiSystem_re_cmp = NULL;
56 
57 static f_plug_api cfapiObject_get_property = NULL;
58 static f_plug_api cfapiObject_set_property = NULL;
59 static f_plug_api cfapiObject_apply = NULL;
60 static f_plug_api cfapiObject_identify = NULL;
61 static f_plug_api cfapiObject_describe = NULL;
62 static f_plug_api cfapiObject_drain = NULL;
63 static f_plug_api cfapiObject_fix = NULL;
64 static f_plug_api cfapiObject_give_skill = NULL;
65 static f_plug_api cfapiObject_transmute = NULL;
66 static f_plug_api cfapiObject_remove = NULL;
67 static f_plug_api cfapiObject_delete = NULL;
68 static f_plug_api cfapiObject_clone = NULL;
69 static f_plug_api cfapiObject_create = NULL;
70 static f_plug_api cfapiObject_insert = NULL;
71 static f_plug_api cfapiObject_split = NULL;
72 static f_plug_api cfapiObject_merge = NULL;
73 static f_plug_api cfapiObject_distance = NULL;
74 static f_plug_api cfapiObject_update = NULL;
75 static f_plug_api cfapiObject_clear = NULL;
76 static f_plug_api cfapiObject_reset = NULL;
77 static f_plug_api cfapiObject_activate_rune = NULL;
78 static f_plug_api cfapiObject_check_trigger = NULL;
79 static f_plug_api cfapiObject_query_money = NULL;
80 static f_plug_api cfapiObject_cast = NULL;
81 static f_plug_api cfapiObject_learn_spell = NULL;
82 static f_plug_api cfapiObject_forget_spell = NULL;
83 static f_plug_api cfapiObject_check_spell = NULL;
84 static f_plug_api cfapiObject_pay_amount = NULL;
85 static f_plug_api cfapiObject_pay_item = NULL;
86 static f_plug_api cfapiObject_transfer = NULL;
87 static f_plug_api cfapiObject_find_archetype_inside = NULL;
88 static f_plug_api cfapiObject_find_by_arch_name = NULL;
89 static f_plug_api cfapiObject_find_by_name = NULL;
90 static f_plug_api cfapiObject_out_of_map = NULL;
91 static f_plug_api cfapiObject_drop = NULL;
92 static f_plug_api cfapiObject_change_abil = NULL;
93 static f_plug_api cfapiObject_say = NULL;
94 static f_plug_api cfapiMap_get_property = NULL;
95 static f_plug_api cfapiMap_set_property = NULL;
96 static f_plug_api cfapiMap_get_map = NULL;
97 static f_plug_api cfapiMap_message = NULL;
98 static f_plug_api cfapiMap_get_object_at = NULL;
99 static f_plug_api cfapiMap_find_by_archetype_name = NULL;
100 static f_plug_api cfapiMap_create_path = NULL;
101 static f_plug_api cfapiMap_has_been_loaded = NULL;
102 static f_plug_api cfapiMap_change_light = NULL;
103 static f_plug_api cfapiMap_trigger_connected = NULL;
104 static f_plug_api cfapiPlayer_find = NULL;
105 static f_plug_api cfapiPlayer_message = NULL;
106 static f_plug_api cfapiObject_teleport = NULL;
107 static f_plug_api cfapiObject_pickup = NULL;
108 static f_plug_api cfapiObject_get_key = NULL;
109 static f_plug_api cfapiObject_set_key = NULL;
110 static f_plug_api cfapiObject_move = NULL;
111 static f_plug_api cfapiObject_apply_below = NULL;
112 static f_plug_api cfapiArchetype_get_property = NULL;
113 static f_plug_api cfapiParty_get_property = NULL;
114 static f_plug_api cfapiRegion_get_property = NULL;
115 static f_plug_api cfapiPlayer_can_pay = NULL;
116 static f_plug_api cfapiFriendlylist_get_next = NULL;
117 static f_plug_api cfapiSet_random_map_variable = NULL;
118 static f_plug_api cfapiGenerate_random_map = NULL;
119 static f_plug_api cfapiObject_change_exp = NULL;
120 static f_plug_api cfapiSystem_get_month_name = NULL;
121 static f_plug_api cfapiSystem_get_season_name = NULL;
122 static f_plug_api cfapiSystem_get_weekday_name = NULL;
123 static f_plug_api cfapiSystem_get_periodofday_name = NULL;
124 static f_plug_api cfapiObject_user_event = NULL;
125 static f_plug_api cfapiCost_string_from_value = NULL;
126 static f_plug_api cfapiPlayer_quest = NULL;
127 static f_plug_api cfapiObject_remove_depletion = NULL;
128 static f_plug_api cfapiPlayer_knowledge = NULL;
129 static f_plug_api cfapiObject_perm_exp = NULL;
130 static f_plug_api cfapiSystem_register_command = NULL;
131 static f_plug_api cfapiSystem_unregister_command = NULL;
132 static f_plug_api cfapiSystem_get_object_vector = NULL;
133 static f_plug_api cfapiSystem_get_map_vector = NULL;
134 static f_plug_api cfapiSystem_get_archetype_vector = NULL;
135 static f_plug_api cfapiSystem_get_region_vector = NULL;
136 static f_plug_api cfapiSystem_get_party_vector = NULL;
137 
138 #define GET_HOOK(x, y, z) { \
139  getHooks(&z, 1, y, &x); \
140  if (z != CFAPI_FUNC) { \
141  printf("unable to find hook %s!\n", y); \
142  return 0; \
143  } \
144 }
145 
146 int cf_init_plugin(f_plug_api getHooks) {
147  int z;
148 
149  GET_HOOK(cfapiSystem_strdup_local, "cfapi_system_strdup_local", z);
150  GET_HOOK(cfapiSystem_add_string, "cfapi_system_add_string", z);
151  GET_HOOK(cfapiSystem_register_global_event, "cfapi_system_register_global_event", z);
152  GET_HOOK(cfapiSystem_remove_string, "cfapi_system_remove_string", z);
153  GET_HOOK(cfapiSystem_directory, "cfapi_system_directory", z);
154  GET_HOOK(cfapiSystem_unregister_global_event, "cfapi_system_unregister_global_event", z);
155  GET_HOOK(cfapiSystem_find_animation, "cfapi_system_find_animation", z);
156  GET_HOOK(cfapiSystem_find_face, "cfapi_system_find_face", z);
157  GET_HOOK(cfapiSystem_re_cmp, "cfapi_system_re_cmp", z);
158  GET_HOOK(cfapiObject_get_property, "cfapi_object_get_property", z);
159  GET_HOOK(cfapiObject_set_property, "cfapi_object_set_property", z);
160  GET_HOOK(cfapiObject_apply, "cfapi_object_apply", z);
161  GET_HOOK(cfapiObject_identify, "cfapi_object_identify", z);
162  GET_HOOK(cfapiObject_describe, "cfapi_object_describe", z);
163  GET_HOOK(cfapiObject_drain, "cfapi_object_drain", z);
164  GET_HOOK(cfapiObject_fix, "cfapi_object_fix", z);
165  GET_HOOK(cfapiObject_give_skill, "cfapi_object_give_skill", z);
166  GET_HOOK(cfapiObject_transmute, "cfapi_object_transmute", z);
167  GET_HOOK(cfapiObject_remove, "cfapi_object_remove", z);
168  GET_HOOK(cfapiObject_delete, "cfapi_object_delete", z);
169  GET_HOOK(cfapiObject_clone, "cfapi_object_clone", z);
170  GET_HOOK(cfapiObject_create, "cfapi_object_create", z);
171  GET_HOOK(cfapiObject_insert, "cfapi_object_insert", z);
172  GET_HOOK(cfapiObject_split, "cfapi_object_split", z);
173  GET_HOOK(cfapiObject_merge, "cfapi_object_merge", z);
174  GET_HOOK(cfapiObject_distance, "cfapi_object_distance", z);
175  GET_HOOK(cfapiObject_update, "cfapi_object_update", z);
176  GET_HOOK(cfapiObject_clear, "cfapi_object_clear", z);
177  GET_HOOK(cfapiObject_reset, "cfapi_object_reset", z);
178  GET_HOOK(cfapiObject_activate_rune, "cfapi_object_spring_trap", z);
179  GET_HOOK(cfapiObject_check_trigger, "cfapi_object_check_trigger", z);
180  GET_HOOK(cfapiObject_query_money, "cfapi_object_query_money", z);
181  GET_HOOK(cfapiObject_cast, "cfapi_object_cast", z);
182  GET_HOOK(cfapiObject_learn_spell, "cfapi_object_learn_spell", z);
183  GET_HOOK(cfapiObject_forget_spell, "cfapi_object_forget_spell", z);
184  GET_HOOK(cfapiObject_check_spell, "cfapi_object_check_spell", z);
185  GET_HOOK(cfapiObject_pay_amount, "cfapi_object_pay_amount", z);
186  GET_HOOK(cfapiObject_pay_item, "cfapi_object_pay_item", z);
187  GET_HOOK(cfapiObject_transfer, "cfapi_object_transfer", z);
188  GET_HOOK(cfapiObject_find_archetype_inside, "cfapi_object_find_archetype_inside", z);
189  GET_HOOK(cfapiObject_remove, "cfapi_object_remove", z);
190  GET_HOOK(cfapiObject_delete, "cfapi_object_delete", z);
191  GET_HOOK(cfapiObject_out_of_map, "cfapi_map_out_of_map", z);
192  GET_HOOK(cfapiObject_drop, "cfapi_object_drop", z);
193  GET_HOOK(cfapiObject_change_abil, "cfapi_object_change_abil", z);
194  GET_HOOK(cfapiObject_say, "cfapi_object_say", z);
195  GET_HOOK(cfapiMap_create_path, "cfapi_map_create_path", z);
196  GET_HOOK(cfapiMap_get_property, "cfapi_map_get_property", z);
197  GET_HOOK(cfapiMap_set_property, "cfapi_map_set_property", z);
198  GET_HOOK(cfapiMap_get_map, "cfapi_map_get_map", z);
199  GET_HOOK(cfapiMap_message, "cfapi_map_message", z);
200  GET_HOOK(cfapiMap_get_object_at, "cfapi_map_get_object_at", z);
201  GET_HOOK(cfapiMap_find_by_archetype_name, "cfapi_map_find_by_archetype_name", z);
202  GET_HOOK(cfapiMap_change_light, "cfapi_map_change_light", z);
203  GET_HOOK(cfapiMap_has_been_loaded, "cfapi_map_has_been_loaded", z);
204  GET_HOOK(cfapiMap_trigger_connected, "cfapi_map_trigger_connected", z);
205  GET_HOOK(cfapiPlayer_find, "cfapi_player_find", z);
206  GET_HOOK(cfapiPlayer_message, "cfapi_player_message", z);
207  GET_HOOK(cfapiObject_teleport, "cfapi_object_teleport", z);
208  GET_HOOK(cfapiObject_pickup, "cfapi_object_pickup", z);
209  GET_HOOK(cfapiObject_get_key, "cfapi_object_get_key", z);
210  GET_HOOK(cfapiObject_set_key, "cfapi_object_set_key", z);
211  GET_HOOK(cfapiObject_move, "cfapi_object_move", z);
212  GET_HOOK(cfapiObject_apply_below, "cfapi_object_apply_below", z);
213  GET_HOOK(cfapiArchetype_get_property, "cfapi_archetype_get_property", z);
214  GET_HOOK(cfapiParty_get_property, "cfapi_party_get_property", z);
215  GET_HOOK(cfapiRegion_get_property, "cfapi_region_get_property", z);
216  GET_HOOK(cfapiPlayer_can_pay, "cfapi_player_can_pay", z);
217  GET_HOOK(cfapiSystem_log, "cfapi_log", z);
218  GET_HOOK(cfapiSystem_get_time, "cfapi_system_get_time", z);
219  GET_HOOK(cfapiSystem_timer_create, "cfapi_system_timer_create", z);
220  GET_HOOK(cfapiSystem_timer_destroy, "cfapi_system_timer_destroy", z);
221  GET_HOOK(cfapiFriendlylist_get_next, "cfapi_friendlylist_get_next", z);
222  GET_HOOK(cfapiSet_random_map_variable, "cfapi_set_random_map_variable", z);
223  GET_HOOK(cfapiGenerate_random_map, "cfapi_generate_random_map", z);
224  GET_HOOK(cfapiObject_change_exp, "cfapi_object_change_exp", z);
225  GET_HOOK(cfapiSystem_get_season_name, "cfapi_system_get_season_name", z);
226  GET_HOOK(cfapiSystem_get_month_name, "cfapi_system_get_month_name", z);
227  GET_HOOK(cfapiSystem_get_weekday_name, "cfapi_system_get_weekday_name", z);
228  GET_HOOK(cfapiSystem_get_periodofday_name, "cfapi_system_get_periodofday_name", z);
229  GET_HOOK(cfapiObject_user_event, "cfapi_object_user_event", z);
230  GET_HOOK(cfapiSystem_find_string, "cfapi_system_find_string", z);
231  GET_HOOK(cfapiCost_string_from_value, "cfapi_cost_string_from_value", z);
232  GET_HOOK(cfapiPlayer_quest, "cfapi_player_quest", z);
233  GET_HOOK(cfapiObject_remove_depletion, "cfapi_object_remove_depletion", z);
234  GET_HOOK(cfapiObject_find_by_arch_name, "cfapi_object_find_by_arch_name", z);
235  GET_HOOK(cfapiObject_find_by_name, "cfapi_object_find_by_name", z);
236  GET_HOOK(cfapiPlayer_knowledge, "cfapi_player_knowledge", z);
237  GET_HOOK(cfapiObject_perm_exp, "cfapi_object_perm_exp", z);
238  GET_HOOK(cfapiSystem_register_command, "cfapi_register_command", z);
239  GET_HOOK(cfapiSystem_unregister_command, "cfapi_unregister_command", z);
240  GET_HOOK(cfapiSystem_get_object_vector, "cfapi_get_object_vector", z);
241  GET_HOOK(cfapiSystem_get_map_vector, "cfapi_get_map_vector", z);
242  GET_HOOK(cfapiSystem_get_archetype_vector, "cfapi_get_archetype_vector", z);
243  GET_HOOK(cfapiSystem_get_party_vector, "cfapi_get_party_vector", z);
244  GET_HOOK(cfapiSystem_get_region_vector, "cfapi_get_region_vector", z);
245  return 1;
246 }
247 
248 /* Should get replaced by tons of more explicit wrappers */
249 /*void *cf_map_get_property(mapstruct *map, int propcode) {
250  int type;
251  return cfapiMap_get_property(&type, propcode, map);
252 }*/
253 
254 int cf_map_get_int_property(mapstruct *map, int property) {
255  int type, value;
256 
257  cfapiMap_get_property(&type, map, property, &value);
258  assert(type == CFAPI_INT);
259  return value;
260 }
261 
262 int cf_object_user_event(object *op, object *activator, object *third, const char *message, int fix) {
263  int type, value;
264 
265  cfapiObject_user_event(&type, op, activator, third, message, fix, &value);
266  assert(type == CFAPI_INT);
267  return value;
268 }
269 
270 sstring cf_map_get_sstring_property(mapstruct *map, int propcode) {
271  int type;
272  sstring value;
273 
274  cfapiMap_get_property(&type, map, propcode, &value);
275  assert(type == CFAPI_SSTRING);
276  return value;
277 }
278 
279 mapstruct *cf_map_get_map_property(mapstruct *map, int propcode) {
280  int type;
281  mapstruct *value;
282 
283  cfapiMap_get_property(&type, map, propcode, &value);
284  assert(type == CFAPI_PMAP);
285  return value;
286 }
287 
288 region *cf_map_get_region_property(mapstruct *map, int propcode) {
289  int type;
290  region *value;
291 
292  cfapiMap_get_property(&type, map, propcode, &value);
293  assert(type == CFAPI_PREGION);
294  return value;
295 }
296 
297 /* Should get replaced by tons of more explicit wrappers */
298 void cf_map_set_int_property(mapstruct *map, int propcode, int value) {
299  int type;
300 
301  cfapiMap_set_property(&type, map, propcode, value);
302  assert(type == CFAPI_INT);
303 }
304 
305 void cf_map_set_string_property(mapstruct *map, int propcode, const char *value) {
306  int type;
307 
308  cfapiMap_set_property(&type, map, propcode, value);
309  assert(type == CFAPI_STRING);
310 }
311 
312 /* Should get replaced by tons of more explicit wrappers */
313 int16_t cf_object_get_resistance(object *op, int rtype) {
314  int type;
315  int16_t resist;
316 
317  cfapiObject_get_property(&type, op, CFAPI_OBJECT_PROP_RESIST, rtype, &resist);
318  assert(type == CFAPI_INT16);
319  return resist;
320 }
321 void cf_object_set_resistance(object *op, int rtype, int16_t value) {
322  int type;
323 
324  cfapiObject_set_property(&type, op, CFAPI_OBJECT_PROP_RESIST, rtype, value);
325  assert(type == CFAPI_INT16);
326 }
327 
328 /* Should get replaced by tons of more explicit wrappers */
329 void cf_object_set_int_property(object *op, int propcode, int value) {
330  int type;
331 
332  cfapiObject_set_property(&type, op, propcode, value);
333  assert(type == CFAPI_INT);
334 }
335 int cf_object_get_int_property(object *op, int propcode) {
336  int type, value;
337 
338  cfapiObject_get_property(&type, op, propcode, &value);
339  assert(type == CFAPI_INT);
340  return value;
341 }
342 long cf_object_get_long_property(object *op, long propcode) {
343  int type;
344  long value;
345 
346  cfapiObject_get_property(&type, op, propcode, &value);
347  assert(type == CFAPI_LONG);
348  return value;
349 }
350 void cf_object_set_movetype_property(object *op, int propcode, MoveType value) {
351  int type;
352 
353  /* note: MoveType can't be used through va_arg, so use MoveType * */
354  cfapiObject_set_property(&type, op, propcode, &value);
355  assert(type == CFAPI_MOVETYPE);
356 }
357 MoveType cf_object_get_movetype_property(object *op, int propcode) {
358  int type;
359  MoveType value;
360 
361  cfapiObject_get_property(&type, op, propcode, &value);
362  assert(type == CFAPI_MOVETYPE);
363  return value;
364 }
365 object *cf_object_get_object_property(object *op, int propcode) {
366  int type;
367  object *value;
368 
369  cfapiObject_get_property(&type, op, propcode, &value);
370  assert(type == CFAPI_POBJECT);
371  return value;
372 }
373 mapstruct *cf_object_get_map_property(object *op, int propcode) {
374  int type;
375  mapstruct *value;
376 
377  cfapiObject_get_property(&type, op, propcode, &value);
378  assert(type == CFAPI_PMAP);
379  return value;
380 }
381 int64_t cf_object_get_int64_property(object *op, int propcode) {
382  int type;
383  int64_t value;
384 
385  cfapiObject_get_property(&type, op, propcode, &value);
386  assert(type == CFAPI_SINT64);
387  return value;
388 }
389 /* Should get replaced by tons of more explicit wrappers */
390 void cf_object_set_long_property(object *op, int propcode, long value) {
391  int type;
392 
393  cfapiObject_set_property(&type, op, propcode, value);
394  assert(type == CFAPI_LONG);
395 }
396 void cf_object_set_float_property(object *op, int propcode, float value) {
397  int type;
398 
399  cfapiObject_set_property(&type, op, propcode, value);
400  assert(type == CFAPI_FLOAT);
401 }
402 void cf_object_set_int64_property(object *op, int propcode, int64_t value) {
403  int type;
404 
405  cfapiObject_set_property(&type, op, propcode, value);
406  assert(type == CFAPI_SINT64);
407 }
408 float cf_object_get_float_property(object *op, int propcode) {
409  int type;
410  float value;
411 
412  cfapiObject_get_property(&type, op, propcode, &value);
413  assert(type == CFAPI_FLOAT);
414  return value;
415 }
416 archetype *cf_object_get_archetype_property(object *op, int propcode) {
417  int type;
418  archetype *value;
419 
420  cfapiObject_get_property(&type, op, propcode, &value);
421  assert(type == CFAPI_PARCH);
422  return value;
423 }
424 partylist *cf_object_get_partylist_property(object *op, int propcode) {
425  int type;
426  partylist *value;
427 
428  cfapiObject_get_property(&type, op, propcode, &value);
429  assert(type == CFAPI_PPARTY);
430  return value;
431 }
432 double cf_object_get_double_property(object *op, int propcode) {
433  int type;
434  double value;
435 
436  cfapiObject_get_property(&type, op, propcode, &value);
437  assert(type == CFAPI_DOUBLE);
438  return value;
439 }
440 sstring cf_object_get_sstring_property(object *op, int propcode) {
441  int type;
442  sstring value;
443 
444  cfapiObject_get_property(&type, op, propcode, &value);
445  assert(type == CFAPI_SSTRING);
446  return value;
447 }
448 char *cf_object_get_string_property(object *op, int propcode, char *buf, int size) {
449  int type;
450 
451  cfapiObject_get_property(&type, op, propcode, buf, size);
452  assert(type == CFAPI_STRING);
453  return buf;
454 }
455 /* Should get replaced by tons of more explicit wrappers */
456 void cf_object_set_string_property(object *op, int propcode, const char *value) {
457  int type;
458 
459  /* use cf_object_set_face() for changing the face! */
460  assert(propcode != CFAPI_OBJECT_PROP_FACE);
461  /* use cf_object_set_animation() to change the animation */
462  assert(propcode != CFAPI_OBJECT_PROP_ANIMATION);
463 
464  cfapiObject_set_property(&type, op, propcode, value);
465  assert(type == CFAPI_STRING);
466 }
467 
474 int cf_object_set_face(object *op, const char *face) {
475  int type, ret;
476  cfapiObject_set_property(&type, op, CFAPI_OBJECT_PROP_FACE, face, &ret);
477  assert(type == CFAPI_INT);
478  return ret;
479 }
486 int cf_object_set_animation(object *op, const char *animation) {
487  int type, ret;
488  cfapiObject_set_property(&type, op, CFAPI_OBJECT_PROP_ANIMATION, animation, &ret);
489  assert(type == CFAPI_INT);
490  return ret;
491 }
492 
493 void cf_object_set_object_property(object *op, int propcode, object *value) {
494  int type;
495 
496  cfapiObject_set_property(&type, op, propcode, value);
497  assert(type == CFAPI_POBJECT);
498 }
499 
504 void cf_object_change_exp(object *op, int64_t exp, const char *skill_name, int flag) {
505  int type;
506 
507  cfapiObject_change_exp(&type, op, exp, skill_name && strlen(skill_name) > 0 ? skill_name : NULL, flag);
508  assert(type == CFAPI_NONE);
509 }
510 
515 int64_t cf_object_perm_exp(object *op) {
516  int type;
517  int64_t ret;
518 
519  cfapiObject_perm_exp(&type, op, &ret);
520  assert(type == CFAPI_SINT64);
521  return ret;
522 }
523 
524 int cf_player_move(player *pl, int dir) {
525  int type, ret;
526 
527  cfapiObject_move(&type, 1, pl, dir, &ret);
528  assert(type == CFAPI_INT);
529  return ret;
530 }
531 int cf_object_move(object *op, int dir, object*originator) {
532  int type, ret;
533 
534  cfapiObject_move(&type, 0, op, dir, originator, &ret);
535  assert(type == CFAPI_INT);
536  return ret;
537 }
542 int cf_object_apply(object *op, object *tmp, int aflag) {
543  int type, ret;
544 
545  cfapiObject_apply(&type, op, tmp, aflag, &ret);
546  return ret;
547 }
548 
553 void cf_object_apply_below(object *pl) {
554  int type;
555 
556  cfapiObject_apply_below(&type, pl);
557 }
562 void cf_object_remove(object *op) {
563  int type;
564 
565  cfapiObject_remove(&type, op);
566 }
571 void cf_object_free_drop_inventory(object *ob) {
572  int type;
573 
574  cfapiObject_delete(&type, ob);
575 }
579 object *cf_object_present_archname_inside(object *op, char *whatstr) {
580  int type;
581  object *value;
582 
583  cfapiObject_find_archetype_inside(&type, op, whatstr, &value);
584  assert(type == CFAPI_POBJECT);
585  return value;
586 }
587 
592 object *cf_object_find_by_arch_name(const object *who, const char *name) {
593  int type;
594  object *result;
595 
596  cfapiObject_find_by_arch_name(&type, who, name, &result);
597  assert(type == CFAPI_POBJECT);
598  return result;
599 }
600 
605 object *cf_object_find_by_name(const object *who, const char *name) {
606  int type;
607  object *result;
608 
609  cfapiObject_find_by_name(&type, who, name, &result);
610  assert(type == CFAPI_POBJECT);
611  return result;
612 }
613 
618 int cf_object_transfer(object *op, int x, int y, int randomly, object *originator) {
619  int type, value;
620 
621  cfapiObject_transfer(&type, op, 0, x, y, randomly, originator, &value);
622  assert(type == CFAPI_INT);
623  return value;
624 }
625 
630 int cf_object_move_to(object *op, int x, int y) {
631  int type, value;
632 
633  cfapiObject_transfer(&type, op, 2, x, y, &value);
634  assert(type == CFAPI_INT);
635  return value;
636 }
637 
642 object *cf_object_change_map(object *op, mapstruct *m, object *originator, int flag, int x, int y) {
643  int type;
644  object *value;
645 
646  cfapiObject_transfer(&type, op, 1, m, originator, flag, x, y, &value);
647  assert(type == CFAPI_POBJECT);
648  return value;
649 }
650 
655 object *cf_map_get_object_at(mapstruct *m, int x, int y) {
656  int type;
657  object *value;
658 
659  cfapiMap_get_object_at(&type, m, x, y, &value);
660  assert(type == CFAPI_POBJECT);
661  return value;
662 }
667 void cf_map_message(mapstruct *m, const char *msg, int color) {
668  int type;
669 
670  cfapiMap_message(&type, m, msg, color);
671 }
672 
683 object *cf_object_clone(object *op, int clonetype) {
684  int type;
685  object *value;
686 
687  cfapiObject_clone(&type, op, clonetype, &value);
688  assert(type == CFAPI_POBJECT);
689  return value;
690 }
691 
692 
697 object *cf_object_split(object *orig_ob, uint32_t nr, char *err, size_t size) {
698  int type;
699  object *value;
700 
701  cfapiObject_split(&type, orig_ob, nr, err, size, &value);
702 
703  if (value == NULL)
704  {
705  assert(type == CFAPI_NONE);
706  }
707  else
708  {
709  assert(type == CFAPI_POBJECT);
710  }
711 
712  return value;
713 }
714 
715 
720 int cf_object_pay_item(object *op, object *pl) {
721  int type, value;
722 
723  cfapiObject_pay_item(&type, op, pl, &value);
724  assert(type == CFAPI_INT);
725  return value;
726 }
727 
732 int cf_object_pay_amount(object *pl, uint64_t to_pay) {
733  int type, value;
734 
735  cfapiObject_pay_amount(&type, pl, to_pay, &value);
736  assert(type == CFAPI_INT);
737  return value;
738 }
739 
744 int cf_object_cast_spell(object *op, object *caster, int dir, object *spell_ob, char *stringarg) {
745  int type, value;
746 
747  cfapiObject_cast(&type, op, caster, dir, spell_ob, stringarg, &value);
748  assert(type == CFAPI_INT);
749  return value;
750 }
751 
756 void cf_object_learn_spell(object *op, object *spell, int special_prayer) {
757  int type;
758 
759  cfapiObject_learn_spell(&type, op, spell, special_prayer);
760  assert(type == CFAPI_NONE);
761 }
762 
768 void cf_object_forget_spell(object *op, object *sp) {
769  int type;
770 
771  cfapiObject_forget_spell(&type, op, sp);
772 }
773 
778 object *cf_object_check_for_spell(object *op, const char *name) {
779  int type;
780  object *value;
781 
782  cfapiObject_check_spell(&type, op, name, &value);
783  assert(type == CFAPI_POBJECT);
784  return value;
785 }
786 
787 void cf_player_message(object *op, const char *txt, int flags) {
788  int type;
789 
790  cfapiPlayer_message(&type, flags, 0, op, txt);
791  assert(type == CFAPI_NONE);
792 }
793 
798 int cf_object_remove_depletion(object *op, int level) {
799  int type, result;
800 
801  cfapiObject_remove_depletion(&type, op, level, &result);
802  assert(type == CFAPI_INT);
803  return result;
804 }
805 
812 object *cf_identify(object *op) {
813  int type;
814  object *result;
815 
816  cfapiObject_identify(&type, op, &result);
817  assert(type == CFAPI_POBJECT);
818  return result;
819 }
820 
825 player *cf_player_find(const char *plname) {
826  int type;
827  player *value;
828 
829  cfapiPlayer_find(&type, plname, &value);
830  assert(type == CFAPI_PPLAYER);
831  return value;
832 }
833 
834 char *cf_player_get_title(object *op, char *title, int size) {
835  int type;
836 
837  cfapiObject_get_property(&type, op, CFAPI_PLAYER_PROP_TITLE, title, size);
838  assert(type == CFAPI_STRING);
839  return title;
840 }
841 
842 void cf_player_set_title(object *op, const char *title) {
843  int type;
844 
845  cfapiObject_set_property(&type, op, CFAPI_PLAYER_PROP_TITLE, title);
846 }
847 
848 sstring cf_player_get_ip(object *op) {
849  int type;
850  sstring value;
851 
852  cfapiObject_get_property(&type, op, CFAPI_PLAYER_PROP_IP, &value);
853  assert(type == CFAPI_SSTRING);
854  return value;
855 }
856 
857 sstring cf_player_get_client(object *op) {
858  int type;
859  sstring value;
860 
861  cfapiObject_get_property(&type, op, CFAPI_PLAYER_PROP_CLIENT, &value);
862  assert(type == CFAPI_SSTRING);
863  return value;
864 }
865 
866 object *cf_player_get_marked_item(object *op) {
867  int type;
868  object *value;
869 
870  cfapiObject_get_property(&type, op, CFAPI_PLAYER_PROP_MARKED_ITEM, &value);
871  assert(type == CFAPI_POBJECT);
872  return value;
873 }
874 
875 void cf_player_set_marked_item(object *op, object *ob) {
876  int type;
877 
878  cfapiObject_set_property(&type, op, CFAPI_PLAYER_PROP_MARKED_ITEM, ob);
879 }
880 
881 partylist *cf_player_get_party(object *op) {
882  return cf_object_get_partylist_property(op, CFAPI_PLAYER_PROP_PARTY);
883 }
884 
885 void cf_player_set_party(object *op, partylist *party) {
886  int type;
887 
888  cfapiObject_set_property(&type, op, CFAPI_PLAYER_PROP_PARTY, party);
889 }
890 
895 int cf_player_can_pay(object *pl) {
896  int type, value;
897 
898  cfapiPlayer_can_pay(&type, pl, &value);
899  assert(type == CFAPI_INT);
900  return value;
901 }
902 
909 int cf_player_knowledge_has(object *op, const char *knowledge) {
910  int type, value;
911 
912  cfapiPlayer_knowledge(&type, 1, op, knowledge, &value);
913  assert(type == CFAPI_INT);
914  return value;
915 }
916 
922 void cf_player_knowledge_give(object *op, const char *knowledge) {
923  int type;
924 
925  cfapiPlayer_knowledge(&type, 2, op, knowledge);
926  assert(type == CFAPI_NONE);
927 }
928 
933 int cf_player_arrest(object *who) {
934  int type, value;
935  cfapiObject_move(&type, 2, who, &value);
936  assert(type == CFAPI_INT);
937  return value;
938 }
939 
944 mapstruct *cf_map_get_map(const char *name, int flags) {
945  int type;
946  mapstruct *ret;
947 
948  cfapiMap_get_map(&type, 1, name, flags, &ret);
949  assert(type == CFAPI_PMAP);
950  return ret;
951 }
952 
957 mapstruct *cf_get_empty_map(int sizex, int sizey) {
958  int type;
959  mapstruct *ret;
960 
961  cfapiMap_get_map(&type, 0, sizex, sizey, &ret);
962  assert(type == CFAPI_PMAP);
963  return ret;
964 }
965 
970 mapstruct *cf_map_has_been_loaded(const char *name) {
971  int type;
972  mapstruct *ret;
973 
974  cfapiMap_has_been_loaded(&type, name, &ret);
975  assert(type == CFAPI_PMAP);
976  return ret;
977 }
978 
984 mapstruct *cf_map_get_first(void) {
985  return cf_map_get_map_property(NULL, CFAPI_MAP_PROP_NEXT);
986 }
987 
992 int cf_object_query_money(const object *op) {
993  int type, value;
994 
995  cfapiObject_query_money(&type, op, &value);
996  assert(type == CFAPI_INT);
997  return value;
998 }
999 
1003 void cf_cost_string_from_value(uint64_t cost, int largest_coin, char *buffer, int length) {
1004  int type;
1005 
1006  cfapiCost_string_from_value(&type, cost, largest_coin, buffer, length);
1007  assert(type == CFAPI_NONE);
1008 }
1009 
1014 void cf_spring_trap(object *trap, object *victim) {
1015  int type;
1016 
1017  if (trap)
1018  cfapiObject_activate_rune(&type, trap, victim);
1019 }
1020 
1025 int cf_object_check_trigger(object *op, object *cause) {
1026  int type, value;
1027 
1028  cfapiObject_check_trigger(&type, op, cause, &value);
1029  assert(type == CFAPI_INT);
1030  return value;
1031 }
1032 
1037 void cf_map_trigger_connected(objectlink *ol, object *cause, int state) {
1038  int type;
1039 
1040  cfapiMap_trigger_connected(&type, ol, cause, state);
1041  assert(type == CFAPI_NONE);
1042 }
1043 
1044 int cf_object_out_of_map(object *op, int x, int y) {
1045  int type, value;
1046 
1047  cfapiObject_out_of_map(&type, op->map, x, y, &value);
1048  assert(type == CFAPI_INT);
1049  return value;
1050 }
1051 
1052 void cf_object_drop(object *op, object *author) {
1053  int type;
1054 
1055  cfapiObject_drop(&type, op, author);
1056 }
1057 
1058 void cf_object_say(object *op, const char *msg) {
1059  int type, value;
1060 
1061  cfapiObject_say(&type, op, msg, &value);
1062  assert(type == CFAPI_INT);
1063 }
1064 
1065 object *cf_object_insert_object(object *op, object *container) {
1066  int type;
1067  object *value;
1068 
1069  cfapiObject_insert(&type, op, 3, container, &value);
1070  assert(type == CFAPI_POBJECT);
1071  return value;
1072 }
1073 
1078 char *cf_get_maps_directory(const char *name, char *buf, int size) {
1079  int type;
1080 
1081  cfapiMap_create_path(&type, 0, name, buf, size);
1082  assert(type == CFAPI_STRING);
1083  return buf;
1084 }
1085 
1090 object *cf_create_object(void) {
1091  int type;
1092  object *value;
1093 
1094  cfapiObject_create(&type, 0, &value);
1095  assert(type == CFAPI_POBJECT);
1096  return value;
1097 }
1098 
1102 object *cf_create_object_by_name(const char *name) {
1103  int type;
1104  object *value;
1105 
1106  cfapiObject_create(&type, 1, name, &value);
1107  assert(type == CFAPI_POBJECT);
1108  return value;
1109 }
1110 
1111 void cf_system_register_global_event(int event, const char *name, f_plug_event hook) {
1112  int type;
1113 
1114  cfapiSystem_register_global_event(&type, event, name, hook);
1115  assert(type == CFAPI_NONE);
1116 }
1117 
1118 void cf_system_unregister_global_event(int event, const char *name) {
1119  int type;
1120 
1121  cfapiSystem_unregister_global_event(&type, event, name);
1122  assert(type == CFAPI_NONE);
1123 }
1124 
1139 const char *cf_get_directory(int id) {
1140  int type;
1141  const char *ret;
1142 
1143  cfapiSystem_directory(&type, id, &ret);
1144  assert(type == CFAPI_STRING);
1145  return ret;
1146 }
1147 
1152 const char *cf_re_cmp(const char *str, const char *regexp) {
1153  int type;
1154  const char *result;
1155 
1156  cfapiSystem_re_cmp(&type, str, regexp, &result);
1157  assert(type == CFAPI_STRING);
1158  return result;
1159 }
1160 
1165 void cf_fix_object(object *op) {
1166  int type;
1167 
1168  if (op)
1169  cfapiObject_fix(&type, op);
1170 }
1171 
1176 sstring cf_add_string(const char *str) {
1177  int type;
1178  sstring ret;
1179 
1180  if (!str)
1181  return NULL;
1182  cfapiSystem_add_string(&type, str, &ret);
1183  assert(type == CFAPI_SSTRING);
1184  return ret;
1185 }
1186 
1191 void cf_free_string(sstring str) {
1192  int type;
1193 
1194  if (str)
1195  cfapiSystem_remove_string(&type, str);
1196 }
1197 
1198 sstring cf_find_string(const char *str) {
1199  int type;
1200  sstring ret;
1201 
1202  if (!str)
1203  return NULL;
1204 
1205  cfapiSystem_find_string(&type, str, &ret);
1206  assert(type == CFAPI_SSTRING);
1207  return ret;
1208 }
1209 
1210 char *cf_query_name(object *ob, char *name, int size) {
1211  int type;
1212 
1213  cfapiObject_get_property(&type, ob, CFAPI_OBJECT_PROP_NAME, name, size);
1214  assert(type == CFAPI_STRING);
1215  return name;
1216 }
1217 
1218 sstring cf_query_name_pl(object *ob) {
1219  int type;
1220  sstring value;
1221 
1222  cfapiObject_get_property(&type, ob, CFAPI_OBJECT_PROP_NAME_PLURAL, &value);
1223  assert(type == CFAPI_SSTRING);
1224  return value;
1225 }
1226 
1227 sstring cf_object_get_msg(object *ob) {
1228  int type;
1229  sstring value;
1230 
1231  cfapiObject_get_property(&type, ob, CFAPI_OBJECT_PROP_MESSAGE, &value);
1232  assert(type == CFAPI_SSTRING);
1233  return value;
1234 }
1235 
1236 void cf_object_set_weight(object *ob, int weight) {
1237  int type;
1238 
1239  cfapiObject_set_property(&type, ob, CFAPI_OBJECT_PROP_WEIGHT, weight);
1240  assert(type == CFAPI_INT);
1241 }
1242 
1243 void cf_object_set_weight_limit(object *ob, int weight_limit) {
1244  int type;
1245 
1246  cfapiObject_set_property(&type, ob, CFAPI_OBJECT_PROP_WEIGHT_LIMIT, weight_limit);
1247  assert(type == CFAPI_INT);
1248 }
1249 
1250 int cf_object_get_weight(object *ob) {
1251  int type, weight;
1252 
1253  cfapiObject_get_property(&type, ob, CFAPI_OBJECT_PROP_WEIGHT, &weight);
1254  assert(type == CFAPI_INT);
1255  return weight;
1256 }
1257 
1258 int cf_object_get_weight_limit(object *ob) {
1259  int type, limit;
1260 
1261  cfapiObject_get_property(&type, ob, CFAPI_OBJECT_PROP_WEIGHT_LIMIT, &limit);
1262  assert(type == CFAPI_INT);
1263  return limit;
1264 }
1265 
1269 int cf_object_set_nrof(object *ob, int nrof) {
1270  int type;
1271 
1272  if (nrof < 0)
1273  return -1;
1274 
1275  cfapiObject_set_property(&type, ob, CFAPI_OBJECT_PROP_NROF, nrof);
1276  return 0;
1277 }
1278 
1279 int cf_object_get_nrof(object *ob) {
1280  int type, nrof;
1281 
1282  cfapiObject_get_property(&type, ob, CFAPI_OBJECT_PROP_NROF, &nrof);
1283  return nrof;
1284 }
1285 
1286 int cf_object_get_flag(object *ob, int flag) {
1287  int type;
1288  int rv;
1289 
1290  cfapiObject_get_property(&type, ob, CFAPI_OBJECT_PROP_FLAGS, flag, &rv);
1291  if (rv != 0)
1292  return 1;
1293  else
1294  return 0;
1295 }
1296 
1297 void cf_object_set_flag(object *ob, int flag, int value) {
1298  int type;
1299 
1300  cfapiObject_set_property(&type, ob, CFAPI_OBJECT_PROP_FLAGS, flag, value ? 1 : 0);
1301 }
1302 
1307 object *cf_object_insert_in_ob(object *op, object *where) {
1308  int type;
1309  object *value;
1310 
1311  if (!cf_object_get_flag(op, FLAG_REMOVED)) {
1312  cfapiObject_remove(&type, op);
1313  }
1314 
1315  cfapiObject_insert(&type, op, 3, where, &value);
1316  assert(type == CFAPI_POBJECT);
1317  return value;
1318 }
1319 
1324 object *cf_map_insert_object_there(object *op, mapstruct *m, object *originator, int flag) {
1325  int type;
1326  object *value;
1327 
1328  cfapiObject_insert(&type, op, 1, m, originator, flag, &value);
1329  assert(type == CFAPI_POBJECT);
1330  return value;
1331 }
1332 
1338 object *cf_map_insert_object(mapstruct *where, object *op, int x, int y) {
1339  int type;
1340  object *value;
1341 
1342  cfapiObject_insert(&type, op, 0, where, NULL, 0 , x, y, &value);
1343  assert(type == CFAPI_POBJECT);
1344  return value;
1345 }
1346 
1360 object *cf_map_insert_object_around(mapstruct *where, object *op, int x, int y) {
1361  int type;
1362  object *value;
1363 
1364  cfapiObject_insert(&type, op, 2, where, NULL, 0 , x, y, &value);
1365  assert(type == CFAPI_POBJECT);
1366  return value;
1367 }
1368 
1369 int cf_object_teleport(object *op, mapstruct *map, int x, int y) {
1370  int type, value;
1371 
1372  cfapiObject_teleport(&type, op, map, x, y, &value);
1373  assert(type == CFAPI_INT);
1374  return value;
1375 }
1376 
1380 object *cf_map_find_by_archetype_name(const char *str, mapstruct *map, int nx, int ny) {
1381  int type;
1382  object *value;
1383 
1384  cfapiMap_find_by_archetype_name(&type, str, map, nx, ny, &value);
1385  assert(type == CFAPI_POBJECT);
1386  return value;
1387 }
1388 
1389 int cf_map_get_difficulty(mapstruct *map) {
1390  return cf_map_get_int_property(map, CFAPI_MAP_PROP_DIFFICULTY);
1391 }
1392 
1393 int cf_map_get_reset_time(mapstruct *map) {
1394  return cf_map_get_int_property(map, CFAPI_MAP_PROP_RESET_TIME);
1395 }
1396 
1397 int cf_map_get_reset_timeout(mapstruct *map) {
1398  return cf_map_get_int_property(map, CFAPI_MAP_PROP_RESET_TIMEOUT);
1399 }
1400 
1401 int cf_map_get_players(mapstruct *map) {
1402  return cf_map_get_int_property(map, CFAPI_MAP_PROP_PLAYERS);
1403 }
1404 
1405 int cf_map_get_darkness(mapstruct *map) {
1406  return cf_map_get_int_property(map, CFAPI_MAP_PROP_DARKNESS);
1407 }
1408 
1409 int cf_map_get_width(mapstruct *map) {
1410  return cf_map_get_int_property(map, CFAPI_MAP_PROP_WIDTH);
1411 }
1412 
1413 int cf_map_get_height(mapstruct *map) {
1414  return cf_map_get_int_property(map, CFAPI_MAP_PROP_HEIGHT);
1415 }
1416 
1417 int cf_map_get_enter_x(mapstruct *map) {
1418  return cf_map_get_int_property(map, CFAPI_MAP_PROP_ENTER_X);
1419 }
1420 
1421 int cf_map_get_enter_y(mapstruct *map) {
1422  return cf_map_get_int_property(map, CFAPI_MAP_PROP_ENTER_Y);
1423 }
1424 
1429 int cf_map_change_light(mapstruct *m, int change) {
1430  int type, value;
1431 
1432  cfapiMap_change_light(&type, m, change, &value);
1433  assert(type == CFAPI_INT);
1434  return value;
1435 }
1436 
1437 void cf_object_update(object *op, int flags) {
1438  int type;
1439 
1440  cfapiObject_update(&type, op, flags);
1441 }
1442 
1443 int cf_object_pickup(object *op, object *what) {
1444  int type, value;
1445  cfapiObject_pickup(&type, op, what, &value);
1446  assert(type == CFAPI_INT);
1447  return value;
1448 }
1449 
1455 char *cf_strdup_local(const char *str) {
1456  int type;
1457  char *dup;
1458 
1459  if (str == NULL)
1460  return NULL;
1461  cfapiSystem_strdup_local(&type, str, &dup);
1462  assert(type == CFAPI_STRING);
1463  return dup;
1464 }
1465 
1470 int cf_map_get_flags(mapstruct *oldmap, mapstruct **newmap, int16_t x, int16_t y, int16_t *nx, int16_t *ny) {
1471  int type, value;
1472 
1473  cfapiMap_get_property(&type, oldmap, CFAPI_MAP_PROP_FLAGS, newmap, x, y, nx, ny, &value);
1474  assert(type == CFAPI_INT);
1475  return value;
1476 }
1477 
1482 int cf_random_map_set_variable(RMParms *rp, const char *buf) {
1483  int type, ret;
1484 
1485  cfapiSet_random_map_variable(&type, rp, buf, &ret);
1486  assert(type == CFAPI_INT);
1487  return ret;
1488 }
1489 
1494 mapstruct *cf_random_map_generate(const char *OutFileName, RMParms *RP, char **use_layout, sstring reset_group) {
1495  int type;
1496  mapstruct *map;
1497 
1498  cfapiGenerate_random_map(&type, OutFileName, RP, use_layout, reset_group, &map);
1499  assert(type == CFAPI_PMAP);
1500  return map;
1501 }
1502 
1507 int cf_find_animation(const char *name) {
1508  int type, anim;
1509 
1510  cfapiSystem_find_animation(&type, name, &anim);
1511  assert(type == CFAPI_INT);
1512  return anim;
1513 }
1514 
1519 int cf_find_face(const char *name, int error) {
1520  int type, anim;
1521 
1522  cfapiSystem_find_face(&type, name, error, &anim);
1523  assert(type == CFAPI_INT);
1524  return anim;
1525 }
1526 
1531 void cf_log(LogLevel logLevel, const char *format, ...) {
1532  int type;
1533  /* Copied from common/logger.c */
1534  char buf[20480]; /* This needs to be really really big - larger than any other buffer, since that buffer may
1535  need to be put in this one. */
1536  va_list ap;
1537 
1538  va_start(ap, format);
1539  buf[0] = '\0';
1540  vsprintf(buf, format, ap);
1541  va_end(ap);
1542 
1543  cfapiSystem_log(&type, (int)logLevel, buf);
1544  assert(type == CFAPI_NONE);
1545 }
1546 
1551 void cf_log_plain(LogLevel logLevel, const char *message) {
1552  int type;
1553 
1554  cfapiSystem_log(&type, logLevel, message);
1555  assert(type == CFAPI_NONE);
1556 }
1557 
1558 void cf_get_time(timeofday_t *tod) {
1559  int type;
1560 
1561  cfapiSystem_get_time(&type, tod);
1562  assert(type == CFAPI_NONE);
1563 }
1564 
1565 const char *cf_get_season_name(int index) {
1566  int type;
1567  char *result;
1568 
1569  cfapiSystem_get_season_name(&type, index, &result);
1570  assert(type == CFAPI_STRING);
1571  return result;
1572 }
1573 
1574 const char *cf_get_month_name(int index) {
1575  int type;
1576  char *result;
1577 
1578  cfapiSystem_get_month_name(&type, index, &result);
1579  assert(type == CFAPI_STRING);
1580  return result;
1581 }
1582 
1583 const char *cf_get_weekday_name(int index) {
1584  int type;
1585  char *result;
1586 
1587  cfapiSystem_get_weekday_name(&type, index, &result);
1588  assert(type == CFAPI_STRING);
1589  return result;
1590 }
1591 
1592 const char *cf_get_periodofday_name(int index) {
1593  int type;
1594  char *result;
1595 
1596  cfapiSystem_get_periodofday_name(&type, index, &result);
1597  assert(type == CFAPI_STRING);
1598  return result;
1599 }
1600 
1613 int cf_timer_create(object *ob, long delay, int mode) {
1614  int type, timer;
1615 
1616  cfapiSystem_timer_create(&type, ob, delay, mode, &timer);
1617  assert(type == CFAPI_INT);
1618  return timer;
1619 }
1620 
1629 int cf_timer_destroy(int id) {
1630  int type, code;
1631 
1632  cfapiSystem_timer_destroy(&type, id, &code);
1633  assert(type == CFAPI_INT);
1634  return code;
1635 }
1636 
1646 const char *cf_object_get_key(object *op, const char *keyname) {
1647  int type;
1648  const char *value;
1649 
1650  cfapiObject_get_key(&type, op, keyname, &value);
1651  assert(type == CFAPI_SSTRING);
1652  return value;
1653 }
1654 
1668 int cf_object_set_key(object *op, const char *keyname, const char *value, int add_key) {
1669  int type, ret;
1670 
1671  cfapiObject_set_key(&type, op, keyname, value, add_key, &ret);
1672  assert(type == CFAPI_INT);
1673  return ret;
1674 }
1675 
1680 int cf_object_change_abil(object *op, object *tmp) {
1681  int type, ret;
1682 
1683  cfapiObject_change_abil(&type, op, tmp, &ret);
1684  assert(type == CFAPI_INT);
1685  return ret;
1686 }
1687 
1688 /* Archetype-related functions */
1689 
1695 archetype *cf_archetype_get_first(void) {
1696  int type;
1697  archetype *value;
1698 
1699  cfapiArchetype_get_property(&type, NULL, CFAPI_ARCH_PROP_NEXT, &value);
1700  assert(type == CFAPI_PARCH);
1701  return value;
1702 }
1703 
1711 sstring cf_archetype_get_name(archetype *arch) {
1712  int type;
1713  sstring name;
1714 
1715  cfapiArchetype_get_property(&type, arch, CFAPI_ARCH_PROP_NAME, &name);
1716  assert(type == CFAPI_SSTRING);
1717  return name;
1718 }
1719 
1728 archetype *cf_archetype_get_next(archetype *arch) {
1729  int type;
1730  archetype *value;
1731 
1732  cfapiArchetype_get_property(&type, arch, CFAPI_ARCH_PROP_NEXT, &value);
1733  assert(type == CFAPI_PARCH);
1734  return value;
1735 }
1736 
1744 archetype *cf_archetype_get_more(archetype *arch) {
1745  int type;
1746  archetype *value;
1747 
1748  cfapiArchetype_get_property(&type, arch, CFAPI_ARCH_PROP_MORE, &value);
1749  assert(type == CFAPI_PARCH);
1750  return value;
1751 }
1752 
1760 archetype *cf_archetype_get_head(archetype *arch) {
1761  int type;
1762  archetype *value;
1763 
1764  cfapiArchetype_get_property(&type, arch, CFAPI_ARCH_PROP_HEAD, &value);
1765  assert(type == CFAPI_PARCH);
1766  return value;
1767 }
1768 
1776 object *cf_archetype_get_clone(archetype *arch) {
1777  int type;
1778  object *value;
1779 
1780  cfapiArchetype_get_property(&type, arch, CFAPI_ARCH_PROP_CLONE, &value);
1781  assert(type == CFAPI_POBJECT);
1782  return value;
1783 }
1784 
1785 /* Party-related functions */
1786 
1792 partylist *cf_party_get_first(void) {
1793  int type;
1794  partylist *value;
1795 
1796  cfapiParty_get_property(&type, NULL, CFAPI_PARTY_PROP_NEXT, &value);
1797  assert(type == CFAPI_PPARTY);
1798  return value;
1799 }
1800 
1807 const char *cf_party_get_name(partylist *party) {
1808  int type;
1809  sstring value;
1810 
1811  cfapiParty_get_property(&type, party, CFAPI_PARTY_PROP_NAME, &value);
1812  assert(type == CFAPI_SSTRING);
1813  return value;
1814 }
1815 
1823 partylist *cf_party_get_next(partylist *party) {
1824  int type;
1825  partylist *value;
1826 
1827  cfapiParty_get_property(&type, party, CFAPI_PARTY_PROP_NEXT, &value);
1828  assert(type == CFAPI_PPARTY);
1829  return value;
1830 }
1831 
1839 const char *cf_party_get_password(partylist *party) {
1840  int type;
1841  sstring value;
1842 
1843  cfapiParty_get_property(&type, party, CFAPI_PARTY_PROP_PASSWORD, &value);
1844  assert(type == CFAPI_SSTRING);
1845  return value;
1846 }
1847 
1855 player *cf_party_get_first_player(partylist *party) {
1856  int type;
1857  player *value;
1858 
1859  cfapiParty_get_property(&type, party, CFAPI_PARTY_PROP_PLAYER, NULL, &value);
1860  assert(type == CFAPI_PPLAYER);
1861  return value;
1862 }
1863 
1873 player *cf_party_get_next_player(partylist *party, player *op) {
1874  int type;
1875  player *value;
1876 
1877  cfapiParty_get_property(&type, party, CFAPI_PARTY_PROP_PLAYER, op, &value);
1878  assert(type == CFAPI_PPLAYER);
1879  return value;
1880 }
1881 
1887 region *cf_region_get_first(void) {
1888  int type;
1889  region *value;
1890 
1891  cfapiRegion_get_property(&type, NULL, CFAPI_REGION_PROP_NEXT, &value);
1892  assert(type == CFAPI_PREGION);
1893  return value;
1894 }
1895 
1903 const char *cf_region_get_name(region *reg) {
1904  int type;
1905  sstring value;
1906 
1907  cfapiRegion_get_property(&type, reg, CFAPI_REGION_PROP_NAME, &value);
1908  assert(type == CFAPI_SSTRING);
1909  return value;
1910 }
1911 
1919 region *cf_region_get_next(region *reg) {
1920  int type;
1921  region *value;
1922 
1923  cfapiRegion_get_property(&type, reg, CFAPI_REGION_PROP_NEXT, &value);
1924  assert(type == CFAPI_PREGION);
1925  return value;
1926 }
1927 
1935 region *cf_region_get_parent(region *reg) {
1936  int type;
1937  region *value;
1938 
1939  cfapiRegion_get_property(&type, reg, CFAPI_REGION_PROP_PARENT, &value);
1940  assert(type == CFAPI_PREGION);
1941  return value;
1942 }
1943 
1951 const char *cf_region_get_longname(region *reg) {
1952  int type;
1953  sstring value;
1954 
1955  cfapiRegion_get_property(&type, reg, CFAPI_REGION_PROP_LONGNAME, &value);
1956  assert(type == CFAPI_SSTRING);
1957  return value;
1958 }
1959 
1967 const char *cf_region_get_message(region *reg) {
1968  int type;
1969  sstring value;
1970 
1971  cfapiRegion_get_property(&type, reg, CFAPI_REGION_PROP_MESSAGE, &value);
1972  assert(type == CFAPI_SSTRING);
1973  return value;
1974 }
1975 
1983 int cf_region_get_jail_x(region *reg) {
1984  int type, value;
1985 
1986  cfapiRegion_get_property(&type, reg, CFAPI_REGION_PROP_JAIL_X, &value);
1987  assert(type == CFAPI_INT);
1988  return value;
1989 }
1990 
1998 int cf_region_get_jail_y(region *reg) {
1999  int type, value;
2000 
2001  cfapiRegion_get_property(&type, reg, CFAPI_REGION_PROP_JAIL_Y, &value);
2002  assert(type == CFAPI_INT);
2003  return value;
2004 }
2005 
2013 const char *cf_region_get_jail_path(region *reg) {
2014  int type;
2015  sstring value;
2016 
2017  cfapiRegion_get_property(&type, reg, CFAPI_REGION_PROP_JAIL_PATH, &value);
2018  assert(type == CFAPI_SSTRING);
2019  return value;
2020 }
2021 
2022 /* Friendlylist functions. */
2023 
2029 object *cf_friendlylist_get_first(void) {
2030  int type;
2031  object *value;
2032 
2033  cfapiFriendlylist_get_next(&type, NULL, &value);
2034  assert(type == CFAPI_POBJECT);
2035  return value;
2036 }
2037 
2045 object *cf_friendlylist_get_next(object *ob) {
2046  int type;
2047  object *value;
2048 
2049  cfapiFriendlylist_get_next(&type, ob, &value);
2050  assert(type == CFAPI_POBJECT);
2051  return value;
2052 }
2053 
2054 /* Quest-related functions */
2055 
2060 int cf_quest_get_player_state(object *pl, sstring quest_code) {
2061  int type, ret;
2062 
2063  cfapiPlayer_quest(&type, CFAPI_PLAYER_QUEST_GET_STATE, pl, quest_code, &ret);
2064  assert(type == CFAPI_INT);
2065 
2066  return ret;
2067 }
2068 
2073 void cf_quest_start(object *pl, sstring quest_code, int state) {
2074  int type;
2075 
2076  cfapiPlayer_quest(&type, CFAPI_PLAYER_QUEST_START, pl, quest_code, state);
2077  assert(type == CFAPI_NONE);
2078 }
2079 
2084 void cf_quest_set_player_state(object *pl, sstring quest_code, int state) {
2085  int type;
2086 
2087  cfapiPlayer_quest(&type, CFAPI_PLAYER_QUEST_SET_STATE, pl, quest_code, state);
2088  assert(type == CFAPI_NONE);
2089 }
2090 
2095 int cf_quest_was_completed(object *pl, sstring quest_code) {
2096  int type, ret;
2097 
2098  cfapiPlayer_quest(&type, CFAPI_PLAYER_QUEST_WAS_COMPLETED, pl, quest_code, &ret);
2099  assert(type == CFAPI_INT);
2100 
2101  return ret;
2102 }
2103 
2104 command_registration cf_system_register_command(const char *name, command_function func, uint8_t command_type, float time) {
2105  int type;
2106  command_registration cr;
2107  cfapiSystem_register_command(&type, 1, name, func, command_type, time, &cr);
2108  assert(type == CFAPI_SINT64);
2109  return cr;
2110 }
2111 
2112 command_registration cf_system_register_command_extra(const char *name, const char *extra, command_function_extra func, uint8_t command_type, float time) {
2113  int type;
2114  command_registration cr;
2115  cfapiSystem_register_command(&type, 2, name, extra, func, command_type, time, &cr);
2116  assert(type == CFAPI_SINT64);
2117  return cr;
2118 }
2119 
2120 void cf_system_unregister_command(command_registration command) {
2121  int type;
2122  cfapiSystem_unregister_command(&type, command);
2123 }
2124 
2125 void cf_system_get_object_vector(int property, std::vector<object *> *list) {
2126  int type;
2127  cfapiSystem_get_object_vector(&type, property, list);
2128  assert(type == CFAPI_OBJECT_VECTOR);
2129 }
2130 
2131 void cf_system_get_map_vector(int property, std::vector<mapstruct *> *list) {
2132  int type;
2133  cfapiSystem_get_map_vector(&type, property, list);
2134  assert(type == CFAPI_MAP_VECTOR);
2135 }
2136 
2137 void cf_system_get_archetype_vector(int property, std::vector<archetype *> *list) {
2138  int type;
2139  cfapiSystem_get_archetype_vector(&type, property, list);
2140  assert(type == CFAPI_ARCHETYPE_VECTOR);
2141 }
2142 
2143 void cf_system_get_party_vector(int property, std::vector<partylist *> *list) {
2144  int type;
2145  cfapiSystem_get_party_vector(&type, property, list);
2146  assert(type == CFAPI_PARTY_VECTOR);
2147 }
2148 
2149 void cf_system_get_region_vector(int property, std::vector<region *> *list) {
2150  int type;
2151  cfapiSystem_get_region_vector(&type, property, list);
2152  assert(type == CFAPI_REGION_VECTOR);
2153 }
cf_archetype_get_first
archetype * cf_archetype_get_first(void)
Get first archetype.
Definition: plugin_common.cpp:1695
cfapiSystem_strdup_local
static f_plug_api cfapiSystem_strdup_local
Definition: plugin_common.cpp:47
cf_log_plain
void cf_log_plain(LogLevel logLevel, const char *message)
Wrapper for LOG() that uses directly a buffer, without format.
Definition: plugin_common.cpp:1551
cf_player_knowledge_has
int cf_player_knowledge_has(object *op, const char *knowledge)
Wrapper for knowledge_player_has().
Definition: plugin_common.cpp:909
cfapiSystem_get_object_vector
static f_plug_api cfapiSystem_get_object_vector
Definition: plugin_common.cpp:132
cf_object_set_long_property
void cf_object_set_long_property(object *op, int propcode, long value)
Definition: plugin_common.cpp:390
cfapiSystem_find_string
static f_plug_api cfapiSystem_find_string
Definition: plugin_common.cpp:43
CFAPI_SSTRING
#define CFAPI_SSTRING
Definition: plugin.h:70
cf_system_register_command_extra
command_registration cf_system_register_command_extra(const char *name, const char *extra, command_function_extra func, uint8_t command_type, float time)
Definition: plugin_common.cpp:2112
cfapiSystem_get_party_vector
static f_plug_api cfapiSystem_get_party_vector
Definition: plugin_common.cpp:136
cf_party_get_first_player
player * cf_party_get_first_player(partylist *party)
Get first player in party.
Definition: plugin_common.cpp:1855
CFAPI_PPLAYER
#define CFAPI_PPLAYER
Definition: plugin.h:64
cfapiObject_pay_item
static f_plug_api cfapiObject_pay_item
Definition: plugin_common.cpp:85
CFAPI_POBJECT
#define CFAPI_POBJECT
Definition: plugin.h:58
cf_object_set_flag
void cf_object_set_flag(object *ob, int flag, int value)
Definition: plugin_common.cpp:1297
CFAPI_PARTY_VECTOR
#define CFAPI_PARTY_VECTOR
Pointer to a std::vector<partylist *>
Definition: plugin.h:76
cf_get_maps_directory
char * cf_get_maps_directory(const char *name, char *buf, int size)
Wrapper for create_pathname().
Definition: plugin_common.cpp:1078
CFAPI_OBJECT_VECTOR
#define CFAPI_OBJECT_VECTOR
Pointer to a std::vector<object *>
Definition: plugin.h:72
cfapiObject_clear
static f_plug_api cfapiObject_clear
Definition: plugin_common.cpp:75
cfapiObject_find_by_arch_name
static f_plug_api cfapiObject_find_by_arch_name
Definition: plugin_common.cpp:88
cf_object_change_abil
int cf_object_change_abil(object *op, object *tmp)
Wrapper for change_abil().
Definition: plugin_common.cpp:1680
cf_system_get_archetype_vector
void cf_system_get_archetype_vector(int property, std::vector< archetype * > *list)
Definition: plugin_common.cpp:2137
cf_get_directory
const char * cf_get_directory(int id)
Gets a directory Crossfire uses.
Definition: plugin_common.cpp:1139
cf_get_periodofday_name
const char * cf_get_periodofday_name(int index)
Definition: plugin_common.cpp:1592
cf_map_message
void cf_map_message(mapstruct *m, const char *msg, int color)
Partial wrapper for ext_info_map().
Definition: plugin_common.cpp:667
CFAPI_PARTY_PROP_NAME
#define CFAPI_PARTY_PROP_NAME
Definition: plugin.h:272
cf_player_find
player * cf_player_find(const char *plname)
Wrapper for find_player_partial_name().
Definition: plugin_common.cpp:825
cfapiSystem_find_animation
static f_plug_api cfapiSystem_find_animation
Definition: plugin_common.cpp:48
cf_player_set_marked_item
void cf_player_set_marked_item(object *op, object *ob)
Definition: plugin_common.cpp:875
CFAPI_MAP_PROP_RESET_TIME
#define CFAPI_MAP_PROP_RESET_TIME
Definition: plugin.h:252
CFAPI_MAP_PROP_RESET_TIMEOUT
#define CFAPI_MAP_PROP_RESET_TIMEOUT
Definition: plugin.h:253
CFAPI_REGION_PROP_LONGNAME
#define CFAPI_REGION_PROP_LONGNAME
Definition: plugin.h:280
cf_object_change_exp
void cf_object_change_exp(object *op, int64_t exp, const char *skill_name, int flag)
Wrapper for change_exp().
Definition: plugin_common.cpp:504
cf_object_update
void cf_object_update(object *op, int flags)
Definition: plugin_common.cpp:1437
CFAPI_NONE
#define CFAPI_NONE
Definition: plugin.h:53
player
One player.
Definition: player.h:107
cf_object_move
int cf_object_move(object *op, int dir, object *originator)
Definition: plugin_common.cpp:531
cf_log
void cf_log(LogLevel logLevel, const char *format,...)
Wrapper for LOG().
Definition: plugin_common.cpp:1531
cf_archetype_get_clone
object * cf_archetype_get_clone(archetype *arch)
Get clone of archetype.
Definition: plugin_common.cpp:1776
cf_object_check_trigger
int cf_object_check_trigger(object *op, object *cause)
Wrapper for check_trigger().
Definition: plugin_common.cpp:1025
cfapiMap_set_property
static f_plug_api cfapiMap_set_property
Definition: plugin_common.cpp:95
cfapiObject_remove_depletion
static f_plug_api cfapiObject_remove_depletion
Definition: plugin_common.cpp:127
CFAPI_REGION_PROP_NEXT
#define CFAPI_REGION_PROP_NEXT
Definition: plugin.h:278
cfapiSystem_unregister_command
static f_plug_api cfapiSystem_unregister_command
Definition: plugin_common.cpp:131
cf_party_get_next_player
player * cf_party_get_next_player(partylist *party, player *op)
Get next player in party.
Definition: plugin_common.cpp:1873
command
same as sound ncom command like but with extra the client want tick commands so it knows animation timing the client wants to be informed of pickup mode changes Mode will be sent when the player successfully logs and afterward any time the value is but over many options have become defaults This documents those now obsolete client can handle the bit exp values that are now used values are sent as bit Setting this flag also means that skill exp will be and it will be sent in revised method as described in the stats command Value is an integer in string format else Deprecated client should presume all servers support this server will return FALSE Deprecated replaced with sound2 setup command
Definition: protocol.txt:461
cfapiObject_get_key
static f_plug_api cfapiObject_get_key
Definition: plugin_common.cpp:108
CFAPI_MAP_PROP_NEXT
#define CFAPI_MAP_PROP_NEXT
Definition: plugin.h:262
cfapiMap_get_object_at
static f_plug_api cfapiMap_get_object_at
Definition: plugin_common.cpp:98
cfapiObject_apply
static f_plug_api cfapiObject_apply
Definition: plugin_common.cpp:59
cfapiObject_set_property
static f_plug_api cfapiObject_set_property
Definition: plugin_common.cpp:58
cfapiSystem_find_face
static f_plug_api cfapiSystem_find_face
Definition: plugin_common.cpp:49
cf_map_get_enter_x
int cf_map_get_enter_x(mapstruct *map)
Definition: plugin_common.cpp:1417
cf_player_knowledge_give
void cf_player_knowledge_give(object *op, const char *knowledge)
Wrapper for knowledge_give();.
Definition: plugin_common.cpp:922
cf_object_get_int_property
int cf_object_get_int_property(object *op, int propcode)
Definition: plugin_common.cpp:335
cf_region_get_message
const char * cf_region_get_message(region *reg)
Get message of region.
Definition: plugin_common.cpp:1967
cf_object_get_partylist_property
partylist * cf_object_get_partylist_property(object *op, int propcode)
Definition: plugin_common.cpp:424
cf_fix_object
void cf_fix_object(object *op)
Wrapper for fix_object().
Definition: plugin_common.cpp:1165
cfapiRegion_get_property
static f_plug_api cfapiRegion_get_property
Definition: plugin_common.cpp:114
cf_map_insert_object_there
object * cf_map_insert_object_there(object *op, mapstruct *m, object *originator, int flag)
Wrapper for object_insert_in_map().
Definition: plugin_common.cpp:1324
cf_object_get_key
const char * cf_object_get_key(object *op, const char *keyname)
Gets value for specified key, equivalent of object_get_value().
Definition: plugin_common.cpp:1646
cf_object_get_msg
sstring cf_object_get_msg(object *ob)
Definition: plugin_common.cpp:1227
cf_map_insert_object_around
object * cf_map_insert_object_around(mapstruct *where, object *op, int x, int y)
Will insert op in the map where around the spot x, y.
Definition: plugin_common.cpp:1360
cf_object_set_weight_limit
void cf_object_set_weight_limit(object *ob, int weight_limit)
Definition: plugin_common.cpp:1243
cf_object_insert_in_ob
object * cf_object_insert_in_ob(object *op, object *where)
Wrapper for object_insert_in_ob().
Definition: plugin_common.cpp:1307
cfapiMap_create_path
static f_plug_api cfapiMap_create_path
Definition: plugin_common.cpp:100
object::map
struct mapstruct * map
Pointer to the map in which this object is present.
Definition: object.h:305
cf_region_get_first
region * cf_region_get_first(void)
Get first region in region list.
Definition: plugin_common.cpp:1887
MoveType
unsigned char MoveType
Typdef here to define type large enough to hold bitmask of all movement types.
Definition: define.h:409
timeofday_t
Represents the ingame time.
Definition: tod.h:38
cf_region_get_parent
region * cf_region_get_parent(region *reg)
Get parent of region.
Definition: plugin_common.cpp:1935
cfapiPlayer_knowledge
static f_plug_api cfapiPlayer_knowledge
Definition: plugin_common.cpp:128
cfapiObject_move
static f_plug_api cfapiObject_move
Definition: plugin_common.cpp:110
cf_system_unregister_command
void cf_system_unregister_command(command_registration command)
Definition: plugin_common.cpp:2120
cf_object_set_object_property
void cf_object_set_object_property(object *op, int propcode, object *value)
Definition: plugin_common.cpp:493
cfapiObject_set_key
static f_plug_api cfapiObject_set_key
Definition: plugin_common.cpp:109
CFAPI_PLAYER_PROP_MARKED_ITEM
#define CFAPI_PLAYER_PROP_MARKED_ITEM
Definition: plugin.h:231
time
non standard information is not specified or uptime this means how long since the executable has been started A particular host may have been running a server for quite a long time
Definition: arch-handbook.txt:206
cf_object_split
object * cf_object_split(object *orig_ob, uint32_t nr, char *err, size_t size)
Wrapper for object_split().
Definition: plugin_common.cpp:697
cf_object_get_sstring_property
sstring cf_object_get_sstring_property(object *op, int propcode)
Definition: plugin_common.cpp:440
CFAPI_ARCH_PROP_NEXT
#define CFAPI_ARCH_PROP_NEXT
Definition: plugin.h:267
cfapiObject_pay_amount
static f_plug_api cfapiObject_pay_amount
Definition: plugin_common.cpp:84
cf_region_get_next
region * cf_region_get_next(region *reg)
Get next region in region list.
Definition: plugin_common.cpp:1919
flags
static const flag_definition flags[]
Flag mapping.
Definition: gridarta-types-convert.cpp:101
cf_get_weekday_name
const char * cf_get_weekday_name(int index)
Definition: plugin_common.cpp:1583
cf_object_pay_item
int cf_object_pay_item(object *op, object *pl)
Wrapper for pay_for_item().
Definition: plugin_common.cpp:720
cf_object_perm_exp
int64_t cf_object_perm_exp(object *op)
Wrapper for PERM_EXP macro.
Definition: plugin_common.cpp:515
cf_object_get_double_property
double cf_object_get_double_property(object *op, int propcode)
Definition: plugin_common.cpp:432
cf_object_learn_spell
void cf_object_learn_spell(object *op, object *spell, int special_prayer)
Wrapper for do_learn_spell().
Definition: plugin_common.cpp:756
CFAPI_OBJECT_PROP_FACE
#define CFAPI_OBJECT_PROP_FACE
Definition: plugin.h:217
CFAPI_REGION_PROP_PARENT
#define CFAPI_REGION_PROP_PARENT
Definition: plugin.h:279
cfapiPlayer_find
static f_plug_api cfapiPlayer_find
Definition: plugin_common.cpp:104
cfapiObject_insert
static f_plug_api cfapiObject_insert
Definition: plugin_common.cpp:70
CFAPI_PPARTY
#define CFAPI_PPARTY
Definition: plugin.h:65
cf_party_get_password
const char * cf_party_get_password(partylist *party)
Get party's password.
Definition: plugin_common.cpp:1839
cfapiObject_fix
static f_plug_api cfapiObject_fix
Definition: plugin_common.cpp:63
cf_cost_string_from_value
void cf_cost_string_from_value(uint64_t cost, int largest_coin, char *buffer, int length)
Wrapper for cost_string_from_value modified to take a char* and length instead of a StringBuffer.
Definition: plugin_common.cpp:1003
CFAPI_REGION_PROP_JAIL_PATH
#define CFAPI_REGION_PROP_JAIL_PATH
Definition: plugin.h:284
CFAPI_MAP_PROP_WIDTH
#define CFAPI_MAP_PROP_WIDTH
Definition: plugin.h:257
cf_map_get_players
int cf_map_get_players(mapstruct *map)
Definition: plugin_common.cpp:1401
CFAPI_ARCH_PROP_NAME
#define CFAPI_ARCH_PROP_NAME
Definition: plugin.h:266
cf_map_insert_object
object * cf_map_insert_object(mapstruct *where, object *op, int x, int y)
Wrapper for object_insert_in_map_at().
Definition: plugin_common.cpp:1338
cf_map_set_string_property
void cf_map_set_string_property(mapstruct *map, int propcode, const char *value)
Definition: plugin_common.cpp:305
partylist
One party.
Definition: party.h:10
cf_party_get_next
partylist * cf_party_get_next(partylist *party)
Get next party in party list.
Definition: plugin_common.cpp:1823
CFAPI_FLOAT
#define CFAPI_FLOAT
Definition: plugin.h:60
cf_object_set_movetype_property
void cf_object_set_movetype_property(object *op, int propcode, MoveType value)
Definition: plugin_common.cpp:350
cfapiSystem_get_region_vector
static f_plug_api cfapiSystem_get_region_vector
Definition: plugin_common.cpp:135
cf_system_register_command
command_registration cf_system_register_command(const char *name, command_function func, uint8_t command_type, float time)
Definition: plugin_common.cpp:2104
buf
StringBuffer * buf
Definition: readable.cpp:1565
cfapiSystem_remove_string
static f_plug_api cfapiSystem_remove_string
Definition: plugin_common.cpp:45
cfapiObject_apply_below
static f_plug_api cfapiObject_apply_below
Definition: plugin_common.cpp:111
RMParms
Random map parameters.
Definition: random_map.h:14
cfapiSystem_get_time
static f_plug_api cfapiSystem_get_time
Definition: plugin_common.cpp:51
CFAPI_MAP_PROP_ENTER_X
#define CFAPI_MAP_PROP_ENTER_X
Definition: plugin.h:259
cf_object_get_weight
int cf_object_get_weight(object *ob)
Definition: plugin_common.cpp:1250
name
Plugin animator file specs[Config] name
Definition: animfiles.txt:4
FLAG_REMOVED
#define FLAG_REMOVED
Object is not in any map or invenory.
Definition: define.h:219
cfapiSystem_get_weekday_name
static f_plug_api cfapiSystem_get_weekday_name
Definition: plugin_common.cpp:122
cfapiObject_describe
static f_plug_api cfapiObject_describe
Definition: plugin_common.cpp:61
cf_map_get_reset_time
int cf_map_get_reset_time(mapstruct *map)
Definition: plugin_common.cpp:1393
cfapiParty_get_property
static f_plug_api cfapiParty_get_property
Definition: plugin_common.cpp:113
m
static event_registration m
Definition: citylife.cpp:424
cf_player_arrest
int cf_player_arrest(object *who)
Wrapper for player_arrest().
Definition: plugin_common.cpp:933
cfapiObject_distance
static f_plug_api cfapiObject_distance
Definition: plugin_common.cpp:73
cfapiObject_out_of_map
static f_plug_api cfapiObject_out_of_map
Definition: plugin_common.cpp:90
cf_player_get_marked_item
object * cf_player_get_marked_item(object *op)
Definition: plugin_common.cpp:866
cf_timer_destroy
int cf_timer_destroy(int id)
Destroys specified timer, equivalent of calling cftimer_destroy().
Definition: plugin_common.cpp:1629
cf_friendlylist_get_first
object * cf_friendlylist_get_first(void)
Get first object on friendly list.
Definition: plugin_common.cpp:2029
CFAPI_ARCH_PROP_HEAD
#define CFAPI_ARCH_PROP_HEAD
Definition: plugin.h:268
cfapiSystem_re_cmp
static f_plug_api cfapiSystem_re_cmp
Definition: plugin_common.cpp:55
cfapiObject_get_property
static f_plug_api cfapiObject_get_property
Definition: plugin_common.cpp:57
CFAPI_PLAYER_PROP_PARTY
#define CFAPI_PLAYER_PROP_PARTY
Definition: plugin.h:232
cfapiSystem_timer_create
static f_plug_api cfapiSystem_timer_create
Definition: plugin_common.cpp:52
cfapiSystem_unregister_global_event
static f_plug_api cfapiSystem_unregister_global_event
Definition: plugin_common.cpp:46
cf_object_transfer
int cf_object_transfer(object *op, int x, int y, int randomly, object *originator)
Wrapper for transfer_ob().
Definition: plugin_common.cpp:618
cf_object_forget_spell
void cf_object_forget_spell(object *op, object *sp)
Wrapper for do_forget_spell(), except takes an object, not a string.
Definition: plugin_common.cpp:768
cf_random_map_generate
mapstruct * cf_random_map_generate(const char *OutFileName, RMParms *RP, char **use_layout, sstring reset_group)
Wrapper for generate_random_map().
Definition: plugin_common.cpp:1494
cf_archetype_get_next
archetype * cf_archetype_get_next(archetype *arch)
Get next archetype in linked list.
Definition: plugin_common.cpp:1728
cf_player_message
void cf_player_message(object *op, const char *txt, int flags)
Definition: plugin_common.cpp:787
cf_quest_start
void cf_quest_start(object *pl, sstring quest_code, int state)
Wrapper for quest_start().
Definition: plugin_common.cpp:2073
cfapiObject_pickup
static f_plug_api cfapiObject_pickup
Definition: plugin_common.cpp:107
cfapiObject_check_trigger
static f_plug_api cfapiObject_check_trigger
Definition: plugin_common.cpp:78
cf_map_get_object_at
object * cf_map_get_object_at(mapstruct *m, int x, int y)
Wrapper for GET_MAP_OB().
Definition: plugin_common.cpp:655
CFAPI_REGION_PROP_JAIL_Y
#define CFAPI_REGION_PROP_JAIL_Y
Definition: plugin.h:283
cf_map_get_reset_timeout
int cf_map_get_reset_timeout(mapstruct *map)
Definition: plugin_common.cpp:1397
cfapiSystem_get_archetype_vector
static f_plug_api cfapiSystem_get_archetype_vector
Definition: plugin_common.cpp:134
f_plug_api
void(* f_plug_api)(int *type,...)
General API function.
Definition: plugin.h:79
cf_object_get_resistance
int16_t cf_object_get_resistance(object *op, int rtype)
Definition: plugin_common.cpp:313
cf_map_change_light
int cf_map_change_light(mapstruct *m, int change)
Wrapper for change_map_light().
Definition: plugin_common.cpp:1429
cf_identify
object * cf_identify(object *op)
Wrapper for identify().
Definition: plugin_common.cpp:812
cf_find_animation
int cf_find_animation(const char *name)
Wrapper for find_animation().
Definition: plugin_common.cpp:1507
cf_object_get_long_property
long cf_object_get_long_property(object *op, long propcode)
Definition: plugin_common.cpp:342
cfapiObject_give_skill
static f_plug_api cfapiObject_give_skill
Definition: plugin_common.cpp:64
CFAPI_INT
#define CFAPI_INT
Definition: plugin.h:54
CFAPI_OBJECT_PROP_WEIGHT
#define CFAPI_OBJECT_PROP_WEIGHT
Definition: plugin.h:166
cf_object_get_archetype_property
archetype * cf_object_get_archetype_property(object *op, int propcode)
Definition: plugin_common.cpp:416
CFAPI_OBJECT_PROP_RESIST
#define CFAPI_OBJECT_PROP_RESIST
Definition: plugin.h:148
CFAPI_PLAYER_PROP_IP
#define CFAPI_PLAYER_PROP_IP
Definition: plugin.h:230
cfapiSystem_log
static f_plug_api cfapiSystem_log
Definition: plugin_common.cpp:50
cf_archetype_get_head
archetype * cf_archetype_get_head(archetype *arch)
Get head of archetype.
Definition: plugin_common.cpp:1760
cfapiSystem_get_periodofday_name
static f_plug_api cfapiSystem_get_periodofday_name
Definition: plugin_common.cpp:123
cfapiSystem_timer_destroy
static f_plug_api cfapiSystem_timer_destroy
Definition: plugin_common.cpp:53
cf_init_plugin
int cf_init_plugin(f_plug_api getHooks)
Definition: plugin_common.cpp:146
cf_object_move_to
int cf_object_move_to(object *op, int x, int y)
Wrapper for move_to().
Definition: plugin_common.cpp:630
cf_object_cast_spell
int cf_object_cast_spell(object *op, object *caster, int dir, object *spell_ob, char *stringarg)
Wrapper for cast_spell().
Definition: plugin_common.cpp:744
cf_object_get_object_property
object * cf_object_get_object_property(object *op, int propcode)
Definition: plugin_common.cpp:365
cf_object_teleport
int cf_object_teleport(object *op, mapstruct *map, int x, int y)
Definition: plugin_common.cpp:1369
cf_add_string
sstring cf_add_string(const char *str)
Wrapper for add_string().
Definition: plugin_common.cpp:1176
cf_player_set_party
void cf_player_set_party(object *op, partylist *party)
Definition: plugin_common.cpp:885
message
TIPS on SURVIVING Crossfire is populated with a wealth of different monsters These monsters can have varying immunities and attack types In some of them can be quite a bit smarter than others It will be important for new players to learn the abilities of different monsters and learn just how much it will take to kill them This section discusses how monsters can interact with players Most monsters in the game are out to mindlessly kill and destroy the players These monsters will help boost a player s after he kills them When fighting a large amount of monsters in a single attempt to find a narrower hallway so that you are not being attacked from all sides Charging into a room full of Beholders for instance would not be open the door and fight them one at a time For there are several maps designed for them Find these areas and clear them out All throughout these a player can find signs and books which they can read by stepping onto them and hitting A to apply the book sign These messages will help the player to learn the system One more always keep an eye on your food If your food drops to your character will soon so BE CAREFUL ! NPCs Non Player Character are special monsters which have intelligence Players may be able to interact with these monsters to help solve puzzles and find items of interest To speak with a monster you suspect to be a simply move to an adjacent square to them and push the double ie Enter your message
Definition: survival-guide.txt:34
CFAPI_ARCH_PROP_CLONE
#define CFAPI_ARCH_PROP_CLONE
Definition: plugin.h:270
cf_random_map_set_variable
int cf_random_map_set_variable(RMParms *rp, const char *buf)
Wrapper for set_random_map_variable().
Definition: plugin_common.cpp:1482
CFAPI_OBJECT_PROP_NROF
#define CFAPI_OBJECT_PROP_NROF
Definition: plugin.h:142
cf_map_get_int_property
int cf_map_get_int_property(mapstruct *map, int property)
Definition: plugin_common.cpp:254
CFAPI_PLAYER_PROP_TITLE
#define CFAPI_PLAYER_PROP_TITLE
Definition: plugin.h:237
cf_timer_create
int cf_timer_create(object *ob, long delay, int mode)
Creates a timer, equivalent of calling cftimer_create().
Definition: plugin_common.cpp:1613
spell
with a maximum of six This is not so if you are wearing plate you receive no benefit Armour is additive with all the supplementry forms of which means that it lasts until the next semi permanent spell effect is cast upon the character spell
Definition: tome-of-magic.txt:44
cf_object_remove_depletion
int cf_object_remove_depletion(object *op, int level)
Wrapper for remove_depletion().
Definition: plugin_common.cpp:798
cfapiObject_find_by_name
static f_plug_api cfapiObject_find_by_name
Definition: plugin_common.cpp:89
title
Information on one title.
Definition: readable.cpp:108
cfapiCost_string_from_value
static f_plug_api cfapiCost_string_from_value
Definition: plugin_common.cpp:125
cf_player_get_title
char * cf_player_get_title(object *op, char *title, int size)
Definition: plugin_common.cpp:834
CFAPI_PREGION
#define CFAPI_PREGION
Definition: plugin.h:66
cf_get_season_name
const char * cf_get_season_name(int index)
Definition: plugin_common.cpp:1565
cf_object_out_of_map
int cf_object_out_of_map(object *op, int x, int y)
Definition: plugin_common.cpp:1044
CFAPI_REGION_VECTOR
#define CFAPI_REGION_VECTOR
Pointer to a std::vector<region *>
Definition: plugin.h:75
cfapiObject_drop
static f_plug_api cfapiObject_drop
Definition: plugin_common.cpp:91
cf_object_set_resistance
void cf_object_set_resistance(object *op, int rtype, int16_t value)
Definition: plugin_common.cpp:321
cf_object_get_string_property
char * cf_object_get_string_property(object *op, int propcode, char *buf, int size)
Definition: plugin_common.cpp:448
cf_quest_was_completed
int cf_quest_was_completed(object *pl, sstring quest_code)
Wrapper for quest_was_completed().
Definition: plugin_common.cpp:2095
cfapiObject_user_event
static f_plug_api cfapiObject_user_event
Definition: plugin_common.cpp:124
cfapiObject_find_archetype_inside
static f_plug_api cfapiObject_find_archetype_inside
Definition: plugin_common.cpp:87
cfapiSystem_directory
static f_plug_api cfapiSystem_directory
Definition: plugin_common.cpp:54
CFAPI_PLAYER_QUEST_START
#define CFAPI_PLAYER_QUEST_START
Definition: plugin.h:242
CFAPI_REGION_PROP_NAME
#define CFAPI_REGION_PROP_NAME
Definition: plugin.h:277
archetype
The archetype structure is a set of rules on how to generate and manipulate objects which point to ar...
Definition: object.h:483
cf_object_apply_below
void cf_object_apply_below(object *pl)
Wrapper for apply_by_living_below().
Definition: plugin_common.cpp:553
cfapiObject_transmute
static f_plug_api cfapiObject_transmute
Definition: plugin_common.cpp:65
cf_player_get_ip
sstring cf_player_get_ip(object *op)
Definition: plugin_common.cpp:848
CFAPI_REGION_PROP_JAIL_X
#define CFAPI_REGION_PROP_JAIL_X
Definition: plugin.h:282
cfapiObject_clone
static f_plug_api cfapiObject_clone
Definition: plugin_common.cpp:68
cf_region_get_longname
const char * cf_region_get_longname(region *reg)
Get longname of region.
Definition: plugin_common.cpp:1951
cfapiSystem_get_season_name
static f_plug_api cfapiSystem_get_season_name
Definition: plugin_common.cpp:121
cfapiObject_delete
static f_plug_api cfapiObject_delete
Definition: plugin_common.cpp:67
cf_object_set_weight
void cf_object_set_weight(object *ob, int weight)
Definition: plugin_common.cpp:1236
cf_object_set_face
int cf_object_set_face(object *op, const char *face)
Set the object's face.
Definition: plugin_common.cpp:474
weight
TIPS on SURVIVING Crossfire is populated with a wealth of different monsters These monsters can have varying immunities and attack types In some of them can be quite a bit smarter than others It will be important for new players to learn the abilities of different monsters and learn just how much it will take to kill them This section discusses how monsters can interact with players Most monsters in the game are out to mindlessly kill and destroy the players These monsters will help boost a player s after he kills them When fighting a large amount of monsters in a single attempt to find a narrower hallway so that you are not being attacked from all sides Charging into a room full of Beholders for instance would not be open the door and fight them one at a time For there are several maps designed for them Find these areas and clear them out All throughout these a player can find signs and books which they can read by stepping onto them and hitting A to apply the book sign These messages will help the player to learn the system One more always keep an eye on your food If your food drops to your character will soon so BE CAREFUL ! NPCs Non Player Character are special monsters which have intelligence Players may be able to interact with these monsters to help solve puzzles and find items of interest To speak with a monster you suspect to be a simply move to an adjacent square to them and push the double ie Enter your and press< Return > You can also use say if you feel like typing a little extra Other NPCs may not speak to but display intelligence with their movement Some monsters can be and may attack the nearest of your enemies Others can be in that they follow you around and help you in your quest to kill enemies and find treasure SPECIAL ITEMS There are many special items which can be found in of these the most important may be the signs all a player must do is apply the handle In the case of the player must move items over the button to hold it down Some of the larger buttons may need very large items to be moved onto before they can be activated Gates and locked but be for you could fall down into a pit full of ghosts or dragons and not be able to get back out Break away sometimes it may be worth a player s time to test the walls of a map for secret doors Fire such as missile weapons and spells you will notice them going up in smoke ! So be careful not to destroy valuable items Spellbooks sometimes a player can learn the other times they cannot There are many different types of books and scrolls out there Improve item have lower weight
Definition: survival-guide.txt:100
CFAPI_OBJECT_PROP_NAME_PLURAL
#define CFAPI_OBJECT_PROP_NAME_PLURAL
Definition: plugin.h:131
CFAPI_PARTY_PROP_NEXT
#define CFAPI_PARTY_PROP_NEXT
Definition: plugin.h:273
cf_region_get_jail_path
const char * cf_region_get_jail_path(region *reg)
Get jail path of region.
Definition: plugin_common.cpp:2013
cfapiObject_reset
static f_plug_api cfapiObject_reset
Definition: plugin_common.cpp:76
cfapiMap_get_map
static f_plug_api cfapiMap_get_map
Definition: plugin_common.cpp:96
cfapiSystem_get_month_name
static f_plug_api cfapiSystem_get_month_name
Definition: plugin_common.cpp:120
cf_map_get_enter_y
int cf_map_get_enter_y(mapstruct *map)
Definition: plugin_common.cpp:1421
cf_object_set_key
int cf_object_set_key(object *op, const char *keyname, const char *value, int add_key)
Sets a value for specified key, equivalent to object_set_value().
Definition: plugin_common.cpp:1668
cf_map_get_sstring_property
sstring cf_map_get_sstring_property(mapstruct *map, int propcode)
Definition: plugin_common.cpp:270
cf_object_apply
int cf_object_apply(object *op, object *tmp, int aflag)
Wrapper for apply_manual().
Definition: plugin_common.cpp:542
cfapiObject_merge
static f_plug_api cfapiObject_merge
Definition: plugin_common.cpp:72
cf_system_get_region_vector
void cf_system_get_region_vector(int property, std::vector< region * > *list)
Definition: plugin_common.cpp:2149
CFAPI_REGION_PROP_MESSAGE
#define CFAPI_REGION_PROP_MESSAGE
Definition: plugin.h:281
cf_object_find_by_name
object * cf_object_find_by_name(const object *who, const char *name)
Wrapper for object_find_by_name().
Definition: plugin_common.cpp:605
cfapiObject_query_money
static f_plug_api cfapiObject_query_money
Definition: plugin_common.cpp:79
cf_map_set_int_property
void cf_map_set_int_property(mapstruct *map, int propcode, int value)
Definition: plugin_common.cpp:298
CFAPI_DOUBLE
#define CFAPI_DOUBLE
Definition: plugin.h:61
cf_object_clone
object * cf_object_clone(object *op, int clonetype)
Clone an object.
Definition: plugin_common.cpp:683
cf_object_find_by_arch_name
object * cf_object_find_by_arch_name(const object *who, const char *name)
Wrapper for object_find_by_arch_name().
Definition: plugin_common.cpp:592
cf_object_set_nrof
int cf_object_set_nrof(object *ob, int nrof)
Definition: plugin_common.cpp:1269
cf_object_drop
void cf_object_drop(object *op, object *author)
Definition: plugin_common.cpp:1052
cfapiMap_has_been_loaded
static f_plug_api cfapiMap_has_been_loaded
Definition: plugin_common.cpp:101
cf_player_get_client
sstring cf_player_get_client(object *op)
Definition: plugin_common.cpp:857
cfapiMap_message
static f_plug_api cfapiMap_message
Definition: plugin_common.cpp:97
CFAPI_MAP_PROP_FLAGS
#define CFAPI_MAP_PROP_FLAGS
Definition: plugin.h:247
region
This is a game region.
Definition: map.h:277
CFAPI_MAP_PROP_DARKNESS
#define CFAPI_MAP_PROP_DARKNESS
Definition: plugin.h:256
cf_player_move
int cf_player_move(player *pl, int dir)
Definition: plugin_common.cpp:524
cfapiObject_cast
static f_plug_api cfapiObject_cast
Definition: plugin_common.cpp:80
cf_quest_get_player_state
int cf_quest_get_player_state(object *pl, sstring quest_code)
Wrapper for quest_get_player_state().
Definition: plugin_common.cpp:2060
CFAPI_MAP_PROP_PLAYERS
#define CFAPI_MAP_PROP_PLAYERS
Definition: plugin.h:254
cfapiObject_update
static f_plug_api cfapiObject_update
Definition: plugin_common.cpp:74
cf_map_get_darkness
int cf_map_get_darkness(mapstruct *map)
Definition: plugin_common.cpp:1405
cfapiFriendlylist_get_next
static f_plug_api cfapiFriendlylist_get_next
Definition: plugin_common.cpp:116
CFAPI_SINT64
#define CFAPI_SINT64
Definition: plugin.h:69
cfapiObject_say
static f_plug_api cfapiObject_say
Definition: plugin_common.cpp:93
cf_object_set_float_property
void cf_object_set_float_property(object *op, int propcode, float value)
Definition: plugin_common.cpp:396
CFAPI_PARTY_PROP_PLAYER
#define CFAPI_PARTY_PROP_PLAYER
Definition: plugin.h:275
CFAPI_PMAP
#define CFAPI_PMAP
Definition: plugin.h:59
CFAPI_PLAYER_QUEST_GET_STATE
#define CFAPI_PLAYER_QUEST_GET_STATE
Definition: plugin.h:243
CFAPI_MAP_PROP_DIFFICULTY
#define CFAPI_MAP_PROP_DIFFICULTY
Definition: plugin.h:248
cf_system_get_object_vector
void cf_system_get_object_vector(int property, std::vector< object * > *list)
Definition: plugin_common.cpp:2125
cf_object_insert_object
object * cf_object_insert_object(object *op, object *container)
Definition: plugin_common.cpp:1065
cf_object_get_int64_property
int64_t cf_object_get_int64_property(object *op, int propcode)
Definition: plugin_common.cpp:381
cf_map_get_map
mapstruct * cf_map_get_map(const char *name, int flags)
Wrapper for ready_map_name().
Definition: plugin_common.cpp:944
CFAPI_OBJECT_PROP_ANIMATION
#define CFAPI_OBJECT_PROP_ANIMATION
Definition: plugin.h:218
cf_region_get_jail_y
int cf_region_get_jail_y(region *reg)
Get region's jail y coordinate.
Definition: plugin_common.cpp:1998
cf_player_set_title
void cf_player_set_title(object *op, const char *title)
Definition: plugin_common.cpp:842
cfapiObject_create
static f_plug_api cfapiObject_create
Definition: plugin_common.cpp:69
cfapiObject_change_abil
static f_plug_api cfapiObject_change_abil
Definition: plugin_common.cpp:92
cf_object_get_weight_limit
int cf_object_get_weight_limit(object *ob)
Definition: plugin_common.cpp:1258
cfapiMap_trigger_connected
static f_plug_api cfapiMap_trigger_connected
Definition: plugin_common.cpp:103
cfapiMap_find_by_archetype_name
static f_plug_api cfapiMap_find_by_archetype_name
Definition: plugin_common.cpp:99
CFAPI_PLAYER_QUEST_SET_STATE
#define CFAPI_PLAYER_QUEST_SET_STATE
Definition: plugin.h:244
cfapiObject_activate_rune
static f_plug_api cfapiObject_activate_rune
Definition: plugin_common.cpp:77
cf_object_get_float_property
float cf_object_get_float_property(object *op, int propcode)
Definition: plugin_common.cpp:408
CFAPI_OBJECT_PROP_NAME
#define CFAPI_OBJECT_PROP_NAME
Definition: plugin.h:130
cf_object_set_int64_property
void cf_object_set_int64_property(object *op, int propcode, int64_t value)
Definition: plugin_common.cpp:402
cf_get_month_name
const char * cf_get_month_name(int index)
Definition: plugin_common.cpp:1574
cfapiObject_forget_spell
static f_plug_api cfapiObject_forget_spell
Definition: plugin_common.cpp:82
cfapiObject_teleport
static f_plug_api cfapiObject_teleport
Definition: plugin_common.cpp:106
cfapiObject_remove
static f_plug_api cfapiObject_remove
Definition: plugin_common.cpp:66
cf_system_get_map_vector
void cf_system_get_map_vector(int property, std::vector< mapstruct * > *list)
Definition: plugin_common.cpp:2131
mapstruct
This is a game-map.
Definition: map.h:318
CFAPI_PARCH
#define CFAPI_PARCH
Definition: plugin.h:62
cf_friendlylist_get_next
object * cf_friendlylist_get_next(object *ob)
Get next object on friendly list.
Definition: plugin_common.cpp:2045
cf_object_user_event
int cf_object_user_event(object *op, object *activator, object *third, const char *message, int fix)
Definition: plugin_common.cpp:262
cf_object_remove
void cf_object_remove(object *op)
Wrapper for object_remove().
Definition: plugin_common.cpp:562
f_plug_event
int(* f_plug_event)(int *type,...)
Function to call to handle global or object-related events.
Definition: events.h:82
sstring
const typedef char * sstring
Definition: sstring.h:2
cfapiObject_split
static f_plug_api cfapiObject_split
Definition: plugin_common.cpp:71
cf_region_get_name
const char * cf_region_get_name(region *reg)
Get name of region.
Definition: plugin_common.cpp:1903
cf_object_present_archname_inside
object * cf_object_present_archname_inside(object *op, char *whatstr)
Kinda wrapper for arch_present_in_ob().
Definition: plugin_common.cpp:579
cf_archetype_get_more
archetype * cf_archetype_get_more(archetype *arch)
Get next part of archetype.
Definition: plugin_common.cpp:1744
cf_map_get_difficulty
int cf_map_get_difficulty(mapstruct *map)
Definition: plugin_common.cpp:1389
cf_system_unregister_global_event
void cf_system_unregister_global_event(int event, const char *name)
Definition: plugin_common.cpp:1118
cf_object_get_movetype_property
MoveType cf_object_get_movetype_property(object *op, int propcode)
Definition: plugin_common.cpp:357
CFAPI_INT16
#define CFAPI_INT16
Definition: plugin.h:67
plugin_common.h
cf_map_get_region_property
region * cf_map_get_region_property(mapstruct *map, int propcode)
Definition: plugin_common.cpp:288
cfapiGenerate_random_map
static f_plug_api cfapiGenerate_random_map
Definition: plugin_common.cpp:118
cf_system_register_global_event
void cf_system_register_global_event(int event, const char *name, f_plug_event hook)
Definition: plugin_common.cpp:1111
cf_object_get_nrof
int cf_object_get_nrof(object *ob)
Definition: plugin_common.cpp:1279
cf_object_change_map
object * cf_object_change_map(object *op, mapstruct *m, object *originator, int flag, int x, int y)
Wrapper for object_insert_in_map_at().
Definition: plugin_common.cpp:642
cf_object_check_for_spell
object * cf_object_check_for_spell(object *op, const char *name)
Wrapper for check_spell_known().
Definition: plugin_common.cpp:778
cf_archetype_get_name
sstring cf_archetype_get_name(archetype *arch)
Get archetype's name.
Definition: plugin_common.cpp:1711
CFAPI_ARCHETYPE_VECTOR
#define CFAPI_ARCHETYPE_VECTOR
Pointer to a std::vector<archetype *>
Definition: plugin.h:74
cfapiObject_learn_spell
static f_plug_api cfapiObject_learn_spell
Definition: plugin_common.cpp:81
buffer
if you malloc the data for the buffer
Definition: protocol.txt:2106
cfapiMap_get_property
static f_plug_api cfapiMap_get_property
Definition: plugin_common.cpp:94
CFAPI_MAP_VECTOR
#define CFAPI_MAP_VECTOR
Pointer to a std::vector<mapstruct *>
Definition: plugin.h:73
cf_query_name_pl
sstring cf_query_name_pl(object *ob)
Definition: plugin_common.cpp:1218
cf_object_say
void cf_object_say(object *op, const char *msg)
Definition: plugin_common.cpp:1058
CFAPI_STRING
#define CFAPI_STRING
Definition: plugin.h:57
cf_spring_trap
void cf_spring_trap(object *trap, object *victim)
Wrapper for spring_trap().
Definition: plugin_common.cpp:1014
cf_object_pay_amount
int cf_object_pay_amount(object *pl, uint64_t to_pay)
Wrapper for pay_for_amount().
Definition: plugin_common.cpp:732
cf_map_get_first
mapstruct * cf_map_get_first(void)
Gives access to first_map.
Definition: plugin_common.cpp:984
level
int level
Definition: readable.cpp:1563
cf_system_get_party_vector
void cf_system_get_party_vector(int property, std::vector< partylist * > *list)
Definition: plugin_common.cpp:2143
cf_party_get_name
const char * cf_party_get_name(partylist *party)
Definition: plugin_common.cpp:1807
cf_find_face
int cf_find_face(const char *name, int error)
Wrapper for find_face().
Definition: plugin_common.cpp:1519
cf_object_get_map_property
mapstruct * cf_object_get_map_property(object *op, int propcode)
Definition: plugin_common.cpp:373
CFAPI_MAP_PROP_ENTER_Y
#define CFAPI_MAP_PROP_ENTER_Y
Definition: plugin.h:260
cf_query_name
char * cf_query_name(object *ob, char *name, int size)
Definition: plugin_common.cpp:1210
cf_get_time
void cf_get_time(timeofday_t *tod)
Definition: plugin_common.cpp:1558
CFAPI_ARCH_PROP_MORE
#define CFAPI_ARCH_PROP_MORE
Definition: plugin.h:269
cfapiMap_change_light
static f_plug_api cfapiMap_change_light
Definition: plugin_common.cpp:102
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
cf_object_get_flag
int cf_object_get_flag(object *ob, int flag)
Definition: plugin_common.cpp:1286
cfapiSet_random_map_variable
static f_plug_api cfapiSet_random_map_variable
Definition: plugin_common.cpp:117
cf_object_query_money
int cf_object_query_money(const object *op)
Wrapper for query_money().
Definition: plugin_common.cpp:992
cf_re_cmp
const char * cf_re_cmp(const char *str, const char *regexp)
Wrapper for re_cmp().
Definition: plugin_common.cpp:1152
command_registration
uint64_t command_registration
Identifier when registering a command.
Definition: commands.h:32
cf_player_get_party
partylist * cf_player_get_party(object *op)
Definition: plugin_common.cpp:881
CFAPI_OBJECT_PROP_FLAGS
#define CFAPI_OBJECT_PROP_FLAGS
Definition: plugin.h:196
cfapiSystem_register_global_event
static f_plug_api cfapiSystem_register_global_event
Definition: plugin_common.cpp:44
CFAPI_MAP_PROP_HEIGHT
#define CFAPI_MAP_PROP_HEIGHT
Definition: plugin.h:258
code
Crossfire Architecture the general intention is to enhance the enjoyability and playability of CF In this code
Definition: arch-handbook.txt:14
cfapiObject_transfer
static f_plug_api cfapiObject_transfer
Definition: plugin_common.cpp:86
cf_player_can_pay
int cf_player_can_pay(object *pl)
Wrapper for can_pay().
Definition: plugin_common.cpp:895
cf_map_trigger_connected
void cf_map_trigger_connected(objectlink *ol, object *cause, int state)
Wrapper for trigger_connected().
Definition: plugin_common.cpp:1037
cf_create_object_by_name
object * cf_create_object_by_name(const char *name)
Wrapper for create_archetype() and create_archetype_by_object_name().
Definition: plugin_common.cpp:1102
cf_object_set_int_property
void cf_object_set_int_property(object *op, int propcode, int value)
Definition: plugin_common.cpp:329
CFAPI_OBJECT_PROP_MESSAGE
#define CFAPI_OBJECT_PROP_MESSAGE
Definition: plugin.h:136
list
How to Install a Crossfire Server on you must install a python script engine on your computer Python is the default script engine of Crossfire You can find the python engine you have only to install them The VisualC Crossfire settings are for but you habe then to change the pathes in the VC settings Go in Settings C and Settings Link and change the optional include and libs path to the new python installation path o except the maps ! You must download a map package and install them the share folder Its must look like doubleclick on crossfire32 dsw There are projects in your libcross lib and plugin_python You need to compile all Easiest way is to select the plugin_python ReleaseLog as active this will compile all others too Then in Visual C press< F7 > to compile If you don t have an appropriate compiler you can try to get the the VC copies the crossfire32 exe in the crossfire folder and the plugin_python dll in the crossfire share plugins folder we will remove it when we get time for it o Last showing lots of weird write to the Crossfire mailing list
Definition: INSTALL_WIN32.txt:50
LogLevel
LogLevel
Log levels for the LOG() function.
Definition: logger.h:10
cf_object_set_animation
int cf_object_set_animation(object *op, const char *animation)
Set the object's animation.
Definition: plugin_common.cpp:486
cfapiPlayer_can_pay
static f_plug_api cfapiPlayer_can_pay
Definition: plugin_common.cpp:115
CFAPI_PLAYER_QUEST_WAS_COMPLETED
#define CFAPI_PLAYER_QUEST_WAS_COMPLETED
Definition: plugin.h:245
cf_map_has_been_loaded
mapstruct * cf_map_has_been_loaded(const char *name)
Wrapper for has_been_loaded().
Definition: plugin_common.cpp:970
cfapiPlayer_message
static f_plug_api cfapiPlayer_message
Definition: plugin_common.cpp:105
command_function
void(* command_function)(object *op, const char *params)
One command function.
Definition: commands.h:17
CFAPI_LONG
#define CFAPI_LONG
Definition: plugin.h:55
cf_map_get_height
int cf_map_get_height(mapstruct *map)
Definition: plugin_common.cpp:1413
cfapiObject_identify
static f_plug_api cfapiObject_identify
Definition: plugin_common.cpp:60
cf_party_get_first
partylist * cf_party_get_first(void)
Get first party.
Definition: plugin_common.cpp:1792
cf_object_free_drop_inventory
void cf_object_free_drop_inventory(object *ob)
Wrapper for object_free_drop_inventory().
Definition: plugin_common.cpp:571
cf_get_empty_map
mapstruct * cf_get_empty_map(int sizex, int sizey)
Wrapper for get_empty_map().
Definition: plugin_common.cpp:957
GET_HOOK
#define GET_HOOK(x, y, z)
Definition: plugin_common.cpp:138
cfapiSystem_add_string
static f_plug_api cfapiSystem_add_string
Definition: plugin_common.cpp:42
cf_free_string
void cf_free_string(sstring str)
Wrapper for free_string().
Definition: plugin_common.cpp:1191
cf_map_get_map_property
mapstruct * cf_map_get_map_property(mapstruct *map, int propcode)
Definition: plugin_common.cpp:279
cf_find_string
sstring cf_find_string(const char *str)
Definition: plugin_common.cpp:1198
cfapiSystem_get_map_vector
static f_plug_api cfapiSystem_get_map_vector
Definition: plugin_common.cpp:133
cf_map_find_by_archetype_name
object * cf_map_find_by_archetype_name(const char *str, mapstruct *map, int nx, int ny)
Kinda wrapper for map_find_by_archetype_name().
Definition: plugin_common.cpp:1380
cfapiSystem_register_command
static f_plug_api cfapiSystem_register_command
Definition: plugin_common.cpp:130
cfapiObject_change_exp
static f_plug_api cfapiObject_change_exp
Definition: plugin_common.cpp:119
cf_create_object
object * cf_create_object(void)
Wrapper for object_new().
Definition: plugin_common.cpp:1090
cf_object_set_string_property
void cf_object_set_string_property(object *op, int propcode, const char *value)
Definition: plugin_common.cpp:456
cfapiObject_drain
static f_plug_api cfapiObject_drain
Definition: plugin_common.cpp:62
CFAPI_PLAYER_PROP_CLIENT
#define CFAPI_PLAYER_PROP_CLIENT
Definition: plugin.h:239
CFAPI_PARTY_PROP_PASSWORD
#define CFAPI_PARTY_PROP_PASSWORD
Definition: plugin.h:274
cf_map_get_flags
int cf_map_get_flags(mapstruct *oldmap, mapstruct **newmap, int16_t x, int16_t y, int16_t *nx, int16_t *ny)
Wrapper for get_map_flags().
Definition: plugin_common.cpp:1470
CFAPI_MOVETYPE
#define CFAPI_MOVETYPE
Definition: plugin.h:71
cf_strdup_local
char * cf_strdup_local(const char *str)
Wrapper for strdup_local().
Definition: plugin_common.cpp:1455
cf_quest_set_player_state
void cf_quest_set_player_state(object *pl, sstring quest_code, int state)
Wrapper for quest_set_player_state();.
Definition: plugin_common.cpp:2084
cfapiObject_check_spell
static f_plug_api cfapiObject_check_spell
Definition: plugin_common.cpp:83
cf_map_get_width
int cf_map_get_width(mapstruct *map)
Definition: plugin_common.cpp:1409
is_valid_types_gen.type
list type
Definition: is_valid_types_gen.py:25
cfapiArchetype_get_property
static f_plug_api cfapiArchetype_get_property
Definition: plugin_common.cpp:112
cf_region_get_jail_x
int cf_region_get_jail_x(region *reg)
Get region's jail x coordinate.
Definition: plugin_common.cpp:1983
CFAPI_OBJECT_PROP_WEIGHT_LIMIT
#define CFAPI_OBJECT_PROP_WEIGHT_LIMIT
Definition: plugin.h:167
face
in that case they will be relative to whatever the PWD of the crossfire server process is You probably shouldn though Notes on Specific and settings file datadir Usually usr share crossfire Contains data that the server does not need to modify while such as the etc A default install will pack the and treasurelist definitions into a single or trs file and the graphics into a face(metadata) and .tar(bitmaps) file
cfapiPlayer_quest
static f_plug_api cfapiPlayer_quest
Definition: plugin_common.cpp:126
cf_object_pickup
int cf_object_pickup(object *op, object *what)
Definition: plugin_common.cpp:1443
cfapiObject_perm_exp
static f_plug_api cfapiObject_perm_exp
Definition: plugin_common.cpp:129