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.42 by root, Mon Sep 4 11:08:00 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 line = 0;
475
476 if (filename)
477 {
478 dSP;
479 ENTER;
480 SAVETMPS;
481 PUSHMARK (SP);
482 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
483 PUTBACK;
484
485 if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
486 {
487 SPAGAIN;
488
489 // second value - perl objects
490 {
491 SV *sv = POPs;
492 if (SvROK (sv))
493 av = (AV *)SvREFCNT_inc (SvRV (sv));
494 }
495
496 // first value - text part, pad with 3 zeroes
497 {
498 SV *sv = POPs;
499 STRLEN len;
500 char *sv_ = SvPVbyte (sv, len);
501 text = newSV (len + sizeof (eof));
502 SvCUR_set (text, len);
503 memcpy (SvPVX (text), sv_, len);
504 memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
505
506 line = SvPVX (text);
507 }
508 }
509
510 PUTBACK;
511 FREETMPS;
512 LEAVE;
513 }
514}
515
451void object_thawer::get (data_type type, void *obj, extendable_base *ext) 516void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
452{ 517{
453 if (!av) 518 if (!av || oid < 0) // this is actually an error of sorts
454 return; 519 return;
455 520
456 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach 521 // we have to "re-instantiate"/reattach to an object, so nuke ext->attach
457 ext->clear (); 522 ext->clear ();
458 523
459 SV **svp = av_fetch ((AV *)av, idx, 0); 524 SV **svp = av_fetch ((AV *)av, oid, 0);
460 525
461 ++idx;
462
463 if (!svp)
464 return;
465
466 if (SvROK (*svp)) 526 if (!svp || !SvROK (*svp))
467 { 527 {
468 ext->self = SvREFCNT_inc (*svp); 528 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); 529 return;
470
471 reattach (type, obj);
472 } 530 }
531
532 ext->self = *svp; *svp = &PL_sv_undef;
533 sv_magic (SvRV (ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
534
535 reattach (type, obj);
473} 536}
474 537
475object_thawer::~object_thawer () 538object_thawer::~object_thawer ()
476{ 539{
540 if (text) SvREFCNT_dec (text);
541 if (av) SvREFCNT_dec (av);
542}
543
544char *fgets (char *s, int n, object_thawer &thawer)
545{
546 char *p = thawer.line;
547 char *q = s;
548
477 if (av) 549 if (!p)
478 SvREFCNT_dec ((SV *)av); 550 return 0;
551
552 while (--n)
553 {
554 if (!*p)
555 break;
556
557 *q++ = *p;
558
559 if (*p++ == '\n')
560 break;
561 }
562
563 *q = 0;
564 thawer.line = p;
565
566 return s == q ? 0 : s;
567}
568
569keyword object_thawer::get_kv ()
570{
571 if (!line)
572 return KW_EOF;
573
574 for (;;)
575 {
576 char *p = line;
577
578 if (!*p)
579 return KW_EOF;
580
581 // parse keyword
582 while (*p > ' ')
583 p++;
584
585 int klen = p - line;
586
587 if (*p++ != '\n')
588 {
589 // parse value
590 while (*p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
591 ++p;
592
593 last_value = p;
594
595 while (*p != '\n')
596 p++;
597
598 *p++ = 0;
599 }
600 else
601 last_value = 0;
602
603 line [klen] = 0;
604 keyword_idx *kw = kw_lex::match (line, klen);
605
606 //printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
607
608 if (kw)
609 {
610 line = p;
611 return kw->index;
612 }
613 else if (!*line || *line == '#')
614 {
615 // empty/comment line
616 line = p;
617 }
618 else
619 return KW_ERROR;
620 }
621}
622
623void object_thawer::get (shstr &sh) const
624{
625 if (last_value)
626 sh = last_value;
627 else
628 {
629 sh = "<value missing>";
630 LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
631 }
632}
633
634void object_thawer::get_ml (keyword kend, shstr &sh)
635{
636 char kw[128];
637
638 // multi-line strings are delimited by "\nendXXX\n"
639 kw [0] = '\n';
640 strcpy (kw + 1, keyword_str [kend]);
641
642 char *end = strstr (line, kw);
643
644 if (!end)
645 {
646 sh = 0;
647 return;
648 }
649
650 *end = 0;
651 sh = line;
652
653 line = end + keyword_len [kend] + 1;
654
655 while (*line++ != '\n')
656 ;
657}
658
659sint32 object_thawer::get_sint32 () const
660{
661 char *p = last_value;
662
663 if (!p)
664 return 0;
665
666 sint32 val = 0;
667 bool negate;
668
669 if (*p == '-')
670 {
671 negate = true;
672 ++p;
673 }
674 else
675 negate = false;
676
677 do
678 {
679 val *= 10;
680 val += *p++ - '0';
681 }
682 while (*p);
683
684 return negate ? -val : val;
685}
686
687sint64 object_thawer::get_sint64 () const
688{
689 return last_value ? atoll (last_value) : 0;
690}
691
692double object_thawer::get_double () const
693{
694 return last_value ? atof (last_value) : 0;
479} 695}
480 696
481///////////////////////////////////////////////////////////////////////////// 697/////////////////////////////////////////////////////////////////////////////
482 698
483extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 699extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
484{ 700{
485 gethook = gethooksptr;
486 printf (PLUGIN_VERSION " init\n");
487
488 return 0; 701 return 0;
489} 702}
490 703
491static CommArray_s rtn_cmd; 704static CommArray_s rtn_cmd;
492 705
… …
572extern "C" int cfperl_postInitPlugin () 785extern "C" int cfperl_postInitPlugin ()
573{ 786{
574 int hooktype = 1; 787 int hooktype = 1;
575 int rtype = 0; 788 int rtype = 0;
576 789
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); 790 cf_init_plugin (gethook);
585 791
586 return 0; 792 return 0;
587} 793}
588 794
… …
592} 798}
593 799
594void 800void
595cfperl_init () 801cfperl_init ()
596{ 802{
803 PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);
804 perl = perl_alloc ();
805 perl_construct (perl);
806
807 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
808
597 char *argv[] = { 809 char *argv[] = {
598 "", 810 "",
599 "-e" 811 "-e"
600 "BEGIN {"
601 " cf->bootstrap;" 812 "cf->bootstrap;"
602 " unshift @INC, cf::datadir ();" 813 "unshift @INC, cf::datadir ();"
603 "}"
604 ""
605 "use cf;" 814 "require cf;"
606 }; 815 };
607
608 perl = perl_alloc ();
609 perl_construct (perl);
610
611 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
612 816
613 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl)) 817 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))
614 { 818 {
615 printf ("unable to initialize perl-interpreter, aborting.\n"); 819 printf ("unable to initialize perl-interpreter, aborting.\n");
616
617 exit (EXIT_FAILURE); 820 exit (EXIT_FAILURE);
618 //perl_destruct (perl);
619 //perl_free (perl);
620 //perl = 0;
621 //return;
622 } 821 }
623 822
624 obj_cache = newHV (); 823 obj_cache = newHV ();
625} 824}
626 825
… …
636static event_klass klass_of[NUM_EVENT_TYPES] = { 835static event_klass klass_of[NUM_EVENT_TYPES] = {
637# define def(type,name) KLASS_ ## type, 836# define def(type,name) KLASS_ ## type,
638# include "eventinc.h" 837# include "eventinc.h"
639# undef def 838# undef def
640}; 839};
840
841#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
641 842
642static void 843static void
643gather_callbacks (AV *&callbacks, AV *registry, event_type event) 844gather_callbacks (AV *&callbacks, AV *registry, event_type event)
644{ 845{
645 // event must be in array 846 // event must be in array
… …
688 // 2a. per-type callback 889 // 2a. per-type callback
689 // 4. global callbacks 890 // 4. global callbacks
690 891
691 gather_callbacks (callbacks, cb_global, event); 892 gather_callbacks (callbacks, cb_global, event);
692 893
693 switch (klass_of [event]) 894 switch (KLASS_OF (event))
694 { 895 {
695 case KLASS_GLOBAL: 896 case KLASS_GLOBAL:
696 break; 897 break;
697 898
698 case KLASS_OBJECT: 899 case KLASS_OBJECT:
699 dt = (data_type) va_arg (ap, int); 900 dt = (data_type) va_arg (ap, int);
700 assert (("first argument must be of type object", dt == DT_OBJECT)); 901 assert (("first argument must be of type object", dt == DT_OBJECT));
701 op = va_arg (ap, object *); 902 op = va_arg (ap, object *);
702 903
703 if (op->cb) 904 if (op->cb)
704 gather_callbacks (callbacks, (AV *)op->cb, event); 905 gather_callbacks (callbacks, op->cb, event);
705 906
706 if (op->type) 907 if (op->type)
707 { 908 {
708 if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type)) 909 if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
709 { 910 {
… …
730 dt = (data_type) va_arg (ap, int); 931 dt = (data_type) va_arg (ap, int);
731 assert (("first argument must be of type player", dt == DT_PLAYER)); 932 assert (("first argument must be of type player", dt == DT_PLAYER));
732 pl = va_arg (ap, player *); 933 pl = va_arg (ap, player *);
733 934
734 if (pl->cb) 935 if (pl->cb)
735 gather_callbacks (callbacks, (AV *)pl->cb, event); 936 gather_callbacks (callbacks, pl->cb, event);
736 937
737 gather_callbacks (callbacks, cb_player, event); 938 gather_callbacks (callbacks, cb_player, event);
738 break; 939 break;
739 940
740 case KLASS_MAP: 941 case KLASS_MAP:
741 dt = (data_type) va_arg (ap, int); 942 dt = (data_type) va_arg (ap, int);
742 assert (("first argument must be of type object", dt == DT_MAP)); 943 assert (("first argument must be of type object", dt == DT_MAP));
743 map = va_arg (ap, mapstruct *); 944 map = va_arg (ap, mapstruct *);
744 945
745 if (map->cb) 946 if (map->cb)
746 gather_callbacks (callbacks, (AV *)map->cb, event); 947 gather_callbacks (callbacks, map->cb, event);
747 948
748 gather_callbacks (callbacks, cb_map, event); 949 gather_callbacks (callbacks, cb_map, event);
749 break; 950 break;
750 951
751 default: 952 default:
… …
764 EXTEND (SP, 3); 965 EXTEND (SP, 3);
765 966
766 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays 967 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays
767 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks))); 968 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));
768 969
769 switch (klass_of [event]) 970 switch (KLASS_OF (event))
770 { 971 {
771 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break; 972 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;
772 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break; 973 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;
773 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break; 974 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;
774 } 975 }
… …
1203 1404
1204 const_iv (SK_EXP_ADD_SKILL) 1405 const_iv (SK_EXP_ADD_SKILL)
1205 const_iv (SK_EXP_TOTAL) 1406 const_iv (SK_EXP_TOTAL)
1206 const_iv (SK_EXP_NONE) 1407 const_iv (SK_EXP_NONE)
1207 const_iv (SK_SUBTRACT_SKILL_EXP) 1408 const_iv (SK_SUBTRACT_SKILL_EXP)
1409 const_iv (SK_EXP_SKILL_ONLY)
1208 1410
1209 const_iv (SK_LOCKPICKING) 1411 const_iv (SK_LOCKPICKING)
1210 const_iv (SK_HIDING) 1412 const_iv (SK_HIDING)
1211 const_iv (SK_SMITHERY) 1413 const_iv (SK_SMITHERY)
1212 const_iv (SK_BOWYER) 1414 const_iv (SK_BOWYER)
… …
1371 prop (CFAPI_INT, MAP_PROP_WINDDIR) 1573 prop (CFAPI_INT, MAP_PROP_WINDDIR)
1372 prop (CFAPI_INT, MAP_PROP_SKY) 1574 prop (CFAPI_INT, MAP_PROP_SKY)
1373 prop (CFAPI_INT, MAP_PROP_WPARTX) 1575 prop (CFAPI_INT, MAP_PROP_WPARTX)
1374 prop (CFAPI_INT, MAP_PROP_WPARTY) 1576 prop (CFAPI_INT, MAP_PROP_WPARTY)
1375 prop (CFAPI_STRING, MAP_PROP_MESSAGE) 1577 prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1376 prop (CFAPI_PMAP, MAP_PROP_NEXT)
1377 prop (CFAPI_PREGION, MAP_PROP_REGION) 1578 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) 1579 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1381 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB) 1580 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1382 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY) 1581 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1383 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT) 1582 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1384 prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1385 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER) 1583 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1386 prop (CFAPI_PMAP, OBJECT_PROP_MAP) 1584 prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1387 prop (CFAPI_INT, OBJECT_PROP_COUNT) 1585 prop (CFAPI_INT, OBJECT_PROP_COUNT)
1388 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT) 1586 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1389 prop (CFAPI_STRING, OBJECT_PROP_NAME) 1587 prop (CFAPI_STRING, OBJECT_PROP_NAME)
… …
1521 PROTOTYPE: $$ 1719 PROTOTYPE: $$
1522 1720
1523char *path_combine_and_normalize (char *base, char *path) 1721char *path_combine_and_normalize (char *base, char *path)
1524 PROTOTYPE: $$ 1722 PROTOTYPE: $$
1525 1723
1526char * 1724const char *
1527cf_get_maps_directory (char *path) 1725get_maps_directory (char *path)
1528 PROTOTYPE: $ 1726 PROTOTYPE: $
1529 ALIAS: maps_directory = 0 1727 ALIAS: maps_directory = 0
1728 CODE:
1729 RETVAL = create_pathname (path);
1730 OUTPUT: RETVAL
1530 1731
1531void 1732void
1532sub_generation_inc () 1733sub_generation_inc ()
1533 CODE: 1734 CODE:
1534 PL_sub_generation++; 1735 PL_sub_generation++;
… …
1543 confdir = 3 1744 confdir = 3
1544 localdir = 4 1745 localdir = 4
1545 playerdir = 5 1746 playerdir = 5
1546 datadir = 6 1747 datadir = 6
1547 CODE: 1748 CODE:
1548{ 1749 switch (ix)
1549 int unused_type; 1750 {
1550 RETVAL = (char *)systemDirectory (&unused_type, ix); 1751 case 0: RETVAL = settings.mapdir ; break;
1551} 1752 case 1: RETVAL = settings.uniquedir; break;
1753 case 2: RETVAL = settings.tmpdir ; break;
1754 case 3: RETVAL = settings.confdir ; break;
1755 case 4: RETVAL = settings.localdir ; break;
1756 case 5: RETVAL = settings.playerdir; break;
1757 case 6: RETVAL = settings.datadir ; break;
1758 }
1552 OUTPUT: RETVAL 1759 OUTPUT: RETVAL
1553 1760
1554int 1761int
1555cf_find_animation (char *text) 1762cf_find_animation (char *text)
1556 PROTOTYPE: $ 1763 PROTOTYPE: $
1557 1764
1558int random_roll(int min, int max, object *op, int goodbad); 1765int random_roll(int min, int max, object *op, int goodbad);
1559 1766
1560const char *cost_string_from_value(uint64 cost, int approx = 0) 1767const char *cost_string_from_value(uint64 cost, int approx = 0)
1561 1768
1562int invoke (int event, SV *arg1, ...) 1769int invoke (int event, ...)
1563 CODE: 1770 CODE:
1564{ 1771 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1565 // parse first arg and call invoke_object etc as seen fit 1772 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1566 //TODO 1773 for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1567 //cfperl_invoke (event, 1774 RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1568} 1775 OUTPUT: RETVAL
1569 1776
1570int 1777int
1571exp_to_level (val64 exp) 1778exp_to_level (val64 exp)
1572 CODE: 1779 CODE:
1573{ 1780{
… …
1604 RETVAL = newSVpv (resist_plus[atnr], 0); 1811 RETVAL = newSVpv (resist_plus[atnr], 0);
1605 else 1812 else
1606 XSRETURN_UNDEF; 1813 XSRETURN_UNDEF;
1607 OUTPUT: RETVAL 1814 OUTPUT: RETVAL
1608 1815
1816int
1817_valid (SV *obj)
1818 CODE:
1819 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1820 OUTPUT:
1821 RETVAL
1822
1609MODULE = cf PACKAGE = cf::object PREFIX = cf_object_ 1823MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1824
1825int invoke (object *op, int event, ...)
1826 CODE:
1827 if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1828 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1829 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1830 RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));
1831 OUTPUT: RETVAL
1832
1833SV *registry (object *op)
1834 CODE:
1835 RETVAL = registry_of (op);
1836 OUTPUT:
1837 RETVAL
1838
1839object *head (object *op)
1840 PROTOTYPE: $
1841 ALIAS:
1842 more = 1
1843 above = 2
1844 below = 3
1845 CODE:
1846 switch (ix)
1847 {
1848 case 0: RETVAL = op->head ? op->head : op; break; // DOH!
1849 case 1: RETVAL = op->more; break;
1850 case 2: RETVAL = op->above; break;
1851 case 3: RETVAL = op->below; break;
1852 }
1853 OUTPUT:
1854 RETVAL
1610 1855
1611SV * 1856SV *
1612get_property (object *obj, int type, int idx) 1857get_property (object *obj, int type, int idx)
1613 CODE: 1858 CODE:
1614 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx)); 1859 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));
… …
1693 1938
1694int need_identify (const object *obj); 1939int need_identify (const object *obj);
1695 1940
1696int apply_shop_mat (object *shop_mat, object *op); 1941int apply_shop_mat (object *shop_mat, object *op);
1697 1942
1698void cf_object_move (object *op, int dir, object *originator = op) 1943int move (object *op, int dir, object *originator = op)
1944 CODE:
1945 RETVAL = move_ob (op, dir, originator);
1946 OUTPUT:
1947 RETVAL
1699 1948
1700void cf_object_apply (object *op, object *author, int flags = 0) 1949void cf_object_apply (object *op, object *author, int flags = 0)
1701 1950
1702void cf_object_apply_below (object *op) 1951void cf_object_apply_below (object *op)
1703 1952
… …
1744int cf_object_out_of_map (object *op, int x, int y) 1993int cf_object_out_of_map (object *op, int x, int y)
1745 1994
1746void cf_object_drop (object *op, object *author) 1995void cf_object_drop (object *op, object *author)
1747 1996
1748void cf_object_take (object *op, object *author) 1997void 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 1998
1754object *cf_object_insert_object (object *op, object *container) 1999object *cf_object_insert_object (object *op, object *container)
1755 2000
1756const char *cf_object_get_msg (object *ob) 2001const char *cf_object_get_msg (object *ob)
1757 ALIAS: msg = 0 2002 ALIAS: msg = 0
… …
1811 CODE: 2056 CODE:
1812{ 2057{
1813 int unused_type; 2058 int unused_type;
1814 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y); 2059 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1815} 2060}
1816
1817SV *registry (object *op)
1818 CODE:
1819 RETVAL = registry_of (op);
1820 OUTPUT:
1821 RETVAL
1822 2061
1823# syntatic sugar for easier use in event callbacks. 2062# syntatic sugar for easier use in event callbacks.
1824const char *options (object *op) 2063const char *options (object *op)
1825 CODE: 2064 CODE:
1826 RETVAL = op->name; 2065 RETVAL = op->name;
… …
1899 2138
1900void kill_player (object *op) 2139void kill_player (object *op)
1901 2140
1902MODULE = cf PACKAGE = cf::player PREFIX = cf_player_ 2141MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1903 2142
2143int invoke (player *pl, int event, ...)
2144 CODE:
2145 if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2146 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2147 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2148 RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));
2149 OUTPUT: RETVAL
2150
1904SV *registry (player *pl) 2151SV *registry (player *pl)
1905 CODE: 2152 CODE:
1906 RETVAL = registry_of (pl); 2153 RETVAL = registry_of (pl);
1907 OUTPUT: 2154 OUTPUT:
1908 RETVAL 2155 RETVAL
… …
2032 OUTPUT: RETVAL 2279 OUTPUT: RETVAL
2033 2280
2034 2281
2035MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2282MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2036 2283
2284mapstruct *first ()
2285 PROTOTYPE:
2286 CODE:
2287 RETVAL = first_map;
2288 OUTPUT: RETVAL
2289
2290mapstruct *next (mapstruct *map)
2291 PROTOTYPE:
2292 CODE:
2293 RETVAL = map->next;
2294 OUTPUT: RETVAL
2295
2296int invoke (mapstruct *map, int event, ...)
2297 CODE:
2298 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2299 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2300 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2301 RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));
2302 OUTPUT: RETVAL
2303
2037SV *registry (mapstruct *map) 2304SV *registry (mapstruct *map)
2038 CODE: 2305 CODE:
2039 RETVAL = registry_of (map); 2306 RETVAL = registry_of (map);
2040 OUTPUT: 2307 OUTPUT:
2041 RETVAL 2308 RETVAL
… …
2060 2327
2061mapstruct *new (int width, int height) 2328mapstruct *new (int width, int height)
2062 PROTOTYPE: 2329 PROTOTYPE:
2063 CODE: 2330 CODE:
2064{ 2331{
2065 int unused_type; 2332 RETVAL = get_empty_map (width, height);
2066 RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
2067} 2333}
2068 OUTPUT: 2334 OUTPUT:
2069 RETVAL 2335 RETVAL
2070 2336
2071void delete_map (mapstruct *map) 2337void delete_map (mapstruct *map)
… …
2086 XSRETURN_UNDEF; 2352 XSRETURN_UNDEF;
2087 RETVAL = map->tile_path [dir]; 2353 RETVAL = map->tile_path [dir];
2088 OUTPUT: 2354 OUTPUT:
2089 RETVAL 2355 RETVAL
2090 2356
2091mapstruct *cf_map_get_map (char *name) 2357mapstruct *ready_map_name (char *name, int flags = 0)
2092 PROTOTYPE: $ 2358 PROTOTYPE: $;$
2093 ALIAS: map = 0 2359 ALIAS:
2360 find = 0
2361 get_map = 1
2094 2362
2095mapstruct *has_been_loaded (char *name) 2363mapstruct *has_been_loaded (char *name)
2096 PROTOTYPE: $ 2364 PROTOTYPE: $
2097
2098mapstruct *cf_map_get_first ()
2099 PROTOTYPE:
2100 ALIAS: first = 0
2101 2365
2102# whoever "designed" the plug-in api should have wasted 2366# whoever "designed" the plug-in api should have wasted
2103# his/her time with staying away from the project - would have 2367# his/her time with staying away from the project - would have
2104# saved others a lot of time, without doubt. 2368# saved others a lot of time, without doubt.
2105void set_path (mapstruct *where, char *path) 2369void set_path (mapstruct *where, char *path)
… …
2120 2384
2121void set_unique (mapstruct *map, bool unique) 2385void set_unique (mapstruct *map, bool unique)
2122 CODE: 2386 CODE:
2123 map->unique = unique; 2387 map->unique = unique;
2124 2388
2389void
2390trigger (mapstruct *map, long connection, bool state = true)
2391 CODE:
2392 activate_connection (map, connection, state);
2393
2394void
2395get_connection (mapstruct *map, long connection)
2396 PPCODE:
2397 oblinkpt *obp = get_connection_links (map, connection);
2398 if (obp)
2399 for (objectlink *ol = obp->link; ol; ol = ol->next)
2400 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, ol->ob)));
2401
2125object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags) 2402object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags)
2126 2403
2127object *cf_map_insert_object (mapstruct *where, object* op, int x, int y) 2404object *cf_map_insert_object (mapstruct *where, object* op, int x, int y)
2128 2405
2129object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny) 2406object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny)
… …
2133cf_map_normalise (mapstruct *map, int x, int y) 2410cf_map_normalise (mapstruct *map, int x, int y)
2134 PPCODE: 2411 PPCODE:
2135{ 2412{
2136 mapstruct *nmap = 0; 2413 mapstruct *nmap = 0;
2137 I16 nx = 0, ny = 0; 2414 I16 nx = 0, ny = 0;
2138 int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2415 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2139 2416
2140 EXTEND (SP, 4); 2417 EXTEND (SP, 4);
2141 PUSHs (sv_2mortal (newSViv (flags))); 2418 PUSHs (sv_2mortal (newSViv (flags)));
2142 2419
2143 if (GIMME_V == G_ARRAY) 2420 if (GIMME_V == G_ARRAY)
… …
2155{ 2432{
2156 object *o; 2433 object *o;
2157 mapstruct *nmap = 0; 2434 mapstruct *nmap = 0;
2158 I16 nx, ny; 2435 I16 nx, ny;
2159 2436
2160 cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2437 get_map_flags (map, &nmap, x, y, &nx, &ny);
2161 2438
2162 if (nmap) 2439 if (nmap)
2163 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above) 2440 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2164 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o))); 2441 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2165} 2442}
… …
2190 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break; 2467 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2191 } 2468 }
2192 OUTPUT: 2469 OUTPUT:
2193 RETVAL 2470 RETVAL
2194 2471
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 2472
2205 for (y = 0; y < MAP_HEIGHT (map); y++) 2473MODULE = 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 2474
2210 if (!SvROK (sv)) 2475archetype *find (const char *name)
2211 continue; 2476 CODE:
2477 RETVAL = find_archetype (name);
2478 OUTPUT:
2479 RETVAL
2212 2480
2213 av = (AV *)SvRV (sv); 2481archetype *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: 2482 PROTOTYPE:
2233 ALIAS: first = 0 2483 CODE:
2484 RETVAL = first_archetype;
2485 OUTPUT: RETVAL
2234 2486
2235archetype *cf_archetype_get_next (archetype *arch) 2487archetype *next (archetype *arch)
2236 ALIAS: next = 0 2488 CODE:
2489 RETVAL = arch->next;
2490 OUTPUT: RETVAL
2237 2491
2238archetype *cf_archetype_get_head (archetype *arch) 2492archetype *head (archetype *arch)
2239 ALIAS: head = 0 2493 CODE:
2494 RETVAL = arch->head;
2495 OUTPUT: RETVAL
2240 2496
2241archetype *cf_archetype_get_more (archetype *arch) 2497archetype *more (archetype *arch)
2242 ALIAS: more = 0 2498 CODE:
2499 RETVAL = arch->more;
2500 OUTPUT: RETVAL
2243 2501
2244const char *cf_archetype_get_name (archetype *arch) 2502const char *name (archetype *arch)
2245 ALIAS: name = 0 2503 CODE:
2504 RETVAL = arch->name;
2505 OUTPUT: RETVAL
2246 2506
2247object *cf_archetype_get_clone (archetype *arch) 2507object *clone (archetype *arch)
2248 ALIAS: clone = 0 2508 CODE:
2509 RETVAL = &arch->clone;
2510 OUTPUT: RETVAL
2249 2511
2250MODULE = cf PACKAGE = cf::party PREFIX = cf_party_ 2512MODULE = cf PACKAGE = cf::party
2251 2513
2252partylist *cf_party_get_first () 2514partylist *first ()
2253 PROTOTYPE: 2515 PROTOTYPE:
2254 ALIAS: first = 0 2516 CODE:
2517 RETVAL = get_firstparty ();
2518 OUTPUT: RETVAL
2255 2519
2256partylist *cf_party_get_next (partylist *party) 2520partylist *next (partylist *party)
2257 ALIAS: next = 0 2521 CODE:
2522 RETVAL = party->next;
2523 OUTPUT: RETVAL
2258 2524
2259const char *cf_party_get_name (partylist *party) 2525const char *name (partylist *party)
2526 CODE:
2527 RETVAL = party->partyname;
2528 OUTPUT: RETVAL
2260 2529
2261const char *cf_party_get_password (partylist *party) 2530const char *password (partylist *party)
2262 ALIAS: password = 0 2531 CODE:
2532 RETVAL = party->passwd;
2533 OUTPUT: RETVAL
2263 2534
2264player *cf_party_get_first_player (partylist *party) 2535MODULE = cf PACKAGE = cf::region
2265 ALIAS: first_player = 0
2266 2536
2267player *cf_party_get_next_player (partylist *party, player *op) 2537region *first ()
2268 ALIAS: next_player = 0
2269
2270
2271MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2272
2273region *cf_region_get_first ()
2274 PROTOTYPE: 2538 PROTOTYPE:
2275 ALIAS: first = 0 2539 CODE:
2540 RETVAL = first_region;
2541 OUTPUT: RETVAL
2276 2542
2543region *next (region *reg)
2544 CODE:
2545 RETVAL = reg->next;
2546 OUTPUT: RETVAL
2547
2548const char *name (region *reg)
2549 CODE:
2550 RETVAL = reg->name;
2551 OUTPUT: RETVAL
2552
2553region *parent (region *reg)
2554 CODE:
2555 RETVAL = reg->parent;
2556 OUTPUT: RETVAL
2557
2277const char *cf_region_get_name (region *reg) 2558const char *longname (region *reg)
2278 ALIAS: name = 0 2559 CODE:
2560 RETVAL = reg->longname;
2561 OUTPUT: RETVAL
2279 2562
2280region *cf_region_get_next (region *reg) 2563const char *msg (region *reg)
2281 ALIAS: next = 0 2564 CODE:
2565 RETVAL = reg->msg;
2566 OUTPUT: RETVAL
2282 2567
2283region *cf_region_get_parent (region *reg) 2568MODULE = 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 2569
2295val64 2570val64
2296exp (living *liv, val64 new_val = 0) 2571exp (living *liv, val64 new_val = 0)
2297 PROTOTYPE: $;$ 2572 PROTOTYPE: $;$
2298 ALIAS: 2573 ALIAS:

Diff Legend

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