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.16 by root, Sun Aug 27 15:24:22 2006 UTC vs.
Revision 1.31 by root, Wed Aug 30 12:08:15 2006 UTC

… …
59 59
60typedef double val64; 60typedef double val64;
61#define newSVval64 newSVnv 61#define newSVval64 newSVnv
62#define SvVAL64 SvNV 62#define SvVAL64 SvNV
63 63
64static f_plug_api gethook; 64static f_plug_api gethook = cfapi_get_hooks;
65static f_plug_api systemDirectory; 65static f_plug_api object_set_property = cfapi_object_set_property;
66static f_plug_api object_set_property; 66static f_plug_api map_get_map = cfapi_map_get_map;
67static f_plug_api map_get_map; 67static f_plug_api object_insert = cfapi_object_insert;
68static f_plug_api object_insert;
69 68
70/* this is a stupid way to do things, and awkward to use for plug-in authors */ 69/* this is a stupid way to do things, and awkward to use for plug-in authors */
71typedef struct 70typedef struct
72{ 71{
73 object* who; 72 object* who;
… …
108 107
109 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0); 108 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
110 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1)); 109 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
111} 110}
112 111
113template<class extendable> 112template<class attachable>
114SV * 113SV *
115newSVextendable (extendable *obj, const char *klass) 114newSVattachable (attachable *obj, const char *klass)
116{ 115{
117 if (!obj) 116 if (!obj)
118 return &PL_sv_undef; 117 return &PL_sv_undef;
119 118
120 if (!obj->self) 119 if (!obj->self)
… …
227 break; 226 break;
228 227
229 case DT_OBJECT: 228 case DT_OBJECT:
230 { 229 {
231 object *obj = va_arg (ap, object *); 230 object *obj = va_arg (ap, object *);
232 sv = newSVextendable (obj, obj && obj->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap"); 231 sv = newSVattachable (obj, obj && obj->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap");
233 } 232 }
234 break; 233 break;
235 234
236 case DT_MAP: 235 case DT_MAP:
237 // va_arg (object *) when void * is passed is an XSI extension 236 // va_arg (object *) when void * is passed is an XSI extension
238 sv = newSVextendable (va_arg (ap, mapstruct *), "cf::map::wrap"); 237 sv = newSVattachable (va_arg (ap, mapstruct *), "cf::map::wrap");
239 break; 238 break;
240 239
241 case DT_PLAYER: 240 case DT_PLAYER:
242 sv = newSVextendable (va_arg (ap, player *), "cf::player::wrap"); 241 sv = newSVattachable (va_arg (ap, player *), "cf::player::wrap");
243 break; 242 break;
244 243
245 case DT_ARCH: 244 case DT_ARCH:
246 sv = newSVptr (va_arg (ap, archetype *), "cf::arch::wrap"); 245 sv = newSVptr (va_arg (ap, archetype *), "cf::arch::wrap");
247 break; 246 break;
… …
304} 303}
305 304
306////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 305//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
307 306
308SV * 307SV *
309registry_of (extendable_base *ext) 308registry_of (attachable_base *ext)
310{ 309{
311 if (!ext->cb) 310 if (!ext->cb)
312 ext->cb = newAV (); 311 ext->cb = newAV ();
313 312
314 return newRV_inc ((SV *)ext->cb); 313 return newRV_inc ((SV *)ext->cb);
315} 314}
316 315
317void extendable_base::clear () 316void attachable_base::clear ()
318{ 317{
319 //if (self) fprintf (stderr, "free_ob_self %p %s (%p,%p)\n", this, ((object *)this)->name, self, cb);//D 318 if (self)
319 {
320 if (cb)
321 if (SvROK (*av_fetch ((AV *)cb, EVENT_OBJECT_DESTROY, 1)))
322 INVOKE_OBJECT (DESTROY, static_cast<object *>(this));
323 else if (SvROK (*av_fetch ((AV *)cb, EVENT_MAP_DESTROY, 1)))
324 INVOKE_MAP (DESTROY, static_cast<mapstruct *>(this));
320 325
326 // disconnect Perl from C, to avoid crashes
327 sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
328
329 // clear the perl hash, might or might not be a good idea
330 hv_clear ((HV *)SvRV ((SV *)self));
331
321 if (self) SvREFCNT_dec (self); 332 SvREFCNT_dec (self);
333 self = 0;
334 }
335
336 if (cb)
337 {
322 if (cb) SvREFCNT_dec (cb); 338 SvREFCNT_dec (cb);
339 cb = 0;
340 }
323 341
342 if (attach)
343 {
324 if (attach) free_string (attach); 344 free_string (attach);
325
326 self = 0;
327 cb = 0;
328 attach = 0; 345 attach = 0;
346 }
329} 347}
330 348
331void extendable_base::optimise () 349void attachable_base::optimise ()
332{ 350{
333 if (!self) 351 if (!self)
334 return; 352 return;
335 353
336 HV *hv = (HV *)SvRV ((SV *)self); 354 HV *hv = (HV *)SvRV ((SV *)self);
… …
342 SvREFCNT_dec ((SV *)self); 360 SvREFCNT_dec ((SV *)self);
343 self = 0; 361 self = 0;
344 } 362 }
345} 363}
346 364
347void 365void attachable_base::instantiate (data_type type, void *obj)
348object::instantiate_ ()
349{ 366{
350 dSP; 367 dSP;
351 ENTER; 368 ENTER;
352 SAVETMPS; 369 SAVETMPS;
353 PUSHMARK (SP); 370 PUSHMARK (SP);
354 EXTEND (SP, 2); 371 EXTEND (SP, 2);
355 PUSHs (sv_2mortal (newSVdt (DT_OBJECT, static_cast<object *>(this)))); 372 PUSHs (sv_2mortal (newSVdt (type, obj)));
356 PUSHs (sv_2mortal (newSVpv (attach, 0))); 373 PUSHs (sv_2mortal (newSVpv (attach, 0)));
374
375 free_string (attach);
376 attach = 0;
377
357 PUTBACK; 378 PUTBACK;
358 call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL); 379 call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL);
359 FREETMPS; 380 FREETMPS;
360 LEAVE; 381 LEAVE;
361 382
362 INVOKE_OBJECT (INSTANTIATE, this); 383 switch (type)
384 {
385 case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
386 case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
387 }
363} 388}
364 389
365///////////////////////////////////////////////////////////////////////////// 390/////////////////////////////////////////////////////////////////////////////
366 391
367object_freezer::object_freezer (const char *filename)
368: filename (filename)
369{
370 av = (AV *)newAV ();
371 idx = 0;
372 av_extend ((AV *)av, 1024);
373}
374
375object_freezer::~object_freezer ()
376{
377 dSP;
378 ENTER;
379 SAVETMPS;
380 PUSHMARK (SP);
381 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
382 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
383 PUTBACK;
384 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
385 FREETMPS;
386 LEAVE;
387}
388
389void object_freezer::put (extendable_base *ext)
390{
391 ext->optimise ();
392
393 if (ext->self)
394 av_store ((AV *)av, idx, SvREFCNT_inc ((SV *)ext->self));
395
396 ++idx;
397}
398
399object_thawer::object_thawer (const char *filename)
400{
401 av = 0;
402 idx = 0;
403
404 if (!filename)
405 return;
406
407 dSP;
408 ENTER;
409 SAVETMPS;
410 PUSHMARK (SP);
411 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
412 PUTBACK;
413
414 if (0 < call_pv ("cf::object_thawer_load", G_SCALAR | G_EVAL))
415 {
416 SPAGAIN;
417 SV *sv = POPs;
418 if (SvROK (sv))
419 av = SvREFCNT_inc (SvRV (sv));
420 }
421
422 FREETMPS;
423 LEAVE;
424}
425
426void reattach (data_type type, void *obj) 392void reattach (data_type type, void *obj)
427{ 393{
394 //TODO only do this when the object has _attachment's
395
428 dSP; 396 dSP;
429 ENTER; 397 ENTER;
430 SAVETMPS; 398 SAVETMPS;
431 PUSHMARK (SP); 399 PUSHMARK (SP);
432 XPUSHs (sv_2mortal (newSVdt (type, obj))); 400 XPUSHs (sv_2mortal (newSVdt (type, obj)));
… …
442 case DT_MAP: INVOKE_MAP (REATTACH, obj); break; 410 case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
443 } 411 }
444} 412}
445 413
446template<class subclass> 414template<class subclass>
447void reattach (extendable<subclass> *obj) 415void reattach (attachable<subclass> *obj)
448{ 416{
449 obj->optimise (); 417 obj->optimise ();
450 418
451 if (obj->self) 419 if (obj->self)
452 reattach (subclass::get_dt (), (subclass *)obj); 420 reattach (subclass::get_dt (), (subclass *)obj);
453} 421}
454 422
423object_freezer::object_freezer (const char *filename)
424{
425 this->filename = (SV *)newSVpv (filename, 0);
426
427 char filename2 [4096];
428 snprintf (filename2, 4096, "%s~", filename);
429
430 fp = fopen (filename2, "w");
431
432 if (!fp)
433 LOG (llevError, "cannot open file '%s' for writing: %s\n", filename2, strerror (errno));
434
435 av = (AV *)newAV ();
436}
437
438object_freezer::~object_freezer ()
439{
440 if (fp)
441 {
442 fclose (fp);
443
444 dSP;
445 ENTER;
446 SAVETMPS;
447 PUSHMARK (SP);
448 XPUSHs (sv_2mortal ((SV *)filename));
449 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
450 PUTBACK;
451 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
452 FREETMPS;
453 LEAVE;
454 }
455 else
456 SvREFCNT_dec ((SV *)filename);
457}
458
459void object_freezer::put (attachable_base *ext)
460{
461 ext->optimise ();
462
463 if (ext->self)
464 {
465 int idx = AvFILLp ((AV *)av) + 1;
466 av_store ((AV *)av, idx, SvREFCNT_inc ((SV *)ext->self));
467 fprintf (fp, "oid %d\n", idx);
468 }
469}
470
471object_thawer::object_thawer (const char *filename)
472{
473 av = 0;
474 fp = 0;
475
476 if (!filename)
477 return;
478
479 fp = fopen (filename, "r");
480 if (!fp)
481 {
482 LOG (llevError, "object_thawer: unable to open '%s': %s.\n", filename, strerror (errno));
483 return;
484 }
485
486 if (perl)
487 {
488 dSP;
489 ENTER;
490 SAVETMPS;
491 PUSHMARK (SP);
492 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
493 PUTBACK;
494
495 if (0 < call_pv ("cf::object_thawer_load", G_SCALAR | G_EVAL))
496 {
497 SPAGAIN;
498 SV *sv = POPs;
499 if (SvROK (sv))
500 av = SvREFCNT_inc (SvRV (sv));
501 }
502
503 FREETMPS;
504 LEAVE;
505 }
506}
507
508// compatibility support, should be removed when no longer needed
509int fprintf (object_freezer &freezer, const char *format, ...)
510{
511 va_list ap;
512
513 va_start (ap, format);
514 vfprintf (freezer.fp, format, ap);
515 va_end (ap);
516}
517
518int fputs (const char *s, object_freezer &freezer)
519{
520 fputs (s, freezer.fp);
521}
522
455void object_thawer::get (data_type type, void *obj, extendable_base *ext) 523void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
456{ 524{
457 if (!av) 525 if (!av || oid < 0) // this is actually an error of sorts
458 return; 526 return;
459 527
460 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach 528 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach
461 ext->clear (); 529 ext->clear ();
462 530
463 SV **svp = av_fetch ((AV *)av, idx, 0); 531 SV **svp = av_fetch ((AV *)av, oid, 0);
464 532
465 ++idx;
466
467 if (!svp)
468 return;
469
470 if (SvROK (*svp)) 533 if (!svp || !SvROK (*svp))
471 { 534 {
472 ext->self = SvREFCNT_inc (*svp); 535 printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
473 sv_magic (SvRV ((SV *)ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0); 536 return;
474
475 reattach (type, obj);
476 } 537 }
538
539 ext->self = *svp; *svp = &PL_sv_undef;
540 sv_magic (SvRV ((SV *)ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
541
542 reattach (type, obj);
477} 543}
478 544
479object_thawer::~object_thawer () 545object_thawer::~object_thawer ()
480{ 546{
481 if (av) 547 if (fp) fclose (fp);
482 SvREFCNT_dec ((SV *)av); 548 if (av) SvREFCNT_dec ((AV *)av);
483} 549}
484 550
485///////////////////////////////////////////////////////////////////////////// 551/////////////////////////////////////////////////////////////////////////////
486 552
487extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 553extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
488{ 554{
489 gethook = gethooksptr;
490 printf (PLUGIN_VERSION " init\n");
491
492 return 0; 555 return 0;
493} 556}
494 557
495static CommArray_s rtn_cmd; 558static CommArray_s rtn_cmd;
496 559
… …
576extern "C" int cfperl_postInitPlugin () 639extern "C" int cfperl_postInitPlugin ()
577{ 640{
578 int hooktype = 1; 641 int hooktype = 1;
579 int rtype = 0; 642 int rtype = 0;
580 643
581 printf (PLUGIN_VERSION " post init\n");
582
583 systemDirectory = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_directory");
584 object_set_property = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_set_property");
585 map_get_map = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_map_get_map");
586 object_insert = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_insert");
587
588 cf_init_plugin (gethook); 644 cf_init_plugin (gethook);
589 645
590 return 0; 646 return 0;
591} 647}
592 648
… …
640static event_klass klass_of[NUM_EVENT_TYPES] = { 696static event_klass klass_of[NUM_EVENT_TYPES] = {
641# define def(type,name) KLASS_ ## type, 697# define def(type,name) KLASS_ ## type,
642# include "eventinc.h" 698# include "eventinc.h"
643# undef def 699# undef def
644}; 700};
701
702#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
645 703
646static void 704static void
647gather_callbacks (AV *&callbacks, AV *registry, event_type event) 705gather_callbacks (AV *&callbacks, AV *registry, event_type event)
648{ 706{
649 // event must be in array 707 // event must be in array
… …
692 // 2a. per-type callback 750 // 2a. per-type callback
693 // 4. global callbacks 751 // 4. global callbacks
694 752
695 gather_callbacks (callbacks, cb_global, event); 753 gather_callbacks (callbacks, cb_global, event);
696 754
697 switch (klass_of [event]) 755 switch (KLASS_OF (event))
698 { 756 {
699 case KLASS_GLOBAL: 757 case KLASS_GLOBAL:
700 break; 758 break;
701 759
702 case KLASS_OBJECT: 760 case KLASS_OBJECT:
… …
768 EXTEND (SP, 3); 826 EXTEND (SP, 3);
769 827
770 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays 828 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays
771 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks))); 829 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));
772 830
773 switch (klass_of [event]) 831 switch (KLASS_OF (event))
774 { 832 {
775 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break; 833 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;
776 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break; 834 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;
777 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break; 835 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;
778 } 836 }
… …
1375 prop (CFAPI_INT, MAP_PROP_WINDDIR) 1433 prop (CFAPI_INT, MAP_PROP_WINDDIR)
1376 prop (CFAPI_INT, MAP_PROP_SKY) 1434 prop (CFAPI_INT, MAP_PROP_SKY)
1377 prop (CFAPI_INT, MAP_PROP_WPARTX) 1435 prop (CFAPI_INT, MAP_PROP_WPARTX)
1378 prop (CFAPI_INT, MAP_PROP_WPARTY) 1436 prop (CFAPI_INT, MAP_PROP_WPARTY)
1379 prop (CFAPI_STRING, MAP_PROP_MESSAGE) 1437 prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1380 prop (CFAPI_PMAP, MAP_PROP_NEXT)
1381 prop (CFAPI_PREGION, MAP_PROP_REGION) 1438 prop (CFAPI_PREGION, MAP_PROP_REGION)
1382 prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1383 prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1384 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB) 1439 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1385 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB) 1440 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1386 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY) 1441 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1387 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT) 1442 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1388 prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1389 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER) 1443 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1390 prop (CFAPI_PMAP, OBJECT_PROP_MAP) 1444 prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1391 prop (CFAPI_INT, OBJECT_PROP_COUNT) 1445 prop (CFAPI_INT, OBJECT_PROP_COUNT)
1392 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT) 1446 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1393 prop (CFAPI_STRING, OBJECT_PROP_NAME) 1447 prop (CFAPI_STRING, OBJECT_PROP_NAME)
… …
1525 PROTOTYPE: $$ 1579 PROTOTYPE: $$
1526 1580
1527char *path_combine_and_normalize (char *base, char *path) 1581char *path_combine_and_normalize (char *base, char *path)
1528 PROTOTYPE: $$ 1582 PROTOTYPE: $$
1529 1583
1530char * 1584const char *
1531cf_get_maps_directory (char *path) 1585get_maps_directory (char *path)
1532 PROTOTYPE: $ 1586 PROTOTYPE: $
1533 ALIAS: maps_directory = 0 1587 ALIAS: maps_directory = 0
1588 CODE:
1589 RETVAL = create_pathname (path);
1590 OUTPUT: RETVAL
1534 1591
1535void 1592void
1536sub_generation_inc () 1593sub_generation_inc ()
1537 CODE: 1594 CODE:
1538 PL_sub_generation++; 1595 PL_sub_generation++;
… …
1547 confdir = 3 1604 confdir = 3
1548 localdir = 4 1605 localdir = 4
1549 playerdir = 5 1606 playerdir = 5
1550 datadir = 6 1607 datadir = 6
1551 CODE: 1608 CODE:
1552{ 1609 switch (ix)
1553 int unused_type; 1610 {
1554 RETVAL = (char *)systemDirectory (&unused_type, ix); 1611 case 0: RETVAL = settings.mapdir ; break;
1555} 1612 case 1: RETVAL = settings.uniquedir; break;
1613 case 2: RETVAL = settings.tmpdir ; break;
1614 case 3: RETVAL = settings.confdir ; break;
1615 case 4: RETVAL = settings.localdir ; break;
1616 case 5: RETVAL = settings.playerdir; break;
1617 case 6: RETVAL = settings.datadir ; break;
1618 }
1556 OUTPUT: RETVAL 1619 OUTPUT: RETVAL
1557 1620
1558int 1621int
1559cf_find_animation (char *text) 1622cf_find_animation (char *text)
1560 PROTOTYPE: $ 1623 PROTOTYPE: $
1561 1624
1562int random_roll(int min, int max, object *op, int goodbad); 1625int random_roll(int min, int max, object *op, int goodbad);
1563 1626
1564const char *cost_string_from_value(uint64 cost, int approx = 0) 1627const char *cost_string_from_value(uint64 cost, int approx = 0)
1565 1628
1566int invoke (int event, SV *arg1, ...) 1629int invoke (int event, ...)
1567 CODE: 1630 CODE:
1568{ 1631 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1569 // parse first arg and call invoke_object etc as seen fit 1632 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1570 //TODO 1633 for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1571 //cfperl_invoke (event, 1634 RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1572} 1635 OUTPUT: RETVAL
1573 1636
1574int 1637int
1575exp_to_level (val64 exp) 1638exp_to_level (val64 exp)
1576 CODE: 1639 CODE:
1577{ 1640{
… …
1608 RETVAL = newSVpv (resist_plus[atnr], 0); 1671 RETVAL = newSVpv (resist_plus[atnr], 0);
1609 else 1672 else
1610 XSRETURN_UNDEF; 1673 XSRETURN_UNDEF;
1611 OUTPUT: RETVAL 1674 OUTPUT: RETVAL
1612 1675
1676int
1677_valid (SV *obj)
1678 CODE:
1679 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1680 OUTPUT:
1681 RETVAL
1682
1613MODULE = cf PACKAGE = cf::object PREFIX = cf_object_ 1683MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1684
1685int invoke (object *op, int event, ...)
1686 CODE:
1687 if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1688 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1689 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1690 RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));
1691 OUTPUT: RETVAL
1692
1693SV *registry (object *op)
1694 CODE:
1695 RETVAL = registry_of (op);
1696 OUTPUT:
1697 RETVAL
1698
1699object *head (object *op)
1700 PROTOTYPE: $
1701 ALIAS:
1702 more = 1
1703 above = 2
1704 below = 3
1705 CODE:
1706 switch (ix)
1707 {
1708 case 0: RETVAL = op->head ? op->head : op; break; // DOH!
1709 case 1: RETVAL = op->more; break;
1710 case 2: RETVAL = op->above; break;
1711 case 3: RETVAL = op->below; break;
1712 }
1713 OUTPUT:
1714 RETVAL
1614 1715
1615SV * 1716SV *
1616get_property (object *obj, int type, int idx) 1717get_property (object *obj, int type, int idx)
1617 CODE: 1718 CODE:
1618 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx)); 1719 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));
… …
1697 1798
1698int need_identify (const object *obj); 1799int need_identify (const object *obj);
1699 1800
1700int apply_shop_mat (object *shop_mat, object *op); 1801int apply_shop_mat (object *shop_mat, object *op);
1701 1802
1702void cf_object_move (object *op, int dir, object *originator = op) 1803int move (object *op, int dir, object *originator = op)
1804 CODE:
1805 RETVAL = move_ob (op, dir, originator);
1806 OUTPUT:
1807 RETVAL
1703 1808
1704void cf_object_apply (object *op, object *author, int flags = 0) 1809void cf_object_apply (object *op, object *author, int flags = 0)
1705 1810
1706void cf_object_apply_below (object *op) 1811void cf_object_apply_below (object *op)
1707 1812
… …
1815 CODE: 1920 CODE:
1816{ 1921{
1817 int unused_type; 1922 int unused_type;
1818 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y); 1923 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1819} 1924}
1820
1821SV *registry (object *op)
1822 CODE:
1823 RETVAL = registry_of (op);
1824 OUTPUT:
1825 RETVAL
1826 1925
1827# syntatic sugar for easier use in event callbacks. 1926# syntatic sugar for easier use in event callbacks.
1828const char *options (object *op) 1927const char *options (object *op)
1829 CODE: 1928 CODE:
1830 RETVAL = op->name; 1929 RETVAL = op->name;
… …
1903 2002
1904void kill_player (object *op) 2003void kill_player (object *op)
1905 2004
1906MODULE = cf PACKAGE = cf::player PREFIX = cf_player_ 2005MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1907 2006
2007int invoke (player *pl, int event, ...)
2008 CODE:
2009 if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2010 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2011 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2012 RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));
2013 OUTPUT: RETVAL
2014
1908SV *registry (player *pl) 2015SV *registry (player *pl)
1909 CODE: 2016 CODE:
1910 RETVAL = registry_of (pl); 2017 RETVAL = registry_of (pl);
1911 OUTPUT: 2018 OUTPUT:
1912 RETVAL 2019 RETVAL
… …
2036 OUTPUT: RETVAL 2143 OUTPUT: RETVAL
2037 2144
2038 2145
2039MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2146MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2040 2147
2148mapstruct *first ()
2149 PROTOTYPE:
2150 CODE:
2151 RETVAL = first_map;
2152 OUTPUT: RETVAL
2153
2154mapstruct *next (mapstruct *map)
2155 PROTOTYPE:
2156 CODE:
2157 RETVAL = map->next;
2158 OUTPUT: RETVAL
2159
2160int invoke (mapstruct *map, int event, ...)
2161 CODE:
2162 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2163 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2164 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2165 RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));
2166 OUTPUT: RETVAL
2167
2041SV *registry (mapstruct *map) 2168SV *registry (mapstruct *map)
2042 CODE: 2169 CODE:
2043 RETVAL = registry_of (map); 2170 RETVAL = registry_of (map);
2044 OUTPUT: 2171 OUTPUT:
2045 RETVAL 2172 RETVAL
… …
2064 2191
2065mapstruct *new (int width, int height) 2192mapstruct *new (int width, int height)
2066 PROTOTYPE: 2193 PROTOTYPE:
2067 CODE: 2194 CODE:
2068{ 2195{
2069 int unused_type; 2196 RETVAL = get_empty_map (width, height);
2070 RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
2071} 2197}
2072 OUTPUT: 2198 OUTPUT:
2073 RETVAL 2199 RETVAL
2074 2200
2075void delete_map (mapstruct *map) 2201void delete_map (mapstruct *map)
… …
2090 XSRETURN_UNDEF; 2216 XSRETURN_UNDEF;
2091 RETVAL = map->tile_path [dir]; 2217 RETVAL = map->tile_path [dir];
2092 OUTPUT: 2218 OUTPUT:
2093 RETVAL 2219 RETVAL
2094 2220
2095mapstruct *cf_map_get_map (char *name) 2221mapstruct *ready_map_name (char *name, int flags = 0)
2096 PROTOTYPE: $ 2222 PROTOTYPE: $;$
2097 ALIAS: map = 0 2223 ALIAS:
2224 find = 0
2225 get_map = 1
2098 2226
2099mapstruct *has_been_loaded (char *name) 2227mapstruct *has_been_loaded (char *name)
2100 PROTOTYPE: $ 2228 PROTOTYPE: $
2101
2102mapstruct *cf_map_get_first ()
2103 PROTOTYPE:
2104 ALIAS: first = 0
2105 2229
2106# whoever "designed" the plug-in api should have wasted 2230# whoever "designed" the plug-in api should have wasted
2107# his/her time with staying away from the project - would have 2231# his/her time with staying away from the project - would have
2108# saved others a lot of time, without doubt. 2232# saved others a lot of time, without doubt.
2109void set_path (mapstruct *where, char *path) 2233void set_path (mapstruct *where, char *path)
… …
2124 2248
2125void set_unique (mapstruct *map, bool unique) 2249void set_unique (mapstruct *map, bool unique)
2126 CODE: 2250 CODE:
2127 map->unique = unique; 2251 map->unique = unique;
2128 2252
2253void
2254trigger (mapstruct *map, long connection, bool state = true)
2255 CODE:
2256 activate_connection (map, connection, state);
2257
2258void
2259get_connection (mapstruct *map, long connection)
2260 PPCODE:
2261 oblinkpt *obp = get_connection_links (map, connection);
2262 if (obp)
2263 for (objectlink *ol = obp->link; ol; ol = ol->next)
2264 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, ol->ob)));
2265
2129object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags) 2266object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags)
2130 2267
2131object *cf_map_insert_object (mapstruct *where, object* op, int x, int y) 2268object *cf_map_insert_object (mapstruct *where, object* op, int x, int y)
2132 2269
2133object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny) 2270object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny)
… …
2137cf_map_normalise (mapstruct *map, int x, int y) 2274cf_map_normalise (mapstruct *map, int x, int y)
2138 PPCODE: 2275 PPCODE:
2139{ 2276{
2140 mapstruct *nmap = 0; 2277 mapstruct *nmap = 0;
2141 I16 nx = 0, ny = 0; 2278 I16 nx = 0, ny = 0;
2142 int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2279 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2143 2280
2144 EXTEND (SP, 4); 2281 EXTEND (SP, 4);
2145 PUSHs (sv_2mortal (newSViv (flags))); 2282 PUSHs (sv_2mortal (newSViv (flags)));
2146 2283
2147 if (GIMME_V == G_ARRAY) 2284 if (GIMME_V == G_ARRAY)
… …
2159{ 2296{
2160 object *o; 2297 object *o;
2161 mapstruct *nmap = 0; 2298 mapstruct *nmap = 0;
2162 I16 nx, ny; 2299 I16 nx, ny;
2163 2300
2164 cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2301 get_map_flags (map, &nmap, x, y, &nx, &ny);
2165 2302
2166 if (nmap) 2303 if (nmap)
2167 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above) 2304 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2168 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o))); 2305 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2169} 2306}
… …
2194 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break; 2331 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2195 } 2332 }
2196 OUTPUT: 2333 OUTPUT:
2197 RETVAL 2334 RETVAL
2198 2335
2199# "deserialise" perl map data into the map # TODO# compatibility cruft, remove
2200void
2201_set_obs (mapstruct *map, SV *sv)
2202 CODE:
2203{
2204 object *o;
2205 AV *av;
2206 int x, y;
2207 AV *obs = (AV *)SvRV (sv);
2208 2336
2209 for (y = 0; y < MAP_HEIGHT (map); y++) 2337MODULE = cf PACKAGE = cf::arch
2210 for (x = 0; x < MAP_WIDTH (map); x++)
2211 {
2212 sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);
2213 2338
2214 if (!SvROK (sv)) 2339archetype *first()
2215 continue;
2216
2217 av = (AV *)SvRV (sv);
2218
2219 for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2220 {
2221 sv = av_shift (av);
2222
2223 if (SvROK (sv))
2224 {
2225 sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2226 SVptr_cache_set (o, sv);
2227 }
2228 }
2229 }
2230}
2231
2232
2233MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_
2234
2235archetype *cf_archetype_get_first()
2236 PROTOTYPE: 2340 PROTOTYPE:
2237 ALIAS: first = 0 2341 CODE:
2342 RETVAL = first_archetype;
2343 OUTPUT: RETVAL
2238 2344
2239archetype *cf_archetype_get_next (archetype *arch) 2345archetype *next (archetype *arch)
2240 ALIAS: next = 0 2346 CODE:
2347 RETVAL = arch->next;
2348 OUTPUT: RETVAL
2241 2349
2242archetype *cf_archetype_get_head (archetype *arch) 2350archetype *head (archetype *arch)
2243 ALIAS: head = 0 2351 CODE:
2352 RETVAL = arch->head;
2353 OUTPUT: RETVAL
2244 2354
2245archetype *cf_archetype_get_more (archetype *arch) 2355archetype *more (archetype *arch)
2246 ALIAS: more = 0 2356 CODE:
2357 RETVAL = arch->more;
2358 OUTPUT: RETVAL
2247 2359
2248const char *cf_archetype_get_name (archetype *arch) 2360const char *name (archetype *arch)
2249 ALIAS: name = 0 2361 CODE:
2362 RETVAL = arch->name;
2363 OUTPUT: RETVAL
2250 2364
2251object *cf_archetype_get_clone (archetype *arch) 2365object *clone (archetype *arch)
2252 ALIAS: clone = 0 2366 CODE:
2367 RETVAL = &arch->clone;
2368 OUTPUT: RETVAL
2253 2369
2254MODULE = cf PACKAGE = cf::party PREFIX = cf_party_ 2370MODULE = cf PACKAGE = cf::party
2255 2371
2256partylist *cf_party_get_first () 2372partylist *first ()
2257 PROTOTYPE: 2373 PROTOTYPE:
2258 ALIAS: first = 0 2374 CODE:
2375 RETVAL = get_firstparty ();
2376 OUTPUT: RETVAL
2259 2377
2260partylist *cf_party_get_next (partylist *party) 2378partylist *next (partylist *party)
2261 ALIAS: next = 0 2379 CODE:
2380 RETVAL = party->next;
2381 OUTPUT: RETVAL
2262 2382
2263const char *cf_party_get_name (partylist *party) 2383const char *name (partylist *party)
2384 CODE:
2385 RETVAL = party->partyname;
2386 OUTPUT: RETVAL
2264 2387
2265const char *cf_party_get_password (partylist *party) 2388const char *password (partylist *party)
2266 ALIAS: password = 0 2389 CODE:
2390 RETVAL = party->passwd;
2391 OUTPUT: RETVAL
2267 2392
2268player *cf_party_get_first_player (partylist *party) 2393MODULE = cf PACKAGE = cf::region
2269 ALIAS: first_player = 0
2270 2394
2271player *cf_party_get_next_player (partylist *party, player *op) 2395region *first ()
2272 ALIAS: next_player = 0
2273
2274
2275MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2276
2277region *cf_region_get_first ()
2278 PROTOTYPE: 2396 PROTOTYPE:
2279 ALIAS: first = 0 2397 CODE:
2398 RETVAL = first_region;
2399 OUTPUT: RETVAL
2280 2400
2401region *next (region *reg)
2402 CODE:
2403 RETVAL = reg->next;
2404 OUTPUT: RETVAL
2405
2406const char *name (region *reg)
2407 CODE:
2408 RETVAL = reg->name;
2409 OUTPUT: RETVAL
2410
2411region *parent (region *reg)
2412 CODE:
2413 RETVAL = reg->parent;
2414 OUTPUT: RETVAL
2415
2281const char *cf_region_get_name (region *reg) 2416const char *longname (region *reg)
2282 ALIAS: name = 0 2417 CODE:
2418 RETVAL = reg->longname;
2419 OUTPUT: RETVAL
2283 2420
2284region *cf_region_get_next (region *reg) 2421const char *msg (region *reg)
2285 ALIAS: next = 0 2422 CODE:
2423 RETVAL = reg->msg;
2424 OUTPUT: RETVAL
2286 2425
2287region *cf_region_get_parent (region *reg) 2426MODULE = cf PACKAGE = cf::living
2288 ALIAS: parent = 0
2289
2290const char *cf_region_get_longname (region *reg)
2291 ALIAS: longname = 0
2292
2293const char *cf_region_get_message (region *reg)
2294 ALIAS: message = 0
2295
2296
2297MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2298 2427
2299val64 2428val64
2300exp (living *liv, val64 new_val = 0) 2429exp (living *liv, val64 new_val = 0)
2301 PROTOTYPE: $;$ 2430 PROTOTYPE: $;$
2302 ALIAS: 2431 ALIAS:

Diff Legend

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