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.14 by root, Sun Aug 27 13:02:04 2006 UTC vs.
Revision 1.28 by root, Wed Aug 30 06:06:27 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;
382
383 switch (type)
384 {
385 case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
386 case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
387 }
361} 388}
362 389
363///////////////////////////////////////////////////////////////////////////// 390/////////////////////////////////////////////////////////////////////////////
364 391
365object_freezer::object_freezer (const char *filename)
366: filename (filename)
367{
368 av = (AV *)newAV ();
369 idx = 0;
370 av_extend ((AV *)av, 1024);
371}
372
373object_freezer::~object_freezer ()
374{
375 dSP;
376 ENTER;
377 SAVETMPS;
378 PUSHMARK (SP);
379 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
380 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
381 PUTBACK;
382 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
383 FREETMPS;
384 LEAVE;
385}
386
387void object_freezer::put (extendable_base *ext)
388{
389 ext->optimise ();
390
391 if (ext->self)
392 av_store ((AV *)av, idx, SvREFCNT_inc ((SV *)ext->self));
393
394 ++idx;
395}
396
397object_thawer::object_thawer (const char *filename)
398{
399 av = 0;
400 idx = 0;
401
402 if (!filename)
403 return;
404
405 dSP;
406 ENTER;
407 SAVETMPS;
408 PUSHMARK (SP);
409 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
410 PUTBACK;
411
412 if (0 < call_pv ("cf::object_thawer_load", G_SCALAR | G_EVAL))
413 {
414 SPAGAIN;
415 SV *sv = POPs;
416 if (SvROK (sv))
417 av = SvREFCNT_inc (SvRV (sv));
418 }
419
420 FREETMPS;
421 LEAVE;
422}
423
424void reattach (data_type type, void *obj) 392void reattach (data_type type, void *obj)
425{ 393{
394 //TODO only do this when the object has _attachment's
395
426 dSP; 396 dSP;
427 ENTER; 397 ENTER;
428 SAVETMPS; 398 SAVETMPS;
429 PUSHMARK (SP); 399 PUSHMARK (SP);
430 XPUSHs (sv_2mortal (newSVdt (type, obj))); 400 XPUSHs (sv_2mortal (newSVdt (type, obj)));
… …
440 case DT_MAP: INVOKE_MAP (REATTACH, obj); break; 410 case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
441 } 411 }
442} 412}
443 413
444template<class subclass> 414template<class subclass>
445void reattach (extendable<subclass> *obj) 415void reattach (attachable<subclass> *obj)
446{ 416{
417 obj->optimise ();
418
447 if (obj->self) 419 if (obj->self)
448 reattach (subclass::get_dt (), (subclass *)obj); 420 reattach (subclass::get_dt (), (subclass *)obj);
449} 421}
450 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
451void object_thawer::get (data_type type, void *obj, extendable_base *ext) 508void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
452{ 509{
453 if (!av) 510 if (!av || oid < 0) // this is actually an error of sorts
454 return; 511 return;
455 512
456 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach 513 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach
457 ext->clear (); 514 ext->clear ();
458 515
459 SV **svp = av_fetch ((AV *)av, idx, 0); 516 SV **svp = av_fetch ((AV *)av, oid, 0);
460 517
461 ++idx;
462
463 if (!svp)
464 return;
465
466 if (SvROK (*svp)) 518 if (!svp || !SvROK (*svp))
467 { 519 {
468 ext->self = SvREFCNT_inc (*svp); 520 printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
469 sv_magic (SvRV ((SV *)ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0); 521 return;
470
471 reattach (type, obj);
472 } 522 }
523
524 ext->self = *svp; *svp = &PL_sv_undef;
525 sv_magic (SvRV ((SV *)ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
526
527 reattach (type, obj);
473} 528}
474 529
475object_thawer::~object_thawer () 530object_thawer::~object_thawer ()
476{ 531{
477 if (av) 532 if (fp) fclose (fp);
478 SvREFCNT_dec ((SV *)av); 533 if (av) SvREFCNT_dec ((AV *)av);
479} 534}
480 535
481///////////////////////////////////////////////////////////////////////////// 536/////////////////////////////////////////////////////////////////////////////
482 537
483extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 538extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
484{ 539{
485 gethook = gethooksptr;
486 printf (PLUGIN_VERSION " init\n");
487
488 return 0; 540 return 0;
489} 541}
490 542
491static CommArray_s rtn_cmd; 543static CommArray_s rtn_cmd;
492 544
… …
572extern "C" int cfperl_postInitPlugin () 624extern "C" int cfperl_postInitPlugin ()
573{ 625{
574 int hooktype = 1; 626 int hooktype = 1;
575 int rtype = 0; 627 int rtype = 0;
576 628
577 printf (PLUGIN_VERSION " post init\n");
578
579 systemDirectory = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_directory");
580 object_set_property = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_set_property");
581 map_get_map = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_map_get_map");
582 object_insert = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_insert");
583
584 cf_init_plugin (gethook); 629 cf_init_plugin (gethook);
585 630
586 return 0; 631 return 0;
587} 632}
588 633
… …
636static event_klass klass_of[NUM_EVENT_TYPES] = { 681static event_klass klass_of[NUM_EVENT_TYPES] = {
637# define def(type,name) KLASS_ ## type, 682# define def(type,name) KLASS_ ## type,
638# include "eventinc.h" 683# include "eventinc.h"
639# undef def 684# undef def
640}; 685};
686
687#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
641 688
642static void 689static void
643gather_callbacks (AV *&callbacks, AV *registry, event_type event) 690gather_callbacks (AV *&callbacks, AV *registry, event_type event)
644{ 691{
645 // event must be in array 692 // event must be in array
… …
688 // 2a. per-type callback 735 // 2a. per-type callback
689 // 4. global callbacks 736 // 4. global callbacks
690 737
691 gather_callbacks (callbacks, cb_global, event); 738 gather_callbacks (callbacks, cb_global, event);
692 739
693 switch (klass_of [event]) 740 switch (KLASS_OF (event))
694 { 741 {
695 case KLASS_GLOBAL: 742 case KLASS_GLOBAL:
696 break; 743 break;
697 744
698 case KLASS_OBJECT: 745 case KLASS_OBJECT:
… …
764 EXTEND (SP, 3); 811 EXTEND (SP, 3);
765 812
766 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays 813 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays
767 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks))); 814 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));
768 815
769 switch (klass_of [event]) 816 switch (KLASS_OF (event))
770 { 817 {
771 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break; 818 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;
772 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break; 819 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;
773 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break; 820 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;
774 } 821 }
… …
1373 prop (CFAPI_INT, MAP_PROP_WPARTX) 1420 prop (CFAPI_INT, MAP_PROP_WPARTX)
1374 prop (CFAPI_INT, MAP_PROP_WPARTY) 1421 prop (CFAPI_INT, MAP_PROP_WPARTY)
1375 prop (CFAPI_STRING, MAP_PROP_MESSAGE) 1422 prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1376 prop (CFAPI_PMAP, MAP_PROP_NEXT) 1423 prop (CFAPI_PMAP, MAP_PROP_NEXT)
1377 prop (CFAPI_PREGION, MAP_PROP_REGION) 1424 prop (CFAPI_PREGION, MAP_PROP_REGION)
1378 prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1379 prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1380 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB) 1425 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1381 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB) 1426 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1382 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY) 1427 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1383 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT) 1428 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1384 prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1385 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER) 1429 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1386 prop (CFAPI_PMAP, OBJECT_PROP_MAP) 1430 prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1387 prop (CFAPI_INT, OBJECT_PROP_COUNT) 1431 prop (CFAPI_INT, OBJECT_PROP_COUNT)
1388 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT) 1432 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1389 prop (CFAPI_STRING, OBJECT_PROP_NAME) 1433 prop (CFAPI_STRING, OBJECT_PROP_NAME)
… …
1521 PROTOTYPE: $$ 1565 PROTOTYPE: $$
1522 1566
1523char *path_combine_and_normalize (char *base, char *path) 1567char *path_combine_and_normalize (char *base, char *path)
1524 PROTOTYPE: $$ 1568 PROTOTYPE: $$
1525 1569
1526char * 1570const char *
1527cf_get_maps_directory (char *path) 1571get_maps_directory (char *path)
1528 PROTOTYPE: $ 1572 PROTOTYPE: $
1529 ALIAS: maps_directory = 0 1573 ALIAS: maps_directory = 0
1574 CODE:
1575 RETVAL = create_pathname (path);
1576 OUTPUT: RETVAL
1530 1577
1531void 1578void
1532sub_generation_inc () 1579sub_generation_inc ()
1533 CODE: 1580 CODE:
1534 PL_sub_generation++; 1581 PL_sub_generation++;
… …
1543 confdir = 3 1590 confdir = 3
1544 localdir = 4 1591 localdir = 4
1545 playerdir = 5 1592 playerdir = 5
1546 datadir = 6 1593 datadir = 6
1547 CODE: 1594 CODE:
1548{ 1595 switch (ix)
1549 int unused_type; 1596 {
1550 RETVAL = (char *)systemDirectory (&unused_type, ix); 1597 case 0: RETVAL = settings.mapdir ; break;
1551} 1598 case 1: RETVAL = settings.uniquedir; break;
1599 case 2: RETVAL = settings.tmpdir ; break;
1600 case 3: RETVAL = settings.confdir ; break;
1601 case 4: RETVAL = settings.localdir ; break;
1602 case 5: RETVAL = settings.playerdir; break;
1603 case 6: RETVAL = settings.datadir ; break;
1604 }
1552 OUTPUT: RETVAL 1605 OUTPUT: RETVAL
1553 1606
1554int 1607int
1555cf_find_animation (char *text) 1608cf_find_animation (char *text)
1556 PROTOTYPE: $ 1609 PROTOTYPE: $
1557 1610
1558int random_roll(int min, int max, object *op, int goodbad); 1611int random_roll(int min, int max, object *op, int goodbad);
1559 1612
1560const char *cost_string_from_value(uint64 cost, int approx = 0) 1613const char *cost_string_from_value(uint64 cost, int approx = 0)
1561 1614
1562int invoke (int event, SV *arg1, ...) 1615int invoke (int event, ...)
1563 CODE: 1616 CODE:
1564{ 1617 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1565 // parse first arg and call invoke_object etc as seen fit 1618 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1566 //TODO 1619 for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1567 //cfperl_invoke (event, 1620 RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1568} 1621 OUTPUT: RETVAL
1569 1622
1570int 1623int
1571exp_to_level (val64 exp) 1624exp_to_level (val64 exp)
1572 CODE: 1625 CODE:
1573{ 1626{
… …
1604 RETVAL = newSVpv (resist_plus[atnr], 0); 1657 RETVAL = newSVpv (resist_plus[atnr], 0);
1605 else 1658 else
1606 XSRETURN_UNDEF; 1659 XSRETURN_UNDEF;
1607 OUTPUT: RETVAL 1660 OUTPUT: RETVAL
1608 1661
1662int
1663_valid (SV *obj)
1664 CODE:
1665 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1666 OUTPUT:
1667 RETVAL
1668
1609MODULE = cf PACKAGE = cf::object PREFIX = cf_object_ 1669MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1670
1671int invoke (object *op, int event, ...)
1672 CODE:
1673 if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1674 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1675 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1676 RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));
1677 OUTPUT: RETVAL
1678
1679SV *registry (object *op)
1680 CODE:
1681 RETVAL = registry_of (op);
1682 OUTPUT:
1683 RETVAL
1684
1685object *head (object *op)
1686 PROTOTYPE: $
1687 ALIAS:
1688 more = 1
1689 above = 2
1690 below = 3
1691 CODE:
1692 switch (ix)
1693 {
1694 case 0: RETVAL = op->head ? op->head : op; break; // DOH!
1695 case 1: RETVAL = op->more; break;
1696 case 2: RETVAL = op->above; break;
1697 case 3: RETVAL = op->below; break;
1698 }
1699 OUTPUT:
1700 RETVAL
1610 1701
1611SV * 1702SV *
1612get_property (object *obj, int type, int idx) 1703get_property (object *obj, int type, int idx)
1613 CODE: 1704 CODE:
1614 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx)); 1705 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));
… …
1693 1784
1694int need_identify (const object *obj); 1785int need_identify (const object *obj);
1695 1786
1696int apply_shop_mat (object *shop_mat, object *op); 1787int apply_shop_mat (object *shop_mat, object *op);
1697 1788
1698void cf_object_move (object *op, int dir, object *originator = op) 1789int move (object *op, int dir, object *originator = op)
1790 CODE:
1791 RETVAL = move_ob (op, dir, originator);
1792 OUTPUT:
1793 RETVAL
1699 1794
1700void cf_object_apply (object *op, object *author, int flags = 0) 1795void cf_object_apply (object *op, object *author, int flags = 0)
1701 1796
1702void cf_object_apply_below (object *op) 1797void cf_object_apply_below (object *op)
1703 1798
… …
1811 CODE: 1906 CODE:
1812{ 1907{
1813 int unused_type; 1908 int unused_type;
1814 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y); 1909 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1815} 1910}
1816
1817SV *registry (object *op)
1818 CODE:
1819 RETVAL = registry_of (op);
1820 OUTPUT:
1821 RETVAL
1822 1911
1823# syntatic sugar for easier use in event callbacks. 1912# syntatic sugar for easier use in event callbacks.
1824const char *options (object *op) 1913const char *options (object *op)
1825 CODE: 1914 CODE:
1826 RETVAL = op->name; 1915 RETVAL = op->name;
… …
1899 1988
1900void kill_player (object *op) 1989void kill_player (object *op)
1901 1990
1902MODULE = cf PACKAGE = cf::player PREFIX = cf_player_ 1991MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1903 1992
1993int invoke (player *pl, int event, ...)
1994 CODE:
1995 if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
1996 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1997 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1998 RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));
1999 OUTPUT: RETVAL
2000
1904SV *registry (player *pl) 2001SV *registry (player *pl)
1905 CODE: 2002 CODE:
1906 RETVAL = registry_of (pl); 2003 RETVAL = registry_of (pl);
1907 OUTPUT: 2004 OUTPUT:
1908 RETVAL 2005 RETVAL
… …
2032 OUTPUT: RETVAL 2129 OUTPUT: RETVAL
2033 2130
2034 2131
2035MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2132MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2036 2133
2134void
2135trigger (mapstruct *map, long connection, bool state = true)
2136 CODE:
2137 activate_connection (map, connection, state);
2138
2139void
2140get_connection (mapstruct *map, long connection)
2141 PPCODE:
2142{
2143 oblinkpt *obp = get_connection_links (map, connection);
2144 if (obp)
2145 for (objectlink *ol = obp->link; ol; ol = ol->next)
2146 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, ol->ob)));
2147}
2148
2149int invoke (mapstruct *map, int event, ...)
2150 CODE:
2151 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2152 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2153 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2154 RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));
2155 OUTPUT: RETVAL
2156
2037SV *registry (mapstruct *map) 2157SV *registry (mapstruct *map)
2038 CODE: 2158 CODE:
2039 RETVAL = registry_of (map); 2159 RETVAL = registry_of (map);
2040 OUTPUT: 2160 OUTPUT:
2041 RETVAL 2161 RETVAL
… …
2133cf_map_normalise (mapstruct *map, int x, int y) 2253cf_map_normalise (mapstruct *map, int x, int y)
2134 PPCODE: 2254 PPCODE:
2135{ 2255{
2136 mapstruct *nmap = 0; 2256 mapstruct *nmap = 0;
2137 I16 nx = 0, ny = 0; 2257 I16 nx = 0, ny = 0;
2138 int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2258 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2139 2259
2140 EXTEND (SP, 4); 2260 EXTEND (SP, 4);
2141 PUSHs (sv_2mortal (newSViv (flags))); 2261 PUSHs (sv_2mortal (newSViv (flags)));
2142 2262
2143 if (GIMME_V == G_ARRAY) 2263 if (GIMME_V == G_ARRAY)
… …
2155{ 2275{
2156 object *o; 2276 object *o;
2157 mapstruct *nmap = 0; 2277 mapstruct *nmap = 0;
2158 I16 nx, ny; 2278 I16 nx, ny;
2159 2279
2160 cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2280 get_map_flags (map, &nmap, x, y, &nx, &ny);
2161 2281
2162 if (nmap) 2282 if (nmap)
2163 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above) 2283 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2164 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o))); 2284 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2165} 2285}
… …
2224 } 2344 }
2225 } 2345 }
2226} 2346}
2227 2347
2228 2348
2229MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_ 2349MODULE = cf PACKAGE = cf::arch
2230 2350
2231archetype *cf_archetype_get_first() 2351archetype *first()
2232 PROTOTYPE: 2352 PROTOTYPE:
2233 ALIAS: first = 0 2353 CODE:
2354 RETVAL = first_archetype;
2355 OUTPUT: RETVAL
2234 2356
2235archetype *cf_archetype_get_next (archetype *arch) 2357archetype *next (archetype *arch)
2236 ALIAS: next = 0 2358 CODE:
2359 RETVAL = arch->next;
2360 OUTPUT: RETVAL
2237 2361
2238archetype *cf_archetype_get_head (archetype *arch) 2362archetype *head (archetype *arch)
2239 ALIAS: head = 0 2363 CODE:
2364 RETVAL = arch->head;
2365 OUTPUT: RETVAL
2240 2366
2241archetype *cf_archetype_get_more (archetype *arch) 2367archetype *more (archetype *arch)
2242 ALIAS: more = 0 2368 CODE:
2369 RETVAL = arch->more;
2370 OUTPUT: RETVAL
2243 2371
2244const char *cf_archetype_get_name (archetype *arch) 2372const char *name (archetype *arch)
2245 ALIAS: name = 0 2373 CODE:
2374 RETVAL = arch->name;
2375 OUTPUT: RETVAL
2246 2376
2247object *cf_archetype_get_clone (archetype *arch) 2377object *clone (archetype *arch)
2248 ALIAS: clone = 0 2378 CODE:
2379 RETVAL = &arch->clone;
2380 OUTPUT: RETVAL
2249 2381
2250MODULE = cf PACKAGE = cf::party PREFIX = cf_party_ 2382MODULE = cf PACKAGE = cf::party
2251 2383
2252partylist *cf_party_get_first () 2384partylist *first ()
2253 PROTOTYPE: 2385 PROTOTYPE:
2254 ALIAS: first = 0 2386 CODE:
2387 RETVAL = get_firstparty ();
2388 OUTPUT: RETVAL
2255 2389
2256partylist *cf_party_get_next (partylist *party) 2390partylist *next (partylist *party)
2257 ALIAS: next = 0 2391 CODE:
2392 RETVAL = party->next;
2393 OUTPUT: RETVAL
2258 2394
2259const char *cf_party_get_name (partylist *party) 2395const char *name (partylist *party)
2396 CODE:
2397 RETVAL = party->partyname;
2398 OUTPUT: RETVAL
2260 2399
2261const char *cf_party_get_password (partylist *party) 2400const char *password (partylist *party)
2262 ALIAS: password = 0 2401 CODE:
2402 RETVAL = party->passwd;
2403 OUTPUT: RETVAL
2263 2404
2264player *cf_party_get_first_player (partylist *party) 2405MODULE = cf PACKAGE = cf::region
2265 ALIAS: first_player = 0
2266 2406
2267player *cf_party_get_next_player (partylist *party, player *op) 2407region *first ()
2268 ALIAS: next_player = 0
2269
2270
2271MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2272
2273region *cf_region_get_first ()
2274 PROTOTYPE: 2408 PROTOTYPE:
2275 ALIAS: first = 0 2409 CODE:
2410 RETVAL = first_region;
2411 OUTPUT: RETVAL
2276 2412
2413region *next (region *reg)
2414 CODE:
2415 RETVAL = reg->next;
2416 OUTPUT: RETVAL
2417
2418const char *name (region *reg)
2419 CODE:
2420 RETVAL = reg->name;
2421 OUTPUT: RETVAL
2422
2423region *parent (region *reg)
2424 CODE:
2425 RETVAL = reg->parent;
2426 OUTPUT: RETVAL
2427
2277const char *cf_region_get_name (region *reg) 2428const char *longname (region *reg)
2278 ALIAS: name = 0 2429 CODE:
2430 RETVAL = reg->longname;
2431 OUTPUT: RETVAL
2279 2432
2280region *cf_region_get_next (region *reg) 2433const char *msg (region *reg)
2281 ALIAS: next = 0 2434 CODE:
2435 RETVAL = reg->msg;
2436 OUTPUT: RETVAL
2282 2437
2283region *cf_region_get_parent (region *reg) 2438MODULE = cf PACKAGE = cf::living
2284 ALIAS: parent = 0
2285
2286const char *cf_region_get_longname (region *reg)
2287 ALIAS: longname = 0
2288
2289const char *cf_region_get_message (region *reg)
2290 ALIAS: message = 0
2291
2292
2293MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2294 2439
2295val64 2440val64
2296exp (living *liv, val64 new_val = 0) 2441exp (living *liv, val64 new_val = 0)
2297 PROTOTYPE: $;$ 2442 PROTOTYPE: $;$
2298 ALIAS: 2443 ALIAS:

Diff Legend

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