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.41 by root, Sun Sep 3 22:45:57 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.5" 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"
51#include "shstr.h" 35#include "shstr.h"
52 36
37#include <EXTERN.h>
38#include <perl.h>
39#include <XSUB.h>
40
53#include "perlxsi.c" 41#include "perlxsi.c"
54 42
55extern sint64 *levels; // the experience table 43extern sint64 *levels; // the experience table
56 44
57typedef object object_ornull; 45typedef object object_ornull;
… …
59 47
60typedef double val64; 48typedef double val64;
61#define newSVval64 newSVnv 49#define newSVval64 newSVnv
62#define SvVAL64 SvNV 50#define SvVAL64 SvNV
63 51
64static f_plug_api gethook; 52static f_plug_api gethook = cfapi_get_hooks;
65static f_plug_api systemDirectory; 53static f_plug_api object_set_property = cfapi_object_set_property;
66static f_plug_api object_set_property; 54static f_plug_api object_insert = cfapi_object_insert;
67static f_plug_api map_get_map;
68static f_plug_api object_insert;
69 55
70/* this is a stupid way to do things, and awkward to use for plug-in authors */ 56/* this is a stupid way to do things, and awkward to use for plug-in authors */
71typedef struct 57typedef struct
72{ 58{
73 object* who; 59 object* who;
… …
108 94
109 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0); 95 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
110 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1)); 96 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
111} 97}
112 98
113template<class extendable> 99template<class attachable>
114SV * 100SV *
115newSVextendable (extendable *obj, const char *klass) 101newSVattachable (attachable *obj, const char *klass)
116{ 102{
117 if (!obj) 103 if (!obj)
118 return &PL_sv_undef; 104 return &PL_sv_undef;
119 105
120 if (!obj->self) 106 if (!obj->self)
121 obj->self = newSVptr (obj, klass); 107 obj->self = newSVptr (obj, klass);
122 108
123 return newSVsv (static_cast<SV *>(obj->self)); 109 return newSVsv (obj->self);
124} 110}
125 111
126static void 112static void
127SVptr_cache_set (void *ptr, SV *sv) 113SVptr_cache_set (void *ptr, SV *sv)
128{ 114{
… …
227 break; 213 break;
228 214
229 case DT_OBJECT: 215 case DT_OBJECT:
230 { 216 {
231 object *obj = va_arg (ap, object *); 217 object *obj = va_arg (ap, object *);
232 sv = newSVextendable (obj, obj && obj->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap"); 218 sv = newSVattachable (obj, obj && obj->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap");
233 } 219 }
234 break; 220 break;
235 221
236 case DT_MAP: 222 case DT_MAP:
237 // va_arg (object *) when void * is passed is an XSI extension 223 // va_arg (object *) when void * is passed is an XSI extension
238 sv = newSVextendable (va_arg (ap, mapstruct *), "cf::map::wrap"); 224 sv = newSVattachable (va_arg (ap, mapstruct *), "cf::map::wrap");
239 break; 225 break;
240 226
241 case DT_PLAYER: 227 case DT_PLAYER:
242 sv = newSVextendable (va_arg (ap, player *), "cf::player::wrap"); 228 sv = newSVattachable (va_arg (ap, player *), "cf::player::wrap");
243 break; 229 break;
244 230
245 case DT_ARCH: 231 case DT_ARCH:
246 sv = newSVptr (va_arg (ap, archetype *), "cf::arch::wrap"); 232 sv = newSVptr (va_arg (ap, archetype *), "cf::arch::wrap");
247 break; 233 break;
… …
304} 290}
305 291
306////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 292//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
307 293
308SV * 294SV *
309registry_of (extendable_base *ext) 295registry_of (attachable_base *ext)
310{ 296{
311 if (!ext->cb) 297 if (!ext->cb)
312 ext->cb = newAV (); 298 ext->cb = newAV ();
313 299
314 return newRV_inc ((SV *)ext->cb); 300 return newRV_inc ((SV *)ext->cb);
315} 301}
316 302
317void extendable_base::clear () 303void attachable_base::clear ()
318{ 304{
319 //if (self) fprintf (stderr, "free_ob_self %p %s (%p,%p)\n", this, ((object *)this)->name, self, cb);//D 305 if (self)
306 {
307 if (cb)
308 if (SvROK (*av_fetch (cb, EVENT_OBJECT_DESTROY, 1)))
309 INVOKE_OBJECT (DESTROY, static_cast<object *>(this));
310 else if (SvROK (*av_fetch (cb, EVENT_MAP_DESTROY, 1)))
311 INVOKE_MAP (DESTROY, static_cast<mapstruct *>(this));
320 312
313 // disconnect Perl from C, to avoid crashes
314 sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
315
316 // clear the perl hash, might or might not be a good idea
317 hv_clear ((HV *)SvRV ((SV *)self));
318
321 if (self) SvREFCNT_dec (self); 319 SvREFCNT_dec (self);
320 self = 0;
321 }
322
323 if (cb)
324 {
322 if (cb) SvREFCNT_dec (cb); 325 SvREFCNT_dec (cb);
326 cb = 0;
327 }
323 328
324 if (attach) free_string (attach);
325
326 self = 0;
327 cb = 0;
328 attach = 0; 329 attach = 0;
329} 330}
330 331
331void extendable_base::optimise () 332void attachable_base::optimise ()
332{ 333{
333 if (!self) 334 if (!self)
334 return; 335 return;
335 336
336 HV *hv = (HV *)SvRV ((SV *)self); 337 HV *hv = (HV *)SvRV ((SV *)self);
… …
342 SvREFCNT_dec ((SV *)self); 343 SvREFCNT_dec ((SV *)self);
343 self = 0; 344 self = 0;
344 } 345 }
345} 346}
346 347
347void 348void attachable_base::instantiate (data_type type, void *obj)
348object::instantiate_ ()
349{ 349{
350 dSP; 350 dSP;
351 ENTER; 351 ENTER;
352 SAVETMPS; 352 SAVETMPS;
353 PUSHMARK (SP); 353 PUSHMARK (SP);
354 EXTEND (SP, 2); 354 EXTEND (SP, 2);
355 PUSHs (sv_2mortal (newSVdt (DT_OBJECT, static_cast<object *>(this)))); 355 PUSHs (sv_2mortal (newSVdt (type, obj)));
356 PUSHs (sv_2mortal (newSVpv (attach, 0))); 356 PUSHs (sv_2mortal (newSVpv (attach, 0)));
357
358 attach = 0;
359
357 PUTBACK; 360 PUTBACK;
358 call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL); 361 call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL);
359 FREETMPS; 362 FREETMPS;
360 LEAVE; 363 LEAVE;
364
365 switch (type)
366 {
367 case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
368 case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
369 }
361} 370}
362 371
363///////////////////////////////////////////////////////////////////////////// 372/////////////////////////////////////////////////////////////////////////////
364 373
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) 374void reattach (data_type type, void *obj)
425{ 375{
376 //TODO only do this when the object has _attachment's
377
426 dSP; 378 dSP;
427 ENTER; 379 ENTER;
428 SAVETMPS; 380 SAVETMPS;
429 PUSHMARK (SP); 381 PUSHMARK (SP);
430 XPUSHs (sv_2mortal (newSVdt (type, obj))); 382 XPUSHs (sv_2mortal (newSVdt (type, obj)));
… …
440 case DT_MAP: INVOKE_MAP (REATTACH, obj); break; 392 case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
441 } 393 }
442} 394}
443 395
444template<class subclass> 396template<class subclass>
445void reattach (extendable<subclass> *obj) 397void reattach (attachable<subclass> *obj)
446{ 398{
399 obj->optimise ();
400
447 if (obj->self) 401 if (obj->self)
448 reattach (subclass::get_dt (), (subclass *)obj); 402 reattach ((data_type) cftype<subclass>::dt, (subclass *)obj);
449} 403}
450 404
405#include "kw_hash.h"
406
407object_freezer::object_freezer ()
408: dynbuf (128 * 1024, 64 * 1024)
409{
410 av = newAV ();
411}
412
413object_freezer::~object_freezer ()
414{
415 SvREFCNT_dec (av);
416}
417
418void object_freezer::put (attachable_base *ext)
419{
420 ext->optimise ();
421
422 if (ext->self)
423 {
424 int idx = AvFILLp ((AV *)av) + 1;
425 av_store (av, idx, SvREFCNT_inc (ext->self));
426
427 add ((void *)"oid ", 4);
428 add ((sint32)idx);
429 add ('\n');
430 }
431}
432
433bool object_freezer::save (const char *filename)
434{
435 dSP;
436 ENTER;
437 SAVETMPS;
438 PUSHMARK (SP);
439 EXTEND (SP, 3);
440 PUSHs (sv_2mortal (newSVpv (filename, 0)));
441 PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
442 PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
443 PUTBACK;
444 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
445 FREETMPS;
446 LEAVE;
447}
448
449int fprintf (object_freezer &freezer, const char *format, ...)
450{
451 va_list ap;
452
453 va_start (ap, format);
454
455 int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
456
457 if (len >= 0)
458 freezer.alloc (len);
459
460 va_end (ap);
461}
462
463int fputs (const char *s, object_freezer &freezer)
464{
465 freezer.add (s);
466}
467
468object_thawer::object_thawer (const char *filename)
469{
470 static const char eof[] = "\n\n\n\0\0\0";
471
472 av = 0;
473 text = 0;
474
475 if (filename)
476 {
477 dSP;
478 ENTER;
479 SAVETMPS;
480 PUSHMARK (SP);
481 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
482 PUTBACK;
483
484 if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
485 {
486 SPAGAIN;
487
488 // second value - perl objects
489 {
490 SV *sv = POPs;
491 if (SvROK (sv))
492 av = (AV *)SvREFCNT_inc (SvRV (sv));
493 }
494
495 // first value - text part, pad with 3 zeroes
496 {
497 SV *sv = POPs;
498 STRLEN len;
499 char *sv_ = SvPVbyte (sv, len);
500 text = newSV (len + sizeof (eof));
501 SvCUR_set (text, len);
502 memcpy (SvPVX (text), sv_, len);
503 memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
504 }
505 }
506
507 PUTBACK;
508 FREETMPS;
509 LEAVE;
510 }
511
512 if (!text)
513 text = newSVpvn (eof, sizeof (eof));
514
515 line = SvPVX (text);
516}
517
451void object_thawer::get (data_type type, void *obj, extendable_base *ext) 518void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
452{ 519{
453 if (!av) 520 if (!av || oid < 0) // this is actually an error of sorts
454 return; 521 return;
455 522
456 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach 523 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach
457 ext->clear (); 524 ext->clear ();
458 525
459 SV **svp = av_fetch ((AV *)av, idx, 0); 526 SV **svp = av_fetch ((AV *)av, oid, 0);
460 527
461 ++idx;
462
463 if (!svp)
464 return;
465
466 if (SvROK (*svp)) 528 if (!svp || !SvROK (*svp))
467 { 529 {
468 ext->self = SvREFCNT_inc (*svp); 530 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); 531 return;
470
471 reattach (type, obj);
472 } 532 }
533
534 ext->self = *svp; *svp = &PL_sv_undef;
535 sv_magic (SvRV (ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
536
537 reattach (type, obj);
473} 538}
474 539
475object_thawer::~object_thawer () 540object_thawer::~object_thawer ()
476{ 541{
542 if (text) SvREFCNT_dec (text);
543 if (av) SvREFCNT_dec (av);
544}
545
546char *fgets (char *s, int n, object_thawer &thawer)
547{
548 char *p = thawer.line;
549 char *q = s;
550
551 while (--n)
552 {
553 if (!*p)
554 break;
555
556 *q++ = *p;
557
558 if (*p++ == '\n')
559 break;
560 }
561
562 *q = 0;
563 thawer.line = p;
564
565 return s == q ? 0 : s;
566}
567
568keyword object_thawer::get_kv ()
569{
570 for (;;)
571 {
572 char *p = line;
573
574 if (!*p)
575 return KW_EOF;
576
577 // parse keyword
578 while (*p > ' ')
579 p++;
580
581 int klen = p - line;
582
583 if (*p++ != '\n')
584 {
585 // parse value
586 while (*p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
587 ++p;
588
589 last_value = p;
590
591 while (*p != '\n')
592 p++;
593
594 *p++ = 0;
595 }
596 else
597 last_value = 0;
598
599 line [klen] = 0;
600 keyword_idx *kw = kw_lex::match (line, klen);
601
602 //printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
603
604 if (kw)
605 {
606 line = p;
607 return kw->index;
608 }
609 else if (!*line || *line == '#')
610 {
611 // empty/comment line
612 line = p;
613 }
614 else
615 return KW_ERROR;
616 }
617}
618
619void object_thawer::get (shstr &sh) const
620{
621 if (last_value)
622 sh = last_value;
623 else
624 {
625 sh = "<value missing>";
626 LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
627 }
628}
629
630void object_thawer::get_ml (keyword kend, shstr &sh)
631{
632 char kw[128];
633
634 // multi-line strings are delimited by "\nendXXX\n"
635 kw [0] = '\n';
636 strcpy (kw + 1, keyword_str [kend]);
637
638 char *end = strstr (line, kw);
639
640 if (!end)
641 {
642 sh = 0;
643 return;
644 }
645
646 *end = 0;
647 sh = line;
648
649 line = end + keyword_len [kend] + 1;
650
651 while (*line++ != '\n')
652 ;
653}
654
655sint32 object_thawer::get_sint32 () const
656{
657 char *p = last_value;
658
477 if (av) 659 if (!p)
478 SvREFCNT_dec ((SV *)av); 660 return 0;
661
662 sint32 val = 0;
663 bool negate;
664
665 if (*p == '-')
666 {
667 negate = true;
668 ++p;
669 }
670 else
671 negate = false;
672
673 do
674 {
675 val *= 10;
676 val += *p++ - '0';
677 }
678 while (*p);
679
680 return negate ? -val : val;
681}
682
683sint64 object_thawer::get_sint64 () const
684{
685 return last_value ? atoll (last_value) : 0;
686}
687
688double object_thawer::get_double () const
689{
690 return last_value ? atof (last_value) : 0;
479} 691}
480 692
481///////////////////////////////////////////////////////////////////////////// 693/////////////////////////////////////////////////////////////////////////////
482 694
483extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 695extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
484{ 696{
485 gethook = gethooksptr;
486 printf (PLUGIN_VERSION " init\n");
487
488 return 0; 697 return 0;
489} 698}
490 699
491static CommArray_s rtn_cmd; 700static CommArray_s rtn_cmd;
492 701
… …
572extern "C" int cfperl_postInitPlugin () 781extern "C" int cfperl_postInitPlugin ()
573{ 782{
574 int hooktype = 1; 783 int hooktype = 1;
575 int rtype = 0; 784 int rtype = 0;
576 785
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); 786 cf_init_plugin (gethook);
585 787
586 return 0; 788 return 0;
587} 789}
588 790
… …
592} 794}
593 795
594void 796void
595cfperl_init () 797cfperl_init ()
596{ 798{
799 PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);
800 perl = perl_alloc ();
801 perl_construct (perl);
802
803 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
804
597 char *argv[] = { 805 char *argv[] = {
598 "", 806 "",
599 "-e" 807 "-e"
600 "BEGIN {"
601 " cf->bootstrap;" 808 "cf->bootstrap;"
602 " unshift @INC, cf::datadir ();" 809 "unshift @INC, cf::datadir ();"
603 "}"
604 ""
605 "use cf;" 810 "require cf;"
606 }; 811 };
607
608 perl = perl_alloc ();
609 perl_construct (perl);
610
611 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
612 812
613 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl)) 813 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))
614 { 814 {
615 printf ("unable to initialize perl-interpreter, aborting.\n"); 815 printf ("unable to initialize perl-interpreter, aborting.\n");
616
617 exit (EXIT_FAILURE); 816 exit (EXIT_FAILURE);
618 //perl_destruct (perl);
619 //perl_free (perl);
620 //perl = 0;
621 //return;
622 } 817 }
623 818
624 obj_cache = newHV (); 819 obj_cache = newHV ();
625} 820}
626 821
… …
636static event_klass klass_of[NUM_EVENT_TYPES] = { 831static event_klass klass_of[NUM_EVENT_TYPES] = {
637# define def(type,name) KLASS_ ## type, 832# define def(type,name) KLASS_ ## type,
638# include "eventinc.h" 833# include "eventinc.h"
639# undef def 834# undef def
640}; 835};
836
837#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
641 838
642static void 839static void
643gather_callbacks (AV *&callbacks, AV *registry, event_type event) 840gather_callbacks (AV *&callbacks, AV *registry, event_type event)
644{ 841{
645 // event must be in array 842 // event must be in array
… …
688 // 2a. per-type callback 885 // 2a. per-type callback
689 // 4. global callbacks 886 // 4. global callbacks
690 887
691 gather_callbacks (callbacks, cb_global, event); 888 gather_callbacks (callbacks, cb_global, event);
692 889
693 switch (klass_of [event]) 890 switch (KLASS_OF (event))
694 { 891 {
695 case KLASS_GLOBAL: 892 case KLASS_GLOBAL:
696 break; 893 break;
697 894
698 case KLASS_OBJECT: 895 case KLASS_OBJECT:
699 dt = (data_type) va_arg (ap, int); 896 dt = (data_type) va_arg (ap, int);
700 assert (("first argument must be of type object", dt == DT_OBJECT)); 897 assert (("first argument must be of type object", dt == DT_OBJECT));
701 op = va_arg (ap, object *); 898 op = va_arg (ap, object *);
702 899
703 if (op->cb) 900 if (op->cb)
704 gather_callbacks (callbacks, (AV *)op->cb, event); 901 gather_callbacks (callbacks, op->cb, event);
705 902
706 if (op->type) 903 if (op->type)
707 { 904 {
708 if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type)) 905 if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
709 { 906 {
… …
730 dt = (data_type) va_arg (ap, int); 927 dt = (data_type) va_arg (ap, int);
731 assert (("first argument must be of type player", dt == DT_PLAYER)); 928 assert (("first argument must be of type player", dt == DT_PLAYER));
732 pl = va_arg (ap, player *); 929 pl = va_arg (ap, player *);
733 930
734 if (pl->cb) 931 if (pl->cb)
735 gather_callbacks (callbacks, (AV *)pl->cb, event); 932 gather_callbacks (callbacks, pl->cb, event);
736 933
737 gather_callbacks (callbacks, cb_player, event); 934 gather_callbacks (callbacks, cb_player, event);
738 break; 935 break;
739 936
740 case KLASS_MAP: 937 case KLASS_MAP:
741 dt = (data_type) va_arg (ap, int); 938 dt = (data_type) va_arg (ap, int);
742 assert (("first argument must be of type object", dt == DT_MAP)); 939 assert (("first argument must be of type object", dt == DT_MAP));
743 map = va_arg (ap, mapstruct *); 940 map = va_arg (ap, mapstruct *);
744 941
745 if (map->cb) 942 if (map->cb)
746 gather_callbacks (callbacks, (AV *)map->cb, event); 943 gather_callbacks (callbacks, map->cb, event);
747 944
748 gather_callbacks (callbacks, cb_map, event); 945 gather_callbacks (callbacks, cb_map, event);
749 break; 946 break;
750 947
751 default: 948 default:
… …
764 EXTEND (SP, 3); 961 EXTEND (SP, 3);
765 962
766 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays 963 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays
767 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks))); 964 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));
768 965
769 switch (klass_of [event]) 966 switch (KLASS_OF (event))
770 { 967 {
771 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break; 968 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;
772 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break; 969 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;
773 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break; 970 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;
774 } 971 }
… …
1203 1400
1204 const_iv (SK_EXP_ADD_SKILL) 1401 const_iv (SK_EXP_ADD_SKILL)
1205 const_iv (SK_EXP_TOTAL) 1402 const_iv (SK_EXP_TOTAL)
1206 const_iv (SK_EXP_NONE) 1403 const_iv (SK_EXP_NONE)
1207 const_iv (SK_SUBTRACT_SKILL_EXP) 1404 const_iv (SK_SUBTRACT_SKILL_EXP)
1405 const_iv (SK_EXP_SKILL_ONLY)
1208 1406
1209 const_iv (SK_LOCKPICKING) 1407 const_iv (SK_LOCKPICKING)
1210 const_iv (SK_HIDING) 1408 const_iv (SK_HIDING)
1211 const_iv (SK_SMITHERY) 1409 const_iv (SK_SMITHERY)
1212 const_iv (SK_BOWYER) 1410 const_iv (SK_BOWYER)
… …
1371 prop (CFAPI_INT, MAP_PROP_WINDDIR) 1569 prop (CFAPI_INT, MAP_PROP_WINDDIR)
1372 prop (CFAPI_INT, MAP_PROP_SKY) 1570 prop (CFAPI_INT, MAP_PROP_SKY)
1373 prop (CFAPI_INT, MAP_PROP_WPARTX) 1571 prop (CFAPI_INT, MAP_PROP_WPARTX)
1374 prop (CFAPI_INT, MAP_PROP_WPARTY) 1572 prop (CFAPI_INT, MAP_PROP_WPARTY)
1375 prop (CFAPI_STRING, MAP_PROP_MESSAGE) 1573 prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1376 prop (CFAPI_PMAP, MAP_PROP_NEXT)
1377 prop (CFAPI_PREGION, MAP_PROP_REGION) 1574 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) 1575 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1381 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB) 1576 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1382 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY) 1577 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1383 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT) 1578 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1384 prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1385 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER) 1579 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1386 prop (CFAPI_PMAP, OBJECT_PROP_MAP) 1580 prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1387 prop (CFAPI_INT, OBJECT_PROP_COUNT) 1581 prop (CFAPI_INT, OBJECT_PROP_COUNT)
1388 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT) 1582 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1389 prop (CFAPI_STRING, OBJECT_PROP_NAME) 1583 prop (CFAPI_STRING, OBJECT_PROP_NAME)
… …
1521 PROTOTYPE: $$ 1715 PROTOTYPE: $$
1522 1716
1523char *path_combine_and_normalize (char *base, char *path) 1717char *path_combine_and_normalize (char *base, char *path)
1524 PROTOTYPE: $$ 1718 PROTOTYPE: $$
1525 1719
1526char * 1720const char *
1527cf_get_maps_directory (char *path) 1721get_maps_directory (char *path)
1528 PROTOTYPE: $ 1722 PROTOTYPE: $
1529 ALIAS: maps_directory = 0 1723 ALIAS: maps_directory = 0
1724 CODE:
1725 RETVAL = create_pathname (path);
1726 OUTPUT: RETVAL
1530 1727
1531void 1728void
1532sub_generation_inc () 1729sub_generation_inc ()
1533 CODE: 1730 CODE:
1534 PL_sub_generation++; 1731 PL_sub_generation++;
… …
1543 confdir = 3 1740 confdir = 3
1544 localdir = 4 1741 localdir = 4
1545 playerdir = 5 1742 playerdir = 5
1546 datadir = 6 1743 datadir = 6
1547 CODE: 1744 CODE:
1548{ 1745 switch (ix)
1549 int unused_type; 1746 {
1550 RETVAL = (char *)systemDirectory (&unused_type, ix); 1747 case 0: RETVAL = settings.mapdir ; break;
1551} 1748 case 1: RETVAL = settings.uniquedir; break;
1749 case 2: RETVAL = settings.tmpdir ; break;
1750 case 3: RETVAL = settings.confdir ; break;
1751 case 4: RETVAL = settings.localdir ; break;
1752 case 5: RETVAL = settings.playerdir; break;
1753 case 6: RETVAL = settings.datadir ; break;
1754 }
1552 OUTPUT: RETVAL 1755 OUTPUT: RETVAL
1553 1756
1554int 1757int
1555cf_find_animation (char *text) 1758cf_find_animation (char *text)
1556 PROTOTYPE: $ 1759 PROTOTYPE: $
1557 1760
1558int random_roll(int min, int max, object *op, int goodbad); 1761int random_roll(int min, int max, object *op, int goodbad);
1559 1762
1560const char *cost_string_from_value(uint64 cost, int approx = 0) 1763const char *cost_string_from_value(uint64 cost, int approx = 0)
1561 1764
1562int invoke (int event, SV *arg1, ...) 1765int invoke (int event, ...)
1563 CODE: 1766 CODE:
1564{ 1767 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1565 // parse first arg and call invoke_object etc as seen fit 1768 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1566 //TODO 1769 for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1567 //cfperl_invoke (event, 1770 RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1568} 1771 OUTPUT: RETVAL
1569 1772
1570int 1773int
1571exp_to_level (val64 exp) 1774exp_to_level (val64 exp)
1572 CODE: 1775 CODE:
1573{ 1776{
… …
1604 RETVAL = newSVpv (resist_plus[atnr], 0); 1807 RETVAL = newSVpv (resist_plus[atnr], 0);
1605 else 1808 else
1606 XSRETURN_UNDEF; 1809 XSRETURN_UNDEF;
1607 OUTPUT: RETVAL 1810 OUTPUT: RETVAL
1608 1811
1812int
1813_valid (SV *obj)
1814 CODE:
1815 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1816 OUTPUT:
1817 RETVAL
1818
1609MODULE = cf PACKAGE = cf::object PREFIX = cf_object_ 1819MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1820
1821int invoke (object *op, int event, ...)
1822 CODE:
1823 if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1824 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1825 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1826 RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));
1827 OUTPUT: RETVAL
1828
1829SV *registry (object *op)
1830 CODE:
1831 RETVAL = registry_of (op);
1832 OUTPUT:
1833 RETVAL
1834
1835object *head (object *op)
1836 PROTOTYPE: $
1837 ALIAS:
1838 more = 1
1839 above = 2
1840 below = 3
1841 CODE:
1842 switch (ix)
1843 {
1844 case 0: RETVAL = op->head ? op->head : op; break; // DOH!
1845 case 1: RETVAL = op->more; break;
1846 case 2: RETVAL = op->above; break;
1847 case 3: RETVAL = op->below; break;
1848 }
1849 OUTPUT:
1850 RETVAL
1610 1851
1611SV * 1852SV *
1612get_property (object *obj, int type, int idx) 1853get_property (object *obj, int type, int idx)
1613 CODE: 1854 CODE:
1614 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx)); 1855 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));
… …
1693 1934
1694int need_identify (const object *obj); 1935int need_identify (const object *obj);
1695 1936
1696int apply_shop_mat (object *shop_mat, object *op); 1937int apply_shop_mat (object *shop_mat, object *op);
1697 1938
1698void cf_object_move (object *op, int dir, object *originator = op) 1939int move (object *op, int dir, object *originator = op)
1940 CODE:
1941 RETVAL = move_ob (op, dir, originator);
1942 OUTPUT:
1943 RETVAL
1699 1944
1700void cf_object_apply (object *op, object *author, int flags = 0) 1945void cf_object_apply (object *op, object *author, int flags = 0)
1701 1946
1702void cf_object_apply_below (object *op) 1947void cf_object_apply_below (object *op)
1703 1948
… …
1744int cf_object_out_of_map (object *op, int x, int y) 1989int cf_object_out_of_map (object *op, int x, int y)
1745 1990
1746void cf_object_drop (object *op, object *author) 1991void cf_object_drop (object *op, object *author)
1747 1992
1748void cf_object_take (object *op, object *author) 1993void cf_object_take (object *op, object *author)
1749
1750void cf_object_say (object *op, char *msg)
1751
1752void cf_object_speak (object *op, char *msg)
1753 1994
1754object *cf_object_insert_object (object *op, object *container) 1995object *cf_object_insert_object (object *op, object *container)
1755 1996
1756const char *cf_object_get_msg (object *ob) 1997const char *cf_object_get_msg (object *ob)
1757 ALIAS: msg = 0 1998 ALIAS: msg = 0
… …
1811 CODE: 2052 CODE:
1812{ 2053{
1813 int unused_type; 2054 int unused_type;
1814 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y); 2055 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1815} 2056}
1816
1817SV *registry (object *op)
1818 CODE:
1819 RETVAL = registry_of (op);
1820 OUTPUT:
1821 RETVAL
1822 2057
1823# syntatic sugar for easier use in event callbacks. 2058# syntatic sugar for easier use in event callbacks.
1824const char *options (object *op) 2059const char *options (object *op)
1825 CODE: 2060 CODE:
1826 RETVAL = op->name; 2061 RETVAL = op->name;
… …
1899 2134
1900void kill_player (object *op) 2135void kill_player (object *op)
1901 2136
1902MODULE = cf PACKAGE = cf::player PREFIX = cf_player_ 2137MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1903 2138
2139int invoke (player *pl, int event, ...)
2140 CODE:
2141 if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2142 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2143 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2144 RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));
2145 OUTPUT: RETVAL
2146
1904SV *registry (player *pl) 2147SV *registry (player *pl)
1905 CODE: 2148 CODE:
1906 RETVAL = registry_of (pl); 2149 RETVAL = registry_of (pl);
1907 OUTPUT: 2150 OUTPUT:
1908 RETVAL 2151 RETVAL
… …
2032 OUTPUT: RETVAL 2275 OUTPUT: RETVAL
2033 2276
2034 2277
2035MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2278MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2036 2279
2280mapstruct *first ()
2281 PROTOTYPE:
2282 CODE:
2283 RETVAL = first_map;
2284 OUTPUT: RETVAL
2285
2286mapstruct *next (mapstruct *map)
2287 PROTOTYPE:
2288 CODE:
2289 RETVAL = map->next;
2290 OUTPUT: RETVAL
2291
2292int invoke (mapstruct *map, int event, ...)
2293 CODE:
2294 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2295 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2296 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2297 RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));
2298 OUTPUT: RETVAL
2299
2037SV *registry (mapstruct *map) 2300SV *registry (mapstruct *map)
2038 CODE: 2301 CODE:
2039 RETVAL = registry_of (map); 2302 RETVAL = registry_of (map);
2040 OUTPUT: 2303 OUTPUT:
2041 RETVAL 2304 RETVAL
… …
2060 2323
2061mapstruct *new (int width, int height) 2324mapstruct *new (int width, int height)
2062 PROTOTYPE: 2325 PROTOTYPE:
2063 CODE: 2326 CODE:
2064{ 2327{
2065 int unused_type; 2328 RETVAL = get_empty_map (width, height);
2066 RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
2067} 2329}
2068 OUTPUT: 2330 OUTPUT:
2069 RETVAL 2331 RETVAL
2070 2332
2071void delete_map (mapstruct *map) 2333void delete_map (mapstruct *map)
… …
2086 XSRETURN_UNDEF; 2348 XSRETURN_UNDEF;
2087 RETVAL = map->tile_path [dir]; 2349 RETVAL = map->tile_path [dir];
2088 OUTPUT: 2350 OUTPUT:
2089 RETVAL 2351 RETVAL
2090 2352
2091mapstruct *cf_map_get_map (char *name) 2353mapstruct *ready_map_name (char *name, int flags = 0)
2092 PROTOTYPE: $ 2354 PROTOTYPE: $;$
2093 ALIAS: map = 0 2355 ALIAS:
2356 find = 0
2357 get_map = 1
2094 2358
2095mapstruct *has_been_loaded (char *name) 2359mapstruct *has_been_loaded (char *name)
2096 PROTOTYPE: $ 2360 PROTOTYPE: $
2097
2098mapstruct *cf_map_get_first ()
2099 PROTOTYPE:
2100 ALIAS: first = 0
2101 2361
2102# whoever "designed" the plug-in api should have wasted 2362# whoever "designed" the plug-in api should have wasted
2103# his/her time with staying away from the project - would have 2363# his/her time with staying away from the project - would have
2104# saved others a lot of time, without doubt. 2364# saved others a lot of time, without doubt.
2105void set_path (mapstruct *where, char *path) 2365void set_path (mapstruct *where, char *path)
… …
2120 2380
2121void set_unique (mapstruct *map, bool unique) 2381void set_unique (mapstruct *map, bool unique)
2122 CODE: 2382 CODE:
2123 map->unique = unique; 2383 map->unique = unique;
2124 2384
2385void
2386trigger (mapstruct *map, long connection, bool state = true)
2387 CODE:
2388 activate_connection (map, connection, state);
2389
2390void
2391get_connection (mapstruct *map, long connection)
2392 PPCODE:
2393 oblinkpt *obp = get_connection_links (map, connection);
2394 if (obp)
2395 for (objectlink *ol = obp->link; ol; ol = ol->next)
2396 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, ol->ob)));
2397
2125object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags) 2398object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags)
2126 2399
2127object *cf_map_insert_object (mapstruct *where, object* op, int x, int y) 2400object *cf_map_insert_object (mapstruct *where, object* op, int x, int y)
2128 2401
2129object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny) 2402object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny)
… …
2133cf_map_normalise (mapstruct *map, int x, int y) 2406cf_map_normalise (mapstruct *map, int x, int y)
2134 PPCODE: 2407 PPCODE:
2135{ 2408{
2136 mapstruct *nmap = 0; 2409 mapstruct *nmap = 0;
2137 I16 nx = 0, ny = 0; 2410 I16 nx = 0, ny = 0;
2138 int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2411 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2139 2412
2140 EXTEND (SP, 4); 2413 EXTEND (SP, 4);
2141 PUSHs (sv_2mortal (newSViv (flags))); 2414 PUSHs (sv_2mortal (newSViv (flags)));
2142 2415
2143 if (GIMME_V == G_ARRAY) 2416 if (GIMME_V == G_ARRAY)
… …
2155{ 2428{
2156 object *o; 2429 object *o;
2157 mapstruct *nmap = 0; 2430 mapstruct *nmap = 0;
2158 I16 nx, ny; 2431 I16 nx, ny;
2159 2432
2160 cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2433 get_map_flags (map, &nmap, x, y, &nx, &ny);
2161 2434
2162 if (nmap) 2435 if (nmap)
2163 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above) 2436 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2164 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o))); 2437 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2165} 2438}
… …
2190 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break; 2463 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2191 } 2464 }
2192 OUTPUT: 2465 OUTPUT:
2193 RETVAL 2466 RETVAL
2194 2467
2195# "deserialise" perl map data into the map # TODO# compatibility cruft, remove
2196void
2197_set_obs (mapstruct *map, SV *sv)
2198 CODE:
2199{
2200 object *o;
2201 AV *av;
2202 int x, y;
2203 AV *obs = (AV *)SvRV (sv);
2204 2468
2205 for (y = 0; y < MAP_HEIGHT (map); y++) 2469MODULE = cf PACKAGE = cf::arch
2206 for (x = 0; x < MAP_WIDTH (map); x++)
2207 {
2208 sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);
2209 2470
2210 if (!SvROK (sv)) 2471archetype *find (const char *name)
2211 continue; 2472 CODE:
2473 RETVAL = find_archetype (name);
2474 OUTPUT:
2475 RETVAL
2212 2476
2213 av = (AV *)SvRV (sv); 2477archetype *first()
2214
2215 for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2216 {
2217 sv = av_shift (av);
2218
2219 if (SvROK (sv))
2220 {
2221 sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2222 SVptr_cache_set (o, sv);
2223 }
2224 }
2225 }
2226}
2227
2228
2229MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_
2230
2231archetype *cf_archetype_get_first()
2232 PROTOTYPE: 2478 PROTOTYPE:
2233 ALIAS: first = 0 2479 CODE:
2480 RETVAL = first_archetype;
2481 OUTPUT: RETVAL
2234 2482
2235archetype *cf_archetype_get_next (archetype *arch) 2483archetype *next (archetype *arch)
2236 ALIAS: next = 0 2484 CODE:
2485 RETVAL = arch->next;
2486 OUTPUT: RETVAL
2237 2487
2238archetype *cf_archetype_get_head (archetype *arch) 2488archetype *head (archetype *arch)
2239 ALIAS: head = 0 2489 CODE:
2490 RETVAL = arch->head;
2491 OUTPUT: RETVAL
2240 2492
2241archetype *cf_archetype_get_more (archetype *arch) 2493archetype *more (archetype *arch)
2242 ALIAS: more = 0 2494 CODE:
2495 RETVAL = arch->more;
2496 OUTPUT: RETVAL
2243 2497
2244const char *cf_archetype_get_name (archetype *arch) 2498const char *name (archetype *arch)
2245 ALIAS: name = 0 2499 CODE:
2500 RETVAL = arch->name;
2501 OUTPUT: RETVAL
2246 2502
2247object *cf_archetype_get_clone (archetype *arch) 2503object *clone (archetype *arch)
2248 ALIAS: clone = 0 2504 CODE:
2505 RETVAL = &arch->clone;
2506 OUTPUT: RETVAL
2249 2507
2250MODULE = cf PACKAGE = cf::party PREFIX = cf_party_ 2508MODULE = cf PACKAGE = cf::party
2251 2509
2252partylist *cf_party_get_first () 2510partylist *first ()
2253 PROTOTYPE: 2511 PROTOTYPE:
2254 ALIAS: first = 0 2512 CODE:
2513 RETVAL = get_firstparty ();
2514 OUTPUT: RETVAL
2255 2515
2256partylist *cf_party_get_next (partylist *party) 2516partylist *next (partylist *party)
2257 ALIAS: next = 0 2517 CODE:
2518 RETVAL = party->next;
2519 OUTPUT: RETVAL
2258 2520
2259const char *cf_party_get_name (partylist *party) 2521const char *name (partylist *party)
2522 CODE:
2523 RETVAL = party->partyname;
2524 OUTPUT: RETVAL
2260 2525
2261const char *cf_party_get_password (partylist *party) 2526const char *password (partylist *party)
2262 ALIAS: password = 0 2527 CODE:
2528 RETVAL = party->passwd;
2529 OUTPUT: RETVAL
2263 2530
2264player *cf_party_get_first_player (partylist *party) 2531MODULE = cf PACKAGE = cf::region
2265 ALIAS: first_player = 0
2266 2532
2267player *cf_party_get_next_player (partylist *party, player *op) 2533region *first ()
2268 ALIAS: next_player = 0
2269
2270
2271MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2272
2273region *cf_region_get_first ()
2274 PROTOTYPE: 2534 PROTOTYPE:
2275 ALIAS: first = 0 2535 CODE:
2536 RETVAL = first_region;
2537 OUTPUT: RETVAL
2276 2538
2539region *next (region *reg)
2540 CODE:
2541 RETVAL = reg->next;
2542 OUTPUT: RETVAL
2543
2544const char *name (region *reg)
2545 CODE:
2546 RETVAL = reg->name;
2547 OUTPUT: RETVAL
2548
2549region *parent (region *reg)
2550 CODE:
2551 RETVAL = reg->parent;
2552 OUTPUT: RETVAL
2553
2277const char *cf_region_get_name (region *reg) 2554const char *longname (region *reg)
2278 ALIAS: name = 0 2555 CODE:
2556 RETVAL = reg->longname;
2557 OUTPUT: RETVAL
2279 2558
2280region *cf_region_get_next (region *reg) 2559const char *msg (region *reg)
2281 ALIAS: next = 0 2560 CODE:
2561 RETVAL = reg->msg;
2562 OUTPUT: RETVAL
2282 2563
2283region *cf_region_get_parent (region *reg) 2564MODULE = 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 2565
2295val64 2566val64
2296exp (living *liv, val64 new_val = 0) 2567exp (living *liv, val64 new_val = 0)
2297 PROTOTYPE: $;$ 2568 PROTOTYPE: $;$
2298 ALIAS: 2569 ALIAS:

Diff Legend

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