ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/cfperl.xs
(Generate patch)

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.3 by root, Thu Aug 17 20:23:31 2006 UTC vs.
Revision 1.50 by root, Mon Sep 11 01:16:20 2006 UTC

… …
4 4
5/* 5/*
6 * This code is placed under the GNU General Public Licence (GPL) 6 * This code is placed under the GNU General Public Licence (GPL)
7 * 7 *
8 * Copyright (C) 2001-2005 by Chachkoff Yann 8 * Copyright (C) 2001-2005 by Chachkoff Yann
9 * Copyright (C) 2006 by Marc Lehmann <cf@schmorpd.e> 9 * Copyright (C) 2006 by Marc Lehmann <cf@schmorp.de>
10 * 10 *
11 * This program is free software; you can redistribute it and/or modify 11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by 12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or 13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version. 14 * (at your option) any later version.
… …
21 * You should have received a copy of the GNU General Public License 21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software 22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 23 * Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24*/ 24*/
25 25
26#define PLUGIN_NAME "perl"
27#define PLUGIN_VERSION "cfperl 0.5"
28
29#include <plugin_common.h>
30#include <sounds.h>
31#include <cstdarg>
32#include <sproto.h>
33
34#include "cfperl.h"
35#include "shstr.h"
36
26#include <EXTERN.h> 37#include <EXTERN.h>
27#include <perl.h> 38#include <perl.h>
28#include <XSUB.h> 39#include <XSUB.h>
29 40
30#undef save_long // clashes with libproto.h
31
32#define PLUGIN_NAME "perl"
33#define PLUGIN_VERSION "cfperl 0.3"
34
35#ifndef __CEXTRACT__
36#include <plugin.h>
37#endif
38
39#undef MODULEAPI
40#ifdef WIN32
41#else
42#define MODULEAPI
43#endif
44
45#include <plugin_common.h>
46#include <sounds.h>
47
48#include <stdarg.h>
49
50#include <sproto.h>
51
52//#include "EventAPI.h"
53#include "perlxsi.c" 41#include "perlxsi.c"
54
55static void *globalEventListener (int *type, ...);
56 42
57extern sint64 *levels; // the experience table 43extern sint64 *levels; // the experience table
58 44
59typedef object object_ornull; 45typedef object object_ornull;
60typedef mapstruct mapstruct_ornull; 46typedef mapstruct mapstruct_ornull;
61 47
62typedef double val64; 48typedef double val64;
63#define newSVval64 newSVnv 49#define newSVval64 newSVnv
64#define SvVAL64 SvNV 50#define SvVAL64 SvNV
65 51
66static f_plug_api gethook; 52static f_plug_api gethook = cfapi_get_hooks;
67static f_plug_api registerGlobalEvent; 53static f_plug_api object_set_property = cfapi_object_set_property;
68static f_plug_api unregisterGlobalEvent; 54static f_plug_api object_insert = cfapi_object_insert;
69static f_plug_api systemDirectory;
70static f_plug_api object_set_property;
71static f_plug_api map_get_map;
72static f_plug_api object_insert;
73
74/* this is a stupid way to do things, and awkward to use for plug-in authors */
75typedef struct
76{
77 object* who;
78 object* activator;
79 object* third;
80 object* event;
81 mapstruct* map;
82 char message[1024];
83 int fix; // seems to be python-only, and should not be part of the API
84 int event_code;
85 char extension[1024]; // name field, should invoke specific perl extension
86 char options[1024]; // slaying field of event_connectors
87 int returnvalue;
88} CFPContext;
89 55
90static HV *obj_cache; 56static HV *obj_cache;
91static PerlInterpreter *perl; 57static PerlInterpreter *perl;
58
59static AV *cb_global, *cb_object, *cb_player, *cb_type, *cb_map;
92 60
93#define PUSHcfapi(type,value) PUSHs (sv_2mortal (newSVcfapi (CFAPI_ ## type, (value)))) 61#define PUSHcfapi(type,value) PUSHs (sv_2mortal (newSVcfapi (CFAPI_ ## type, (value))))
94#define PUSHcfapi_va(type,ctype) PUSHcfapi (type, va_arg (args, ctype)) 62#define PUSHcfapi_va(type,ctype) PUSHcfapi (type, va_arg (args, ctype))
95#define PUSH_OB PUSHcfapi_va(POBJECT, object *) 63#define PUSH_OB PUSHcfapi_va(POBJECT, object *)
96#define PUSH_PL PUSHcfapi_va(PPLAYER, player *) 64#define PUSH_PL PUSHcfapi_va(PPLAYER, player *)
… …
98#define PUSH_PV PUSHcfapi_va(STRING, const char *) 66#define PUSH_PV PUSHcfapi_va(STRING, const char *)
99#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int)))) 67#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int))))
100 68
101////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 69//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
102 70
103// garbage collect some perl objects, if possible
104// all objects no longer referenced and empty are
105// eligible for destruction.
106static void
107clean_obj_cache ()
108{
109 static int count;
110
111 if (++count & 7)
112 return;
113
114 int todo = 1000;
115 do
116 {
117 I32 klen;
118 char *key;
119 HE *he = hv_iternext (obj_cache);
120
121 if (he)
122 {
123 SV *sv = hv_iterval (obj_cache, he);
124
125 // empty and unreferenced? nuke it
126 if (SvREFCNT (sv) == 1 && SvREFCNT (SvRV (sv)) == 1 && !HvFILL ((HV *)(SvRV (sv))))
127 {
128 hv_delete (obj_cache, HeKEY (he), HeKLEN (he), G_DISCARD);
129 todo++;
130 }
131 }
132 else
133 break;
134 }
135 while (--todo);
136}
137
138static SV * 71static SV *
139newSVptr (void *ptr, const char *klass) 72newSVptr (void *ptr, const char *klass, HV *hv = newHV ())
140{ 73{
141 SV *sv; 74 SV *sv;
142 75
143 if (!ptr) 76 if (!ptr)
144 return &PL_sv_undef; 77 return &PL_sv_undef;
145 78
146 sv = newSV (0);
147 sv_magic (sv, 0, PERL_MAGIC_ext, (char *)ptr, 0); 79 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
148 return sv_bless (newRV_noinc (sv), gv_stashpv (klass, 1)); 80 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
81}
82
83template<class attachable>
84SV *
85newSVattachable (attachable *obj, const char *klass)
86{
87 if (!obj)
88 return &PL_sv_undef;
89
90 if (!obj->self)
91 obj->self = newSVptr (obj, klass);
92
93 return newSVsv (obj->self);
149} 94}
150 95
151static void 96static void
152SVptr_cache_set (void *ptr, SV *sv) 97SVptr_cache_set (void *ptr, SV *sv)
153{ 98{
… …
215 return SvPTR (sv, klass); 160 return SvPTR (sv, klass);
216 else 161 else
217 return 0; 162 return 0;
218} 163}
219 164
165inline SV *to_sv (const shstr & v) { return v ? newSVpvn ((const char *)v, v.length ()) : &PL_sv_undef; }
166inline SV *to_sv (const char * v) { return newSVpv (v, 0); }
167inline SV *to_sv (bool v) { return newSViv (v); }
168inline SV *to_sv ( signed char v) { return newSViv (v); }
169inline SV *to_sv (unsigned char v) { return newSViv (v); }
170inline SV *to_sv ( signed short v) { return newSViv (v); }
171inline SV *to_sv (unsigned short v) { return newSVuv (v); }
172inline SV *to_sv ( signed int v) { return newSViv (v); }
173inline SV *to_sv (unsigned int v) { return newSVuv (v); }
174inline SV *to_sv ( signed long v) { return newSViv (v); }
175inline SV *to_sv (unsigned long v) { return newSVuv (v); }
176inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
177inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
178inline SV *to_sv (float v) { return newSVnv (v); }
179inline SV *to_sv (double v) { return newSVnv (v); }
180inline SV *to_sv (player * v) { return newSVattachable (v, "cf::player::wrap"); }
181inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap"); }
182inline SV *to_sv (mapstruct * v) { return newSVattachable (v, "cf::map::wrap"); }
183inline SV *to_sv (archetype * v) { return newSVptr (v, "cf::arch::wrap"); }
184inline SV *to_sv (partylist * v) { return newSVptr (v, "cf::party::wrap"); }
185inline SV *to_sv (region * v) { return newSVptr (v, "cf::region::wrap"); }
186inline SV *to_sv (living * v) { return newSVptr (v, "cf::living::wrap"); }
187
188inline SV *to_sv (object & v) { return to_sv (&v); }
189inline SV *to_sv (living & v) { return to_sv (&v); }
190
191//TODO:
192inline SV *to_sv (New_Face * v) { return to_sv (v->name); }
193inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
194
195inline void sv_to (SV *sv, shstr &v) { v = SvPV_nolen (sv); }
196inline void sv_to (SV *sv, char * &v) { free (v); v = strdup (SvPV_nolen (sv)); } //TODO: verify that all simple pointers are strdup-managed
197inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
198inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
199inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
200inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
201inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
202inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
203inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
204inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
205inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
206inline void sv_to (SV *sv, signed long long &v) { v = SvVAL64 (sv); }
207inline void sv_to (SV *sv, unsigned long long &v) { v = SvVAL64 (sv); }
208inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
209inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
210inline void sv_to (SV *sv, player * &v) { v = (player *)SvPTR_ornull (sv, "cf::player"); }
211inline void sv_to (SV *sv, object * &v) { v = (object *)SvPTR_ornull (sv, "cf::object"); }
212inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)SvPTR_ornull (sv, "cf::arch"); }
213inline void sv_to (SV *sv, mapstruct * &v) { v = (mapstruct *)SvPTR_ornull (sv, "cf::map"); }
214inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
215inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
216inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
217
218inline void sv_to (SV *sv, New_Face * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO
219inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); } // TODO
220
221template<int N>
222inline void sv_to (SV *sv, char (&v)[N]) { snprintf (v, N, "%s", SvPV_nolen (sv)); }
223
220static SV * 224static SV *
221newSVcfapi (int type, ...) 225newSVdt_va (va_list &ap, data_type type)
222{ 226{
223 SV *sv; 227 SV *sv;
224 228
225 va_list args;
226 va_start (args, type);
227
228 switch (type) 229 switch (type)
229 { 230 {
230#if 0
231 case CFAPI_INT16: 231 case DT_INT:
232 sv = newSViv (*va_arg (args, sint16_t *)); 232 sv = newSViv (va_arg (ap, int));
233 break; 233 break;
234#endif
235 234
236 case CFAPI_INT: 235 case DT_INT64:
237 sv = newSViv (*va_arg (args, int *)); 236 sv = newSVval64 ((val64)va_arg (ap, sint64));
238 break; 237 break;
239 238
240 case CFAPI_LONG: 239 case DT_DOUBLE:
241 sv = newSVval64 ((val64)*va_arg (args, sint64 *)); 240 sv = newSVnv (va_arg (ap, double));
242 break; 241 break;
243 242
244 case CFAPI_DOUBLE:
245 sv = newSVnv (*va_arg (args, double *));
246 break;
247
248 case CFAPI_STRING: 243 case DT_STRING:
249 { 244 {
250 char *str = va_arg (args, char *); 245 char *str = (char *)va_arg (ap, const char *);
251 sv = str ? newSVpv (str, 0) : &PL_sv_undef; 246 sv = str ? newSVpv (str, 0) : &PL_sv_undef;
252 } 247 }
253 break; 248 break;
254 249
255 case CFAPI_POBJECT: 250 case DT_DATA:
256 { 251 {
257 object *obj = va_arg (args, object *); 252 char *str = (char *)va_arg (ap, const void *);
258 253 int len = va_arg (ap, int);
259 if (!obj) 254 sv = str ? newSVpv (str, len) : &PL_sv_undef;
260 sv = &PL_sv_undef;
261 else
262 switch (obj->type)
263 {
264 case MAP:
265 sv = newSVptr_cached (obj, "cf::object::map::wrap");
266 break;
267
268 case PLAYER:
269 sv = newSVptr_cached (obj, "cf::object::player::wrap");
270 break;
271
272 default:
273 sv = newSVptr_cached (obj, "cf::object::wrap");
274 break;
275 }
276 } 255 }
277 break; 256 break;
278 257
279 case CFAPI_PMAP: 258 case DT_OBJECT:
280 sv = newSVptr (va_arg (args, mapstruct *), "cf::map::wrap"); 259 sv = to_sv (va_arg (ap, object *));
281 break; 260 break;
282 261
283 case CFAPI_PPLAYER: 262 case DT_MAP:
284 sv = newSVptr (va_arg (args, player *), "cf::player::wrap"); 263 // va_arg (object *) when void * is passed is an XSI extension
264 sv = to_sv (va_arg (ap, mapstruct *));
285 break; 265 break;
286 266
287 case CFAPI_PARCH: 267 case DT_PLAYER:
288 sv = newSVptr (va_arg (args, archetype *), "cf::arch::wrap"); 268 sv = to_sv (va_arg (ap, player *));
289 break; 269 break;
290 270
291 case CFAPI_PPARTY: 271 case DT_ARCH:
292 sv = newSVptr (va_arg (args, partylist *), "cf::party::wrap"); 272 sv = to_sv (va_arg (ap, archetype *));
293 break; 273 break;
294 274
295 case CFAPI_PREGION: 275 case DT_PARTY:
296 sv = newSVptr (va_arg (args, region *), "cf::region::wrap"); 276 sv = to_sv (va_arg (ap, partylist *));
297 break; 277 break;
278
279 case DT_REGION:
280 sv = to_sv (va_arg (ap, region *));
281 break;
282
283 default:
284 assert (("unhandled type in newSVdt_va", 0));
285 }
286
287 return sv;
288}
289
290static SV *
291newSVdt (data_type type, ...)
292{
293 va_list ap;
294
295 va_start (ap, type);
296 SV *sv = newSVdt_va (ap, type);
297 va_end (ap);
298
299 return sv;
300}
301
302static SV *
303newSVcfapi (int type, ...)
304{
305 SV *sv;
306
307 va_list ap;
308 va_start (ap, type);
309
310 switch (type)
311 {
312 case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
313 case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
314 case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
315 case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
316 case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
317 case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
318 case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
319 case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
320 case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
321 case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
298 322
299 default: 323 default:
300 assert (("unhandled type in newSVcfapi", 0)); 324 assert (("unhandled type in newSVcfapi", 0));
301 } 325 }
302 326
303 va_end (args); 327 va_end (ap);
304 328
305 return sv; 329 return sv;
306} 330}
307 331
332//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
333
334SV *
335registry_of (attachable_base *ext)
336{
337 if (!ext->cb)
338 ext->cb = newAV ();
339
340 return newRV_inc ((SV *)ext->cb);
341}
342
343void attachable_base::clear ()
344{
345 if (self)
346 {
347 if (cb)
348 if (SvROK (*av_fetch (cb, EVENT_OBJECT_DESTROY, 1)))
349 INVOKE_OBJECT (DESTROY, static_cast<object *>(this));
350 else if (SvROK (*av_fetch (cb, EVENT_MAP_DESTROY, 1)))
351 INVOKE_MAP (DESTROY, static_cast<mapstruct *>(this));
352
353 // disconnect Perl from C, to avoid crashes
354 sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
355
356 // clear the perl hash, might or might not be a good idea
357 hv_clear ((HV *)SvRV ((SV *)self));
358
359 SvREFCNT_dec (self);
360 self = 0;
361 }
362
363 if (cb)
364 {
365 SvREFCNT_dec (cb);
366 cb = 0;
367 }
368
369 attach = 0;
370}
371
372void attachable_base::optimise ()
373{
374 if (!self)
375 return;
376
377 HV *hv = (HV *)SvRV ((SV *)self);
378
379 if (SvREFCNT ((SV *)self) == 1
380 && SvREFCNT ((SV *)hv) == 1
381 && !HvKEYS (hv))
382 {
383 SvREFCNT_dec ((SV *)self);
384 self = 0;
385 }
386}
387
388void attachable_base::instantiate (data_type type, void *obj)
389{
390 dSP;
391 ENTER;
392 SAVETMPS;
393 PUSHMARK (SP);
394 EXTEND (SP, 2);
395 PUSHs (sv_2mortal (newSVdt (type, obj)));
396 PUSHs (sv_2mortal (newSVpv (attach, 0)));
397
398 attach = 0;
399
400 PUTBACK;
401 call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL);
402 FREETMPS;
403 LEAVE;
404
405 switch (type)
406 {
407 case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
408 case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
409 }
410}
411
308///////////////////////////////////////////////////////////////////////////// 412/////////////////////////////////////////////////////////////////////////////
309 413
414void reattach (data_type type, void *obj)
415{
416 //TODO only do this when the object has _attachment's
417
418 dSP;
419 ENTER;
420 SAVETMPS;
421 PUSHMARK (SP);
422 XPUSHs (sv_2mortal (newSVdt (type, obj)));
423 PUTBACK;
424 call_pv ("cf::reattach", G_DISCARD | G_VOID | G_EVAL);
425 FREETMPS;
426 LEAVE;
427
428 switch (type)
429 {
430 case DT_OBJECT: INVOKE_OBJECT (REATTACH, obj); break;
431 case DT_PLAYER: INVOKE_PLAYER (REATTACH, obj); break;
432 case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
433 }
434}
435
436template<class subclass>
437void reattach (attachable<subclass> *obj)
438{
439 obj->optimise ();
440
441 if (obj->self)
442 reattach ((data_type) cftype<subclass>::dt, (subclass *)obj);
443}
444
445#include "kw_hash.h"
446
447object_freezer::object_freezer ()
448: dynbuf (128 * 1024, 64 * 1024)
449{
450 av = newAV ();
451}
452
453object_freezer::~object_freezer ()
454{
455 SvREFCNT_dec (av);
456}
457
458void object_freezer::put (attachable_base *ext)
459{
460 ext->optimise ();
461
462 if (ext->self)
463 {
464 int idx = AvFILLp ((AV *)av) + 1;
465 av_store (av, idx, SvREFCNT_inc (ext->self));
466
467 add ((void *)"oid ", 4);
468 add ((sint32)idx);
469 add ('\n');
470 }
471}
472
473bool object_freezer::save (const char *filename)
474{
475 dSP;
476 ENTER;
477 SAVETMPS;
478 PUSHMARK (SP);
479 EXTEND (SP, 3);
480 PUSHs (sv_2mortal (newSVpv (filename, 0)));
481 PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
482 PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
483 PUTBACK;
484 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
485 FREETMPS;
486 LEAVE;
487}
488
489int fprintf (object_freezer &freezer, const char *format, ...)
490{
491 va_list ap;
492
493 va_start (ap, format);
494
495 int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
496
497 if (len >= 0)
498 freezer.alloc (len);
499
500 va_end (ap);
501}
502
503int fputs (const char *s, object_freezer &freezer)
504{
505 freezer.add (s);
506}
507
508object_thawer::object_thawer (const char *filename)
509{
510 static const char eof[] = "\n\n\n\0\0\0";
511
512 av = 0;
513 text = 0;
514 line = 0;
515
516 if (filename)
517 {
518 dSP;
519 ENTER;
520 SAVETMPS;
521 PUSHMARK (SP);
522 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
523 PUTBACK;
524
525 if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
526 {
527 SPAGAIN;
528
529 // second value - perl objects
530 {
531 SV *sv = POPs;
532 if (SvROK (sv))
533 av = (AV *)SvREFCNT_inc (SvRV (sv));
534 }
535
536 // first value - text part, pad with 3 zeroes
537 {
538 SV *sv = POPs;
539 STRLEN len;
540 char *sv_ = SvPVbyte (sv, len);
541 text = newSV (len + sizeof (eof));
542 SvCUR_set (text, len);
543 memcpy (SvPVX (text), sv_, len);
544 memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
545
546 line = SvPVX (text);
547 }
548 }
549
550 PUTBACK;
551 FREETMPS;
552 LEAVE;
553 }
554}
555
556void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
557{
558 if (!av || oid < 0) // this is actually an error of sorts
559 return;
560
561 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach
562 ext->clear ();
563
564 SV **svp = av_fetch ((AV *)av, oid, 0);
565
566 if (!svp || !SvROK (*svp))
567 {
568 printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
569 return;
570 }
571
572 ext->self = *svp; *svp = &PL_sv_undef;
573 sv_magic (SvRV (ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
574
575 reattach (type, obj);
576}
577
578object_thawer::~object_thawer ()
579{
580 if (text) SvREFCNT_dec (text);
581 if (av) SvREFCNT_dec (av);
582}
583
584char *fgets (char *s, int n, object_thawer &thawer)
585{
586 char *p = thawer.line;
587 char *q = s;
588
589 if (!p)
590 return 0;
591
592 while (--n)
593 {
594 if (!*p)
595 break;
596
597 *q++ = *p;
598
599 if (*p++ == '\n')
600 break;
601 }
602
603 *q = 0;
604 thawer.line = p;
605
606 return s == q ? 0 : s;
607}
608
609keyword object_thawer::get_kv ()
610{
611 if (!line)
612 return KW_EOF;
613
614 for (;;)
615 {
616 char *p = line;
617
618 if (!*p)
619 return KW_EOF;
620
621 // parse keyword
622 while (*p > ' ')
623 p++;
624
625 int klen = p - line;
626
627 if (*p++ != '\n')
628 {
629 // parse value
630 while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
631 ++p;
632
633 last_value = p;
634
635 while (*p != '\n')
636 p++;
637
638 *p++ = 0;
639 }
640 else
641 last_value = 0;
642
643 line [klen] = 0;
644 keyword_idx *kw = kw_lex::match (line, klen);
645
646 //printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
647
648 if (kw)
649 {
650 line = p;
651 return kw->index;
652 }
653 else if (!*line || *line == '#')
654 {
655 // empty/comment line
656 line = p;
657 }
658 else
659 return KW_ERROR;
660 }
661}
662
663void object_thawer::get (shstr &sh) const
664{
665 if (last_value)
666 sh = last_value;
667 else
668 {
669 sh = "<value missing>";
670 LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
671 }
672}
673
674void object_thawer::get_ml (keyword kend, shstr &sh)
675{
676 char kw[128];
677
678 int klen = keyword_len [kend];
679
680 kw [0] = '\n';
681 memcpy (kw + 1, keyword_str [kend], klen);
682 kw [klen + 1] = '\n';
683 kw [klen + 2] = 0;
684
685 // first test for completely empty msg... "endXXX\n"
686 if (!strncmp (line, kw + 1, klen + 1))
687 {
688 sh = 0;
689
690 line += klen + 1;
691
692 return;
693 }
694 else
695 {
696 // multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
697
698 char *end = strstr (line, kw);
699
700 if (!end)
701 {
702 sh = 0;
703 return;
704 }
705
706 *end = 0;
707 sh = line;
708
709 line = end + keyword_len [kend] + 1;
710
711 while (*line++ != '\n')
712 ;
713 }
714}
715
716sint32 object_thawer::get_sint32 () const
717{
718 char *p = last_value;
719
720 if (!p)
721 return 0;
722
723 sint32 val = 0;
724 bool negate;
725
726 if (*p == '-')
727 {
728 negate = true;
729 ++p;
730 }
731 else
732 negate = false;
733
734 do
735 {
736 val *= 10;
737 val += *p++ - '0';
738 }
739 while (*p);
740
741 return negate ? -val : val;
742}
743
744sint64 object_thawer::get_sint64 () const
745{
746 return last_value ? atoll (last_value) : 0;
747}
748
749double object_thawer::get_double () const
750{
751 return last_value ? atof (last_value) : 0;
752}
753
754/////////////////////////////////////////////////////////////////////////////
755
310extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 756extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
311{ 757{
312 gethook = gethooksptr;
313 printf (PLUGIN_VERSION " init\n");
314
315 return 0; 758 return 0;
316} 759}
317 760
318static CommArray_s rtn_cmd; 761static CommArray_s rtn_cmd;
319 762
… …
399extern "C" int cfperl_postInitPlugin () 842extern "C" int cfperl_postInitPlugin ()
400{ 843{
401 int hooktype = 1; 844 int hooktype = 1;
402 int rtype = 0; 845 int rtype = 0;
403 846
404 printf (PLUGIN_VERSION " post init\n");
405
406 registerGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_register_global_event");
407 unregisterGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_unregister_global_event");
408 systemDirectory = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_directory");
409 object_set_property = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_set_property");
410 map_get_map = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_map_get_map");
411 object_insert = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_insert");
412
413 cf_init_plugin (gethook); 847 cf_init_plugin (gethook);
414 848
415 /* Pick the global events you want to monitor from this plugin */ 849 return 0;
416 registerGlobalEvent (NULL, EVENT_BORN, PLUGIN_NAME, globalEventListener); 850}
417 registerGlobalEvent (NULL, EVENT_CLOCK, PLUGIN_NAME, globalEventListener); 851
418 //registerGlobalEvent (NULL, EVENT_CRASH, PLUGIN_NAME, globalEventListener); 852extern "C" int cfperl_closePlugin ()
419 registerGlobalEvent (NULL, EVENT_FIND_UNARMED_SKILL, PLUGIN_NAME, globalEventListener); 853{
420 registerGlobalEvent (NULL, EVENT_PLAYER_USE_SKILL, PLUGIN_NAME, globalEventListener); 854 return 0;
421 registerGlobalEvent (NULL, EVENT_CAST_SPELL, PLUGIN_NAME, globalEventListener); 855}
422 registerGlobalEvent (NULL, EVENT_MONSTER_USE_SKILL, PLUGIN_NAME, globalEventListener); 856
423 registerGlobalEvent (NULL, EVENT_PLAYER_DEATH, PLUGIN_NAME, globalEventListener); 857void
424 registerGlobalEvent (NULL, EVENT_GKILL, PLUGIN_NAME, globalEventListener); 858cfperl_init ()
425 registerGlobalEvent (NULL, EVENT_LOGIN, PLUGIN_NAME, globalEventListener); 859{
426 registerGlobalEvent (NULL, EVENT_LOGOUT, PLUGIN_NAME, globalEventListener); 860 PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);
427 registerGlobalEvent (NULL, EVENT_MAPENTER, PLUGIN_NAME, globalEventListener); 861 perl = perl_alloc ();
428 registerGlobalEvent (NULL, EVENT_MAPLEAVE, PLUGIN_NAME, globalEventListener); 862 perl_construct (perl);
429 registerGlobalEvent (NULL, EVENT_MAPRESET, PLUGIN_NAME, globalEventListener); 863
430 registerGlobalEvent (NULL, EVENT_MAPLOAD, PLUGIN_NAME, globalEventListener); 864 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
431 registerGlobalEvent (NULL, EVENT_MAPOUT, PLUGIN_NAME, globalEventListener);
432 registerGlobalEvent (NULL, EVENT_MAPIN, PLUGIN_NAME, globalEventListener);
433 registerGlobalEvent (NULL, EVENT_MAPCLEAN, PLUGIN_NAME, globalEventListener);
434 registerGlobalEvent (NULL, EVENT_REMOVE, PLUGIN_NAME, globalEventListener);
435 registerGlobalEvent (NULL, EVENT_SHOUT, PLUGIN_NAME, globalEventListener);
436 registerGlobalEvent (NULL, EVENT_TELL, PLUGIN_NAME, globalEventListener);
437 registerGlobalEvent (NULL, EVENT_MUZZLE, PLUGIN_NAME, globalEventListener);
438 registerGlobalEvent (NULL, EVENT_KICK, PLUGIN_NAME, globalEventListener);
439 registerGlobalEvent (NULL, EVENT_FREE_OB, PLUGIN_NAME, globalEventListener);
440 registerGlobalEvent (NULL, EVENT_PLAYER_LOAD, PLUGIN_NAME, globalEventListener);
441 registerGlobalEvent (NULL, EVENT_PLAYER_SAVE, PLUGIN_NAME, globalEventListener);
442 registerGlobalEvent (NULL, EVENT_EXTCMD, PLUGIN_NAME, globalEventListener);
443 865
444 char *argv[] = { 866 char *argv[] = {
445 "", 867 "",
446 "-e" 868 "-e"
447 "BEGIN {"
448 " cf->bootstrap;" 869 "cf->bootstrap;"
449 " unshift @INC, cf::datadir ();" 870 "unshift @INC, cf::datadir ();"
450 "}"
451 ""
452 "use cf;" 871 "require cf;"
453 }; 872 };
454 873
455 perl = perl_alloc ();
456 perl_construct (perl);
457
458 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
459
460 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl)) 874 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))
461 { 875 {
462 printf ("unable to initialize perl-interpreter, continuing without.\n"); 876 printf ("unable to initialize perl-interpreter, aborting.\n");
463 877 exit (EXIT_FAILURE);
464 perl_destruct (perl);
465 perl_free (perl);
466 perl = 0;
467 }
468 else
469 { 878 }
879
470 obj_cache = newHV (); 880 obj_cache = newHV ();
471 }
472
473 return 0;
474} 881}
475 882
883void cfperl_main ()
884{
885 dSP;
886
887 PUSHMARK (SP);
888 PUTBACK;
889 call_pv ("cf::main", G_DISCARD | G_VOID);
890}
891
892static event_klass klass_of[NUM_EVENT_TYPES] = {
893# define def(type,name) KLASS_ ## type,
894# include "eventinc.h"
895# undef def
896};
897
898#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
899
476static void * 900static void
477globalEventListener (int *type, ...) 901gather_callbacks (AV *&callbacks, AV *registry, event_type event)
478{ 902{
479 va_list args; 903 // event must be in array
480 static int rv; 904 if (event >= 0 && event <= AvFILLp (registry))
481 int event_code;
482
483 if (!perl)
484 return NULL;
485
486 va_start (args, type);
487 event_code = va_arg (args, int);
488
489 if (event_code == EVENT_FREE_OB)
490 {
491 player *pl;
492 object *op;
493 SV *sv;
494
495 op = va_arg (args, object *);
496 sv = hv_delete (obj_cache, (char *)&op, sizeof (void *), 0);
497
498 if (sv)
499 clearSVptr (sv);
500
501 rv = 0;
502 } 905 {
503 else if (event_code == EVENT_CLOCK) 906 SV *cbs_ = AvARRAY (registry)[event];
504 {
505 clean_obj_cache ();
506 }
507 else
508 {
509 dSP;
510 907
511 ENTER; 908 // element must be list of callback entries
512 SAVETMPS; 909 if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
513
514 PUSHMARK (SP);
515
516 EXTEND (SP, 10);
517 PUSHs (sv_2mortal (newSViv (event_code)));
518
519 switch (event_code)
520 { 910 {
521 case EVENT_CRASH: 911 AV *cbs = (AV *)SvRV (cbs_);
522 break;
523 912
524 case EVENT_PLAYER_LOAD: 913 // no callback entries, no callbacks to call
525 case EVENT_PLAYER_SAVE: 914 if (AvFILLp (cbs) >= 0)
526 PUSH_OB;
527 PUSH_PV;
528 break;
529
530 case EVENT_MAPLOAD:
531 case EVENT_MAPOUT:
532 case EVENT_MAPIN:
533 case EVENT_MAPCLEAN:
534 case EVENT_MAPRESET:
535 PUSH_MAP;
536 break;
537
538 case EVENT_MAPENTER:
539 case EVENT_MAPLEAVE:
540 case EVENT_BORN:
541 case EVENT_REMOVE:
542 case EVENT_PLAYER_DEATH:
543 PUSH_OB;
544 break;
545
546 case EVENT_GKILL:
547 PUSH_OB;
548 PUSH_OB;
549 break;
550
551 case EVENT_LOGIN:
552 case EVENT_LOGOUT:
553 PUSH_PL;
554 PUSH_PV;
555 break;
556
557 case EVENT_SHOUT:
558 case EVENT_MUZZLE:
559 case EVENT_KICK:
560 PUSH_OB;
561 PUSH_PV;
562 break;
563
564 case EVENT_FIND_UNARMED_SKILL:
565 PUSH_OB;
566 break;
567
568 case EVENT_PLAYER_USE_SKILL:
569 case EVENT_MONSTER_USE_SKILL:
570 case EVENT_CAST_SPELL:
571 PUSH_OB;
572 PUSH_OB;
573 PUSH_OB;
574 PUSH_IV;
575 PUSH_PV;
576 break;
577
578 case EVENT_EXTCMD:
579 PUSH_PL;
580 { 915 {
581 char *buf = va_arg (args, char *); 916 if (!callbacks)
582 int len = va_arg (args, int); 917 {
583 PUSHs (sv_2mortal (newSVpvn (buf, len))); 918 callbacks = newAV ();
919 av_extend (callbacks, 16);
920 }
921
922 // never use SvREFCNT_inc to copy values, but its ok here :)
923 for (int i = 0; i <= AvFILLp (cbs); ++i)
924 av_push (callbacks, SvREFCNT_inc (AvARRAY (cbs)[i]));
584 } 925 }
585 break;
586
587 case EVENT_TELL:
588 break;
589 } 926 }
590
591 va_end (args);
592
593 PUTBACK;
594 int count = call_pv ("cf::inject_global_event", G_SCALAR | G_EVAL);
595 SPAGAIN;
596
597 if (SvTRUE (ERRSV))
598 LOG (llevError, "global event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
599
600 rv = count > 0 ? POPi : 0;
601
602 PUTBACK;
603 FREETMPS;
604 LEAVE;
605 } 927 }
606
607 return &rv;
608} 928}
609 929
610extern "C" void *cfperl_eventListener (int *type, ...) 930bool cfperl_invoke (event_type event, ...)
611{ 931{
612 static int rv; 932 data_type dt;
613 va_list args; 933 va_list ap;
614 int event_code;
615 object *who, *activator, *third, *event;
616 char *message, *extension, *options;
617 934
618 if (!perl)
619 return NULL;
620
621 va_start (args, type); 935 va_start (ap, event);
622 who = va_arg (args, object *);
623 event_code = va_arg (args, int);
624 activator = va_arg (args, object *);
625 third = va_arg (args, object *);
626 message = va_arg (args, char *);
627 va_arg (args, int); // fix yourself
628 extension = va_arg (args, char *);
629 options = va_arg (args, char *);
630 event = va_arg (args, object *);
631 va_end (args);
632 936
633 { 937 AV *callbacks = 0;
634 dSP;
635 938
636 ENTER; 939 object *op;
637 SAVETMPS; 940 player *pl;
941 mapstruct *map;
638 942
639 PUSHMARK (SP); 943 // callback call ordering is:
640 EXTEND (SP, 10); 944 // 1. per-object callback (NYI)
945 // 2. per-class object
946 // 2a. per-type callback
947 // 4. global callbacks
641 948
642 PUSHcfapi (STRING, extension); 949 gather_callbacks (callbacks, cb_global, event);
643 PUSHs (sv_2mortal (newSViv (event_code)));
644 950
645 PUSHcfapi (POBJECT, event); 951 switch (KLASS_OF (event))
646 PUSHcfapi (POBJECT, who);
647
648 switch (event_code)
649 { 952 {
650 case EVENT_STOP: // $ob (e.g. arrow) 953 case KLASS_GLOBAL:
651 case EVENT_TIME: // $ob
652 case EVENT_TIMER: // $ob
653 break; 954 break;
654 955
655 case EVENT_APPLY: // $ob, $who 956 case KLASS_OBJECT:
656 case EVENT_DROP: // $ob, $who 957 dt = (data_type) va_arg (ap, int);
657 case EVENT_CLOSE: // $ob, $who 958 assert (("first argument must be of type object", dt == DT_OBJECT));
658 case EVENT_DEATH: // $ob[, $killer] 959 op = va_arg (ap, object *);
659 case EVENT_MOVE: // $ob, $enemy 960
660 case EVENT_THROW: // $ob, $thrower 961 if (op->cb)
661 PUSHcfapi (POBJECT, activator); 962 gather_callbacks (callbacks, op->cb, event);
963
964 if (op->type)
965 {
966 if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
967 {
968 SV *registry = AvARRAY (cb_type)[op->type + op->subtype * NUM_SUBTYPES];
969
970 if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
971 gather_callbacks (callbacks, (AV *)SvRV (registry), event);
972 }
973
974 if (op->type <= AvFILLp (cb_type))
975 {
976 SV *registry = AvARRAY (cb_type)[op->type];
977
978 if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
979 gather_callbacks (callbacks, (AV *)SvRV (registry), event);
980 }
981 }
982
983 gather_callbacks (callbacks, cb_object, event);
984
662 break; 985 break;
663 986
664 case EVENT_DROP_ON: // $ob, $who, $what 987 case KLASS_PLAYER:
665 case EVENT_ATTACK: // $ob, $who, $victim (?? please god enlighten me) 988 dt = (data_type) va_arg (ap, int);
666 PUSHcfapi (POBJECT, activator); 989 assert (("first argument must be of type player", dt == DT_PLAYER));
667 PUSHcfapi (POBJECT, third); 990 pl = va_arg (ap, player *);
991
992 if (pl->cb)
993 gather_callbacks (callbacks, pl->cb, event);
994
995 gather_callbacks (callbacks, cb_player, event);
668 break; 996 break;
669 997
670 case EVENT_TRIGGER: // $ob, $originator, [$victim], [$msg] 998 case KLASS_MAP:
671 PUSHcfapi (POBJECT, activator); 999 dt = (data_type) va_arg (ap, int);
672 PUSHcfapi (POBJECT, third); 1000 assert (("first argument must be of type object", dt == DT_MAP));
673 PUSHcfapi (POBJECT, message); 1001 map = va_arg (ap, mapstruct *);
1002
1003 if (map->cb)
1004 gather_callbacks (callbacks, map->cb, event);
1005
1006 gather_callbacks (callbacks, cb_map, event);
674 break; 1007 break;
675 1008
676 case EVENT_SAY: // $ob, $who, $msg
677 PUSHcfapi (POBJECT, activator);
678 PUSHcfapi (STRING, message);
679 break;
680
681 default: 1009 default:
682 LOG (llevError, "perl plugin called for unsupported event type %d", event_code); 1010 assert (("unsupported event klass in cfperl_invoke", 0));
683 break;
684 } 1011 }
685 1012
686 PUTBACK; 1013 // short-circuit processing if no callbacks found/defined
687 int count = call_pv ("cf::inject_event", G_SCALAR | G_EVAL); 1014 if (!callbacks)
688 SPAGAIN;
689
690 if (SvTRUE (ERRSV))
691 LOG (llevError, "event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
692
693 rv = count > 0 ? POPi : 0;
694
695 PUTBACK;
696 FREETMPS;
697 LEAVE;
698 }
699
700 return &rv;
701}
702
703extern "C" int cfperl_closePlugin ()
704{
705 printf (PLUGIN_VERSION " closing\n");
706
707 if (perl)
708 {
709 perl_destruct (perl);
710 perl_free (perl);
711 perl = 0;
712 }
713
714 return 0; 1015 return 0;
715}
716 1016
717void cfperl_sleep (double delta)
718{
719 dSP; 1017 dSP;
720 ENTER; 1018 ENTER;
721 SAVETMPS; 1019 SAVETMPS;
722 1020
723 PUSHMARK (SP); 1021 PUSHMARK (SP);
1022 EXTEND (SP, 3);
1023
1024 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays
1025 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));
1026
1027 switch (KLASS_OF (event))
1028 {
1029 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;
1030 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;
1031 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;
1032 }
1033
1034 for (;;)
1035 {
1036 dt = (data_type) va_arg (ap, int);
1037
1038 if (dt == DT_END)
1039 break;
1040
1041 if (dt == DT_AV)
1042 {
1043 AV *av = va_arg (ap, AV *);
1044
1045 for (int i = 0; i <= av_len (av); ++i)
1046 XPUSHs (*av_fetch (av, i, 1));
1047 }
1048 else
724 XPUSHs (sv_2mortal (newSVnv (delta))); 1049 XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1050 }
1051
1052 va_end (ap);
1053
725 PUTBACK; 1054 PUTBACK;
726 call_pv ("cf::sleep_delta", G_DISCARD | G_VOID | G_EVAL); 1055 int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
727 SPAGAIN; 1056 SPAGAIN;
1057
1058 count = count > 0 ? POPi : 0;
728 1059
729 FREETMPS; 1060 FREETMPS;
730 LEAVE; 1061 LEAVE;
1062
1063 return count;
1064}
1065
1066SV *
1067cfperl_result (int idx)
1068{
1069 AV *av = get_av ("cfperl::invoke_results", 0);
1070 if (!av)
1071 return &PL_sv_undef;
1072
1073 SV **sv = av_fetch (av, idx, 0);
1074 if (!sv)
1075 return &PL_sv_undef;
1076
1077 return *sv;
1078}
1079
1080int
1081cfperl_result_INT (int idx)
1082{
1083 return SvIV (cfperl_result (idx));
731} 1084}
732 1085
733MODULE = cf PACKAGE = cf PREFIX = cf_ 1086MODULE = cf PACKAGE = cf PREFIX = cf_
734 1087
735BOOT: 1088BOOT:
… …
744 const_iv (llevError) 1097 const_iv (llevError)
745 const_iv (llevInfo) 1098 const_iv (llevInfo)
746 const_iv (llevDebug) 1099 const_iv (llevDebug)
747 const_iv (llevMonster) 1100 const_iv (llevMonster)
748 1101
1102 const_iv (MAX_TIME)
749 const_iv (PLAYER) 1103 const_iv (PLAYER)
750 const_iv (TRANSPORT) 1104 const_iv (TRANSPORT)
751 const_iv (ROD) 1105 const_iv (ROD)
752 const_iv (TREASURE) 1106 const_iv (TREASURE)
753 const_iv (POTION) 1107 const_iv (POTION)
… …
868 const_iv (BUILDER) 1222 const_iv (BUILDER)
869 const_iv (MATERIAL) 1223 const_iv (MATERIAL)
870 const_iv (ITEM_TRANSFORMER) 1224 const_iv (ITEM_TRANSFORMER)
871 const_iv (QUEST) 1225 const_iv (QUEST)
872 1226
1227 const_iv (NUM_SUBTYPES)
1228
873 const_iv (ST_BD_BUILD) 1229 const_iv (ST_BD_BUILD)
874 const_iv (ST_BD_REMOVE) 1230 const_iv (ST_BD_REMOVE)
875 1231
876 const_iv (ST_MAT_FLOOR) 1232 const_iv (ST_MAT_FLOOR)
877 const_iv (ST_MAT_WALL) 1233 const_iv (ST_MAT_WALL)
… …
1105 1461
1106 const_iv (SK_EXP_ADD_SKILL) 1462 const_iv (SK_EXP_ADD_SKILL)
1107 const_iv (SK_EXP_TOTAL) 1463 const_iv (SK_EXP_TOTAL)
1108 const_iv (SK_EXP_NONE) 1464 const_iv (SK_EXP_NONE)
1109 const_iv (SK_SUBTRACT_SKILL_EXP) 1465 const_iv (SK_SUBTRACT_SKILL_EXP)
1466 const_iv (SK_EXP_SKILL_ONLY)
1110 1467
1111 const_iv (SK_LOCKPICKING) 1468 const_iv (SK_LOCKPICKING)
1112 const_iv (SK_HIDING) 1469 const_iv (SK_HIDING)
1113 const_iv (SK_SMITHERY) 1470 const_iv (SK_SMITHERY)
1114 const_iv (SK_BOWYER) 1471 const_iv (SK_BOWYER)
… …
1213 1570
1214 const_iv (MAP_IN_MEMORY) 1571 const_iv (MAP_IN_MEMORY)
1215 const_iv (MAP_SWAPPED) 1572 const_iv (MAP_SWAPPED)
1216 const_iv (MAP_LOADING) 1573 const_iv (MAP_LOADING)
1217 const_iv (MAP_SAVING) 1574 const_iv (MAP_SAVING)
1575
1576 const_iv (KLASS_GLOBAL)
1577 const_iv (KLASS_OBJECT)
1578 const_iv (KLASS_PLAYER)
1579 const_iv (KLASS_MAP)
1218 }; 1580 };
1219 1581
1220 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1582 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1221 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 1583 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1222 1584
1223 static const struct { 1585 static const struct {
1224 const char *name; 1586 const char *name;
1587 int skip;
1588 IV klass;
1225 IV iv; 1589 IV iv;
1226 } *event, event_list[] = { 1590 } *eiv, event_iv[] = {
1227# define const_event(name) { # name, (IV)EVENT_ ## name }, 1591# define def(klass,name) { "EVENT_" # klass "_" # name, sizeof ("EVENT_" # klass), (IV)KLASS_ ## klass, (IV)EVENT_ ## klass ## _ ## name },
1228 const_event (NONE) 1592# include "eventinc.h"
1229 const_event (APPLY) 1593# undef def
1230 const_event (ATTACK)
1231 const_event (DEATH)
1232 const_event (DROP)
1233 const_event (DROP_ON)
1234 const_event (PICKUP)
1235 const_event (SAY)
1236 const_event (STOP)
1237 const_event (TIME)
1238 const_event (THROW)
1239 const_event (TRIGGER)
1240 const_event (CLOSE)
1241 const_event (TIMER)
1242 const_event (MOVE)
1243
1244 const_event (BORN)
1245 //const_event (CLOCK)
1246 const_event (CRASH)
1247 const_event (PLAYER_DEATH)
1248 const_event (PLAYER_LOAD)
1249 const_event (PLAYER_SAVE)
1250 const_event (GKILL)
1251 const_event (LOGIN)
1252 const_event (LOGOUT)
1253 const_event (MAPENTER)
1254 const_event (MAPLEAVE)
1255 const_event (MAPRESET)
1256 const_event (MAPLOAD)
1257 const_event (MAPOUT)
1258 const_event (MAPIN)
1259 const_event (MAPCLEAN)
1260 const_event (REMOVE)
1261 const_event (SHOUT)
1262 const_event (TELL)
1263 const_event (MUZZLE)
1264 const_event (KICK)
1265 const_event (PLAYER_USE_SKILL)
1266 const_event (MONSTER_USE_SKILL)
1267 const_event (CAST_SPELL)
1268 const_event (FIND_UNARMED_SKILL)
1269 const_event (EXTCMD)
1270 //const_event (FREE_OB)
1271 }; 1594 };
1272 1595
1273 AV *av = get_av ("cf::EVENT", 1); 1596 AV *av = get_av ("cf::EVENT", 1);
1274 1597
1275 for (event = event_list + sizeof (event_list) / sizeof (event_list [0]); event-- > event_list; ) 1598 for (eiv = event_iv + sizeof (event_iv) / sizeof (event_iv [0]); eiv-- > event_iv; )
1276 av_store (av, event->iv, newSVpv ((char *)event->name, 0));
1277
1278 static const struct {
1279 int dtype;
1280 const char *name;
1281 IV idx;
1282 } *cprop, prop_table[] = {
1283# define prop(type, name) { type, # name, (IV) CFAPI_ ## name },
1284 prop (CFAPI_INT, MAP_PROP_FLAGS)
1285 prop (CFAPI_INT, MAP_PROP_DIFFICULTY)
1286 prop (CFAPI_STRING, MAP_PROP_PATH)
1287 prop (CFAPI_STRING, MAP_PROP_TMPNAME)
1288 prop (CFAPI_STRING, MAP_PROP_NAME)
1289 prop (CFAPI_INT, MAP_PROP_RESET_TIME)
1290 prop (CFAPI_INT, MAP_PROP_RESET_TIMEOUT)
1291 prop (CFAPI_INT, MAP_PROP_PLAYERS)
1292 prop (CFAPI_INT, MAP_PROP_DARKNESS)
1293 prop (CFAPI_INT, MAP_PROP_WIDTH)
1294 prop (CFAPI_INT, MAP_PROP_HEIGHT)
1295 prop (CFAPI_INT, MAP_PROP_ENTER_X)
1296 prop (CFAPI_INT, MAP_PROP_ENTER_Y)
1297 prop (CFAPI_INT, MAP_PROP_TEMPERATURE)
1298 prop (CFAPI_INT, MAP_PROP_PRESSURE)
1299 prop (CFAPI_INT, MAP_PROP_HUMIDITY)
1300 prop (CFAPI_INT, MAP_PROP_WINDSPEED)
1301 prop (CFAPI_INT, MAP_PROP_WINDDIR)
1302 prop (CFAPI_INT, MAP_PROP_SKY)
1303 prop (CFAPI_INT, MAP_PROP_WPARTX)
1304 prop (CFAPI_INT, MAP_PROP_WPARTY)
1305 prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1306 prop (CFAPI_PMAP, MAP_PROP_NEXT)
1307 prop (CFAPI_PREGION, MAP_PROP_REGION)
1308 prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1309 prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1310 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1311 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1312 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1313 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1314 prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1315 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1316 prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1317 prop (CFAPI_INT, OBJECT_PROP_COUNT)
1318 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1319 prop (CFAPI_STRING, OBJECT_PROP_NAME)
1320 prop (CFAPI_STRING, OBJECT_PROP_NAME_PLURAL)
1321 prop (CFAPI_STRING, OBJECT_PROP_TITLE)
1322 prop (CFAPI_STRING, OBJECT_PROP_RACE)
1323 prop (CFAPI_STRING, OBJECT_PROP_SLAYING)
1324 prop (CFAPI_STRING, OBJECT_PROP_SKILL)
1325 prop (CFAPI_STRING, OBJECT_PROP_MESSAGE)
1326 prop (CFAPI_STRING, OBJECT_PROP_LORE)
1327 prop (CFAPI_INT, OBJECT_PROP_X)
1328 prop (CFAPI_INT, OBJECT_PROP_Y)
1329 prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED)
1330 prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED_LEFT)
1331 prop (CFAPI_INT, OBJECT_PROP_NROF)
1332 prop (CFAPI_INT, OBJECT_PROP_DIRECTION)
1333 prop (CFAPI_INT, OBJECT_PROP_FACING)
1334 prop (CFAPI_INT, OBJECT_PROP_TYPE)
1335 prop (CFAPI_INT, OBJECT_PROP_SUBTYPE)
1336 prop (CFAPI_INT, OBJECT_PROP_CLIENT_TYPE)
1337 prop (CFAPI_INT, OBJECT_PROP_ATTACK_TYPE)
1338 prop (CFAPI_INT, OBJECT_PROP_PATH_ATTUNED)
1339 prop (CFAPI_INT, OBJECT_PROP_PATH_REPELLED)
1340 prop (CFAPI_INT, OBJECT_PROP_PATH_DENIED)
1341 prop (CFAPI_INT, OBJECT_PROP_MATERIAL)
1342 prop (CFAPI_STRING, OBJECT_PROP_MATERIAL_NAME)
1343 prop (CFAPI_INT, OBJECT_PROP_MAGIC)
1344 prop (CFAPI_INT, OBJECT_PROP_VALUE)
1345 prop (CFAPI_INT, OBJECT_PROP_LEVEL)
1346 prop (CFAPI_INT, OBJECT_PROP_LAST_HEAL)
1347 prop (CFAPI_INT, OBJECT_PROP_LAST_SP)
1348 prop (CFAPI_INT, OBJECT_PROP_LAST_GRACE)
1349 prop (CFAPI_INT, OBJECT_PROP_LAST_EAT)
1350 prop (CFAPI_INT, OBJECT_PROP_INVISIBLE_TIME)
1351 prop (CFAPI_INT, OBJECT_PROP_PICK_UP)
1352 prop (CFAPI_INT, OBJECT_PROP_ITEM_POWER)
1353 prop (CFAPI_INT, OBJECT_PROP_GEN_SP_ARMOUR)
1354 prop (CFAPI_INT, OBJECT_PROP_WEIGHT)
1355 prop (CFAPI_INT, OBJECT_PROP_WEIGHT_LIMIT)
1356 prop (CFAPI_INT, OBJECT_PROP_CARRYING)
1357 prop (CFAPI_INT, OBJECT_PROP_GLOW_RADIUS)
1358 prop (CFAPI_LONG, OBJECT_PROP_PERM_EXP)
1359 prop (CFAPI_POBJECT, OBJECT_PROP_CURRENT_WEAPON)
1360 prop (CFAPI_POBJECT, OBJECT_PROP_ENEMY)
1361 prop (CFAPI_POBJECT, OBJECT_PROP_ATTACKED_BY)
1362 prop (CFAPI_INT, OBJECT_PROP_RUN_AWAY)
1363 prop (CFAPI_POBJECT, OBJECT_PROP_CHOSEN_SKILL)
1364 prop (CFAPI_INT, OBJECT_PROP_HIDDEN)
1365 prop (CFAPI_INT, OBJECT_PROP_MOVE_STATUS)
1366 prop (CFAPI_INT, OBJECT_PROP_MOVE_TYPE)
1367 prop (CFAPI_POBJECT, OBJECT_PROP_SPELL_ITEM)
1368 prop (CFAPI_DOUBLE, OBJECT_PROP_EXP_MULTIPLIER)
1369 prop (CFAPI_PARCH, OBJECT_PROP_ARCHETYPE)
1370 prop (CFAPI_PARCH, OBJECT_PROP_OTHER_ARCH)
1371 prop (CFAPI_STRING, OBJECT_PROP_CUSTOM_NAME)
1372 prop (CFAPI_INT, OBJECT_PROP_ANIM_SPEED)
1373 prop (CFAPI_INT, OBJECT_PROP_FRIENDLY)
1374 prop (CFAPI_STRING, OBJECT_PROP_SHORT_NAME)
1375 prop (CFAPI_INT, OBJECT_PROP_MAGICAL)
1376 prop (CFAPI_INT, OBJECT_PROP_LUCK)
1377 prop (CFAPI_POBJECT, OBJECT_PROP_OWNER)
1378 prop (CFAPI_POBJECT, OBJECT_PROP_PRESENT)
1379 prop (CFAPI_INT, OBJECT_PROP_CHEATER)
1380 prop (CFAPI_INT, OBJECT_PROP_MERGEABLE)
1381 prop (CFAPI_INT, OBJECT_PROP_PICKABLE)
1382 prop (CFAPI_INT, OBJECT_PROP_STR)
1383 prop (CFAPI_INT, OBJECT_PROP_DEX)
1384 prop (CFAPI_INT, OBJECT_PROP_CON)
1385 prop (CFAPI_INT, OBJECT_PROP_WIS)
1386 prop (CFAPI_INT, OBJECT_PROP_INT)
1387 prop (CFAPI_INT, OBJECT_PROP_POW)
1388 prop (CFAPI_INT, OBJECT_PROP_CHA)
1389 prop (CFAPI_INT, OBJECT_PROP_WC)
1390 prop (CFAPI_INT, OBJECT_PROP_AC)
1391 prop (CFAPI_INT, OBJECT_PROP_HP)
1392 prop (CFAPI_INT, OBJECT_PROP_SP)
1393 prop (CFAPI_INT, OBJECT_PROP_GP)
1394 prop (CFAPI_INT, OBJECT_PROP_FP)
1395 prop (CFAPI_INT, OBJECT_PROP_MAXHP)
1396 prop (CFAPI_INT, OBJECT_PROP_MAXSP)
1397 prop (CFAPI_INT, OBJECT_PROP_MAXGP)
1398 prop (CFAPI_INT, OBJECT_PROP_DAM)
1399 prop (CFAPI_STRING, OBJECT_PROP_GOD)
1400 prop (CFAPI_STRING, OBJECT_PROP_ARCH_NAME)
1401 prop (CFAPI_INT, OBJECT_PROP_INVISIBLE)
1402 prop (CFAPI_INT, OBJECT_PROP_FACE)
1403 };
1404
1405 HV *prop_type = get_hv ("cf::PROP_TYPE", 1);
1406 HV *prop_idx = get_hv ("cf::PROP_IDX", 1);
1407
1408 for (cprop = prop_table + sizeof (prop_table) / sizeof (prop_table [0]); cprop-- > prop_table; )
1409 { 1599 {
1410 hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0); 1600 AV *event = newAV ();
1411 hv_store (prop_idx, cprop->name, strlen (cprop->name), newSViv (cprop->idx ), 0); 1601 av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1602 av_push (event, newSViv (eiv->klass));
1603 av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1604 newCONSTSUB (stash, (char *)eiv->name, newSViv (eiv->iv));
1412 } 1605 }
1413 1606
1414 //I_EVENT_API (PACKAGE); 1607 //I_EVENT_API (PACKAGE);
1415} 1608}
1416 1609
1610void _init_vars ()
1611 CODE:
1612 cb_global = get_av ("cf::CB_GLOBAL", 1);
1613 cb_object = get_av ("cf::CB_OBJECT", 1);
1614 cb_player = get_av ("cf::CB_PLAYER", 1);
1615 cb_type = get_av ("cf::CB_TYPE" , 1);
1616 cb_map = get_av ("cf::CB_MAP" , 1);
1617
1618void _global_reattach ()
1619 CODE:
1620{
1621 // reattach to all attachable objects in the game.
1622 for (player *pl = first_player; pl; pl = pl->next)
1623 reattach (pl);
1624
1625 for (mapstruct *map = first_map; map; map = map->next)
1626 reattach (map);
1627
1628 for (object *op = objects; op; op = op->next)
1629 reattach (op);
1630}
1631
1417NV floor (NV x) 1632NV floor (NV x)
1418 1633
1419NV ceil (NV x) 1634NV ceil (NV x)
1635
1636void server_tick ()
1420 1637
1421void 1638void
1422LOG (int level, char *msg) 1639LOG (int level, char *msg)
1423 PROTOTYPE: $$ 1640 PROTOTYPE: $$
1424 C_ARGS: (LogLevel)level, "%s", msg 1641 C_ARGS: (LogLevel)level, "%s", msg
… …
1427 PROTOTYPE: $$ 1644 PROTOTYPE: $$
1428 1645
1429char *path_combine_and_normalize (char *base, char *path) 1646char *path_combine_and_normalize (char *base, char *path)
1430 PROTOTYPE: $$ 1647 PROTOTYPE: $$
1431 1648
1432char * 1649const char *
1433cf_get_maps_directory (char *path) 1650get_maps_directory (char *path)
1434 PROTOTYPE: $ 1651 PROTOTYPE: $
1435 ALIAS: maps_directory = 0 1652 ALIAS: maps_directory = 0
1653 CODE:
1654 RETVAL = create_pathname (path);
1655 OUTPUT: RETVAL
1436 1656
1437void 1657void
1438sub_generation_inc () 1658sub_generation_inc ()
1439 CODE: 1659 CODE:
1440 PL_sub_generation++; 1660 PL_sub_generation++;
… …
1449 confdir = 3 1669 confdir = 3
1450 localdir = 4 1670 localdir = 4
1451 playerdir = 5 1671 playerdir = 5
1452 datadir = 6 1672 datadir = 6
1453 CODE: 1673 CODE:
1454{ 1674 switch (ix)
1455 int unused_type; 1675 {
1456 RETVAL = (char *)systemDirectory (&unused_type, ix); 1676 case 0: RETVAL = settings.mapdir ; break;
1457} 1677 case 1: RETVAL = settings.uniquedir; break;
1678 case 2: RETVAL = settings.tmpdir ; break;
1679 case 3: RETVAL = settings.confdir ; break;
1680 case 4: RETVAL = settings.localdir ; break;
1681 case 5: RETVAL = settings.playerdir; break;
1682 case 6: RETVAL = settings.datadir ; break;
1683 }
1458 OUTPUT: RETVAL 1684 OUTPUT: RETVAL
1459 1685
1460int 1686int
1461cf_find_animation (char *text) 1687cf_find_animation (char *text)
1462 PROTOTYPE: $ 1688 PROTOTYPE: $
1463 1689
1464int random_roll(int min, int max, object *op, int goodbad); 1690int random_roll(int min, int max, object *op, int goodbad);
1465 1691
1466const char *cost_string_from_value(uint64 cost, int approx = 0) 1692const char *cost_string_from_value(uint64 cost, int approx = 0)
1693
1694int invoke (int event, ...)
1695 CODE:
1696 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1697 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1698 for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1699 RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1700 OUTPUT: RETVAL
1467 1701
1468int 1702int
1469exp_to_level (val64 exp) 1703exp_to_level (val64 exp)
1470 CODE: 1704 CODE:
1471{ 1705{
… …
1502 RETVAL = newSVpv (resist_plus[atnr], 0); 1736 RETVAL = newSVpv (resist_plus[atnr], 0);
1503 else 1737 else
1504 XSRETURN_UNDEF; 1738 XSRETURN_UNDEF;
1505 OUTPUT: RETVAL 1739 OUTPUT: RETVAL
1506 1740
1741int
1742_valid (SV *obj)
1743 CODE:
1744 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1745 OUTPUT:
1746 RETVAL
1747
1507MODULE = cf PACKAGE = cf::object PREFIX = cf_object_ 1748MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1508 1749
1509SV * 1750int invoke (object *op, int event, ...)
1510get_property (object *obj, int type, int idx)
1511 CODE: 1751 CODE:
1512 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx)); 1752 if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1753 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1754 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1755 RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));
1513 OUTPUT: RETVAL 1756 OUTPUT: RETVAL
1514 1757
1515SV * 1758SV *registry (object *op)
1516set_property (object *obj, int type, int idx, SV *newval)
1517 CODE: 1759 CODE:
1518 switch (type) 1760 RETVAL = registry_of (op);
1519 { 1761 OUTPUT:
1520 case CFAPI_INT: 1762 RETVAL
1521 cf_object_set_int_property (obj, idx, SvIV (newval)); 1763
1522 break; 1764INCLUDE: $PERL genacc object ../include/object.h |
1523 case CFAPI_LONG:
1524 cf_object_set_long_property (obj, idx, (long) SvVAL64 (newval));
1525 break;
1526 case CFAPI_DOUBLE:
1527 {
1528 int unused_type;
1529 object_set_property (&unused_type, obj, idx, (double)SvNV (newval));
1530 }
1531 break;
1532 case CFAPI_STRING:
1533 cf_object_set_string_property (obj, idx, SvOK (newval) ? SvPV_nolen (newval) : 0);
1534 break;
1535 case CFAPI_POBJECT:
1536 {
1537 int unused_type;
1538 object_set_property (&unused_type, obj, idx, (object *)SvPTR_ornull (newval, "cf::object"));
1539 }
1540 break;
1541 default:
1542 croak ("unhandled type '%d' in set_property '%d'", type, idx);
1543 }
1544 1765
1545# missing properties 1766# missing properties
1546 1767
1547void 1768int flag (object *op, int flag, int value = 1)
1548set_attacktype (object *obj, U32 attacktype) 1769 PROTOTYPE: $$;$
1549 CODE: 1770 CODE:
1550 obj->attacktype = attacktype; 1771 RETVAL = QUERY_FLAG (op, flag);
1551 1772 if (items >= 3)
1552U32 1773 if (value)
1553get_attacktype (object *obj) 1774 SET_FLAG (op, flag);
1554 ALIAS: 1775 else
1555 attacktype = 0 1776 CLEAR_FLAG (op, flag);
1556 CODE:
1557 RETVAL = obj->attacktype;
1558 OUTPUT: RETVAL 1777 OUTPUT: RETVAL
1559
1560# missing in plug-in api, of course
1561void
1562set_food (object *obj, int food)
1563 CODE:
1564 obj->stats.food = food;
1565
1566int
1567get_food (object *obj)
1568 ALIAS:
1569 food = 0
1570 CODE:
1571 RETVAL = obj->stats.food;
1572 OUTPUT: RETVAL
1573 1778
1574void 1779void
1575inv (object *obj) 1780inv (object *obj)
1576 PROTOTYPE: $ 1781 PROTOTYPE: $
1577 PPCODE: 1782 PPCODE:
… …
1582} 1787}
1583 1788
1584int cf_object_get_resistance (object *op, int rtype) 1789int cf_object_get_resistance (object *op, int rtype)
1585 ALIAS: resistance = 0 1790 ALIAS: resistance = 0
1586 1791
1587int cf_object_get_flag (object *op, int flag)
1588 ALIAS: flag = 0
1589
1590void cf_object_set_flag (object *op, int flag, int value)
1591
1592int need_identify (const object *obj); 1792int need_identify (const object *obj);
1593 1793
1594int apply_shop_mat (object *shop_mat, object *op); 1794int apply_shop_mat (object *shop_mat, object *op);
1595 1795
1596void cf_object_move (object *op, int dir, object *originator = op) 1796int move (object *op, int dir, object *originator = op)
1797 CODE:
1798 RETVAL = move_ob (op, dir, originator);
1799 OUTPUT:
1800 RETVAL
1597 1801
1598void cf_object_apply (object *op, object *author, int flags = 0) 1802void cf_object_apply (object *op, object *author, int flags = 0)
1599 1803
1600void cf_object_apply_below (object *op) 1804void cf_object_apply_below (object *op)
1601 1805
… …
1643 1847
1644void cf_object_drop (object *op, object *author) 1848void cf_object_drop (object *op, object *author)
1645 1849
1646void cf_object_take (object *op, object *author) 1850void cf_object_take (object *op, object *author)
1647 1851
1648void cf_object_say (object *op, char *msg)
1649
1650void cf_object_speak (object *op, char *msg)
1651
1652object *cf_object_insert_object (object *op, object *container) 1852object *cf_object_insert_object (object *op, object *container)
1653
1654const char *cf_object_get_msg (object *ob)
1655 ALIAS: msg = 0
1656 1853
1657object *cf_object_insert_in_ob (object *ob, object *where) 1854object *cf_object_insert_in_ob (object *ob, object *where)
1658 1855
1659int cf_object_teleport (object *op, mapstruct *map, int x, int y) 1856int cf_object_teleport (object *op, mapstruct *map, int x, int y)
1660 1857
… …
1756base_name (object *ob, int plural) 1953base_name (object *ob, int plural)
1757 CODE: 1954 CODE:
1758 RETVAL = cf_query_base_name (ob, plural); 1955 RETVAL = cf_query_base_name (ob, plural);
1759 OUTPUT: RETVAL 1956 OUTPUT: RETVAL
1760 1957
1761living *
1762stats (object *ob)
1763 CODE:
1764 RETVAL = &ob->stats;
1765 OUTPUT: RETVAL
1766
1767
1768MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_ 1958MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1769 1959
1770player *player (object *op) 1960player *player (object *op)
1771 CODE: 1961 CODE:
1772 RETVAL = op->contr; 1962 RETVAL = op->contr;
… …
1789 1979
1790void cf_player_set_party (object *op, partylist *party) 1980void cf_player_set_party (object *op, partylist *party)
1791 1981
1792void kill_player (object *op) 1982void kill_player (object *op)
1793 1983
1794MODULE = cf PACKAGE = cf::object::map PREFIX = cf_
1795
1796MODULE = cf PACKAGE = cf::player PREFIX = cf_player_ 1984MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1985
1986int invoke (player *pl, int event, ...)
1987 CODE:
1988 if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
1989 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1990 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1991 RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));
1992 OUTPUT: RETVAL
1993
1994SV *registry (player *pl)
1995 CODE:
1996 RETVAL = registry_of (pl);
1997 OUTPUT:
1998 RETVAL
1797 1999
1798player *cf_player_find (char *name) 2000player *cf_player_find (char *name)
1799 PROTOTYPE: $ 2001 PROTOTYPE: $
1800 2002
1801void cf_player_move (player *pl, int dir) 2003void cf_player_move (player *pl, int dir)
… …
1823 CODE: 2025 CODE:
1824 RETVAL = FABS (dx) <= pl->socket.mapx / 2 && FABS (dy) <= pl->socket.mapy / 2 2026 RETVAL = FABS (dx) <= pl->socket.mapx / 2 && FABS (dy) <= pl->socket.mapy / 2
1825 && !pl->blocked_los [dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2]; 2027 && !pl->blocked_los [dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2];
1826 OUTPUT: 2028 OUTPUT:
1827 RETVAL 2029 RETVAL
2030
2031char *
2032client (player *pl)
2033 CODE:
2034 RETVAL = pl->socket.client;
2035 OUTPUT:
2036 RETVAL
2037
2038char *
2039host (player *pl)
2040 CODE:
2041 RETVAL = pl->socket.host;
2042 OUTPUT:
2043 RETVAL
2044
2045char *
2046killer (player *pl, char *killer = 0)
2047 CODE:
2048 if (killer)
2049 snprintf (pl->killer, sizeof (pl->killer), "%s", killer);
2050 RETVAL = pl->killer;
2051 OUTPUT:
2052 RETVAL
2053
2054void
2055buggy_mapscroll (player *pl, int value = 1)
2056 CODE:
2057 pl->socket.buggy_mapscroll = value;
1828 2058
1829void 2059void
1830send (player *pl, SV *packet) 2060send (player *pl, SV *packet)
1831 CODE: 2061 CODE:
1832{ 2062{
… …
1843 if (new_value >= 0) 2073 if (new_value >= 0)
1844 pl->listening = new_value; 2074 pl->listening = new_value;
1845 OUTPUT: 2075 OUTPUT:
1846 RETVAL 2076 RETVAL
1847 2077
1848void get_savebed (player *pl) 2078void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
1849 ALIAS: 2079 PROTOTYPE: $;$$$
1850 savebed = 0
1851 PPCODE: 2080 PPCODE:
2081 if (GIMME_V != G_VOID)
2082 {
1852 EXTEND (SP, 3); 2083 EXTEND (SP, 3);
1853 PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0))); 2084 PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));
1854 PUSHs (sv_2mortal (newSViv (pl->bed_x))); 2085 PUSHs (sv_2mortal (newSViv (pl->bed_x)));
1855 PUSHs (sv_2mortal (newSViv (pl->bed_y))); 2086 PUSHs (sv_2mortal (newSViv (pl->bed_y)));
1856 2087 }
1857void set_savebed (player *pl, char *map_path, int x, int y) 2088 if (map_path) sv_to (map_path, pl->savebed_map);
1858 CODE: 2089 if (x) sv_to (x, pl->bed_x);
1859 strcpy (pl->savebed_map, map_path); 2090 if (y) sv_to (y, pl->bed_y);
1860 pl->bed_x = x;
1861 pl->bed_y = y;
1862 2091
1863void 2092void
1864list () 2093list ()
1865 PPCODE: 2094 PPCODE:
1866{ 2095{
… …
1892 OUTPUT: RETVAL 2121 OUTPUT: RETVAL
1893 2122
1894 2123
1895MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2124MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
1896 2125
1897SV * 2126mapstruct *first ()
1898get_property (mapstruct *obj, int type, int idx) 2127 PROTOTYPE:
2128 CODE:
2129 RETVAL = first_map;
2130 OUTPUT: RETVAL
2131
2132int invoke (mapstruct *map, int event, ...)
1899 CODE: 2133 CODE:
1900 RETVAL = newSVcfapi (type, cf_map_get_property (obj, idx)); 2134 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2135 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2136 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2137 RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));
1901 OUTPUT: RETVAL 2138 OUTPUT: RETVAL
1902 2139
1903SV * 2140SV *registry (mapstruct *map)
1904set_property (mapstruct *obj, int type, int idx, SV *newval)
1905 CODE: 2141 CODE:
1906 switch (type) 2142 RETVAL = registry_of (map);
1907 { 2143 OUTPUT:
1908 case CFAPI_INT: 2144 RETVAL
1909 cf_map_set_int_property (obj, idx, SvIV (newval)); 2145
1910 break; 2146INCLUDE: $PERL genacc mapstruct ../include/map.h |
1911 default:
1912 croak ("unhandled type '%d' in set_property '%d'", type, idx);
1913 }
1914 2147
1915mapstruct *new (int width, int height) 2148mapstruct *new (int width, int height)
1916 PROTOTYPE: 2149 PROTOTYPE:
1917 CODE: 2150 CODE:
1918{ 2151{
1919 int unused_type; 2152 RETVAL = get_empty_map (width, height);
1920 RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
1921} 2153}
1922 OUTPUT: 2154 OUTPUT:
1923 RETVAL 2155 RETVAL
1924 2156
1925void delete_map (mapstruct *map) 2157void delete_map (mapstruct *map)
… …
1940 XSRETURN_UNDEF; 2172 XSRETURN_UNDEF;
1941 RETVAL = map->tile_path [dir]; 2173 RETVAL = map->tile_path [dir];
1942 OUTPUT: 2174 OUTPUT:
1943 RETVAL 2175 RETVAL
1944 2176
1945mapstruct *cf_map_get_map (char *name) 2177mapstruct *ready_map_name (char *name, int flags = 0)
1946 PROTOTYPE: $ 2178 PROTOTYPE: $;$
1947 ALIAS: map = 0 2179 ALIAS:
2180 find = 0
2181 get_map = 1
1948 2182
1949mapstruct *has_been_loaded (char *name) 2183mapstruct *has_been_loaded (char *name)
1950 PROTOTYPE: $ 2184 PROTOTYPE: $
1951
1952mapstruct *cf_map_get_first ()
1953 PROTOTYPE:
1954 ALIAS: first = 0
1955
1956# whoever "designed" the plug-in api should have wasted
1957# his/her time with staying away from the project - would have
1958# saved others a lot of time, without doubt.
1959void set_path (mapstruct *where, char *path)
1960 CODE:
1961 strcpy (where->path, path);
1962 2185
1963int in_memory (mapstruct *map) 2186int in_memory (mapstruct *map)
1964 CODE: 2187 CODE:
1965 RETVAL = map->in_memory; 2188 RETVAL = map->in_memory;
1966 OUTPUT: 2189 OUTPUT:
1967 RETVAL 2190 RETVAL
1968 2191
1969bool unique (mapstruct *map) 2192void
1970 CODE: 2193trigger (mapstruct *map, long connection, bool state = true)
1971 RETVAL = map->unique; 2194 CODE:
1972 OUTPUT: 2195 activate_connection (map, connection, state);
1973 RETVAL
1974 2196
1975void set_unique (mapstruct *map, bool unique) 2197void
1976 CODE: 2198get_connection (mapstruct *map, long connection)
1977 map->unique = unique; 2199 PPCODE:
2200 oblinkpt *obp = get_connection_links (map, connection);
2201 if (obp)
2202 for (objectlink *ol = obp->link; ol; ol = ol->next)
2203 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, ol->ob)));
1978 2204
1979object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags) 2205object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags)
1980 2206
1981object *cf_map_insert_object (mapstruct *where, object* op, int x, int y) 2207object *cf_map_insert_object (mapstruct *where, object* op, int x, int y)
1982 2208
… …
1987cf_map_normalise (mapstruct *map, int x, int y) 2213cf_map_normalise (mapstruct *map, int x, int y)
1988 PPCODE: 2214 PPCODE:
1989{ 2215{
1990 mapstruct *nmap = 0; 2216 mapstruct *nmap = 0;
1991 I16 nx = 0, ny = 0; 2217 I16 nx = 0, ny = 0;
1992 int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2218 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
1993 2219
1994 EXTEND (SP, 4); 2220 EXTEND (SP, 4);
1995 PUSHs (sv_2mortal (newSViv (flags))); 2221 PUSHs (sv_2mortal (newSViv (flags)));
1996 2222
1997 if (GIMME_V == G_ARRAY) 2223 if (GIMME_V == G_ARRAY)
… …
2009{ 2235{
2010 object *o; 2236 object *o;
2011 mapstruct *nmap = 0; 2237 mapstruct *nmap = 0;
2012 I16 nx, ny; 2238 I16 nx, ny;
2013 2239
2014 cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2240 get_map_flags (map, &nmap, x, y, &nx, &ny);
2015 2241
2016 if (nmap) 2242 if (nmap)
2017 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above) 2243 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2018 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o))); 2244 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2019} 2245}
… …
2044 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break; 2270 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2045 } 2271 }
2046 OUTPUT: 2272 OUTPUT:
2047 RETVAL 2273 RETVAL
2048 2274
2049# "serialise" map perl data into a ref
2050void
2051_get_obs (mapstruct *map)
2052 PPCODE:
2053{
2054 object *o;
2055 int x, y;
2056 AV *obs = newAV ();
2057 int nonnull = 0;
2058 2275
2059 for (y = 0; y < MAP_HEIGHT (map); y++) 2276MODULE = cf PACKAGE = cf::arch
2060 for (x = 0; x < MAP_WIDTH (map); x++)
2061 {
2062 AV *av = newAV ();
2063 2277
2064 for (o = GET_MAP_OB (map, x, y); o; o = o->above) 2278archetype *find (const char *name)
2065 { 2279 CODE:
2066 SV *sv = SVptr_cache_get (o); 2280 RETVAL = find_archetype (name);
2281 OUTPUT:
2282 RETVAL
2067 2283
2068 if (sv && HvFILL (SvRV (sv))) 2284archetype *first()
2069 {
2070 nonnull = 1;
2071 sv = newSVsv (sv);
2072 }
2073 else
2074 sv = &PL_sv_undef;
2075
2076 av_push (av, sv);
2077 }
2078
2079 av_store (obs, x + y * MAP_HEIGHT (map), newRV_noinc ((SV *)av));
2080 }
2081
2082 if (nonnull)
2083 XPUSHs (sv_2mortal (newRV_noinc ((SV *)obs)));
2084 else
2085 SvREFCNT_dec (obs);
2086}
2087
2088# "deserialise" perl map data into the map
2089void
2090_set_obs (mapstruct *map, SV *sv)
2091 CODE:
2092{
2093 object *o;
2094 AV *av;
2095 int x, y;
2096 AV *obs = (AV *)SvRV (sv);
2097
2098 for (y = 0; y < MAP_HEIGHT (map); y++)
2099 for (x = 0; x < MAP_WIDTH (map); x++)
2100 {
2101 sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);
2102
2103 if (!SvROK (sv))
2104 continue;
2105
2106 av = (AV *)SvRV (sv);
2107
2108 for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2109 {
2110 sv = av_shift (av);
2111
2112 if (SvROK (sv))
2113 {
2114 sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2115 SVptr_cache_set (o, sv);
2116 }
2117 }
2118 }
2119}
2120
2121
2122MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_
2123
2124archetype *cf_archetype_get_first()
2125 PROTOTYPE: 2285 PROTOTYPE:
2126 ALIAS: first = 0 2286 CODE:
2287 RETVAL = first_archetype;
2288 OUTPUT: RETVAL
2127 2289
2128archetype *cf_archetype_get_next (archetype *arch) 2290INCLUDE: $PERL genacc archetype ../include/object.h |
2129 ALIAS: next = 0
2130 2291
2131archetype *cf_archetype_get_head (archetype *arch) 2292MODULE = cf PACKAGE = cf::party
2132 ALIAS: head = 0
2133 2293
2134archetype *cf_archetype_get_more (archetype *arch) 2294partylist *first ()
2135 ALIAS: more = 0
2136
2137const char *cf_archetype_get_name (archetype *arch)
2138 ALIAS: name = 0
2139
2140object *cf_archetype_get_clone (archetype *arch)
2141 ALIAS: clone = 0
2142
2143MODULE = cf PACKAGE = cf::party PREFIX = cf_party_
2144
2145partylist *cf_party_get_first ()
2146 PROTOTYPE: 2295 PROTOTYPE:
2147 ALIAS: first = 0 2296 CODE:
2297 RETVAL = get_firstparty ();
2298 OUTPUT: RETVAL
2148 2299
2149partylist *cf_party_get_next (partylist *party) 2300partylist *next (partylist *party)
2150 ALIAS: next = 0 2301 CODE:
2302 RETVAL = party->next;
2303 OUTPUT: RETVAL
2151 2304
2152const char *cf_party_get_name (partylist *party) 2305const char *name (partylist *party)
2306 CODE:
2307 RETVAL = party->partyname;
2308 OUTPUT: RETVAL
2153 2309
2154const char *cf_party_get_password (partylist *party) 2310const char *password (partylist *party)
2155 ALIAS: password = 0 2311 CODE:
2312 RETVAL = party->passwd;
2313 OUTPUT: RETVAL
2156 2314
2157player *cf_party_get_first_player (partylist *party) 2315MODULE = cf PACKAGE = cf::region
2158 ALIAS: first_player = 0
2159 2316
2160player *cf_party_get_next_player (partylist *party, player *op) 2317region *first ()
2161 ALIAS: next_player = 0
2162
2163
2164MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2165
2166region *cf_region_get_first ()
2167 PROTOTYPE: 2318 PROTOTYPE:
2168 ALIAS: first = 0
2169
2170const char *cf_region_get_name (region *reg)
2171 ALIAS: name = 0
2172
2173region *cf_region_get_next (region *reg)
2174 ALIAS: next = 0
2175
2176region *cf_region_get_parent (region *reg)
2177 ALIAS: parent = 0
2178
2179const char *cf_region_get_longname (region *reg)
2180 ALIAS: longname = 0
2181
2182const char *cf_region_get_message (region *reg)
2183 ALIAS: message = 0
2184
2185
2186MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2187
2188val64
2189exp (living *liv, val64 new_val = 0)
2190 PROTOTYPE: $;$
2191 ALIAS:
2192 Str = 1
2193 Dex = 2
2194 Con = 3
2195 Wis = 4
2196 Cha = 5
2197 Int = 6
2198 Pow = 7
2199 wc = 8
2200 ac = 9
2201 hp = 10
2202 maxhp = 11
2203 sp = 12
2204 maxsp = 13
2205 grace = 14
2206 maxgrace = 15
2207 food = 16
2208 dam = 17
2209 luck = 18
2210 CODE: 2319 CODE:
2211# define LIVING_ACC(acc,idx) case idx: RETVAL = liv->acc; if (items > 1) liv->acc = (sint64)new_val; break 2320 RETVAL = first_region;
2212 switch (ix)
2213 {
2214 LIVING_ACC (exp , 0);
2215 LIVING_ACC (Str , 1);
2216 LIVING_ACC (Dex , 2);
2217 LIVING_ACC (Con , 3);
2218 LIVING_ACC (Wis , 4);
2219 LIVING_ACC (Cha , 5);
2220 LIVING_ACC (Int , 6);
2221 LIVING_ACC (Pow , 7);
2222 LIVING_ACC (wc , 8);
2223 LIVING_ACC (ac , 9);
2224 LIVING_ACC (hp , 10);
2225 LIVING_ACC (maxhp , 11);
2226 LIVING_ACC (sp , 12);
2227 LIVING_ACC (maxsp , 13);
2228 LIVING_ACC (grace , 14);
2229 LIVING_ACC (maxgrace, 15);
2230 LIVING_ACC (food , 16);
2231 LIVING_ACC (dam , 17);
2232 LIVING_ACC (luck , 18);
2233 }
2234# undef LIVING_ACC
2235 OUTPUT:
2236 RETVAL 2321 OUTPUT: RETVAL
2237 2322
2323region *next (region *reg)
2324 CODE:
2325 RETVAL = reg->next;
2326 OUTPUT: RETVAL
2327
2328const char *name (region *reg)
2329 CODE:
2330 RETVAL = reg->name;
2331 OUTPUT: RETVAL
2332
2333region *parent (region *reg)
2334 CODE:
2335 RETVAL = reg->parent;
2336 OUTPUT: RETVAL
2337
2338const char *longname (region *reg)
2339 CODE:
2340 RETVAL = reg->longname;
2341 OUTPUT: RETVAL
2342
2343const char *msg (region *reg)
2344 CODE:
2345 RETVAL = reg->msg;
2346 OUTPUT: RETVAL
2347
2348MODULE = cf PACKAGE = cf::living
2349
2350INCLUDE: $PERL genacc living ../include/living.h |
2351

Diff Legend

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