ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/cfperl.xs
(Generate patch)

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.16 by root, Sun Aug 27 15:24:22 2006 UTC vs.
Revision 1.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;
361 364
362 INVOKE_OBJECT (INSTANTIATE, this); 365 switch (type)
366 {
367 case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
368 case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
369 }
363} 370}
364 371
365///////////////////////////////////////////////////////////////////////////// 372/////////////////////////////////////////////////////////////////////////////
366 373
367object_freezer::object_freezer (const char *filename)
368: filename (filename)
369{
370 av = (AV *)newAV ();
371 idx = 0;
372 av_extend ((AV *)av, 1024);
373}
374
375object_freezer::~object_freezer ()
376{
377 dSP;
378 ENTER;
379 SAVETMPS;
380 PUSHMARK (SP);
381 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
382 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
383 PUTBACK;
384 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
385 FREETMPS;
386 LEAVE;
387}
388
389void object_freezer::put (extendable_base *ext)
390{
391 ext->optimise ();
392
393 if (ext->self)
394 av_store ((AV *)av, idx, SvREFCNT_inc ((SV *)ext->self));
395
396 ++idx;
397}
398
399object_thawer::object_thawer (const char *filename)
400{
401 av = 0;
402 idx = 0;
403
404 if (!filename)
405 return;
406
407 dSP;
408 ENTER;
409 SAVETMPS;
410 PUSHMARK (SP);
411 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
412 PUTBACK;
413
414 if (0 < call_pv ("cf::object_thawer_load", G_SCALAR | G_EVAL))
415 {
416 SPAGAIN;
417 SV *sv = POPs;
418 if (SvROK (sv))
419 av = SvREFCNT_inc (SvRV (sv));
420 }
421
422 FREETMPS;
423 LEAVE;
424}
425
426void reattach (data_type type, void *obj) 374void reattach (data_type type, void *obj)
427{ 375{
376 //TODO only do this when the object has _attachment's
377
428 dSP; 378 dSP;
429 ENTER; 379 ENTER;
430 SAVETMPS; 380 SAVETMPS;
431 PUSHMARK (SP); 381 PUSHMARK (SP);
432 XPUSHs (sv_2mortal (newSVdt (type, obj))); 382 XPUSHs (sv_2mortal (newSVdt (type, obj)));
… …
442 case DT_MAP: INVOKE_MAP (REATTACH, obj); break; 392 case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
443 } 393 }
444} 394}
445 395
446template<class subclass> 396template<class subclass>
447void reattach (extendable<subclass> *obj) 397void reattach (attachable<subclass> *obj)
448{ 398{
449 obj->optimise (); 399 obj->optimise ();
450 400
451 if (obj->self) 401 if (obj->self)
452 reattach (subclass::get_dt (), (subclass *)obj); 402 reattach ((data_type) cftype<subclass>::dt, (subclass *)obj);
453} 403}
454 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
455void 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)
456{ 517{
457 if (!av) 518 if (!av || oid < 0) // this is actually an error of sorts
458 return; 519 return;
459 520
460 // 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
461 ext->clear (); 522 ext->clear ();
462 523
463 SV **svp = av_fetch ((AV *)av, idx, 0); 524 SV **svp = av_fetch ((AV *)av, oid, 0);
464 525
465 ++idx;
466
467 if (!svp)
468 return;
469
470 if (SvROK (*svp)) 526 if (!svp || !SvROK (*svp))
471 { 527 {
472 ext->self = SvREFCNT_inc (*svp); 528 printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
473 sv_magic (SvRV ((SV *)ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0); 529 return;
474
475 reattach (type, obj);
476 } 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);
477} 536}
478 537
479object_thawer::~object_thawer () 538object_thawer::~object_thawer ()
480{ 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
481 if (av) 549 if (!p)
482 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;
483} 695}
484 696
485///////////////////////////////////////////////////////////////////////////// 697/////////////////////////////////////////////////////////////////////////////
486 698
487extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 699extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
488{ 700{
489 gethook = gethooksptr;
490 printf (PLUGIN_VERSION " init\n");
491
492 return 0; 701 return 0;
493} 702}
494 703
495static CommArray_s rtn_cmd; 704static CommArray_s rtn_cmd;
496 705
… …
576extern "C" int cfperl_postInitPlugin () 785extern "C" int cfperl_postInitPlugin ()
577{ 786{
578 int hooktype = 1; 787 int hooktype = 1;
579 int rtype = 0; 788 int rtype = 0;
580 789
581 printf (PLUGIN_VERSION " post init\n");
582
583 systemDirectory = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_directory");
584 object_set_property = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_set_property");
585 map_get_map = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_map_get_map");
586 object_insert = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_insert");
587
588 cf_init_plugin (gethook); 790 cf_init_plugin (gethook);
589 791
590 return 0; 792 return 0;
591} 793}
592 794
… …
596} 798}
597 799
598void 800void
599cfperl_init () 801cfperl_init ()
600{ 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
601 char *argv[] = { 809 char *argv[] = {
602 "", 810 "",
603 "-e" 811 "-e"
604 "BEGIN {"
605 " cf->bootstrap;" 812 "cf->bootstrap;"
606 " unshift @INC, cf::datadir ();" 813 "unshift @INC, cf::datadir ();"
607 "}"
608 ""
609 "use cf;" 814 "require cf;"
610 }; 815 };
611
612 perl = perl_alloc ();
613 perl_construct (perl);
614
615 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
616 816
617 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))
618 { 818 {
619 printf ("unable to initialize perl-interpreter, aborting.\n"); 819 printf ("unable to initialize perl-interpreter, aborting.\n");
620
621 exit (EXIT_FAILURE); 820 exit (EXIT_FAILURE);
622 //perl_destruct (perl);
623 //perl_free (perl);
624 //perl = 0;
625 //return;
626 } 821 }
627 822
628 obj_cache = newHV (); 823 obj_cache = newHV ();
629} 824}
630 825
… …
640static event_klass klass_of[NUM_EVENT_TYPES] = { 835static event_klass klass_of[NUM_EVENT_TYPES] = {
641# define def(type,name) KLASS_ ## type, 836# define def(type,name) KLASS_ ## type,
642# include "eventinc.h" 837# include "eventinc.h"
643# undef def 838# undef def
644}; 839};
840
841#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
645 842
646static void 843static void
647gather_callbacks (AV *&callbacks, AV *registry, event_type event) 844gather_callbacks (AV *&callbacks, AV *registry, event_type event)
648{ 845{
649 // event must be in array 846 // event must be in array
… …
692 // 2a. per-type callback 889 // 2a. per-type callback
693 // 4. global callbacks 890 // 4. global callbacks
694 891
695 gather_callbacks (callbacks, cb_global, event); 892 gather_callbacks (callbacks, cb_global, event);
696 893
697 switch (klass_of [event]) 894 switch (KLASS_OF (event))
698 { 895 {
699 case KLASS_GLOBAL: 896 case KLASS_GLOBAL:
700 break; 897 break;
701 898
702 case KLASS_OBJECT: 899 case KLASS_OBJECT:
703 dt = (data_type) va_arg (ap, int); 900 dt = (data_type) va_arg (ap, int);
704 assert (("first argument must be of type object", dt == DT_OBJECT)); 901 assert (("first argument must be of type object", dt == DT_OBJECT));
705 op = va_arg (ap, object *); 902 op = va_arg (ap, object *);
706 903
707 if (op->cb) 904 if (op->cb)
708 gather_callbacks (callbacks, (AV *)op->cb, event); 905 gather_callbacks (callbacks, op->cb, event);
709 906
710 if (op->type) 907 if (op->type)
711 { 908 {
712 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))
713 { 910 {
… …
734 dt = (data_type) va_arg (ap, int); 931 dt = (data_type) va_arg (ap, int);
735 assert (("first argument must be of type player", dt == DT_PLAYER)); 932 assert (("first argument must be of type player", dt == DT_PLAYER));
736 pl = va_arg (ap, player *); 933 pl = va_arg (ap, player *);
737 934
738 if (pl->cb) 935 if (pl->cb)
739 gather_callbacks (callbacks, (AV *)pl->cb, event); 936 gather_callbacks (callbacks, pl->cb, event);
740 937
741 gather_callbacks (callbacks, cb_player, event); 938 gather_callbacks (callbacks, cb_player, event);
742 break; 939 break;
743 940
744 case KLASS_MAP: 941 case KLASS_MAP:
745 dt = (data_type) va_arg (ap, int); 942 dt = (data_type) va_arg (ap, int);
746 assert (("first argument must be of type object", dt == DT_MAP)); 943 assert (("first argument must be of type object", dt == DT_MAP));
747 map = va_arg (ap, mapstruct *); 944 map = va_arg (ap, mapstruct *);
748 945
749 if (map->cb) 946 if (map->cb)
750 gather_callbacks (callbacks, (AV *)map->cb, event); 947 gather_callbacks (callbacks, map->cb, event);
751 948
752 gather_callbacks (callbacks, cb_map, event); 949 gather_callbacks (callbacks, cb_map, event);
753 break; 950 break;
754 951
755 default: 952 default:
… …
768 EXTEND (SP, 3); 965 EXTEND (SP, 3);
769 966
770 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays 967 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays
771 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks))); 968 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));
772 969
773 switch (klass_of [event]) 970 switch (KLASS_OF (event))
774 { 971 {
775 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break; 972 case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;
776 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break; 973 case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;
777 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break; 974 case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;
778 } 975 }
… …
1207 1404
1208 const_iv (SK_EXP_ADD_SKILL) 1405 const_iv (SK_EXP_ADD_SKILL)
1209 const_iv (SK_EXP_TOTAL) 1406 const_iv (SK_EXP_TOTAL)
1210 const_iv (SK_EXP_NONE) 1407 const_iv (SK_EXP_NONE)
1211 const_iv (SK_SUBTRACT_SKILL_EXP) 1408 const_iv (SK_SUBTRACT_SKILL_EXP)
1409 const_iv (SK_EXP_SKILL_ONLY)
1212 1410
1213 const_iv (SK_LOCKPICKING) 1411 const_iv (SK_LOCKPICKING)
1214 const_iv (SK_HIDING) 1412 const_iv (SK_HIDING)
1215 const_iv (SK_SMITHERY) 1413 const_iv (SK_SMITHERY)
1216 const_iv (SK_BOWYER) 1414 const_iv (SK_BOWYER)
… …
1375 prop (CFAPI_INT, MAP_PROP_WINDDIR) 1573 prop (CFAPI_INT, MAP_PROP_WINDDIR)
1376 prop (CFAPI_INT, MAP_PROP_SKY) 1574 prop (CFAPI_INT, MAP_PROP_SKY)
1377 prop (CFAPI_INT, MAP_PROP_WPARTX) 1575 prop (CFAPI_INT, MAP_PROP_WPARTX)
1378 prop (CFAPI_INT, MAP_PROP_WPARTY) 1576 prop (CFAPI_INT, MAP_PROP_WPARTY)
1379 prop (CFAPI_STRING, MAP_PROP_MESSAGE) 1577 prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1380 prop (CFAPI_PMAP, MAP_PROP_NEXT)
1381 prop (CFAPI_PREGION, MAP_PROP_REGION) 1578 prop (CFAPI_PREGION, MAP_PROP_REGION)
1382 prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1383 prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1384 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB) 1579 prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1385 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB) 1580 prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1386 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY) 1581 prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1387 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT) 1582 prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1388 prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1389 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER) 1583 prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1390 prop (CFAPI_PMAP, OBJECT_PROP_MAP) 1584 prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1391 prop (CFAPI_INT, OBJECT_PROP_COUNT) 1585 prop (CFAPI_INT, OBJECT_PROP_COUNT)
1392 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT) 1586 prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1393 prop (CFAPI_STRING, OBJECT_PROP_NAME) 1587 prop (CFAPI_STRING, OBJECT_PROP_NAME)
… …
1525 PROTOTYPE: $$ 1719 PROTOTYPE: $$
1526 1720
1527char *path_combine_and_normalize (char *base, char *path) 1721char *path_combine_and_normalize (char *base, char *path)
1528 PROTOTYPE: $$ 1722 PROTOTYPE: $$
1529 1723
1530char * 1724const char *
1531cf_get_maps_directory (char *path) 1725get_maps_directory (char *path)
1532 PROTOTYPE: $ 1726 PROTOTYPE: $
1533 ALIAS: maps_directory = 0 1727 ALIAS: maps_directory = 0
1728 CODE:
1729 RETVAL = create_pathname (path);
1730 OUTPUT: RETVAL
1534 1731
1535void 1732void
1536sub_generation_inc () 1733sub_generation_inc ()
1537 CODE: 1734 CODE:
1538 PL_sub_generation++; 1735 PL_sub_generation++;
… …
1547 confdir = 3 1744 confdir = 3
1548 localdir = 4 1745 localdir = 4
1549 playerdir = 5 1746 playerdir = 5
1550 datadir = 6 1747 datadir = 6
1551 CODE: 1748 CODE:
1552{ 1749 switch (ix)
1553 int unused_type; 1750 {
1554 RETVAL = (char *)systemDirectory (&unused_type, ix); 1751 case 0: RETVAL = settings.mapdir ; break;
1555} 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 }
1556 OUTPUT: RETVAL 1759 OUTPUT: RETVAL
1557 1760
1558int 1761int
1559cf_find_animation (char *text) 1762cf_find_animation (char *text)
1560 PROTOTYPE: $ 1763 PROTOTYPE: $
1561 1764
1562int random_roll(int min, int max, object *op, int goodbad); 1765int random_roll(int min, int max, object *op, int goodbad);
1563 1766
1564const char *cost_string_from_value(uint64 cost, int approx = 0) 1767const char *cost_string_from_value(uint64 cost, int approx = 0)
1565 1768
1566int invoke (int event, SV *arg1, ...) 1769int invoke (int event, ...)
1567 CODE: 1770 CODE:
1568{ 1771 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1569 // parse first arg and call invoke_object etc as seen fit 1772 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1570 //TODO 1773 for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1571 //cfperl_invoke (event, 1774 RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1572} 1775 OUTPUT: RETVAL
1573 1776
1574int 1777int
1575exp_to_level (val64 exp) 1778exp_to_level (val64 exp)
1576 CODE: 1779 CODE:
1577{ 1780{
… …
1608 RETVAL = newSVpv (resist_plus[atnr], 0); 1811 RETVAL = newSVpv (resist_plus[atnr], 0);
1609 else 1812 else
1610 XSRETURN_UNDEF; 1813 XSRETURN_UNDEF;
1611 OUTPUT: RETVAL 1814 OUTPUT: RETVAL
1612 1815
1816int
1817_valid (SV *obj)
1818 CODE:
1819 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1820 OUTPUT:
1821 RETVAL
1822
1613MODULE = 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
1614 1855
1615SV * 1856SV *
1616get_property (object *obj, int type, int idx) 1857get_property (object *obj, int type, int idx)
1617 CODE: 1858 CODE:
1618 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx)); 1859 RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));
… …
1697 1938
1698int need_identify (const object *obj); 1939int need_identify (const object *obj);
1699 1940
1700int apply_shop_mat (object *shop_mat, object *op); 1941int apply_shop_mat (object *shop_mat, object *op);
1701 1942
1702void 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
1703 1948
1704void cf_object_apply (object *op, object *author, int flags = 0) 1949void cf_object_apply (object *op, object *author, int flags = 0)
1705 1950
1706void cf_object_apply_below (object *op) 1951void cf_object_apply_below (object *op)
1707 1952
… …
1748int cf_object_out_of_map (object *op, int x, int y) 1993int cf_object_out_of_map (object *op, int x, int y)
1749 1994
1750void cf_object_drop (object *op, object *author) 1995void cf_object_drop (object *op, object *author)
1751 1996
1752void cf_object_take (object *op, object *author) 1997void cf_object_take (object *op, object *author)
1753
1754void cf_object_say (object *op, char *msg)
1755
1756void cf_object_speak (object *op, char *msg)
1757 1998
1758object *cf_object_insert_object (object *op, object *container) 1999object *cf_object_insert_object (object *op, object *container)
1759 2000
1760const char *cf_object_get_msg (object *ob) 2001const char *cf_object_get_msg (object *ob)
1761 ALIAS: msg = 0 2002 ALIAS: msg = 0
… …
1815 CODE: 2056 CODE:
1816{ 2057{
1817 int unused_type; 2058 int unused_type;
1818 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);
1819} 2060}
1820
1821SV *registry (object *op)
1822 CODE:
1823 RETVAL = registry_of (op);
1824 OUTPUT:
1825 RETVAL
1826 2061
1827# syntatic sugar for easier use in event callbacks. 2062# syntatic sugar for easier use in event callbacks.
1828const char *options (object *op) 2063const char *options (object *op)
1829 CODE: 2064 CODE:
1830 RETVAL = op->name; 2065 RETVAL = op->name;
… …
1903 2138
1904void kill_player (object *op) 2139void kill_player (object *op)
1905 2140
1906MODULE = cf PACKAGE = cf::player PREFIX = cf_player_ 2141MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1907 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
1908SV *registry (player *pl) 2151SV *registry (player *pl)
1909 CODE: 2152 CODE:
1910 RETVAL = registry_of (pl); 2153 RETVAL = registry_of (pl);
1911 OUTPUT: 2154 OUTPUT:
1912 RETVAL 2155 RETVAL
… …
2036 OUTPUT: RETVAL 2279 OUTPUT: RETVAL
2037 2280
2038 2281
2039MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2282MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2040 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
2041SV *registry (mapstruct *map) 2304SV *registry (mapstruct *map)
2042 CODE: 2305 CODE:
2043 RETVAL = registry_of (map); 2306 RETVAL = registry_of (map);
2044 OUTPUT: 2307 OUTPUT:
2045 RETVAL 2308 RETVAL
… …
2064 2327
2065mapstruct *new (int width, int height) 2328mapstruct *new (int width, int height)
2066 PROTOTYPE: 2329 PROTOTYPE:
2067 CODE: 2330 CODE:
2068{ 2331{
2069 int unused_type; 2332 RETVAL = get_empty_map (width, height);
2070 RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
2071} 2333}
2072 OUTPUT: 2334 OUTPUT:
2073 RETVAL 2335 RETVAL
2074 2336
2075void delete_map (mapstruct *map) 2337void delete_map (mapstruct *map)
… …
2090 XSRETURN_UNDEF; 2352 XSRETURN_UNDEF;
2091 RETVAL = map->tile_path [dir]; 2353 RETVAL = map->tile_path [dir];
2092 OUTPUT: 2354 OUTPUT:
2093 RETVAL 2355 RETVAL
2094 2356
2095mapstruct *cf_map_get_map (char *name) 2357mapstruct *ready_map_name (char *name, int flags = 0)
2096 PROTOTYPE: $ 2358 PROTOTYPE: $;$
2097 ALIAS: map = 0 2359 ALIAS:
2360 find = 0
2361 get_map = 1
2098 2362
2099mapstruct *has_been_loaded (char *name) 2363mapstruct *has_been_loaded (char *name)
2100 PROTOTYPE: $ 2364 PROTOTYPE: $
2101
2102mapstruct *cf_map_get_first ()
2103 PROTOTYPE:
2104 ALIAS: first = 0
2105 2365
2106# whoever "designed" the plug-in api should have wasted 2366# whoever "designed" the plug-in api should have wasted
2107# his/her time with staying away from the project - would have 2367# his/her time with staying away from the project - would have
2108# saved others a lot of time, without doubt. 2368# saved others a lot of time, without doubt.
2109void set_path (mapstruct *where, char *path) 2369void set_path (mapstruct *where, char *path)
… …
2124 2384
2125void set_unique (mapstruct *map, bool unique) 2385void set_unique (mapstruct *map, bool unique)
2126 CODE: 2386 CODE:
2127 map->unique = unique; 2387 map->unique = unique;
2128 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
2129object *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)
2130 2403
2131object *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)
2132 2405
2133object* 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)
… …
2137cf_map_normalise (mapstruct *map, int x, int y) 2410cf_map_normalise (mapstruct *map, int x, int y)
2138 PPCODE: 2411 PPCODE:
2139{ 2412{
2140 mapstruct *nmap = 0; 2413 mapstruct *nmap = 0;
2141 I16 nx = 0, ny = 0; 2414 I16 nx = 0, ny = 0;
2142 int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2415 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2143 2416
2144 EXTEND (SP, 4); 2417 EXTEND (SP, 4);
2145 PUSHs (sv_2mortal (newSViv (flags))); 2418 PUSHs (sv_2mortal (newSViv (flags)));
2146 2419
2147 if (GIMME_V == G_ARRAY) 2420 if (GIMME_V == G_ARRAY)
… …
2159{ 2432{
2160 object *o; 2433 object *o;
2161 mapstruct *nmap = 0; 2434 mapstruct *nmap = 0;
2162 I16 nx, ny; 2435 I16 nx, ny;
2163 2436
2164 cf_map_get_flags (map, &nmap, x, y, &nx, &ny); 2437 get_map_flags (map, &nmap, x, y, &nx, &ny);
2165 2438
2166 if (nmap) 2439 if (nmap)
2167 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)
2168 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o))); 2441 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2169} 2442}
… …
2194 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;
2195 } 2468 }
2196 OUTPUT: 2469 OUTPUT:
2197 RETVAL 2470 RETVAL
2198 2471
2199# "deserialise" perl map data into the map # TODO# compatibility cruft, remove
2200void
2201_set_obs (mapstruct *map, SV *sv)
2202 CODE:
2203{
2204 object *o;
2205 AV *av;
2206 int x, y;
2207 AV *obs = (AV *)SvRV (sv);
2208 2472
2209 for (y = 0; y < MAP_HEIGHT (map); y++) 2473MODULE = cf PACKAGE = cf::arch
2210 for (x = 0; x < MAP_WIDTH (map); x++)
2211 {
2212 sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);
2213 2474
2214 if (!SvROK (sv)) 2475archetype *find (const char *name)
2215 continue; 2476 CODE:
2477 RETVAL = find_archetype (name);
2478 OUTPUT:
2479 RETVAL
2216 2480
2217 av = (AV *)SvRV (sv); 2481archetype *first()
2218
2219 for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2220 {
2221 sv = av_shift (av);
2222
2223 if (SvROK (sv))
2224 {
2225 sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2226 SVptr_cache_set (o, sv);
2227 }
2228 }
2229 }
2230}
2231
2232
2233MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_
2234
2235archetype *cf_archetype_get_first()
2236 PROTOTYPE: 2482 PROTOTYPE:
2237 ALIAS: first = 0 2483 CODE:
2484 RETVAL = first_archetype;
2485 OUTPUT: RETVAL
2238 2486
2239archetype *cf_archetype_get_next (archetype *arch) 2487archetype *next (archetype *arch)
2240 ALIAS: next = 0 2488 CODE:
2489 RETVAL = arch->next;
2490 OUTPUT: RETVAL
2241 2491
2242archetype *cf_archetype_get_head (archetype *arch) 2492archetype *head (archetype *arch)
2243 ALIAS: head = 0 2493 CODE:
2494 RETVAL = arch->head;
2495 OUTPUT: RETVAL
2244 2496
2245archetype *cf_archetype_get_more (archetype *arch) 2497archetype *more (archetype *arch)
2246 ALIAS: more = 0 2498 CODE:
2499 RETVAL = arch->more;
2500 OUTPUT: RETVAL
2247 2501
2248const char *cf_archetype_get_name (archetype *arch) 2502const char *name (archetype *arch)
2249 ALIAS: name = 0 2503 CODE:
2504 RETVAL = arch->name;
2505 OUTPUT: RETVAL
2250 2506
2251object *cf_archetype_get_clone (archetype *arch) 2507object *clone (archetype *arch)
2252 ALIAS: clone = 0 2508 CODE:
2509 RETVAL = &arch->clone;
2510 OUTPUT: RETVAL
2253 2511
2254MODULE = cf PACKAGE = cf::party PREFIX = cf_party_ 2512MODULE = cf PACKAGE = cf::party
2255 2513
2256partylist *cf_party_get_first () 2514partylist *first ()
2257 PROTOTYPE: 2515 PROTOTYPE:
2258 ALIAS: first = 0 2516 CODE:
2517 RETVAL = get_firstparty ();
2518 OUTPUT: RETVAL
2259 2519
2260partylist *cf_party_get_next (partylist *party) 2520partylist *next (partylist *party)
2261 ALIAS: next = 0 2521 CODE:
2522 RETVAL = party->next;
2523 OUTPUT: RETVAL
2262 2524
2263const char *cf_party_get_name (partylist *party) 2525const char *name (partylist *party)
2526 CODE:
2527 RETVAL = party->partyname;
2528 OUTPUT: RETVAL
2264 2529
2265const char *cf_party_get_password (partylist *party) 2530const char *password (partylist *party)
2266 ALIAS: password = 0 2531 CODE:
2532 RETVAL = party->passwd;
2533 OUTPUT: RETVAL
2267 2534
2268player *cf_party_get_first_player (partylist *party) 2535MODULE = cf PACKAGE = cf::region
2269 ALIAS: first_player = 0
2270 2536
2271player *cf_party_get_next_player (partylist *party, player *op) 2537region *first ()
2272 ALIAS: next_player = 0
2273
2274
2275MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2276
2277region *cf_region_get_first ()
2278 PROTOTYPE: 2538 PROTOTYPE:
2279 ALIAS: first = 0 2539 CODE:
2540 RETVAL = first_region;
2541 OUTPUT: RETVAL
2280 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
2281const char *cf_region_get_name (region *reg) 2558const char *longname (region *reg)
2282 ALIAS: name = 0 2559 CODE:
2560 RETVAL = reg->longname;
2561 OUTPUT: RETVAL
2283 2562
2284region *cf_region_get_next (region *reg) 2563const char *msg (region *reg)
2285 ALIAS: next = 0 2564 CODE:
2565 RETVAL = reg->msg;
2566 OUTPUT: RETVAL
2286 2567
2287region *cf_region_get_parent (region *reg) 2568MODULE = cf PACKAGE = cf::living
2288 ALIAS: parent = 0
2289
2290const char *cf_region_get_longname (region *reg)
2291 ALIAS: longname = 0
2292
2293const char *cf_region_get_message (region *reg)
2294 ALIAS: message = 0
2295
2296
2297MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2298 2569
2299val64 2570val64
2300exp (living *liv, val64 new_val = 0) 2571exp (living *liv, val64 new_val = 0)
2301 PROTOTYPE: $;$ 2572 PROTOTYPE: $;$
2302 ALIAS: 2573 ALIAS:

Diff Legend

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