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.10 by root, Fri Aug 25 17:11:53 2006 UTC vs.
Revision 1.40 by root, Sun Sep 3 00:18:42 2006 UTC

… …
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#include <EXTERN.h>
27#include <perl.h>
28#include <XSUB.h>
29
30#undef save_long // clashes with libproto.h
31
32#define PLUGIN_NAME "perl" 26#define PLUGIN_NAME "perl"
33#define PLUGIN_VERSION "cfperl 0.3" 27#define PLUGIN_VERSION "cfperl 0.5"
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 28
45#include <plugin_common.h> 29#include <plugin_common.h>
46#include <sounds.h> 30#include <sounds.h>
47#include <cstdarg> 31#include <cstdarg>
48#include <sproto.h> 32#include <sproto.h>
49 33
50#include "cfperl.h" 34#include "cfperl.h"
35#include "shstr.h"
36
37#include <EXTERN.h>
38#include <perl.h>
39#include <XSUB.h>
51 40
52#include "perlxsi.c" 41#include "perlxsi.c"
53
54static void *globalEventListener (int *type, ...);
55 42
56extern sint64 *levels; // the experience table 43extern sint64 *levels; // the experience table
57 44
58typedef object object_ornull; 45typedef object object_ornull;
59typedef mapstruct mapstruct_ornull; 46typedef mapstruct mapstruct_ornull;
60 47
61typedef double val64; 48typedef double val64;
62#define newSVval64 newSVnv 49#define newSVval64 newSVnv
63#define SvVAL64 SvNV 50#define SvVAL64 SvNV
64 51
65static f_plug_api gethook; 52static f_plug_api gethook = cfapi_get_hooks;
66static f_plug_api registerGlobalEvent; 53static f_plug_api object_set_property = cfapi_object_set_property;
67static f_plug_api unregisterGlobalEvent; 54static f_plug_api object_insert = cfapi_object_insert;
68static f_plug_api systemDirectory; 55
69static f_plug_api object_set_property; 56static bool perl_booted;
70static f_plug_api map_get_map;
71static f_plug_api object_insert;
72 57
73/* this is a stupid way to do things, and awkward to use for plug-in authors */ 58/* this is a stupid way to do things, and awkward to use for plug-in authors */
74typedef struct 59typedef struct
75{ 60{
76 object* who; 61 object* who;
… …
99#define PUSH_PV PUSHcfapi_va(STRING, const char *) 84#define PUSH_PV PUSHcfapi_va(STRING, const char *)
100#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int)))) 85#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int))))
101 86
102////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 87//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
103 88
104// garbage collect some perl objects, if possible
105// all objects no longer referenced and empty are
106// eligible for destruction.
107static void
108clean_obj_cache ()
109{
110 static int count;
111
112 if (++count & 7)
113 return;
114
115 int todo = 1000;
116 do
117 {
118 I32 klen;
119 char *key;
120 HE *he = hv_iternext (obj_cache);
121
122 if (he)
123 {
124 SV *sv = hv_iterval (obj_cache, he);
125
126 // empty and unreferenced? nuke it
127 if (SvREFCNT (sv) == 1 && SvREFCNT (SvRV (sv)) == 1 && !HvFILL ((HV *)(SvRV (sv))))
128 {
129 hv_delete (obj_cache, HeKEY (he), HeKLEN (he), G_DISCARD);
130 todo++;
131 }
132 }
133 else
134 break;
135 }
136 while (--todo);
137}
138
139static SV * 89static SV *
140newSVptr (void *ptr, const char *klass) 90newSVptr (void *ptr, const char *klass, HV *hv = newHV ())
141{ 91{
142 SV *sv; 92 SV *sv;
143 93
144 if (!ptr) 94 if (!ptr)
145 return &PL_sv_undef; 95 return &PL_sv_undef;
146 96
147 sv = (SV *)newHV ();
148 sv_magic (sv, 0, PERL_MAGIC_ext, (char *)ptr, 0); 97 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
149 return sv_bless (newRV_noinc (sv), gv_stashpv (klass, 1)); 98 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
99}
100
101template<class attachable>
102SV *
103newSVattachable (attachable *obj, const char *klass)
104{
105 if (!obj)
106 return &PL_sv_undef;
107
108 if (!obj->self)
109 obj->self = newSVptr (obj, klass);
110
111 return newSVsv (obj->self);
150} 112}
151 113
152static void 114static void
153SVptr_cache_set (void *ptr, SV *sv) 115SVptr_cache_set (void *ptr, SV *sv)
154{ 116{
… …
223{ 185{
224 SV *sv; 186 SV *sv;
225 187
226 switch (type) 188 switch (type)
227 { 189 {
228 // first three exist only for cfapi-compatibility
229 case DT_INT_PTR:
230 sv = newSViv (*va_arg (ap, int *));
231 break;
232
233 case DT_INT64_PTR:
234 sv = newSVval64 ((val64)*va_arg (ap, sint64 *));
235 break;
236
237 case DT_DOUBLE_PTR:
238 sv = newSVnv (*va_arg (ap, double *));
239 break;
240
241 case DT_INT: 190 case DT_INT:
242 sv = newSViv (va_arg (ap, int)); 191 sv = newSViv (va_arg (ap, int));
243 break; 192 break;
244 193
245 case DT_INT64: 194 case DT_INT64:
… …
266 break; 215 break;
267 216
268 case DT_OBJECT: 217 case DT_OBJECT:
269 { 218 {
270 object *obj = va_arg (ap, object *); 219 object *obj = va_arg (ap, object *);
271 220 sv = newSVattachable (obj, obj && obj->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap");
272 if (!obj)
273 sv = &PL_sv_undef;
274 else
275 {
276 if (!obj->self)
277 switch (obj->type)
278 {
279 case MAP:
280 obj->self = static_cast<void *>(newSVptr (obj, "cf::object::map::wrap"));
281 break;
282
283 case PLAYER:
284 obj->self = static_cast<void *>(newSVptr (obj, "cf::object::player::wrap"));
285 break;
286
287 default:
288 obj->self = static_cast<void *>(newSVptr (obj, "cf::object::wrap"));
289 break;
290 }
291
292 sv = newSVsv (static_cast<SV *>(obj->self));
293 }
294 } 221 }
295 break; 222 break;
296 223
297 case DT_MAP: 224 case DT_MAP:
225 // va_arg (object *) when void * is passed is an XSI extension
298 sv = newSVptr (va_arg (ap, mapstruct *), "cf::map::wrap"); 226 sv = newSVattachable (va_arg (ap, mapstruct *), "cf::map::wrap");
299 break; 227 break;
300 228
301 case DT_PLAYER: 229 case DT_PLAYER:
302 sv = newSVptr (va_arg (ap, player *), "cf::player::wrap"); 230 sv = newSVattachable (va_arg (ap, player *), "cf::player::wrap");
303 break; 231 break;
304 232
305 case DT_ARCH: 233 case DT_ARCH:
306 sv = newSVptr (va_arg (ap, archetype *), "cf::arch::wrap"); 234 sv = newSVptr (va_arg (ap, archetype *), "cf::arch::wrap");
307 break; 235 break;
… …
341 va_list ap; 269 va_list ap;
342 va_start (ap, type); 270 va_start (ap, type);
343 271
344 switch (type) 272 switch (type)
345 { 273 {
346 case CFAPI_INT: sv = newSVdt_va (ap, DT_INT_PTR ); break; 274 case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
347 case CFAPI_LONG: sv = newSVdt_va (ap, DT_INT64_PTR ); break; 275 case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
348 case CFAPI_DOUBLE: sv = newSVdt_va (ap, DT_DOUBLE_PTR); break; 276 case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
349 case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break; 277 case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
350 case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break; 278 case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
351 case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break; 279 case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
352 case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break; 280 case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
353 case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break; 281 case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
… …
361 va_end (ap); 289 va_end (ap);
362 290
363 return sv; 291 return sv;
364} 292}
365 293
294//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
295
296SV *
297registry_of (attachable_base *ext)
298{
299 if (!ext->cb)
300 ext->cb = newAV ();
301
302 return newRV_inc ((SV *)ext->cb);
303}
304
305void attachable_base::clear ()
306{
307 if (self)
308 {
309 if (cb)
310 if (SvROK (*av_fetch (cb, EVENT_OBJECT_DESTROY, 1)))
311 INVOKE_OBJECT (DESTROY, static_cast<object *>(this));
312 else if (SvROK (*av_fetch (cb, EVENT_MAP_DESTROY, 1)))
313 INVOKE_MAP (DESTROY, static_cast<mapstruct *>(this));
314
315 // disconnect Perl from C, to avoid crashes
316 sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
317
318 // clear the perl hash, might or might not be a good idea
319 hv_clear ((HV *)SvRV ((SV *)self));
320
321 SvREFCNT_dec (self);
322 self = 0;
323 }
324
325 if (cb)
326 {
327 SvREFCNT_dec (cb);
328 cb = 0;
329 }
330
331 attach = 0;
332}
333
334void attachable_base::optimise ()
335{
336 if (!self)
337 return;
338
339 HV *hv = (HV *)SvRV ((SV *)self);
340
341 if (SvREFCNT ((SV *)self) == 1
342 && SvREFCNT ((SV *)hv) == 1
343 && !HvKEYS (hv))
344 {
345 SvREFCNT_dec ((SV *)self);
346 self = 0;
347 }
348}
349
350void attachable_base::instantiate (data_type type, void *obj)
351{
352 dSP;
353 ENTER;
354 SAVETMPS;
355 PUSHMARK (SP);
356 EXTEND (SP, 2);
357 PUSHs (sv_2mortal (newSVdt (type, obj)));
358 PUSHs (sv_2mortal (newSVpv (attach, 0)));
359
360 attach = 0;
361
362 PUTBACK;
363 call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL);
364 FREETMPS;
365 LEAVE;
366
367 switch (type)
368 {
369 case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
370 case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
371 }
372}
373
366///////////////////////////////////////////////////////////////////////////// 374/////////////////////////////////////////////////////////////////////////////
367 375
376void reattach (data_type type, void *obj)
377{
378 //TODO only do this when the object has _attachment's
379
380 dSP;
381 ENTER;
382 SAVETMPS;
383 PUSHMARK (SP);
384 XPUSHs (sv_2mortal (newSVdt (type, obj)));
385 PUTBACK;
386 call_pv ("cf::reattach", G_DISCARD | G_VOID | G_EVAL);
387 FREETMPS;
388 LEAVE;
389
390 switch (type)
391 {
392 case DT_OBJECT: INVOKE_OBJECT (REATTACH, obj); break;
393 case DT_PLAYER: INVOKE_PLAYER (REATTACH, obj); break;
394 case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
395 }
396}
397
398template<class subclass>
399void reattach (attachable<subclass> *obj)
400{
401 obj->optimise ();
402
403 if (obj->self)
404 reattach ((data_type) cftype<subclass>::dt, (subclass *)obj);
405}
406
407#include "kw_hash.h"
408
409object_freezer::object_freezer ()
410: dynbuf (128 * 1024, 64 * 1024)
411{
412 av = newAV ();
413}
414
415object_freezer::~object_freezer ()
416{
417 SvREFCNT_dec (av);
418}
419
420void object_freezer::put (attachable_base *ext)
421{
422 ext->optimise ();
423
424 if (ext->self)
425 {
426 int idx = AvFILLp ((AV *)av) + 1;
427 av_store (av, idx, SvREFCNT_inc (ext->self));
428
429 add ((void *)"oid ", 4);
430 add ((sint32)idx);
431 add ('\n');
432 }
433}
434
435bool object_freezer::save (const char *filename)
436{
437 dSP;
438 ENTER;
439 SAVETMPS;
440 PUSHMARK (SP);
441 EXTEND (SP, 3);
442 PUSHs (sv_2mortal (newSVpv (filename, 0)));
443 PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
444 PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
445 PUTBACK;
446 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
447 FREETMPS;
448 LEAVE;
449}
450
451int fprintf (object_freezer &freezer, const char *format, ...)
452{
453 va_list ap;
454
455 va_start (ap, format);
456
457 int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
458
459 if (len >= 0)
460 freezer.alloc (len);
461
462 va_end (ap);
463}
464
465int fputs (const char *s, object_freezer &freezer)
466{
467 freezer.add (s);
468}
469
470object_thawer::object_thawer (const char *filename)
471{
472 av = 0;
473 fp = 0;
474
475 if (!filename)
476 return;
477
478 fp = fopen (filename, "r");
479 if (!fp)
480 {
481 LOG (llevError, "object_thawer: unable to open '%s': %s.\n", filename, strerror (errno));
482 return;
483 }
484
485 if (perl_booted)
486 {
487 dSP;
488 ENTER;
489 SAVETMPS;
490 PUSHMARK (SP);
491 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
492 PUTBACK;
493
494 if (0 < call_pv ("cf::object_thawer_load", G_SCALAR | G_EVAL))
495 {
496 SPAGAIN;
497 SV *sv = POPs;
498 if (SvROK (sv))
499 av = (AV *)SvREFCNT_inc (SvRV (sv));
500 }
501
502 FREETMPS;
503 LEAVE;
504 }
505}
506
507void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
508{
509 if (!av || oid < 0) // this is actually an error of sorts
510 return;
511
512 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach
513 ext->clear ();
514
515 SV **svp = av_fetch ((AV *)av, oid, 0);
516
517 if (!svp || !SvROK (*svp))
518 {
519 printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
520 return;
521 }
522
523 ext->self = *svp; *svp = &PL_sv_undef;
524 sv_magic (SvRV (ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
525
526 reattach (type, obj);
527}
528
529object_thawer::~object_thawer ()
530{
531 if (fp) fclose (fp);
532 if (av) SvREFCNT_dec ((AV *)av);
533}
534
535token object_thawer::get_token ()
536{
537#if 0
538 for (;;)
539 {
540 if (!fgets (line, sizeof (line), fp))
541 return token (KW_eof);
542
543 unsigned char *p = (unsigned char *)line;
544
545 while (*p > ' ')
546 p++;
547
548 int len = p - (unsigned char *)line;
549
550 while ((*p - 1) < ' ')
551 p++;
552
553 if (*p)
554 {
555 char *v = p;
556
557 while (*p && *p != '\n')
558 p++;
559
560 *p = 0;
561
562 return token (k, v);
563 }
564 else
565 return token (k);
566 }
567#endif
568}
569
570/////////////////////////////////////////////////////////////////////////////
571
368extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 572extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
369{ 573{
370 gethook = gethooksptr;
371 printf (PLUGIN_VERSION " init\n");
372
373 return 0; 574 return 0;
374} 575}
375 576
376static CommArray_s rtn_cmd; 577static CommArray_s rtn_cmd;
377 578
… …
457extern "C" int cfperl_postInitPlugin () 658extern "C" int cfperl_postInitPlugin ()
458{ 659{
459 int hooktype = 1; 660 int hooktype = 1;
460 int rtype = 0; 661 int rtype = 0;
461 662
462 printf (PLUGIN_VERSION " post init\n");
463
464 registerGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_register_global_event");
465 unregisterGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_unregister_global_event");
466 systemDirectory = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_directory");
467 object_set_property = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_set_property");
468 map_get_map = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_map_get_map");
469 object_insert = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_insert");
470
471 cf_init_plugin (gethook); 663 cf_init_plugin (gethook);
472 664
473 /* Pick the global events you want to monitor from this plugin */
474 registerGlobalEvent (NULL, EVENT_CLOCK, PLUGIN_NAME, globalEventListener);
475 //registerGlobalEvent (NULL, EVENT_CRASH, PLUGIN_NAME, globalEventListener);
476 registerGlobalEvent (NULL, EVENT_FIND_UNARMED_SKILL, PLUGIN_NAME, globalEventListener);
477 registerGlobalEvent (NULL, EVENT_SHOUT, PLUGIN_NAME, globalEventListener);
478 registerGlobalEvent (NULL, EVENT_TELL, PLUGIN_NAME, globalEventListener);
479 registerGlobalEvent (NULL, EVENT_MUZZLE, PLUGIN_NAME, globalEventListener);
480 registerGlobalEvent (NULL, EVENT_KICK, PLUGIN_NAME, globalEventListener);
481
482 return 0; 665 return 0;
483}
484
485static void *
486globalEventListener (int *type, ...)
487{
488 va_list args;
489 static int rv;
490 int event_code;
491
492 if (!perl)
493 return NULL;
494
495 va_start (args, type);
496 event_code = va_arg (args, int);
497
498 if (event_code == EVENT_CLOCK)
499 {
500 clean_obj_cache ();
501 }
502 else
503 {
504 dSP;
505
506 ENTER;
507 SAVETMPS;
508
509 PUSHMARK (SP);
510
511 EXTEND (SP, 10);
512 PUSHs (sv_2mortal (newSViv (event_code)));
513
514 switch (event_code)
515 {
516 case EVENT_CRASH:
517 break;
518
519 case EVENT_SHOUT:
520 case EVENT_MUZZLE:
521 case EVENT_KICK:
522 PUSH_OB;
523 PUSH_PV;
524 break;
525
526 case EVENT_FIND_UNARMED_SKILL:
527 PUSH_OB;
528 break;
529
530 case EVENT_TELL:
531 break;
532 }
533
534 va_end (args);
535
536 PUTBACK;
537 int count = call_pv ("cf::inject_global_event", G_SCALAR | G_EVAL);
538 SPAGAIN;
539
540 if (SvTRUE (ERRSV))
541 LOG (llevError, "global event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
542
543 rv = count > 0 ? POPi : 0;
544
545 PUTBACK;
546 FREETMPS;
547 LEAVE;
548 }
549
550 return &rv;
551}
552
553extern "C" void *cfperl_eventListener (int *type, ...)
554{
555 static int rv;
556 va_list args;
557 int event_code;
558 object *who, *activator, *third, *event;
559 char *message, *extension, *options;
560
561 if (!perl)
562 return NULL;
563
564 va_start (args, type);
565 who = va_arg (args, object *);
566 event_code = va_arg (args, int);
567 activator = va_arg (args, object *);
568 third = va_arg (args, object *);
569 message = va_arg (args, char *);
570 va_arg (args, int); // fix yourself
571 extension = va_arg (args, char *);
572 options = va_arg (args, char *);
573 event = va_arg (args, object *);
574 va_end (args);
575
576 {
577 dSP;
578
579 ENTER;
580 SAVETMPS;
581
582 PUSHMARK (SP);
583 EXTEND (SP, 10);
584
585 PUSHcfapi (STRING, extension);
586 PUSHs (sv_2mortal (newSViv (event_code)));
587
588 PUSHcfapi (POBJECT, event);
589 PUSHcfapi (POBJECT, who);
590
591 switch (event_code)
592 {
593 case EVENT_STOP: // $ob (e.g. arrow)
594 case EVENT_TIME: // $ob
595 case EVENT_TIMER: // $ob
596 break;
597
598 case EVENT_APPLY: // $ob, $who
599 case EVENT_DROP: // $ob, $who
600 case EVENT_CLOSE: // $ob, $who
601 case EVENT_MOVE: // $ob, $enemy
602 case EVENT_THROW: // $ob, $thrower
603 PUSHcfapi (POBJECT, activator);
604 break;
605
606 case EVENT_DROP_ON: // $ob, $who, $what
607 case EVENT_ATTACK: // $ob, $who, $victim (?? please god enlighten me)
608 PUSHcfapi (POBJECT, activator);
609 PUSHcfapi (POBJECT, third);
610 break;
611
612 case EVENT_TRIGGER: // $ob, $originator, [$victim], [$msg]
613 PUSHcfapi (POBJECT, activator);
614 PUSHcfapi (POBJECT, third);
615 PUSHcfapi (POBJECT, message);
616 break;
617
618 case EVENT_SAY: // $ob, $who, $msg
619 PUSHcfapi (POBJECT, activator);
620 PUSHcfapi (STRING, message);
621 break;
622
623 default:
624 LOG (llevError, "perl plugin called for unsupported event type %d", event_code);
625 break;
626 }
627
628 PUTBACK;
629 int count = call_pv ("cf::inject_event", G_SCALAR | G_EVAL);
630 SPAGAIN;
631
632 if (SvTRUE (ERRSV))
633 LOG (llevError, "event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
634
635 rv = count > 0 ? POPi : 0;
636
637 PUTBACK;
638 FREETMPS;
639 LEAVE;
640 }
641
642 return &rv;
643} 666}
644 667
645extern "C" int cfperl_closePlugin () 668extern "C" int cfperl_closePlugin ()
646{ 669{
647 return 0; 670 return 0;
648} 671}
649 672
650void 673void
651cfperl_init () 674cfperl_init ()
652{ 675{
676 PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);
677 perl = perl_alloc ();
678 perl_construct (perl);
679
680 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
681
653 char *argv[] = { 682 char *argv[] = {
654 "", 683 "",
655 "-e" 684 "-e"
656 "BEGIN {"
657 " cf->bootstrap;" 685 "cf->bootstrap;"
658 " unshift @INC, cf::datadir ();" 686 "unshift @INC, cf::datadir ();"
659 "}"
660 ""
661 "use cf;"
662 }; 687 };
663
664 perl = perl_alloc ();
665 perl_construct (perl);
666
667 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
668 688
669 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl)) 689 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))
670 { 690 {
671 printf ("unable to initialize perl-interpreter, aborting.\n"); 691 printf ("unable to initialize perl-interpreter, aborting.\n");
672
673 exit (EXIT_FAILURE); 692 exit (EXIT_FAILURE);
674 //perl_destruct (perl);
675 //perl_free (perl);
676 //perl = 0;
677 //return;
678 } 693 }
679 694
680 obj_cache = newHV (); 695 obj_cache = newHV ();
696}
697
698void cfperl_boot ()
699{
700 perl_booted = true;
701
702 eval_pv ("require cf", 1);
681} 703}
682 704
683void cfperl_main () 705void cfperl_main ()
684{ 706{
685 dSP; 707 dSP;
686 708
687 PUSHMARK (SP); 709 PUSHMARK (SP);
688 PUTBACK; 710 PUTBACK;
689 call_pv ("cf::main", G_DISCARD | G_VOID); 711 call_pv ("cf::main", G_DISCARD | G_VOID);
690}
691
692void cfperl_free_ob (object *op)
693{
694 if (op->self) fprintf (stderr, "free_ob_self %p %s\n", op, op->name);//D
695 if (op->self) SvREFCNT_dec (op->self), op->self = 0;
696 if (op->cb) SvREFCNT_dec (op->cb), op->cb = 0;
697} 712}
698 713
699static event_klass klass_of[NUM_EVENT_TYPES] = { 714static event_klass klass_of[NUM_EVENT_TYPES] = {
700# define def(type,name) KLASS_ ## type, 715# define def(type,name) KLASS_ ## type,
701# include "eventinc.h" 716# include "eventinc.h"
702# undef def 717# undef def
703}; 718};
719
720#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
704 721
705static void 722static void
706gather_callbacks (AV *&callbacks, AV *registry, event_type event) 723gather_callbacks (AV *&callbacks, AV *registry, event_type event)
707{ 724{
708 // event must be in array 725 // event must be in array
… …
751 // 2a. per-type callback 768 // 2a. per-type callback
752 // 4. global callbacks 769 // 4. global callbacks
753 770
754 gather_callbacks (callbacks, cb_global, event); 771 gather_callbacks (callbacks, cb_global, event);
755 772
756 switch (klass_of [event]) 773 switch (KLASS_OF (event))
757 { 774 {
758 case KLASS_GLOBAL: 775 case KLASS_GLOBAL:
759 break; 776 break;
760 777
761 case KLASS_OBJECT: 778 case KLASS_OBJECT:
762 dt = (data_type) va_arg (ap, int); 779 dt = (data_type) va_arg (ap, int);
763 assert (("first argument must be of type object", dt == DT_OBJECT)); 780 assert (("first argument must be of type object", dt == DT_OBJECT));
764
765 op = va_arg (ap, object *); 781 op = va_arg (ap, object *);
766 782
783 if (op->cb)
784 gather_callbacks (callbacks, op->cb, event);
785
786 if (op->type)
787 {
788 if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
789 {
790 SV *registry = AvARRAY (cb_type)[op->type + op->subtype * NUM_SUBTYPES];
791
792 if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
793 gather_callbacks (callbacks, (AV *)SvRV (registry), event);
794 }
795
796 if (op->type <= AvFILLp (cb_type))
797 {
798 SV *registry = AvARRAY (cb_type)[op->type];
799
800 if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
801 gather_callbacks (callbacks, (AV *)SvRV (registry), event);
802 }
803 }
804
767 gather_callbacks (callbacks, cb_object, event); 805 gather_callbacks (callbacks, cb_object, event);
768 //TODO: per-object
769
770 if (op->type > 0 && op->type <= AvFILLp (cb_type))
771 {
772 SV *registry = AvARRAY (cb_type)[op->type];
773
774 if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
775 gather_callbacks (callbacks, (AV *)SvRV (registry), event);
776 }
777 806
778 break; 807 break;
779 808
780 case KLASS_PLAYER: 809 case KLASS_PLAYER:
781 dt = (data_type) va_arg (ap, int); 810 dt = (data_type) va_arg (ap, int);
782 assert (("first argument must be of type player", dt == DT_PLAYER)); 811 assert (("first argument must be of type player", dt == DT_PLAYER));
783
784 pl = va_arg (ap, player *); 812 pl = va_arg (ap, player *);
813
814 if (pl->cb)
815 gather_callbacks (callbacks, pl->cb, event);
816
785 gather_callbacks (callbacks, cb_player, event); 817 gather_callbacks (callbacks, cb_player, event);
786 break; 818 break;
787 819
788 case KLASS_MAP: 820 case KLASS_MAP:
789 dt = (data_type) va_arg (ap, int); 821 dt = (data_type) va_arg (ap, int);
790 assert (("first argument must be of type object", dt == DT_MAP)); 822 assert (("first argument must be of type object", dt == DT_MAP));
791
792 map = va_arg (ap, mapstruct *); 823 map = va_arg (ap, mapstruct *);
824
825 if (map->cb)
826 gather_callbacks (callbacks, map->cb, event);
827
793 gather_callbacks (callbacks, cb_map, event); 828 gather_callbacks (callbacks, cb_map, event);
794 break; 829 break;
795 830
796 default: 831 default:
797 assert (("unsupported event klass in cfperl_invoke", 0)); 832 assert (("unsupported event klass in cfperl_invoke", 0));
… …
809 EXTEND (SP, 3); 844 EXTEND (SP, 3);
810 845
811 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays 846 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays
812 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks))); 847 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));
813 848
814 switch (klass_of [event]) 849 switch (KLASS_OF (event))
815 { 850 {
816 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break; 851 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;
817 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break; 852 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;
818 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break; 853 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;
819 } 854 }
… …
823 dt = (data_type) va_arg (ap, int); 858 dt = (data_type) va_arg (ap, int);
824 859
825 if (dt == DT_END) 860 if (dt == DT_END)
826 break; 861 break;
827 862
863 if (dt == DT_AV)
864 {
865 AV *av = va_arg (ap, AV *);
866
867 for (int i = 0; i <= av_len (av); ++i)
868 XPUSHs (*av_fetch (av, i, 1));
869 }
870 else
828 XPUSHs (sv_2mortal (newSVdt_va (ap, dt))); 871 XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
829 } 872 }
830 873
831 va_end (ap); 874 va_end (ap);
832 875
833 PUTBACK; 876 PUTBACK;
834 int count = call_pv ("cf::invoke", G_SCALAR | G_EVAL); 877 int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
835 SPAGAIN; 878 SPAGAIN;
836 879
837 count = count > 0 ? POPi : 0; 880 count = count > 0 ? POPi : 0;
838 881
839 FREETMPS; 882 FREETMPS;
840 LEAVE; 883 LEAVE;
841 884
842 return count; 885 return count;
886}
887
888SV *
889cfperl_result (int idx)
890{
891 AV *av = get_av ("cfperl::invoke_results", 0);
892 if (!av)
893 return &PL_sv_undef;
894
895 SV **sv = av_fetch (av, idx, 0);
896 if (!sv)
897 return &PL_sv_undef;
898
899 return *sv;
900}
901
902int
903cfperl_result_INT (int idx)
904{
905 return SvIV (cfperl_result (idx));
843} 906}
844 907
845MODULE = cf PACKAGE = cf PREFIX = cf_ 908MODULE = cf PACKAGE = cf PREFIX = cf_
846 909
847BOOT: 910BOOT:
… …
981 const_iv (BUILDER) 1044 const_iv (BUILDER)
982 const_iv (MATERIAL) 1045 const_iv (MATERIAL)
983 const_iv (ITEM_TRANSFORMER) 1046 const_iv (ITEM_TRANSFORMER)
984 const_iv (QUEST) 1047 const_iv (QUEST)
985 1048
1049 const_iv (NUM_SUBTYPES)
1050
986 const_iv (ST_BD_BUILD) 1051 const_iv (ST_BD_BUILD)
987 const_iv (ST_BD_REMOVE) 1052 const_iv (ST_BD_REMOVE)
988 1053
989 const_iv (ST_MAT_FLOOR) 1054 const_iv (ST_MAT_FLOOR)
990 const_iv (ST_MAT_WALL) 1055 const_iv (ST_MAT_WALL)
… …
1218 1283
1219 const_iv (SK_EXP_ADD_SKILL) 1284 const_iv (SK_EXP_ADD_SKILL)
1220 const_iv (SK_EXP_TOTAL) 1285 const_iv (SK_EXP_TOTAL)
1221 const_iv (SK_EXP_NONE) 1286 const_iv (SK_EXP_NONE)
1222 const_iv (SK_SUBTRACT_SKILL_EXP) 1287 const_iv (SK_SUBTRACT_SKILL_EXP)
1288 const_iv (SK_EXP_SKILL_ONLY)
1223 1289
1224 const_iv (SK_LOCKPICKING) 1290 const_iv (SK_LOCKPICKING)
1225 const_iv (SK_HIDING) 1291 const_iv (SK_HIDING)
1226 const_iv (SK_SMITHERY) 1292 const_iv (SK_SMITHERY)
1227 const_iv (SK_BOWYER) 1293 const_iv (SK_BOWYER)
… …
1338 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1404 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1339 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 1405 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1340 1406
1341 static const struct { 1407 static const struct {
1342 const char *name; 1408 const char *name;
1409 int skip;
1343 IV klass; 1410 IV klass;
1344 IV iv; 1411 IV iv;
1345 } *eiv, event_iv[] = { 1412 } *eiv, event_iv[] = {
1346# define def(klass,name) { # name, (IV)KLASS_ ## klass, (IV)EV_ ## klass ## _ ## name }, 1413# define def(klass,name) { "EVENT_" # klass "_" # name, sizeof ("EVENT_" # klass), (IV)KLASS_ ## klass, (IV)EVENT_ ## klass ## _ ## name },
1347# include "eventinc.h" 1414# include "eventinc.h"
1348# undef def 1415# undef def
1349 }; 1416 };
1350 1417
1351 AV *av = get_av ("cf::EVENT", 1); 1418 AV *av = get_av ("cf::EVENT", 1);
1352 1419
1353 for (eiv = event_iv + sizeof (event_iv) / sizeof (event_iv [0]); eiv-- > event_iv; ) 1420 for (eiv = event_iv + sizeof (event_iv) / sizeof (event_iv [0]); eiv-- > event_iv; )
1354 { 1421 {
1355 AV *event = newAV (); 1422 AV *event = newAV ();
1356 av_push (event, newSVpv ((char *)eiv->name, 0)); 1423 av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1357 av_push (event, newSViv (eiv->klass)); 1424 av_push (event, newSViv (eiv->klass));
1358 av_store (av, eiv->iv, newRV_noinc ((SV *)event)); 1425 av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1426 newCONSTSUB (stash, (char *)eiv->name, newSViv (eiv->iv));
1359 } 1427 }
1360
1361 static const struct {
1362 const char *name;
1363 IV iv;
1364 } *event, event_list[] = {
1365# define const_event(name) { # name, (IV)EVENT_ ## name },
1366 const_event (NONE)
1367 const_event (APPLY)
1368 const_event (ATTACK)
1369 const_event (DROP)
1370 const_event (DROP_ON)
1371 const_event (PICKUP)
1372 const_event (SAY)
1373 const_event (STOP)
1374 const_event (TIME)
1375 const_event (THROW)
1376 const_event (TRIGGER)
1377 const_event (CLOSE)
1378 const_event (TIMER)
1379 const_event (MOVE)
1380
1381 //const_event (CLOCK)
1382 const_event (CRASH)
1383 const_event (SHOUT)
1384 const_event (TELL)
1385 const_event (MUZZLE)
1386 const_event (KICK)
1387 const_event (FIND_UNARMED_SKILL)
1388 //const_event (FREE_OB)
1389 };
1390
1391 av = get_av ("cf::PLUGIN_EVENT", 1);
1392
1393 for (event = event_list + sizeof (event_list) / sizeof (event_list [0]); event-- > event_list; )
1394 av_store (av, event->iv, newSVpv ((char *)event->name, 0));
1395 1428
1396 static const struct { 1429 static const struct {
1397 int dtype; 1430 int dtype;
1398 const char *name; 1431 const char *name;
1399 IV idx; 1432 IV idx;
… …
1419 prop (CFAPI_INT, MAP_PROP_WINDDIR) 1452 prop (CFAPI_INT, MAP_PROP_WINDDIR)
1420 prop (CFAPI_INT, MAP_PROP_SKY) 1453 prop (CFAPI_INT, MAP_PROP_SKY)
1421 prop (CFAPI_INT, MAP_PROP_WPARTX) 1454 prop (CFAPI_INT, MAP_PROP_WPARTX)
1422 prop (CFAPI_INT, MAP_PROP_WPARTY) 1455 prop (CFAPI_INT, MAP_PROP_WPARTY)
1423 prop (CFAPI_STRING, MAP_PROP_MESSAGE) 1456 prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1424 prop (CFAPI_PMAP, MAP_PROP_NEXT)
1425 prop (CFAPI_PREGION, MAP_PROP_REGION) 1457 prop (CFAPI_PREGION, MAP_PROP_REGION)
1426 prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1427 prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1428 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB) 1458 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1429 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB) 1459 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1430 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY) 1460 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1431 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT) 1461 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1432 prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1433 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER) 1462 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1434 prop (CFAPI_PMAP, OBJECT_PROP_MAP) 1463 prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1435 prop (CFAPI_INT, OBJECT_PROP_COUNT) 1464 prop (CFAPI_INT, OBJECT_PROP_COUNT)
1436 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT) 1465 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1437 prop (CFAPI_STRING, OBJECT_PROP_NAME) 1466 prop (CFAPI_STRING, OBJECT_PROP_NAME)
… …
1527 { 1556 {
1528 hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0); 1557 hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0);
1529 hv_store (prop_idx, cprop->name, strlen (cprop->name), newSViv (cprop->idx ), 0); 1558 hv_store (prop_idx, cprop->name, strlen (cprop->name), newSViv (cprop->idx ), 0);
1530 } 1559 }
1531 1560
1532 cb_global = get_av ("cf::CB_GLOBAL", 1);
1533 cb_object = get_av ("cf::CB_OBJECT", 1);
1534 cb_player = get_av ("cf::CB_PLAYER", 1);
1535 cb_type = get_av ("cf::CB_TYPE" , 1);
1536 cb_map = get_av ("cf::CB_MAP" , 1);
1537
1538 //I_EVENT_API (PACKAGE); 1561 //I_EVENT_API (PACKAGE);
1562}
1563
1564void _reload_1 ()
1565 CODE:
1566 cb_global = get_av ("cf::CB_GLOBAL", 1);
1567 cb_object = get_av ("cf::CB_OBJECT", 1);
1568 cb_player = get_av ("cf::CB_PLAYER", 1);
1569 cb_type = get_av ("cf::CB_TYPE" , 1);
1570 cb_map = get_av ("cf::CB_MAP" , 1);
1571
1572void _reload_2 ()
1573 CODE:
1574{
1575 // reattach to all attachable objects in the game.
1576 for (player *pl = first_player; pl; pl = pl->next)
1577 reattach (pl);
1578
1579 for (mapstruct *map = first_map; map; map = map->next)
1580 reattach (map);
1581
1582 for (object *op = objects; op; op = op->next)
1583 reattach (op);
1539} 1584}
1540 1585
1541NV floor (NV x) 1586NV floor (NV x)
1542 1587
1543NV ceil (NV x) 1588NV ceil (NV x)
… …
1553 PROTOTYPE: $$ 1598 PROTOTYPE: $$
1554 1599
1555char *path_combine_and_normalize (char *base, char *path) 1600char *path_combine_and_normalize (char *base, char *path)
1556 PROTOTYPE: $$ 1601 PROTOTYPE: $$
1557 1602
1558char * 1603const char *
1559cf_get_maps_directory (char *path) 1604get_maps_directory (char *path)
1560 PROTOTYPE: $ 1605 PROTOTYPE: $
1561 ALIAS: maps_directory = 0 1606 ALIAS: maps_directory = 0
1607 CODE:
1608 RETVAL = create_pathname (path);
1609 OUTPUT: RETVAL
1562 1610
1563void 1611void
1564sub_generation_inc () 1612sub_generation_inc ()
1565 CODE: 1613 CODE:
1566 PL_sub_generation++; 1614 PL_sub_generation++;
… …
1575 confdir = 3 1623 confdir = 3
1576 localdir = 4 1624 localdir = 4
1577 playerdir = 5 1625 playerdir = 5
1578 datadir = 6 1626 datadir = 6
1579 CODE: 1627 CODE:
1580{ 1628 switch (ix)
1581 int unused_type; 1629 {
1582 RETVAL = (char *)systemDirectory (&unused_type, ix); 1630 case 0: RETVAL = settings.mapdir ; break;
1583} 1631 case 1: RETVAL = settings.uniquedir; break;
1632 case 2: RETVAL = settings.tmpdir ; break;
1633 case 3: RETVAL = settings.confdir ; break;
1634 case 4: RETVAL = settings.localdir ; break;
1635 case 5: RETVAL = settings.playerdir; break;
1636 case 6: RETVAL = settings.datadir ; break;
1637 }
1584 OUTPUT: RETVAL 1638 OUTPUT: RETVAL
1585 1639
1586int 1640int
1587cf_find_animation (char *text) 1641cf_find_animation (char *text)
1588 PROTOTYPE: $ 1642 PROTOTYPE: $
1589 1643
1590int random_roll(int min, int max, object *op, int goodbad); 1644int random_roll(int min, int max, object *op, int goodbad);
1591 1645
1592const char *cost_string_from_value(uint64 cost, int approx = 0) 1646const char *cost_string_from_value(uint64 cost, int approx = 0)
1647
1648int invoke (int event, ...)
1649 CODE:
1650 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1651 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1652 for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1653 RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1654 OUTPUT: RETVAL
1593 1655
1594int 1656int
1595exp_to_level (val64 exp) 1657exp_to_level (val64 exp)
1596 CODE: 1658 CODE:
1597{ 1659{
… …
1628 RETVAL = newSVpv (resist_plus[atnr], 0); 1690 RETVAL = newSVpv (resist_plus[atnr], 0);
1629 else 1691 else
1630 XSRETURN_UNDEF; 1692 XSRETURN_UNDEF;
1631 OUTPUT: RETVAL 1693 OUTPUT: RETVAL
1632 1694
1695int
1696_valid (SV *obj)
1697 CODE:
1698 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1699 OUTPUT:
1700 RETVAL
1701
1633MODULE = cf PACKAGE = cf::object PREFIX = cf_object_ 1702MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1703
1704int invoke (object *op, int event, ...)
1705 CODE:
1706 if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1707 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1708 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1709 RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));
1710 OUTPUT: RETVAL
1711
1712SV *registry (object *op)
1713 CODE:
1714 RETVAL = registry_of (op);
1715 OUTPUT:
1716 RETVAL
1717
1718object *head (object *op)
1719 PROTOTYPE: $
1720 ALIAS:
1721 more = 1
1722 above = 2
1723 below = 3
1724 CODE:
1725 switch (ix)
1726 {
1727 case 0: RETVAL = op->head ? op->head : op; break; // DOH!
1728 case 1: RETVAL = op->more; break;
1729 case 2: RETVAL = op->above; break;
1730 case 3: RETVAL = op->below; break;
1731 }
1732 OUTPUT:
1733 RETVAL
1634 1734
1635SV * 1735SV *
1636get_property (object *obj, int type, int idx) 1736get_property (object *obj, int type, int idx)
1637 CODE: 1737 CODE:
1638 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx)); 1738 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));
… …
1717 1817
1718int need_identify (const object *obj); 1818int need_identify (const object *obj);
1719 1819
1720int apply_shop_mat (object *shop_mat, object *op); 1820int apply_shop_mat (object *shop_mat, object *op);
1721 1821
1722void cf_object_move (object *op, int dir, object *originator = op) 1822int move (object *op, int dir, object *originator = op)
1823 CODE:
1824 RETVAL = move_ob (op, dir, originator);
1825 OUTPUT:
1826 RETVAL
1723 1827
1724void cf_object_apply (object *op, object *author, int flags = 0) 1828void cf_object_apply (object *op, object *author, int flags = 0)
1725 1829
1726void cf_object_apply_below (object *op) 1830void cf_object_apply_below (object *op)
1727 1831
… …
1768int cf_object_out_of_map (object *op, int x, int y) 1872int cf_object_out_of_map (object *op, int x, int y)
1769 1873
1770void cf_object_drop (object *op, object *author) 1874void cf_object_drop (object *op, object *author)
1771 1875
1772void cf_object_take (object *op, object *author) 1876void cf_object_take (object *op, object *author)
1773
1774void cf_object_say (object *op, char *msg)
1775
1776void cf_object_speak (object *op, char *msg)
1777 1877
1778object *cf_object_insert_object (object *op, object *container) 1878object *cf_object_insert_object (object *op, object *container)
1779 1879
1780const char *cf_object_get_msg (object *ob) 1880const char *cf_object_get_msg (object *ob)
1781 ALIAS: msg = 0 1881 ALIAS: msg = 0
… …
1915 2015
1916void cf_player_set_party (object *op, partylist *party) 2016void cf_player_set_party (object *op, partylist *party)
1917 2017
1918void kill_player (object *op) 2018void kill_player (object *op)
1919 2019
1920MODULE = cf PACKAGE = cf::object::map PREFIX = cf_
1921
1922MODULE = cf PACKAGE = cf::player PREFIX = cf_player_ 2020MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
2021
2022int invoke (player *pl, int event, ...)
2023 CODE:
2024 if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2025 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2026 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2027 RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));
2028 OUTPUT: RETVAL
2029
2030SV *registry (player *pl)
2031 CODE:
2032 RETVAL = registry_of (pl);
2033 OUTPUT:
2034 RETVAL
1923 2035
1924player *cf_player_find (char *name) 2036player *cf_player_find (char *name)
1925 PROTOTYPE: $ 2037 PROTOTYPE: $
1926 2038
1927void cf_player_move (player *pl, int dir) 2039void cf_player_move (player *pl, int dir)
… …
2046 OUTPUT: RETVAL 2158 OUTPUT: RETVAL
2047 2159
2048 2160
2049MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2161MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2050 2162
2163mapstruct *first ()
2164 PROTOTYPE:
2165 CODE:
2166 RETVAL = first_map;
2167 OUTPUT: RETVAL
2168
2169mapstruct *next (mapstruct *map)
2170 PROTOTYPE:
2171 CODE:
2172 RETVAL = map->next;
2173 OUTPUT: RETVAL
2174
2175int invoke (mapstruct *map, int event, ...)
2176 CODE:
2177 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2178 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2179 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2180 RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));
2181 OUTPUT: RETVAL
2182
2183SV *registry (mapstruct *map)
2184 CODE:
2185 RETVAL = registry_of (map);
2186 OUTPUT:
2187 RETVAL
2188
2051SV * 2189SV *
2052get_property (mapstruct *obj, int type, int idx) 2190get_property (mapstruct *obj, int type, int idx)
2053 CODE: 2191 CODE:
2054 RETVAL = newSVcfapi (type, cf_map_get_property (obj, idx)); 2192 RETVAL = newSVcfapi (type, cf_map_get_property (obj, idx));
2055 OUTPUT: RETVAL 2193 OUTPUT: RETVAL
… …
2068 2206
2069mapstruct *new (int width, int height) 2207mapstruct *new (int width, int height)
2070 PROTOTYPE: 2208 PROTOTYPE:
2071 CODE: 2209 CODE:
2072{ 2210{
2073 int unused_type; 2211 RETVAL = get_empty_map (width, height);
2074 RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
2075} 2212}
2076 OUTPUT: 2213 OUTPUT:
2077 RETVAL 2214 RETVAL
2078 2215
2079void delete_map (mapstruct *map) 2216void delete_map (mapstruct *map)
… …
2094 XSRETURN_UNDEF; 2231 XSRETURN_UNDEF;
2095 RETVAL = map->tile_path [dir]; 2232 RETVAL = map->tile_path [dir];
2096 OUTPUT: 2233 OUTPUT:
2097 RETVAL 2234 RETVAL
2098 2235
2099mapstruct *cf_map_get_map (char *name) 2236mapstruct *ready_map_name (char *name, int flags = 0)
2100 PROTOTYPE: $ 2237 PROTOTYPE: $;$
2101 ALIAS: map = 0 2238 ALIAS:
2239 find = 0
2240 get_map = 1
2102 2241
2103mapstruct *has_been_loaded (char *name) 2242mapstruct *has_been_loaded (char *name)
2104 PROTOTYPE: $ 2243 PROTOTYPE: $
2105
2106mapstruct *cf_map_get_first ()
2107 PROTOTYPE:
2108 ALIAS: first = 0
2109 2244
2110# whoever "designed" the plug-in api should have wasted 2245# whoever "designed" the plug-in api should have wasted
2111# his/her time with staying away from the project - would have 2246# his/her time with staying away from the project - would have
2112# saved others a lot of time, without doubt. 2247# saved others a lot of time, without doubt.
2113void set_path (mapstruct *where, char *path) 2248void set_path (mapstruct *where, char *path)
… …
2128 2263
2129void set_unique (mapstruct *map, bool unique) 2264void set_unique (mapstruct *map, bool unique)
2130 CODE: 2265 CODE:
2131 map->unique = unique; 2266 map->unique = unique;
2132 2267
2268void
2269trigger (mapstruct *map, long connection, bool state = true)
2270 CODE:
2271 activate_connection (map, connection, state);
2272
2273void
2274get_connection (mapstruct *map, long connection)
2275 PPCODE:
2276 oblinkpt *obp = get_connection_links (map, connection);
2277 if (obp)
2278 for (objectlink *ol = obp->link; ol; ol = ol->next)
2279 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, ol->ob)));
2280
2133object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags) 2281object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags)
2134 2282
2135object *cf_map_insert_object (mapstruct *where, object* op, int x, int y) 2283object *cf_map_insert_object (mapstruct *where, object* op, int x, int y)
2136 2284
2137object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny) 2285object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny)
… …
2141cf_map_normalise (mapstruct *map, int x, int y) 2289cf_map_normalise (mapstruct *map, int x, int y)
2142 PPCODE: 2290 PPCODE:
2143{ 2291{
2144 mapstruct *nmap = 0; 2292 mapstruct *nmap = 0;
2145 I16 nx = 0, ny = 0; 2293 I16 nx = 0, ny = 0;
2146 int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2294 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2147 2295
2148 EXTEND (SP, 4); 2296 EXTEND (SP, 4);
2149 PUSHs (sv_2mortal (newSViv (flags))); 2297 PUSHs (sv_2mortal (newSViv (flags)));
2150 2298
2151 if (GIMME_V == G_ARRAY) 2299 if (GIMME_V == G_ARRAY)
… …
2163{ 2311{
2164 object *o; 2312 object *o;
2165 mapstruct *nmap = 0; 2313 mapstruct *nmap = 0;
2166 I16 nx, ny; 2314 I16 nx, ny;
2167 2315
2168 cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2316 get_map_flags (map, &nmap, x, y, &nx, &ny);
2169 2317
2170 if (nmap) 2318 if (nmap)
2171 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above) 2319 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2172 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o))); 2320 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2173} 2321}
… …
2198 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break; 2346 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2199 } 2347 }
2200 OUTPUT: 2348 OUTPUT:
2201 RETVAL 2349 RETVAL
2202 2350
2203# "serialise" map perl data into a ref
2204void
2205_get_obs (mapstruct *map)
2206 PPCODE:
2207{
2208 object *o;
2209 int x, y;
2210 AV *obs = newAV ();
2211 int nonnull = 0;
2212 2351
2213 for (y = 0; y < MAP_HEIGHT (map); y++) 2352MODULE = cf PACKAGE = cf::arch
2214 for (x = 0; x < MAP_WIDTH (map); x++)
2215 {
2216 AV *av = newAV ();
2217 2353
2218 for (o = GET_MAP_OB (map, x, y); o; o = o->above) 2354archetype *find (const char *name)
2219 { 2355 CODE:
2220 SV *sv = SVptr_cache_get (o); 2356 RETVAL = find_archetype (name);
2357 OUTPUT:
2358 RETVAL
2221 2359
2222 if (sv && HvFILL (SvRV (sv))) 2360archetype *first()
2223 {
2224 nonnull = 1;
2225 sv = newSVsv (sv);
2226 }
2227 else
2228 sv = &PL_sv_undef;
2229
2230 av_push (av, sv);
2231 }
2232
2233 av_store (obs, x + y * MAP_HEIGHT (map), newRV_noinc ((SV *)av));
2234 }
2235
2236 if (nonnull)
2237 XPUSHs (sv_2mortal (newRV_noinc ((SV *)obs)));
2238 else
2239 SvREFCNT_dec (obs);
2240}
2241
2242# "deserialise" perl map data into the map
2243void
2244_set_obs (mapstruct *map, SV *sv)
2245 CODE:
2246{
2247 object *o;
2248 AV *av;
2249 int x, y;
2250 AV *obs = (AV *)SvRV (sv);
2251
2252 for (y = 0; y < MAP_HEIGHT (map); y++)
2253 for (x = 0; x < MAP_WIDTH (map); x++)
2254 {
2255 sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);
2256
2257 if (!SvROK (sv))
2258 continue;
2259
2260 av = (AV *)SvRV (sv);
2261
2262 for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2263 {
2264 sv = av_shift (av);
2265
2266 if (SvROK (sv))
2267 {
2268 sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2269 SVptr_cache_set (o, sv);
2270 }
2271 }
2272 }
2273}
2274
2275
2276MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_
2277
2278archetype *cf_archetype_get_first()
2279 PROTOTYPE: 2361 PROTOTYPE:
2280 ALIAS: first = 0 2362 CODE:
2363 RETVAL = first_archetype;
2364 OUTPUT: RETVAL
2281 2365
2282archetype *cf_archetype_get_next (archetype *arch) 2366archetype *next (archetype *arch)
2283 ALIAS: next = 0 2367 CODE:
2368 RETVAL = arch->next;
2369 OUTPUT: RETVAL
2284 2370
2285archetype *cf_archetype_get_head (archetype *arch) 2371archetype *head (archetype *arch)
2286 ALIAS: head = 0 2372 CODE:
2373 RETVAL = arch->head;
2374 OUTPUT: RETVAL
2287 2375
2288archetype *cf_archetype_get_more (archetype *arch) 2376archetype *more (archetype *arch)
2289 ALIAS: more = 0 2377 CODE:
2378 RETVAL = arch->more;
2379 OUTPUT: RETVAL
2290 2380
2291const char *cf_archetype_get_name (archetype *arch) 2381const char *name (archetype *arch)
2292 ALIAS: name = 0 2382 CODE:
2383 RETVAL = arch->name;
2384 OUTPUT: RETVAL
2293 2385
2294object *cf_archetype_get_clone (archetype *arch) 2386object *clone (archetype *arch)
2295 ALIAS: clone = 0 2387 CODE:
2388 RETVAL = &arch->clone;
2389 OUTPUT: RETVAL
2296 2390
2297MODULE = cf PACKAGE = cf::party PREFIX = cf_party_ 2391MODULE = cf PACKAGE = cf::party
2298 2392
2299partylist *cf_party_get_first () 2393partylist *first ()
2300 PROTOTYPE: 2394 PROTOTYPE:
2301 ALIAS: first = 0 2395 CODE:
2396 RETVAL = get_firstparty ();
2397 OUTPUT: RETVAL
2302 2398
2303partylist *cf_party_get_next (partylist *party) 2399partylist *next (partylist *party)
2304 ALIAS: next = 0 2400 CODE:
2401 RETVAL = party->next;
2402 OUTPUT: RETVAL
2305 2403
2306const char *cf_party_get_name (partylist *party) 2404const char *name (partylist *party)
2405 CODE:
2406 RETVAL = party->partyname;
2407 OUTPUT: RETVAL
2307 2408
2308const char *cf_party_get_password (partylist *party) 2409const char *password (partylist *party)
2309 ALIAS: password = 0 2410 CODE:
2411 RETVAL = party->passwd;
2412 OUTPUT: RETVAL
2310 2413
2311player *cf_party_get_first_player (partylist *party) 2414MODULE = cf PACKAGE = cf::region
2312 ALIAS: first_player = 0
2313 2415
2314player *cf_party_get_next_player (partylist *party, player *op) 2416region *first ()
2315 ALIAS: next_player = 0
2316
2317
2318MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2319
2320region *cf_region_get_first ()
2321 PROTOTYPE: 2417 PROTOTYPE:
2322 ALIAS: first = 0 2418 CODE:
2419 RETVAL = first_region;
2420 OUTPUT: RETVAL
2323 2421
2422region *next (region *reg)
2423 CODE:
2424 RETVAL = reg->next;
2425 OUTPUT: RETVAL
2426
2427const char *name (region *reg)
2428 CODE:
2429 RETVAL = reg->name;
2430 OUTPUT: RETVAL
2431
2432region *parent (region *reg)
2433 CODE:
2434 RETVAL = reg->parent;
2435 OUTPUT: RETVAL
2436
2324const char *cf_region_get_name (region *reg) 2437const char *longname (region *reg)
2325 ALIAS: name = 0 2438 CODE:
2439 RETVAL = reg->longname;
2440 OUTPUT: RETVAL
2326 2441
2327region *cf_region_get_next (region *reg) 2442const char *msg (region *reg)
2328 ALIAS: next = 0 2443 CODE:
2444 RETVAL = reg->msg;
2445 OUTPUT: RETVAL
2329 2446
2330region *cf_region_get_parent (region *reg) 2447MODULE = cf PACKAGE = cf::living
2331 ALIAS: parent = 0
2332
2333const char *cf_region_get_longname (region *reg)
2334 ALIAS: longname = 0
2335
2336const char *cf_region_get_message (region *reg)
2337 ALIAS: message = 0
2338
2339
2340MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2341 2448
2342val64 2449val64
2343exp (living *liv, val64 new_val = 0) 2450exp (living *liv, val64 new_val = 0)
2344 PROTOTYPE: $;$ 2451 PROTOTYPE: $;$
2345 ALIAS: 2452 ALIAS:

Diff Legend

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